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},
layout::via::ViaWeight,
router::{navmesh::NavmeshError, RouterError},
triangulation::GetTrianvertexIndex,
triangulation::GetTrianvertexNodeIndex,
};
#[derive(Error, Debug, Clone)]
@ -100,7 +100,7 @@ impl<M: MesadataTrait> Autorouter<M> {
.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<M: MesadataTrait> Autorouter<M> {
.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<M: MesadataTrait> Autorouter<M> {
.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())

28
src/autorouter/ratsnest.rs
View File

@ -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<RatvertexIndex> for RatvertexWeight {
fn trianvertex_index(&self) -> RatvertexIndex {
impl GetTrianvertexNodeIndex<RatvertexIndex> 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<BandIndex>,
pub band: Option<BandFirstSegIndex>,
}
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<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);
}

4
src/autorouter/selection.rs
View File

@ -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::<ZoneWeight>::new(compound.node_index()))
.zone(GenericIndex::<ZoneWeight>::new(compound.petgraph_index()))
.layer()
} else {
unreachable!()

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

@ -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<FixedDotIndex>,
pub to: Option<FixedDotIndex>,
pub navmesh: Option<Navmesh>,
pub path: Vec<NavvertexIndex>,
pub path: Vec<NavvertexNodeIndex>,
pub ghosts: Vec<PrimitiveShape>,
pub highlighteds: Vec<PrimitiveIndex>,
}

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

@ -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::<ZoneWeight>::new(compound.node_index()),
GenericIndex::<ZoneWeight>::new(compound.petgraph_index()),
board.layout(),
)
.shape()
.into(),*/
CompoundWeight::Zone(weight) => board
.layout()
.zone(GenericIndex::<ZoneWeight>::new(compound.node_index()))
.zone(GenericIndex::<ZoneWeight>::new(compound.petgraph_index()))
.shape()
.into(),
CompoundWeight::Via(weight) => board
.layout()
.via(GenericIndex::<ViaWeight>::new(compound.node_index()))
.via(GenericIndex::<ViaWeight>::new(compound.petgraph_index()))
.shape()
.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::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<impl RulesTrait>,
_unused: Option<()>,
mut maybe_navmesh: Option<Navmesh>,
path: &[NavvertexIndex],
path: &[NavvertexNodeIndex],
ghosts: &[PrimitiveShape],
highlighteds: &[PrimitiveIndex],
times: i64,

12
src/board/board.rs
View File

