refactor(drawing/drawing): Rename `.primitive(...)` to `.primitive_ref(...)`

crates/topola-egui/src/displayer.rs

@@ -579,7 +579,12 @@ impl<'a> Displayer<'a> {
                     let (origin, destination) = (navmesh.origin(), navmesh.destination());
                     self.painter.paint_solid_circle(
                         Circle {
-                            pos: board.layout().drawing().primitive(origin).shape().center(),
+                            pos: board
+                                .layout()
+                                .drawing()
+                                .primitive_ref(origin)
+                                .shape()
+                                .center(),
                             r: 150.0,
                         },
                         egui::Color32::from_rgb(255, 255, 100),
@@ -589,7 +594,7 @@ impl<'a> Displayer<'a> {
                             pos: board
                                 .layout()
                                 .drawing()
-                                .primitive(destination)
+                                .primitive_ref(destination)
                                 .shape()
                                 .center(),
                             r: 150.0,

src/autorouter/anterouter.rs

@@ -138,7 +138,7 @@ impl Anterouter {
                 .board()
                 .layout()
                 .drawing()
-                .primitive(source_dot)
+                .primitive_ref(source_dot)
                 .shape()
                 .envelope()
         };
@@ -400,20 +400,20 @@ impl Anterouter {
             .board()
             .layout()
             .drawing()
-            .primitive(source_dot)
+            .primitive_ref(source_dot)
             .layer();
         let pin_maybe_net = autorouter
             .board()
             .layout()
             .drawing()
-            .primitive(source_dot)
+            .primitive_ref(source_dot)
             .maybe_net();
         let bbox_center = point! {x: bbox.center()[0], y: bbox.center()[1]};
         let center = autorouter
             .board()
             .layout()
             .drawing()
-            .primitive(source_dot)
+            .primitive_ref(source_dot)
             .shape()
             .center();
 

src/autorouter/connected_components.rs

@@ -78,27 +78,27 @@ impl ConnectedComponents {
     ) {
         match primitive {
             PrimitiveIndex::FixedSeg(seg) => {
-                let joints = board.layout().drawing().primitive(seg).joints();
+                let joints = board.layout().drawing().primitive_ref(seg).joints();
                 dot_unionfind.union(joints.0.index(), joints.1.index());
                 Self::unionize_fixed_dot_via(board, dot_unionfind, joints.0);
                 Self::unionize_fixed_dot_via(board, dot_unionfind, joints.1);
             }
             PrimitiveIndex::LoneLooseSeg(seg) => {
-                let joints = board.layout().drawing().primitive(seg).joints();
+                let joints = board.layout().drawing().primitive_ref(seg).joints();
                 dot_unionfind.union(joints.0.index(), joints.1.index());
             }
             PrimitiveIndex::SeqLooseSeg(seg) => {
-                let joints = board.layout().drawing().primitive(seg).joints();
+                let joints = board.layout().drawing().primitive_ref(seg).joints();
                 dot_unionfind.union(joints.0.index(), joints.1.index());
             }
             PrimitiveIndex::FixedBend(bend) => {
-                let joints = board.layout().drawing().primitive(bend).joints();
+                let joints = board.layout().drawing().primitive_ref(bend).joints();
                 dot_unionfind.union(joints.0.index(), joints.1.index());
                 Self::unionize_fixed_dot_via(board, dot_unionfind, joints.0);
                 Self::unionize_fixed_dot_via(board, dot_unionfind, joints.1);
             }
             PrimitiveIndex::LooseBend(bend) => {
-                let joints = board.layout().drawing().primitive(bend).joints();
+                let joints = board.layout().drawing().primitive_ref(bend).joints();
                 dot_unionfind.union(joints.0.index(), joints.1.index());
             }
             _ => (),
@@ -143,31 +143,31 @@ impl ConnectedComponents {
                 dot_unionfind.union(common.index(), dot.index());
             }
             PrimitiveIndex::FixedSeg(seg) => {
-                let joints = board.layout().drawing().primitive(seg).joints();
+                let joints = board.layout().drawing().primitive_ref(seg).joints();
                 dot_unionfind.union(common.index(), joints.0.index());
                 Self::unionize_fixed_dot_via(board, dot_unionfind, joints.0);
                 dot_unionfind.union(common.index(), joints.1.index());
                 Self::unionize_fixed_dot_via(board, dot_unionfind, joints.1);
             }
             PrimitiveIndex::LoneLooseSeg(seg) => {
-                let joints = board.layout().drawing().primitive(seg).joints();
+                let joints = board.layout().drawing().primitive_ref(seg).joints();
                 dot_unionfind.union(common.index(), joints.0.index());
                 dot_unionfind.union(common.index(), joints.1.index());
             }
             PrimitiveIndex::SeqLooseSeg(seg) => {
-                let joints = board.layout().drawing().primitive(seg).joints();
+                let joints = board.layout().drawing().primitive_ref(seg).joints();
                 dot_unionfind.union(common.index(), joints.0.index());
                 dot_unionfind.union(common.index(), joints.1.index());
             }
             PrimitiveIndex::FixedBend(bend) => {
-                let joints = board.layout().drawing().primitive(bend).joints();
+                let joints = board.layout().drawing().primitive_ref(bend).joints();
                 dot_unionfind.union(common.index(), joints.0.index());
                 Self::unionize_fixed_dot_via(board, dot_unionfind, joints.0);
                 dot_unionfind.union(common.index(), joints.1.index());
                 Self::unionize_fixed_dot_via(board, dot_unionfind, joints.1);
             }
             PrimitiveIndex::LooseBend(bend) => {
-                let joints = board.layout().drawing().primitive(bend).joints();
+                let joints = board.layout().drawing().primitive_ref(bend).joints();
                 dot_unionfind.union(common.index(), joints.0.index());
                 dot_unionfind.union(common.index(), joints.1.index());
             }

src/autorouter/ratsnest.rs

@@ -196,7 +196,7 @@ impl Ratsnest {
                 // should only go to their centerpoints.
                 if board.layout().drawing().compounds(dot).next().is_none() {
                     handle_ratvertex_weight(
-                        board.layout().drawing().primitive(dot).maybe_net(),
+                        board.layout().drawing().primitive_ref(dot).maybe_net(),
                         RatvertexNodeIndex::FixedDot(dot),
                         node.primitive_ref(board.layout().drawing())
                             .shape()

src/drawing/drawing.rs

@@ -177,7 +177,7 @@ impl<CW, Cel, R> Drawing<CW, Cel, R> {
         &mut self.rules
     }
 
-    pub fn primitive<W>(&self, index: GenericIndex<W>) -> GenericPrimitive<'_, W, CW, Cel, R> {
+    pub fn primitive_ref<W>(&self, index: GenericIndex<W>) -> GenericPrimitive<'_, W, CW, Cel, R> {
         GenericPrimitive::new(index, self)
     }
 
@@ -260,10 +260,10 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
                 LooseIndex::Bend(bend) => {
                     bends.push(bend);
 
-                    let bend_primitive = self.primitive(bend);
+                    let bend_primitive = self.primitive_ref(bend);
                     let inner = bend_primitive.inner();
 
-                    for outer in self.primitive(bend).outers().collect::<Vec<_>>() {
+                    for outer in self.primitive_ref(bend).outers().collect::<Vec<_>>() {
                         outers.push(outer);
                         self.reattach_bend(recorder, outer, inner);
                     }
@@ -555,8 +555,8 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         filter: &impl Fn(&Self, PrimitiveIndex, PrimitiveIndex) -> bool,
     ) -> Result<GenericIndex<LooseBendWeight>, Infringement> {
         let core = match inner {
-            BendIndex::Fixed(bend) => self.primitive(bend).core(),
+            BendIndex::Fixed(bend) => self.primitive_ref(bend).core(),
-            BendIndex::Loose(bend) => self.primitive(bend).core(),
+            BendIndex::Loose(bend) => self.primitive_ref(bend).core(),
         };
         let bend = self.recording_geometry_with_rtree.add_bend(
             recorder,
@@ -621,10 +621,10 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
             self.reattach_bend(recorder, gear, Some(cane.bend));
         }
 
-        for outer in self.primitive(cane.bend).outers().collect::<Vec<_>>() {
+        for outer in self.primitive_ref(cane.bend).outers().collect::<Vec<_>>() {
             self.update_this_and_outward_bows(recorder, outer)
                 .inspect_err(|_| {
-                    let joint = self.primitive(cane.bend).other_joint(cane.dot);
+                    let joint = self.primitive_ref(cane.bend).other_joint(cane.dot);
                     self.remove_cane(recorder, &cane, joint);
                 })?;
         }
@@ -640,7 +640,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
     ) -> Result<(), DrawingException> {
         self.update_bow(recorder, around)?;
 
-        let mut outwards = self.primitive(around).outwards();
+        let mut outwards = self.primitive_ref(around).outwards();
         while let Some(rail) = outwards.walk_next(self) {
             self.update_bow(recorder, rail)?;
         }
@@ -653,7 +653,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         recorder: &mut DrawingEdit<CW, Cel>,
         rail: LooseBendIndex,
     ) -> Result<(), DrawingException> {
-        let rail_primitive = self.primitive(rail);
+        let rail_primitive = self.primitive_ref(rail);
         let joints = rail_primitive.joints();
         let width = rail_primitive.width();
 
@@ -786,11 +786,11 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         cane: &Cane,
         face: LooseDotIndex,
     ) {
-        let outers = self.primitive(cane.bend).outers().collect::<Vec<_>>();
+        let outers = self.primitive_ref(cane.bend).outers().collect::<Vec<_>>();
 
         // Removing a loose bend affects its outer bends.
         for outer in &outers {
-            self.reattach_bend(recorder, *outer, self.primitive(cane.bend).inner());
+            self.reattach_bend(recorder, *outer, self.primitive_ref(cane.bend).inner());
         }
 
         self.recording_geometry_with_rtree

src/drawing/gear.rs

@@ -63,9 +63,9 @@ pub enum GearRef<'a, CW, Cel, R> {
 impl<'a, CW, Cel, R> GearRef<'a, CW, Cel, R> {
     pub fn new(index: GearIndex, drawing: &'a Drawing<CW, Cel, R>) -> Self {
         match index {
-            GearIndex::FixedDot(dot) => drawing.primitive(dot).into(),
+            GearIndex::FixedDot(dot) => drawing.primitive_ref(dot).into(),
-            GearIndex::FixedBend(bend) => drawing.primitive(bend).into(),
+            GearIndex::FixedBend(bend) => drawing.primitive_ref(bend).into(),
-            GearIndex::LooseBend(bend) => drawing.primitive(bend).into(),
+            GearIndex::LooseBend(bend) => drawing.primitive_ref(bend).into(),
         }
     }
 }
@@ -102,7 +102,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Walker<&Drawing<CW, Cel, R>> for Draw
 
     fn walk_next(&mut self, drawing: &Drawing<CW, Cel, R>) -> Option<Self::Item> {
         let front = self.frontier.pop_front()?;
-        self.frontier.extend(drawing.primitive(front).outers());
+        self.frontier.extend(drawing.primitive_ref(front).outers());
 
         Some(front)
     }

src/drawing/guide.rs

@@ -28,7 +28,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
     ) -> Result<Line, NoBitangents> {
         let from_circle = self.head_circle(head, width);
         let to_circle = Circle {
-            pos: self.primitive(into).weight().0.circle.pos,
+            pos: self.primitive_ref(into).weight().0.circle.pos,
             r: 0.0,
         };
 
@@ -124,7 +124,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
 
     pub fn head_sense(&self, head: &Head) -> Option<RotationSense> {
         if let Head::Cane(head) = head {
-            let joints = self.primitive(head.cane.bend).joints();
+            let joints = self.primitive_ref(head.cane.bend).joints();
 
             if head.face() == joints.0.into() {
                 Some(RotationSense::Counterclockwise)
@@ -206,7 +206,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
                 r: 0.0,
             },
             Head::Cane(head) => {
-                if let Some(inner) = self.primitive(head.cane.bend).inner() {
+                if let Some(inner) = self.primitive_ref(head.cane.bend).inner() {
                     self.bend_circle(
                         inner.into(),
                         width,
@@ -214,7 +214,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
                     )
                 } else {
                     self.dot_circle(
-                        self.primitive(head.cane.bend).core().into(),
+                        self.primitive_ref(head.cane.bend).core().into(),
                         width,
                         self.conditions(head.face().into()).as_ref(),
                     )
@@ -224,7 +224,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
     }
 
     fn rear(&self, head: CaneHead) -> DotIndex {
-        self.primitive(head.cane.seg)
+        self.primitive_ref(head.cane.seg)
             .other_joint(head.cane.dot.into())
     }
 }

src/drawing/head.rs

@@ -103,8 +103,15 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> MeasureLength for HeadRef<'_, CW, Cel
         match self.head {
             Head::Bare(..) => 0.0,
             Head::Cane(cane_head) => {
-                self.drawing.primitive(cane_head.cane.seg).shape().length()
+                self.drawing
-                    + self.drawing.primitive(cane_head.cane.bend).shape().length()
+                    .primitive_ref(cane_head.cane.seg)
+                    .shape()
+                    .length()
+                    + self
+                        .drawing
+                        .primitive_ref(cane_head.cane.bend)
+                        .shape()
+                        .length()
             }
         }
     }

src/drawing/loose.rs

@@ -81,10 +81,10 @@ pub enum Loose<'a, CW, Cel, R> {
 impl<'a, CW, Cel, R> Loose<'a, CW, Cel, R> {
     pub fn new(index: LooseIndex, drawing: &'a Drawing<CW, Cel, R>) -> Self {
         match index {
-            LooseIndex::Dot(dot) => drawing.primitive(dot).into(),
+            LooseIndex::Dot(dot) => drawing.primitive_ref(dot).into(),
-            LooseIndex::LoneSeg(seg) => drawing.primitive(seg).into(),
+            LooseIndex::LoneSeg(seg) => drawing.primitive_ref(seg).into(),
-            LooseIndex::SeqSeg(seg) => drawing.primitive(seg).into(),
+            LooseIndex::SeqSeg(seg) => drawing.primitive_ref(seg).into(),
-            LooseIndex::Bend(bend) => drawing.primitive(bend).into(),
+            LooseIndex::Bend(bend) => drawing.primitive_ref(bend).into(),
         }
     }
 }

src/drawing/query.rs

@@ -90,7 +90,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
     pub fn collect_bend_outward_bows(&self, bend: LooseBendIndex) -> Vec<PrimitiveIndex> {
         let mut v = vec![];
 
-        let mut outwards = self.primitive(bend).outwards();
+        let mut outwards = self.primitive_ref(bend).outwards();
         while let Some(next) = outwards.walk_next(self) {
             v.append(&mut self.collect_bend_bow(next));
         }
@@ -102,7 +102,7 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         let mut v: Vec<PrimitiveIndex> = vec![];
         v.push(bend.into());
 
-        let joints = self.primitive(bend).joints();
+        let joints = self.primitive_ref(bend).joints();
         v.push(joints.0.into());
         v.push(joints.1.into());
 
@@ -117,11 +117,11 @@ impl<CW: Clone, Cel: Copy, R: AccessRules> Drawing<CW, Cel, R> {
         &self,
         bend: LooseBendIndex,
     ) -> impl Iterator<Item = SeqLooseSegIndex> {
-        let joints = self.primitive(bend).joints();
+        let joints = self.primitive_ref(bend).joints();
-        self.primitive(joints.0)
+        self.primitive_ref(joints.0)
             .seg()
             .into_iter()
-            .chain(self.primitive(joints.1).seg().into_iter())
+            .chain(self.primitive_ref(joints.1).seg().into_iter())
     }
 
     pub fn cut(

src/layout/poly.rs

@@ -150,11 +150,11 @@ fn is_apex<R>(
     dot: FixedDotIndex,
 ) -> bool {
     !drawing
-        .primitive(dot)
+        .primitive_ref(dot)
         .segs()
         .iter()
         .any(|seg| matches!(seg, SegIndex::Fixed(..)))
-        && drawing.primitive(dot).bends().is_empty()
+        && drawing.primitive_ref(dot).bends().is_empty()
         // FIXME: Only the following should be needed to make sure dot is an apex.
         // But for some reason I had to keep the above part.
         || drawing

src/router/draw.rs

@@ -192,7 +192,7 @@ impl<R: AccessRules> Draw for Layout<R> {
     fn undo_cane(&mut self, recorder: &mut LayoutEdit, head: CaneHead) -> Option<Head> {
         let prev_dot = self
             .drawing()
-            .primitive(head.cane.seg)
+            .primitive_ref(head.cane.seg)
             .other_joint(head.cane.dot.into());
 
         self.remove_cane(recorder, &head.cane, head.face);
@@ -337,7 +337,10 @@ impl<R: AccessRules> DrawPrivate for Layout<R> {
         };
 
         Ok(CaneHead {
-            face: self.drawing().primitive(cane.bend).other_joint(cane.dot),
+            face: self
+                .drawing()
+                .primitive_ref(cane.bend)
+                .other_joint(cane.dot),
             cane,
         })
     }

src/router/navcord.rs

@@ -129,7 +129,7 @@ impl Navcord {
             let bend_length = match self.head {
                 Head::Cane(old_cane_head) => layout
                     .drawing()
-                    .primitive(old_cane_head.cane.bend)
+                    .primitive_ref(old_cane_head.cane.bend)
                     .shape()
                     .length(),
                 Head::Bare(..) => 0.0,
@@ -148,7 +148,7 @@ impl Navcord {
             let prev_bend_length = match old_head {
                 Head::Cane(old_cane_head) => layout
                     .drawing()
-                    .primitive(old_cane_head.cane.bend)
+                    .primitive_ref(old_cane_head.cane.bend)
                     .shape()
                     .length(),
                 Head::Bare(..) => 0.0,

src/router/navmesh.rs

@@ -6,6 +6,7 @@ use std::collections::BTreeMap;
 
 use derive_getters::Getters;
 use enum_dispatch::enum_dispatch;
+use geo::Point;
 use petgraph::{
     data::DataMap,
     graph::UnGraph,
@@ -25,10 +26,10 @@ use crate::{
         dot::FixedDotIndex,
         gear::{GearIndex, GetOuterGears, WalkOutwards},
         graph::{MakePrimitiveRef, PrimitiveIndex},
-        primitive::GetJoints,
+        primitive::{GetJoints, MakePrimitiveShape},
         rules::AccessRules,
     },
-    geometry::GetLayer,
+    geometry::{primitive::PrimitiveShape, shape::AccessShape, GetLayer},
     graph::{GenericIndex, GetIndex, MakeRef},
     layout::{CompoundEntryLabel, Layout},
     math::RotationSense,
@@ -36,7 +37,7 @@ use crate::{
 };
 
 use super::{
-    prenavmesh::{Prenavmesh, PrenavmeshNodeIndex},
+    prenavmesh::{Prenavmesh, PrenavnodeNodeIndex},
     RouterOptions,
 };
 
@@ -66,11 +67,11 @@ pub enum BinavnodeNodeIndex {
     LooseBend(LooseBendIndex),
 }
 
-impl From<PrenavmeshNodeIndex> for BinavnodeNodeIndex {
+impl From<PrenavnodeNodeIndex> for BinavnodeNodeIndex {
-    fn from(node: PrenavmeshNodeIndex) -> Self {
+    fn from(node: PrenavnodeNodeIndex) -> Self {
         match node {
-            PrenavmeshNodeIndex::FixedDot(dot) => BinavnodeNodeIndex::FixedDot(dot),
+            PrenavnodeNodeIndex::FixedDot(dot) => BinavnodeNodeIndex::FixedDot(dot),
-            PrenavmeshNodeIndex::FixedBend(bend) => BinavnodeNodeIndex::FixedBend(bend),
+            PrenavnodeNodeIndex::FixedBend(bend) => BinavnodeNodeIndex::FixedBend(bend),
         }
     }
 }
@@ -224,7 +225,7 @@ impl Navmesh {
                     while let Some(outward) = outwards.walk_next(layout.drawing()) {
                         if layout
                             .drawing()
-                            .primitive(outward)
+                            .primitive_ref(outward)
                             .outers()
                             .collect::<Vec<_>>()
                             .is_empty()
@@ -280,7 +281,7 @@ impl Navmesh {
         // Copy prenavedges of prenavnodes union representatives to all elements
         // for each union.
         for prenavnode in prenavmesh.triangulation().node_identifiers() {
-            let repr = PrenavmeshNodeIndex::FixedDot(GenericIndex::new(
+            let repr = PrenavnodeNodeIndex::FixedDot(GenericIndex::new(
                 overlapping_prenavnodes_unions.find(prenavnode.index()),
             ));
 
@@ -330,7 +331,7 @@ impl Navmesh {
     fn unionize_with_overlapees(
         layout: &Layout<impl AccessRules>,
         overlapping_prenavnodes_unions: &mut UnionFind<usize>,
-        prenavnode: PrenavmeshNodeIndex,
+        prenavnode: PrenavnodeNodeIndex,
     ) {
         // Ignore overlaps of a fillet.
         if layout
@@ -364,10 +365,10 @@ impl Navmesh {
     fn add_prenavnode_as_binavnode(
         graph: &mut UnGraph<NavnodeWeight, (), usize>,
         prenavnode_to_navnodes: &mut BTreeMap<
-            PrenavmeshNodeIndex,
+            PrenavnodeNodeIndex,
             Vec<(NodeIndex<usize>, NodeIndex<usize>)>,
         >,
-        prenavnode: PrenavmeshNodeIndex,
+        prenavnode: PrenavnodeNodeIndex,
         binavnode: BinavnodeNodeIndex,
     ) {
         let navnode1 = graph.add_node(NavnodeWeight {
@@ -390,19 +391,19 @@ impl Navmesh {
         layout: &Layout<impl AccessRules>,
         graph: &mut UnGraph<NavnodeWeight, (), usize>,
         prenavnode_to_navnodes: &BTreeMap<
-            PrenavmeshNodeIndex,
+            PrenavnodeNodeIndex,
             Vec<(NodeIndex<usize>, NodeIndex<usize>)>,
         >,
         overlapping_prenavnodes_unions: &UnionFind<usize>,
-        from_prenavnode: PrenavmeshNodeIndex,
+        from_prenavnode: PrenavnodeNodeIndex,
-        to_prenavnode: PrenavmeshNodeIndex,
+        to_prenavnode: PrenavnodeNodeIndex,
     ) {
         // We assume prenavmesh nodes are fixed dots. This is an ugly shortcut,
         // since fixed bends also can be prenavnodes, but it works for now.
-        let from_prenavnode_repr = PrenavmeshNodeIndex::FixedDot(GenericIndex::new(
+        let from_prenavnode_repr = PrenavnodeNodeIndex::FixedDot(GenericIndex::new(
             overlapping_prenavnodes_unions.find(from_prenavnode.index().into()),
         ));
-        let to_prenavnode_repr = PrenavmeshNodeIndex::FixedDot(GenericIndex::new(
+        let to_prenavnode_repr = PrenavnodeNodeIndex::FixedDot(GenericIndex::new(
             overlapping_prenavnodes_unions.find(to_prenavnode.index().into()),
         ));
 
@@ -419,11 +420,11 @@ impl Navmesh {
         layout: &Layout<impl AccessRules>,
         graph: &mut UnGraph<NavnodeWeight, (), usize>,
         prenavnode_to_navnodes: &BTreeMap<
-            PrenavmeshNodeIndex,
+            PrenavnodeNodeIndex,
             Vec<(NodeIndex<usize>, NodeIndex<usize>)>,
         >,
-        from_prenavnode: PrenavmeshNodeIndex,
+        from_prenavnode: PrenavnodeNodeIndex,
-        to_prenavnode: PrenavmeshNodeIndex,
+        to_prenavnode: PrenavnodeNodeIndex,
     ) {
         let mut maybe_lowest_join: Option<(usize, usize)> = None;
 
@@ -507,12 +508,22 @@ impl Navmesh {
         // Besides checking if binavnodes are joined, we make sure that they
         // have the same rotation sense.
 
-        let from_bend_joints = layout.drawing().primitive(from_bend).joints();
+        let from_bend_joints = layout.drawing().primitive_ref(from_bend).joints();
-        let to_bend_joints = layout.drawing().primitive(to_bend).joints();
+        let to_bend_joints = layout.drawing().primitive_ref(to_bend).joints();
 
-        let (from_joints, to_joints) = if layout.drawing().primitive(*common_seg).joints().0.index()
+        let (from_joints, to_joints) = if layout
+            .drawing()
+            .primitive_ref(*common_seg)
+            .joints()
+            .0
+            .index()
             == from_bend_joints.0.index()
-            || layout.drawing().primitive(*common_seg).joints().0.index()
+            || layout
+                .drawing()
+                .primitive_ref(*common_seg)
+                .joints()
+                .0
+                .index()
                 == from_bend_joints.1.index()
         {
             (from_bend_joints, to_bend_joints)
@@ -521,9 +532,21 @@ impl Navmesh {
         };
 
         [from_joints.0, from_joints.1].iter().position(|joint| {
-            joint.index() == layout.drawing().primitive(*common_seg).joints().0.index()
+            joint.index()
+                == layout
+                    .drawing()
+                    .primitive_ref(*common_seg)
+                    .joints()
+                    .0
+                    .index()
         }) != [to_joints.0, to_joints.1].iter().position(|joint| {
-            joint.index() == layout.drawing().primitive(*common_seg).joints().1.index()
+            joint.index()
+                == layout
+                    .drawing()
+                    .primitive_ref(*common_seg)
+                    .joints()
+                    .1
+                    .index()
         })
     }
 

src/router/prenavmesh.rs

@@ -31,28 +31,28 @@ use super::{navmesh::NavmeshError, RouterOptions};
 /// of the prenavmesh nodes into more nodes, called navnodes.
 #[enum_dispatch(GetIndex, MakePrimitive)]
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub enum PrenavmeshNodeIndex {
+pub enum PrenavnodeNodeIndex {
     FixedDot(FixedDotIndex),
     FixedBend(FixedBendIndex),
 }
 
-impl From<PrenavmeshNodeIndex> for PrimitiveIndex {
+impl From<PrenavnodeNodeIndex> for PrimitiveIndex {
-    fn from(node: PrenavmeshNodeIndex) -> Self {
+    fn from(node: PrenavnodeNodeIndex) -> Self {
         match node {
-            PrenavmeshNodeIndex::FixedDot(dot) => PrimitiveIndex::FixedDot(dot),
+            PrenavnodeNodeIndex::FixedDot(dot) => PrimitiveIndex::FixedDot(dot),
-            PrenavmeshNodeIndex::FixedBend(bend) => PrimitiveIndex::FixedBend(bend),
+            PrenavnodeNodeIndex::FixedBend(bend) => PrimitiveIndex::FixedBend(bend),
         }
     }
 }
 
 #[derive(Clone, Copy)]
 pub struct PrenavmeshWeight {
-    pub node: PrenavmeshNodeIndex,
+    pub node: PrenavnodeNodeIndex,
     pub pos: Point,
 }
 
-impl GetTrianvertexNodeIndex<PrenavmeshNodeIndex> for PrenavmeshWeight {
+impl GetTrianvertexNodeIndex<PrenavnodeNodeIndex> for PrenavmeshWeight {
-    fn node_index(&self) -> PrenavmeshNodeIndex {
+    fn node_index(&self) -> PrenavnodeNodeIndex {
         self.node
     }
 }
@@ -99,7 +99,7 @@ impl PrenavmeshConstraint {
         layout: &Layout<impl AccessRules>,
         seg: LoneLooseSegIndex,
     ) -> Self {
-        let (from_dot, to_dot) = layout.drawing().primitive(seg).joints();
+        let (from_dot, to_dot) = layout.drawing().primitive_ref(seg).joints();
         Self::new_from_fixed_dot_pair(layout, from_dot, to_dot)
     }
 
@@ -107,24 +107,24 @@ impl PrenavmeshConstraint {
         layout: &Layout<impl AccessRules>,
         seg: SeqLooseSegIndex,
     ) -> Self {
-        let (from_joint, to_joint) = layout.drawing().primitive(seg).joints();
+        let (from_joint, to_joint) = layout.drawing().primitive_ref(seg).joints();
 
         let from_dot = match from_joint {
             DotIndex::Fixed(dot) => dot,
             DotIndex::Loose(dot) => {
-                let bend = layout.drawing().primitive(dot).bend();
+                let bend = layout.drawing().primitive_ref(dot).bend();
 
-                layout.drawing().primitive(bend).core()
+                layout.drawing().primitive_ref(bend).core()
             }
         };
 
-        let to_bend = layout.drawing().primitive(to_joint).bend();
+        let to_bend = layout.drawing().primitive_ref(to_joint).bend();
-        let to_dot = layout.drawing().primitive(to_bend).core();
+        let to_dot = layout.drawing().primitive_ref(to_bend).core();
         Self::new_from_fixed_dot_pair(layout, from_dot, to_dot)
     }
 
     pub fn new_from_fixed_seg(layout: &Layout<impl AccessRules>, seg: FixedSegIndex) -> Self {
-        let (from_dot, to_dot) = layout.drawing().primitive(seg).joints();
+        let (from_dot, to_dot) = layout.drawing().primitive_ref(seg).joints();
         Self::new_from_fixed_dot_pair(layout, from_dot, to_dot)
     }
 }
@@ -144,29 +144,29 @@ impl PrenavnodeToHandleMap {
     }
 }
 
-impl Index<PrenavmeshNodeIndex> for PrenavnodeToHandleMap {
+impl Index<PrenavnodeNodeIndex> for PrenavnodeToHandleMap {
     type Output = Option<FixedVertexHandle>;
 
-    fn index(&self, prenavnode: PrenavmeshNodeIndex) -> &Self::Output {
+    fn index(&self, prenavnode: PrenavnodeNodeIndex) -> &Self::Output {
         match prenavnode {
-            PrenavmeshNodeIndex::FixedDot(dot) => &self.fixed_dot_to_handle[dot.index()],
+            PrenavnodeNodeIndex::FixedDot(dot) => &self.fixed_dot_to_handle[dot.index()],
-            PrenavmeshNodeIndex::FixedBend(bend) => &self.fixed_bend_to_handle[bend.index()],
+            PrenavnodeNodeIndex::FixedBend(bend) => &self.fixed_bend_to_handle[bend.index()],
         }
     }
 }
 
-impl IndexMut<PrenavmeshNodeIndex> for PrenavnodeToHandleMap {
+impl IndexMut<PrenavnodeNodeIndex> for PrenavnodeToHandleMap {
-    fn index_mut(&mut self, prenavnode: PrenavmeshNodeIndex) -> &mut Self::Output {
+    fn index_mut(&mut self, prenavnode: PrenavnodeNodeIndex) -> &mut Self::Output {
         match prenavnode {
-            PrenavmeshNodeIndex::FixedDot(dot) => &mut self.fixed_dot_to_handle[dot.index()],
+            PrenavnodeNodeIndex::FixedDot(dot) => &mut self.fixed_dot_to_handle[dot.index()],
-            PrenavmeshNodeIndex::FixedBend(bend) => &mut self.fixed_bend_to_handle[bend.index()],
+            PrenavnodeNodeIndex::FixedBend(bend) => &mut self.fixed_bend_to_handle[bend.index()],
         }
     }
 }
 
 #[derive(Clone, Getters)]
 pub struct Prenavmesh {
-    triangulation: Triangulation<PrenavmeshNodeIndex, PrenavnodeToHandleMap, PrenavmeshWeight, ()>,
+    triangulation: Triangulation<PrenavnodeNodeIndex, PrenavnodeToHandleMap, PrenavmeshWeight, ()>,
     constraints: Vec<PrenavmeshConstraint>,
 }
 
@@ -185,8 +185,8 @@ impl Prenavmesh {
             constraints: vec![],
         };
 
-        let layer = layout.drawing().primitive(origin).layer();
+        let layer = layout.drawing().primitive_ref(origin).layer();
-        let maybe_net = layout.drawing().primitive(origin).maybe_net();
+        let maybe_net = layout.drawing().primitive_ref(origin).maybe_net();
 
         for node in layout.drawing().layer_primitive_nodes(layer) {
             let primitive = node.primitive_ref(layout.drawing());
@@ -270,7 +270,7 @@ impl Prenavmesh {
                 // fixed segs that do not cause an intersection.
                 match node {
                     PrimitiveIndex::FixedSeg(seg) => {
-                        let (from_dot, to_dot) = layout.drawing().primitive(seg).joints();
+                        let (from_dot, to_dot) = layout.drawing().primitive_ref(seg).joints();
 
                         if Self::is_fixed_dot_filleted(layout, from_dot)
                             && Self::is_fixed_dot_filleted(layout, to_dot)

src/router/router.rs

@@ -190,7 +190,7 @@ impl<R: AccessRules> ThetastarStrategy<Navmesh, f64, BandTermsegIndex>
         let end_point = self
             .layout
             .drawing()
-            .primitive(self.destination)
+            .primitive_ref(self.destination)
             .shape()
             .center();
 

tests/common/mod.rs

@@ -199,13 +199,13 @@ pub fn assert_that_all_ratlines_besides_gnd_are_autorouted(
                 .board()
                 .layout()
                 .drawing()
-                .primitive(origin_dot)
+                .primitive_ref(origin_dot)
                 .maybe_net();
             let destination_net = autorouter
                 .board()
                 .layout()
                 .drawing()
-                .primitive(destination_dot)
+                .primitive_ref(destination_dot)
                 .maybe_net();
             assert_eq!(origin_net, destination_net);