berkus
/
topola
mirror of https://codeberg.org/topola/topola.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

autorouter,board: use both band uids and band termsegs

This commit is contained in:
Mikolaj Wielgus 2024-07-24 01:53:06 +02:00
parent f7126dfa33
commit 3bf4d2cdb1
11 changed files with 86 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/autorouter/autoroute.rs
View File

@ -56,18 +56,25 @@ impl Autoroute {
let (source, target) = autorouter.ratline_endpoints(curr_ratline);
let band = {
let band_last_seg = {
let mut router = Router::new(autorouter.board.layout_mut());
let RouterStatus::Finished(band) = route.step(&mut router)? else {
let RouterStatus::Finished(band_last_seg) = route.step(&mut router)? else {
return Ok(AutorouterStatus::Running);
};
band
band_last_seg
};
let band = autorouter
.board
.layout()
.drawing()
.collect()
.loose_band_uid(band_last_seg.into());
autorouter
.ratsnest
.assign_band_to_ratline(self.curr_ratline.unwrap(), band);
.assign_band_termseg_to_ratline(self.curr_ratline.unwrap(), band_last_seg);
autorouter
.board

2
src/autorouter/autorouter.rs
View File

@ -70,7 +70,7 @@ impl<M: AccessMesadata> Autorouter<M> {
.graph()
.edge_weight(*ratline)
.unwrap()
.band
.band_termseg
.unwrap();
self.board.layout_mut().remove_band(band);
}

10
src/autorouter/ratsnest.rs
View File

@ -12,7 +12,7 @@ use spade::{HasPosition, InsertionError, Point2};
use crate::{
drawing::{
band::BandTerminatingSegIndex,
band::BandTermsegIndex,
dot::FixedDotIndex,
graph::{GetMaybeNet, MakePrimitive, PrimitiveIndex},
primitive::MakePrimitiveShape,
@ -64,7 +64,7 @@ impl HasPosition for RatvertexWeight {
#[derive(Debug, Default, Clone, Copy)]
pub struct RatlineWeight {
pub band: Option<BandTerminatingSegIndex>,
pub band_termseg: Option<BandTermsegIndex>,
}
pub struct Ratsnest {
@ -165,12 +165,12 @@ impl Ratsnest {
Ok(this)
}
pub fn assign_band_to_ratline(
pub fn assign_band_termseg_to_ratline(
&mut self,
ratline: EdgeIndex<usize>,
band: BandTerminatingSegIndex,
termseg: BandTermsegIndex,
) {
self.graph.edge_weight_mut(ratline).unwrap().band = Some(band);
self.graph.edge_weight_mut(ratline).unwrap().band_termseg = Some(termseg);
}
pub fn graph(&self) -> &UnGraph<RatvertexWeight, RatlineWeight, usize> {

43
src/board/board.rs
View File

@ -1,9 +1,11 @@
use std::collections::HashMap;
use std::{cmp::Ordering, collections::HashMap};
use bimap::BiHashMap;
use crate::{
board::mesadata::AccessMesadata,
drawing::{
band::BandTerminatingSegIndex,
band::{BandTermsegIndex, BandUid},
dot::{FixedDotIndex, FixedDotWeight},
graph::{GetLayer, GetMaybeNet},
seg::{FixedSegIndex, FixedSegWeight},
@ -17,11 +19,24 @@ use crate::{
math::Circle,
};
#[derive(Debug, Hash, Clone, PartialEq, Eq)]
pub struct BandName(String, String);
impl BandName {
pub fn new(pinname1: String, pinname2: String) -> Self {
if pinname1.cmp(&pinname2) == Ordering::Greater {
BandName(pinname2, pinname1)
} else {
BandName(pinname1, pinname2)
}
}
}
#[derive(Debug)]
pub struct Board<M: AccessMesadata> {
layout: Layout<M>,
node_to_pinname: HashMap<NodeIndex, String>,
pinname_pair_to_band: HashMap<(String, String), BandTerminatingSegIndex>,
band_bandname: BiHashMap<BandUid, BandName>,
}
impl<M: AccessMesadata> Board<M> {
@ -29,7 +44,7 @@ impl<M: AccessMesadata> Board<M> {
Self {
layout,
node_to_pinname: HashMap::new(),
pinname_pair_to_band: HashMap::new(),
band_bandname: BiHashMap::new(),
}
}
@ -140,7 +155,7 @@ impl<M: AccessMesadata> Board<M> {
&mut self,
source: FixedDotIndex,
target: FixedDotIndex,
band: BandTerminatingSegIndex,
band: BandUid,
) {
let source_pinname = self
.node_pinname(GenericNode::Primitive(source.into()))
@ -150,23 +165,19 @@ impl<M: AccessMesadata> Board<M> {
.node_pinname(GenericNode::Primitive(target.into()))
.unwrap()
.to_string();
self.pinname_pair_to_band
.insert((source_pinname, target_pinname), band);
self.band_bandname
.insert(band, BandName::new(source_pinname, target_pinname));
}
pub fn band_between_pins(
&self,
pinname1: &str,
pinname2: &str,
) -> Option<BandTerminatingSegIndex> {
pub fn band_between_pins(&self, pinname1: &str, pinname2: &str) -> Option<BandUid> {
if let Some(band) = self
.pinname_pair_to_band
.get(&(pinname1.to_string(), pinname2.to_string()))
.band_bandname
.get_by_right(&BandName::new(pinname1.to_string(), pinname2.to_string()))
{
Some(*band)
} else if let Some(band) = self
.pinname_pair_to_band
.get(&(pinname2.to_string(), pinname1.to_string()))
.band_bandname
.get_by_right(&BandName::new(pinname2.to_string(), pinname1.to_string()))
{
Some(*band)
} else {

28
src/drawing/band.rs
View File

@ -16,10 +16,10 @@ use super::{
};
#[derive(Debug, Hash, Clone, Copy)]
pub struct BandUid(BandTerminatingSegIndex, BandTerminatingSegIndex);
pub struct BandUid(BandTermsegIndex, BandTermsegIndex);
impl BandUid {
pub fn new(first_seg1: BandTerminatingSegIndex, first_seg2: BandTerminatingSegIndex) -> Self {
pub fn new(first_seg1: BandTermsegIndex, first_seg2: BandTermsegIndex) -> Self {
if first_seg1.petgraph_index() <= first_seg2.petgraph_index() {
BandUid(first_seg1, first_seg2)
} else {
@ -39,13 +39,22 @@ impl Eq for BandUid {}
#[enum_dispatch(GetPetgraphIndex)]
#[derive(Debug, Hash, Clone, Copy)]
pub enum BandTerminatingSegIndex {
pub enum BandTermsegIndex {
Straight(LoneLooseSegIndex),
Bended(SeqLooseSegIndex),
}
impl From<BandTermsegIndex> for LooseIndex {
fn from(terminating_seg: BandTermsegIndex) -> Self {
match terminating_seg {
BandTermsegIndex::Straight(seg) => LooseIndex::LoneSeg(seg),
BandTermsegIndex::Bended(seg) => LooseIndex::SeqSeg(seg),
}
}
}
impl<'a, CW: Copy, R: AccessRules> MakeRef<'a, BandRef<'a, CW, R>, Drawing<CW, R>>
for BandTerminatingSegIndex
for BandTermsegIndex
{
fn ref_(&self, drawing: &'a Drawing<CW, R>) -> BandRef<'a, CW, R> {
BandRef::new(*self, drawing)
@ -53,15 +62,12 @@ impl<'a, CW: Copy, R: AccessRules> MakeRef<'a, BandRef<'a, CW, R>, Drawing<CW, R
}
pub struct BandRef<'a, CW: Copy, R: AccessRules> {
first_seg: BandTerminatingSegIndex,
first_seg: BandTermsegIndex,
drawing: &'a Drawing<CW, R>,
}
impl<'a, CW: Copy, R: AccessRules> BandRef<'a, CW, R> {
pub fn new(
first_seg: BandTerminatingSegIndex,
drawing: &'a Drawing<CW, R>,
) -> BandRef<'a, CW, R> {
pub fn new(first_seg: BandTermsegIndex, drawing: &'a Drawing<CW, R>) -> BandRef<'a, CW, R> {
Self { first_seg, drawing }
}
}
@ -69,10 +75,10 @@ impl<'a, CW: Copy, R: AccessRules> BandRef<'a, CW, R> {
impl<'a, CW: Copy, R: AccessRules> MeasureLength for BandRef<'a, CW, R> {
fn length(&self) -> f64 {
match self.first_seg {
BandTerminatingSegIndex::Straight(seg) => {
BandTermsegIndex::Straight(seg) => {
self.drawing.geometry().seg_shape(seg.into()).length()
}
BandTerminatingSegIndex::Bended(first_loose_seg) => {
BandTermsegIndex::Bended(first_loose_seg) => {
let mut maybe_loose: Option<LooseIndex> = Some(first_loose_seg.into());
let mut prev = None;
let mut length = 0.0;

14
src/drawing/collect.rs
View File

@ -1,7 +1,7 @@
use crate::graph::{GenericIndex, GetPetgraphIndex};
use super::{
band::{BandTerminatingSegIndex, BandUid},
band::{BandTermsegIndex, BandUid},
bend::LooseBendIndex,
graph::PrimitiveIndex,
loose::{GetPrevNextLoose, LooseIndex},
@ -28,9 +28,9 @@ impl<'a, CW: Copy, R: AccessRules> Collect<'a, CW, R> {
)
}
fn loose_band_first_seg(&self, start_loose: LooseIndex) -> BandTerminatingSegIndex {
fn loose_band_first_seg(&self, start_loose: LooseIndex) -> BandTermsegIndex {
if let LooseIndex::LoneSeg(seg) = start_loose {
return BandTerminatingSegIndex::Straight(seg);
return BandTermsegIndex::Straight(seg);
}
let mut loose = start_loose;
@ -41,14 +41,14 @@ impl<'a, CW: Copy, R: AccessRules> Collect<'a, CW, R> {
prev = Some(loose);
loose = next_loose;
} else {
return BandTerminatingSegIndex::Bended(GenericIndex::new(loose.petgraph_index()));
return BandTermsegIndex::Bended(GenericIndex::new(loose.petgraph_index()));
}
}
}
fn loose_band_last_seg(&self, start_loose: LooseIndex) -> BandTerminatingSegIndex {
fn loose_band_last_seg(&self, start_loose: LooseIndex) -> BandTermsegIndex {
if let LooseIndex::LoneSeg(seg) = start_loose {
return BandTerminatingSegIndex::Straight(seg);
return BandTermsegIndex::Straight(seg);
}
let mut loose = start_loose;
@ -59,7 +59,7 @@ impl<'a, CW: Copy, R: AccessRules> Collect<'a, CW, R> {
next = Some(loose);
loose = prev_loose;
} else {
return BandTerminatingSegIndex::Bended(GenericIndex::new(loose.petgraph_index()));
return BandTermsegIndex::Bended(GenericIndex::new(loose.petgraph_index()));
}
}
}

8
src/drawing/drawing.rs
View File

@ -6,7 +6,7 @@ use rstar::{RTree, AABB};
use thiserror::Error;
use crate::drawing::{
band::BandTerminatingSegIndex,
band::BandTermsegIndex,
bend::{BendIndex, BendWeight, FixedBendIndex, LooseBendIndex, LooseBendWeight},
cane::Cane,
collect::Collect,
@ -88,12 +88,12 @@ impl<CW: Copy, R: AccessRules> Drawing<CW, R> {
}
}
pub fn remove_band(&mut self, band: BandTerminatingSegIndex) {
pub fn remove_band(&mut self, band: BandTermsegIndex) {
match band {
BandTerminatingSegIndex::Straight(seg) => {
BandTermsegIndex::Straight(seg) => {
self.geometry_with_rtree.remove_seg(seg.into());
}
BandTerminatingSegIndex::Bended(first_loose_seg) => {
BandTermsegIndex::Bended(first_loose_seg) => {
let mut dots = vec![];
let mut segs = vec![];
let mut bends = vec![];

4
src/layout/layout.rs
View File

@ -5,7 +5,7 @@ use rstar::AABB;
use crate::{
drawing::{
band::BandTerminatingSegIndex,
band::BandTermsegIndex,
bend::LooseBendWeight,
cane::Cane,
dot::{DotIndex, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight},
@ -204,7 +204,7 @@ impl<R: AccessRules> Layout<R> {
)
}
pub fn remove_band(&mut self, band: BandTerminatingSegIndex) {
pub fn remove_band(&mut self, band: BandTermsegIndex) {
self.drawing.remove_band(band);
}

10
src/router/draw.rs
View File

@ -4,7 +4,7 @@ use thiserror::Error;
use crate::{
drawing::{
band::BandTerminatingSegIndex,
band::BandTermsegIndex,
bend::{BendIndex, LooseBendWeight},
dot::{DotIndex, FixedDotIndex, LooseDotIndex, LooseDotWeight},
graph::{GetLayer, GetMaybeNet, MakePrimitive},
@ -51,7 +51,7 @@ impl<'a, R: AccessRules> Draw<'a, R> {
head: Head,
into: FixedDotIndex,
width: f64,
) -> Result<BandTerminatingSegIndex, DrawException> {
) -> Result<BandTermsegIndex, DrawException> {
let tangent = self
.guide()
.head_into_dot_segment(&head, into, width)
@ -62,8 +62,8 @@ impl<'a, R: AccessRules> Draw<'a, R> {
let layer = head.face().primitive(self.layout.drawing()).layer();
let maybe_net = head.face().primitive(self.layout.drawing()).maybe_net();
Ok::<BandTerminatingSegIndex, DrawException>(match head.face() {
DotIndex::Fixed(dot) => BandTerminatingSegIndex::Straight(
Ok::<BandTermsegIndex, DrawException>(match head.face() {
DotIndex::Fixed(dot) => BandTermsegIndex::Straight(
self.layout
.add_lone_loose_seg(
dot,
@ -76,7 +76,7 @@ impl<'a, R: AccessRules> Draw<'a, R> {
)
.map_err(|err| DrawException::CannotFinishIn(into, err.into()))?,
),
DotIndex::Loose(dot) => BandTerminatingSegIndex::Bended(
DotIndex::Loose(dot) => BandTermsegIndex::Bended(
self.layout
.add_seq_loose_seg(
into.into(),

10
src/router/router.rs
View File

@ -4,7 +4,7 @@ use thiserror::Error;
use crate::{
drawing::{
band::BandTerminatingSegIndex,
band::BandTermsegIndex,
dot::{DotIndex, FixedDotIndex},
graph::{MakePrimitive, PrimitiveIndex},
head::GetFace,
@ -39,7 +39,7 @@ pub enum RouterError {
#[derive(Debug)]
pub enum RouterStatus {
Running,
Finished(BandTerminatingSegIndex),
Finished(BandTermsegIndex),
}
#[derive(Debug)]
@ -78,7 +78,7 @@ impl<'a, R: AccessRules> RouterAstarStrategy<'a, R> {
}
}
impl<'a, R: AccessRules> AstarStrategy<Navmesh, f64, BandTerminatingSegIndex>
impl<'a, R: AccessRules> AstarStrategy<Navmesh, f64, BandTermsegIndex>
for RouterAstarStrategy<'a, R>
{
fn is_goal(
@ -86,7 +86,7 @@ impl<'a, R: AccessRules> AstarStrategy<Navmesh, f64, BandTerminatingSegIndex>
navmesh: &Navmesh,
vertex: NavvertexIndex,
tracker: &PathTracker<Navmesh>,
) -> Option<BandTerminatingSegIndex> {
) -> Option<BandTermsegIndex> {
let new_path = tracker.reconstruct_path_to(vertex);
let width = self.trace.width;
@ -176,7 +176,7 @@ impl<'a, R: AccessRules> Router<'a, R> {
from: FixedDotIndex,
to: FixedDotIndex,
width: f64,
) -> Result<BandTerminatingSegIndex, RouterError> {
) -> Result<BandTermsegIndex, RouterError> {
let mut route = self.route_walk(from, to, width)?;
loop {

4
src/router/tracer.rs
View File

@ -2,7 +2,7 @@ use contracts::{debug_ensures, debug_requires};
use thiserror::Error;
use crate::{
drawing::{band::BandTerminatingSegIndex, dot::FixedDotIndex, rules::AccessRules},
drawing::{band::BandTermsegIndex, dot::FixedDotIndex, rules::AccessRules},
layout::Layout,
router::{
draw::{Draw, DrawException},
@ -44,7 +44,7 @@ impl<'a, R: AccessRules> Tracer<'a, R> {
trace: &mut Trace,
target: FixedDotIndex,
width: f64,
) -> Result<BandTerminatingSegIndex, TracerException> {
) -> Result<BandTermsegIndex, TracerException> {
Ok(Draw::new(self.layout).finish_in_dot(trace.head, target, width)?)
}