@ -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<M: MesadataTrait> {
layout: Layout<M>,
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> {
@ -115,7 +115,11 @@ impl<M: MesadataTrait> Board<M> {
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
.node_pinname(GenericNode::Primitive(navmesh.source().into()))
.unwrap()
@ -158,7 +162,7 @@ impl<M: MesadataTrait> Board<M> {
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
.pinname_pair_to_band
.get(&(pinname1.to_string(), pinname2.to_string()))

2
src/drawing/band.rs
View File

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

4
src/drawing/bend.rs
View File

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

4
src/drawing/dot.rs
View File

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

14
src/drawing/drawing.rs
View File

@ -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<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 {
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<CW: Copy, R: RulesTrait> Drawing<CW, R> {
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<CW: Copy, R: RulesTrait> Drawing<CW, R> {
.edge_weight(
self.geometry_with_rtree
.graph()
.find_edge(inner.node_index(), *ni)
.find_edge(inner.petgraph_index(), *ni)
.unwrap()
)
.unwrap(),

4
src/drawing/graph.rs
View File

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

12
src/drawing/loose.rs
View File

@ -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<LooseIndex>) -> Option<LooseIndex>;
}
#[enum_dispatch(GetNodeIndex, MakePrimitive)]
#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum LooseIndex {
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> {
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())

62
src/drawing/primitive.rs
View File

@ -15,7 +15,7 @@ use crate::{
Drawing,
},
geometry::GenericNode,
graph::{GenericIndex, GetNodeIndex},
graph::{GenericIndex, GetPetgraphIndex},
};
#[enum_dispatch]
@ -55,10 +55,12 @@ pub trait GetInterior<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 {
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<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> {
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<LooseBendIndex> {
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<PrimitiveIndex>
for GenericPrimitive<'a, W, CW, R>
{
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> {
fn node_index(&self) -> NodeIndex<usize> {
self.index.node_index()
impl<'a, W, CW: Copy, R: RulesTrait> GetPetgraphIndex for GenericPrimitive<'a, W, CW, R> {
fn petgraph_index(&self) -> NodeIndex<usize> {
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<FixedDotIndex, FixedDotIndex> 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<FixedDotIndex, FixedDotIndex>
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<DotIndex, LooseDotIndex> 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<FixedDotIndex, FixedDotIndex> 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<LooseDotIndex, LooseDotIndex> 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()),
)
}
}

4
src/drawing/seg.rs
View File

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

8
src/drawing/wraparoundable.rs
View File

@ -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<LooseBendIndex>;
}
#[enum_dispatch(GetNodeIndex, MakePrimitive)]
#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum WraparoundableIndex {
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> {
FixedDot(FixedDot<'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 remove_compound(&mut self, 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,
primitive::{BendShape, DotShape, PrimitiveShape, SegShape},
},
graph::{GenericIndex, GetNodeIndex},
graph::{GenericIndex, GetPetgraphIndex},
math::Circle,
};
@ -75,10 +75,10 @@ pub struct Geometry<
SW: SegWeightTrait<PW>,
BW: BendWeightTrait<PW>,
CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetNodeIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetPetgraphIndex + Into<PI> + Copy,
> {
graph: StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize>,
weight_marker: PhantomData<PW>,
@ -98,10 +98,10 @@ impl<
SW: SegWeightTrait<PW>,
BW: BendWeightTrait<PW>,
CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetNodeIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetPetgraphIndex + Into<PI> + Copy,
> Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{
pub fn new() -> Self {
@ -132,10 +132,16 @@ impl<
let seg =
GenericIndex::<W>::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::<W>::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<BI>) {
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>) -> 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<BI> {
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<BI> {
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<Item = PI> + '_ {
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<CW>) -> impl Iterator<Item = PI> + '_ {
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<PW>,
BW: BendWeightTrait<PW>,
CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetNodeIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetPetgraphIndex + Into<PI> + Copy,
> CompoundManagerTrait<CW, GenericIndex<CW>> for Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{
fn add_compound(&mut self, weight: CW) -> GenericIndex<CW> {
@ -496,20 +515,20 @@ impl<
}
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>) {
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>) -> 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<W>(&self, node: GenericIndex<W>) -> impl Iterator<Item = GenericIndex<CW>> {
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
)

34
src/geometry/with_rtree.rs
View File

@ -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<PW> + GetLayer,
BW: BendWeightTrait<PW> + GetLayer,
CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetNodeIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetPetgraphIndex + Into<PI> + Copy,
> {
geometry: Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>,
rtree: RTree<BboxedIndex<GenericNode<PI, GenericIndex<CW>>>>,
@ -69,10 +69,10 @@ impl<
SW: SegWeightTrait<PW> + GetLayer,
BW: BendWeightTrait<PW> + GetLayer,
CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetNodeIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetPetgraphIndex + Into<PI> + Copy,
> GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{
pub fn new(layer_count: usize) -> Self {
@ -259,10 +259,10 @@ impl<
SW: SegWeightTrait<PW> + GetLayer,
BW: BendWeightTrait<PW> + GetLayer,
CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetNodeIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetPetgraphIndex + Into<PI> + Copy,
> GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI>
{
fn make_bbox(&self, primitive: PI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
@ -390,10 +390,10 @@ impl<
SW: SegWeightTrait<PW> + GetLayer,
BW: BendWeightTrait<PW> + GetLayer,
CW: Copy,
PI: GetNodeIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetNodeIndex + Into<PI> + Copy,
SI: GetNodeIndex + Into<PI> + Copy,
BI: GetNodeIndex + Into<PI> + Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetPetgraphIndex + Into<PI> + Copy,
> CompoundManagerTrait<CW, GenericIndex<CW>>
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.
#[enum_dispatch]
pub trait GetNodeIndex {
fn node_index(&self) -> NodeIndex<usize>;
pub trait GetPetgraphIndex {
fn petgraph_index(&self) -> NodeIndex<usize>;
}
#[derive(Debug, Clone, Copy)]
@ -42,8 +42,8 @@ impl<W> PartialEq for GenericIndex<W> {
impl<W> Eq for GenericIndex<W> {}
impl<W> GetNodeIndex for GenericIndex<W> {
fn node_index(&self) -> NodeIndex<usize> {
impl<W> GetPetgraphIndex for GenericIndex<W> {
fn petgraph_index(&self) -> NodeIndex<usize> {
self.node_index
}
}

24
src/layout/layout.rs
View File

@ -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<R: RulesTrait> Layout<R> {
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<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> {
@ -204,7 +204,7 @@ impl<R: RulesTrait> Layout<R> {
GenericIndex::<ZoneWeight>::new(
self.drawing
.add_compound(CompoundWeight::Zone(weight))
.node_index(),
.petgraph_index(),
)
}
@ -215,10 +215,12 @@ impl<R: RulesTrait> Layout<R> {
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<R: RulesTrait> Layout<R> {
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::<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| {
if let NodeIndex::Compound(compound) = wrapper.data {
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> + '_ {
self.drawing
.geometry()
.compound_members(GenericIndex::new(zone.node_index()))
.compound_members(GenericIndex::new(zone.petgraph_index()))
}
pub fn drawing(&self) -> &Drawing<CompoundWeight, R> {

4
src/layout/via.rs
View File

@ -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<GenericIndex<ViaWeight>> for GenericIndex<CompoundWeight> {
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,
},
geometry::{compound::CompoundManagerTrait, poly::PolyShape, GetPos},
graph::{GenericIndex, GetNodeIndex},
graph::{GenericIndex, GetPetgraphIndex},
layout::{CompoundWeight, Layout},
};
@ -130,7 +130,7 @@ pub enum ZoneWeight {
impl From<GenericIndex<ZoneWeight>> for GenericIndex<CompoundWeight> {
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> {
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> {
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::{
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<BandIndex, DrawException> {
) -> Result<BandFirstSegIndex, DrawException> {
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::<BandIndex, DrawException>(match head.face() {
DotIndex::Fixed(dot) => BandIndex::Straight(
Ok::<BandFirstSegIndex, DrawException>(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(),

94
src/router/navmesh.rs
View File

@ -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<NavvertexIndex> for PrimitiveIndex {
fn from(vertex: NavvertexIndex) -> Self {
impl From<NavvertexNodeIndex> 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<TrianvertexIndex> for NavvertexIndex {
fn from(vertex: TrianvertexIndex) -> Self {
impl From<TrianvertexNodeIndex> 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<LooseBendIndex>,
pos: Point,
}
impl GetTrianvertexIndex<TrianvertexIndex> for TrianvertexWeight {
fn trianvertex_index(&self) -> TrianvertexIndex {
self.trianvertex
impl GetTrianvertexNodeIndex<TrianvertexNodeIndex> 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<TrianvertexIndex, TrianvertexWeight, ()>,
navvertex_to_trianvertex: Vec<Option<TrianvertexIndex>>,
triangulation: Triangulation<TrianvertexNodeIndex, TrianvertexWeight, ()>,
navvertex_to_trianvertex: Vec<Option<TrianvertexNodeIndex>>,
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<dyn Iterator<Item = NavvertexIndex> + 'a>;
type Neighbors = Box<dyn Iterator<Item = NavvertexNodeIndex> + '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<TrianvertexIndex, TrianvertexWeight, ()>,
edge: TriangulationEdgeReference<TrianvertexIndex, ()>,
triangulation: &Triangulation<TrianvertexNodeIndex, TrianvertexWeight, ()>,
edge: TriangulationEdgeReference<TrianvertexNodeIndex, ()>,
) -> impl Iterator<Item = NavmeshEdgeReference> {
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<TrianvertexIndex, TrianvertexWeight, ()>,
from: NavvertexIndex,
to: TrianvertexIndex,
triangulation: &Triangulation<TrianvertexNodeIndex, TrianvertexWeight, ()>,
from: NavvertexNodeIndex,
to: TrianvertexNodeIndex,
) -> impl Iterator<Item = NavmeshEdgeReference> {
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())),
)
}

16
src/router/router.rs
View File

@ -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<BandIndex> {
) -> Option<BandFirstSegIndex> {
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<BandIndex, RouterError> {
pub fn route_band(&mut self, width: f64) -> Result<BandFirstSegIndex, RouterError> {
let from = self.navmesh.source();
let to = self.navmesh.target();
let mut tracer = Tracer::new(self.layout);

22
src/router/tracer.rs
View File

@ -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<NavvertexIndex>,
pub path: Vec<NavvertexNodeIndex>,
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<BandIndex, DrawException> {
) -> Result<BandFirstSegIndex, DrawException> {
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<CaneHead, DrawException> {
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)
}
}

2
src/specctra/design.rs
View File

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

64
src/triangulation.rs
View File

@ -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<I> {
fn trianvertex_index(&self) -> I;
pub trait GetTrianvertexNodeIndex<I> {
fn node_index(&self) -> I;
}
#[derive(Debug, Clone)]
pub struct Triangulation<
I: Copy + PartialEq + GetNodeIndex,
VW: GetTrianvertexIndex<I> + HasPosition,
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition,
EW: Copy + Default,
> {
triangulation: DelaunayTriangulation<VW, EW>,
@ -22,8 +22,8 @@ pub struct Triangulation<
}
impl<
I: Copy + PartialEq + GetNodeIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> Triangulation<I, VW, EW>
{
@ -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<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::GraphBase for Triangulation<I, VW, EW>
{
@ -104,8 +104,8 @@ impl<EW: Copy + Default> PartialOrd for TriangulationEdgeWeightWrapper<EW> {
}
impl<
I: Copy + PartialEq + GetNodeIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::Data for Triangulation<I, VW, EW>
{
@ -144,8 +144,8 @@ impl<I: Copy, EW: Copy + Default> visit::EdgeRef for TriangulationEdgeReference<
impl<
'a,
I: Copy + PartialEq + GetNodeIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::IntoNeighbors for &'a Triangulation<I, VW, EW>
{
@ -162,8 +162,8 @@ impl<
impl<
'a,
I: Copy + PartialEq + GetNodeIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::IntoEdgeReferences for &'a Triangulation<I, VW, EW>
{
@ -191,8 +191,8 @@ impl<
impl<
'a,
I: Copy + PartialEq + GetNodeIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::IntoEdges for &'a Triangulation<I, VW, EW>
{
@ -221,8 +221,8 @@ impl<
impl<
'a,
I: Copy + PartialEq + GetNodeIndex,
VW: GetTrianvertexIndex<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::IntoNodeIdentifiers for &'a Triangulation<I, VW, EW>
{
@ -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<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex,
VW: Copy + GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::IntoNodeReferences for &'a Triangulation<I, VW, EW>
{
@ -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<I> + HasPosition<Scalar = f64>,
I: Copy + PartialEq + GetPetgraphIndex + std::fmt::Debug,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::NodeIndexable for &'a Triangulation<I, VW, EW>
{
@ -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()
}
}

8
tests/common/mod.rs
View File

@ -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<impl MesadataTrait>) -> UnionFind<NodeI
.geometry()
.joineds(primitive)
{
unionfind.union(primitive.node_index(), joined.node_index());
unionfind.union(primitive.petgraph_index(), joined.petgraph_index());
}
}