debug: Create and use `before_probe` observer for search visualization

Also changed `as_*`s to `into_*`s.

src/band.rs

@@ -29,7 +29,7 @@ impl Band {
             None
         } else {
             Some(Self {
-                from: *interior.pop().unwrap().as_dot().unwrap(),
+                from: interior.pop().unwrap().into_dot().unwrap(),
                 to: dot,
                 interior,
             })
@@ -54,7 +54,7 @@ impl Band {
         } else {
             Some(Self {
                 from: dot,
-                to: *interior.pop().unwrap().as_dot().unwrap(),
+                to: interior.pop().unwrap().into_dot().unwrap(),
                 interior,
             })
         }

src/bow.rs

@@ -21,18 +21,18 @@ impl Bow {
         let bend = index;
 
         let seg1_dot2 = Bend::new(bend, graph).prev().unwrap();
-        let seg1 = *Dot::new(seg1_dot2, graph)
+        let seg1 = Dot::new(seg1_dot2, graph)
             .tagged_prev()
             .unwrap()
-            .as_seg()
+            .into_seg()
             .unwrap();
         let seg1_dot1 = Seg::new(seg1, graph).prev().unwrap();
 
         let seg2_dot1 = Bend::new(bend, graph).next().unwrap();
-        let seg2 = *Dot::new(seg2_dot1, graph)
+        let seg2 = Dot::new(seg2_dot1, graph)
             .tagged_next()
             .unwrap()
-            .as_seg()
+            .into_seg()
             .unwrap();
         let seg2_dot2 = Seg::new(seg2, graph).next().unwrap();
 

src/guide.rs

@@ -116,7 +116,7 @@ impl<'a, 'b> Guide<'a, 'b> {
             .layout
             .primitive(bend)
             .shape()
-            .as_bend()
+            .into_bend()
             .unwrap()
             .circle();
         circle.r += self.rules.ruleset(&self.conditions).clearance.min;

src/layout.rs

@@ -188,7 +188,7 @@ impl Layout {
             .graph
             .node_weight(bend.index)
             .unwrap()
-            .as_bend()
+            .into_bend()
             .unwrap()
             .cw;
         self.graph

src/main.rs

@@ -40,7 +40,7 @@ use sdl2::EventPump;
 use shape::Shape;
 use std::panic;
 use std::time::Duration;
-use tracer::Tracer;
+use tracer::{Trace, Tracer};
 
 use crate::graph::DotWeight;
 use crate::math::Circle;
@@ -67,7 +67,7 @@ impl<'a> DebugRouterObserver<'a> {
 }
 
 impl<'a> RouterObserver for DebugRouterObserver<'a> {
-    fn on_rework(&mut self, tracer: &Tracer, path: &[VertexIndex]) {
+    fn on_rework(&mut self, tracer: &Tracer, trace: &Trace) {
         render_times(
             self.event_pump,
             self.canvas,
@@ -75,12 +75,39 @@ impl<'a> RouterObserver for DebugRouterObserver<'a> {
             None,
             None,
             Some(tracer.mesh.clone()),
-            path,
-            10,
+            &trace.path,
+            20,
+        );
+    }
+
+    fn before_probe(&mut self, tracer: &Tracer, trace: &Trace, edge: MeshEdgeReference) {
+        let mut path = trace.path.clone();
+        path.push(edge.target());
+        render_times(
+            self.event_pump,
+            self.canvas,
+            RouterOrLayout::Layout(tracer.layout),
+            None,
+            None,
+            Some(tracer.mesh.clone()),
+            &path,
+            5,
+        );
+    }
+
+    fn on_probe(&mut self, tracer: &Tracer, trace: &Trace, edge: MeshEdgeReference) {
+        render_times(
+            self.event_pump,
+            self.canvas,
+            RouterOrLayout::Layout(tracer.layout),
+            None,
+            None,
+            Some(tracer.mesh.clone()),
+            &trace.path,
+            5,
         );
     }
 
-    fn on_probe(&mut self, _tracer: &Tracer, _edge: MeshEdgeReference) {}
     fn on_estimate(&mut self, _tracer: &Tracer, _vertex: VertexIndex) {}
 }
 
@@ -120,7 +147,7 @@ fn main() {
         .add_dot(DotWeight {
             net: 1,
             circle: Circle {
-                pos: (500.5, 430.5).into(),
+                pos: (470.5, 350.5).into(),
                 r: 8.0,
             },
         })
@@ -208,6 +235,26 @@ fn main() {
         },
     );
 
+    let dot5 = router
+        .layout
+        .add_dot(DotWeight {
+            net: 2,
+            circle: Circle {
+                pos: (530.5, 400.5).into(),
+                r: 8.0,
+            },
+        })
+        .unwrap();
+
+    let _ = router.layout.add_seg(
+        dot4,
+        dot5,
+        SegWeight {
+            net: 20,
+            width: 16.0,
+        },
+    );
+
     let dot1_2 = router
         .layout
         .add_dot(DotWeight {
@@ -228,6 +275,15 @@ fn main() {
         },
     );
 
+    let _ = router.layout.add_seg(
+        dot1_2,
+        dot2_2,
+        SegWeight {
+            net: 20,
+            width: 16.0,
+        },
+    );
+
     render_times(
         &mut event_pump,
         &mut canvas,
@@ -283,7 +339,7 @@ fn render_times(
                     let state = event_pump.mouse_state();
 
                     /*let _ = router.layout.move_dot(
-                        *follower.as_dot().unwrap(),
+                        follower.into_dot().unwrap(),
                         (state.x() as f64, state.y() as f64).into(),
                     );*/
 

src/primitive.rs

@@ -286,7 +286,7 @@ impl<'a> Dot<'a> {
     }
 
     pub fn weight(&self) -> DotWeight {
-        *self.tagged_weight().as_dot().unwrap()
+        self.tagged_weight().into_dot().unwrap()
     }
 }
 
@@ -300,7 +300,7 @@ impl<'a> Seg<'a> {
     }
 
     pub fn weight(&self) -> SegWeight {
-        *self.tagged_weight().as_seg().unwrap()
+        self.tagged_weight().into_seg().unwrap()
     }
 }
 
@@ -348,7 +348,7 @@ impl<'a> Bend<'a> {
     }
 
     pub fn weight(&self) -> BendWeight {
-        *self.tagged_weight().as_bend().unwrap()
+        self.tagged_weight().into_bend().unwrap()
     }
 
     pub fn cross_product(&self) -> f64 {

src/router.rs

@@ -12,8 +12,9 @@ use crate::rules::Rules;
 use crate::tracer::{Trace, Tracer};
 
 pub trait RouterObserver {
-    fn on_rework(&mut self, tracer: &Tracer, path: &[VertexIndex]);
-    fn on_probe(&mut self, tracer: &Tracer, edge: MeshEdgeReference);
+    fn on_rework(&mut self, tracer: &Tracer, trace: &Trace);
+    fn before_probe(&mut self, tracer: &Tracer, trace: &Trace, edge: MeshEdgeReference);
+    fn on_probe(&mut self, tracer: &Tracer, trace: &Trace, edge: MeshEdgeReference);
     fn on_estimate(&mut self, tracer: &Tracer, vertex: VertexIndex);
 }
 
@@ -45,18 +46,19 @@ impl<'a, RO: RouterObserver> AstarStrategy<&Mesh, u64> for RouterAstarStrategy<'
         let new_path = tracker.reconstruct_path_to(vertex);
 
         self.tracer.rework_path(&mut self.trace, &new_path, 5.0);
-        self.observer.on_rework(&self.tracer, &new_path);
+        self.observer.on_rework(&self.tracer, &self.trace);
 
         self.tracer.finish(&mut self.trace, self.to, 5.0).is_ok()
     }
 
     fn edge_cost(&mut self, edge: MeshEdgeReference) -> Option<u64> {
+        self.observer.before_probe(&self.tracer, &self.trace, edge);
         if self
             .tracer
             .step(&mut self.trace, edge.target(), 5.0)
             .is_ok()
         {
-            self.observer.on_probe(&self.tracer, edge);
+            self.observer.on_probe(&self.tracer, &self.trace, edge);
             self.tracer.undo_step(&mut self.trace);
             Some(1)
         } else {

src/segbend.rs

@@ -22,12 +22,12 @@ impl Segbend {
         graph: &StableDiGraph<TaggedWeight, Label, usize>,
     ) -> Option<Self> {
         Dot::new(dot, graph).tagged_prev().map(|tagged_prev| {
-            let bend = *tagged_prev.as_bend().unwrap();
+            let bend = tagged_prev.into_bend().unwrap();
             let dot = Bend::new(bend, graph).prev().unwrap();
-            let seg = *Dot::new(dot, graph)
+            let seg = Dot::new(dot, graph)
                 .tagged_prev()
                 .unwrap()
-                .as_seg()
+                .into_seg()
                 .unwrap();
 
             Self { bend, dot, seg }
@@ -39,12 +39,12 @@ impl Segbend {
         graph: &StableDiGraph<TaggedWeight, Label, usize>,
     ) -> Option<Self> {
         Dot::new(dot, graph).tagged_next().map(|tagged_next| {
-            let bend = *tagged_next.as_bend().unwrap();
+            let bend = tagged_next.into_bend().unwrap();
             let dot = Bend::new(bend, graph).next().unwrap();
-            let seg = *Dot::new(dot, graph)
+            let seg = Dot::new(dot, graph)
                 .tagged_next()
                 .unwrap()
-                .as_seg()
+                .into_seg()
                 .unwrap();
 
             Self { bend, dot, seg }

src/tracer.rs

@@ -9,7 +9,7 @@ use crate::{
 
 #[derive(Debug)]
 pub struct Trace {
-    path: Vec<VertexIndex>,
+    pub path: Vec<VertexIndex>,
     head: Head,
 }