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

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.
This commit is contained in:
Mikolaj Wielgus 2024-06-18 14:33:35 +02:00
parent 7f46d436af
commit d4a310a5c0
30 changed files with 318 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/autorouter/autorouter.rs
View File

@ -13,7 +13,7 @@ use crate::{
drawing::{dot::FixedDotIndex, Infringement}, drawing::{dot::FixedDotIndex, Infringement},
layout::via::ViaWeight, layout::via::ViaWeight,
router::{navmesh::NavmeshError, RouterError}, router::{navmesh::NavmeshError, RouterError},
triangulation::GetTrianvertexIndex, triangulation::GetTrianvertexNodeIndex,
}; };
#[derive(Error, Debug, Clone)] #[derive(Error, Debug, Clone)]
@ -100,7 +100,7 @@ impl<M: MesadataTrait> Autorouter<M> {
.graph() .graph()
.node_weight(source) .node_weight(source)
.unwrap() .unwrap()
.trianvertex_index() .node_index()
{ {
RatvertexIndex::FixedDot(dot) => dot, RatvertexIndex::FixedDot(dot) => dot,
RatvertexIndex::Zone(zone) => self.board.zone_apex(zone), RatvertexIndex::Zone(zone) => self.board.zone_apex(zone),
@ -111,7 +111,7 @@ impl<M: MesadataTrait> Autorouter<M> {
.graph() .graph()
.node_weight(target) .node_weight(target)
.unwrap() .unwrap()
.trianvertex_index() .node_index()
{ {
RatvertexIndex::FixedDot(dot) => dot, RatvertexIndex::FixedDot(dot) => dot,
RatvertexIndex::Zone(zone) => self.board.zone_apex(zone), RatvertexIndex::Zone(zone) => self.board.zone_apex(zone),
@ -132,13 +132,13 @@ impl<M: MesadataTrait> Autorouter<M> {
.graph() .graph()
.node_weight(source) .node_weight(source)
.unwrap() .unwrap()
.trianvertex_index(); .node_index();
let to_vertex = self let to_vertex = self
.ratsnest .ratsnest
.graph() .graph()
.node_weight(target) .node_weight(target)
.unwrap() .unwrap()
.trianvertex_index(); .node_index();
selection.contains_node(&self.board, source_vertex.into()) selection.contains_node(&self.board, source_vertex.into())
&& selection.contains_node(&self.board, to_vertex.into()) && selection.contains_node(&self.board, to_vertex.into())

28
src/autorouter/ratsnest.rs
View File

@ -12,22 +12,22 @@ use spade::{HasPosition, InsertionError, Point2};
use crate::{ use crate::{
drawing::{ drawing::{
band::BandIndex, band::BandFirstSegIndex,
dot::FixedDotIndex, dot::FixedDotIndex,
graph::{GetMaybeNet, MakePrimitive, PrimitiveIndex}, graph::{GetMaybeNet, MakePrimitive, PrimitiveIndex},
primitive::MakePrimitiveShape, primitive::MakePrimitiveShape,
rules::RulesTrait, rules::RulesTrait,
}, },
geometry::{compound::CompoundManagerTrait, shape::ShapeTrait}, geometry::{compound::CompoundManagerTrait, shape::ShapeTrait},
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
layout::{ layout::{
zone::{MakePolyShape, ZoneWeight}, zone::{MakePolyShape, ZoneWeight},
Layout, Layout,
}, },
triangulation::{GetTrianvertexIndex, Triangulation}, triangulation::{GetTrianvertexNodeIndex, Triangulation},
}; };
#[enum_dispatch(GetNodeIndex)] #[enum_dispatch(GetPetgraphIndex)]
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
pub enum RatvertexIndex { pub enum RatvertexIndex {
FixedDot(FixedDotIndex), FixedDot(FixedDotIndex),
@ -49,8 +49,8 @@ pub struct RatvertexWeight {
pub pos: Point, pub pos: Point,
} }
impl GetTrianvertexIndex<RatvertexIndex> for RatvertexWeight { impl GetTrianvertexNodeIndex<RatvertexIndex> for RatvertexWeight {
fn trianvertex_index(&self) -> RatvertexIndex { fn node_index(&self) -> RatvertexIndex {
self.vertex self.vertex
} }
} }
@ -64,7 +64,7 @@ impl HasPosition for RatvertexWeight {
#[derive(Debug, Default, Clone, Copy)] #[derive(Debug, Default, Clone, Copy)]
pub struct RatlineWeight { pub struct RatlineWeight {
pub band: Option<BandIndex>, pub band: Option<BandFirstSegIndex>,
} }
pub struct Ratsnest { pub struct Ratsnest {
@ -154,16 +154,8 @@ impl Ratsnest {
this.graph.retain_edges(|g, i| { this.graph.retain_edges(|g, i| {
if let Some((source, target)) = g.edge_endpoints(i) { if let Some((source, target)) = g.edge_endpoints(i) {
let source_index = g let source_index = g.node_weight(source).unwrap().node_index().petgraph_index();
.node_weight(source) let target_index = g.node_weight(target).unwrap().node_index().petgraph_index();
.unwrap()
.trianvertex_index()
.node_index();
let target_index = g
.node_weight(target)
.unwrap()
.trianvertex_index()
.node_index();
!unionfind.equiv(source_index, target_index) !unionfind.equiv(source_index, target_index)
} else { } else {
true true
@ -173,7 +165,7 @@ impl Ratsnest {
Ok(this) Ok(this)
} }
pub fn assign_band_to_ratline(&mut self, ratline: EdgeIndex<usize>, band: BandIndex) { pub fn assign_band_to_ratline(&mut self, ratline: EdgeIndex<usize>, band: BandFirstSegIndex) {
self.graph.edge_weight_mut(ratline).unwrap().band = Some(band); self.graph.edge_weight_mut(ratline).unwrap().band = Some(band);
} }

4
src/autorouter/selection.rs
View File

@ -6,7 +6,7 @@ use crate::{
board::{mesadata::MesadataTrait, Board}, board::{mesadata::MesadataTrait, Board},
drawing::graph::{GetLayer, MakePrimitive}, drawing::graph::{GetLayer, MakePrimitive},
geometry::compound::CompoundManagerTrait, geometry::compound::CompoundManagerTrait,
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
layout::{zone::ZoneWeight, CompoundWeight, NodeIndex}, layout::{zone::ZoneWeight, CompoundWeight, NodeIndex},
}; };
@ -70,7 +70,7 @@ impl Selection {
{ {
board board
.layout() .layout()
.zone(GenericIndex::<ZoneWeight>::new(compound.node_index())) .zone(GenericIndex::<ZoneWeight>::new(compound.petgraph_index()))
.layer() .layer()
} else { } else {
unreachable!() unreachable!()

4
src/bin/topola-egui/app.rs
View File

@ -33,7 +33,7 @@ use topola::{
math::Circle, math::Circle,
router::{ router::{
draw::DrawException, draw::DrawException,
navmesh::{Navmesh, NavmeshEdgeReference, NavvertexIndex}, navmesh::{Navmesh, NavmeshEdgeReference, NavvertexNodeIndex},
tracer::{Trace, Tracer}, tracer::{Trace, Tracer},
}, },
specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata}, specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata},
@ -49,7 +49,7 @@ pub struct SharedData {
pub from: Option<FixedDotIndex>, pub from: Option<FixedDotIndex>,
pub to: Option<FixedDotIndex>, pub to: Option<FixedDotIndex>,
pub navmesh: Option<Navmesh>, pub navmesh: Option<Navmesh>,
pub path: Vec<NavvertexIndex>, pub path: Vec<NavvertexNodeIndex>,
pub ghosts: Vec<PrimitiveShape>, pub ghosts: Vec<PrimitiveShape>,
pub highlighteds: Vec<PrimitiveIndex>, pub highlighteds: Vec<PrimitiveIndex>,
} }

8
src/bin/topola-egui/overlay.rs
View File

@ -15,7 +15,7 @@ use topola::{
compound::CompoundManagerTrait, compound::CompoundManagerTrait,
shape::{Shape, ShapeTrait}, shape::{Shape, ShapeTrait},
}, },
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
layout::{ layout::{
via::ViaWeight, via::ViaWeight,
zone::{MakePolyShape, Zone, ZoneWeight}, zone::{MakePolyShape, Zone, ZoneWeight},
@ -80,19 +80,19 @@ impl Overlay {
NodeIndex::Compound(compound) => { NodeIndex::Compound(compound) => {
match board.layout().drawing().compound_weight(compound) { match board.layout().drawing().compound_weight(compound) {
/*CompoundWeight::Zone(zone) => Zone::new( /*CompoundWeight::Zone(zone) => Zone::new(
GenericIndex::<ZoneWeight>::new(compound.node_index()), GenericIndex::<ZoneWeight>::new(compound.petgraph_index()),
board.layout(), board.layout(),
) )
.shape() .shape()
.into(),*/ .into(),*/
CompoundWeight::Zone(weight) => board CompoundWeight::Zone(weight) => board
.layout() .layout()
.zone(GenericIndex::<ZoneWeight>::new(compound.node_index())) .zone(GenericIndex::<ZoneWeight>::new(compound.petgraph_index()))
.shape() .shape()
.into(), .into(),
CompoundWeight::Via(weight) => board CompoundWeight::Via(weight) => board
.layout() .layout()
.via(GenericIndex::<ViaWeight>::new(compound.node_index())) .via(GenericIndex::<ViaWeight>::new(compound.petgraph_index()))
.shape() .shape()
.into(), .into(),
} }

4
src/bin/topola-sdl2-demo/main.rs
View File

@ -25,7 +25,7 @@ use topola::geometry::shape::ShapeTrait;
use topola::layout::zone::MakePolyShape; use topola::layout::zone::MakePolyShape;
use topola::layout::Layout; use topola::layout::Layout;
use topola::router::draw::DrawException; 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::router::tracer::{Trace, Tracer};
use topola::specctra::design::SpecctraDesign; use topola::specctra::design::SpecctraDesign;
use topola::specctra::mesadata::SpecctraMesadata; use topola::specctra::mesadata::SpecctraMesadata;
@ -225,7 +225,7 @@ fn render_times(
mut router_or_layout: RouterOrLayout<impl RulesTrait>, mut router_or_layout: RouterOrLayout<impl RulesTrait>,
_unused: Option<()>, _unused: Option<()>,
mut maybe_navmesh: Option<Navmesh>, mut maybe_navmesh: Option<Navmesh>,
path: &[NavvertexIndex], path: &[NavvertexNodeIndex],
ghosts: &[PrimitiveShape], ghosts: &[PrimitiveShape],
highlighteds: &[PrimitiveIndex], highlighteds: &[PrimitiveIndex],
times: i64, times: i64,

12
src/board/board.rs
View File

@ -3,7 +3,7 @@ use std::collections::HashMap;
use crate::{ use crate::{
board::mesadata::MesadataTrait, board::mesadata::MesadataTrait,
drawing::{ drawing::{
band::BandIndex, band::BandFirstSegIndex,
dot::{FixedDotIndex, FixedDotWeight}, dot::{FixedDotIndex, FixedDotWeight},
graph::{GetLayer, GetMaybeNet}, graph::{GetLayer, GetMaybeNet},
seg::{FixedSegIndex, FixedSegWeight}, seg::{FixedSegIndex, FixedSegWeight},
@ -22,7 +22,7 @@ use crate::{
pub struct Board<M: MesadataTrait> { pub struct Board<M: MesadataTrait> {
layout: Layout<M>, layout: Layout<M>,
node_to_pinname: HashMap<NodeIndex, String>, node_to_pinname: HashMap<NodeIndex, String>,
pinname_pair_to_band: HashMap<(String, String), BandIndex>, pinname_pair_to_band: HashMap<(String, String), BandFirstSegIndex>,
} }
impl<M: MesadataTrait> Board<M> { impl<M: MesadataTrait> Board<M> {
@ -115,7 +115,11 @@ impl<M: MesadataTrait> Board<M> {
zone zone
} }
pub fn route_band(&mut self, navmesh: Navmesh, width: f64) -> Result<BandIndex, RouterError> { pub fn route_band(
&mut self,
navmesh: Navmesh,
width: f64,
) -> Result<BandFirstSegIndex, RouterError> {
let source_pinname = self let source_pinname = self
.node_pinname(GenericNode::Primitive(navmesh.source().into())) .node_pinname(GenericNode::Primitive(navmesh.source().into()))
.unwrap() .unwrap()
@ -158,7 +162,7 @@ impl<M: MesadataTrait> Board<M> {
self.node_to_pinname.get(&node) self.node_to_pinname.get(&node)
} }
pub fn band_between_pins(&self, pinname1: &str, pinname2: &str) -> Option<BandIndex> { pub fn band_between_pins(&self, pinname1: &str, pinname2: &str) -> Option<BandFirstSegIndex> {
if let Some(band) = self if let Some(band) = self
.pinname_pair_to_band .pinname_pair_to_band
.get(&(pinname1.to_string(), pinname2.to_string())) .get(&(pinname1.to_string(), pinname2.to_string()))

2
src/drawing/band.rs
View File

@ -1,7 +1,7 @@
use crate::drawing::seg::{LoneLooseSegIndex, SeqLooseSegIndex}; use crate::drawing::seg::{LoneLooseSegIndex, SeqLooseSegIndex};
#[derive(Debug, Hash, Clone, Copy, Eq, PartialEq)] #[derive(Debug, Hash, Clone, Copy, Eq, PartialEq)]
pub enum BandIndex { pub enum BandFirstSegIndex {
Straight(LoneLooseSegIndex), Straight(LoneLooseSegIndex),
Bended(SeqLooseSegIndex), Bended(SeqLooseSegIndex),
} }

4
src/drawing/bend.rs
View File

@ -8,12 +8,12 @@ use crate::{
Drawing, Drawing,
}, },
geometry::{BendWeightTrait, GetOffset, GetWidth, SetOffset}, geometry::{BendWeightTrait, GetOffset, GetWidth, SetOffset},
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
}; };
use petgraph::stable_graph::NodeIndex; use petgraph::stable_graph::NodeIndex;
#[enum_dispatch(GetNodeIndex, MakePrimitive)] #[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
pub enum BendIndex { pub enum BendIndex {
Fixed(FixedBendIndex), Fixed(FixedBendIndex),

4
src/drawing/dot.rs
View File

@ -11,11 +11,11 @@ use crate::{
Drawing, Drawing,
}, },
geometry::{DotWeightTrait, GetPos, GetWidth, SetPos}, geometry::{DotWeightTrait, GetPos, GetWidth, SetPos},
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
math::Circle, math::Circle,
}; };
#[enum_dispatch(GetNodeIndex, MakePrimitive)] #[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
pub enum DotIndex { pub enum DotIndex {
Fixed(FixedDotIndex), Fixed(FixedDotIndex),

14
src/drawing/drawing.rs
View File

@ -6,7 +6,7 @@ use rstar::{RTree, AABB};
use thiserror::Error; use thiserror::Error;
use crate::drawing::{ use crate::drawing::{
band::BandIndex, band::BandFirstSegIndex,
bend::{BendIndex, BendWeight, FixedBendIndex, LooseBendIndex, LooseBendWeight}, bend::{BendIndex, BendWeight, FixedBendIndex, LooseBendIndex, LooseBendWeight},
cane::Cane, cane::Cane,
collect::Collect, collect::Collect,
@ -32,7 +32,7 @@ use crate::geometry::{
BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetOffset, GetPos, BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetOffset, GetPos,
GetWidth, SegWeightTrait, GetWidth, SegWeightTrait,
}; };
use crate::graph::{GenericIndex, GetNodeIndex}; use crate::graph::{GenericIndex, GetPetgraphIndex};
use crate::math::NoTangents; use crate::math::NoTangents;
#[enum_dispatch] #[enum_dispatch]
@ -85,12 +85,12 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
} }
} }
pub fn remove_band(&mut self, band: BandIndex) { pub fn remove_band(&mut self, band: BandFirstSegIndex) {
match band { match band {
BandIndex::Straight(seg) => { BandFirstSegIndex::Straight(seg) => {
self.geometry_with_rtree.remove_seg(seg.into()); self.geometry_with_rtree.remove_seg(seg.into());
} }
BandIndex::Bended(first_loose_seg) => { BandFirstSegIndex::Bended(first_loose_seg) => {
let mut dots = vec![]; let mut dots = vec![];
let mut segs = vec![]; let mut segs = vec![];
let mut bends = vec![]; let mut bends = vec![];
@ -360,7 +360,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
let core = *self let core = *self
.geometry_with_rtree .geometry_with_rtree
.graph() .graph()
.neighbors(inner.node_index()) .neighbors(inner.petgraph_index())
.filter(|ni| { .filter(|ni| {
matches!( matches!(
self.geometry_with_rtree self.geometry_with_rtree
@ -368,7 +368,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
.edge_weight( .edge_weight(
self.geometry_with_rtree self.geometry_with_rtree
.graph() .graph()
.find_edge(inner.node_index(), *ni) .find_edge(inner.petgraph_index(), *ni)
.unwrap() .unwrap()
) )
.unwrap(), .unwrap(),

4
src/drawing/graph.rs
View File

@ -2,7 +2,7 @@ use enum_dispatch::enum_dispatch;
use petgraph::stable_graph::NodeIndex; use petgraph::stable_graph::NodeIndex;
use crate::{drawing::Drawing, graph::GetNodeIndex}; use crate::{drawing::Drawing, graph::GetPetgraphIndex};
use super::{ use super::{
bend::{FixedBendIndex, FixedBendWeight, LooseBendIndex, LooseBendWeight}, 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 // 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. // 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)] #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
pub enum PrimitiveIndex { pub enum PrimitiveIndex {
FixedDot(FixedDotIndex), FixedDot(FixedDotIndex),

12
src/drawing/loose.rs
View File

@ -10,7 +10,7 @@ use crate::{
primitive::{GetJoints, LoneLooseSeg, LooseBend, LooseDot, Primitive, SeqLooseSeg}, primitive::{GetJoints, LoneLooseSeg, LooseBend, LooseDot, Primitive, SeqLooseSeg},
seg::{LoneLooseSegIndex, SeqLooseSegIndex}, seg::{LoneLooseSegIndex, SeqLooseSegIndex},
}, },
graph::GetNodeIndex, graph::GetPetgraphIndex,
}; };
use super::rules::RulesTrait; use super::rules::RulesTrait;
@ -20,7 +20,7 @@ pub trait GetNextLoose {
fn next_loose(&self, maybe_prev: Option<LooseIndex>) -> Option<LooseIndex>; fn next_loose(&self, maybe_prev: Option<LooseIndex>) -> Option<LooseIndex>;
} }
#[enum_dispatch(GetNodeIndex, MakePrimitive)] #[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
pub enum LooseIndex { pub enum LooseIndex {
Dot(LooseDotIndex), Dot(LooseDotIndex),
@ -40,7 +40,7 @@ impl From<LooseIndex> for PrimitiveIndex {
} }
} }
#[enum_dispatch(GetNextLoose, GetDrawing, GetNodeIndex)] #[enum_dispatch(GetNextLoose, GetDrawing, GetPetgraphIndex)]
pub enum Loose<'a, CW: Copy, R: RulesTrait> { pub enum Loose<'a, CW: Copy, R: RulesTrait> {
Dot(LooseDot<'a, CW, R>), Dot(LooseDot<'a, CW, R>),
LoneSeg(LoneLooseSeg<'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!(); unreachable!();
}; };
if bend.node_index() != prev.node_index() { if bend.petgraph_index() != prev.petgraph_index() {
Some(bend.into()) Some(bend.into())
} else { } else {
self.seg().map(Into::into) 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()); return Some(ends.1.into());
}; };
if ends.0.node_index() != prev.node_index() { if ends.0.petgraph_index() != prev.petgraph_index() {
match ends.0 { match ends.0 {
DotIndex::Fixed(..) => None, DotIndex::Fixed(..) => None,
DotIndex::Loose(dot) => Some(dot.into()), DotIndex::Loose(dot) => Some(dot.into()),
@ -105,7 +105,7 @@ impl<'a, CW: Copy, R: RulesTrait> GetNextLoose for LooseBend<'a, CW, R> {
unreachable!(); unreachable!();
}; };
if ends.0.node_index() != prev.node_index() { if ends.0.petgraph_index() != prev.petgraph_index() {
Some(ends.0.into()) Some(ends.0.into())
} else { } else {
Some(ends.1.into()) Some(ends.1.into())

62
src/drawing/primitive.rs
View File

@ -15,7 +15,7 @@ use crate::{
Drawing, Drawing,
}, },
geometry::GenericNode, geometry::GenericNode,
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
}; };
#[enum_dispatch] #[enum_dispatch]
@ -55,10 +55,12 @@ pub trait GetInterior<T> {
fn interior(&self) -> Vec<T>; fn interior(&self) -> Vec<T>;
} }
pub trait GetOtherJoint<F: GetNodeIndex, T: GetNodeIndex + Into<F>>: GetJoints<F, T> { pub trait GetOtherJoint<F: GetPetgraphIndex, T: GetPetgraphIndex + Into<F>>:
GetJoints<F, T>
{
fn other_joint(&self, end: F) -> F { fn other_joint(&self, end: F) -> F {
let ends = self.joints(); let ends = self.joints();
if ends.0.node_index() != end.node_index() { if ends.0.petgraph_index() != end.petgraph_index() {
ends.0 ends.0
} else { } else {
ends.1.into() ends.1.into()
@ -70,12 +72,12 @@ pub trait GetJoints<F, T> {
fn joints(&self) -> (F, T); 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<LooseBendIndex> { fn first_rail(&self) -> Option<LooseBendIndex> {
self.drawing() self.drawing()
.geometry() .geometry()
.first_rail(self.node_index()) .first_rail(self.petgraph_index())
.map(|ni| LooseBendIndex::new(ni.node_index())) .map(|ni| LooseBendIndex::new(ni.petgraph_index()))
} }
} }
@ -89,7 +91,7 @@ pub trait GetCore<'a, R: RulesTrait>: GetDrawing<'a, R> + GetBendIndex {
self.drawing() self.drawing()
.geometry() .geometry()
.core(self.bend_index()) .core(self.bend_index())
.node_index(), .petgraph_index(),
) )
} }
} }
@ -99,14 +101,14 @@ pub trait GetInnerOuter<'a, R: RulesTrait>: GetDrawing<'a, R> + GetBendIndex {
self.drawing() self.drawing()
.geometry() .geometry()
.inner(self.bend_index()) .inner(self.bend_index())
.map(|ni| LooseBendIndex::new(ni.node_index())) .map(|ni| LooseBendIndex::new(ni.petgraph_index()))
} }
fn outer(&self) -> Option<LooseBendIndex> { fn outer(&self) -> Option<LooseBendIndex> {
self.drawing() self.drawing()
.geometry() .geometry()
.outer(self.bend_index()) .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 .drawing
.geometry() .geometry()
.graph() .graph()
.node_weight(self.index.node_index()) .node_weight(self.index.petgraph_index())
.unwrap() .unwrap()
{ {
weight weight
@ -203,7 +205,7 @@ impl<'a, W, CW: Copy, R: RulesTrait> GetInterior<PrimitiveIndex>
for GenericPrimitive<'a, W, CW, R> for GenericPrimitive<'a, W, CW, R>
{ {
fn interior(&self) -> Vec<PrimitiveIndex> { fn interior(&self) -> Vec<PrimitiveIndex> {
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> { impl<'a, W, CW: Copy, R: RulesTrait> GetPetgraphIndex for GenericPrimitive<'a, W, CW, R> {
fn node_index(&self) -> NodeIndex<usize> { fn petgraph_index(&self) -> NodeIndex<usize> {
self.index.node_index() self.index.petgraph_index()
} }
} }
@ -276,7 +278,7 @@ impl<'a, CW: Copy, R: RulesTrait> LooseDot<'a, CW, R> {
self.drawing self.drawing
.geometry() .geometry()
.joined_segs(self.index.into()) .joined_segs(self.index.into())
.map(|ni| SeqLooseSegIndex::new(ni.node_index())) .map(|ni| SeqLooseSegIndex::new(ni.petgraph_index()))
.next() .next()
} }
@ -284,7 +286,7 @@ impl<'a, CW: Copy, R: RulesTrait> LooseDot<'a, CW, R> {
self.drawing self.drawing
.geometry() .geometry()
.joined_bends(self.index.into()) .joined_bends(self.index.into())
.map(|ni| LooseBendIndex::new(ni.node_index())) .map(|ni| LooseBendIndex::new(ni.petgraph_index()))
.next() .next()
.unwrap() .unwrap()
} }
@ -325,8 +327,8 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints<FixedDotIndex, FixedDotIndex> for Fi
fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { fn joints(&self) -> (FixedDotIndex, FixedDotIndex) {
let (from, to) = self.drawing.geometry().seg_joints(self.index.into()); let (from, to) = self.drawing.geometry().seg_joints(self.index.into());
( (
FixedDotIndex::new(from.node_index()), FixedDotIndex::new(from.petgraph_index()),
FixedDotIndex::new(to.node_index()), FixedDotIndex::new(to.petgraph_index()),
) )
} }
} }
@ -353,8 +355,8 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints<FixedDotIndex, FixedDotIndex>
fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { fn joints(&self) -> (FixedDotIndex, FixedDotIndex) {
let (from, to) = self.drawing.geometry().seg_joints(self.index.into()); let (from, to) = self.drawing.geometry().seg_joints(self.index.into());
( (
FixedDotIndex::new(from.node_index()), FixedDotIndex::new(from.petgraph_index()),
FixedDotIndex::new(to.node_index()), FixedDotIndex::new(to.petgraph_index()),
) )
} }
} }
@ -380,18 +382,18 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints<DotIndex, LooseDotIndex> for SeqLoos
let joints = self.drawing.geometry().seg_joints(self.index.into()); let joints = self.drawing.geometry().seg_joints(self.index.into());
if let DotWeight::Fixed(..) = self.drawing.geometry().dot_weight(joints.0) { if let DotWeight::Fixed(..) = self.drawing.geometry().dot_weight(joints.0) {
( (
FixedDotIndex::new(joints.0.node_index()).into(), FixedDotIndex::new(joints.0.petgraph_index()).into(),
LooseDotIndex::new(joints.1.node_index()).into(), LooseDotIndex::new(joints.1.petgraph_index()).into(),
) )
} else if let DotWeight::Fixed(..) = self.drawing.geometry().dot_weight(joints.1) { } else if let DotWeight::Fixed(..) = self.drawing.geometry().dot_weight(joints.1) {
( (
FixedDotIndex::new(joints.1.node_index()).into(), FixedDotIndex::new(joints.1.petgraph_index()).into(),
LooseDotIndex::new(joints.0.node_index()), LooseDotIndex::new(joints.0.petgraph_index()),
) )
} else { } else {
( (
LooseDotIndex::new(joints.0.node_index()).into(), LooseDotIndex::new(joints.0.petgraph_index()).into(),
LooseDotIndex::new(joints.1.node_index()).into(), LooseDotIndex::new(joints.1.petgraph_index()).into(),
) )
} }
} }
@ -423,8 +425,8 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints<FixedDotIndex, FixedDotIndex> for Fi
fn joints(&self) -> (FixedDotIndex, FixedDotIndex) { fn joints(&self) -> (FixedDotIndex, FixedDotIndex) {
let (from, to) = self.drawing.geometry().bend_joints(self.index.into()); let (from, to) = self.drawing.geometry().bend_joints(self.index.into());
( (
FixedDotIndex::new(from.node_index()), FixedDotIndex::new(from.petgraph_index()),
FixedDotIndex::new(to.node_index()), FixedDotIndex::new(to.petgraph_index()),
) )
} }
} }
@ -470,8 +472,8 @@ impl<'a, CW: Copy, R: RulesTrait> GetJoints<LooseDotIndex, LooseDotIndex> for Lo
fn joints(&self) -> (LooseDotIndex, LooseDotIndex) { fn joints(&self) -> (LooseDotIndex, LooseDotIndex) {
let (from, to) = self.drawing.geometry().bend_joints(self.index.into()); let (from, to) = self.drawing.geometry().bend_joints(self.index.into());
( (
LooseDotIndex::new(from.node_index()), LooseDotIndex::new(from.petgraph_index()),
LooseDotIndex::new(to.node_index()), LooseDotIndex::new(to.petgraph_index()),
) )
} }
} }

4
src/drawing/seg.rs
View File

@ -8,12 +8,12 @@ use crate::{
Drawing, Drawing,
}, },
geometry::{GetWidth, SegWeightTrait}, geometry::{GetWidth, SegWeightTrait},
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
}; };
use petgraph::stable_graph::NodeIndex; use petgraph::stable_graph::NodeIndex;
#[enum_dispatch(GetNodeIndex, MakePrimitive)] #[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
pub enum SegIndex { pub enum SegIndex {
Fixed(FixedSegIndex), Fixed(FixedSegIndex),

8
src/drawing/wraparoundable.rs
View File

@ -10,15 +10,15 @@ use crate::{
rules::RulesTrait, rules::RulesTrait,
Drawing, Drawing,
}, },
graph::GetNodeIndex, graph::GetPetgraphIndex,
}; };
#[enum_dispatch] #[enum_dispatch]
pub trait GetWraparound: GetNodeIndex { pub trait GetWraparound: GetPetgraphIndex {
fn wraparound(&self) -> Option<LooseBendIndex>; fn wraparound(&self) -> Option<LooseBendIndex>;
} }
#[enum_dispatch(GetNodeIndex, MakePrimitive)] #[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
pub enum WraparoundableIndex { pub enum WraparoundableIndex {
FixedDot(FixedDotIndex), FixedDot(FixedDotIndex),
@ -45,7 +45,7 @@ impl From<BendIndex> for WraparoundableIndex {
} }
} }
#[enum_dispatch(GetWraparound, GetDrawing, GetNodeIndex)] #[enum_dispatch(GetWraparound, GetDrawing, GetPetgraphIndex)]
pub enum Wraparoundable<'a, CW: Copy, R: RulesTrait> { pub enum Wraparoundable<'a, CW: Copy, R: RulesTrait> {
FixedDot(FixedDot<'a, CW, R>), FixedDot(FixedDot<'a, CW, R>),
FixedBend(FixedBend<'a, CW, R>), FixedBend(FixedBend<'a, CW, R>),

4
src/geometry/compound.rs
View File

@ -1,6 +1,6 @@
use crate::graph::{GenericIndex, GetNodeIndex}; use crate::graph::{GenericIndex, GetPetgraphIndex};
pub trait CompoundManagerTrait<CW: Copy, GI: GetNodeIndex + Copy> { pub trait CompoundManagerTrait<CW: Copy, GI: GetPetgraphIndex + Copy> {
fn add_compound(&mut self, weight: CW) -> GenericIndex<CW>; fn add_compound(&mut self, weight: CW) -> GenericIndex<CW>;
fn remove_compound(&mut self, compound: GenericIndex<CW>); fn remove_compound(&mut self, compound: GenericIndex<CW>);
fn add_to_compound<W>(&mut self, node: GenericIndex<W>, compound: GenericIndex<CW>); fn add_to_compound<W>(&mut self, node: GenericIndex<W>, compound: GenericIndex<CW>);

133
src/geometry/geometry.rs
View File

@ -21,7 +21,7 @@ use crate::{
compound::CompoundManagerTrait, compound::CompoundManagerTrait,
primitive::{BendShape, DotShape, PrimitiveShape, SegShape}, primitive::{BendShape, DotShape, PrimitiveShape, SegShape},
}, },
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
math::Circle, math::Circle,
}; };
@ -75,10 +75,10 @@ pub struct Geometry<
SW: SegWeightTrait<PW>, SW: SegWeightTrait<PW>,
BW: BendWeightTrait<PW>, BW: BendWeightTrait<PW>,
CW: Copy, CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy, PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetNodeIndex + Into<PI> + Copy, DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy, SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy, BI: GetPetgraphIndex + Into<PI> + Copy,
> { > {
graph: StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize>, graph: StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize>,
weight_marker: PhantomData<PW>, weight_marker: PhantomData<PW>,
@ -98,10 +98,10 @@ impl<
SW: SegWeightTrait<PW>, SW: SegWeightTrait<PW>,
BW: BendWeightTrait<PW>, BW: BendWeightTrait<PW>,
CW: Copy, CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy, PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetNodeIndex + Into<PI> + Copy, DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy, SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy, BI: GetPetgraphIndex + Into<PI> + Copy,
> Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI> > Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{ {
pub fn new() -> Self { pub fn new() -> Self {
@ -132,10 +132,16 @@ impl<
let seg = let seg =
GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into()))); GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into())));
self.graph self.graph.update_edge(
.update_edge(from.node_index(), seg.node_index(), GeometryLabel::Joined); from.petgraph_index(),
self.graph seg.petgraph_index(),
.update_edge(seg.node_index(), to.node_index(), GeometryLabel::Joined); GeometryLabel::Joined,
);
self.graph.update_edge(
seg.petgraph_index(),
to.petgraph_index(),
GeometryLabel::Joined,
);
seg seg
} }
@ -150,31 +156,40 @@ impl<
let bend = let bend =
GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into()))); GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into())));
self.graph self.graph.update_edge(
.update_edge(from.node_index(), bend.node_index(), GeometryLabel::Joined); from.petgraph_index(),
self.graph bend.petgraph_index(),
.update_edge(bend.node_index(), to.node_index(), GeometryLabel::Joined); GeometryLabel::Joined,
self.graph );
.update_edge(bend.node_index(), core.node_index(), GeometryLabel::Core); 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 bend
} }
pub fn remove_primitive(&mut self, primitive: PI) { 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) { pub fn move_dot(&mut self, dot: DI, to: Point) {
let mut weight = self.dot_weight(dot); let mut weight = self.dot_weight(dot);
weight.set_pos(to); 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()); GenericNode::Primitive(weight.into());
} }
pub fn shift_bend(&mut self, bend: BI, offset: f64) { pub fn shift_bend(&mut self, bend: BI, offset: f64) {
let mut weight = self.bend_weight(bend); let mut weight = self.bend_weight(bend);
weight.set_offset(offset); 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()); GenericNode::Primitive(weight.into());
} }
@ -184,7 +199,7 @@ impl<
.graph .graph
.remove_edge( .remove_edge(
self.graph self.graph
.find_edge(from.node_index(), bend.node_index()) .find_edge(from.petgraph_index(), bend.petgraph_index())
.unwrap(), .unwrap(),
) )
.unwrap(); .unwrap();
@ -192,20 +207,20 @@ impl<
.graph .graph
.remove_edge( .remove_edge(
self.graph self.graph
.find_edge(bend.node_index(), to.node_index()) .find_edge(bend.petgraph_index(), to.petgraph_index())
.unwrap(), .unwrap(),
) )
.unwrap(); .unwrap();
self.graph 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 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<BI>) { pub fn reattach_bend(&mut self, bend: BI, maybe_new_inner: Option<BI>) {
if let Some(old_inner_edge) = self if let Some(old_inner_edge) = self
.graph .graph
.edges_directed(bend.node_index(), Incoming) .edges_directed(bend.petgraph_index(), Incoming)
.filter(|edge| *edge.weight() == GeometryLabel::Outer) .filter(|edge| *edge.weight() == GeometryLabel::Outer)
.next() .next()
{ {
@ -214,8 +229,8 @@ impl<
if let Some(new_inner) = maybe_new_inner { if let Some(new_inner) = maybe_new_inner {
self.graph.update_edge( self.graph.update_edge(
new_inner.node_index(), new_inner.petgraph_index(),
bend.node_index(), bend.petgraph_index(),
GeometryLabel::Outer, GeometryLabel::Outer,
); );
} }
@ -236,7 +251,7 @@ impl<
PrimitiveShape::Seg(SegShape { PrimitiveShape::Seg(SegShape {
from: self.dot_weight(from).pos(), from: self.dot_weight(from).pos(),
to: self.dot_weight(to).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(), pos: core_weight.pos(),
r: self.inner_radius(bend), 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 { pub fn dot_weight(&self, dot: DI) -> DW {
self.primitive_weight(dot.node_index()) self.primitive_weight(dot.petgraph_index())
.try_into() .try_into()
.unwrap_or_else(|_| unreachable!()) .unwrap_or_else(|_| unreachable!())
} }
pub fn seg_weight(&self, seg: SI) -> SW { pub fn seg_weight(&self, seg: SI) -> SW {
self.primitive_weight(seg.node_index()) self.primitive_weight(seg.petgraph_index())
.try_into() .try_into()
.unwrap_or_else(|_| unreachable!()) .unwrap_or_else(|_| unreachable!())
} }
pub fn bend_weight(&self, bend: BI) -> BW { pub fn bend_weight(&self, bend: BI) -> BW {
self.primitive_weight(bend.node_index()) self.primitive_weight(bend.petgraph_index())
.try_into() .try_into()
.unwrap_or_else(|_| unreachable!()) .unwrap_or_else(|_| unreachable!())
} }
pub fn compound_weight(&self, compound: GenericIndex<CW>) -> CW { pub fn compound_weight(&self, compound: GenericIndex<CW>) -> CW {
if let GenericNode::Compound(weight) = if let GenericNode::Compound(weight) =
*self.graph.node_weight(compound.node_index()).unwrap() *self.graph.node_weight(compound.petgraph_index()).unwrap()
{ {
weight weight
} else { } else {
@ -308,11 +323,11 @@ impl<
fn core_weight(&self, bend: BI) -> DW { fn core_weight(&self, bend: BI) -> DW {
self.graph self.graph
.neighbors(bend.node_index()) .neighbors(bend.petgraph_index())
.filter(|ni| { .filter(|ni| {
matches!( matches!(
self.graph 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(), .unwrap(),
GeometryLabel::Core GeometryLabel::Core
) )
@ -348,11 +363,11 @@ impl<
pub fn core(&self, bend: BI) -> DI { pub fn core(&self, bend: BI) -> DI {
self.graph self.graph
.neighbors(bend.node_index()) .neighbors(bend.petgraph_index())
.filter(|ni| { .filter(|ni| {
matches!( matches!(
self.graph 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(), .unwrap(),
GeometryLabel::Core GeometryLabel::Core
) )
@ -369,11 +384,11 @@ impl<
pub fn inner(&self, bend: BI) -> Option<BI> { pub fn inner(&self, bend: BI) -> Option<BI> {
self.graph self.graph
.neighbors_directed(bend.node_index(), Incoming) .neighbors_directed(bend.petgraph_index(), Incoming)
.filter(|ni| { .filter(|ni| {
matches!( matches!(
self.graph 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(), .unwrap(),
GeometryLabel::Outer GeometryLabel::Outer
) )
@ -389,11 +404,11 @@ impl<
pub fn outer(&self, bend: BI) -> Option<BI> { pub fn outer(&self, bend: BI) -> Option<BI> {
self.graph self.graph
.neighbors(bend.node_index()) .neighbors(bend.petgraph_index())
.filter(|ni| { .filter(|ni| {
matches!( matches!(
self.graph 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(), .unwrap(),
GeometryLabel::Outer GeometryLabel::Outer
) )
@ -409,13 +424,13 @@ impl<
pub fn joineds(&self, node: PI) -> impl Iterator<Item = PI> + '_ { pub fn joineds(&self, node: PI) -> impl Iterator<Item = PI> + '_ {
self.graph self.graph
.neighbors_undirected(node.node_index()) .neighbors_undirected(node.petgraph_index())
.filter(move |ni| { .filter(move |ni| {
matches!( matches!(
self.graph self.graph
.edge_weight( .edge_weight(
self.graph self.graph
.find_edge_undirected(node.node_index(), *ni) .find_edge_undirected(node.petgraph_index(), *ni)
.unwrap() .unwrap()
.0, .0,
) )
@ -457,11 +472,15 @@ impl<
pub fn compound_members(&self, compound: GenericIndex<CW>) -> impl Iterator<Item = PI> + '_ { pub fn compound_members(&self, compound: GenericIndex<CW>) -> impl Iterator<Item = PI> + '_ {
self.graph self.graph
.neighbors_directed(compound.node_index(), Incoming) .neighbors_directed(compound.petgraph_index(), Incoming)
.filter(move |ni| { .filter(move |ni| {
matches!( matches!(
self.graph 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(), .unwrap(),
GeometryLabel::Compound GeometryLabel::Compound
) )
@ -485,10 +504,10 @@ impl<
SW: SegWeightTrait<PW>, SW: SegWeightTrait<PW>,
BW: BendWeightTrait<PW>, BW: BendWeightTrait<PW>,
CW: Copy, CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy, PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetNodeIndex + Into<PI> + Copy, DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy, SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy, BI: GetPetgraphIndex + Into<PI> + Copy,
> CompoundManagerTrait<CW, GenericIndex<CW>> for Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI> > CompoundManagerTrait<CW, GenericIndex<CW>> for Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{ {
fn add_compound(&mut self, weight: CW) -> GenericIndex<CW> { fn add_compound(&mut self, weight: CW) -> GenericIndex<CW> {
@ -496,20 +515,20 @@ impl<
} }
fn remove_compound(&mut self, compound: GenericIndex<CW>) { fn remove_compound(&mut self, compound: GenericIndex<CW>) {
self.graph.remove_node(compound.node_index()); self.graph.remove_node(compound.petgraph_index());
} }
fn add_to_compound<W>(&mut self, primitive: GenericIndex<W>, compound: GenericIndex<CW>) { fn add_to_compound<W>(&mut self, primitive: GenericIndex<W>, compound: GenericIndex<CW>) {
self.graph.update_edge( self.graph.update_edge(
primitive.node_index(), primitive.petgraph_index(),
compound.node_index(), compound.petgraph_index(),
GeometryLabel::Compound, GeometryLabel::Compound,
); );
} }
fn compound_weight(&self, compound: GenericIndex<CW>) -> CW { fn compound_weight(&self, compound: GenericIndex<CW>) -> CW {
if let GenericNode::Compound(weight) = if let GenericNode::Compound(weight) =
*self.graph.node_weight(compound.node_index()).unwrap() *self.graph.node_weight(compound.petgraph_index()).unwrap()
{ {
weight weight
} else { } else {
@ -519,11 +538,11 @@ impl<
fn compounds<W>(&self, node: GenericIndex<W>) -> impl Iterator<Item = GenericIndex<CW>> { fn compounds<W>(&self, node: GenericIndex<W>) -> impl Iterator<Item = GenericIndex<CW>> {
self.graph self.graph
.neighbors(node.node_index()) .neighbors(node.petgraph_index())
.filter(move |ni| { .filter(move |ni| {
matches!( matches!(
self.graph 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(), .unwrap(),
GeometryLabel::Compound GeometryLabel::Compound
) )

34
src/geometry/with_rtree.rs
View File

@ -13,7 +13,7 @@ use crate::{
BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetWidth, BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetWidth,
SegWeightTrait, SegWeightTrait,
}, },
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
}; };
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
@ -43,10 +43,10 @@ pub struct GeometryWithRtree<
SW: SegWeightTrait<PW> + GetLayer, SW: SegWeightTrait<PW> + GetLayer,
BW: BendWeightTrait<PW> + GetLayer, BW: BendWeightTrait<PW> + GetLayer,
CW: Copy, CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy, PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetNodeIndex + Into<PI> + Copy, DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy, SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy, BI: GetPetgraphIndex + Into<PI> + Copy,
> { > {
geometry: Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>, geometry: Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>,
rtree: RTree<BboxedIndex<GenericNode<PI, GenericIndex<CW>>>>, rtree: RTree<BboxedIndex<GenericNode<PI, GenericIndex<CW>>>>,
@ -69,10 +69,10 @@ impl<
SW: SegWeightTrait<PW> + GetLayer, SW: SegWeightTrait<PW> + GetLayer,
BW: BendWeightTrait<PW> + GetLayer, BW: BendWeightTrait<PW> + GetLayer,
CW: Copy, CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy, PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetNodeIndex + Into<PI> + Copy, DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy, SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy, BI: GetPetgraphIndex + Into<PI> + Copy,
> GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI> > GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{ {
pub fn new(layer_count: usize) -> Self { pub fn new(layer_count: usize) -> Self {
@ -259,10 +259,10 @@ impl<
SW: SegWeightTrait<PW> + GetLayer, SW: SegWeightTrait<PW> + GetLayer,
BW: BendWeightTrait<PW> + GetLayer, BW: BendWeightTrait<PW> + GetLayer,
CW: Copy, CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy, PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetNodeIndex + Into<PI> + Copy, DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy, SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy, BI: GetPetgraphIndex + Into<PI> + Copy,
> GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI> > GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{ {
fn make_bbox(&self, primitive: PI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> { fn make_bbox(&self, primitive: PI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
@ -390,10 +390,10 @@ impl<
SW: SegWeightTrait<PW> + GetLayer, SW: SegWeightTrait<PW> + GetLayer,
BW: BendWeightTrait<PW> + GetLayer, BW: BendWeightTrait<PW> + GetLayer,
CW: Copy, CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy, PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetNodeIndex + Into<PI> + Copy, DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy, SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy, BI: GetPetgraphIndex + Into<PI> + Copy,
> CompoundManagerTrait<CW, GenericIndex<CW>> > CompoundManagerTrait<CW, GenericIndex<CW>>
for GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI> for GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{ {

8
src/graph.rs
View File

@ -9,8 +9,8 @@ use petgraph::stable_graph::NodeIndex;
// Due to apparent limitations of enum_dispatch we're forced to import some types backwards. // Due to apparent limitations of enum_dispatch we're forced to import some types backwards.
#[enum_dispatch] #[enum_dispatch]
pub trait GetNodeIndex { pub trait GetPetgraphIndex {
fn node_index(&self) -> NodeIndex<usize>; fn petgraph_index(&self) -> NodeIndex<usize>;
} }
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
@ -42,8 +42,8 @@ impl<W> PartialEq for GenericIndex<W> {
impl<W> Eq for GenericIndex<W> {} impl<W> Eq for GenericIndex<W> {}
impl<W> GetNodeIndex for GenericIndex<W> { impl<W> GetPetgraphIndex for GenericIndex<W> {
fn node_index(&self) -> NodeIndex<usize> { fn petgraph_index(&self) -> NodeIndex<usize> {
self.node_index self.node_index
} }
} }

24
src/layout/layout.rs
View File

@ -5,7 +5,7 @@ use rstar::AABB;
use crate::{ use crate::{
drawing::{ drawing::{
band::BandIndex, band::BandFirstSegIndex,
bend::LooseBendWeight, bend::LooseBendWeight,
cane::Cane, cane::Cane,
dot::{DotIndex, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight}, dot::{DotIndex, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight},
@ -20,7 +20,7 @@ use crate::{
Drawing, Infringement, LayoutException, Drawing, Infringement, LayoutException,
}, },
geometry::{compound::CompoundManagerTrait, primitive::PrimitiveShapeTrait, GenericNode}, geometry::{compound::CompoundManagerTrait, primitive::PrimitiveShapeTrait, GenericNode},
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
layout::{ layout::{
via::{Via, ViaWeight}, via::{Via, ViaWeight},
zone::{Zone, ZoneWeight}, zone::{Zone, ZoneWeight},
@ -46,7 +46,7 @@ impl<R: RulesTrait> Layout<R> {
Self { drawing } Self { drawing }
} }
pub fn remove_band(&mut self, band: BandIndex) { pub fn remove_band(&mut self, band: BandFirstSegIndex) {
self.drawing.remove_band(band); self.drawing.remove_band(band);
} }
@ -97,7 +97,7 @@ impl<R: RulesTrait> Layout<R> {
} }
} }
Ok(GenericIndex::<ViaWeight>::new(compound.node_index())) Ok(GenericIndex::<ViaWeight>::new(compound.petgraph_index()))
} }
pub fn add_fixed_dot(&mut self, weight: FixedDotWeight) -> Result<FixedDotIndex, Infringement> { pub fn add_fixed_dot(&mut self, weight: FixedDotWeight) -> Result<FixedDotIndex, Infringement> {
@ -204,7 +204,7 @@ impl<R: RulesTrait> Layout<R> {
GenericIndex::<ZoneWeight>::new( GenericIndex::<ZoneWeight>::new(
self.drawing self.drawing
.add_compound(CompoundWeight::Zone(weight)) .add_compound(CompoundWeight::Zone(weight))
.node_index(), .petgraph_index(),
) )
} }
@ -215,10 +215,12 @@ impl<R: RulesTrait> Layout<R> {
self.drawing.compounds(node) self.drawing.compounds(node)
} }
pub fn band_length(&self, band: BandIndex) -> f64 { pub fn band_length(&self, band: BandFirstSegIndex) -> f64 {
match band { match band {
BandIndex::Straight(seg) => self.drawing.geometry().seg_shape(seg.into()).length(), BandFirstSegIndex::Straight(seg) => {
BandIndex::Bended(start_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 mut length = self.drawing.geometry().seg_shape(start_seg.into()).length();
let start_dot = self.drawing.primitive(start_seg).joints().1; let start_dot = self.drawing.primitive(start_seg).joints().1;
@ -249,7 +251,7 @@ impl<R: RulesTrait> Layout<R> {
self.drawing.rtree().iter().filter_map(|wrapper| { self.drawing.rtree().iter().filter_map(|wrapper| {
if let NodeIndex::Compound(compound) = wrapper.data { if let NodeIndex::Compound(compound) = wrapper.data {
if let CompoundWeight::Zone(..) = self.drawing.compound_weight(compound) { if let CompoundWeight::Zone(..) = self.drawing.compound_weight(compound) {
return Some(GenericIndex::<ZoneWeight>::new(compound.node_index())); return Some(GenericIndex::<ZoneWeight>::new(compound.petgraph_index()));
} }
} }
@ -270,7 +272,7 @@ impl<R: RulesTrait> Layout<R> {
.filter_map(|wrapper| { .filter_map(|wrapper| {
if let NodeIndex::Compound(compound) = wrapper.data { if let NodeIndex::Compound(compound) = wrapper.data {
if let CompoundWeight::Zone(..) = self.drawing.compound_weight(compound) { if let CompoundWeight::Zone(..) = self.drawing.compound_weight(compound) {
return Some(GenericIndex::<ZoneWeight>::new(compound.node_index())); return Some(GenericIndex::<ZoneWeight>::new(compound.petgraph_index()));
} }
} }
@ -284,7 +286,7 @@ impl<R: RulesTrait> Layout<R> {
) -> impl Iterator<Item = PrimitiveIndex> + '_ { ) -> impl Iterator<Item = PrimitiveIndex> + '_ {
self.drawing self.drawing
.geometry() .geometry()
.compound_members(GenericIndex::new(zone.node_index())) .compound_members(GenericIndex::new(zone.petgraph_index()))
} }
pub fn drawing(&self) -> &Drawing<CompoundWeight, R> { pub fn drawing(&self) -> &Drawing<CompoundWeight, R> {

4
src/layout/via.rs
View File

@ -6,7 +6,7 @@ use crate::{
compound::CompoundManagerTrait, compound::CompoundManagerTrait,
primitive::{DotShape, PrimitiveShape}, primitive::{DotShape, PrimitiveShape},
}, },
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
layout::{CompoundWeight, Layout}, layout::{CompoundWeight, Layout},
math::Circle, math::Circle,
}; };
@ -54,7 +54,7 @@ pub struct ViaWeight {
impl From<GenericIndex<ViaWeight>> for GenericIndex<CompoundWeight> { impl From<GenericIndex<ViaWeight>> for GenericIndex<CompoundWeight> {
fn from(via: GenericIndex<ViaWeight>) -> Self { fn from(via: GenericIndex<ViaWeight>) -> Self {
GenericIndex::<CompoundWeight>::new(via.node_index()) GenericIndex::<CompoundWeight>::new(via.petgraph_index())
} }
} }

8
src/layout/zone.rs
View File

@ -11,7 +11,7 @@ use crate::{
seg::SegIndex, seg::SegIndex,
}, },
geometry::{compound::CompoundManagerTrait, poly::PolyShape, GetPos}, geometry::{compound::CompoundManagerTrait, poly::PolyShape, GetPos},
graph::{GenericIndex, GetNodeIndex}, graph::{GenericIndex, GetPetgraphIndex},
layout::{CompoundWeight, Layout}, layout::{CompoundWeight, Layout},
}; };
@ -130,7 +130,7 @@ pub enum ZoneWeight {
impl From<GenericIndex<ZoneWeight>> for GenericIndex<CompoundWeight> { impl From<GenericIndex<ZoneWeight>> for GenericIndex<CompoundWeight> {
fn from(zone: GenericIndex<ZoneWeight>) -> Self { fn from(zone: GenericIndex<ZoneWeight>) -> Self {
GenericIndex::<CompoundWeight>::new(zone.node_index()) GenericIndex::<CompoundWeight>::new(zone.petgraph_index())
} }
} }
@ -154,7 +154,7 @@ impl GetMaybeNet for SolidZoneWeight {
impl From<GenericIndex<SolidZoneWeight>> for GenericIndex<CompoundWeight> { impl From<GenericIndex<SolidZoneWeight>> for GenericIndex<CompoundWeight> {
fn from(zone: GenericIndex<SolidZoneWeight>) -> Self { fn from(zone: GenericIndex<SolidZoneWeight>) -> Self {
GenericIndex::<CompoundWeight>::new(zone.node_index()) GenericIndex::<CompoundWeight>::new(zone.petgraph_index())
} }
} }
@ -178,6 +178,6 @@ impl<'a> GetMaybeNet for PourZoneWeight {
impl From<GenericIndex<PourZoneWeight>> for GenericIndex<CompoundWeight> { impl From<GenericIndex<PourZoneWeight>> for GenericIndex<CompoundWeight> {
fn from(zone: GenericIndex<PourZoneWeight>) -> Self { fn from(zone: GenericIndex<PourZoneWeight>) -> Self {
GenericIndex::<CompoundWeight>::new(zone.node_index()) GenericIndex::<CompoundWeight>::new(zone.petgraph_index())
} }
} }

10
src/router/draw.rs
View File

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

94
src/router/navmesh.rs
View File

@ -19,55 +19,55 @@ use crate::{
rules::RulesTrait, rules::RulesTrait,
Drawing, Drawing,
}, },
graph::GetNodeIndex, graph::GetPetgraphIndex,
layout::Layout, 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)] #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
pub enum NavvertexIndex { pub enum NavvertexNodeIndex {
FixedDot(FixedDotIndex), FixedDot(FixedDotIndex),
FixedBend(FixedBendIndex), FixedBend(FixedBendIndex),
LooseBend(LooseBendIndex), LooseBend(LooseBendIndex),
} }
#[enum_dispatch(GetNodeIndex, MakePrimitive)] #[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
enum TrianvertexIndex { enum TrianvertexNodeIndex {
FixedDot(FixedDotIndex), FixedDot(FixedDotIndex),
FixedBend(FixedBendIndex), FixedBend(FixedBendIndex),
} }
impl From<NavvertexIndex> for PrimitiveIndex { impl From<NavvertexNodeIndex> for PrimitiveIndex {
fn from(vertex: NavvertexIndex) -> Self { fn from(vertex: NavvertexNodeIndex) -> Self {
match vertex { match vertex {
NavvertexIndex::FixedDot(dot) => PrimitiveIndex::FixedDot(dot), NavvertexNodeIndex::FixedDot(dot) => PrimitiveIndex::FixedDot(dot),
NavvertexIndex::FixedBend(bend) => PrimitiveIndex::FixedBend(bend), NavvertexNodeIndex::FixedBend(bend) => PrimitiveIndex::FixedBend(bend),
NavvertexIndex::LooseBend(bend) => PrimitiveIndex::LooseBend(bend), NavvertexNodeIndex::LooseBend(bend) => PrimitiveIndex::LooseBend(bend),
} }
} }
} }
impl From<TrianvertexIndex> for NavvertexIndex { impl From<TrianvertexNodeIndex> for NavvertexNodeIndex {
fn from(vertex: TrianvertexIndex) -> Self { fn from(vertex: TrianvertexNodeIndex) -> Self {
match vertex { match vertex {
TrianvertexIndex::FixedDot(dot) => NavvertexIndex::FixedDot(dot), TrianvertexNodeIndex::FixedDot(dot) => NavvertexNodeIndex::FixedDot(dot),
TrianvertexIndex::FixedBend(bend) => NavvertexIndex::FixedBend(bend), TrianvertexNodeIndex::FixedBend(bend) => NavvertexNodeIndex::FixedBend(bend),
} }
} }
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
struct TrianvertexWeight { struct TrianvertexWeight {
trianvertex: TrianvertexIndex, node: TrianvertexNodeIndex,
rails: Vec<LooseBendIndex>, rails: Vec<LooseBendIndex>,
pos: Point, pos: Point,
} }
impl GetTrianvertexIndex<TrianvertexIndex> for TrianvertexWeight { impl GetTrianvertexNodeIndex<TrianvertexNodeIndex> for TrianvertexWeight {
fn trianvertex_index(&self) -> TrianvertexIndex { fn node_index(&self) -> TrianvertexNodeIndex {
self.trianvertex self.node
} }
} }
@ -80,8 +80,8 @@ impl HasPosition for TrianvertexWeight {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Navmesh { pub struct Navmesh {
triangulation: Triangulation<TrianvertexIndex, TrianvertexWeight, ()>, triangulation: Triangulation<TrianvertexNodeIndex, TrianvertexWeight, ()>,
navvertex_to_trianvertex: Vec<Option<TrianvertexIndex>>, navvertex_to_trianvertex: Vec<Option<TrianvertexNodeIndex>>,
source: FixedDotIndex, source: FixedDotIndex,
target: FixedDotIndex, target: FixedDotIndex,
} }
@ -121,14 +121,14 @@ impl Navmesh {
match node { match node {
PrimitiveIndex::FixedDot(dot) => { PrimitiveIndex::FixedDot(dot) => {
this.triangulation.add_vertex(TrianvertexWeight { this.triangulation.add_vertex(TrianvertexWeight {
trianvertex: dot.into(), node: dot.into(),
rails: vec![], rails: vec![],
pos: primitive.shape().center(), pos: primitive.shape().center(),
})?; })?;
} }
PrimitiveIndex::FixedBend(bend) => { PrimitiveIndex::FixedBend(bend) => {
this.triangulation.add_vertex(TrianvertexWeight { this.triangulation.add_vertex(TrianvertexWeight {
trianvertex: bend.into(), node: bend.into(),
rails: vec![], rails: vec![],
pos: primitive.shape().center(), pos: primitive.shape().center(),
})?; })?;
@ -147,7 +147,7 @@ impl Navmesh {
.weight_mut(layout.drawing().primitive(bend).core().into()) .weight_mut(layout.drawing().primitive(bend).core().into())
.rails .rails
.push(bend.into()); .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()); Some(layout.drawing().primitive(bend).core().into());
} }
_ => (), _ => (),
@ -157,12 +157,12 @@ impl Navmesh {
Ok(this) Ok(this)
} }
fn triangulation_vertex(&self, vertex: NavvertexIndex) -> TrianvertexIndex { fn trianvertex(&self, vertex: NavvertexNodeIndex) -> TrianvertexNodeIndex {
match vertex { match vertex {
NavvertexIndex::FixedDot(dot) => TrianvertexIndex::FixedDot(dot), NavvertexNodeIndex::FixedDot(dot) => TrianvertexNodeIndex::FixedDot(dot),
NavvertexIndex::FixedBend(bend) => TrianvertexIndex::FixedBend(bend), NavvertexNodeIndex::FixedBend(bend) => TrianvertexNodeIndex::FixedBend(bend),
NavvertexIndex::LooseBend(bend) => { NavvertexNodeIndex::LooseBend(bend) => {
self.navvertex_to_trianvertex[bend.node_index().index()].unwrap() self.navvertex_to_trianvertex[bend.petgraph_index().index()].unwrap()
} }
} }
} }
@ -177,8 +177,8 @@ impl Navmesh {
} }
impl visit::GraphBase for Navmesh { impl visit::GraphBase for Navmesh {
type NodeId = NavvertexIndex; type NodeId = NavvertexNodeIndex;
type EdgeId = (NavvertexIndex, NavvertexIndex); type EdgeId = (NavvertexNodeIndex, NavvertexNodeIndex);
} }
impl visit::Data for Navmesh { impl visit::Data for Navmesh {
@ -188,13 +188,13 @@ impl visit::Data for Navmesh {
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
pub struct NavmeshEdgeReference { pub struct NavmeshEdgeReference {
from: NavvertexIndex, from: NavvertexNodeIndex,
to: NavvertexIndex, to: NavvertexNodeIndex,
} }
impl visit::EdgeRef for NavmeshEdgeReference { impl visit::EdgeRef for NavmeshEdgeReference {
type NodeId = NavvertexIndex; type NodeId = NavvertexNodeIndex;
type EdgeId = (NavvertexIndex, NavvertexIndex); type EdgeId = (NavvertexNodeIndex, NavvertexNodeIndex);
type Weight = (); type Weight = ();
fn source(&self) -> Self::NodeId { fn source(&self) -> Self::NodeId {
@ -215,19 +215,19 @@ impl visit::EdgeRef for NavmeshEdgeReference {
} }
impl<'a> visit::IntoNeighbors for &'a Navmesh { impl<'a> visit::IntoNeighbors for &'a Navmesh {
type Neighbors = Box<dyn Iterator<Item = NavvertexIndex> + 'a>; type Neighbors = Box<dyn Iterator<Item = NavvertexNodeIndex> + 'a>;
fn neighbors(self, vertex: Self::NodeId) -> Self::Neighbors { fn neighbors(self, vertex: Self::NodeId) -> Self::Neighbors {
Box::new( Box::new(
self.triangulation self.triangulation
.neighbors(self.triangulation_vertex(vertex)) .neighbors(self.trianvertex(vertex))
.flat_map(|neighbor| { .flat_map(|neighbor| {
iter::once(neighbor.into()).chain( iter::once(neighbor.into()).chain(
self.triangulation self.triangulation
.weight(neighbor) .weight(neighbor)
.rails .rails
.iter() .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( fn edge_with_near_edges(
triangulation: &Triangulation<TrianvertexIndex, TrianvertexWeight, ()>, triangulation: &Triangulation<TrianvertexNodeIndex, TrianvertexWeight, ()>,
edge: TriangulationEdgeReference<TrianvertexIndex, ()>, edge: TriangulationEdgeReference<TrianvertexNodeIndex, ()>,
) -> impl Iterator<Item = NavmeshEdgeReference> { ) -> impl Iterator<Item = NavmeshEdgeReference> {
let mut from_vertices = vec![edge.source().into()]; let mut from_vertices = vec![edge.source().into()];
@ -246,7 +246,7 @@ fn edge_with_near_edges(
.weight(edge.source()) .weight(edge.source())
.rails .rails
.iter() .iter()
.map(|bend| NavvertexIndex::from(*bend)), .map(|bend| NavvertexNodeIndex::from(*bend)),
); );
let mut to_vertices = vec![edge.target().into()]; let mut to_vertices = vec![edge.target().into()];
@ -257,7 +257,7 @@ fn edge_with_near_edges(
.weight(edge.target()) .weight(edge.target())
.rails .rails
.iter() .iter()
.map(|bend| NavvertexIndex::from(*bend)), .map(|bend| NavvertexNodeIndex::from(*bend)),
); );
// Return cartesian product. // Return cartesian product.
@ -284,9 +284,9 @@ impl<'a> visit::IntoEdgeReferences for &'a Navmesh {
} }
fn vertex_edges( fn vertex_edges(
triangulation: &Triangulation<TrianvertexIndex, TrianvertexWeight, ()>, triangulation: &Triangulation<TrianvertexNodeIndex, TrianvertexWeight, ()>,
from: NavvertexIndex, from: NavvertexNodeIndex,
to: TrianvertexIndex, to: TrianvertexNodeIndex,
) -> impl Iterator<Item = NavmeshEdgeReference> { ) -> impl Iterator<Item = NavmeshEdgeReference> {
let from_vertices = vec![from]; let from_vertices = vec![from];
let mut to_vertices = vec![to.into()]; let mut to_vertices = vec![to.into()];
@ -297,7 +297,7 @@ fn vertex_edges(
.weight(to) .weight(to)
.rails .rails
.iter() .iter()
.map(|bend| NavvertexIndex::from(*bend)), .map(|bend| NavvertexNodeIndex::from(*bend)),
); );
// Return cartesian product. // Return cartesian product.
@ -316,7 +316,7 @@ impl<'a> visit::IntoEdges for &'a Navmesh {
fn edges(self, vertex: Self::NodeId) -> Self::Edges { fn edges(self, vertex: Self::NodeId) -> Self::Edges {
Box::new( Box::new(
self.triangulation self.triangulation
.edges(self.triangulation_vertex(vertex)) .edges(self.trianvertex(vertex))
.flat_map(move |edge| vertex_edges(&self.triangulation, vertex, edge.target())), .flat_map(move |edge| vertex_edges(&self.triangulation, vertex, edge.target())),
) )
} }

16
src/router/router.rs
View File

@ -4,7 +4,7 @@ use thiserror::Error;
use crate::{ use crate::{
drawing::{ drawing::{
band::BandIndex, band::BandFirstSegIndex,
dot::FixedDotIndex, dot::FixedDotIndex,
graph::{MakePrimitive, PrimitiveIndex}, graph::{MakePrimitive, PrimitiveIndex},
primitive::MakePrimitiveShape, primitive::MakePrimitiveShape,
@ -15,7 +15,7 @@ use crate::{
router::{ router::{
astar::{astar, AstarError, AstarStrategy, PathTracker}, astar::{astar, AstarError, AstarStrategy, PathTracker},
draw::DrawException, draw::DrawException,
navmesh::{Navmesh, NavmeshEdgeReference, NavmeshError, NavvertexIndex}, navmesh::{Navmesh, NavmeshEdgeReference, NavmeshError, NavvertexNodeIndex},
tracer::{Trace, Tracer}, 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( fn is_goal(
&mut self, &mut self,
vertex: NavvertexIndex, vertex: NavvertexNodeIndex,
tracker: &PathTracker<&Navmesh>, tracker: &PathTracker<&Navmesh>,
) -> Option<BandIndex> { ) -> Option<BandFirstSegIndex> {
let new_path = tracker.reconstruct_path_to(vertex); let new_path = tracker.reconstruct_path_to(vertex);
let width = self.trace.width; 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) let start_point = PrimitiveIndex::from(vertex)
.primitive(self.tracer.layout.drawing()) .primitive(self.tracer.layout.drawing())
.shape() .shape()
@ -111,7 +113,7 @@ impl<'a, R: RulesTrait> Router<'a, R> {
Self { layout, navmesh } Self { layout, navmesh }
} }
pub fn route_band(&mut self, width: f64) -> Result<BandIndex, RouterError> { pub fn route_band(&mut self, width: f64) -> Result<BandFirstSegIndex, RouterError> {
let from = self.navmesh.source(); let from = self.navmesh.source();
let to = self.navmesh.target(); let to = self.navmesh.target();
let mut tracer = Tracer::new(self.layout); let mut tracer = Tracer::new(self.layout);

22
src/router/tracer.rs
View File

@ -2,7 +2,7 @@ use contracts::debug_ensures;
use crate::{ use crate::{
drawing::{ drawing::{
band::BandIndex, band::BandFirstSegIndex,
bend::LooseBendIndex, bend::LooseBendIndex,
dot::FixedDotIndex, dot::FixedDotIndex,
guide::{BareHead, CaneHead, Head}, guide::{BareHead, CaneHead, Head},
@ -11,13 +11,13 @@ use crate::{
layout::Layout, layout::Layout,
router::{ router::{
draw::{Draw, DrawException}, draw::{Draw, DrawException},
navmesh::NavvertexIndex, navmesh::NavvertexNodeIndex,
}, },
}; };
#[derive(Debug)] #[derive(Debug)]
pub struct Trace { pub struct Trace {
pub path: Vec<NavvertexIndex>, pub path: Vec<NavvertexNodeIndex>,
pub head: Head, pub head: Head,
pub width: f64, pub width: f64,
} }
@ -45,7 +45,7 @@ impl<'a, R: RulesTrait> Tracer<'a, R> {
trace: &mut Trace, trace: &mut Trace,
into: FixedDotIndex, into: FixedDotIndex,
width: f64, width: f64,
) -> Result<BandIndex, DrawException> { ) -> Result<BandFirstSegIndex, DrawException> {
Draw::new(self.layout).finish_in_dot(trace.head, into, width) 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( pub fn rework_path(
&mut self, &mut self,
trace: &mut Trace, trace: &mut Trace,
path: &[NavvertexIndex], path: &[NavvertexNodeIndex],
width: f64, width: f64,
) -> Result<(), DrawException> { ) -> Result<(), DrawException> {
let prefix_length = trace let prefix_length = trace
@ -72,7 +72,7 @@ impl<'a, R: RulesTrait> Tracer<'a, R> {
pub fn path( pub fn path(
&mut self, &mut self,
trace: &mut Trace, trace: &mut Trace,
path: &[NavvertexIndex], path: &[NavvertexNodeIndex],
width: f64, width: f64,
) -> Result<(), DrawException> { ) -> Result<(), DrawException> {
for (i, vertex) in path.iter().enumerate() { for (i, vertex) in path.iter().enumerate() {
@ -97,7 +97,7 @@ impl<'a, R: RulesTrait> Tracer<'a, R> {
pub fn step( pub fn step(
&mut self, &mut self,
trace: &mut Trace, trace: &mut Trace,
to: NavvertexIndex, to: NavvertexNodeIndex,
width: f64, width: f64,
) -> Result<(), DrawException> { ) -> Result<(), DrawException> {
trace.head = self.wrap(trace.head, to, width)?.into(); trace.head = self.wrap(trace.head, to, width)?.into();
@ -109,13 +109,13 @@ impl<'a, R: RulesTrait> Tracer<'a, R> {
fn wrap( fn wrap(
&mut self, &mut self,
head: Head, head: Head,
around: NavvertexIndex, around: NavvertexNodeIndex,
width: f64, width: f64,
) -> Result<CaneHead, DrawException> { ) -> Result<CaneHead, DrawException> {
match around { match around {
NavvertexIndex::FixedDot(dot) => self.wrap_around_fixed_dot(head, dot, width), NavvertexNodeIndex::FixedDot(dot) => self.wrap_around_fixed_dot(head, dot, width),
NavvertexIndex::FixedBend(_fixed_bend) => todo!(), NavvertexNodeIndex::FixedBend(_fixed_bend) => todo!(),
NavvertexIndex::LooseBend(loose_bend) => { NavvertexNodeIndex::LooseBend(loose_bend) => {
self.wrap_around_loose_bend(head, loose_bend, width) self.wrap_around_loose_bend(head, loose_bend, width)
} }
} }

2
src/specctra/design.rs
View File

@ -671,7 +671,7 @@ impl SpecctraDesign {
maybe_net: Some(net), maybe_net: Some(net),
}, },
// TODO: This manual retagging shouldn't be necessary, `.into()` should suffice. // TODO: This manual retagging shouldn't be necessary, `.into()` should suffice.
//GenericIndex::new(zone.node_index()).into(), //GenericIndex::new(zone.petgraph_index()).into(),
zone, zone,
); );

64
src/triangulation.rs
View File

@ -4,16 +4,16 @@ use geo::{point, EuclideanDistance, Point};
use petgraph::visit; use petgraph::visit;
use spade::{handles::FixedVertexHandle, DelaunayTriangulation, HasPosition, InsertionError}; use spade::{handles::FixedVertexHandle, DelaunayTriangulation, HasPosition, InsertionError};
use crate::graph::GetNodeIndex; use crate::graph::GetPetgraphIndex;
pub trait GetTrianvertexIndex<I> { pub trait GetTrianvertexNodeIndex<I> {
fn trianvertex_index(&self) -> I; fn node_index(&self) -> I;
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Triangulation< pub struct Triangulation<
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexIndex<I> + HasPosition, VW: GetTrianvertexNodeIndex<I> + HasPosition,
EW: Copy + Default, EW: Copy + Default,
> { > {
triangulation: DelaunayTriangulation<VW, EW>, triangulation: DelaunayTriangulation<VW, EW>,
@ -22,8 +22,8 @@ pub struct Triangulation<
} }
impl< impl<
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> Triangulation<I, VW, EW> > Triangulation<I, VW, EW>
{ {
@ -38,7 +38,7 @@ impl<
} }
pub fn add_vertex(&mut self, weight: VW) -> Result<(), InsertionError> { 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( self.trianvertex_to_handle[index] = Some(spade::Triangulation::insert(
&mut self.triangulation, &mut self.triangulation,
weight, weight,
@ -48,13 +48,13 @@ impl<
pub fn weight(&self, vertex: I) -> &VW { pub fn weight(&self, vertex: I) -> &VW {
spade::Triangulation::s(&self.triangulation) 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 { pub fn weight_mut(&mut self, vertex: I) -> &mut VW {
spade::Triangulation::vertex_data_mut( spade::Triangulation::vertex_data_mut(
&mut self.triangulation, &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 { fn vertex(&self, handle: FixedVertexHandle) -> I {
spade::Triangulation::vertex(&self.triangulation, handle) spade::Triangulation::vertex(&self.triangulation, handle)
.as_ref() .as_ref()
.trianvertex_index() .node_index()
} }
fn handle(&self, vertex: I) -> FixedVertexHandle { 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< impl<
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> visit::GraphBase for Triangulation<I, VW, EW> > visit::GraphBase for Triangulation<I, VW, EW>
{ {
@ -104,8 +104,8 @@ impl<EW: Copy + Default> PartialOrd for TriangulationEdgeWeightWrapper<EW> {
} }
impl< impl<
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> visit::Data for Triangulation<I, VW, EW> > visit::Data for Triangulation<I, VW, EW>
{ {
@ -144,8 +144,8 @@ impl<I: Copy, EW: Copy + Default> visit::EdgeRef for TriangulationEdgeReference<
impl< impl<
'a, 'a,
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> visit::IntoNeighbors for &'a Triangulation<I, VW, EW> > visit::IntoNeighbors for &'a Triangulation<I, VW, EW>
{ {
@ -162,8 +162,8 @@ impl<
impl< impl<
'a, 'a,
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> visit::IntoEdgeReferences for &'a Triangulation<I, VW, EW> > visit::IntoEdgeReferences for &'a Triangulation<I, VW, EW>
{ {
@ -191,8 +191,8 @@ impl<
impl< impl<
'a, 'a,
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> visit::IntoEdges for &'a Triangulation<I, VW, EW> > visit::IntoEdges for &'a Triangulation<I, VW, EW>
{ {
@ -221,8 +221,8 @@ impl<
impl< impl<
'a, 'a,
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> visit::IntoNodeIdentifiers for &'a Triangulation<I, VW, EW> > visit::IntoNodeIdentifiers for &'a Triangulation<I, VW, EW>
{ {
@ -233,7 +233,7 @@ impl<
spade::Triangulation::fixed_vertices(&self.triangulation).map(|vertex| { spade::Triangulation::fixed_vertices(&self.triangulation).map(|vertex| {
spade::Triangulation::s(&self.triangulation) spade::Triangulation::s(&self.triangulation)
.vertex_data(vertex) .vertex_data(vertex)
.trianvertex_index() .node_index()
}), }),
) )
} }
@ -260,8 +260,8 @@ impl<'a, I: Copy, VW: Copy> visit::NodeRef for TriangulationVertexReference<'a,
impl< impl<
'a, 'a,
I: Copy + PartialEq + GetNodeIndex, I: Copy + PartialEq + GetPetgraphIndex,
VW: Copy + GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: Copy + GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> visit::IntoNodeReferences for &'a Triangulation<I, VW, EW> > visit::IntoNodeReferences for &'a Triangulation<I, VW, EW>
{ {
@ -273,7 +273,7 @@ impl<
spade::Triangulation::fixed_vertices(&self.triangulation).map(|vertex| { spade::Triangulation::fixed_vertices(&self.triangulation).map(|vertex| {
let weight = spade::Triangulation::s(&self.triangulation).vertex_data(vertex); let weight = spade::Triangulation::s(&self.triangulation).vertex_data(vertex);
TriangulationVertexReference { TriangulationVertexReference {
index: weight.trianvertex_index(), index: weight.node_index(),
weight, weight,
} }
}), }),
@ -283,8 +283,8 @@ impl<
impl< impl<
'a, 'a,
I: Copy + PartialEq + GetNodeIndex + std::fmt::Debug, I: Copy + PartialEq + GetPetgraphIndex + std::fmt::Debug,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>, VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default, EW: Copy + Default,
> visit::NodeIndexable for &'a Triangulation<I, VW, EW> > visit::NodeIndexable for &'a Triangulation<I, VW, EW>
{ {
@ -294,12 +294,12 @@ impl<
} }
fn to_index(&self, node: I) -> usize { fn to_index(&self, node: I) -> usize {
node.node_index().index() node.petgraph_index().index()
} }
fn from_index(&self, index: usize) -> I { fn from_index(&self, index: usize) -> I {
spade::Triangulation::s(&self.triangulation) spade::Triangulation::s(&self.triangulation)
.vertex_data(self.trianvertex_to_handle[index].unwrap()) .vertex_data(self.trianvertex_to_handle[index].unwrap())
.trianvertex_index() .node_index()
} }
} }

8
tests/common/mod.rs
View File

@ -9,7 +9,7 @@ use topola::{
}, },
board::{mesadata::MesadataTrait, Board}, board::{mesadata::MesadataTrait, Board},
drawing::graph::{GetLayer, GetMaybeNet}, drawing::graph::{GetLayer, GetMaybeNet},
graph::GetNodeIndex, graph::GetPetgraphIndex,
specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata}, specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata},
}; };
@ -121,8 +121,8 @@ pub fn assert_single_layer_groundless_autoroute(
if netname != "GND" { if netname != "GND" {
dbg!(source_dot, target_dot); dbg!(source_dot, target_dot);
assert_eq!( assert_eq!(
unionfind.find(source_dot.node_index()), unionfind.find(source_dot.petgraph_index()),
unionfind.find(target_dot.node_index()) unionfind.find(target_dot.petgraph_index())
); );
} }
} }
@ -179,7 +179,7 @@ fn unionfind(autorouter: &mut Autorouter<impl MesadataTrait>) -> UnionFind<NodeI
.geometry() .geometry()
.joineds(primitive) .joineds(primitive)
{ {
unionfind.union(primitive.node_index(), joined.node_index()); unionfind.union(primitive.petgraph_index(), joined.petgraph_index());
} }
} }