diff --git a/src/autorouter/autorouter.rs b/src/autorouter/autorouter.rs
index f5f66ea..dfa7531 100644
--- a/src/autorouter/autorouter.rs
+++ b/src/autorouter/autorouter.rs
@@ -13,7 +13,7 @@ use crate::{
     drawing::{dot::FixedDotIndex, Infringement},
     layout::via::ViaWeight,
     router::{navmesh::NavmeshError, RouterError},
-    triangulation::GetTrianvertexIndex,
+    triangulation::GetTrianvertexNodeIndex,
 };
 
 #[derive(Error, Debug, Clone)]
@@ -100,7 +100,7 @@ impl<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())
diff --git a/src/autorouter/ratsnest.rs b/src/autorouter/ratsnest.rs
index b4ace6f..059d1f9 100644
--- a/src/autorouter/ratsnest.rs
+++ b/src/autorouter/ratsnest.rs
@@ -12,22 +12,22 @@ use spade::{HasPosition, InsertionError, Point2};
 
 use crate::{
     drawing::{
-        band::BandIndex,
+        band::BandFirstSegIndex,
         dot::FixedDotIndex,
         graph::{GetMaybeNet, MakePrimitive, PrimitiveIndex},
         primitive::MakePrimitiveShape,
         rules::RulesTrait,
     },
     geometry::{compound::CompoundManagerTrait, shape::ShapeTrait},
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
     layout::{
         zone::{MakePolyShape, ZoneWeight},
         Layout,
     },
-    triangulation::{GetTrianvertexIndex, Triangulation},
+    triangulation::{GetTrianvertexNodeIndex, Triangulation},
 };
 
-#[enum_dispatch(GetNodeIndex)]
+#[enum_dispatch(GetPetgraphIndex)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum RatvertexIndex {
     FixedDot(FixedDotIndex),
@@ -49,8 +49,8 @@ pub struct RatvertexWeight {
     pub pos: Point,
 }
 
-impl GetTrianvertexIndex<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);
     }
 
diff --git a/src/autorouter/selection.rs b/src/autorouter/selection.rs
index 9abe479..fdf1c99 100644
--- a/src/autorouter/selection.rs
+++ b/src/autorouter/selection.rs
@@ -6,7 +6,7 @@ use crate::{
     board::{mesadata::MesadataTrait, Board},
     drawing::graph::{GetLayer, MakePrimitive},
     geometry::compound::CompoundManagerTrait,
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
     layout::{zone::ZoneWeight, CompoundWeight, NodeIndex},
 };
 
