From d4a310a5c08c8a770b9b062b7246d7db922a78f8 Mon Sep 17 00:00:00 2001 From: Mikolaj Wielgus Date: Tue, 18 Jun 2024 14:33:35 +0200 Subject: [PATCH] graph: disambiguate naming of different kinds of indices Disambiguate between node indices and (teir inner) petgraph indices. Rename "band index" to "band first seg index", as we identify bands by teir first segs. Rename "trianvertex index" and "navvertex index" respectively to "trianvertex node index" and "navvertex node index", as these point to nodes on the geometry graph and only indirectly to vertices on the vertex graph. --- src/autorouter/autorouter.rs | 10 +-- src/autorouter/ratsnest.rs | 28 +++---- src/autorouter/selection.rs | 4 +- src/bin/topola-egui/app.rs | 4 +- src/bin/topola-egui/overlay.rs | 8 +- src/bin/topola-sdl2-demo/main.rs | 4 +- src/board/board.rs | 12 ++- src/drawing/band.rs | 2 +- src/drawing/bend.rs | 4 +- src/drawing/dot.rs | 4 +- src/drawing/drawing.rs | 14 ++-- src/drawing/graph.rs | 4 +- src/drawing/loose.rs | 12 +-- src/drawing/primitive.rs | 62 +++++++------- src/drawing/seg.rs | 4 +- src/drawing/wraparoundable.rs | 8 +- src/geometry/compound.rs | 4 +- src/geometry/geometry.rs | 133 ++++++++++++++++++------------- src/geometry/with_rtree.rs | 34 ++++---- src/graph.rs | 8 +- src/layout/layout.rs | 24 +++--- src/layout/via.rs | 4 +- src/layout/zone.rs | 8 +- src/router/draw.rs | 10 +-- src/router/navmesh.rs | 94 +++++++++++----------- src/router/router.rs | 16 ++-- src/router/tracer.rs | 22 ++--- src/specctra/design.rs | 2 +- src/triangulation.rs | 64 +++++++-------- tests/common/mod.rs | 8 +- 30 files changed, 318 insertions(+), 297 deletions(-) diff --git a/src/autorouter/autorouter.rs b/src/autorouter/autorouter.rs index f5f66ea..dfa7531 100644 --- a/src/autorouter/autorouter.rs +++ b/src/autorouter/autorouter.rs @@ -13,7 +13,7 @@ use crate::{ drawing::{dot::FixedDotIndex, Infringement}, layout::via::ViaWeight, router::{navmesh::NavmeshError, RouterError}, - triangulation::GetTrianvertexIndex, + triangulation::GetTrianvertexNodeIndex, }; #[derive(Error, Debug, Clone)] @@ -100,7 +100,7 @@ impl Autorouter { .graph() .node_weight(source) .unwrap() - .trianvertex_index() + .node_index() { RatvertexIndex::FixedDot(dot) => dot, RatvertexIndex::Zone(zone) => self.board.zone_apex(zone), @@ -111,7 +111,7 @@ impl Autorouter { .graph() .node_weight(target) .unwrap() - .trianvertex_index() + .node_index() { RatvertexIndex::FixedDot(dot) => dot, RatvertexIndex::Zone(zone) => self.board.zone_apex(zone), @@ -132,13 +132,13 @@ impl Autorouter { .graph() .node_weight(source) .unwrap() - .trianvertex_index(); + .node_index(); let to_vertex = self .ratsnest .graph() .node_weight(target) .unwrap() - .trianvertex_index(); + .node_index(); selection.contains_node(&self.board, source_vertex.into()) && selection.contains_node(&self.board, to_vertex.into()) diff --git a/src/autorouter/ratsnest.rs b/src/autorouter/ratsnest.rs index b4ace6f..059d1f9 100644 --- a/src/autorouter/ratsnest.rs +++ b/src/autorouter/ratsnest.rs @@ -12,22 +12,22 @@ use spade::{HasPosition, InsertionError, Point2}; use crate::{ drawing::{ - band::BandIndex, + band::BandFirstSegIndex, dot::FixedDotIndex, graph::{GetMaybeNet, MakePrimitive, PrimitiveIndex}, primitive::MakePrimitiveShape, rules::RulesTrait, }, geometry::{compound::CompoundManagerTrait, shape::ShapeTrait}, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, layout::{ zone::{MakePolyShape, ZoneWeight}, Layout, }, - triangulation::{GetTrianvertexIndex, Triangulation}, + triangulation::{GetTrianvertexNodeIndex, Triangulation}, }; -#[enum_dispatch(GetNodeIndex)] +#[enum_dispatch(GetPetgraphIndex)] #[derive(Debug, Clone, Copy, PartialEq)] pub enum RatvertexIndex { FixedDot(FixedDotIndex), @@ -49,8 +49,8 @@ pub struct RatvertexWeight { pub pos: Point, } -impl GetTrianvertexIndex for RatvertexWeight { - fn trianvertex_index(&self) -> RatvertexIndex { +impl GetTrianvertexNodeIndex for RatvertexWeight { + fn node_index(&self) -> RatvertexIndex { self.vertex } } @@ -64,7 +64,7 @@ impl HasPosition for RatvertexWeight { #[derive(Debug, Default, Clone, Copy)] pub struct RatlineWeight { - pub band: Option, + pub band: Option, } pub struct Ratsnest { @@ -154,16 +154,8 @@ impl Ratsnest { this.graph.retain_edges(|g, i| { if let Some((source, target)) = g.edge_endpoints(i) { - let source_index = g - .node_weight(source) - .unwrap() - .trianvertex_index() - .node_index(); - let target_index = g - .node_weight(target) - .unwrap() - .trianvertex_index() - .node_index(); + let source_index = g.node_weight(source).unwrap().node_index().petgraph_index(); + let target_index = g.node_weight(target).unwrap().node_index().petgraph_index(); !unionfind.equiv(source_index, target_index) } else { true @@ -173,7 +165,7 @@ impl Ratsnest { Ok(this) } - pub fn assign_band_to_ratline(&mut self, ratline: EdgeIndex, band: BandIndex) { + pub fn assign_band_to_ratline(&mut self, ratline: EdgeIndex, band: BandFirstSegIndex) { self.graph.edge_weight_mut(ratline).unwrap().band = Some(band); } diff --git a/src/autorouter/selection.rs b/src/autorouter/selection.rs index 9abe479..fdf1c99 100644 --- a/src/autorouter/selection.rs +++ b/src/autorouter/selection.rs @@ -6,7 +6,7 @@ use crate::{ board::{mesadata::MesadataTrait, Board}, drawing::graph::{GetLayer, MakePrimitive}, geometry::compound::CompoundManagerTrait, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, layout::{zone::ZoneWeight, CompoundWeight, NodeIndex}, }; @@ -70,7 +70,7 @@ impl Selection { { board .layout() - .zone(GenericIndex::::new(compound.node_index())) + .zone(GenericIndex::::new(compound.petgraph_index())) .layer() } else { unreachable!() diff --git a/src/bin/topola-egui/app.rs b/src/bin/topola-egui/app.rs index 3661c88..08a80a3 100644 --- a/src/bin/topola-egui/app.rs +++ b/src/bin/topola-egui/app.rs @@ -33,7 +33,7 @@ use topola::{ math::Circle, router::{ draw::DrawException, - navmesh::{Navmesh, NavmeshEdgeReference, NavvertexIndex}, + navmesh::{Navmesh, NavmeshEdgeReference, NavvertexNodeIndex}, tracer::{Trace, Tracer}, }, specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata}, @@ -49,7 +49,7 @@ pub struct SharedData { pub from: Option, pub to: Option, pub navmesh: Option, - pub path: Vec, + pub path: Vec, pub ghosts: Vec, pub highlighteds: Vec, } diff --git a/src/bin/topola-egui/overlay.rs b/src/bin/topola-egui/overlay.rs index e978f12..5db8842 100644 --- a/src/bin/topola-egui/overlay.rs +++ b/src/bin/topola-egui/overlay.rs @@ -15,7 +15,7 @@ use topola::{ compound::CompoundManagerTrait, shape::{Shape, ShapeTrait}, }, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, layout::{ via::ViaWeight, zone::{MakePolyShape, Zone, ZoneWeight}, @@ -80,19 +80,19 @@ impl Overlay { NodeIndex::Compound(compound) => { match board.layout().drawing().compound_weight(compound) { /*CompoundWeight::Zone(zone) => Zone::new( - GenericIndex::::new(compound.node_index()), + GenericIndex::::new(compound.petgraph_index()), board.layout(), ) .shape() .into(),*/ CompoundWeight::Zone(weight) => board .layout() - .zone(GenericIndex::::new(compound.node_index())) + .zone(GenericIndex::::new(compound.petgraph_index())) .shape() .into(), CompoundWeight::Via(weight) => board .layout() - .via(GenericIndex::::new(compound.node_index())) + .via(GenericIndex::::new(compound.petgraph_index())) .shape() .into(), } diff --git a/src/bin/topola-sdl2-demo/main.rs b/src/bin/topola-sdl2-demo/main.rs index a1aac27..d561c67 100644 --- a/src/bin/topola-sdl2-demo/main.rs +++ b/src/bin/topola-sdl2-demo/main.rs @@ -25,7 +25,7 @@ use topola::geometry::shape::ShapeTrait; use topola::layout::zone::MakePolyShape; use topola::layout::Layout; use topola::router::draw::DrawException; -use topola::router::navmesh::{Navmesh, NavmeshEdgeReference, NavvertexIndex}; +use topola::router::navmesh::{Navmesh, NavmeshEdgeReference, NavvertexNodeIndex}; use topola::router::tracer::{Trace, Tracer}; use topola::specctra::design::SpecctraDesign; use topola::specctra::mesadata::SpecctraMesadata; @@ -225,7 +225,7 @@ fn render_times( mut router_or_layout: RouterOrLayout, _unused: Option<()>, mut maybe_navmesh: Option, - path: &[NavvertexIndex], + path: &[NavvertexNodeIndex], ghosts: &[PrimitiveShape], highlighteds: &[PrimitiveIndex], times: i64, diff --git a/src/board/board.rs b/src/board/board.rs index 0b13589..a698470 100644 --- a/src/board/board.rs +++ b/src/board/board.rs @@ -3,7 +3,7 @@ use std::collections::HashMap; use crate::{ board::mesadata::MesadataTrait, drawing::{ - band::BandIndex, + band::BandFirstSegIndex, dot::{FixedDotIndex, FixedDotWeight}, graph::{GetLayer, GetMaybeNet}, seg::{FixedSegIndex, FixedSegWeight}, @@ -22,7 +22,7 @@ use crate::{ pub struct Board { layout: Layout, node_to_pinname: HashMap, - pinname_pair_to_band: HashMap<(String, String), BandIndex>, + pinname_pair_to_band: HashMap<(String, String), BandFirstSegIndex>, } impl Board { @@ -115,7 +115,11 @@ impl Board { zone } - pub fn route_band(&mut self, navmesh: Navmesh, width: f64) -> Result { + pub fn route_band( + &mut self, + navmesh: Navmesh, + width: f64, + ) -> Result { let source_pinname = self .node_pinname(GenericNode::Primitive(navmesh.source().into())) .unwrap() @@ -158,7 +162,7 @@ impl Board { self.node_to_pinname.get(&node) } - pub fn band_between_pins(&self, pinname1: &str, pinname2: &str) -> Option { + pub fn band_between_pins(&self, pinname1: &str, pinname2: &str) -> Option { if let Some(band) = self .pinname_pair_to_band .get(&(pinname1.to_string(), pinname2.to_string())) diff --git a/src/drawing/band.rs b/src/drawing/band.rs index e486a8c..b7d497a 100644 --- a/src/drawing/band.rs +++ b/src/drawing/band.rs @@ -1,7 +1,7 @@ use crate::drawing::seg::{LoneLooseSegIndex, SeqLooseSegIndex}; #[derive(Debug, Hash, Clone, Copy, Eq, PartialEq)] -pub enum BandIndex { +pub enum BandFirstSegIndex { Straight(LoneLooseSegIndex), Bended(SeqLooseSegIndex), } diff --git a/src/drawing/bend.rs b/src/drawing/bend.rs index 9ee4d37..aaad578 100644 --- a/src/drawing/bend.rs +++ b/src/drawing/bend.rs @@ -8,12 +8,12 @@ use crate::{ Drawing, }, geometry::{BendWeightTrait, GetOffset, GetWidth, SetOffset}, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, }; use petgraph::stable_graph::NodeIndex; -#[enum_dispatch(GetNodeIndex, MakePrimitive)] +#[enum_dispatch(GetPetgraphIndex, MakePrimitive)] #[derive(Debug, Clone, Copy, PartialEq)] pub enum BendIndex { Fixed(FixedBendIndex), diff --git a/src/drawing/dot.rs b/src/drawing/dot.rs index 0fb2982..bede8d7 100644 --- a/src/drawing/dot.rs +++ b/src/drawing/dot.rs @@ -11,11 +11,11 @@ use crate::{ Drawing, }, geometry::{DotWeightTrait, GetPos, GetWidth, SetPos}, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, math::Circle, }; -#[enum_dispatch(GetNodeIndex, MakePrimitive)] +#[enum_dispatch(GetPetgraphIndex, MakePrimitive)] #[derive(Debug, Clone, Copy, PartialEq)] pub enum DotIndex { Fixed(FixedDotIndex), diff --git a/src/drawing/drawing.rs b/src/drawing/drawing.rs index b1dbee4..2eccb34 100644 --- a/src/drawing/drawing.rs +++ b/src/drawing/drawing.rs @@ -6,7 +6,7 @@ use rstar::{RTree, AABB}; use thiserror::Error; use crate::drawing::{ - band::BandIndex, + band::BandFirstSegIndex, bend::{BendIndex, BendWeight, FixedBendIndex, LooseBendIndex, LooseBendWeight}, cane::Cane, collect::Collect, @@ -32,7 +32,7 @@ use crate::geometry::{ BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetOffset, GetPos, GetWidth, SegWeightTrait, }; -use crate::graph::{GenericIndex, GetNodeIndex}; +use crate::graph::{GenericIndex, GetPetgraphIndex}; use crate::math::NoTangents; #[enum_dispatch] @@ -85,12 +85,12 @@ impl Drawing { } } - pub fn remove_band(&mut self, band: BandIndex) { + pub fn remove_band(&mut self, band: BandFirstSegIndex) { match band { - BandIndex::Straight(seg) => { + BandFirstSegIndex::Straight(seg) => { self.geometry_with_rtree.remove_seg(seg.into()); } - BandIndex::Bended(first_loose_seg) => { + BandFirstSegIndex::Bended(first_loose_seg) => { let mut dots = vec![]; let mut segs = vec![]; let mut bends = vec![]; @@ -360,7 +360,7 @@ impl Drawing { let core = *self .geometry_with_rtree .graph() - .neighbors(inner.node_index()) + .neighbors(inner.petgraph_index()) .filter(|ni| { matches!( self.geometry_with_rtree @@ -368,7 +368,7 @@ impl Drawing { .edge_weight( self.geometry_with_rtree .graph() - .find_edge(inner.node_index(), *ni) + .find_edge(inner.petgraph_index(), *ni) .unwrap() ) .unwrap(), diff --git a/src/drawing/graph.rs b/src/drawing/graph.rs index 4ea0273..0902a9c 100644 --- a/src/drawing/graph.rs +++ b/src/drawing/graph.rs @@ -2,7 +2,7 @@ use enum_dispatch::enum_dispatch; use petgraph::stable_graph::NodeIndex; -use crate::{drawing::Drawing, graph::GetNodeIndex}; +use crate::{drawing::Drawing, graph::GetPetgraphIndex}; use super::{ bend::{FixedBendIndex, FixedBendWeight, LooseBendIndex, LooseBendWeight}, @@ -85,7 +85,7 @@ macro_rules! impl_loose_weight { // TODO: This enum shouldn't exist: we shouldn't be carrying the tag around like this. Instead we // should be getting it from the graph when it's needed. -#[enum_dispatch(GetNodeIndex, MakePrimitive)] +#[enum_dispatch(GetPetgraphIndex, MakePrimitive)] #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)] pub enum PrimitiveIndex { FixedDot(FixedDotIndex), diff --git a/src/drawing/loose.rs b/src/drawing/loose.rs index e22e6d7..564e88c 100644 --- a/src/drawing/loose.rs +++ b/src/drawing/loose.rs @@ -10,7 +10,7 @@ use crate::{ primitive::{GetJoints, LoneLooseSeg, LooseBend, LooseDot, Primitive, SeqLooseSeg}, seg::{LoneLooseSegIndex, SeqLooseSegIndex}, }, - graph::GetNodeIndex, + graph::GetPetgraphIndex, }; use super::rules::RulesTrait; @@ -20,7 +20,7 @@ pub trait GetNextLoose { fn next_loose(&self, maybe_prev: Option) -> Option; } -#[enum_dispatch(GetNodeIndex, MakePrimitive)] +#[enum_dispatch(GetPetgraphIndex, MakePrimitive)] #[derive(Debug, Clone, Copy, PartialEq)] pub enum LooseIndex { Dot(LooseDotIndex), @@ -40,7 +40,7 @@ impl From for PrimitiveIndex { } } -#[enum_dispatch(GetNextLoose, GetDrawing, GetNodeIndex)] +#[enum_dispatch(GetNextLoose, GetDrawing, GetPetgraphIndex)] pub enum Loose<'a, CW: Copy, R: RulesTrait> { Dot(LooseDot<'a, CW, R>), LoneSeg(LoneLooseSeg<'a, CW, R>), @@ -66,7 +66,7 @@ impl<'a, CW: Copy, R: RulesTrait> GetNextLoose for LooseDot<'a, CW, R> { unreachable!(); }; - if bend.node_index() != prev.node_index() { + if bend.petgraph_index() != prev.petgraph_index() { Some(bend.into()) } else { self.seg().map(Into::into) @@ -87,7 +87,7 @@ impl<'a, CW: Copy, R: RulesTrait> GetNextLoose for SeqLooseSeg<'a, CW, R> { return Some(ends.1.into()); }; - if ends.0.node_index() != prev.node_index() { + if ends.0.petgraph_index() != prev.petgraph_index() { match ends.0 { DotIndex::Fixed(..) => None, DotIndex::Loose(dot) => Some(dot.into()), @@ -105,7 +105,7 @@ impl<'a, CW: Copy, R: RulesTrait> GetNextLoose for LooseBend<'a, CW, R> { unreachable!(); }; - if ends.0.node_index() != prev.node_index() { + if ends.0.petgraph_index() != prev.petgraph_index() { Some(ends.0.into()) } else { Some(ends.1.into()) diff --git a/src/drawing/primitive.rs b/src/drawing/primitive.rs index 48b2e5d..8d0eb66 100644 --- a/src/drawing/primitive.rs +++ b/src/drawing/primitive.rs @@ -15,7 +15,7 @@ use crate::{ Drawing, }, geometry::GenericNode, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, }; #[enum_dispatch] @@ -55,10 +55,12 @@ pub trait GetInterior { fn interior(&self) -> Vec; } -pub trait GetOtherJoint>: GetJoints { +pub trait GetOtherJoint>: + GetJoints +{ fn other_joint(&self, end: F) -> F { let ends = self.joints(); - if ends.0.node_index() != end.node_index() { + if ends.0.petgraph_index() != end.petgraph_index() { ends.0 } else { ends.1.into() @@ -70,12 +72,12 @@ pub trait GetJoints { fn joints(&self) -> (F, T); } -pub trait GetFirstRail<'a, R: RulesTrait>: GetDrawing<'a, R> + GetNodeIndex { +pub trait GetFirstRail<'a, R: RulesTrait>: GetDrawing<'a, R> + GetPetgraphIndex { fn first_rail(&self) -> Option { self.drawing() .geometry() - .first_rail(self.node_index()) - .map(|ni| LooseBendIndex::new(ni.node_index())) + .first_rail(self.petgraph_index()) + .map(|ni| LooseBendIndex::new(ni.petgraph_index())) } } @@ -89,7 +91,7 @@ pub trait GetCore<'a, R: RulesTrait>: GetDrawing<'a, R> + GetBendIndex { self.drawing() .geometry() .core(self.bend_index()) - .node_index(), + .petgraph_index(), ) } } @@ -99,14 +101,14 @@ pub trait GetInnerOuter<'a, R: RulesTrait>: GetDrawing<'a, R> + GetBendIndex { self.drawing() .geometry() .inner(self.bend_index()) - .map(|ni| LooseBendIndex::new(ni.node_index())) + .map(|ni| LooseBendIndex::new(ni.petgraph_index())) } fn outer(&self) -> Option { self.drawing() .geometry() .outer(self.bend_index()) - .map(|ni| LooseBendIndex::new(ni.node_index())) + .map(|ni| LooseBendIndex::new(ni.petgraph_index())) } } @@ -185,7 +187,7 @@ impl<'a, W, CW: Copy, R: RulesTrait> GenericPrimitive<'a, W, CW, R> { .drawing .geometry() .graph() - .node_weight(self.index.node_index()) + .node_weight(self.index.petgraph_index()) .unwrap() { weight @@ -203,7 +205,7 @@ impl<'a, W, CW: Copy, R: RulesTrait> GetInterior for GenericPrimitive<'a, W, CW, R> { fn interior(&self) -> Vec { - vec![self.tagged_weight().retag(self.index.node_index())] + vec![self.tagged_weight().retag(self.index.petgraph_index())] } } @@ -213,9 +215,9 @@ impl<'a, W, CW: Copy, R: RulesTrait> GetDrawing<'a, R> for GenericPrimitive<'a, } } -impl<'a, W, CW: Copy, R: RulesTrait> GetNodeIndex for GenericPrimitive<'a, W, CW, R> { - fn node_index(&self) -> NodeIndex { - self.index.node_index() +impl<'a, W, CW: Copy, R: RulesTrait> GetPetgraphIndex for GenericPrimitive<'a, W, CW, R> { + fn petgraph_index(&self) -> NodeIndex { + self.index.petgraph_index() } } @@ -276,7 +278,7 @@ impl<'a, CW: Copy, R: RulesTrait> LooseDot<'a, CW, R> { self.drawing .geometry() .joined_segs(self.index.into()) - .map(|ni| SeqLooseSegIndex::new(ni.node_index())) + .map(|ni| SeqLooseSegIndex::new(ni.petgraph_index())) .next() } @@ -284,7 +286,7 @@ impl<'a, CW: Copy, R: RulesTrait> LooseDot<'a, CW, R> { self.drawing .geometry() .joined_bends(self.index.into()) - .map(|ni| LooseBendIndex::new(ni.node_index())) + .map(|ni| LooseBendIndex::new(ni.petgraph_index())) .next() .unwrap() } @@ -325,8 +327,8 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints for Fi fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { let (from, to) = self.drawing.geometry().seg_joints(self.index.into()); ( - FixedDotIndex::new(from.node_index()), - FixedDotIndex::new(to.node_index()), + FixedDotIndex::new(from.petgraph_index()), + FixedDotIndex::new(to.petgraph_index()), ) } } @@ -353,8 +355,8 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { let (from, to) = self.drawing.geometry().seg_joints(self.index.into()); ( - FixedDotIndex::new(from.node_index()), - FixedDotIndex::new(to.node_index()), + FixedDotIndex::new(from.petgraph_index()), + FixedDotIndex::new(to.petgraph_index()), ) } } @@ -380,18 +382,18 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints for SeqLoos let joints = self.drawing.geometry().seg_joints(self.index.into()); if let DotWeight::Fixed(..) = self.drawing.geometry().dot_weight(joints.0) { ( - FixedDotIndex::new(joints.0.node_index()).into(), - LooseDotIndex::new(joints.1.node_index()).into(), + FixedDotIndex::new(joints.0.petgraph_index()).into(), + LooseDotIndex::new(joints.1.petgraph_index()).into(), ) } else if let DotWeight::Fixed(..) = self.drawing.geometry().dot_weight(joints.1) { ( - FixedDotIndex::new(joints.1.node_index()).into(), - LooseDotIndex::new(joints.0.node_index()), + FixedDotIndex::new(joints.1.petgraph_index()).into(), + LooseDotIndex::new(joints.0.petgraph_index()), ) } else { ( - LooseDotIndex::new(joints.0.node_index()).into(), - LooseDotIndex::new(joints.1.node_index()).into(), + LooseDotIndex::new(joints.0.petgraph_index()).into(), + LooseDotIndex::new(joints.1.petgraph_index()).into(), ) } } @@ -423,8 +425,8 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints for Fi fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { let (from, to) = self.drawing.geometry().bend_joints(self.index.into()); ( - FixedDotIndex::new(from.node_index()), - FixedDotIndex::new(to.node_index()), + FixedDotIndex::new(from.petgraph_index()), + FixedDotIndex::new(to.petgraph_index()), ) } } @@ -470,8 +472,8 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints for Lo fn joints(&self) -> (LooseDotIndex, LooseDotIndex) { let (from, to) = self.drawing.geometry().bend_joints(self.index.into()); ( - LooseDotIndex::new(from.node_index()), - LooseDotIndex::new(to.node_index()), + LooseDotIndex::new(from.petgraph_index()), + LooseDotIndex::new(to.petgraph_index()), ) } } diff --git a/src/drawing/seg.rs b/src/drawing/seg.rs index 7c72ae2..dcd8640 100644 --- a/src/drawing/seg.rs +++ b/src/drawing/seg.rs @@ -8,12 +8,12 @@ use crate::{ Drawing, }, geometry::{GetWidth, SegWeightTrait}, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, }; use petgraph::stable_graph::NodeIndex; -#[enum_dispatch(GetNodeIndex, MakePrimitive)] +#[enum_dispatch(GetPetgraphIndex, MakePrimitive)] #[derive(Debug, Clone, Copy, PartialEq)] pub enum SegIndex { Fixed(FixedSegIndex), diff --git a/src/drawing/wraparoundable.rs b/src/drawing/wraparoundable.rs index 611751a..6087d21 100644 --- a/src/drawing/wraparoundable.rs +++ b/src/drawing/wraparoundable.rs @@ -10,15 +10,15 @@ use crate::{ rules::RulesTrait, Drawing, }, - graph::GetNodeIndex, + graph::GetPetgraphIndex, }; #[enum_dispatch] -pub trait GetWraparound: GetNodeIndex { +pub trait GetWraparound: GetPetgraphIndex { fn wraparound(&self) -> Option; } -#[enum_dispatch(GetNodeIndex, MakePrimitive)] +#[enum_dispatch(GetPetgraphIndex, MakePrimitive)] #[derive(Debug, Clone, Copy, PartialEq)] pub enum WraparoundableIndex { FixedDot(FixedDotIndex), @@ -45,7 +45,7 @@ impl From for WraparoundableIndex { } } -#[enum_dispatch(GetWraparound, GetDrawing, GetNodeIndex)] +#[enum_dispatch(GetWraparound, GetDrawing, GetPetgraphIndex)] pub enum Wraparoundable<'a, CW: Copy, R: RulesTrait> { FixedDot(FixedDot<'a, CW, R>), FixedBend(FixedBend<'a, CW, R>), diff --git a/src/geometry/compound.rs b/src/geometry/compound.rs index c80873a..0be1fff 100644 --- a/src/geometry/compound.rs +++ b/src/geometry/compound.rs @@ -1,6 +1,6 @@ -use crate::graph::{GenericIndex, GetNodeIndex}; +use crate::graph::{GenericIndex, GetPetgraphIndex}; -pub trait CompoundManagerTrait { +pub trait CompoundManagerTrait { fn add_compound(&mut self, weight: CW) -> GenericIndex; fn remove_compound(&mut self, compound: GenericIndex); fn add_to_compound(&mut self, node: GenericIndex, compound: GenericIndex); diff --git a/src/geometry/geometry.rs b/src/geometry/geometry.rs index 90946d0..97c2ab1 100644 --- a/src/geometry/geometry.rs +++ b/src/geometry/geometry.rs @@ -21,7 +21,7 @@ use crate::{ compound::CompoundManagerTrait, primitive::{BendShape, DotShape, PrimitiveShape, SegShape}, }, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, math::Circle, }; @@ -75,10 +75,10 @@ pub struct Geometry< SW: SegWeightTrait, BW: BendWeightTrait, CW: Copy, - PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PI: GetPetgraphIndex + TryInto + TryInto + TryInto + Copy, + DI: GetPetgraphIndex + Into + Copy, + SI: GetPetgraphIndex + Into + Copy, + BI: GetPetgraphIndex + Into + Copy, > { graph: StableDiGraph, GeometryLabel, usize>, weight_marker: PhantomData, @@ -98,10 +98,10 @@ impl< SW: SegWeightTrait, BW: BendWeightTrait, CW: Copy, - PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PI: GetPetgraphIndex + TryInto + TryInto + TryInto + Copy, + DI: GetPetgraphIndex + Into + Copy, + SI: GetPetgraphIndex + Into + Copy, + BI: GetPetgraphIndex + Into + Copy, > Geometry { pub fn new() -> Self { @@ -132,10 +132,16 @@ impl< let seg = GenericIndex::::new(self.graph.add_node(GenericNode::Primitive(weight.into()))); - self.graph - .update_edge(from.node_index(), seg.node_index(), GeometryLabel::Joined); - self.graph - .update_edge(seg.node_index(), to.node_index(), GeometryLabel::Joined); + self.graph.update_edge( + from.petgraph_index(), + seg.petgraph_index(), + GeometryLabel::Joined, + ); + self.graph.update_edge( + seg.petgraph_index(), + to.petgraph_index(), + GeometryLabel::Joined, + ); seg } @@ -150,31 +156,40 @@ impl< let bend = GenericIndex::::new(self.graph.add_node(GenericNode::Primitive(weight.into()))); - self.graph - .update_edge(from.node_index(), bend.node_index(), GeometryLabel::Joined); - self.graph - .update_edge(bend.node_index(), to.node_index(), GeometryLabel::Joined); - self.graph - .update_edge(bend.node_index(), core.node_index(), GeometryLabel::Core); + self.graph.update_edge( + from.petgraph_index(), + bend.petgraph_index(), + GeometryLabel::Joined, + ); + self.graph.update_edge( + bend.petgraph_index(), + to.petgraph_index(), + GeometryLabel::Joined, + ); + self.graph.update_edge( + bend.petgraph_index(), + core.petgraph_index(), + GeometryLabel::Core, + ); bend } pub fn remove_primitive(&mut self, primitive: PI) { - self.graph.remove_node(primitive.node_index()); + self.graph.remove_node(primitive.petgraph_index()); } pub fn move_dot(&mut self, dot: DI, to: Point) { let mut weight = self.dot_weight(dot); weight.set_pos(to); - *self.graph.node_weight_mut(dot.node_index()).unwrap() = + *self.graph.node_weight_mut(dot.petgraph_index()).unwrap() = GenericNode::Primitive(weight.into()); } pub fn shift_bend(&mut self, bend: BI, offset: f64) { let mut weight = self.bend_weight(bend); weight.set_offset(offset); - *self.graph.node_weight_mut(bend.node_index()).unwrap() = + *self.graph.node_weight_mut(bend.petgraph_index()).unwrap() = GenericNode::Primitive(weight.into()); } @@ -184,7 +199,7 @@ impl< .graph .remove_edge( self.graph - .find_edge(from.node_index(), bend.node_index()) + .find_edge(from.petgraph_index(), bend.petgraph_index()) .unwrap(), ) .unwrap(); @@ -192,20 +207,20 @@ impl< .graph .remove_edge( self.graph - .find_edge(bend.node_index(), to.node_index()) + .find_edge(bend.petgraph_index(), to.petgraph_index()) .unwrap(), ) .unwrap(); self.graph - .update_edge(from.node_index(), bend.node_index(), to_edge_weight); + .update_edge(from.petgraph_index(), bend.petgraph_index(), to_edge_weight); self.graph - .update_edge(bend.node_index(), to.node_index(), from_edge_weight); + .update_edge(bend.petgraph_index(), to.petgraph_index(), from_edge_weight); } pub fn reattach_bend(&mut self, bend: BI, maybe_new_inner: Option) { if let Some(old_inner_edge) = self .graph - .edges_directed(bend.node_index(), Incoming) + .edges_directed(bend.petgraph_index(), Incoming) .filter(|edge| *edge.weight() == GeometryLabel::Outer) .next() { @@ -214,8 +229,8 @@ impl< if let Some(new_inner) = maybe_new_inner { self.graph.update_edge( - new_inner.node_index(), - bend.node_index(), + new_inner.petgraph_index(), + bend.petgraph_index(), GeometryLabel::Outer, ); } @@ -236,7 +251,7 @@ impl< PrimitiveShape::Seg(SegShape { from: self.dot_weight(from).pos(), to: self.dot_weight(to).pos(), - width: self.primitive_weight(seg.node_index()).width(), + width: self.primitive_weight(seg.petgraph_index()).width(), }) } @@ -250,7 +265,7 @@ impl< pos: core_weight.pos(), r: self.inner_radius(bend), }, - width: self.primitive_weight(bend.node_index()).width(), + width: self.primitive_weight(bend.petgraph_index()).width(), }) } @@ -279,26 +294,26 @@ impl< } pub fn dot_weight(&self, dot: DI) -> DW { - self.primitive_weight(dot.node_index()) + self.primitive_weight(dot.petgraph_index()) .try_into() .unwrap_or_else(|_| unreachable!()) } pub fn seg_weight(&self, seg: SI) -> SW { - self.primitive_weight(seg.node_index()) + self.primitive_weight(seg.petgraph_index()) .try_into() .unwrap_or_else(|_| unreachable!()) } pub fn bend_weight(&self, bend: BI) -> BW { - self.primitive_weight(bend.node_index()) + self.primitive_weight(bend.petgraph_index()) .try_into() .unwrap_or_else(|_| unreachable!()) } pub fn compound_weight(&self, compound: GenericIndex) -> CW { if let GenericNode::Compound(weight) = - *self.graph.node_weight(compound.node_index()).unwrap() + *self.graph.node_weight(compound.petgraph_index()).unwrap() { weight } else { @@ -308,11 +323,11 @@ impl< fn core_weight(&self, bend: BI) -> DW { self.graph - .neighbors(bend.node_index()) + .neighbors(bend.petgraph_index()) .filter(|ni| { matches!( self.graph - .edge_weight(self.graph.find_edge(bend.node_index(), *ni).unwrap()) + .edge_weight(self.graph.find_edge(bend.petgraph_index(), *ni).unwrap()) .unwrap(), GeometryLabel::Core ) @@ -348,11 +363,11 @@ impl< pub fn core(&self, bend: BI) -> DI { self.graph - .neighbors(bend.node_index()) + .neighbors(bend.petgraph_index()) .filter(|ni| { matches!( self.graph - .edge_weight(self.graph.find_edge(bend.node_index(), *ni).unwrap()) + .edge_weight(self.graph.find_edge(bend.petgraph_index(), *ni).unwrap()) .unwrap(), GeometryLabel::Core ) @@ -369,11 +384,11 @@ impl< pub fn inner(&self, bend: BI) -> Option { self.graph - .neighbors_directed(bend.node_index(), Incoming) + .neighbors_directed(bend.petgraph_index(), Incoming) .filter(|ni| { matches!( self.graph - .edge_weight(self.graph.find_edge(*ni, bend.node_index()).unwrap()) + .edge_weight(self.graph.find_edge(*ni, bend.petgraph_index()).unwrap()) .unwrap(), GeometryLabel::Outer ) @@ -389,11 +404,11 @@ impl< pub fn outer(&self, bend: BI) -> Option { self.graph - .neighbors(bend.node_index()) + .neighbors(bend.petgraph_index()) .filter(|ni| { matches!( self.graph - .edge_weight(self.graph.find_edge(bend.node_index(), *ni).unwrap()) + .edge_weight(self.graph.find_edge(bend.petgraph_index(), *ni).unwrap()) .unwrap(), GeometryLabel::Outer ) @@ -409,13 +424,13 @@ impl< pub fn joineds(&self, node: PI) -> impl Iterator + '_ { self.graph - .neighbors_undirected(node.node_index()) + .neighbors_undirected(node.petgraph_index()) .filter(move |ni| { matches!( self.graph .edge_weight( self.graph - .find_edge_undirected(node.node_index(), *ni) + .find_edge_undirected(node.petgraph_index(), *ni) .unwrap() .0, ) @@ -457,11 +472,15 @@ impl< pub fn compound_members(&self, compound: GenericIndex) -> impl Iterator + '_ { self.graph - .neighbors_directed(compound.node_index(), Incoming) + .neighbors_directed(compound.petgraph_index(), Incoming) .filter(move |ni| { matches!( self.graph - .edge_weight(self.graph.find_edge(*ni, compound.node_index()).unwrap()) + .edge_weight( + self.graph + .find_edge(*ni, compound.petgraph_index()) + .unwrap() + ) .unwrap(), GeometryLabel::Compound ) @@ -485,10 +504,10 @@ impl< SW: SegWeightTrait, BW: BendWeightTrait, CW: Copy, - PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PI: GetPetgraphIndex + TryInto + TryInto + TryInto + Copy, + DI: GetPetgraphIndex + Into + Copy, + SI: GetPetgraphIndex + Into + Copy, + BI: GetPetgraphIndex + Into + Copy, > CompoundManagerTrait> for Geometry { fn add_compound(&mut self, weight: CW) -> GenericIndex { @@ -496,20 +515,20 @@ impl< } fn remove_compound(&mut self, compound: GenericIndex) { - self.graph.remove_node(compound.node_index()); + self.graph.remove_node(compound.petgraph_index()); } fn add_to_compound(&mut self, primitive: GenericIndex, compound: GenericIndex) { self.graph.update_edge( - primitive.node_index(), - compound.node_index(), + primitive.petgraph_index(), + compound.petgraph_index(), GeometryLabel::Compound, ); } fn compound_weight(&self, compound: GenericIndex) -> CW { if let GenericNode::Compound(weight) = - *self.graph.node_weight(compound.node_index()).unwrap() + *self.graph.node_weight(compound.petgraph_index()).unwrap() { weight } else { @@ -519,11 +538,11 @@ impl< fn compounds(&self, node: GenericIndex) -> impl Iterator> { self.graph - .neighbors(node.node_index()) + .neighbors(node.petgraph_index()) .filter(move |ni| { matches!( self.graph - .edge_weight(self.graph.find_edge(node.node_index(), *ni).unwrap()) + .edge_weight(self.graph.find_edge(node.petgraph_index(), *ni).unwrap()) .unwrap(), GeometryLabel::Compound ) diff --git a/src/geometry/with_rtree.rs b/src/geometry/with_rtree.rs index 6cbfca9..041ad2a 100644 --- a/src/geometry/with_rtree.rs +++ b/src/geometry/with_rtree.rs @@ -13,7 +13,7 @@ use crate::{ BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetWidth, SegWeightTrait, }, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, }; #[derive(Debug, Clone, Copy, PartialEq)] @@ -43,10 +43,10 @@ pub struct GeometryWithRtree< SW: SegWeightTrait + GetLayer, BW: BendWeightTrait + GetLayer, CW: Copy, - PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PI: GetPetgraphIndex + TryInto + TryInto + TryInto + Copy, + DI: GetPetgraphIndex + Into + Copy, + SI: GetPetgraphIndex + Into + Copy, + BI: GetPetgraphIndex + Into + Copy, > { geometry: Geometry, rtree: RTree>>>, @@ -69,10 +69,10 @@ impl< SW: SegWeightTrait + GetLayer, BW: BendWeightTrait + GetLayer, CW: Copy, - PI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PI: GetPetgraphIndex + TryInto + TryInto + TryInto + PartialEq + Copy, + DI: GetPetgraphIndex + Into + Copy, + SI: GetPetgraphIndex + Into + Copy, + BI: GetPetgraphIndex + Into + Copy, > GeometryWithRtree { pub fn new(layer_count: usize) -> Self { @@ -259,10 +259,10 @@ impl< SW: SegWeightTrait + GetLayer, BW: BendWeightTrait + GetLayer, CW: Copy, - PI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PI: GetPetgraphIndex + TryInto + TryInto + TryInto + PartialEq + Copy, + DI: GetPetgraphIndex + Into + Copy, + SI: GetPetgraphIndex + Into + Copy, + BI: GetPetgraphIndex + Into + Copy, > GeometryWithRtree { fn make_bbox(&self, primitive: PI) -> BboxedIndex>> { @@ -390,10 +390,10 @@ impl< SW: SegWeightTrait + GetLayer, BW: BendWeightTrait + GetLayer, CW: Copy, - PI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PI: GetPetgraphIndex + TryInto + TryInto + TryInto + PartialEq + Copy, + DI: GetPetgraphIndex + Into + Copy, + SI: GetPetgraphIndex + Into + Copy, + BI: GetPetgraphIndex + Into + Copy, > CompoundManagerTrait> for GeometryWithRtree { diff --git a/src/graph.rs b/src/graph.rs index 48ae2d9..b9d47c7 100644 --- a/src/graph.rs +++ b/src/graph.rs @@ -9,8 +9,8 @@ use petgraph::stable_graph::NodeIndex; // Due to apparent limitations of enum_dispatch we're forced to import some types backwards. #[enum_dispatch] -pub trait GetNodeIndex { - fn node_index(&self) -> NodeIndex; +pub trait GetPetgraphIndex { + fn petgraph_index(&self) -> NodeIndex; } #[derive(Debug, Clone, Copy)] @@ -42,8 +42,8 @@ impl PartialEq for GenericIndex { impl Eq for GenericIndex {} -impl GetNodeIndex for GenericIndex { - fn node_index(&self) -> NodeIndex { +impl GetPetgraphIndex for GenericIndex { + fn petgraph_index(&self) -> NodeIndex { self.node_index } } diff --git a/src/layout/layout.rs b/src/layout/layout.rs index 7e3c87a..3b4c82d 100644 --- a/src/layout/layout.rs +++ b/src/layout/layout.rs @@ -5,7 +5,7 @@ use rstar::AABB; use crate::{ drawing::{ - band::BandIndex, + band::BandFirstSegIndex, bend::LooseBendWeight, cane::Cane, dot::{DotIndex, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight}, @@ -20,7 +20,7 @@ use crate::{ Drawing, Infringement, LayoutException, }, geometry::{compound::CompoundManagerTrait, primitive::PrimitiveShapeTrait, GenericNode}, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, layout::{ via::{Via, ViaWeight}, zone::{Zone, ZoneWeight}, @@ -46,7 +46,7 @@ impl Layout { Self { drawing } } - pub fn remove_band(&mut self, band: BandIndex) { + pub fn remove_band(&mut self, band: BandFirstSegIndex) { self.drawing.remove_band(band); } @@ -97,7 +97,7 @@ impl Layout { } } - Ok(GenericIndex::::new(compound.node_index())) + Ok(GenericIndex::::new(compound.petgraph_index())) } pub fn add_fixed_dot(&mut self, weight: FixedDotWeight) -> Result { @@ -204,7 +204,7 @@ impl Layout { GenericIndex::::new( self.drawing .add_compound(CompoundWeight::Zone(weight)) - .node_index(), + .petgraph_index(), ) } @@ -215,10 +215,12 @@ impl Layout { self.drawing.compounds(node) } - pub fn band_length(&self, band: BandIndex) -> f64 { + pub fn band_length(&self, band: BandFirstSegIndex) -> f64 { match band { - BandIndex::Straight(seg) => self.drawing.geometry().seg_shape(seg.into()).length(), - BandIndex::Bended(start_seg) => { + BandFirstSegIndex::Straight(seg) => { + self.drawing.geometry().seg_shape(seg.into()).length() + } + BandFirstSegIndex::Bended(start_seg) => { let mut length = self.drawing.geometry().seg_shape(start_seg.into()).length(); let start_dot = self.drawing.primitive(start_seg).joints().1; @@ -249,7 +251,7 @@ impl Layout { self.drawing.rtree().iter().filter_map(|wrapper| { if let NodeIndex::Compound(compound) = wrapper.data { if let CompoundWeight::Zone(..) = self.drawing.compound_weight(compound) { - return Some(GenericIndex::::new(compound.node_index())); + return Some(GenericIndex::::new(compound.petgraph_index())); } } @@ -270,7 +272,7 @@ impl Layout { .filter_map(|wrapper| { if let NodeIndex::Compound(compound) = wrapper.data { if let CompoundWeight::Zone(..) = self.drawing.compound_weight(compound) { - return Some(GenericIndex::::new(compound.node_index())); + return Some(GenericIndex::::new(compound.petgraph_index())); } } @@ -284,7 +286,7 @@ impl Layout { ) -> impl Iterator + '_ { self.drawing .geometry() - .compound_members(GenericIndex::new(zone.node_index())) + .compound_members(GenericIndex::new(zone.petgraph_index())) } pub fn drawing(&self) -> &Drawing { diff --git a/src/layout/via.rs b/src/layout/via.rs index f265717..caca2d7 100644 --- a/src/layout/via.rs +++ b/src/layout/via.rs @@ -6,7 +6,7 @@ use crate::{ compound::CompoundManagerTrait, primitive::{DotShape, PrimitiveShape}, }, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, layout::{CompoundWeight, Layout}, math::Circle, }; @@ -54,7 +54,7 @@ pub struct ViaWeight { impl From> for GenericIndex { fn from(via: GenericIndex) -> Self { - GenericIndex::::new(via.node_index()) + GenericIndex::::new(via.petgraph_index()) } } diff --git a/src/layout/zone.rs b/src/layout/zone.rs index 8d9477b..44ec117 100644 --- a/src/layout/zone.rs +++ b/src/layout/zone.rs @@ -11,7 +11,7 @@ use crate::{ seg::SegIndex, }, geometry::{compound::CompoundManagerTrait, poly::PolyShape, GetPos}, - graph::{GenericIndex, GetNodeIndex}, + graph::{GenericIndex, GetPetgraphIndex}, layout::{CompoundWeight, Layout}, }; @@ -130,7 +130,7 @@ pub enum ZoneWeight { impl From> for GenericIndex { fn from(zone: GenericIndex) -> Self { - GenericIndex::::new(zone.node_index()) + GenericIndex::::new(zone.petgraph_index()) } } @@ -154,7 +154,7 @@ impl GetMaybeNet for SolidZoneWeight { impl From> for GenericIndex { fn from(zone: GenericIndex) -> Self { - GenericIndex::::new(zone.node_index()) + GenericIndex::::new(zone.petgraph_index()) } } @@ -178,6 +178,6 @@ impl<'a> GetMaybeNet for PourZoneWeight { impl From> for GenericIndex { fn from(zone: GenericIndex) -> Self { - GenericIndex::::new(zone.node_index()) + GenericIndex::::new(zone.petgraph_index()) } } diff --git a/src/router/draw.rs b/src/router/draw.rs index 874bfa9..cafb2ab 100644 --- a/src/router/draw.rs +++ b/src/router/draw.rs @@ -4,7 +4,7 @@ use thiserror::Error; use crate::{ drawing::{ - band::BandIndex, + band::BandFirstSegIndex, bend::{BendIndex, LooseBendWeight}, dot::{DotIndex, FixedDotIndex, LooseDotIndex, LooseDotWeight}, graph::{GetLayer, GetMaybeNet, MakePrimitive}, @@ -51,7 +51,7 @@ impl<'a, R: RulesTrait> Draw<'a, R> { head: Head, into: FixedDotIndex, width: f64, - ) -> Result { + ) -> Result { let tangent = self .guide() .head_into_dot_segment(&head, into, width) @@ -62,8 +62,8 @@ impl<'a, R: RulesTrait> Draw<'a, R> { let layer = head.face().primitive(self.layout.drawing()).layer(); let maybe_net = head.face().primitive(self.layout.drawing()).maybe_net(); - Ok::(match head.face() { - DotIndex::Fixed(dot) => BandIndex::Straight( + Ok::(match head.face() { + DotIndex::Fixed(dot) => BandFirstSegIndex::Straight( self.layout .add_lone_loose_seg( dot, @@ -76,7 +76,7 @@ impl<'a, R: RulesTrait> Draw<'a, R> { ) .map_err(|err| DrawException::CannotFinishIn(into, err.into()))?, ), - DotIndex::Loose(dot) => BandIndex::Bended( + DotIndex::Loose(dot) => BandFirstSegIndex::Bended( self.layout .add_seq_loose_seg( into.into(), diff --git a/src/router/navmesh.rs b/src/router/navmesh.rs index fb67a4b..4a78724 100644 --- a/src/router/navmesh.rs +++ b/src/router/navmesh.rs @@ -19,55 +19,55 @@ use crate::{ rules::RulesTrait, Drawing, }, - graph::GetNodeIndex, + graph::GetPetgraphIndex, layout::Layout, - triangulation::{GetTrianvertexIndex, Triangulation, TriangulationEdgeReference}, + triangulation::{GetTrianvertexNodeIndex, Triangulation, TriangulationEdgeReference}, }; -#[enum_dispatch(GetNodeIndex, MakePrimitive)] +#[enum_dispatch(GetPetgraphIndex, MakePrimitive)] #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)] -pub enum NavvertexIndex { +pub enum NavvertexNodeIndex { FixedDot(FixedDotIndex), FixedBend(FixedBendIndex), LooseBend(LooseBendIndex), } -#[enum_dispatch(GetNodeIndex, MakePrimitive)] +#[enum_dispatch(GetPetgraphIndex, MakePrimitive)] #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)] -enum TrianvertexIndex { +enum TrianvertexNodeIndex { FixedDot(FixedDotIndex), FixedBend(FixedBendIndex), } -impl From for PrimitiveIndex { - fn from(vertex: NavvertexIndex) -> Self { +impl From for PrimitiveIndex { + fn from(vertex: NavvertexNodeIndex) -> Self { match vertex { - NavvertexIndex::FixedDot(dot) => PrimitiveIndex::FixedDot(dot), - NavvertexIndex::FixedBend(bend) => PrimitiveIndex::FixedBend(bend), - NavvertexIndex::LooseBend(bend) => PrimitiveIndex::LooseBend(bend), + NavvertexNodeIndex::FixedDot(dot) => PrimitiveIndex::FixedDot(dot), + NavvertexNodeIndex::FixedBend(bend) => PrimitiveIndex::FixedBend(bend), + NavvertexNodeIndex::LooseBend(bend) => PrimitiveIndex::LooseBend(bend), } } } -impl From for NavvertexIndex { - fn from(vertex: TrianvertexIndex) -> Self { +impl From for NavvertexNodeIndex { + fn from(vertex: TrianvertexNodeIndex) -> Self { match vertex { - TrianvertexIndex::FixedDot(dot) => NavvertexIndex::FixedDot(dot), - TrianvertexIndex::FixedBend(bend) => NavvertexIndex::FixedBend(bend), + TrianvertexNodeIndex::FixedDot(dot) => NavvertexNodeIndex::FixedDot(dot), + TrianvertexNodeIndex::FixedBend(bend) => NavvertexNodeIndex::FixedBend(bend), } } } #[derive(Debug, Clone)] struct TrianvertexWeight { - trianvertex: TrianvertexIndex, + node: TrianvertexNodeIndex, rails: Vec, pos: Point, } -impl GetTrianvertexIndex for TrianvertexWeight { - fn trianvertex_index(&self) -> TrianvertexIndex { - self.trianvertex +impl GetTrianvertexNodeIndex for TrianvertexWeight { + fn node_index(&self) -> TrianvertexNodeIndex { + self.node } } @@ -80,8 +80,8 @@ impl HasPosition for TrianvertexWeight { #[derive(Debug, Clone)] pub struct Navmesh { - triangulation: Triangulation, - navvertex_to_trianvertex: Vec>, + triangulation: Triangulation, + navvertex_to_trianvertex: Vec>, source: FixedDotIndex, target: FixedDotIndex, } @@ -121,14 +121,14 @@ impl Navmesh { match node { PrimitiveIndex::FixedDot(dot) => { this.triangulation.add_vertex(TrianvertexWeight { - trianvertex: dot.into(), + node: dot.into(), rails: vec![], pos: primitive.shape().center(), })?; } PrimitiveIndex::FixedBend(bend) => { this.triangulation.add_vertex(TrianvertexWeight { - trianvertex: bend.into(), + node: bend.into(), rails: vec![], pos: primitive.shape().center(), })?; @@ -147,7 +147,7 @@ impl Navmesh { .weight_mut(layout.drawing().primitive(bend).core().into()) .rails .push(bend.into()); - this.navvertex_to_trianvertex[bend.node_index().index()] = + this.navvertex_to_trianvertex[bend.petgraph_index().index()] = Some(layout.drawing().primitive(bend).core().into()); } _ => (), @@ -157,12 +157,12 @@ impl Navmesh { Ok(this) } - fn triangulation_vertex(&self, vertex: NavvertexIndex) -> TrianvertexIndex { + fn trianvertex(&self, vertex: NavvertexNodeIndex) -> TrianvertexNodeIndex { match vertex { - NavvertexIndex::FixedDot(dot) => TrianvertexIndex::FixedDot(dot), - NavvertexIndex::FixedBend(bend) => TrianvertexIndex::FixedBend(bend), - NavvertexIndex::LooseBend(bend) => { - self.navvertex_to_trianvertex[bend.node_index().index()].unwrap() + NavvertexNodeIndex::FixedDot(dot) => TrianvertexNodeIndex::FixedDot(dot), + NavvertexNodeIndex::FixedBend(bend) => TrianvertexNodeIndex::FixedBend(bend), + NavvertexNodeIndex::LooseBend(bend) => { + self.navvertex_to_trianvertex[bend.petgraph_index().index()].unwrap() } } } @@ -177,8 +177,8 @@ impl Navmesh { } impl visit::GraphBase for Navmesh { - type NodeId = NavvertexIndex; - type EdgeId = (NavvertexIndex, NavvertexIndex); + type NodeId = NavvertexNodeIndex; + type EdgeId = (NavvertexNodeIndex, NavvertexNodeIndex); } impl visit::Data for Navmesh { @@ -188,13 +188,13 @@ impl visit::Data for Navmesh { #[derive(Debug, Clone, Copy)] pub struct NavmeshEdgeReference { - from: NavvertexIndex, - to: NavvertexIndex, + from: NavvertexNodeIndex, + to: NavvertexNodeIndex, } impl visit::EdgeRef for NavmeshEdgeReference { - type NodeId = NavvertexIndex; - type EdgeId = (NavvertexIndex, NavvertexIndex); + type NodeId = NavvertexNodeIndex; + type EdgeId = (NavvertexNodeIndex, NavvertexNodeIndex); type Weight = (); fn source(&self) -> Self::NodeId { @@ -215,19 +215,19 @@ impl visit::EdgeRef for NavmeshEdgeReference { } impl<'a> visit::IntoNeighbors for &'a Navmesh { - type Neighbors = Box + 'a>; + type Neighbors = Box + 'a>; fn neighbors(self, vertex: Self::NodeId) -> Self::Neighbors { Box::new( self.triangulation - .neighbors(self.triangulation_vertex(vertex)) + .neighbors(self.trianvertex(vertex)) .flat_map(|neighbor| { iter::once(neighbor.into()).chain( self.triangulation .weight(neighbor) .rails .iter() - .map(|index| NavvertexIndex::from(*index)), + .map(|index| NavvertexNodeIndex::from(*index)), ) }), ) @@ -235,8 +235,8 @@ impl<'a> visit::IntoNeighbors for &'a Navmesh { } fn edge_with_near_edges( - triangulation: &Triangulation, - edge: TriangulationEdgeReference, + triangulation: &Triangulation, + edge: TriangulationEdgeReference, ) -> impl Iterator { let mut from_vertices = vec![edge.source().into()]; @@ -246,7 +246,7 @@ fn edge_with_near_edges( .weight(edge.source()) .rails .iter() - .map(|bend| NavvertexIndex::from(*bend)), + .map(|bend| NavvertexNodeIndex::from(*bend)), ); let mut to_vertices = vec![edge.target().into()]; @@ -257,7 +257,7 @@ fn edge_with_near_edges( .weight(edge.target()) .rails .iter() - .map(|bend| NavvertexIndex::from(*bend)), + .map(|bend| NavvertexNodeIndex::from(*bend)), ); // Return cartesian product. @@ -284,9 +284,9 @@ impl<'a> visit::IntoEdgeReferences for &'a Navmesh { } fn vertex_edges( - triangulation: &Triangulation, - from: NavvertexIndex, - to: TrianvertexIndex, + triangulation: &Triangulation, + from: NavvertexNodeIndex, + to: TrianvertexNodeIndex, ) -> impl Iterator { let from_vertices = vec![from]; let mut to_vertices = vec![to.into()]; @@ -297,7 +297,7 @@ fn vertex_edges( .weight(to) .rails .iter() - .map(|bend| NavvertexIndex::from(*bend)), + .map(|bend| NavvertexNodeIndex::from(*bend)), ); // Return cartesian product. @@ -316,7 +316,7 @@ impl<'a> visit::IntoEdges for &'a Navmesh { fn edges(self, vertex: Self::NodeId) -> Self::Edges { Box::new( self.triangulation - .edges(self.triangulation_vertex(vertex)) + .edges(self.trianvertex(vertex)) .flat_map(move |edge| vertex_edges(&self.triangulation, vertex, edge.target())), ) } diff --git a/src/router/router.rs b/src/router/router.rs index 4a064dc..940e45c 100644 --- a/src/router/router.rs +++ b/src/router/router.rs @@ -4,7 +4,7 @@ use thiserror::Error; use crate::{ drawing::{ - band::BandIndex, + band::BandFirstSegIndex, dot::FixedDotIndex, graph::{MakePrimitive, PrimitiveIndex}, primitive::MakePrimitiveShape, @@ -15,7 +15,7 @@ use crate::{ router::{ astar::{astar, AstarError, AstarStrategy, PathTracker}, draw::DrawException, - navmesh::{Navmesh, NavmeshEdgeReference, NavmeshError, NavvertexIndex}, + navmesh::{Navmesh, NavmeshEdgeReference, NavmeshError, NavvertexNodeIndex}, tracer::{Trace, Tracer}, }, }; @@ -44,12 +44,14 @@ impl<'a, R: RulesTrait> RouterAstarStrategy<'a, R> { } } -impl<'a, R: RulesTrait> AstarStrategy<&Navmesh, f64, BandIndex> for RouterAstarStrategy<'a, R> { +impl<'a, R: RulesTrait> AstarStrategy<&Navmesh, f64, BandFirstSegIndex> + for RouterAstarStrategy<'a, R> +{ fn is_goal( &mut self, - vertex: NavvertexIndex, + vertex: NavvertexNodeIndex, tracker: &PathTracker<&Navmesh>, - ) -> Option { + ) -> Option { let new_path = tracker.reconstruct_path_to(vertex); let width = self.trace.width; @@ -80,7 +82,7 @@ impl<'a, R: RulesTrait> AstarStrategy<&Navmesh, f64, BandIndex> for RouterAstarS } } - fn estimate_cost(&mut self, vertex: NavvertexIndex) -> f64 { + fn estimate_cost(&mut self, vertex: NavvertexNodeIndex) -> f64 { let start_point = PrimitiveIndex::from(vertex) .primitive(self.tracer.layout.drawing()) .shape() @@ -111,7 +113,7 @@ impl<'a, R: RulesTrait> Router<'a, R> { Self { layout, navmesh } } - pub fn route_band(&mut self, width: f64) -> Result { + pub fn route_band(&mut self, width: f64) -> Result { let from = self.navmesh.source(); let to = self.navmesh.target(); let mut tracer = Tracer::new(self.layout); diff --git a/src/router/tracer.rs b/src/router/tracer.rs index 8d17c26..c5f5364 100644 --- a/src/router/tracer.rs +++ b/src/router/tracer.rs @@ -2,7 +2,7 @@ use contracts::debug_ensures; use crate::{ drawing::{ - band::BandIndex, + band::BandFirstSegIndex, bend::LooseBendIndex, dot::FixedDotIndex, guide::{BareHead, CaneHead, Head}, @@ -11,13 +11,13 @@ use crate::{ layout::Layout, router::{ draw::{Draw, DrawException}, - navmesh::NavvertexIndex, + navmesh::NavvertexNodeIndex, }, }; #[derive(Debug)] pub struct Trace { - pub path: Vec, + pub path: Vec, pub head: Head, pub width: f64, } @@ -45,7 +45,7 @@ impl<'a, R: RulesTrait> Tracer<'a, R> { trace: &mut Trace, into: FixedDotIndex, width: f64, - ) -> Result { + ) -> Result { Draw::new(self.layout).finish_in_dot(trace.head, into, width) } @@ -53,7 +53,7 @@ impl<'a, R: RulesTrait> Tracer<'a, R> { pub fn rework_path( &mut self, trace: &mut Trace, - path: &[NavvertexIndex], + path: &[NavvertexNodeIndex], width: f64, ) -> Result<(), DrawException> { let prefix_length = trace @@ -72,7 +72,7 @@ impl<'a, R: RulesTrait> Tracer<'a, R> { pub fn path( &mut self, trace: &mut Trace, - path: &[NavvertexIndex], + path: &[NavvertexNodeIndex], width: f64, ) -> Result<(), DrawException> { for (i, vertex) in path.iter().enumerate() { @@ -97,7 +97,7 @@ impl<'a, R: RulesTrait> Tracer<'a, R> { pub fn step( &mut self, trace: &mut Trace, - to: NavvertexIndex, + to: NavvertexNodeIndex, width: f64, ) -> Result<(), DrawException> { trace.head = self.wrap(trace.head, to, width)?.into(); @@ -109,13 +109,13 @@ impl<'a, R: RulesTrait> Tracer<'a, R> { fn wrap( &mut self, head: Head, - around: NavvertexIndex, + around: NavvertexNodeIndex, width: f64, ) -> Result { match around { - NavvertexIndex::FixedDot(dot) => self.wrap_around_fixed_dot(head, dot, width), - NavvertexIndex::FixedBend(_fixed_bend) => todo!(), - NavvertexIndex::LooseBend(loose_bend) => { + NavvertexNodeIndex::FixedDot(dot) => self.wrap_around_fixed_dot(head, dot, width), + NavvertexNodeIndex::FixedBend(_fixed_bend) => todo!(), + NavvertexNodeIndex::LooseBend(loose_bend) => { self.wrap_around_loose_bend(head, loose_bend, width) } } diff --git a/src/specctra/design.rs b/src/specctra/design.rs index 1696fad..2958db2 100644 --- a/src/specctra/design.rs +++ b/src/specctra/design.rs @@ -671,7 +671,7 @@ impl SpecctraDesign { maybe_net: Some(net), }, // TODO: This manual retagging shouldn't be necessary, `.into()` should suffice. - //GenericIndex::new(zone.node_index()).into(), + //GenericIndex::new(zone.petgraph_index()).into(), zone, ); diff --git a/src/triangulation.rs b/src/triangulation.rs index 863871f..39e6776 100644 --- a/src/triangulation.rs +++ b/src/triangulation.rs @@ -4,16 +4,16 @@ use geo::{point, EuclideanDistance, Point}; use petgraph::visit; use spade::{handles::FixedVertexHandle, DelaunayTriangulation, HasPosition, InsertionError}; -use crate::graph::GetNodeIndex; +use crate::graph::GetPetgraphIndex; -pub trait GetTrianvertexIndex { - fn trianvertex_index(&self) -> I; +pub trait GetTrianvertexNodeIndex { + fn node_index(&self) -> I; } #[derive(Debug, Clone)] pub struct Triangulation< - I: Copy + PartialEq + GetNodeIndex, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > { triangulation: DelaunayTriangulation, @@ -22,8 +22,8 @@ pub struct Triangulation< } impl< - I: Copy + PartialEq + GetNodeIndex, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > Triangulation { @@ -38,7 +38,7 @@ impl< } pub fn add_vertex(&mut self, weight: VW) -> Result<(), InsertionError> { - let index = weight.trianvertex_index().node_index().index(); + let index = weight.node_index().petgraph_index().index(); self.trianvertex_to_handle[index] = Some(spade::Triangulation::insert( &mut self.triangulation, weight, @@ -48,13 +48,13 @@ impl< pub fn weight(&self, vertex: I) -> &VW { spade::Triangulation::s(&self.triangulation) - .vertex_data(self.trianvertex_to_handle[vertex.node_index().index()].unwrap()) + .vertex_data(self.trianvertex_to_handle[vertex.petgraph_index().index()].unwrap()) } pub fn weight_mut(&mut self, vertex: I) -> &mut VW { spade::Triangulation::vertex_data_mut( &mut self.triangulation, - self.trianvertex_to_handle[vertex.node_index().index()].unwrap(), + self.trianvertex_to_handle[vertex.petgraph_index().index()].unwrap(), ) } @@ -67,17 +67,17 @@ impl< fn vertex(&self, handle: FixedVertexHandle) -> I { spade::Triangulation::vertex(&self.triangulation, handle) .as_ref() - .trianvertex_index() + .node_index() } fn handle(&self, vertex: I) -> FixedVertexHandle { - self.trianvertex_to_handle[vertex.node_index().index()].unwrap() + self.trianvertex_to_handle[vertex.petgraph_index().index()].unwrap() } } impl< - I: Copy + PartialEq + GetNodeIndex, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > visit::GraphBase for Triangulation { @@ -104,8 +104,8 @@ impl PartialOrd for TriangulationEdgeWeightWrapper { } impl< - I: Copy + PartialEq + GetNodeIndex, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > visit::Data for Triangulation { @@ -144,8 +144,8 @@ impl visit::EdgeRef for TriangulationEdgeReference< impl< 'a, - I: Copy + PartialEq + GetNodeIndex, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > visit::IntoNeighbors for &'a Triangulation { @@ -162,8 +162,8 @@ impl< impl< 'a, - I: Copy + PartialEq + GetNodeIndex, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > visit::IntoEdgeReferences for &'a Triangulation { @@ -191,8 +191,8 @@ impl< impl< 'a, - I: Copy + PartialEq + GetNodeIndex, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > visit::IntoEdges for &'a Triangulation { @@ -221,8 +221,8 @@ impl< impl< 'a, - I: Copy + PartialEq + GetNodeIndex, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > visit::IntoNodeIdentifiers for &'a Triangulation { @@ -233,7 +233,7 @@ impl< spade::Triangulation::fixed_vertices(&self.triangulation).map(|vertex| { spade::Triangulation::s(&self.triangulation) .vertex_data(vertex) - .trianvertex_index() + .node_index() }), ) } @@ -260,8 +260,8 @@ impl<'a, I: Copy, VW: Copy> visit::NodeRef for TriangulationVertexReference<'a, impl< 'a, - I: Copy + PartialEq + GetNodeIndex, - VW: Copy + GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex, + VW: Copy + GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > visit::IntoNodeReferences for &'a Triangulation { @@ -273,7 +273,7 @@ impl< spade::Triangulation::fixed_vertices(&self.triangulation).map(|vertex| { let weight = spade::Triangulation::s(&self.triangulation).vertex_data(vertex); TriangulationVertexReference { - index: weight.trianvertex_index(), + index: weight.node_index(), weight, } }), @@ -283,8 +283,8 @@ impl< impl< 'a, - I: Copy + PartialEq + GetNodeIndex + std::fmt::Debug, - VW: GetTrianvertexIndex + HasPosition, + I: Copy + PartialEq + GetPetgraphIndex + std::fmt::Debug, + VW: GetTrianvertexNodeIndex + HasPosition, EW: Copy + Default, > visit::NodeIndexable for &'a Triangulation { @@ -294,12 +294,12 @@ impl< } fn to_index(&self, node: I) -> usize { - node.node_index().index() + node.petgraph_index().index() } fn from_index(&self, index: usize) -> I { spade::Triangulation::s(&self.triangulation) .vertex_data(self.trianvertex_to_handle[index].unwrap()) - .trianvertex_index() + .node_index() } } diff --git a/tests/common/mod.rs b/tests/common/mod.rs index cdd27c8..d0ee299 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -9,7 +9,7 @@ use topola::{ }, board::{mesadata::MesadataTrait, Board}, drawing::graph::{GetLayer, GetMaybeNet}, - graph::GetNodeIndex, + graph::GetPetgraphIndex, specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata}, }; @@ -121,8 +121,8 @@ pub fn assert_single_layer_groundless_autoroute( if netname != "GND" { dbg!(source_dot, target_dot); assert_eq!( - unionfind.find(source_dot.node_index()), - unionfind.find(target_dot.node_index()) + unionfind.find(source_dot.petgraph_index()), + unionfind.find(target_dot.petgraph_index()) ); } } @@ -179,7 +179,7 @@ fn unionfind(autorouter: &mut Autorouter) -> UnionFind