router: reimplement interactive routing

src/band.rs

@@ -4,7 +4,7 @@ use crate::{
     graph::GetNodeIndex,
     layout::Layout,
     loose::{GetNextLoose, LooseIndex},
-    primitive::GetEnds,
+    primitive::{GetEnds, GetOtherEnd},
 };
 
 pub struct Band<'a> {
@@ -46,14 +46,18 @@ impl<'a> Band<'a> {
             maybe_loose = self.layout.loose(loose).next_loose(prev_prev);
         }
 
-        if let Some(LooseIndex::SeqSeg(seg)) = maybe_loose {
+        match prev {
-            if let DotIndex::Fixed(dot) = self.layout.primitive(seg).ends().0 {
+            Some(LooseIndex::LoneSeg(seg)) => {
-                Some(dot)
+                Some(self.layout.primitive(seg).other_end(self.from()))
-            } else {
-                unreachable!()
             }
-        } else {
+            Some(LooseIndex::SeqSeg(seg)) => {
-            None
+                if let DotIndex::Fixed(dot) = self.layout.primitive(seg).ends().0 {
+                    Some(dot)
+                } else {
+                    None
+                }
+            }
+            _ => unreachable!(),
         }
     }
 }

src/layout.rs

@@ -92,8 +92,9 @@ impl Layout {
                 LooseIndex::Dot(dot) => {
                     dots.push(dot);
                 }
-                LooseIndex::LoneSeg(..) => {
+                LooseIndex::LoneSeg(seg) => {
-                    unreachable!();
+                    self.remove(seg.into());
+                    break;
                 }
                 LooseIndex::SeqSeg(seg) => {
                     segs.push(seg);

src/main.rs

@@ -28,6 +28,7 @@ mod tracer;
 mod triangulation;
 mod wraparoundable;
 
+use connectivity::BandIndex;
 use draw::DrawException;
 use geo::point;
 use geometry::{FixedDotIndex, FixedSegWeight, GeometryIndex, LooseDotIndex, MakePrimitive};
@@ -116,7 +117,6 @@ impl<'a> RouterObserver for DebugRouterObserver<'a> {
             self.font_context,
             RouterOrLayout::Layout(tracer.layout),
             None,
-            None,
             Some(tracer.mesh.clone()),
             &trace.path,
             &[],
@@ -135,7 +135,6 @@ impl<'a> RouterObserver for DebugRouterObserver<'a> {
             self.font_context,
             RouterOrLayout::Layout(tracer.layout),
             None,
-            None,
             Some(tracer.mesh.clone()),
             &path,
             &[],
@@ -167,7 +166,6 @@ impl<'a> RouterObserver for DebugRouterObserver<'a> {
             self.font_context,
             RouterOrLayout::Layout(tracer.layout),
             None,
-            None,
             Some(tracer.mesh.clone()),
             &trace.path,
             &ghosts,
@@ -510,7 +508,6 @@ fn main() -> Result<(), anyhow::Error> {
         RouterOrLayout::Layout(&router.layout),
         None,
         None,
-        None,
         &[],
         &[],
         &[],
@@ -543,7 +540,6 @@ fn main() -> Result<(), anyhow::Error> {
         RouterOrLayout::Layout(&router.layout),
         None,
         None,
-        None,
         &[],
         &[],
         &[],
@@ -565,7 +561,6 @@ fn main() -> Result<(), anyhow::Error> {
         RouterOrLayout::Layout(&router.layout),
         None,
         None,
-        None,
         &[],
         &[],
         &[],
@@ -582,6 +577,33 @@ fn main() -> Result<(), anyhow::Error> {
         RouterOrLayout::Layout(&router.layout),
         None,
         None,
+        &[],
+        &[],
+        &[],
+        -1,
+    );
+
+    render_times(
+        &mut event_pump,
+        &window,
+        &mut renderer,
+        &font_context,
+        RouterOrLayout::Router(&mut router),
+        Some(band2),
+        None,
+        &[],
+        &[],
+        &[],
+        -1,
+    );
+
+    render_times(
+        &mut event_pump,
+        &window,
+        &mut renderer,
+        &font_context,
+        RouterOrLayout::Layout(&router.layout),
+        None,
         None,
         &[],
         &[],
@@ -598,9 +620,8 @@ fn render_times(
     renderer: &mut Renderer<GLDevice>,
     font_context: &CanvasFontContext,
     mut router_or_layout: RouterOrLayout,
-    from: Option<FixedDotIndex>,
+    maybe_band: Option<BandIndex>,
-    follower: Option<LooseDotIndex>,
+    mut maybe_mesh: Option<Mesh>,
-    mut mesh: Option<Mesh>,
     path: &[VertexIndex],
     ghosts: &[Shape],
     highlighteds: &[GeometryIndex],
@@ -628,27 +649,22 @@ fn render_times(
 
         let layout = match router_or_layout {
             RouterOrLayout::Router(ref mut router) => {
-                if let Some(follower) = follower {
+                let state = event_pump.mouse_state();
-                    let state = event_pump.mouse_state();
 
-                    if let Some(from) = from {
+                if let Some(band) = maybe_band {
-                        mesh = router
+                    router
-                            .reroute(
+                        .reroute_band(
-                                from,
+                            band,
-                                point! {x: state.x() as f64, y: state.y() as f64},
+                            point! {x: state.x() as f64, y: state.y() as f64},
-                                &mut DebugRouterObserver::new(
+                            &mut DebugRouterObserver::new(
-                                    event_pump,
+                                event_pump,
-                                    window,
+                                window,
-                                    renderer,
+                                renderer,
-                                    font_context,
+                                font_context,
-                                ),
+                            ),
-                            )
+                        )
-                            .ok();
+                        .ok();
-                    } else {
+                    maybe_mesh = None;
-                        let _ = router
-                            .layout
-                            .move_dot(follower.into(), (state.x() as f64, state.y() as f64).into());
-                    }
                 }
 
                 &router.layout
@@ -672,7 +688,7 @@ fn render_times(
             render_shape(&mut canvas, &ghost, ColorU::new(75, 75, 150, 255));
         }
 
-        if let Some(ref mesh) = mesh {
+        if let Some(ref mesh) = maybe_mesh {
             for edge in mesh.edge_references() {
                 let start_point = edge.source().primitive(layout).shape().center();
                 let end_point = edge.target().primitive(layout).shape().center();

src/router.rs

@@ -4,12 +4,13 @@ use spade::InsertionError;
 use thiserror::Error;
 
 use crate::astar::{astar, AstarStrategy, PathTracker};
-use crate::connectivity::BandIndex;
+use crate::connectivity::{BandIndex, GetNet};
 use crate::draw::DrawException;
-use crate::geometry::FixedDotIndex;
+use crate::geometry::{FixedDotIndex, FixedDotWeight};
 use crate::guide::HeadTrait;
 use crate::layout::Layout;
 
+use crate::math::Circle;
 use crate::mesh::{Mesh, MeshEdgeReference, VertexIndex};
 
 use crate::rules::Rules;
@@ -147,13 +148,17 @@ impl Router {
         Ok(band)
     }
 
-    pub fn reroute(
+    pub fn reroute_band(
         &mut self,
-        _from: FixedDotIndex,
+        band: BandIndex,
-        _to: Point,
+        to: Point,
-        _observer: &mut impl RouterObserver,
+        observer: &mut impl RouterObserver,
-    ) -> Result<Mesh, InsertionError> {
+    ) -> Result<BandIndex, RoutingError> {
-        Ok(Mesh::new(&self.layout))
+        let from_dot = self.layout.band(band).from();
+        let to_dot = self.layout.band(band).to().unwrap();
+        self.layout.remove_band(band);
+        self.layout.move_dot(to_dot.into(), to).unwrap(); // TODO: Remove `.unwrap()`.
+        self.route_band(from_dot, to_dot, observer)
     }
 
     pub fn tracer<'a>(&'a mut self, mesh: &'a Mesh) -> Tracer {