From 50597653ad70e0bff9ad5b1f94a70283c7169fee Mon Sep 17 00:00:00 2001
From: Mikolaj Wielgus <wielgusmikolaj@gmail.com>
Date: Sun, 14 Sep 2025 23:42:47 +0200
Subject: [PATCH] refactor(geometry/geometry): Remove `.graph()` and its
 remaining usages

This will allow us to store the dots, segs, bends differently than currently.
---
 src/autorouter/ratsnest.rs           |   2 +-
 src/drawing/cane.rs                  |   9 +-
 src/drawing/drawing.rs               | 137 ++++++++-------------------
 src/drawing/primitive.rs             |  30 +-----
 src/geometry/geometry.rs             |  10 +-
 src/geometry/recording_with_rtree.rs |   4 +-
 src/geometry/with_rtree.rs           |   4 +-
 src/layout/layout.rs                 |   9 +-
 src/router/prenavmesh.rs             |   1 -
 9 files changed, 58 insertions(+), 148 deletions(-)

diff --git a/src/autorouter/ratsnest.rs b/src/autorouter/ratsnest.rs
index b393a9c..b3df1b9 100644
--- a/src/autorouter/ratsnest.rs
+++ b/src/autorouter/ratsnest.rs
@@ -9,7 +9,7 @@ use std::{
 
 use enum_dispatch::enum_dispatch;
 use geo::Point;
-use petgraph::{data::Element, prelude::StableUnGraph, visit::NodeIndexable};
+use petgraph::{data::Element, prelude::StableUnGraph};
 use spade::{handles::FixedVertexHandle, HasPosition, InsertionError, Point2};
 
 use crate::{
diff --git a/src/drawing/cane.rs b/src/drawing/cane.rs
index 861f131..a5a7a41 100644
--- a/src/drawing/cane.rs
+++ b/src/drawing/cane.rs
@@ -5,8 +5,7 @@
 use super::{
     bend::LooseBendIndex,
     dot::LooseDotIndex,
-    graph::PrimitiveIndex,
-    primitive::{GetInterior, GetJoints, GetOtherJoint, LooseBendRef, LooseDotRef},
+    primitive::{GetJoints, GetOtherJoint, LooseBendRef, LooseDotRef},
     rules::AccessRules,
     seg::SeqLooseSegIndex,
     Drawing,
@@ -37,12 +36,6 @@ impl Cane {
     }
 }
 
-impl GetInterior<PrimitiveIndex> for Cane {
-    fn interior(&self) -> Vec<PrimitiveIndex> {
-        vec![self.bend.into(), self.dot.into(), self.seg.into()]
-    }
-}
-
 impl GetJoints for Cane {
     type F = SeqLooseSegIndex;
     type T = LooseBendIndex;
diff --git a/src/drawing/drawing.rs b/src/drawing/drawing.rs
index fd9b873..0ca15e9 100644
--- a/src/drawing/drawing.rs
+++ b/src/drawing/drawing.rs
@@ -184,7 +184,7 @@ impl<CW, Cel, R> Drawing<CW, Cel, R> {
     }
 
     pub fn node_count(&self) -> usize {
-        self.recording_geometry_with_rtree.graph().node_count()
+        self.recording_geometry_with_rtree.node_count()
     }
 }
 
@@ -293,9 +293,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(())
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     pub fn add_fixed_dot(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -304,15 +303,13 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         self.add_dot(recorder, weight, &|_drawing, _infringer, _infringee| true)
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() - 1))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() - 1))]
     pub fn remove_fixed_dot(&mut self, recorder: &mut DrawingEdit<CW, Cel>, dot: FixedDotIndex) {
         self.recording_geometry_with_rtree
             .remove_dot(recorder, dot.into());
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
     pub fn add_fixed_dot_infringably(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -321,8 +318,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         self.add_dot_infringably(recorder, weight)
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn add_dot<W: AccessDotWeight + Into<PrimitiveWeight> + GetLayer>(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -338,9 +335,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(dot)
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     pub fn add_fixed_seg(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -357,8 +353,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         )
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 2))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
     pub fn add_fixed_seg_infringably(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -369,10 +364,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         self.add_seg_infringably(recorder, from.into(), to.into(), weight)
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 2))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     pub fn add_lone_loose_seg(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -390,10 +383,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(seg)
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 2))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     pub fn add_seq_loose_seg(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -412,8 +403,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(seg)
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() - 1))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() - 2))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() - 1))]
     pub fn remove_termseg(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -423,10 +413,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
             .remove_seg(recorder, termseg.into())
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() >= old(self.recording_geometry_with_rtree.graph().edge_count() + 2))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn add_seg<W: AccessSegWeight + Into<PrimitiveWeight> + GetLayer>(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -484,11 +472,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(seg)
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 3)
-        || self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 4))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn add_loose_bend(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -530,10 +515,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         }
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 3))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn add_core_bend<W: AccessBendWeight + Into<PrimitiveWeight> + GetLayer>(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -554,10 +537,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(bend)
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 4))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn add_outer_bend(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -567,29 +548,10 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         weight: LooseBendWeight,
         filter: &impl Fn(&Self, PrimitiveIndex, PrimitiveIndex) -> bool,
     ) -> Result<GenericIndex<LooseBendWeight>, Infringement> {
-        let core = *self
-            .recording_geometry_with_rtree
-            .graph()
-            .neighbors(inner.index().into())
-            .filter(|ni| {
-                matches!(
-                    self.recording_geometry_with_rtree
-                        .graph()
-                        .edge_weight(
-                            self.recording_geometry_with_rtree
-                                .graph()
-                                .find_edge(inner.index().into(), *ni)
-                                .unwrap()
-                        )
-                        .unwrap(),
-                    GeometryLabel::Core
-                )
-            })
-            .map(|node| FixedDotIndex::new(node.index()))
-            .collect::<Vec<FixedDotIndex>>()
-            .first()
-            .unwrap();
-
+        let core = match inner {
+            BendIndex::Fixed(bend) => self.primitive(bend).core(),
+            BendIndex::Loose(bend) => self.primitive(bend).core(),
+        };
         let bend = self.recording_geometry_with_rtree.add_bend(
             recorder,
             from.into(),
@@ -604,17 +566,13 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(bend)
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     pub fn flip_bend(&mut self, recorder: &mut DrawingEdit<CW, Cel>, bend: FixedBendIndex) {
         self.recording_geometry_with_rtree
             .flip_bend(recorder, bend.into());
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count())
-        || self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() - 1)
-        || self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 1))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn reattach_bend(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -628,10 +586,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         );
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 4))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() >= old(self.recording_geometry_with_rtree.graph().edge_count() + 5))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 4))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     pub fn insert_cane(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -670,8 +626,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(cane)
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn update_this_and_outward_bows(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -751,10 +706,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(())
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 4))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() >= old(self.recording_geometry_with_rtree.graph().edge_count() + 5))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 4))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     pub fn add_cane(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -820,7 +773,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         })
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() - 4))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() - 4))]
     pub fn remove_cane(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -856,8 +809,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Cane::from_dot(dot, self)
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     pub fn move_dot(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -880,8 +832,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         }
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn move_dot_with_infringement_filtering(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -916,8 +867,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         Ok(())
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
     fn shift_bend_with_infringement_filtering(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -945,8 +895,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
 }
 
 impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
     fn add_dot_infringably<W: AccessDotWeight + Into<PrimitiveWeight> + GetLayer>(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -958,8 +907,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         self.recording_geometry_with_rtree.add_dot(recorder, weight)
     }
 
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() + 1))]
-    #[debug_ensures(self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count() + 2))]
+    #[debug_ensures(self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() + 1))]
     fn add_seg_infringably<W: AccessSegWeight + Into<PrimitiveWeight> + GetLayer>(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
@@ -1007,9 +955,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         );
     }
 
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count()))]
-    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.graph().edge_count() == old(self.recording_geometry_with_rtree.graph().edge_count()))]
-    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.graph().node_count() == old(self.recording_geometry_with_rtree.graph().node_count() - 1))]
+    #[debug_ensures(ret.is_ok() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count()))]
+    #[debug_ensures(ret.is_err() -> self.recording_geometry_with_rtree.total_node_count() == old(self.recording_geometry_with_rtree.total_node_count() - 1))]
     fn fail_and_remove_if_infringes_except(
         &mut self,
         recorder: &mut DrawingEdit<CW, Cel>,
diff --git a/src/drawing/primitive.rs b/src/drawing/primitive.rs
index 200691c..78a518a 100644
--- a/src/drawing/primitive.rs
+++ b/src/drawing/primitive.rs
@@ -13,7 +13,7 @@ use crate::{
         seg::{FixedSegWeight, LoneLooseSegWeight, SegIndex, SeqLooseSegIndex, SeqLooseSegWeight},
         Drawing,
     },
-    geometry::{primitive::PrimitiveShape, GenericNode, GetLayer, GetOffset, GetWidth, Retag},
+    geometry::{primitive::PrimitiveShape, GetLayer, GetOffset, GetWidth},
     graph::{GenericIndex, GetIndex},
 };
 