@@ -70,7 +70,7 @@ impl Selection {
                 {
                     board
                         .layout()
-                        .zone(GenericIndex::<ZoneWeight>::new(compound.node_index()))
+                        .zone(GenericIndex::<ZoneWeight>::new(compound.petgraph_index()))
                         .layer()
                 } else {
                     unreachable!()
diff --git a/src/bin/topola-egui/app.rs b/src/bin/topola-egui/app.rs
index 3661c88..08a80a3 100644
--- a/src/bin/topola-egui/app.rs
+++ b/src/bin/topola-egui/app.rs
@@ -33,7 +33,7 @@ use topola::{
     math::Circle,
     router::{
         draw::DrawException,
-        navmesh::{Navmesh, NavmeshEdgeReference, NavvertexIndex},
+        navmesh::{Navmesh, NavmeshEdgeReference, NavvertexNodeIndex},
         tracer::{Trace, Tracer},
     },
     specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata},
@@ -49,7 +49,7 @@ pub struct SharedData {
     pub from: Option<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>,
 }
diff --git a/src/bin/topola-egui/overlay.rs b/src/bin/topola-egui/overlay.rs
index e978f12..5db8842 100644
--- a/src/bin/topola-egui/overlay.rs
+++ b/src/bin/topola-egui/overlay.rs
@@ -15,7 +15,7 @@ use topola::{
         compound::CompoundManagerTrait,
         shape::{Shape, ShapeTrait},
     },
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
     layout::{
         via::ViaWeight,
         zone::{MakePolyShape, Zone, ZoneWeight},
@@ -80,19 +80,19 @@ impl Overlay {
             NodeIndex::Compound(compound) => {
                 match board.layout().drawing().compound_weight(compound) {
                     /*CompoundWeight::Zone(zone) => Zone::new(
-                        GenericIndex::<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(),
                 }
diff --git a/src/bin/topola-sdl2-demo/main.rs b/src/bin/topola-sdl2-demo/main.rs
index a1aac27..d561c67 100644
--- a/src/bin/topola-sdl2-demo/main.rs
+++ b/src/bin/topola-sdl2-demo/main.rs
@@ -25,7 +25,7 @@ use topola::geometry::shape::ShapeTrait;
 use topola::layout::zone::MakePolyShape;
 use topola::layout::Layout;
 use topola::router::draw::DrawException;
-use topola::router::navmesh::{Navmesh, NavmeshEdgeReference, NavvertexIndex};
+use topola::router::navmesh::{Navmesh, NavmeshEdgeReference, NavvertexNodeIndex};
 use topola::router::tracer::{Trace, Tracer};
 use topola::specctra::design::SpecctraDesign;
 use topola::specctra::mesadata::SpecctraMesadata;
@@ -225,7 +225,7 @@ fn render_times(
     mut router_or_layout: RouterOrLayout<impl RulesTrait>,
     _unused: Option<()>,
     mut maybe_navmesh: Option<Navmesh>,
-    path: &[NavvertexIndex],
+    path: &[NavvertexNodeIndex],
     ghosts: &[PrimitiveShape],
     highlighteds: &[PrimitiveIndex],
     times: i64,
diff --git a/src/board/board.rs b/src/board/board.rs
index 0b13589..a698470 100644
--- a/src/board/board.rs
+++ b/src/board/board.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use crate::{
     board::mesadata::MesadataTrait,
     drawing::{
-        band::BandIndex,
+        band::BandFirstSegIndex,
         dot::{FixedDotIndex, FixedDotWeight},
         graph::{GetLayer, GetMaybeNet},
         seg::{FixedSegIndex, FixedSegWeight},
@@ -22,7 +22,7 @@ use crate::{
 pub struct Board<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()))
diff --git a/src/drawing/band.rs b/src/drawing/band.rs
index e486a8c..b7d497a 100644
--- a/src/drawing/band.rs
+++ b/src/drawing/band.rs
@@ -1,7 +1,7 @@
 use crate::drawing::seg::{LoneLooseSegIndex, SeqLooseSegIndex};
 
 #[derive(Debug, Hash, Clone, Copy, Eq, PartialEq)]
-pub enum BandIndex {
+pub enum BandFirstSegIndex {
     Straight(LoneLooseSegIndex),
     Bended(SeqLooseSegIndex),
 }
diff --git a/src/drawing/bend.rs b/src/drawing/bend.rs
index 9ee4d37..aaad578 100644
--- a/src/drawing/bend.rs
+++ b/src/drawing/bend.rs
@@ -8,12 +8,12 @@ use crate::{
         Drawing,
     },
     geometry::{BendWeightTrait, GetOffset, GetWidth, SetOffset},
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
 };
 
 use petgraph::stable_graph::NodeIndex;
 
-#[enum_dispatch(GetNodeIndex, MakePrimitive)]
+#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum BendIndex {
     Fixed(FixedBendIndex),
diff --git a/src/drawing/dot.rs b/src/drawing/dot.rs
index 0fb2982..bede8d7 100644
--- a/src/drawing/dot.rs
+++ b/src/drawing/dot.rs
@@ -11,11 +11,11 @@ use crate::{
         Drawing,
     },
     geometry::{DotWeightTrait, GetPos, GetWidth, SetPos},
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
     math::Circle,
 };
 
-#[enum_dispatch(GetNodeIndex, MakePrimitive)]
+#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DotIndex {
     Fixed(FixedDotIndex),
diff --git a/src/drawing/drawing.rs b/src/drawing/drawing.rs
index b1dbee4..2eccb34 100644
--- a/src/drawing/drawing.rs
+++ b/src/drawing/drawing.rs
@@ -6,7 +6,7 @@ use rstar::{RTree, AABB};
 use thiserror::Error;
 
 use crate::drawing::{
-    band::BandIndex,
+    band::BandFirstSegIndex,
     bend::{BendIndex, BendWeight, FixedBendIndex, LooseBendIndex, LooseBendWeight},
     cane::Cane,
     collect::Collect,
@@ -32,7 +32,7 @@ use crate::geometry::{
     BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetOffset, GetPos,
     GetWidth, SegWeightTrait,
 };
-use crate::graph::{GenericIndex, GetNodeIndex};
+use crate::graph::{GenericIndex, GetPetgraphIndex};
 use crate::math::NoTangents;
 
 #[enum_dispatch]
@@ -85,12 +85,12 @@ impl<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(),
diff --git a/src/drawing/graph.rs b/src/drawing/graph.rs
index 4ea0273..0902a9c 100644
--- a/src/drawing/graph.rs
+++ b/src/drawing/graph.rs
@@ -2,7 +2,7 @@ use enum_dispatch::enum_dispatch;
 
 use petgraph::stable_graph::NodeIndex;
 
-use crate::{drawing::Drawing, graph::GetNodeIndex};
+use crate::{drawing::Drawing, graph::GetPetgraphIndex};
 
 use super::{
     bend::{FixedBendIndex, FixedBendWeight, LooseBendIndex, LooseBendWeight},
@@ -85,7 +85,7 @@ macro_rules! impl_loose_weight {
 
 // TODO: This enum shouldn't exist: we shouldn't be carrying the tag around like this. Instead we
 // should be getting it from the graph when it's needed.
-#[enum_dispatch(GetNodeIndex, MakePrimitive)]
+#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
 #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
 pub enum PrimitiveIndex {
     FixedDot(FixedDotIndex),
diff --git a/src/drawing/loose.rs b/src/drawing/loose.rs
index e22e6d7..564e88c 100644
--- a/src/drawing/loose.rs
+++ b/src/drawing/loose.rs
@@ -10,7 +10,7 @@ use crate::{
         primitive::{GetJoints, LoneLooseSeg, LooseBend, LooseDot, Primitive, SeqLooseSeg},
         seg::{LoneLooseSegIndex, SeqLooseSegIndex},
     },
-    graph::GetNodeIndex,
+    graph::GetPetgraphIndex,
 };
 
 use super::rules::RulesTrait;
@@ -20,7 +20,7 @@ pub trait GetNextLoose {
     fn next_loose(&self, maybe_prev: Option<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())
diff --git a/src/drawing/primitive.rs b/src/drawing/primitive.rs
index 48b2e5d..8d0eb66 100644
--- a/src/drawing/primitive.rs
+++ b/src/drawing/primitive.rs
@@ -15,7 +15,7 @@ use crate::{
         Drawing,
     },
     geometry::GenericNode,
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
 };
 
 #[enum_dispatch]
@@ -55,10 +55,12 @@ pub trait GetInterior<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()),
         )
     }
 }
diff --git a/src/drawing/seg.rs b/src/drawing/seg.rs
index 7c72ae2..dcd8640 100644
--- a/src/drawing/seg.rs
+++ b/src/drawing/seg.rs
@@ -8,12 +8,12 @@ use crate::{
         Drawing,
     },
     geometry::{GetWidth, SegWeightTrait},
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
 };
 
 use petgraph::stable_graph::NodeIndex;
 
-#[enum_dispatch(GetNodeIndex, MakePrimitive)]
+#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum SegIndex {
     Fixed(FixedSegIndex),
diff --git a/src/drawing/wraparoundable.rs b/src/drawing/wraparoundable.rs
index 611751a..6087d21 100644
--- a/src/drawing/wraparoundable.rs
+++ b/src/drawing/wraparoundable.rs
@@ -10,15 +10,15 @@ use crate::{
         rules::RulesTrait,
         Drawing,
     },
-    graph::GetNodeIndex,
+    graph::GetPetgraphIndex,
 };
 
 #[enum_dispatch]
-pub trait GetWraparound: GetNodeIndex {
+pub trait GetWraparound: GetPetgraphIndex {
     fn wraparound(&self) -> Option<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>),
diff --git a/src/geometry/compound.rs b/src/geometry/compound.rs
index c80873a..0be1fff 100644
--- a/src/geometry/compound.rs
+++ b/src/geometry/compound.rs
@@ -1,6 +1,6 @@
-use crate::graph::{GenericIndex, GetNodeIndex};
+use crate::graph::{GenericIndex, GetPetgraphIndex};
 
-pub trait CompoundManagerTrait<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>);
diff --git a/src/geometry/geometry.rs b/src/geometry/geometry.rs
index 90946d0..97c2ab1 100644
--- a/src/geometry/geometry.rs
+++ b/src/geometry/geometry.rs
@@ -21,7 +21,7 @@ use crate::{
         compound::CompoundManagerTrait,
         primitive::{BendShape, DotShape, PrimitiveShape, SegShape},
     },
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
     math::Circle,
 };
 
@@ -75,10 +75,10 @@ pub struct Geometry<
     SW: SegWeightTrait<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
                 )
diff --git a/src/geometry/with_rtree.rs b/src/geometry/with_rtree.rs
index 6cbfca9..041ad2a 100644
--- a/src/geometry/with_rtree.rs
+++ b/src/geometry/with_rtree.rs
@@ -13,7 +13,7 @@ use crate::{
         BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetWidth,
         SegWeightTrait,
     },
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
 };
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -43,10 +43,10 @@ pub struct GeometryWithRtree<
     SW: SegWeightTrait<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>
 {
diff --git a/src/graph.rs b/src/graph.rs
index 48ae2d9..b9d47c7 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -9,8 +9,8 @@ use petgraph::stable_graph::NodeIndex;
 // Due to apparent limitations of enum_dispatch we're forced to import some types backwards.
 
 #[enum_dispatch]
-pub trait GetNodeIndex {
-    fn node_index(&self) -> NodeIndex<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
     }
 }
diff --git a/src/layout/layout.rs b/src/layout/layout.rs
index 7e3c87a..3b4c82d 100644
--- a/src/layout/layout.rs
+++ b/src/layout/layout.rs
@@ -5,7 +5,7 @@ use rstar::AABB;
 
 use crate::{
     drawing::{
-        band::BandIndex,
+        band::BandFirstSegIndex,
         bend::LooseBendWeight,
         cane::Cane,
         dot::{DotIndex, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight},
@@ -20,7 +20,7 @@ use crate::{
         Drawing, Infringement, LayoutException,
     },
     geometry::{compound::CompoundManagerTrait, primitive::PrimitiveShapeTrait, GenericNode},
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
     layout::{
         via::{Via, ViaWeight},
         zone::{Zone, ZoneWeight},
@@ -46,7 +46,7 @@ impl<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> {
diff --git a/src/layout/via.rs b/src/layout/via.rs
index f265717..caca2d7 100644
--- a/src/layout/via.rs
+++ b/src/layout/via.rs
@@ -6,7 +6,7 @@ use crate::{
         compound::CompoundManagerTrait,
         primitive::{DotShape, PrimitiveShape},
     },
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
     layout::{CompoundWeight, Layout},
     math::Circle,
 };
@@ -54,7 +54,7 @@ pub struct ViaWeight {
 
 impl From<GenericIndex<ViaWeight>> for GenericIndex<CompoundWeight> {
     fn from(via: GenericIndex<ViaWeight>) -> Self {
-        GenericIndex::<CompoundWeight>::new(via.node_index())
+        GenericIndex::<CompoundWeight>::new(via.petgraph_index())
     }
 }
 
diff --git a/src/layout/zone.rs b/src/layout/zone.rs
index 8d9477b..44ec117 100644
--- a/src/layout/zone.rs
+++ b/src/layout/zone.rs
@@ -11,7 +11,7 @@ use crate::{
         seg::SegIndex,
     },
     geometry::{compound::CompoundManagerTrait, poly::PolyShape, GetPos},
-    graph::{GenericIndex, GetNodeIndex},
+    graph::{GenericIndex, GetPetgraphIndex},
     layout::{CompoundWeight, Layout},
 };
 
@@ -130,7 +130,7 @@ pub enum ZoneWeight {
 
 impl From<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())
     }
 }
diff --git a/src/router/draw.rs b/src/router/draw.rs
index 874bfa9..cafb2ab 100644
--- a/src/router/draw.rs
+++ b/src/router/draw.rs
@@ -4,7 +4,7 @@ use thiserror::Error;
 
 use crate::{
     drawing::{
-        band::BandIndex,
+        band::BandFirstSegIndex,
         bend::{BendIndex, LooseBendWeight},
         dot::{DotIndex, FixedDotIndex, LooseDotIndex, LooseDotWeight},
         graph::{GetLayer, GetMaybeNet, MakePrimitive},
@@ -51,7 +51,7 @@ impl<'a, R: RulesTrait> Draw<'a, R> {
         head: Head,
         into: FixedDotIndex,
         width: f64,
-    ) -> Result<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(),
diff --git a/src/router/navmesh.rs b/src/router/navmesh.rs
index fb67a4b..4a78724 100644
--- a/src/router/navmesh.rs
+++ b/src/router/navmesh.rs
@@ -19,55 +19,55 @@ use crate::{
         rules::RulesTrait,
         Drawing,
     },
-    graph::GetNodeIndex,
+    graph::GetPetgraphIndex,
     layout::Layout,
-    triangulation::{GetTrianvertexIndex, Triangulation, TriangulationEdgeReference},
+    triangulation::{GetTrianvertexNodeIndex, Triangulation, TriangulationEdgeReference},
 };
 
-#[enum_dispatch(GetNodeIndex, MakePrimitive)]
+#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
 #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
-pub enum NavvertexIndex {
+pub enum NavvertexNodeIndex {
     FixedDot(FixedDotIndex),
     FixedBend(FixedBendIndex),
     LooseBend(LooseBendIndex),
 }
 
-#[enum_dispatch(GetNodeIndex, MakePrimitive)]
+#[enum_dispatch(GetPetgraphIndex, MakePrimitive)]
 #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
-enum TrianvertexIndex {
+enum TrianvertexNodeIndex {
     FixedDot(FixedDotIndex),
     FixedBend(FixedBendIndex),
 }
 
-impl From<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())),
         )
     }
diff --git a/src/router/router.rs b/src/router/router.rs
index 4a064dc..940e45c 100644
--- a/src/router/router.rs
+++ b/src/router/router.rs
@@ -4,7 +4,7 @@ use thiserror::Error;
 
 use crate::{
     drawing::{
-        band::BandIndex,
+        band::BandFirstSegIndex,
         dot::FixedDotIndex,
         graph::{MakePrimitive, PrimitiveIndex},
         primitive::MakePrimitiveShape,
@@ -15,7 +15,7 @@ use crate::{
     router::{
         astar::{astar, AstarError, AstarStrategy, PathTracker},
         draw::DrawException,
-        navmesh::{Navmesh, NavmeshEdgeReference, NavmeshError, NavvertexIndex},
+        navmesh::{Navmesh, NavmeshEdgeReference, NavmeshError, NavvertexNodeIndex},
         tracer::{Trace, Tracer},
     },
 };
@@ -44,12 +44,14 @@ impl<'a, R: RulesTrait> RouterAstarStrategy<'a, R> {
     }
 }
 
-impl<'a, R: RulesTrait> AstarStrategy<&Navmesh, f64, BandIndex> for RouterAstarStrategy<'a, R> {
+impl<'a, R: RulesTrait> AstarStrategy<&Navmesh, f64, BandFirstSegIndex>
+    for RouterAstarStrategy<'a, R>
+{
     fn is_goal(
         &mut self,
-        vertex: NavvertexIndex,
+        vertex: NavvertexNodeIndex,
         tracker: &PathTracker<&Navmesh>,
-    ) -> Option<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);
diff --git a/src/router/tracer.rs b/src/router/tracer.rs
index 8d17c26..c5f5364 100644
--- a/src/router/tracer.rs
+++ b/src/router/tracer.rs
@@ -2,7 +2,7 @@ use contracts::debug_ensures;
 
 use crate::{
     drawing::{
-        band::BandIndex,
+        band::BandFirstSegIndex,
         bend::LooseBendIndex,
         dot::FixedDotIndex,
         guide::{BareHead, CaneHead, Head},
@@ -11,13 +11,13 @@ use crate::{
     layout::Layout,
     router::{
         draw::{Draw, DrawException},
-        navmesh::NavvertexIndex,
+        navmesh::NavvertexNodeIndex,
     },
 };
 
 #[derive(Debug)]
 pub struct Trace {
-    pub path: Vec<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)
             }
         }
diff --git a/src/specctra/design.rs b/src/specctra/design.rs
index 1696fad..2958db2 100644
--- a/src/specctra/design.rs
+++ b/src/specctra/design.rs
@@ -671,7 +671,7 @@ impl SpecctraDesign {
                 maybe_net: Some(net),
             },
             // TODO: This manual retagging shouldn't be necessary, `.into()` should suffice.
-            //GenericIndex::new(zone.node_index()).into(),
+            //GenericIndex::new(zone.petgraph_index()).into(),
             zone,
         );
 
diff --git a/src/triangulation.rs b/src/triangulation.rs
index 863871f..39e6776 100644
--- a/src/triangulation.rs
+++ b/src/triangulation.rs
@@ -4,16 +4,16 @@ use geo::{point, EuclideanDistance, Point};
 use petgraph::visit;
 use spade::{handles::FixedVertexHandle, DelaunayTriangulation, HasPosition, InsertionError};
 
-use crate::graph::GetNodeIndex;
+use crate::graph::GetPetgraphIndex;
 
-pub trait GetTrianvertexIndex<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()
     }
 }
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index cdd27c8..d0ee299 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -9,7 +9,7 @@ use topola::{
     },
     board::{mesadata::MesadataTrait, Board},
     drawing::graph::{GetLayer, GetMaybeNet},
-    graph::GetNodeIndex,
+    graph::GetPetgraphIndex,
     specctra::{design::SpecctraDesign, mesadata::SpecctraMesadata},
 };
 
@@ -121,8 +121,8 @@ pub fn assert_single_layer_groundless_autoroute(
             if netname != "GND" {
                 dbg!(source_dot, target_dot);
                 assert_eq!(
-                    unionfind.find(source_dot.node_index()),
-                    unionfind.find(target_dot.node_index())
+                    unionfind.find(source_dot.petgraph_index()),
+                    unionfind.find(target_dot.petgraph_index())
                 );
             }
         }
@@ -179,7 +179,7 @@ fn unionfind(autorouter: &mut Autorouter<impl MesadataTrait>) -> UnionFind<NodeI
             .geometry()
             .joineds(primitive)
         {
-            unionfind.union(primitive.node_index(), joined.node_index());
+            unionfind.union(primitive.petgraph_index(), joined.petgraph_index());
         }
     }