Reinsert all bends into R-tree when moving a dot

This was causing a crash. Added some code that was used to debug this.

src/layout.rs

@@ -206,7 +206,6 @@ impl Layout {
     fn relax_band(&mut self, bend: BendIndex) {
         let mut prev_bend = bend;
         while let Some(cur_bend) = self.mesh.primitive(prev_bend).prev_akin() {
-            dbg!(cur_bend);
             if self.mesh.primitive(cur_bend).cross_product() >= 0.0 {
                 self.release_bow(cur_bend);
             }
@@ -216,7 +215,6 @@ impl Layout {
 
         let mut prev_bend = bend;
         while let Some(cur_bend) = self.mesh.primitive(prev_bend).next_akin() {
-            dbg!(cur_bend);
             if self.mesh.primitive(cur_bend).cross_product() >= 0.0 {
                 self.release_bow(cur_bend);
             }

src/main.rs

@@ -16,6 +16,7 @@ mod primitive;
 mod shape;
 mod math;
 
+use std::panic;
 use std::time::Duration;
 use graph::{TaggedIndex, Tag};
 use sdl2::EventPump;
@@ -202,6 +203,7 @@ fn render_times(event_pump: &mut EventPump, canvas: &mut Canvas<Window>, layout:
             layout.move_dot(*follower.as_dot().unwrap(), (state.x() as f64, state.y() as f64).into());
         }
 
+        let result = panic::catch_unwind(|| {
             for shape in layout.shapes() {
                 if let Some(center) = shape.center {
                     let circle = shape.circle().unwrap();
@@ -236,6 +238,17 @@ fn render_times(event_pump: &mut EventPump, canvas: &mut Canvas<Window>, layout:
                                                  (shape.width / 2.0) as i16,
                                                  Color::RGB(200, 52, 52));
                 }
+                /*let envelope = shape.envelope();
+                let _ = canvas.rectangle(envelope.lower()[0] as i16,
+                                         envelope.lower()[1] as i16,
+                                         envelope.upper()[0] as i16,
+                                         envelope.upper()[1] as i16,
+                                         Color::RGB(100, 100, 100));*/
+            }
+        });
+
+        if let Err(err) = result {
+            dbg!(err);
         }
 
         canvas.present();

src/mesh.rs

@@ -41,8 +41,9 @@ impl Mesh {
     pub fn remove<Weight: std::marker::Copy>(&mut self, index: Index<Weight>) {
         // Unnecessary retag. It should be possible to elide it.
         let weight = *self.graph.node_weight(index.index).unwrap();
-        self.rtree.remove(&RTreeWrapper::new(self.primitive(index).shape(), index.retag(weight)));
 
+        let wrapper = RTreeWrapper::new(self.primitive(index).shape(), index.retag(weight));
+        assert!(self.rtree.remove(&wrapper).is_some());
         self.graph.remove_node(index.index);
     }
 
@@ -110,6 +111,17 @@ impl Mesh {
     }
 
     pub fn move_dot(&mut self, dot: DotIndex, to: Point) {
+        let mut cur_bend = self.primitive(dot).outer();
+        loop {
+            match cur_bend {
+                Some(..) => (),
+                None => break,
+            }
+
+            self.remove_from_rtree(cur_bend.unwrap().tag());
+            cur_bend = self.primitive(cur_bend.unwrap()).outer()
+        }
+
         self.remove_from_rtree(dot.tag());
 
         let mut dot_weight = self.primitive(dot).weight();
@@ -117,6 +129,17 @@ impl Mesh {
         *self.graph.node_weight_mut(dot.index).unwrap() = TaggedWeight::Dot(dot_weight);
 
         self.insert_into_rtree(dot.tag());
+
+        let mut cur_bend = self.primitive(dot).outer();
+        loop {
+            match cur_bend {
+                Some(..) => (),
+                None => break,
+            }
+
+            self.insert_into_rtree(cur_bend.unwrap().tag());
+            cur_bend = self.primitive(cur_bend.unwrap()).outer()
+        }
     }
 
     pub fn nodes(&self) -> impl Iterator<Item=TaggedIndex> + '_ {

src/primitive.rs

@@ -63,13 +63,11 @@ impl<'a, Weight> Primitive<'a, Weight> {
         let mut prev_index = self.index.index;
 
         while let Some(index) = self.graph.neighbors_directed(prev_index, Outgoing)
-            .filter(|ni| dbg!(self.graph.find_edge(prev_index, *ni).is_some()))
+            .filter(|ni| self.graph.find_edge(prev_index, *ni).is_some())
-            .filter(|ni| dbg!(self.graph.edge_weight(self.graph.find_edge(prev_index, *ni).unwrap()).unwrap().is_end()))
+            .filter(|ni| self.graph.edge_weight(self.graph.find_edge(prev_index, *ni).unwrap()).unwrap().is_end())
             .next()
         {
             let weight = *self.graph.node_weight(index).unwrap();
-            dbg!(weight);
-            dbg!(index);
 
             if mem::discriminant(&self.tagged_weight()) == mem::discriminant(&weight) {
                 return Some(Index::<Weight>::new(index));
@@ -92,13 +90,11 @@ impl<'a, Weight> Primitive<'a, Weight> {
         let mut prev_index = self.index.index;
 
         while let Some(index) = self.graph.neighbors_directed(prev_index, Incoming)
-            .filter(|ni| dbg!(self.graph.find_edge(*ni, prev_index).is_some()))
+            .filter(|ni| self.graph.find_edge(*ni, prev_index).is_some())
-            .filter(|ni| dbg!(self.graph.edge_weight(self.graph.find_edge(*ni, prev_index).unwrap()).unwrap().is_end()))
+            .filter(|ni| self.graph.edge_weight(self.graph.find_edge(*ni, prev_index).unwrap()).unwrap().is_end())
             .next()
         {
             let weight = *self.graph.node_weight(index).unwrap();
-            dbg!(weight);
-            dbg!(index);
 
             if mem::discriminant(&self.tagged_weight()) == mem::discriminant(&weight) {
                 return Some(Index::<Weight>::new(index));

src/shape.rs

@@ -4,7 +4,7 @@ use rstar::{RTreeObject, AABB};
 use crate::graph::{TaggedWeight, DotWeight};
 use crate::math::Circle;
 
-#[derive(PartialEq)]
+#[derive(Debug, PartialEq)]
 pub struct Shape {
     pub width: f64,
     pub from: Point,