Unroute path whose routing failed in the middle

src/draw.rs

@@ -1,4 +1,4 @@
-use geo::Point;
+use geo::{EuclideanLength, Point};
 
 use crate::{
     graph::{BendIndex, BendWeight, DotIndex, DotWeight, Ends, SegIndex, SegWeight, TaggedIndex},
@@ -88,7 +88,21 @@ impl<'a> Draw<'a> {
     ) -> Result<Head, ()> {
         let tangent = self
             .guide(&Default::default())
-            .head_around_dot_segment(&head, around, cw, width);
+            .head_around_dot_segments(&head, around, width)
+            .1;
+        /*.into_iter()
+        .max_by(|x, y| x.euclidean_length().total_cmp(&y.euclidean_length()))
+        .unwrap();*/
+
+        /*let tangents = self
+            .guide(&Default::default())
+            .head_around_dot_segments(&head, around, width);
+
+        let tangent = if tangents.0.euclidean_length() <= tangents.1.euclidean_length() {
+            tangents.0
+        } else {
+            tangents.1
+        };*/
 
         head = self.extend_head(head, tangent.start_point())?;
         self.segbend(

src/guide.rs

@@ -48,6 +48,21 @@ impl<'a, 'b> Guide<'a, 'b> {
         math::tangent_segment(from_circle, from_cw, to_circle, Some(cw))
     }
 
+    pub fn head_around_dot_segments(
+        &self,
+        head: &Head,
+        around: DotIndex,
+        width: f64,
+    ) -> (Line, Line) {
+        let from_circle = self.head_circle(&head, width);
+        let to_circle = self.dot_circle(around, width);
+
+        let from_cw = self.head_cw(&head);
+        let tangents: Vec<Line> =
+            math::tangent_segments(from_circle, from_cw, to_circle, None).collect();
+        (tangents[0], tangents[1])
+    }
+
     pub fn head_around_dot_segment(
         &self,
         head: &Head,

src/main.rs

@@ -239,7 +239,7 @@ fn main() {
         .add_dot(DotWeight {
             net: 20,
             circle: Circle {
-                pos: (480.5, 700.5).into(),
+                pos: (480.5, 550.5).into(),
                 r: 8.0,
             },
         })

src/route.rs

@@ -60,8 +60,11 @@ impl<'a> Route<'a> {
     }
 
     pub fn path(&mut self, trace: &mut Trace, path: &[VertexIndex], width: f64) -> Result<(), ()> {
-        for vertex in path {
-            self.step(trace, *vertex, width)?;
+        for (i, vertex) in path.iter().enumerate() {
+            if let Err(err) = self.step(trace, *vertex, width) {
+                self.undo_path(trace, i)?;
+                return Err(err);
+            }
         }
         Ok(())
     }

src/router.rs

@@ -71,17 +71,6 @@ impl<'a, RS: RouteStrategy> AstarStrategy<&Mesh, u64> for RouterAstarStrategy<'a
     fn reroute(&mut self, vertex: VertexIndex, tracker: &PathTracker<&Mesh>) -> Option<u64> {
         let new_path = tracker.reconstruct_path_to(vertex);
 
-        /*if vertex == self.to {
-            self.route
-                .rework_path(&mut self.trace, &new_path[..new_path.len() - 1], 5.0)
-                .ok();
-            self.route
-                .finish(&mut self.trace, new_path[new_path.len() - 1], 5.0)
-                .ok();
-            None
-        } else {*/
-        //}
-
         self.route.rework_path(&mut self.trace, &new_path, 5.0).ok();
 
         if self.route.finish(&mut self.trace, self.to, 5.0).is_ok() {