From fd5a95103de5c0444395ce79774b7f3ab314585d Mon Sep 17 00:00:00 2001
From: Mikolaj Wielgus <wielgusmikolaj@gmail.com>
Date: Sat, 29 Jun 2024 03:07:20 +0200
Subject: [PATCH] autorouter: step through every band routing step, not merely
 over bands

---
 src/autorouter/autoroute.rs | 60 +++++++++++++++++++------------------
 src/bin/topola-egui/top.rs  |  4 +--
 src/router/route.rs         |  4 +++
 3 files changed, 37 insertions(+), 31 deletions(-)

diff --git a/src/autorouter/autoroute.rs b/src/autorouter/autoroute.rs
index 17bac13..c9d0805 100644
--- a/src/autorouter/autoroute.rs
+++ b/src/autorouter/autoroute.rs
@@ -3,12 +3,12 @@ use petgraph::graph::EdgeIndex;
 use crate::{
     autorouter::{Autorouter, AutorouterError, AutorouterStatus},
     board::mesadata::MesadataTrait,
-    router::{navmesh::Navmesh, Router},
+    router::{navmesh::Navmesh, route::Route, Router, RouterStatus},
 };
 
 pub struct Autoroute {
     ratlines_iter: Box<dyn Iterator<Item = EdgeIndex<usize>>>,
-    navmesh: Option<Navmesh>, // Useful for debugging.
+    route: Option<Route>,
     cur_ratline: Option<EdgeIndex<usize>>,
 }
 
@@ -24,12 +24,12 @@ impl Autoroute {
         };
 
         let (source, target) = autorouter.ratline_endpoints(cur_ratline);
-        let navmesh = Some(Navmesh::new(autorouter.board.layout(), source, target)?);
+        let mut router = Router::new(autorouter.board.layout_mut());
 
         let this = Self {
             ratlines_iter,
-            navmesh,
             cur_ratline: Some(cur_ratline),
+            route: Some(router.route_walk(source, target, 100.0)?),
         };
 
         Ok(this)
@@ -39,43 +39,45 @@ impl Autoroute {
         &mut self,
         autorouter: &mut Autorouter<M>,
     ) -> Result<AutorouterStatus, AutorouterError> {
-        let (new_navmesh, new_ratline) = if let Some(cur_ratline) = self.ratlines_iter.next() {
-            let (source, target) = autorouter.ratline_endpoints(cur_ratline);
-
-            (
-                Some(
-                    Navmesh::new(autorouter.board.layout(), source, target)
-                        .ok()
-                        .unwrap(),
-                ),
-                Some(cur_ratline),
-            )
-        } else {
-            (None, None)
+        let Some(ref mut route) = self.route else {
+            return Ok(AutorouterStatus::Finished);
         };
 
-        let navmesh = std::mem::replace(&mut self.navmesh, new_navmesh).unwrap();
-        let mut router = Router::new(autorouter.board.layout_mut());
+        let (source, target) = autorouter.ratline_endpoints(self.cur_ratline.unwrap());
 
-        let band = router.route(navmesh.source(), navmesh.target(), 100.0)?;
+        let band = {
+            let mut router = Router::new(autorouter.board.layout_mut());
+
+            let RouterStatus::Finished(band) = route.step(&mut router)? else {
+                return Ok(AutorouterStatus::Running);
+            };
+            band
+        };
 
         autorouter
             .ratsnest
             .assign_band_to_ratline(self.cur_ratline.unwrap(), band);
-        self.cur_ratline = new_ratline;
 
         autorouter
             .board
-            .try_set_band_between_nodes(navmesh.source(), navmesh.target(), band);
+            .try_set_band_between_nodes(source, target, band);
 
-        if self.navmesh.is_some() {
-            Ok(AutorouterStatus::Running)
-        } else {
-            Ok(AutorouterStatus::Finished)
-        }
+        let Some(new_ratline) = self.ratlines_iter.next() else {
+            self.route = None;
+            self.cur_ratline = None;
+            return Ok(AutorouterStatus::Finished);
+        };
+
+        let (source, target) = autorouter.ratline_endpoints(new_ratline);
+        let mut router = Router::new(autorouter.board.layout_mut());
+
+        self.cur_ratline = Some(new_ratline);
+        self.route = Some(router.route_walk(source, target, 100.0)?);
+
+        Ok(AutorouterStatus::Running)
     }
 
-    pub fn navmesh(&self) -> &Option<Navmesh> {
-        &self.navmesh
+    pub fn navmesh(&self) -> Option<&Navmesh> {
+        self.route.as_ref().map(|route| route.navmesh())
     }
 }
diff --git a/src/bin/topola-egui/top.rs b/src/bin/topola-egui/top.rs
index ae45a3f..dabf45c 100644
--- a/src/bin/topola-egui/top.rs
+++ b/src/bin/topola-egui/top.rs
@@ -121,7 +121,7 @@ impl Top {
                                     let mut shared_data = shared_data_arc_mutex.lock().unwrap();
                                     shared_data.from = Some(from);
                                     shared_data.to = Some(to);
-                                    shared_data.navmesh = autoroute.navmesh().clone();
+                                    shared_data.navmesh = autoroute.navmesh().cloned();
                                 }
                             }
 
@@ -137,7 +137,7 @@ impl Top {
 
                                 if let Execute::Autoroute(ref mut autoroute) = execute {
                                     shared_data_arc_mutex.lock().unwrap().navmesh =
-                                        autoroute.navmesh().clone();
+                                        autoroute.navmesh().cloned();
                                 }
                             };
                         });
diff --git a/src/router/route.rs b/src/router/route.rs
index 6f3fe5b..12d32e0 100644
--- a/src/router/route.rs
+++ b/src/router/route.rs
@@ -78,4 +78,8 @@ impl Route {
             AstarStatus::Finished(_cost, _path, band) => Ok(RouterStatus::Finished(band)),
         }
     }
+
+    pub fn navmesh(&self) -> &Navmesh {
+        &self.astar.graph
+    }
 }