Speed up mode switching by recalculating cells/shortcuts at the appropriate time.

Author: dabreegster

backend/src/lib.rs

@@ -150,6 +150,7 @@ impl LTN {
             &self.neighbourhood.as_ref().unwrap().interior_roads,
             FilterKind::from_string(&kind).unwrap(),
         );
+        self.after_edit();
         Ok(())
     }
 
@@ -165,19 +166,23 @@ impl LTN {
             &self.neighbourhood.as_ref().unwrap().interior_roads,
             FilterKind::from_string(&kind).unwrap(),
         );
+        self.after_edit();
         Ok(())
     }
 
     #[wasm_bindgen(js_name = deleteModalFilter)]
     pub fn delete_modal_filter(&mut self, road: usize) {
         self.map.delete_modal_filter(RoadID(road));
+        self.after_edit();
     }
 
     pub fn undo(&mut self) {
         self.map.undo();
+        self.after_edit();
     }
     pub fn redo(&mut self) {
         self.map.redo();
+        self.after_edit();
     }
 
     #[wasm_bindgen(js_name = getShortcutsCrossingRoad)]
@@ -218,6 +223,14 @@ impl LTN {
         let pt2 = self.map.mercator.pt_to_mercator(Coord { x: x2, y: y2 });
         Ok(serde_json::to_string(&self.map.compare_route(pt1, pt2)).map_err(err_to_js)?)
     }
+
+    // TODO This is also internal to MapModel. But not sure who should own Neighbourhood or how to
+    // plumb, so duplicting here.
+    fn after_edit(&mut self) {
+        if let Some(ref mut n) = self.neighbourhood {
+            n.after_edit(&self.map);
+        }
+    }
 }
 
 #[derive(Deserialize)]

backend/src/neighbourhood.rs

@@ -10,11 +10,20 @@ use crate::render_cells::Color;
 use crate::{Cell, IntersectionID, MapModel, RenderCells, RoadID, Shortcuts};
 
 pub struct Neighbourhood {
+    // Immutable once created
     pub interior_roads: HashSet<RoadID>,
     crosses: HashMap<RoadID, f64>,
     pub border_intersections: HashSet<IntersectionID>,
     name: String,
     pub boundary_polygon: Polygon,
+
+    // Updated after mutations
+    derived: Option<DerivedNeighbourhoodState>,
+}
+
+struct DerivedNeighbourhoodState {
+    render_cells: RenderCells,
+    shortcuts: Shortcuts,
 }
 
 impl Neighbourhood {
@@ -60,32 +69,47 @@ impl Neighbourhood {
             bail!("No roads inside the boundary");
         }
 
-        Ok(Self {
+        let mut n = Self {
             interior_roads,
             crosses,
             border_intersections,
             name,
             boundary_polygon,
-        })
+            derived: None,
+        };
+        n.after_edit(map);
+        Ok(n)
+    }
+
+    pub fn after_edit(&mut self, map: &MapModel) {
+        let cells = Cell::find_all(map, self);
+        let render_cells = RenderCells::new(map, self, &cells);
+        let shortcuts = Shortcuts::new(map, self);
+        self.derived = Some(DerivedNeighbourhoodState {
+            render_cells,
+            shortcuts,
+        });
     }
 
     pub fn to_gj(&self, map: &MapModel) -> FeatureCollection {
         let mut features = Vec::new();
 
+        let derived = self.derived.as_ref().unwrap();
+
         // Just one boundary
         features.push(map.boundaries.get(&self.name).cloned().unwrap());
 
-        // TODO Decide how/where state lives
-        let cells = Cell::find_all(map, self);
-        let render_cells = RenderCells::new(map, self, &cells);
-        let shortcuts = Shortcuts::new(map, self);
-
         for r in &self.interior_roads {
             let mut f = map.get_r(*r).to_gj(&map.mercator);
             f.set_property("kind", "interior_road");
             f.set_property(
                 "shortcuts",
-                shortcuts.count_per_road.get(r).cloned().unwrap_or(0),
+                derived
+                    .shortcuts
+                    .count_per_road
+                    .get(r)
+                    .cloned()
+                    .unwrap_or(0),
             );
             features.push(f);
         }
@@ -101,15 +125,16 @@ impl Neighbourhood {
             features.push(f);
         }
 
-        for (polygons, color) in render_cells
+        for (polygons, color) in derived
+            .render_cells
             .polygons_per_cell
-            .into_iter()
-            .zip(render_cells.colors)
+            .iter()
+            .zip(derived.render_cells.colors.iter())
         {
-            let mut f = Feature::from(Geometry::from(&map.mercator.to_wgs84(&polygons)));
+            let mut f = Feature::from(Geometry::from(&map.mercator.to_wgs84(polygons)));
             match color {
                 Color::Disconnected => f.set_property("cell_color", "disconnected"),
-                Color::Cell(idx) => f.set_property("cell_color", idx),
+                Color::Cell(idx) => f.set_property("cell_color", *idx),
             }
             features.push(f);
         }