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,40 +203,52 @@ 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());
         }
 
-        for shape in layout.shapes() {
-            if let Some(center) = shape.center {
-                let circle = shape.circle().unwrap();
-                let delta1 = shape.from - circle.pos;
-                let delta2 = shape.to - circle.pos;
+        let result = panic::catch_unwind(|| {
+            for shape in layout.shapes() {
+                if let Some(center) = shape.center {
+                    let circle = shape.circle().unwrap();
+                    let delta1 = shape.from - circle.pos;
+                    let delta2 = shape.to - circle.pos;
 
-                let mut angle1 = delta1.y().atan2(delta1.x());
-                let mut angle2 = delta2.y().atan2(delta2.x());
+                    let mut angle1 = delta1.y().atan2(delta1.x());
+                    let mut angle2 = delta2.y().atan2(delta2.x());
 
-                for d in -2..3 {
-                    let _ = canvas.arc(
-                        //around_circle.pos.x() as i16,
-                        //around_circle.pos.y() as i16,
-                        circle.pos.x() as i16,
-                        circle.pos.y() as i16,
-                        //(shape.around_weight.unwrap().circle.r + 10.0 + (d as f64)) as i16,
-                        (circle.r + (d as f64)) as i16,
-                        angle1.to_degrees() as i16,
-                        angle2.to_degrees() as i16,
-                        Color::RGB(200, 52, 52));
+                    for d in -2..3 {
+                        let _ = canvas.arc(
+                            //around_circle.pos.x() as i16,
+                            //around_circle.pos.y() as i16,
+                            circle.pos.x() as i16,
+                            circle.pos.y() as i16,
+                            //(shape.around_weight.unwrap().circle.r + 10.0 + (d as f64)) as i16,
+                            (circle.r + (d as f64)) as i16,
+                            angle1.to_degrees() as i16,
+                            angle2.to_degrees() as i16,
+                            Color::RGB(200, 52, 52));
+                    }
+                } else if shape.from != shape.to {
+                    let _ = canvas.thick_line(shape.from.x() as i16,
+                                              shape.from.y() as i16,
+                                              shape.to.x() as i16,
+                                              shape.to.y() as i16,
+                                              shape.width as u8,
+                                              Color::RGB(200, 52, 52));
+                } else {
+                    let _ = canvas.filled_circle(shape.from.x() as i16,
+                                                 shape.from.y() as i16,
+                                                 (shape.width / 2.0) as i16,
+                                                 Color::RGB(200, 52, 52));
                 }
-            } else if shape.from != shape.to {
-                let _ = canvas.thick_line(shape.from.x() as i16,
-                                          shape.from.y() as i16,
-                                          shape.to.x() as i16,
-                                          shape.to.y() as i16,
-                                          shape.width as u8,
-                                          Color::RGB(200, 52, 52));
-            } else {
-                let _ = canvas.filled_circle(shape.from.x() as i16,
-                                             shape.from.y() as i16,
-                                             (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| dbg!(self.graph.edge_weight(self.graph.find_edge(prev_index, *ni).unwrap()).unwrap().is_end()))
+            .filter(|ni| self.graph.find_edge(prev_index, *ni).is_some())
+            .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| dbg!(self.graph.edge_weight(self.graph.find_edge(*ni, prev_index).unwrap()).unwrap().is_end()))
+            .filter(|ni| self.graph.find_edge(*ni, prev_index).is_some())
+            .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,