From 888a4ecbad77a029c739ee3d5aacba76eb2b486b Mon Sep 17 00:00:00 2001 From: Mikolaj Wielgus Date: Mon, 25 Mar 2024 12:41:56 +0000 Subject: [PATCH] geometry: provide basic internals for storing groupings Will develop an interface in subsequent commits. --- src/drawing/drawing.rs | 5 ++ src/drawing/grouping.rs | 67 +++++++++++++++++++++ src/drawing/mod.rs | 1 + src/drawing/primitive.rs | 44 +++++++++----- src/geometry/geometry.rs | 117 ++++++++++++++++++++++-------------- src/geometry/with_rtree.rs | 118 +++++++++++++++++++------------------ 6 files changed, 237 insertions(+), 115 deletions(-) create mode 100644 src/drawing/grouping.rs diff --git a/src/drawing/drawing.rs b/src/drawing/drawing.rs index 283d41a..b11d1c5 100644 --- a/src/drawing/drawing.rs +++ b/src/drawing/drawing.rs @@ -20,6 +20,7 @@ use crate::drawing::{ bend::{FixedBendIndex, LooseBendIndex, LooseBendWeight}, dot::{DotIndex, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight}, graph::{GeometryIndex, GeometryWeight, MakePrimitive}, + grouping::{GroupingIndex, GroupingWeight}, primitive::{GenericPrimitive, GetCore, GetInnerOuter, GetJoints, GetOtherJoint, MakeShape}, seg::{ FixedSegIndex, FixedSegWeight, LoneLooseSegIndex, LoneLooseSegWeight, SegIndex, @@ -72,10 +73,12 @@ pub struct Drawing { DotWeight, SegWeight, BendWeight, + GroupingWeight, GeometryIndex, DotIndex, SegIndex, BendIndex, + GroupingIndex, >, rules: R, } @@ -789,10 +792,12 @@ impl Drawing { DotWeight, SegWeight, BendWeight, + GroupingWeight, GeometryIndex, DotIndex, SegIndex, BendIndex, + GroupingIndex, > { self.geometry_with_rtree.geometry() } diff --git a/src/drawing/grouping.rs b/src/drawing/grouping.rs new file mode 100644 index 0000000..9c01160 --- /dev/null +++ b/src/drawing/grouping.rs @@ -0,0 +1,67 @@ +use enum_dispatch::enum_dispatch; + +use petgraph::stable_graph::NodeIndex; + +use crate::{ + drawing::{ + graph::{GeometryIndex, GeometryWeight, GetLayer, GetMaybeNet, MakePrimitive, Retag}, + primitive::{GenericPrimitive, Primitive}, + rules::RulesTrait, + Drawing, + }, + graph::{GenericIndex, GetNodeIndex}, +}; + +#[enum_dispatch(GetNodeIndex)] +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum GroupingIndex { + Solid(SolidGroupingIndex), + Pour(PourGroupingIndex), +} + +#[enum_dispatch(GetLayer)] +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum GroupingWeight { + Solid(SolidGroupingWeight), + Pour(PourGroupingWeight), +} + +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct SolidGroupingWeight { + pub layer: u64, + pub maybe_net: Option, +} + +impl<'a> GetLayer for SolidGroupingWeight { + fn layer(&self) -> u64 { + self.layer + } +} + +impl<'a> GetMaybeNet for SolidGroupingWeight { + fn maybe_net(&self) -> Option { + self.maybe_net + } +} + +pub type SolidGroupingIndex = GenericIndex; + +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct PourGroupingWeight { + pub layer: u64, + pub maybe_net: Option, +} + +impl<'a> GetLayer for PourGroupingWeight { + fn layer(&self) -> u64 { + self.layer + } +} + +impl<'a> GetMaybeNet for PourGroupingWeight { + fn maybe_net(&self) -> Option { + self.maybe_net + } +} + +pub type PourGroupingIndex = GenericIndex; diff --git a/src/drawing/mod.rs b/src/drawing/mod.rs index ddd431b..e735ea3 100644 --- a/src/drawing/mod.rs +++ b/src/drawing/mod.rs @@ -4,6 +4,7 @@ pub mod bend; pub mod collect; pub mod dot; mod drawing; +pub mod grouping; pub mod guide; pub mod loose; pub mod primitive; diff --git a/src/drawing/primitive.rs b/src/drawing/primitive.rs index 7512dd8..6799b00 100644 --- a/src/drawing/primitive.rs +++ b/src/drawing/primitive.rs @@ -1,24 +1,27 @@ use enum_dispatch::enum_dispatch; use petgraph::stable_graph::NodeIndex; -use crate::drawing::{ - bend::{BendIndex, FixedBendWeight, LooseBendIndex, LooseBendWeight}, - dot::{DotIndex, DotWeight, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight}, - graph::{GeometryIndex, GeometryWeight, GetLayer, GetMaybeNet, Retag}, - loose::LooseIndex, - rules::{Conditions, GetConditions, RulesTrait}, - seg::{ - FixedSegWeight, LoneLooseSegIndex, LoneLooseSegWeight, SegIndex, SeqLooseSegIndex, - SeqLooseSegWeight, - }, - Drawing, -}; use crate::geometry::{ shape::{Shape, ShapeTrait}, GetOffset, GetWidth, }; use crate::graph::{GenericIndex, GetNodeIndex}; use crate::layout::connectivity::{BandIndex, ContinentIndex}; +use crate::{ + drawing::{ + bend::{BendIndex, FixedBendWeight, LooseBendIndex, LooseBendWeight}, + dot::{DotIndex, DotWeight, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight}, + graph::{GeometryIndex, GeometryWeight, GetLayer, GetMaybeNet, Retag}, + loose::LooseIndex, + rules::{Conditions, GetConditions, RulesTrait}, + seg::{ + FixedSegWeight, LoneLooseSegIndex, LoneLooseSegWeight, SegIndex, SeqLooseSegIndex, + SeqLooseSegWeight, + }, + Drawing, + }, + geometry::CompoundWeight, +}; #[enum_dispatch] pub trait GetDrawing<'a, R: RulesTrait> { @@ -181,12 +184,17 @@ impl<'a, W, R: RulesTrait> GenericPrimitive<'a, W, R> { } fn tagged_weight(&self) -> GeometryWeight { - *self + if let CompoundWeight::Primitive(weight) = *self .drawing .geometry() .graph() .node_weight(self.index.node_index()) .unwrap() + { + weight + } else { + unreachable!() + } } fn primitive(&self, index: GenericIndex) -> GenericPrimitive { @@ -250,9 +258,15 @@ impl<'a, R: RulesTrait> FixedDot<'a, R> { .graph() .node_weight(ni.node_index()) .unwrap(); - if matches!(weight, GeometryWeight::LoneLooseSeg(..)) { + if matches!( + weight, + CompoundWeight::Primitive(GeometryWeight::LoneLooseSeg(..)) + ) { Some(LoneLooseSegIndex::new(ni.node_index()).into()) - } else if matches!(weight, GeometryWeight::SeqLooseSeg(..)) { + } else if matches!( + weight, + CompoundWeight::Primitive(GeometryWeight::SeqLooseSeg(..)) + ) { Some(SeqLooseSegIndex::new(ni.node_index()).into()) } else { None diff --git a/src/geometry/geometry.rs b/src/geometry/geometry.rs index 84e566e..f60ea21 100644 --- a/src/geometry/geometry.rs +++ b/src/geometry/geometry.rs @@ -54,42 +54,54 @@ pub enum GeometryLabel { Core, } +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum CompoundWeight { + Primitive(PW), + Grouping(XW), +} + pub trait DotWeightTrait: GetPos + SetPos + GetWidth + Into + Copy {} pub trait SegWeightTrait: GetWidth + Into + Copy {} pub trait BendWeightTrait: GetOffset + SetOffset + GetWidth + Into + Copy {} #[derive(Debug)] pub struct Geometry< - GW: GetWidth + TryInto + TryInto + TryInto + Retag + Copy, - DW: DotWeightTrait + Copy, - SW: SegWeightTrait + Copy, - BW: BendWeightTrait + Copy, - GI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PW: GetWidth + TryInto + TryInto + TryInto + Retag + Copy, + DW: DotWeightTrait, + SW: SegWeightTrait, + BW: BendWeightTrait, + GW: Copy, + PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, + DI: GetNodeIndex + Into + Copy, + SI: GetNodeIndex + Into + Copy, + BI: GetNodeIndex + Into + Copy, + GI: GetNodeIndex + Copy, > { - graph: StableDiGraph, - weight_marker: PhantomData, + graph: StableDiGraph, GeometryLabel, usize>, + weight_marker: PhantomData, dot_weight_marker: PhantomData, seg_weight_marker: PhantomData, bend_weight_marker: PhantomData, - index_marker: PhantomData, + grouping_weight_marker: PhantomData, + index_marker: PhantomData, dot_index_marker: PhantomData, seg_index_marker: PhantomData, bend_index_marker: PhantomData, + grouping_index_marker: PhantomData, } impl< - GW: GetWidth + TryInto + TryInto + TryInto + Retag + Copy, - DW: DotWeightTrait + Copy, - SW: SegWeightTrait + Copy, - BW: BendWeightTrait + Copy, - GI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, - > Geometry + PW: GetWidth + TryInto + TryInto + TryInto + Retag + Copy, + DW: DotWeightTrait, + SW: SegWeightTrait, + BW: BendWeightTrait, + GW: Copy, + PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, + DI: GetNodeIndex + Into + Copy, + SI: GetNodeIndex + Into + Copy, + BI: GetNodeIndex + Into + Copy, + GI: GetNodeIndex + Copy, + > Geometry { pub fn new() -> Self { Self { @@ -98,24 +110,32 @@ impl< dot_weight_marker: PhantomData, seg_weight_marker: PhantomData, bend_weight_marker: PhantomData, + grouping_weight_marker: PhantomData, index_marker: PhantomData, dot_index_marker: PhantomData, seg_index_marker: PhantomData, bend_index_marker: PhantomData, + grouping_index_marker: PhantomData, } } - pub fn add_dot>(&mut self, weight: W) -> GenericIndex { - GenericIndex::::new(self.graph.add_node(weight.into())) + pub fn add_dot>(&mut self, weight: W) -> GenericIndex { + GenericIndex::::new( + self.graph + .add_node(CompoundWeight::Primitive(weight.into())), + ) } - pub fn add_seg>( + pub fn add_seg>( &mut self, from: DI, to: DI, weight: W, ) -> GenericIndex { - let seg = GenericIndex::::new(self.graph.add_node(weight.into())); + let seg = GenericIndex::::new( + self.graph + .add_node(CompoundWeight::Primitive(weight.into())), + ); self.graph .update_edge(from.node_index(), seg.node_index(), GeometryLabel::Joined); @@ -125,14 +145,17 @@ impl< seg } - pub fn add_bend>( + pub fn add_bend>( &mut self, from: DI, to: DI, core: DI, weight: W, ) -> GenericIndex { - let bend = GenericIndex::::new(self.graph.add_node(weight.into())); + let bend = GenericIndex::::new( + self.graph + .add_node(CompoundWeight::Primitive(weight.into())), + ); self.graph .update_edge(from.node_index(), bend.node_index(), GeometryLabel::Joined); @@ -144,20 +167,22 @@ impl< bend } - pub fn remove(&mut self, node: GI) { + pub fn remove(&mut self, node: PI) { self.graph.remove_node(node.node_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() = weight.into(); + *self.graph.node_weight_mut(dot.node_index()).unwrap() = + CompoundWeight::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() = weight.into(); + *self.graph.node_weight_mut(bend.node_index()).unwrap() = + CompoundWeight::Primitive(weight.into()); } pub fn flip_bend(&mut self, bend: BI) { @@ -218,7 +243,7 @@ impl< Shape::Seg(SegShape { from: self.dot_weight(from).pos(), to: self.dot_weight(to).pos(), - width: self.weight(seg.node_index()).width(), + width: self.primitive_weight(seg.node_index()).width(), }) } @@ -232,7 +257,7 @@ impl< pos: core_weight.pos(), r: self.inner_radius(bend), }, - width: self.weight(bend.node_index()).width(), + width: self.primitive_weight(bend.node_index()).width(), }) } @@ -252,24 +277,28 @@ impl< self.core_weight(bend).width() / 2.0 + r } - fn weight(&self, index: NodeIndex) -> GW { - *self.graph.node_weight(index).unwrap() + fn primitive_weight(&self, index: NodeIndex) -> PW { + if let CompoundWeight::Primitive(weight) = *self.graph.node_weight(index).unwrap() { + weight + } else { + unreachable!() + } } pub fn dot_weight(&self, dot: DI) -> DW { - self.weight(dot.node_index()) + self.primitive_weight(dot.node_index()) .try_into() .unwrap_or_else(|_| unreachable!()) } pub fn seg_weight(&self, seg: SI) -> SW { - self.weight(seg.node_index()) + self.primitive_weight(seg.node_index()) .try_into() .unwrap_or_else(|_| unreachable!()) } pub fn bend_weight(&self, bend: BI) -> BW { - self.weight(bend.node_index()) + self.primitive_weight(bend.node_index()) .try_into() .unwrap_or_else(|_| unreachable!()) } @@ -286,7 +315,7 @@ impl< ) }) .map(|ni| { - self.weight(ni) + self.primitive_weight(ni) .try_into() .unwrap_or_else(|_| unreachable!()) }) @@ -306,7 +335,7 @@ impl< ) }) .map(|ni| { - self.weight(ni) + self.primitive_weight(ni) .retag(ni) .try_into() .unwrap_or_else(|_| unreachable!()) @@ -326,7 +355,7 @@ impl< ) }) .map(|ni| { - self.weight(ni) + self.primitive_weight(ni) .retag(ni) .try_into() .unwrap_or_else(|_| unreachable!()) @@ -347,7 +376,7 @@ impl< ) }) .map(|ni| { - self.weight(ni) + self.primitive_weight(ni) .retag(ni) .try_into() .unwrap_or_else(|_| unreachable!()) @@ -367,7 +396,7 @@ impl< ) }) .map(|ni| { - self.weight(ni) + self.primitive_weight(ni) .retag(ni) .try_into() .unwrap_or_else(|_| unreachable!()) @@ -375,7 +404,7 @@ impl< .next() } - pub fn joineds(&self, node: GI) -> impl Iterator + '_ { + pub fn joineds(&self, node: PI) -> impl Iterator + '_ { self.graph .neighbors_undirected(node.node_index()) .filter(move |ni| { @@ -392,7 +421,7 @@ impl< ) }) .map(|ni| { - self.weight(ni) + self.primitive_weight(ni) .retag(ni) .try_into() .unwrap_or_else(|_| unreachable!()) @@ -423,7 +452,7 @@ impl< self.joineds(dot.into()).filter_map(|ni| ni.try_into().ok()) } - pub fn graph(&self) -> &StableDiGraph { + pub fn graph(&self) -> &StableDiGraph, GeometryLabel, usize> { &self.graph } } diff --git a/src/geometry/with_rtree.rs b/src/geometry/with_rtree.rs index 945c125..0b8ae6c 100644 --- a/src/geometry/with_rtree.rs +++ b/src/geometry/with_rtree.rs @@ -7,14 +7,14 @@ use rstar::{primitives::GeomWithData, RTree, RTreeObject, AABB}; use crate::{ drawing::graph::{GetLayer, Retag}, + geometry::{ + shape::{Shape, ShapeTrait}, + BendWeightTrait, CompoundWeight, DotWeightTrait, Geometry, GeometryLabel, GetWidth, + SegWeightTrait, + }, graph::{GenericIndex, GetNodeIndex}, }; -use super::{ - shape::{Shape, ShapeTrait}, - BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel, GetWidth, SegWeightTrait, -}; - #[derive(Debug, Clone, Copy, PartialEq)] pub struct Bbox { aabb: AABB<[f64; 3]>, @@ -39,23 +39,25 @@ type BboxedIndex = GeomWithData; #[derive(Debug)] pub struct GeometryWithRtree< - GW: GetWidth + GetLayer + TryInto + TryInto + TryInto + Retag + Copy, - DW: DotWeightTrait + GetLayer + Copy, - SW: SegWeightTrait + GetLayer + Copy, - BW: BendWeightTrait + GetLayer + Copy, - GI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, + PW: GetWidth + GetLayer + TryInto + TryInto + TryInto + Retag + Copy, + DW: DotWeightTrait + GetLayer, + SW: SegWeightTrait + GetLayer, + BW: BendWeightTrait + GetLayer, + GW: Copy, + PI: GetNodeIndex + TryInto + TryInto + TryInto + Copy, + DI: GetNodeIndex + Into + Copy, + SI: GetNodeIndex + Into + Copy, + BI: GetNodeIndex + Into + Copy, + GI: GetNodeIndex + Copy, > { - geometry: Geometry, - rtree: RTree>, + geometry: Geometry, + rtree: RTree>, layer_count: u64, - weight_marker: PhantomData, + weight_marker: PhantomData, dot_weight_marker: PhantomData, seg_weight_marker: PhantomData, bend_weight_marker: PhantomData, - index_marker: PhantomData, + index_marker: PhantomData, dot_index_marker: PhantomData, seg_index_marker: PhantomData, bend_index_marker: PhantomData, @@ -64,19 +66,21 @@ pub struct GeometryWithRtree< #[debug_invariant(self.test_envelopes())] #[debug_invariant(self.geometry.graph().node_count() == self.rtree.size())] impl< - GW: GetWidth + GetLayer + TryInto + TryInto + TryInto + Retag + Copy, - DW: DotWeightTrait + GetLayer + Copy, - SW: SegWeightTrait + GetLayer + Copy, - BW: BendWeightTrait + GetLayer + Copy, - GI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, - > GeometryWithRtree + PW: GetWidth + GetLayer + TryInto + TryInto + TryInto + Retag + Copy, + DW: DotWeightTrait + GetLayer, + SW: SegWeightTrait + GetLayer, + BW: BendWeightTrait + GetLayer, + GW: Copy, + PI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, + DI: GetNodeIndex + Into + Copy, + SI: GetNodeIndex + Into + Copy, + BI: GetNodeIndex + Into + Copy, + GI: GetNodeIndex + Copy, + > GeometryWithRtree { pub fn new(layer_count: u64) -> Self { Self { - geometry: Geometry::::new(), + geometry: Geometry::::new(), rtree: RTree::new(), layer_count, weight_marker: PhantomData, @@ -90,9 +94,9 @@ impl< } } - pub fn add_dot + GetLayer>(&mut self, weight: W) -> GenericIndex + pub fn add_dot + GetLayer>(&mut self, weight: W) -> GenericIndex where - GenericIndex: Into, + GenericIndex: Into, { let dot = self.geometry.add_dot(weight); self.rtree.insert(BboxedIndex::new( @@ -107,14 +111,14 @@ impl< dot } - pub fn add_seg + GetLayer>( + pub fn add_seg + GetLayer>( &mut self, from: DI, to: DI, weight: W, ) -> GenericIndex where - GenericIndex: Into, + GenericIndex: Into, { let seg = self.geometry.add_seg(from, to, weight); self.rtree.insert(BboxedIndex::new( @@ -129,7 +133,7 @@ impl< seg } - pub fn add_bend + GetLayer>( + pub fn add_bend + GetLayer>( &mut self, from: DI, to: DI, @@ -137,7 +141,7 @@ impl< weight: W, ) -> GenericIndex where - GenericIndex: Into, + GenericIndex: Into, { let bend = self.geometry.add_bend(from, to, core, weight); self.rtree.insert(BboxedIndex::new( @@ -245,70 +249,72 @@ impl< } impl< - GW: GetWidth + GetLayer + TryInto + TryInto + TryInto + Retag + Copy, - DW: DotWeightTrait + GetLayer + Copy, - SW: SegWeightTrait + GetLayer + Copy, - BW: BendWeightTrait + GetLayer + Copy, - GI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, - DI: GetNodeIndex + Into + Copy, - SI: GetNodeIndex + Into + Copy, - BI: GetNodeIndex + Into + Copy, - > GeometryWithRtree + PW: GetWidth + GetLayer + TryInto + TryInto + TryInto + Retag + Copy, + DW: DotWeightTrait + GetLayer, + SW: SegWeightTrait + GetLayer, + BW: BendWeightTrait + GetLayer, + GW: Copy, + PI: GetNodeIndex + TryInto + TryInto + TryInto + PartialEq + Copy, + DI: GetNodeIndex + Into + Copy, + SI: GetNodeIndex + Into + Copy, + BI: GetNodeIndex + Into + Copy, + GI: GetNodeIndex + Copy, + > GeometryWithRtree { - fn make_dot_bbox(&self, dot: DI) -> BboxedIndex { + fn make_dot_bbox(&self, dot: DI) -> BboxedIndex { BboxedIndex::new( Bbox::new(&self.geometry.dot_shape(dot), self.layer(dot.into())), dot.into(), ) } - fn make_seg_bbox(&self, seg: SI) -> BboxedIndex { + fn make_seg_bbox(&self, seg: SI) -> BboxedIndex { BboxedIndex::new( Bbox::new(&self.geometry.seg_shape(seg), self.layer(seg.into())), seg.into(), ) } - fn make_bend_bbox(&self, bend: BI) -> BboxedIndex { + fn make_bend_bbox(&self, bend: BI) -> BboxedIndex { BboxedIndex::new( Bbox::new(&self.geometry.bend_shape(bend), self.layer(bend.into())), bend.into(), ) } - fn shape(&self, index: GI) -> Shape { - if let Ok(dot) = >::try_into(index) { + fn shape(&self, index: PI) -> Shape { + if let Ok(dot) = >::try_into(index) { self.geometry.dot_shape(dot) - } else if let Ok(seg) = >::try_into(index) { + } else if let Ok(seg) = >::try_into(index) { self.geometry.seg_shape(seg) - } else if let Ok(bend) = >::try_into(index) { + } else if let Ok(bend) = >::try_into(index) { self.geometry.bend_shape(bend) } else { unreachable!(); } } - fn layer(&self, index: GI) -> u64 { - if let Ok(dot) = >::try_into(index) { + fn layer(&self, index: PI) -> u64 { + if let Ok(dot) = >::try_into(index) { self.geometry.dot_weight(dot).layer() - } else if let Ok(seg) = >::try_into(index) { + } else if let Ok(seg) = >::try_into(index) { self.geometry.seg_weight(seg).layer() - } else if let Ok(bend) = >::try_into(index) { + } else if let Ok(bend) = >::try_into(index) { self.geometry.bend_weight(bend).layer() } else { unreachable!(); } } - pub fn geometry(&self) -> &Geometry { + pub fn geometry(&self) -> &Geometry { &self.geometry } - pub fn rtree(&self) -> &RTree> { + pub fn rtree(&self) -> &RTree> { &self.rtree } - pub fn graph(&self) -> &StableDiGraph { + pub fn graph(&self) -> &StableDiGraph, GeometryLabel, usize> { self.geometry.graph() }