From a838310ecb8ef3457b57011bd841dd4542a2edc2 Mon Sep 17 00:00:00 2001 From: Mikolaj Wielgus Date: Thu, 28 Nov 2024 05:15:39 +0100 Subject: [PATCH] feat(geometry): add interface to apply edits --- src/geometry/geometry.rs | 41 +++++++++++++++ src/geometry/recording_with_rtree.rs | 52 +++++++++++++++++++ src/geometry/with_rtree.rs | 75 ++++++++++++++++++++-------- 3 files changed, 148 insertions(+), 20 deletions(-) diff --git a/src/geometry/geometry.rs b/src/geometry/geometry.rs index 91f04d9..0142c44 100644 --- a/src/geometry/geometry.rs +++ b/src/geometry/geometry.rs @@ -124,6 +124,15 @@ impl< GenericIndex::::new(self.graph.add_node(GenericNode::Primitive(weight.into()))) } + pub(super) fn add_dot_at_index>( + &mut self, + dot: GenericIndex, + weight: W, + ) { + self.graph + .update_node(dot.petgraph_index(), GenericNode::Primitive(weight.into())); + } + pub fn add_seg>( &mut self, from: DI, @@ -136,6 +145,18 @@ impl< seg } + pub(super) fn add_seg_at_index>( + &mut self, + seg: GenericIndex, + from: DI, + to: DI, + weight: W, + ) { + self.graph + .update_node(seg.petgraph_index(), GenericNode::Primitive(weight.into())); + self.init_seg_joints(seg, from, to); + } + fn init_seg_joints>(&mut self, seg: GenericIndex, from: DI, to: DI) { self.graph.update_edge( from.petgraph_index(), @@ -162,6 +183,26 @@ impl< bend } + pub(super) fn add_bend_at_index>( + &mut self, + bend: GenericIndex, + from: DI, + to: DI, + core: DI, + weight: W, + ) { + self.graph + .update_node(bend.petgraph_index(), GenericNode::Primitive(weight.into())); + self.init_bend_joints_and_core(bend, from, to, core); + } + + pub(super) fn add_compound_at_index(&mut self, compound: GenericIndex, weight: CW) { + self.graph.update_node( + compound.petgraph_index(), + GenericNode::Compound(weight.into()), + ); + } + fn init_bend_joints_and_core>( &mut self, bend: GenericIndex, diff --git a/src/geometry/recording_with_rtree.rs b/src/geometry/recording_with_rtree.rs index 99325f3..f930d93 100644 --- a/src/geometry/recording_with_rtree.rs +++ b/src/geometry/recording_with_rtree.rs @@ -333,6 +333,58 @@ impl< } } + pub fn apply_edit(&mut self, edit: GeometryEdit) { + for (compound, ..) in &edit.compounds { + self.geometry_with_rtree.remove_compound(*compound); + } + + for (bend, ..) in &edit.bends { + self.geometry_with_rtree.remove_bend(*bend); + } + + for (seg, ..) in &edit.segs { + self.geometry_with_rtree.remove_seg(*seg); + } + + for (dot, ..) in &edit.dots { + self.geometry_with_rtree.remove_dot(*dot); + } + + for (dot, (.., maybe_weight)) in &edit.dots { + if let Some(weight) = maybe_weight { + self.geometry_with_rtree.add_dot_at_index(*dot, *weight); + } + } + + for (seg, (.., maybe_data)) in &edit.segs { + if let Some(((from, to), weight)) = maybe_data { + self.geometry_with_rtree + .add_seg_at_index(*seg, *from, *to, *weight); + } + } + + for (bend, (.., maybe_data)) in &edit.bends { + if let Some(((from, to, core), weight)) = maybe_data { + self.geometry_with_rtree + .add_bend_at_index(*bend, *from, *to, *core, *weight); + } + } + + for (compound, (.., maybe_data)) in &edit.compounds { + if let Some((members, weight)) = maybe_data { + self.geometry_with_rtree + .add_compound_at_index(*compound, *weight); + + for member in members { + self.geometry_with_rtree.add_to_compound( + GenericIndex::::new(member.petgraph_index()), + *compound, + ); + } + } + } + } + pub fn compound_weight(&self, compound: GenericIndex) -> CW { self.geometry_with_rtree.compound_weight(compound) } diff --git a/src/geometry/with_rtree.rs b/src/geometry/with_rtree.rs index 42b9201..e800cef 100644 --- a/src/geometry/with_rtree.rs +++ b/src/geometry/with_rtree.rs @@ -79,16 +79,22 @@ impl< GenericIndex: Into, { let dot = self.geometry.add_dot(weight); - self.init_dot_bbox(dot, weight); + self.init_dot_bbox(dot.into().try_into().unwrap_or_else(|_| unreachable!())); dot } - fn init_dot_bbox + GetLayer>(&mut self, dot: GenericIndex, weight: W) - where - GenericIndex: Into, - { - self.rtree - .insert(self.make_dot_bbox(dot.into().try_into().unwrap_or_else(|_| unreachable!()))); + pub(super) fn add_dot_at_index + GetLayer>( + &mut self, + dot: DI, + weight: W, + ) { + self.geometry + .add_dot_at_index(GenericIndex::::new(dot.petgraph_index()), weight); + self.init_dot_bbox(dot); + } + + fn init_dot_bbox(&mut self, dot: DI) { + self.rtree.insert(self.make_dot_bbox(dot)); } pub fn add_seg + GetLayer>( @@ -101,16 +107,28 @@ impl< GenericIndex: Into, { let seg = self.geometry.add_seg(from, to, weight); - self.init_seg_bbox(seg, weight); + self.init_seg_bbox(seg.into().try_into().unwrap_or_else(|_| unreachable!())); seg } - fn init_seg_bbox + GetLayer>(&mut self, seg: GenericIndex, weight: W) - where - GenericIndex: Into, - { - self.rtree - .insert(self.make_seg_bbox(seg.into().try_into().unwrap_or_else(|_| unreachable!()))); + pub(super) fn add_seg_at_index + GetLayer>( + &mut self, + seg: SI, + from: DI, + to: DI, + weight: W, + ) { + self.geometry.add_seg_at_index( + GenericIndex::::new(seg.petgraph_index()), + from, + to, + weight, + ); + self.init_seg_bbox(seg); + } + + fn init_seg_bbox(&mut self, seg: SI) { + self.rtree.insert(self.make_seg_bbox(seg)); } pub fn add_bend + GetLayer>( @@ -124,17 +142,34 @@ impl< GenericIndex: Into, { let bend = self.geometry.add_bend(from, to, core, weight); - self.init_bend_bbox(bend, weight); + self.init_bend_bbox(bend.into().try_into().unwrap_or_else(|_| unreachable!())); bend } - fn init_bend_bbox + GetLayer>( + pub(super) fn add_bend_at_index + GetLayer>( &mut self, - bend: GenericIndex, + bend: BI, + from: DI, + to: DI, + core: DI, weight: W, - ) where - GenericIndex: Into, - { + ) { + self.geometry.add_bend_at_index( + GenericIndex::::new(bend.petgraph_index()), + from, + to, + core, + weight, + ); + self.init_bend_bbox(bend); + } + + pub(super) fn add_compound_at_index(&mut self, compound: GenericIndex, weight: CW) { + self.geometry + .add_compound_at_index(GenericIndex::::new(compound.petgraph_index()), weight); + } + + fn init_bend_bbox(&mut self, bend: BI) { self.rtree .insert(self.make_bend_bbox(bend.into().try_into().unwrap_or_else(|_| unreachable!()))); }