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

refactor(graph): Rename `GetPetgraphIndex` to `GetIndex`

This commit is contained in:
Mikolaj Wielgus 2025-09-13 20:44:33 +02:00
parent 7c4bc87301
commit 6a2102e0a2
28 changed files with 243 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/autorouter/ratsnest.rs
View File

@ -24,7 +24,7 @@ use crate::{
rules::AccessRules,
},
geometry::shape::AccessShape,
graph::{GenericIndex, GetPetgraphIndex, MakeRef},
graph::{GenericIndex, GetIndex, MakeRef},
layout::{
poly::{MakePolygon, PolyWeight},
Layout,
@ -34,7 +34,7 @@ use crate::{
use super::ratline::{RatlineIndex, RatlineWeight};
#[enum_dispatch(GetPetgraphIndex)]
#[enum_dispatch(GetIndex)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum RatvertexIndex {
FixedDot(FixedDotIndex),
@ -144,8 +144,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().node_index().petgraph_index();
let target_index = g.node_weight(target).unwrap().node_index().petgraph_index();
let source_index = g.node_weight(source).unwrap().node_index().index();
let target_index = g.node_weight(target).unwrap().node_index().index();
!unionfind.equiv(source_index, target_index)
} else {
true

4
src/autorouter/selection.rs
View File

@ -14,7 +14,7 @@ use crate::{
shape::{AccessShape, Shape},
GenericNode, GetLayer,
},
graph::{GenericIndex, GetPetgraphIndex, MakeRef},
graph::{GenericIndex, GetIndex, MakeRef},
layout::{poly::PolyWeight, CompoundWeight, NodeIndex},
};
@ -36,7 +36,7 @@ impl PinSelector {
NodeIndex::Compound(compound) => {
if let CompoundWeight::Poly(..) = board.layout().drawing().compound_weight(compound)
{
GenericIndex::<PolyWeight>::new(compound.petgraph_index())
GenericIndex::<PolyWeight>::new(compound.index())
.ref_(board.layout())
.layer()
} else {

4
src/board/mod.rs
View File

@ -40,7 +40,7 @@ pub enum ResolvedSelector<'a> {
impl<'a> ResolvedSelector<'a> {
pub fn try_from_node(board: &'a Board<impl AccessMesadata>, node: NodeIndex) -> Option<Self> {
use crate::{drawing::graph::MakePrimitiveRef, graph::GetPetgraphIndex};
use crate::{drawing::graph::MakePrimitiveRef, graph::GetIndex};
let (layer, loose) = match node {
NodeIndex::Primitive(primitive) => (
@ -50,7 +50,7 @@ impl<'a> ResolvedSelector<'a> {
NodeIndex::Compound(compound) => {
match board.layout().drawing().compound_weight(compound) {
CompoundWeight::Poly(..) => (
GenericIndex::<PolyWeight>::new(compound.petgraph_index())
GenericIndex::<PolyWeight>::new(compound.index())
.ref_(board.layout())
.layer(),
None,

4
src/drawing/bend.rs
View File

@ -12,12 +12,12 @@ use crate::{
Drawing,
},
geometry::{GetLayer, GetOffset, GetWidth, SetOffset},
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
};
use petgraph::stable_graph::NodeIndex;
#[enum_dispatch(GetPetgraphIndex, MakePrimitiveRef)]
#[enum_dispatch(GetIndex, MakePrimitiveRef)]
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum BendIndex {
Fixed(FixedBendIndex),

4
src/drawing/dot.rs
View File

@ -15,11 +15,11 @@ use crate::{
Drawing,
},
geometry::{GetLayer, GetSetPos, GetWidth},
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
math::Circle,
};
#[enum_dispatch(GetPetgraphIndex, MakePrimitiveRef)]
#[enum_dispatch(GetIndex, MakePrimitiveRef)]
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum DotIndex {
Fixed(FixedDotIndex),

6
src/drawing/drawing.rs
View File

@ -37,7 +37,7 @@ use crate::{
AccessBendWeight, AccessDotWeight, AccessSegWeight, GenericNode, Geometry, GeometryLabel,
GetLayer, GetOffset, GetSetPos, GetWidth,
},
graph::{GenericIndex, GetPetgraphIndex, MakeRef},
graph::{GenericIndex, GetIndex, MakeRef},
math::{NoBitangents, RotationSense},
};
@ -570,7 +570,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
let core = *self
.recording_geometry_with_rtree
.graph()
.neighbors(inner.petgraph_index())
.neighbors(inner.index())
.filter(|ni| {
matches!(
self.recording_geometry_with_rtree
@ -578,7 +578,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
.edge_weight(
self.recording_geometry_with_rtree
.graph()
.find_edge(inner.petgraph_index(), *ni)
.find_edge(inner.index(), *ni)
.unwrap()
)
.unwrap(),

6
src/drawing/gear.rs
View File

@ -16,10 +16,10 @@ use crate::{
rules::AccessRules,
Drawing,
},
graph::{GetPetgraphIndex, MakeRef},
graph::{GetIndex, MakeRef},
};
#[enum_dispatch(GetPetgraphIndex, MakePrimitiveRef)]
#[enum_dispatch(GetIndex, MakePrimitiveRef)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum GearIndex {
FixedDot(FixedDotIndex),
@ -53,7 +53,7 @@ impl From<BendIndex> for GearIndex {
}
}
#[enum_dispatch(GetOuterGears, WalkOutwards, GetDrawing, GetPetgraphIndex)]
#[enum_dispatch(GetOuterGears, WalkOutwards, GetDrawing, GetIndex)]
pub enum GearRef<'a, CW, Cel, R> {
FixedDot(FixedDotRef<'a, CW, Cel, R>),
FixedBend(FixedBendRef<'a, CW, Cel, R>),

4
src/drawing/graph.rs
View File

@ -7,7 +7,7 @@ use petgraph::stable_graph::NodeIndex;
use crate::{
geometry::GetLayer,
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
};
use super::{
@ -88,7 +88,7 @@ macro_rules! impl_weight_forward {
// 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(GetPetgraphIndex, MakePrimitiveRef)]
#[enum_dispatch(GetIndex, MakePrimitiveRef)]
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum PrimitiveIndex {
FixedDot(FixedDotIndex),

12
src/drawing/loose.rs
View File

@ -17,7 +17,7 @@ use crate::{
rules::AccessRules,
seg::{LoneLooseSegIndex, SeqLooseSegIndex},
},
graph::GetPetgraphIndex,
graph::GetIndex,
};
#[enum_dispatch]
@ -38,7 +38,7 @@ pub trait GetPrevNextLoose {
}
}
#[enum_dispatch(GetPetgraphIndex, MakePrimitiveRef)]
#[enum_dispatch(GetIndex, MakePrimitiveRef)]
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum LooseIndex {
Dot(LooseDotIndex),
@ -71,7 +71,7 @@ impl TryFrom<PrimitiveIndex> for LooseIndex {
}
}
#[enum_dispatch(GetPrevNextLoose, GetDrawing, GetPetgraphIndex)]
#[enum_dispatch(GetPrevNextLoose, GetDrawing, GetIndex)]
pub enum Loose<'a, CW, Cel, R> {
Dot(LooseDotRef<'a, CW, Cel, R>),
LoneSeg(LoneLooseSegRef<'a, CW, Cel, R>),
@ -95,7 +95,7 @@ impl<CW, Cel, R> GetPrevNextLoose for LooseDotRef<'_, CW, Cel, R> {
let bend = self.bend();
if let Some(prev) = maybe_prev {
if bend.petgraph_index() != prev.petgraph_index() {
if bend.index() != prev.index() {
Some(bend.into())
} else {
self.seg().map(Into::into)
@ -119,7 +119,7 @@ impl<CW, Cel, R> GetPrevNextLoose for SeqLooseSegRef<'_, CW, Cel, R> {
return Some(joints.1.into());
};
if joints.0.petgraph_index() != prev.petgraph_index() {
if joints.0.index() != prev.index() {
match joints.0 {
DotIndex::Fixed(..) => None,
DotIndex::Loose(dot) => Some(dot.into()),
@ -135,7 +135,7 @@ impl<CW, Cel, R> GetPrevNextLoose for LooseBendRef<'_, CW, Cel, R> {
let joints = self.joints();
if let Some(prev) = maybe_prev {
if joints.0.petgraph_index() != prev.petgraph_index() {
if joints.0.index() != prev.index() {
Some(joints.0.into())
} else {
Some(joints.1.into())

67
src/drawing/primitive.rs
View File

@ -15,7 +15,7 @@ use crate::{
Drawing,
},
geometry::{primitive::PrimitiveShape, GenericNode, GetLayer, GetOffset, GetWidth, Retag},
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
};
use super::gear::{DrawingOutwardWalker, GetOuterGears, WalkOutwards};
@ -67,14 +67,14 @@ pub trait GetOtherJoint: GetJoints {
impl<F, S> GetOtherJoint for S
where
F: GetPetgraphIndex,
F: GetIndex,
S: GetJoints<F = F>,
<S as GetJoints>::T: GetPetgraphIndex + Into<F>,
<S as GetJoints>::T: GetIndex + Into<F>,
{
type J = F;
fn other_joint(&self, end: F) -> F {
let joints = self.joints();
if joints.0.petgraph_index() != end.petgraph_index() {
if joints.0.index() != end.index() {
joints.0
} else {
joints.1.into()
@ -88,13 +88,13 @@ pub trait GetJoints {
fn joints(&self) -> (Self::F, Self::T);
}
pub trait GetLowestGears: GetDrawing + GetPetgraphIndex {
pub trait GetLowestGears: GetDrawing + GetIndex {
// TODO: Make it return an iterator instead of a vec.
fn lowest_gears(&self) -> Vec<LooseBendIndex> {
self.drawing()
.geometry()
.all_rails(self.petgraph_index())
.map(|ni| LooseBendIndex::new(ni.petgraph_index()))
.all_rails(self.index())
.map(|ni| LooseBendIndex::new(ni.index()))
.collect()
}
}
@ -109,12 +109,7 @@ pub trait GetCore: GetBendIndex {
impl<S: GetDrawing + GetBendIndex> GetCore for S {
fn core(&self) -> FixedDotIndex {
FixedDotIndex::new(
self.drawing()
.geometry()
.core(self.bend_index())
.petgraph_index(),
)
FixedDotIndex::new(self.drawing().geometry().core(self.bend_index()).index())
}
}
@ -205,7 +200,7 @@ impl<'a, W, CW, Cel, R> GenericPrimitive<'a, W, CW, Cel, R> {
.drawing
.geometry()
.graph()
.node_weight(self.index.petgraph_index())
.node_weight(self.index.index())
.unwrap()
{
*weight
@ -217,7 +212,7 @@ impl<'a, W, CW, Cel, R> GenericPrimitive<'a, W, CW, Cel, R> {
impl<W, CW, Cel, R> GetInterior<PrimitiveIndex> for GenericPrimitive<'_, W, CW, Cel, R> {
fn interior(&self) -> Vec<PrimitiveIndex> {
vec![self.tagged_weight().retag(self.index.petgraph_index())]
vec![self.tagged_weight().retag(self.index.index())]
}
}
@ -230,9 +225,9 @@ impl<W, CW, Cel, R> GetDrawing for GenericPrimitive<'_, W, CW, Cel, R> {
}
}
impl<W, CW, Cel, R> GetPetgraphIndex for GenericPrimitive<'_, W, CW, Cel, R> {
fn petgraph_index(&self) -> NodeIndex<usize> {
self.index.petgraph_index()
impl<W, CW, Cel, R> GetIndex for GenericPrimitive<'_, W, CW, Cel, R> {
fn index(&self) -> NodeIndex<usize> {
self.index.index()
}
}
@ -305,7 +300,7 @@ impl<CW, Cel, R> LooseDotRef<'_, CW, Cel, R> {
self.drawing
.geometry()
.joined_segs(self.index.into())
.map(|ni| SeqLooseSegIndex::new(ni.petgraph_index()))
.map(|ni| SeqLooseSegIndex::new(ni.index()))
.next()
}
@ -313,7 +308,7 @@ impl<CW, Cel, R> LooseDotRef<'_, CW, Cel, R> {
self.drawing
.geometry()
.joined_bends(self.index.into())
.map(|ni| LooseBendIndex::new(ni.petgraph_index()))
.map(|ni| LooseBendIndex::new(ni.index()))
.next()
.unwrap()
}
@ -356,8 +351,8 @@ impl<CW, Cel, R> GetJoints for FixedSegRef<'_, CW, Cel, R> {
fn joints(&self) -> (FixedDotIndex, FixedDotIndex) {
let (from, to) = self.drawing.geometry().seg_joints(self.index.into());
(
FixedDotIndex::new(from.petgraph_index()),
FixedDotIndex::new(to.petgraph_index()),
FixedDotIndex::new(from.index()),
FixedDotIndex::new(to.index()),
)
}
}
@ -379,8 +374,8 @@ impl<CW, Cel, R> GetJoints for LoneLooseSegRef<'_, CW, Cel, R> {
fn joints(&self) -> (FixedDotIndex, FixedDotIndex) {
let (from, to) = self.drawing.geometry().seg_joints(self.index.into());
(
FixedDotIndex::new(from.petgraph_index()),
FixedDotIndex::new(to.petgraph_index()),
FixedDotIndex::new(from.index()),
FixedDotIndex::new(to.index()),
)
}
}
@ -403,18 +398,18 @@ impl<CW, Cel, R> GetJoints for SeqLooseSegRef<'_, CW, Cel, R> {
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.petgraph_index()).into(),
LooseDotIndex::new(joints.1.petgraph_index()),
FixedDotIndex::new(joints.0.index()).into(),
LooseDotIndex::new(joints.1.index()),
)
} else if let DotWeight::Fixed(..) = self.drawing.geometry().dot_weight(joints.1) {
(
FixedDotIndex::new(joints.1.petgraph_index()).into(),
LooseDotIndex::new(joints.0.petgraph_index()),
FixedDotIndex::new(joints.1.index()).into(),
LooseDotIndex::new(joints.0.index()),
)
} else {
(
LooseDotIndex::new(joints.0.petgraph_index()).into(),
LooseDotIndex::new(joints.1.petgraph_index()),
LooseDotIndex::new(joints.0.index()).into(),
LooseDotIndex::new(joints.1.index()),
)
}
}
@ -443,8 +438,8 @@ impl<CW, Cel, R> GetJoints for FixedBendRef<'_, CW, Cel, R> {
fn joints(&self) -> (FixedDotIndex, FixedDotIndex) {
let (from, to) = self.drawing.geometry().bend_joints(self.index.into());
(
FixedDotIndex::new(from.petgraph_index()),
FixedDotIndex::new(to.petgraph_index()),
FixedDotIndex::new(from.index()),
FixedDotIndex::new(to.index()),
)
}
}
@ -498,8 +493,8 @@ impl<CW, Cel, R> GetJoints for LooseBendRef<'_, CW, Cel, R> {
fn joints(&self) -> (LooseDotIndex, LooseDotIndex) {
let (from, to) = self.drawing.geometry().bend_joints(self.index.into());
(
LooseDotIndex::new(from.petgraph_index()),
LooseDotIndex::new(to.petgraph_index()),
LooseDotIndex::new(from.index()),
LooseDotIndex::new(to.index()),
)
}
}
@ -521,13 +516,13 @@ impl<CW, Cel, R> LooseBendRef<'_, CW, Cel, R> {
self.drawing()
.geometry()
.inner(self.bend_index())
.map(|ni| LooseBendIndex::new(ni.petgraph_index()))
.map(|ni| LooseBendIndex::new(ni.index()))
}
pub fn outers(&self) -> impl Iterator<Item = LooseBendIndex> + '_ {
self.drawing()
.geometry()
.outers(self.bend_index())
.map(|node| LooseBendIndex::new(node.petgraph_index()))
.map(|node| LooseBendIndex::new(node.index()))
}
}

6
src/drawing/seg.rs
View File

@ -13,12 +13,12 @@ use crate::{
Drawing,
},
geometry::{GetLayer, GetWidth},
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
};
use petgraph::stable_graph::NodeIndex;
#[enum_dispatch(GetPetgraphIndex, MakePrimitiveRef)]
#[enum_dispatch(GetIndex, MakePrimitiveRef)]
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Hash)]
pub enum SegIndex {
Fixed(FixedSegIndex),
@ -26,7 +26,7 @@ pub enum SegIndex {
SeqLoose(SeqLooseSegIndex),
}
#[enum_dispatch(GetPetgraphIndex, MakePrimitiveRef)]
#[enum_dispatch(GetIndex, MakePrimitiveRef)]
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Hash)]
pub enum LooseSegIndex {
Lone(LoneLooseSegIndex),

6
src/geometry/compound.rs
View File

@ -2,7 +2,7 @@
//
// SPDX-License-Identifier: MIT
use crate::graph::{GenericIndex, GetPetgraphIndex};
use crate::graph::{GenericIndex, GetIndex};
pub trait ManageCompounds<CW: Clone> {
type GeneralIndex: Copy;
@ -12,7 +12,7 @@ pub trait ManageCompounds<CW: Clone> {
fn remove_compound(&mut self, compound: GenericIndex<CW>);
fn add_to_compound<I>(&mut self, node: I, label: Self::EntryLabel, compound: GenericIndex<CW>)
where
I: Copy + GetPetgraphIndex;
I: Copy + GetIndex;
fn compound_weight(&self, node: GenericIndex<CW>) -> &CW;
@ -23,5 +23,5 @@ pub trait ManageCompounds<CW: Clone> {
fn compounds<I>(&self, node: I) -> impl Iterator<Item = (Self::EntryLabel, GenericIndex<CW>)>
where
I: Copy + GetPetgraphIndex;
I: Copy + GetIndex;
}

18
src/geometry/edit.rs
View File

@ -4,7 +4,7 @@
use std::collections::{btree_map::Entry, BTreeMap};
use crate::graph::{GenericIndex, GetPetgraphIndex};
use crate::graph::{GenericIndex, GetIndex};
use super::{AccessBendWeight, AccessDotWeight, AccessSegWeight, GetLayer};
@ -39,10 +39,10 @@ pub trait ApplyGeometryEdit<
BW: AccessBendWeight + GetLayer,
CW: Clone,
Cel: Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
SI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
BI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetIndex + Into<PI> + Eq + Ord + Copy,
SI: GetIndex + Into<PI> + Eq + Ord + Copy,
BI: GetIndex + Into<PI> + Eq + Ord + Copy,
>
{
fn apply(&mut self, edit: &GeometryEdit<DW, SW, BW, CW, Cel, PI, DI, SI, BI>);
@ -89,10 +89,10 @@ impl<
BW: AccessBendWeight + GetLayer,
CW: Clone,
Cel: Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
SI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
BI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetIndex + Into<PI> + Eq + Ord + Copy,
SI: GetIndex + Into<PI> + Eq + Ord + Copy,
BI: GetIndex + Into<PI> + Eq + Ord + Copy,
> Edit for GeometryEdit<DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{
fn reverse_inplace(&mut self) {

154
src/geometry/geometry.rs
View File

@ -25,12 +25,12 @@ use crate::{
compound::ManageCompounds,
primitive::{BendShape, DotShape, PrimitiveShape, SegShape},
},
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
math::Circle,
};
pub trait Retag {
type Index: Sized + GetPetgraphIndex + PartialEq + Copy;
type Index: Sized + GetIndex + PartialEq + Copy;
fn retag(&self, index: NodeIndex<usize>) -> Self::Index;
}
@ -74,11 +74,11 @@ pub enum GenericNode<P, C> {
Compound(C),
}
impl<P: GetPetgraphIndex, C: GetPetgraphIndex> GetPetgraphIndex for GenericNode<P, C> {
fn petgraph_index(&self) -> NodeIndex<usize> {
impl<P: GetIndex, C: GetIndex> GetIndex for GenericNode<P, C> {
fn index(&self) -> NodeIndex<usize> {
match self {
Self::Primitive(x) => x.petgraph_index(),
Self::Compound(x) => x.petgraph_index(),
Self::Primitive(x) => x.index(),
Self::Compound(x) => x.index(),
}
}
}
@ -168,10 +168,10 @@ impl<
BW: AccessBendWeight + Into<PW>,
CW,
Cel,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetPetgraphIndex + Into<PI> + Copy,
SI: GetPetgraphIndex + Into<PI> + Copy,
BI: GetPetgraphIndex + Into<PI> + Copy,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Copy,
DI: GetIndex + Into<PI> + Copy,
SI: GetIndex + Into<PI> + Copy,
BI: GetIndex + Into<PI> + Copy,
> Geometry<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{
pub fn add_dot<W: AccessDotWeight + Into<PW>>(&mut self, weight: W) -> GenericIndex<W> {
@ -184,7 +184,7 @@ impl<
weight: W,
) {
self.graph
.update_node(dot.petgraph_index(), GenericNode::Primitive(weight.into()));
.update_node(dot.index(), GenericNode::Primitive(weight.into()));
}
pub fn add_seg<W: AccessSegWeight + Into<PW>>(
@ -207,7 +207,7 @@ impl<
weight: W,
) {
self.graph
.update_node(seg.petgraph_index(), GenericNode::Primitive(weight.into()));
.update_node(seg.index(), GenericNode::Primitive(weight.into()));
self.init_seg_joints(seg, from, to);
}
@ -217,28 +217,22 @@ impl<
from: DI,
to: DI,
) {
self.graph.update_edge(
from.petgraph_index(),
seg.petgraph_index(),
GeometryLabel::Joined,
);
self.graph.update_edge(
seg.petgraph_index(),
to.petgraph_index(),
GeometryLabel::Joined,
);
self.graph
.update_edge(from.index(), seg.index(), GeometryLabel::Joined);
self.graph
.update_edge(seg.index(), to.index(), GeometryLabel::Joined);
}
pub fn is_joined_with<I>(&self, seg: I, node: GenericNode<PI, GenericIndex<CW>>) -> bool
where
I: Copy + GetPetgraphIndex,
I: Copy + GetIndex,
CW: Clone,
Cel: Copy,
{
match node {
GenericNode::Primitive(prim) => self
.graph
.find_edge_undirected(seg.petgraph_index(), prim.petgraph_index())
.find_edge_undirected(seg.index(), prim.index())
.map_or(false, |(eidx, _direction)| {
matches!(self.graph.edge_weight(eidx).unwrap(), GeometryLabel::Joined)
}),
@ -270,13 +264,13 @@ impl<
weight: W,
) {
self.graph
.update_node(bend.petgraph_index(), GenericNode::Primitive(weight.into()));
.update_node(bend.index(), GenericNode::Primitive(weight.into()));
self.init_bend_joints_and_core(bend, from, to, core);
}
pub(super) fn add_compound_at_index(&mut self, compound: GenericIndex<CW>, weight: CW) {
self.graph
.update_node(compound.petgraph_index(), GenericNode::Compound(weight));
.update_node(compound.index(), GenericNode::Compound(weight));
}
fn init_bend_joints_and_core<W: AccessBendWeight + Into<PW>>(
@ -286,80 +280,58 @@ impl<
to: DI,
core: DI,
) {
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,
);
self.graph
.update_edge(from.index(), bend.index(), GeometryLabel::Joined);
self.graph
.update_edge(bend.index(), to.index(), GeometryLabel::Joined);
self.graph
.update_edge(bend.index(), core.index(), GeometryLabel::Core);
}
pub fn remove_primitive(&mut self, primitive: PI) {
debug_assert!(self.graph.remove_node(primitive.petgraph_index()).is_some());
debug_assert!(self.graph.remove_node(primitive.index()).is_some());
}
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.petgraph_index()).unwrap() =
GenericNode::Primitive(weight.into());
*self.graph.node_weight_mut(dot.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.petgraph_index()).unwrap() =
GenericNode::Primitive(weight.into());
*self.graph.node_weight_mut(bend.index()).unwrap() = GenericNode::Primitive(weight.into());
}
pub fn flip_bend(&mut self, bend: BI) {
let (from, to) = self.bend_joints(bend);
let from_edge_weight = self
.graph
.remove_edge(
self.graph
.find_edge(from.petgraph_index(), bend.petgraph_index())
.unwrap(),
)
.remove_edge(self.graph.find_edge(from.index(), bend.index()).unwrap())
.unwrap();
let to_edge_weight = self
.graph
.remove_edge(
self.graph
.find_edge(bend.petgraph_index(), to.petgraph_index())
.unwrap(),
)
.remove_edge(self.graph.find_edge(bend.index(), to.index()).unwrap())
.unwrap();
self.graph
.update_edge(from.petgraph_index(), bend.petgraph_index(), to_edge_weight);
.update_edge(from.index(), bend.index(), to_edge_weight);
self.graph
.update_edge(bend.petgraph_index(), to.petgraph_index(), from_edge_weight);
.update_edge(bend.index(), to.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.petgraph_index(), Incoming)
.edges_directed(bend.index(), Incoming)
.find(|edge| matches!(edge.weight(), GeometryLabel::Outer))
{
debug_assert!(self.graph.remove_edge(old_inner_edge.id()).is_some());
}
if let Some(new_inner) = maybe_new_inner {
self.graph.update_edge(
new_inner.petgraph_index(),
bend.petgraph_index(),
GeometryLabel::Outer,
);
self.graph
.update_edge(new_inner.index(), bend.index(), GeometryLabel::Outer);
}
}
@ -378,7 +350,7 @@ impl<
PrimitiveShape::Seg(SegShape {
from: self.dot_weight(from).pos(),
to: self.dot_weight(to).pos(),
width: self.primitive_weight(seg.petgraph_index()).width(),
width: self.primitive_weight(seg.index()).width(),
})
}
@ -392,7 +364,7 @@ impl<
pos: core_weight.pos(),
r: self.inner_radius(bend),
},
width: self.primitive_weight(bend.petgraph_index()).width(),
width: self.primitive_weight(bend.index()).width(),
})
}
@ -410,27 +382,25 @@ impl<
}
pub fn dot_weight(&self, dot: DI) -> DW {
self.primitive_weight(dot.petgraph_index())
self.primitive_weight(dot.index())
.try_into()
.unwrap_or_else(|_| unreachable!())
}
pub fn seg_weight(&self, seg: SI) -> SW {
self.primitive_weight(seg.petgraph_index())
self.primitive_weight(seg.index())
.try_into()
.unwrap_or_else(|_| unreachable!())
}
pub fn bend_weight(&self, bend: BI) -> BW {
self.primitive_weight(bend.petgraph_index())
self.primitive_weight(bend.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.petgraph_index()).unwrap()
{
if let GenericNode::Compound(weight) = self.graph.node_weight(compound.index()).unwrap() {
weight
} else {
unreachable!()
@ -439,7 +409,7 @@ impl<
fn core_weight(&self, bend: BI) -> DW {
self.graph
.edges_directed(bend.petgraph_index(), Outgoing)
.edges_directed(bend.index(), Outgoing)
.find(|edge| matches!(edge.weight(), GeometryLabel::Core))
.map(|edge| {
self.primitive_weight(edge.target())
@ -451,13 +421,13 @@ impl<
pub fn joineds(&self, node: PI) -> impl Iterator<Item = PI> + '_ {
self.graph
.neighbors_undirected(node.petgraph_index())
.neighbors_undirected(node.index())
.filter(move |ni| {
matches!(
self.graph
.edge_weight(
self.graph
.find_edge_undirected(node.petgraph_index(), *ni)
.find_edge_undirected(node.index(), *ni)
.unwrap()
.0,
)
@ -479,12 +449,12 @@ impl<
fn joints(&self, node: PI) -> (DI, DI) {
let lhs = self
.graph
.edges_directed(node.petgraph_index(), Incoming)
.edges_directed(node.index(), Incoming)
.find(|edge| matches!(edge.weight(), GeometryLabel::Joined))
.map(|edge| edge.source());
let rhs = self
.graph
.edges_directed(node.petgraph_index(), Outgoing)
.edges_directed(node.index(), Outgoing)
.find(|edge| matches!(edge.weight(), GeometryLabel::Joined))
.map(|edge| edge.target());
@ -525,7 +495,7 @@ pub struct OutwardWalker<BI> {
frontier: VecDeque<BI>,
}
impl<BI: GetPetgraphIndex> OutwardWalker<BI> {
impl<BI: GetIndex> OutwardWalker<BI> {
pub fn new(initial_frontier: impl Iterator<Item = BI>) -> Self {
let mut frontier = VecDeque::new();
frontier.extend(initial_frontier);
@ -544,7 +514,7 @@ impl<
PI: TryInto<DI> + TryInto<SI> + TryInto<BI>,
DI,
SI,
BI: Copy + GetPetgraphIndex,
BI: Copy + GetIndex,
> Walker<&Geometry<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>> for OutwardWalker<BI>
{
type Item = BI;
@ -570,7 +540,7 @@ impl<
PI: TryInto<DI> + TryInto<SI> + TryInto<BI>,
DI,
SI,
BI: GetPetgraphIndex,
BI: GetIndex,
> Geometry<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{
pub fn all_rails(&self, node: NodeIndex<usize>) -> impl Iterator<Item = BI> + '_ {
@ -586,7 +556,7 @@ impl<
pub fn core(&self, bend: BI) -> DI {
self.graph
.edges_directed(bend.petgraph_index(), Outgoing)
.edges_directed(bend.index(), Outgoing)
.find(|edge| matches!(edge.weight(), GeometryLabel::Core))
.map(|edge| {
self.primitive_index(edge.target())
@ -598,7 +568,7 @@ impl<
pub fn inner(&self, bend: BI) -> Option<BI> {
self.graph
.edges_directed(bend.petgraph_index(), Incoming)
.edges_directed(bend.index(), Incoming)
.find(|edge| matches!(edge.weight(), GeometryLabel::Outer))
.map(|edge| {
self.primitive_index(edge.source())
@ -609,7 +579,7 @@ impl<
pub fn outers(&self, bend: BI) -> impl Iterator<Item = BI> + '_ {
self.graph
.edges_directed(bend.petgraph_index(), Outgoing)
.edges_directed(bend.index(), Outgoing)
.filter(|edge| matches!(edge.weight(), GeometryLabel::Outer))
.map(|edge| {
self.primitive_index(edge.target())
@ -634,24 +604,22 @@ impl<PW: Copy + Retag<Index = PI>, DW, SW, BW, CW: Clone, Cel: Copy, PI: Copy, D
}
fn remove_compound(&mut self, compound: GenericIndex<CW>) {
debug_assert!(self.graph.remove_node(compound.petgraph_index()).is_some());
debug_assert!(self.graph.remove_node(compound.index()).is_some());
}
fn add_to_compound<I>(&mut self, primitive: I, entry_label: Cel, compound: GenericIndex<CW>)
where
I: Copy + GetPetgraphIndex,
I: Copy + GetIndex,
{
self.graph.update_edge(
primitive.petgraph_index(),
compound.petgraph_index(),
primitive.index(),
compound.index(),
GeometryLabel::Compound(entry_label),
);
}
fn compound_weight(&self, compound: GenericIndex<CW>) -> &CW {
if let GenericNode::Compound(weight) =
self.graph.node_weight(compound.petgraph_index()).unwrap()
{
if let GenericNode::Compound(weight) = self.graph.node_weight(compound.index()).unwrap() {
weight
} else {
unreachable!()
@ -663,7 +631,7 @@ impl<PW: Copy + Retag<Index = PI>, DW, SW, BW, CW: Clone, Cel: Copy, PI: Copy, D
compound: GenericIndex<CW>,
) -> impl Iterator<Item = (Cel, Self::GeneralIndex)> + '_ {
self.graph
.edges_directed(compound.petgraph_index(), Incoming)
.edges_directed(compound.index(), Incoming)
.filter_map(|edge| {
if let GeometryLabel::Compound(entry_label) = *edge.weight() {
Some((entry_label, self.primitive_index(edge.source())))
@ -675,10 +643,10 @@ impl<PW: Copy + Retag<Index = PI>, DW, SW, BW, CW: Clone, Cel: Copy, PI: Copy, D
fn compounds<I>(&self, node: I) -> impl Iterator<Item = (Cel, GenericIndex<CW>)>
where
I: Copy + GetPetgraphIndex,
I: Copy + GetIndex,
{
self.graph
.edges_directed(node.petgraph_index(), Outgoing)
.edges_directed(node.index(), Outgoing)
.filter_map(|edge| {
if let GeometryLabel::Compound(entry_label) = *edge.weight() {
Some((entry_label, GenericIndex::new(edge.target())))

18
src/geometry/recording_with_rtree.rs
View File

@ -8,7 +8,7 @@ use geo::Point;
use petgraph::stable_graph::StableDiGraph;
use rstar::RTree;
use crate::graph::{GenericIndex, GetPetgraphIndex};
use crate::graph::{GenericIndex, GetIndex};
use super::{
compound::ManageCompounds,
@ -60,10 +60,10 @@ impl<
BW: AccessBendWeight + Into<PW> + GetLayer,
CW: Clone,
Cel: Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
SI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
BI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetIndex + Into<PI> + Eq + Ord + Copy,
SI: GetIndex + Into<PI> + Eq + Ord + Copy,
BI: GetIndex + Into<PI> + Eq + Ord + Copy,
> RecordingGeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{
pub fn new(layer_count: usize) -> Self {
@ -363,10 +363,10 @@ impl<
BW: AccessBendWeight + Into<PW> + GetLayer,
CW: Clone,
Cel: Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
SI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
BI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetIndex + Into<PI> + Eq + Ord + Copy,
SI: GetIndex + Into<PI> + Eq + Ord + Copy,
BI: GetIndex + Into<PI> + Eq + Ord + Copy,
> ApplyGeometryEdit<DW, SW, BW, CW, Cel, PI, DI, SI, BI>
for RecordingGeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{

57
src/geometry/with_rtree.rs
View File

@ -15,7 +15,7 @@ use crate::{
AccessBendWeight, AccessDotWeight, AccessSegWeight, GenericNode, Geometry, GeometryLabel,
GetLayer, GetWidth, Retag,
},
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
};
use super::edit::{ApplyGeometryEdit, GeometryEdit};
@ -76,10 +76,10 @@ impl<
BW: AccessBendWeight + Into<PW> + GetLayer,
CW: Clone,
Cel: 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,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetIndex + Into<PI> + Copy,
SI: GetIndex + Into<PI> + Copy,
BI: GetIndex + Into<PI> + Copy,
> GeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{
pub fn new(layer_count: usize) -> Self {
@ -108,7 +108,7 @@ impl<
weight: W,
) {
self.geometry
.add_dot_at_index(GenericIndex::<W>::new(dot.petgraph_index()), weight);
.add_dot_at_index(GenericIndex::<W>::new(dot.index()), weight);
self.init_dot_bbox(dot);
}
@ -133,12 +133,8 @@ impl<
to: DI,
weight: W,
) {
self.geometry.add_seg_at_index(
GenericIndex::<W>::new(seg.petgraph_index()),
from,
to,
weight,
);
self.geometry
.add_seg_at_index(GenericIndex::<W>::new(seg.index()), from, to, weight);
self.init_seg_bbox(seg);
}
@ -159,7 +155,7 @@ impl<
pub(super) fn add_compound_at_index(&mut self, compound: GenericIndex<CW>, weight: CW) {
self.geometry
.add_compound_at_index(GenericIndex::<CW>::new(compound.petgraph_index()), weight);
.add_compound_at_index(GenericIndex::<CW>::new(compound.index()), weight);
}
pub fn add_to_compound<W>(
@ -314,10 +310,10 @@ impl<
BW: AccessBendWeight + Into<PW> + GetLayer,
CW: Clone,
Cel: 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,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetIndex + Into<PI> + Copy,
SI: GetIndex + Into<PI> + Copy,
BI: GetIndex + Into<PI> + Copy,
> GeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{
fn init_dot_bbox(&mut self, dot: DI) {
@ -443,10 +439,10 @@ impl<
BW: AccessBendWeight + Into<PW> + GetLayer,
CW: Clone,
Cel: 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,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + PartialEq + Copy,
DI: GetIndex + Into<PI> + Copy,
SI: GetIndex + Into<PI> + Copy,
BI: GetIndex + Into<PI> + Copy,
> ManageCompounds<CW> for GeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{
type GeneralIndex = PI;
@ -467,7 +463,7 @@ impl<
fn add_to_compound<I>(&mut self, primitive: I, label: Cel, compound: GenericIndex<CW>)
where
I: Copy + GetPetgraphIndex,
I: Copy + GetIndex,
{
self.geometry.add_to_compound(primitive, label, compound);
}
@ -485,7 +481,7 @@ impl<
fn compounds<I>(&self, node: I) -> impl Iterator<Item = (Cel, GenericIndex<CW>)>
where
I: Copy + GetPetgraphIndex,
I: Copy + GetIndex,
{
self.geometry.compounds(node)
}
@ -498,10 +494,10 @@ impl<
BW: AccessBendWeight + Into<PW> + GetLayer,
CW: Clone,
Cel: Copy,
PI: GetPetgraphIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
SI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
BI: GetPetgraphIndex + Into<PI> + Eq + Ord + Copy,
PI: GetIndex + TryInto<DI> + TryInto<SI> + TryInto<BI> + Eq + Ord + Copy,
DI: GetIndex + Into<PI> + Eq + Ord + Copy,
SI: GetIndex + Into<PI> + Eq + Ord + Copy,
BI: GetIndex + Into<PI> + Eq + Ord + Copy,
> ApplyGeometryEdit<DW, SW, BW, CW, Cel, PI, DI, SI, BI>
for GeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
{
@ -563,8 +559,7 @@ impl<
// Despite this method's name, it actually does not add the
// dot, it updates it.
geometry
.add_dot_at_index(GenericIndex::<DW>::new(dot.petgraph_index()), *weight);
geometry.add_dot_at_index(GenericIndex::<DW>::new(dot.index()), *weight);
})
}
}
@ -592,7 +587,7 @@ impl<
for (bend, (.., maybe_new_data)) in &edit.bends {
if let Some(((from, to, core, ..), weight)) = maybe_new_data {
self.geometry.add_bend_at_index(
GenericIndex::<BW>::new(bend.petgraph_index()),
GenericIndex::<BW>::new(bend.index()),
*from,
*to,
*core,
@ -622,7 +617,7 @@ impl<
for (entry_label, member) in members {
self.geometry.add_to_compound(
GenericIndex::<PW>::new(member.petgraph_index()),
GenericIndex::<PW>::new(member.index()),
*entry_label,
*compound,
);

12
src/graph.rs
View File

@ -14,13 +14,13 @@ pub trait MakeRef<'a, C> {
}
#[enum_dispatch]
pub trait GetPetgraphIndex {
fn petgraph_index(&self) -> NodeIndex<usize>;
pub trait GetIndex {
fn index(&self) -> NodeIndex<usize>;
}
impl GetPetgraphIndex for NodeIndex<usize> {
impl GetIndex for NodeIndex<usize> {
#[inline(always)]
fn petgraph_index(&self) -> NodeIndex<usize> {
fn index(&self) -> NodeIndex<usize> {
*self
}
}
@ -92,9 +92,9 @@ impl<W> core::hash::Hash for GenericIndex<W> {
}
}
impl<W> GetPetgraphIndex for GenericIndex<W> {
impl<W> GetIndex for GenericIndex<W> {
#[inline]
fn petgraph_index(&self) -> NodeIndex<usize> {
fn index(&self) -> NodeIndex<usize> {
self.node_index
}
}

6
src/layout/collect_bands.rs
View File

@ -23,7 +23,7 @@ use crate::{
shape::AccessShape,
GenericNode,
},
graph::GetPetgraphIndex,
graph::GetIndex,
layout::{Layout, NodeIndex},
math::{intersect_linestring_and_ray, LineInGeneralForm, LineIntersection},
};
@ -121,7 +121,7 @@ impl<R: AccessRules> Layout<R> {
.filter(|(_, band_uid, _)| {
// filter entries which are connected to either lhs or rhs (and possibly both)
let (bts1, bts2) = band_uid.into();
let (bts1, bts2) = (bts1.petgraph_index(), bts2.petgraph_index());
let (bts1, bts2) = (bts1.index(), bts2.index());
let geometry = self.drawing.geometry();
[(bts1, left), (bts1, right), (bts2, left), (bts2, right)]
.iter()
@ -162,7 +162,7 @@ impl<R: AccessRules> Layout<R> {
.filter(|(_, band_uid, _)| {
// filter entries which are connected to rhs
let (bts1, bts2) = band_uid.into();
let (bts1, bts2) = (bts1.petgraph_index(), bts2.petgraph_index());
let (bts1, bts2) = (bts1.index(), bts2.index());
let geometry = self.drawing.geometry();
[(bts1, right), (bts2, right)]
.iter()

26
src/layout/layout.rs
View File

@ -32,7 +32,7 @@ use crate::{
shape::{AccessShape, Shape},
GenericNode, GetLayer, GetSetPos,
},
graph::{GenericIndex, GetPetgraphIndex, MakeRef},
graph::{GenericIndex, GetIndex, MakeRef},
layout::{
poly::{add_poly_with_nodes_intern, MakePolygon, PolyWeight},
via::{Via, ViaWeight},
@ -179,7 +179,7 @@ impl<R: AccessRules> Layout<R> {
}
}
Ok(GenericIndex::<ViaWeight>::new(compound.petgraph_index()))
Ok(GenericIndex::<ViaWeight>::new(compound.index()))
}
pub fn add_fixed_dot(
@ -256,7 +256,7 @@ impl<R: AccessRules> Layout<R> {
GenericIndex::<PolyWeight>::new(
self.drawing
.add_compound(recorder, CompoundWeight::Poly(weight))
.petgraph_index(),
.index(),
)
}
@ -290,7 +290,7 @@ impl<R: AccessRules> Layout<R> {
self.drawing.rtree().iter().filter_map(|wrapper| {
if let NodeIndex::Compound(compound) = wrapper.data {
if let CompoundWeight::Poly(..) = self.drawing.compound_weight(compound) {
return Some(GenericIndex::<PolyWeight>::new(compound.petgraph_index()));
return Some(GenericIndex::<PolyWeight>::new(compound.index()));
}
}
@ -311,7 +311,7 @@ impl<R: AccessRules> Layout<R> {
.filter_map(|wrapper| {
if let NodeIndex::Compound(compound) = wrapper.data {
if let CompoundWeight::Poly(..) = self.drawing.compound_weight(compound) {
return Some(GenericIndex::<PolyWeight>::new(compound.petgraph_index()));
return Some(GenericIndex::<PolyWeight>::new(compound.index()));
}
}
@ -325,12 +325,12 @@ impl<R: AccessRules> Layout<R> {
) -> impl Iterator<Item = (CompoundEntryLabel, PrimitiveIndex)> + '_ {
self.drawing
.geometry()
.compound_members(GenericIndex::new(poly.petgraph_index()))
.compound_members(GenericIndex::new(poly.index()))
}
fn compound_shape(&self, compound: GenericIndex<CompoundWeight>) -> Shape {
match self.drawing.compound_weight(compound) {
CompoundWeight::Poly(_) => GenericIndex::<PolyWeight>::new(compound.petgraph_index())
CompoundWeight::Poly(_) => GenericIndex::<PolyWeight>::new(compound.index())
.ref_(self)
.shape()
.into(),
@ -360,11 +360,8 @@ impl<R: AccessRules> Layout<R> {
let PrimitiveIndex::FixedDot(dot) = index else {
return None;
};
if let GenericNode::Primitive(PrimitiveWeight::FixedDot(weight)) = drawing
.geometry()
.graph()
.node_weight(dot.petgraph_index())
.unwrap()
if let GenericNode::Primitive(PrimitiveWeight::FixedDot(weight)) =
drawing.geometry().graph().node_weight(dot.index()).unwrap()
{
Some((dot, weight))
} else {
@ -378,7 +375,7 @@ impl<R: AccessRules> Layout<R> {
.drawing()
.geometry()
// TODO: Add `.compounds()` method working on `PrimitiveIndex`.
.compounds(GenericIndex::<()>::new(primitive.petgraph_index()))
.compounds(GenericIndex::<()>::new(primitive.index()))
.next()
.is_some()
{
@ -388,8 +385,7 @@ impl<R: AccessRules> Layout<R> {
}
NodeIndex::Compound(compound) => Some(match self.drawing.compound_weight(compound) {
CompoundWeight::Poly(_) => {
let poly =
GenericIndex::<PolyWeight>::new(compound.petgraph_index()).ref_(self);
let poly = GenericIndex::<PolyWeight>::new(compound.index()).ref_(self);
(poly.apex(), poly.shape().center())
}
CompoundWeight::Via(weight) => {

12
src/layout/poly.rs
View File

@ -21,7 +21,7 @@ use crate::{
Drawing,
},
geometry::{compound::ManageCompounds, GetLayer, GetSetPos},
graph::{GenericIndex, GetPetgraphIndex, MakeRef},
graph::{GenericIndex, GetIndex, MakeRef},
layout::{CompoundEntryLabel, CompoundWeight, Layout, LayoutEdit},
math::Circle,
};
@ -81,7 +81,7 @@ pub(super) fn add_poly_with_nodes_intern<R: AccessRules>(
for &idx in nodes {
layout.drawing.add_to_compound(
recorder,
GenericIndex::<()>::new(idx.petgraph_index()),
GenericIndex::<()>::new(idx.index()),
CompoundEntryLabel::Normal,
poly_compound,
);
@ -123,7 +123,7 @@ pub(super) fn add_poly_with_nodes_intern<R: AccessRules>(
for Rto { idx, .. } in temp_rtree {
layout.drawing.add_to_compound(
recorder,
GenericIndex::<()>::new(idx.petgraph_index()),
GenericIndex::<()>::new(idx.index()),
CompoundEntryLabel::Apex,
poly_compound,
);
@ -234,7 +234,7 @@ pub enum PolyWeight {
impl From<GenericIndex<PolyWeight>> for GenericIndex<CompoundWeight> {
fn from(poly: GenericIndex<PolyWeight>) -> Self {
GenericIndex::<CompoundWeight>::new(poly.petgraph_index())
GenericIndex::<CompoundWeight>::new(poly.index())
}
}
@ -258,7 +258,7 @@ impl GetMaybeNet for SolidPolyWeight {
impl From<GenericIndex<SolidPolyWeight>> for GenericIndex<CompoundWeight> {
fn from(poly: GenericIndex<SolidPolyWeight>) -> Self {
GenericIndex::<CompoundWeight>::new(poly.petgraph_index())
GenericIndex::<CompoundWeight>::new(poly.index())
}
}
@ -282,6 +282,6 @@ impl GetMaybeNet for PourPolyWeight {
impl From<GenericIndex<PourPolyWeight>> for GenericIndex<CompoundWeight> {
fn from(poly: GenericIndex<PourPolyWeight>) -> Self {
GenericIndex::<CompoundWeight>::new(poly.petgraph_index())
GenericIndex::<CompoundWeight>::new(poly.index())
}
}

4
src/layout/via.rs
View File

@ -14,7 +14,7 @@ use crate::{
Drawing,
},
geometry::primitive::{DotShape, PrimitiveShape},
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
layout::{CompoundEntryLabel, CompoundWeight},
math::Circle,
};
@ -60,7 +60,7 @@ pub struct ViaWeight {
impl From<GenericIndex<ViaWeight>> for GenericIndex<CompoundWeight> {
fn from(via: GenericIndex<ViaWeight>) -> Self {
GenericIndex::<CompoundWeight>::new(via.petgraph_index())
GenericIndex::<CompoundWeight>::new(via.index())
}
}

31
src/router/navmesh.rs
View File

@ -27,7 +27,7 @@ use crate::{
graph::PrimitiveIndex,
rules::AccessRules,
},
graph::{GenericIndex, GetPetgraphIndex, MakeRef},
graph::{GenericIndex, GetIndex, MakeRef},
layout::{CompoundEntryLabel, Layout},
math::RotationSense,
router::thetastar::MakeEdgeRef,
@ -47,8 +47,8 @@ impl core::fmt::Debug for NavnodeIndex {
}
}
impl GetPetgraphIndex for NavnodeIndex {
fn petgraph_index(&self) -> NodeIndex<usize> {
impl GetIndex for NavnodeIndex {
fn index(&self) -> NodeIndex<usize> {
self.0
}
}
@ -56,7 +56,7 @@ impl GetPetgraphIndex for NavnodeIndex {
/// A binavnode is a pair of navnodes, one clockwise and the other
/// counterclockwise. Unlike their constituents, binavnodes are themselves
/// not considered navnodes.
#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[enum_dispatch(GetIndex, MakePrimitive)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BinavnodeNodeIndex {
FixedDot(FixedDotIndex),
@ -271,7 +271,7 @@ impl Navmesh {
// for each union.
for prenavnode in prenavmesh.triangulation().node_identifiers() {
let repr = PrenavmeshNodeIndex::FixedDot(GenericIndex::new(
overlapping_prenavnodes_unions.find(prenavnode.petgraph_index()),
overlapping_prenavnodes_unions.find(prenavnode.index()),
));
if repr == prenavnode {
@ -325,7 +325,7 @@ impl Navmesh {
// Ignore overlaps of a fillet.
if layout
.drawing()
.compounds(GenericIndex::<()>::new(prenavnode.petgraph_index()))
.compounds(GenericIndex::<()>::new(prenavnode.index()))
.find(|(label, _)| *label == CompoundEntryLabel::Fillet)
.is_some()
{
@ -336,7 +336,7 @@ impl Navmesh {
// Ignore overlaps with fillets.
if layout
.drawing()
.compounds(GenericIndex::<()>::new(overlapee.1.petgraph_index()))
.compounds(GenericIndex::<()>::new(overlapee.1.index()))
.find(|(label, _)| *label == CompoundEntryLabel::Fillet)
.is_some()
{
@ -347,8 +347,7 @@ impl Navmesh {
continue;
};
overlapping_prenavnodes_unions
.union(prenavnode.petgraph_index(), overlapee.petgraph_index());
overlapping_prenavnodes_unions.union(prenavnode.index(), overlapee.index());
}
}
@ -390,10 +389,10 @@ impl Navmesh {
// We assume prenavmesh nodes are fixed dots. This is an ugly shortcut,
// since fixed bends also can be prenavnodes, but it works for now.
let from_prenavnode_repr = PrenavmeshNodeIndex::FixedDot(GenericIndex::new(
overlapping_prenavnodes_unions.find(from_prenavnode.petgraph_index()),
overlapping_prenavnodes_unions.find(from_prenavnode.index()),
));
let to_prenavnode_repr = PrenavmeshNodeIndex::FixedDot(GenericIndex::new(
overlapping_prenavnodes_unions.find(to_prenavnode.petgraph_index()),
overlapping_prenavnodes_unions.find(to_prenavnode.index()),
));
Self::add_prenavedge_as_quadrinavedges(
@ -456,7 +455,7 @@ impl Data for Navmesh {
impl DataMap for Navmesh {
fn node_weight(&self, vertex: Self::NodeId) -> Option<&Self::NodeWeight> {
self.graph.node_weight(vertex.petgraph_index())
self.graph.node_weight(vertex.index())
}
fn edge_weight(&self, _edge: Self::EdgeId) -> Option<&Self::EdgeWeight> {
@ -496,11 +495,7 @@ impl<'a> IntoNeighbors for &'a Navmesh {
type Neighbors = Box<dyn Iterator<Item = NavnodeIndex> + 'a>;
fn neighbors(self, vertex: Self::NodeId) -> Self::Neighbors {
Box::new(
self.graph
.neighbors(vertex.petgraph_index())
.map(NavnodeIndex),
)
Box::new(self.graph.neighbors(vertex.index()).map(NavnodeIndex))
}
}
@ -526,7 +521,7 @@ impl<'a> IntoEdges for &'a Navmesh {
fn edges(self, vertex: Self::NodeId) -> Self::Edges {
Box::new(
self.graph
.edges(vertex.petgraph_index())
.edges(vertex.index())
.map(|edge| NavmeshEdgeReference {
from: NavnodeIndex(edge.source()),
to: NavnodeIndex(edge.target()),

6
src/router/ng/eval.rs
View File

@ -16,7 +16,7 @@ use crate::{
rules::AccessRules,
},
geometry::{primitive::PrimitiveShape, shape::AccessShape as _, shape::MeasureLength as _},
graph::{GenericIndex, GetPetgraphIndex as _},
graph::{GenericIndex, GetIndex as _},
layout::{poly::PolyWeight, CompoundWeight},
math::{poly_ext_handover, RotationSense},
router::{
@ -270,7 +270,7 @@ impl AstarContext {
let current_poly = layout
.drawing()
.compounds(GenericIndex::<()>::new(wrap_core.petgraph_index()))
.compounds(GenericIndex::<()>::new(wrap_core.index()))
.find_map(|(_, compound)| {
if let CompoundWeight::Poly(_) = layout.drawing().compound_weight(compound)
{
@ -279,7 +279,7 @@ impl AstarContext {
None
}
})
.map(|compound| GenericIndex::<PolyWeight>::new(compound.petgraph_index()));
.map(|compound| GenericIndex::<PolyWeight>::new(compound.index()));
let (active_head, length_delta) = match (
sub.polygon.take(),

4
src/router/ng/mod.rs
View File

@ -32,7 +32,7 @@ use crate::{
shape::{AccessShape as _, MeasureLength as _},
GenericNode,
},
graph::GetPetgraphIndex as _,
graph::GetIndex as _,
layout::Layout,
math::{CachedPolyExt, RotationSense},
router::draw::{Draw, DrawException},
@ -580,7 +580,7 @@ fn cane_around<R: AccessRules>(
let inner_bend = layout
.drawing()
.geometry()
.all_rails(core.petgraph_index())
.all_rails(core.index())
.filter_map(|bi| {
if let BendIndex::Loose(lbi) = bi {
if layout.drawing().find_loose_band_uid(lbi.into()).ok() == Some(inner) {

4
src/router/ng/poly.rs
View File

@ -15,7 +15,7 @@ use crate::{
primitive::MakePrimitiveShape as _,
},
geometry::{compound::ManageCompounds, shape::AccessShape as _, GetSetPos as _},
graph::{GenericIndex, GetPetgraphIndex as _},
graph::{GenericIndex, GetIndex as _},
layout::{poly::PolyWeight, CompoundEntryLabel, Layout},
math::{is_poly_convex_hull_cw, CachedPolyExt, RotationSense},
router::ng::{
@ -52,7 +52,7 @@ impl PolygonRouting {
let convex_hull = layout
.drawing()
.geometry()
.compound_members(GenericIndex::new(polyidx.petgraph_index()))
.compound_members(GenericIndex::new(polyidx.index()))
.filter_map(|(entry_label, primitive_node)| {
let PrimitiveIndex::FixedDot(poly_dot) = primitive_node else {
return None;

10
src/router/prenavmesh.rs
View File

@ -18,7 +18,7 @@ use crate::{
seg::{FixedSegIndex, LoneLooseSegIndex, SeqLooseSegIndex},
},
geometry::{shape::AccessShape, GetLayer},
graph::{GenericIndex, GetPetgraphIndex},
graph::{GenericIndex, GetIndex},
layout::{CompoundEntryLabel, Layout},
triangulation::{GetTrianvertexNodeIndex, Triangulation},
};
@ -28,7 +28,7 @@ use super::{navmesh::NavmeshError, RouterOptions};
/// Prenavmesh nodes are the vertices of constrained Delaunay triangulation
/// before it is converted to the navmesh, which is done by multiplying each
/// of the prenavmesh nodes into more nodes, called navnodes.
#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
#[enum_dispatch(GetIndex, MakePrimitive)]
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub enum PrenavmeshNodeIndex {
FixedDot(FixedDotIndex),
@ -165,7 +165,7 @@ impl Prenavmesh {
layout
.drawing()
// TODO: Add `.compounds()` method working on `PrimitiveIndex`.
.compounds(GenericIndex::<()>::new(dot.petgraph_index()))
.compounds(GenericIndex::<()>::new(dot.index()))
.find(|(label, _)| *label == CompoundEntryLabel::Fillet)
.is_some();
@ -254,7 +254,7 @@ impl Prenavmesh {
fn is_fixed_dot_filleted(layout: &Layout<impl AccessRules>, dot: FixedDotIndex) -> bool {
layout
.drawing()
.compounds(GenericIndex::<()>::new(dot.petgraph_index()))
.compounds(GenericIndex::<()>::new(dot.index()))
.find(|(label, _)|
// Fillets fail this test for some reason that I did not investigate, so
// I added this condition.
@ -269,7 +269,7 @@ impl Prenavmesh {
layout
.drawing()
// TODO: Add `.compounds()` method working on `PrimitiveIndex`.
.compounds(GenericIndex::<()>::new(overlapee.1.petgraph_index()))
.compounds(GenericIndex::<()>::new(overlapee.1.index()))
.find(|(label, _)| *label == CompoundEntryLabel::Fillet)
.is_some()
})

39
src/triangulation.rs
View File

@ -11,7 +11,7 @@ use spade::{
handles::FixedVertexHandle, ConstrainedDelaunayTriangulation, HasPosition, InsertionError,
};
use crate::graph::GetPetgraphIndex;
use crate::graph::GetIndex;
pub trait GetTrianvertexNodeIndex<I> {
fn node_index(&self) -> I;
@ -27,7 +27,7 @@ pub struct Triangulation<I, VW: GetTrianvertexNodeIndex<I> + HasPosition, EW: De
index_marker: PhantomData<I>,
}
impl<I: GetPetgraphIndex, VW: GetTrianvertexNodeIndex<I> + HasPosition, EW: Default>
impl<I: GetIndex, VW: GetTrianvertexNodeIndex<I> + HasPosition, EW: Default>
Triangulation<I, VW, EW>
{
pub fn new(node_bound: usize) -> Self {
@ -39,15 +39,15 @@ impl<I: GetPetgraphIndex, VW: GetTrianvertexNodeIndex<I> + HasPosition, EW: Defa
}
pub fn add_vertex(&mut self, weight: VW) -> Result<(), InsertionError> {
let index = weight.node_index().petgraph_index().index();
let index = weight.node_index().index().index();
self.trianvertex_to_handle[index] =
Some(spade::Triangulation::insert(&mut self.cdt, weight)?);
Ok(())
}
pub fn add_constraint_edge(&mut self, from: VW, to: VW) -> Result<bool, InsertionError> {
let from_index = from.node_index().petgraph_index().index();
let to_index = to.node_index().petgraph_index().index();
let from_index = from.node_index().index().index();
let to_index = to.node_index().index().index();
// It is possible for one or both constraint edge endpoint vertices to
// not exist in the triangulation even after everything has been added.
@ -75,13 +75,13 @@ impl<I: GetPetgraphIndex, VW: GetTrianvertexNodeIndex<I> + HasPosition, EW: Defa
pub fn weight(&self, vertex: I) -> &VW {
spade::Triangulation::s(&self.cdt)
.vertex_data(self.trianvertex_to_handle[vertex.petgraph_index().index()].unwrap())
.vertex_data(self.trianvertex_to_handle[vertex.index().index()].unwrap())
}
pub fn weight_mut(&mut self, vertex: I) -> &mut VW {
spade::Triangulation::vertex_data_mut(
&mut self.cdt,
self.trianvertex_to_handle[vertex.petgraph_index().index()].unwrap(),
self.trianvertex_to_handle[vertex.index().index()].unwrap(),
)
}
@ -92,7 +92,7 @@ impl<I: GetPetgraphIndex, VW: GetTrianvertexNodeIndex<I> + HasPosition, EW: Defa
}
fn handle(&self, vertex: I) -> FixedVertexHandle {
self.trianvertex_to_handle[vertex.petgraph_index().index()].unwrap()
self.trianvertex_to_handle[vertex.index().index()].unwrap()
}
pub fn position(&self, vertex: I) -> Point<<VW as HasPosition>::Scalar>
@ -104,11 +104,8 @@ impl<I: GetPetgraphIndex, VW: GetTrianvertexNodeIndex<I> + HasPosition, EW: Defa
}
}
impl<
I: Copy + PartialEq + GetPetgraphIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition,
EW: Default,
> visit::GraphBase for Triangulation<I, VW, EW>
impl<I: Copy + PartialEq + GetIndex, VW: GetTrianvertexNodeIndex<I> + HasPosition, EW: Default>
visit::GraphBase for Triangulation<I, VW, EW>
{
type NodeId = I;
type EdgeId = (I, I);
@ -133,7 +130,7 @@ impl<EW> PartialOrd for TriangulationEdgeWeightWrapper<EW> {
}
impl<
I: Copy + PartialEq + GetPetgraphIndex,
I: Copy + PartialEq + GetIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition,
EW: Copy + Default,
> visit::Data for Triangulation<I, VW, EW>
@ -173,7 +170,7 @@ impl<I: Copy, EW: Copy> visit::EdgeRef for TriangulationEdgeReference<I, EW> {
impl<
'a,
I: Copy + PartialEq + GetPetgraphIndex,
I: Copy + PartialEq + GetIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition,
EW: Default,
> visit::IntoNeighbors for &'a Triangulation<I, VW, EW>
@ -191,7 +188,7 @@ impl<
impl<
'a,
I: Copy + PartialEq + GetPetgraphIndex,
I: Copy + PartialEq + GetIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::IntoEdgeReferences for &'a Triangulation<I, VW, EW>
@ -218,7 +215,7 @@ impl<
impl<
'a,
I: Copy + PartialEq + GetPetgraphIndex,
I: Copy + PartialEq + GetIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition<Scalar = f64>,
EW: Copy + Default,
> visit::IntoEdges for &'a Triangulation<I, VW, EW>
@ -248,7 +245,7 @@ impl<
impl<
'a,
I: Copy + PartialEq + GetPetgraphIndex,
I: Copy + PartialEq + GetIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition,
EW: Default,
> visit::IntoNodeIdentifiers for &'a Triangulation<I, VW, EW>
@ -298,7 +295,7 @@ impl<I: Copy, VW> visit::NodeRef for TriangulationVertexReference<'_, I, VW> {
impl<
'a,
I: Copy + PartialEq + GetPetgraphIndex,
I: Copy + PartialEq + GetIndex,
VW: GetTrianvertexNodeIndex<I> + HasPosition,
EW: Copy + Default,
> visit::IntoNodeReferences for &'a Triangulation<I, VW, EW>
@ -320,7 +317,7 @@ impl<
}
impl<
I: Copy + PartialEq + GetPetgraphIndex + std::fmt::Debug,
I: Copy + PartialEq + GetIndex + std::fmt::Debug,
VW: GetTrianvertexNodeIndex<I> + HasPosition,
EW: Default,
> visit::NodeIndexable for &Triangulation<I, VW, EW>
@ -331,7 +328,7 @@ impl<
}
fn to_index(&self, node: I) -> usize {
node.petgraph_index().index()
node.index().index()
}
fn from_index(&self, index: usize) -> I {

8
tests/common/mod.rs
View File

@ -14,7 +14,7 @@ use topola::{
board::{edit::BoardEdit, AccessMesadata, Board},
drawing::graph::{GetMaybeNet, PrimitiveIndex},
geometry::{shape::MeasureLength, GenericNode, GetLayer},
graph::{GetPetgraphIndex, MakeRef},
graph::{GetIndex, MakeRef},
router::{navmesh::Navmesh, RouterOptions},
specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata},
};
@ -217,8 +217,8 @@ pub fn assert_single_layer_groundless_autoroute(
if let Some(netname) = autorouter.board().layout().rules().net_netname(net) {
// We don't route ground.
let org = unionfind.find(origin_dot.petgraph_index());
let desc = unionfind.find(destination_dot.petgraph_index());
let org = unionfind.find(origin_dot.index());
let desc = unionfind.find(destination_dot.index());
if netname != "GND" {
assert_eq!(org, desc);
@ -282,7 +282,7 @@ fn unionfind(autorouter: &mut Autorouter<impl AccessMesadata>) -> UnionFind<Node
.geometry()
.joineds(primitive)
{
unionfind.union(primitive.petgraph_index(), joined.petgraph_index());
unionfind.union(primitive.index(), joined.index());
}
}