autorouter,board: use both band uids and band termsegs

src/autorouter/autoroute.rs

@@ -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

src/autorouter/autorouter.rs

@@ -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);
         }

src/autorouter/ratsnest.rs

@@ -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> {

src/board/board.rs

@@ -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
+        self.band_bandname
-            .insert((source_pinname, target_pinname), band);
+            .insert(band, BandName::new(source_pinname, target_pinname));
     }
 
-    pub fn band_between_pins(
+    pub fn band_between_pins(&self, pinname1: &str, pinname2: &str) -> Option<BandUid> {
-        &self,
-        pinname1: &str,
-        pinname2: &str,
-    ) -> Option<BandTerminatingSegIndex> {
         if let Some(band) = self
-            .pinname_pair_to_band
+            .band_bandname
-            .get(&(pinname1.to_string(), pinname2.to_string()))
+            .get_by_right(&BandName::new(pinname1.to_string(), pinname2.to_string()))
         {
             Some(*band)
         } else if let Some(band) = self
-            .pinname_pair_to_band
+            .band_bandname
-            .get(&(pinname2.to_string(), pinname1.to_string()))
+            .get_by_right(&BandName::new(pinname2.to_string(), pinname1.to_string()))
         {
             Some(*band)
         } else {

src/drawing/band.rs

@@ -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(
+    pub fn new(first_seg: BandTermsegIndex, drawing: &'a Drawing<CW, R>) -> BandRef<'a, CW, R> {
-        first_seg: BandTerminatingSegIndex,
-        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;

src/drawing/collect.rs

@@ -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()));
             }
         }
     }

src/drawing/drawing.rs

@@ -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![];

src/layout/layout.rs

@@ -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);
     }
 

src/router/draw.rs

@@ -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() {
+        Ok::<BandTermsegIndex, DrawException>(match head.face() {
-            DotIndex::Fixed(dot) => BandTerminatingSegIndex::Straight(
+            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(),

src/router/router.rs

@@ -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 {

src/router/tracer.rs

@@ -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)?)
     }