@@ -55,10 +55,6 @@ pub trait GetLimbs {
     }
 }
 
-pub trait GetInterior<T> {
-    fn interior(&self) -> Vec<T>;
-}
-
 pub trait GetOtherJoint: GetJoints {
     type J;
     fn other_joint(&self, end: Self::J) -> Self::J;
@@ -117,7 +113,9 @@ macro_rules! impl_primitive {
         impl<CW, Cel, R> GetWeight for $primitive_refstruct<'_, CW, Cel, R> {
             type Weight = $weight_struct;
             fn weight(&self) -> $weight_struct {
-                if let PrimitiveWeight::$primitive_variant(weight) = self.tagged_weight() {
+                if let PrimitiveWeight::$primitive_variant(weight) =
+                    self.drawing.geometry().primitive_weight(self.index.index())
+                {
                     weight
                 } else {
                     unreachable!()
@@ -193,26 +191,6 @@ impl<'a, W, CW, Cel, R> GenericPrimitive<'a, W, CW, Cel, R> {
     pub fn new(index: GenericIndex<W>, drawing: &'a Drawing<CW, Cel, R>) -> Self {
         Self { index, drawing }
     }
-
-    fn tagged_weight(&self) -> PrimitiveWeight {
-        if let GenericNode::Primitive(weight) = self
-            .drawing
-            .geometry()
-            .graph()
-            .node_weight(self.index.index().into())
-            .unwrap()
-        {
-            *weight
-        } else {
-            unreachable!()
-        }
-    }
-}
-
-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.index())]
-    }
 }
 
 impl<W, CW, Cel, R> GetDrawing for GenericPrimitive<'_, W, CW, Cel, R> {
diff --git a/src/geometry/geometry.rs b/src/geometry/geometry.rs
index 2e1dae8..f36a510 100644
--- a/src/geometry/geometry.rs
+++ b/src/geometry/geometry.rs
@@ -141,15 +141,11 @@ impl<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI> Geometry<PW, DW, SW, BW, CW, Cel,
         }
     }
 
-    // we could use `derive_getters` to generate these, but `Geometry` only wraps a single
-    // field that actually contains data...
-
-    #[inline(always)]
-    pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel<Cel>, usize> {
-        &self.graph
+    pub fn node_count(&self) -> usize {
+        self.graph.node_count()
     }
 
-    fn primitive_weight(&self, index: usize) -> PW
+    pub fn primitive_weight(&self, index: usize) -> PW
     where
         PW: Copy,
     {
diff --git a/src/geometry/recording_with_rtree.rs b/src/geometry/recording_with_rtree.rs
index eb19d55..a53635e 100644
--- a/src/geometry/recording_with_rtree.rs
+++ b/src/geometry/recording_with_rtree.rs
@@ -48,8 +48,8 @@ impl<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
         *self.geometry_with_rtree.layer_count()
     }
 
-    pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel<Cel>, usize> {
-        self.geometry_with_rtree.graph()
+    pub fn node_count(&self) -> usize {
+        self.geometry_with_rtree.node_count()
     }
 }
 
diff --git a/src/geometry/with_rtree.rs b/src/geometry/with_rtree.rs
index e57a2dc..e79aea7 100644
--- a/src/geometry/with_rtree.rs
+++ b/src/geometry/with_rtree.rs
@@ -62,8 +62,8 @@ impl<PW: Clone, DW, SW, BW, CW: Clone, Cel: Clone, PI: Clone, DI, SI, BI> Clone
 impl<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
     GeometryWithRtree<PW, DW, SW, BW, CW, Cel, PI, DI, SI, BI>
 {
-    pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel<Cel>, usize> {
-        self.geometry.graph()
+    pub fn node_count(&self) -> usize {
+        self.geometry.node_count()
     }
 }
 
diff --git a/src/layout/layout.rs b/src/layout/layout.rs
index 2d09d54..fbf4473 100644
--- a/src/layout/layout.rs
+++ b/src/layout/layout.rs
@@ -356,15 +356,12 @@ impl<R: AccessRules> Layout<R> {
         fn handle_fixed_dot<R: AccessRules>(
             drawing: &Drawing<CompoundWeight, CompoundEntryLabel, R>,
             index: PrimitiveIndex,
-        ) -> Option<(FixedDotIndex, &FixedDotWeight)> {
+        ) -> Option<(FixedDotIndex, FixedDotWeight)> {
             let PrimitiveIndex::FixedDot(dot) = index else {
                 return None;
             };
-            if let GenericNode::Primitive(PrimitiveWeight::FixedDot(weight)) = drawing
-                .geometry()
-                .graph()
-                .node_weight(dot.index().into())
-                .unwrap()
+            if let PrimitiveWeight::FixedDot(weight) =
+                drawing.geometry().primitive_weight(dot.index())
             {
                 Some((dot, weight))
             } else {
diff --git a/src/router/prenavmesh.rs b/src/router/prenavmesh.rs
index 0cbfd1a..8411589 100644
--- a/src/router/prenavmesh.rs
+++ b/src/router/prenavmesh.rs
@@ -7,7 +7,6 @@ use std::ops::{Index, IndexMut};
 use derive_getters::Getters;
 use enum_dispatch::enum_dispatch;
 use geo::Point;
-use petgraph::visit::NodeIndexable;
 use spade::{handles::FixedVertexHandle, HasPosition, InsertionError, Point2};
 
 use crate::{