refactor(autorouter/multilayer_reconfigurator): Wrap multilayer autoroute inputs in new structs

src/autorouter/autorouter.rs

@@ -13,9 +13,13 @@ use thiserror::Error;
 use crate::{
     autorouter::{
         multilayer_autoroute::MultilayerAutorouteOptions,
-        multilayer_reconfigurator::MultilayerAutorouteReconfigurator,
-        planar_autoroute::PlanarAutorouteConfiguration,
-        planar_reconfigurator::PlanarAutorouteReconfigurator, ratsnests::Ratsnests,
+        multilayer_reconfigurator::{
+            MultilayerAutorouteReconfigurator, MultilayerAutorouteReconfiguratorInput,
+        },
+        planar_reconfigurator::{
+            PlanarAutorouteReconfigurator, PlanarAutorouteReconfiguratorInput,
+        },
+        ratsnests::Ratsnests,
     },
     board::{AccessMesadata, Board},
     drawing::{band::BandTermsegIndex, graph::MakePrimitiveRef},
@@ -121,7 +125,9 @@ impl<M: AccessMesadata> Autorouter<M> {
     ) -> Result<MultilayerAutorouteReconfigurator, AutorouterError> {
         MultilayerAutorouteReconfigurator::new(
             self,
-            self.selected_ratlines(selection, options.planar.principal_layer),
+            MultilayerAutorouteReconfiguratorInput {
+                ratlines: self.selected_ratlines(selection, options.planar.principal_layer),
+            },
             options,
         )
     }
@@ -133,7 +139,7 @@ impl<M: AccessMesadata> Autorouter<M> {
     ) -> Result<PlanarAutorouteReconfigurator, AutorouterError> {
         PlanarAutorouteReconfigurator::new(
             self,
-            PlanarAutorouteConfiguration {
+            PlanarAutorouteReconfiguratorInput {
                 ratlines: self.selected_planar_ratlines(selection, options.principal_layer),
             },
             options,

src/autorouter/multilayer_autoroute.rs

@@ -11,9 +11,10 @@ use crate::{
     autorouter::{
         anterouter::{Anterouter, AnterouterOptions, AnterouterPlan},
         invoker::GetDebugOverlayData,
-        planar_autoroute::PlanarAutorouteConfiguration,
-        planar_reconfigurator::{PlanarAutorouteReconfigurator, PlanarReconfiguratorStatus},
-        ratline::RatlineUid,
+        planar_reconfigurator::{
+            PlanarAutorouteReconfigurator, PlanarAutorouteReconfiguratorInput,
+            PlanarReconfiguratorStatus,
+        },
         Autorouter, AutorouterError, PlanarAutorouteOptions,
     },
     board::edit::BoardEdit,
@@ -23,6 +24,12 @@ use crate::{
     stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step},
 };
 
+#[derive(Clone, Debug)]
+pub struct MultilayerAutorouteConfiguration {
+    pub plan: AnterouterPlan,
+    pub planar: PlanarAutorouteReconfiguratorInput,
+}
+
 #[derive(Clone, Copy, Debug, Deserialize, Serialize)]
 pub struct MultilayerAutorouteOptions {
     pub anterouter: AnterouterOptions,
@@ -38,18 +45,17 @@ pub struct MultilayerAutorouteExecutionStepper {
 impl MultilayerAutorouteExecutionStepper {
     pub fn new(
         autorouter: &mut Autorouter<impl AccessMesadata>,
-        ratlines: Vec<RatlineUid>,
-        plan: AnterouterPlan,
+        configuration: MultilayerAutorouteConfiguration,
         options: MultilayerAutorouteOptions,
     ) -> Result<Self, AutorouterError> {
-        let mut anterouter = Anterouter::new(plan);
+        let mut anterouter = Anterouter::new(configuration.plan);
         let mut anteroute_edit = BoardEdit::new();
         anterouter.anteroute(autorouter, &mut anteroute_edit, &options.anterouter);
 
         Ok(Self {
             planar: PlanarAutorouteReconfigurator::new(
                 autorouter,
-                PlanarAutorouteConfiguration { ratlines },
+                configuration.planar,
                 options.planar,
             )?,
             anteroute_edit,

src/autorouter/multilayer_reconfigurator.rs

@@ -9,9 +9,12 @@ use specctra_core::mesadata::AccessMesadata;
 use crate::{
     autorouter::{
         invoker::GetDebugOverlayData,
-        multilayer_autoroute::{MultilayerAutorouteExecutionStepper, MultilayerAutorouteOptions},
+        multilayer_autoroute::{
+            MultilayerAutorouteConfiguration, MultilayerAutorouteExecutionStepper,
+            MultilayerAutorouteOptions,
+        },
         multilayer_reconfigurer::MultilayerReconfigurer,
-        planar_reconfigurator::PlanarReconfiguratorStatus,
+        planar_reconfigurator::{PlanarAutorouteReconfiguratorInput, PlanarReconfiguratorStatus},
         planner::Planner,
         ratline::RatlineUid,
         Autorouter, AutorouterError,
@@ -23,6 +26,10 @@ use crate::{
     stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step},
 };
 
+pub struct MultilayerAutorouteReconfiguratorInput {
+    pub ratlines: Vec<RatlineUid>,
+}
+
 pub type MultilayerReconfiguratorStatus = ReconfiguratorStatus<(), PlanarReconfiguratorStatus>;
 
 pub struct MultilayerAutorouteReconfigurator {
@@ -36,17 +43,22 @@ pub struct MultilayerAutorouteReconfigurator {
 impl MultilayerAutorouteReconfigurator {
     pub fn new(
         autorouter: &mut Autorouter<impl AccessMesadata>,
-        ratlines: Vec<RatlineUid>,
+        input: MultilayerAutorouteReconfiguratorInput,
         options: MultilayerAutorouteOptions,
     ) -> Result<Self, AutorouterError> {
-        let planner = Planner::new(autorouter, &ratlines);
-        let reconfigurer = MultilayerReconfigurer::new(autorouter, ratlines.clone(), &options);
+        let planner = Planner::new(autorouter, &input.ratlines);
+        let preconfiguration = MultilayerAutorouteConfiguration {
+            plan: planner.plan().clone(),
+            planar: PlanarAutorouteReconfiguratorInput {
+                ratlines: input.ratlines.clone(),
+            },
+        };
+        let reconfigurer = MultilayerReconfigurer::new(autorouter, input.ratlines, &options);
 
         Ok(Self {
             stepper: MultilayerAutorouteExecutionStepper::new(
                 autorouter,
-                ratlines,
-                planner.plan().clone(),
+                preconfiguration,
                 options,
             )?,
             reconfigurer,

src/autorouter/planar_reconfigurator.rs

@@ -15,6 +15,7 @@ use crate::{
         },
         planar_reconfigurer::{PermuteRatlines, PlanarReconfigurer},
         presorter::{PresortParams, PresortRatlines, SccIntersectionsAndLengthPresorter},
+        ratline::RatlineUid,
         Autorouter, AutorouterError, PlanarAutorouteOptions,
     },
     board::edit::BoardEdit,
@@ -23,6 +24,12 @@ use crate::{
     router::{navcord::Navcord, navmesh::Navmesh, thetastar::ThetastarStepper},
     stepper::{Abort, EstimateProgress, ReconfiguratorStatus, Reconfigure, Step},
 };
+
+#[derive(Clone, Debug)]
+pub struct PlanarAutorouteReconfiguratorInput {
+    pub ratlines: Vec<RatlineUid>,
+}
+
 pub type PlanarReconfiguratorStatus =
     ReconfiguratorStatus<PlanarAutorouteConfigurationResult, PlanarAutorouteContinueStatus>;
 
@@ -35,12 +42,12 @@ pub struct PlanarAutorouteReconfigurator {
 impl PlanarAutorouteReconfigurator {
     pub fn new(
         autorouter: &mut Autorouter<impl AccessMesadata>,
-        input_configuration: PlanarAutorouteConfiguration,
+        input: PlanarAutorouteReconfiguratorInput,
         options: PlanarAutorouteOptions,
     ) -> Result<Self, AutorouterError> {
         let presorter = SccIntersectionsAndLengthPresorter::new(
             autorouter,
-            &input_configuration.ratlines,
+            &input.ratlines,
             &PresortParams {
                 intersector_count_weight: 1.0,
                 length_weight: 0.001,
@@ -48,10 +55,10 @@ impl PlanarAutorouteReconfigurator {
             &options,
         );
         let preconfiguration = PlanarAutorouteConfiguration {
-            ratlines: presorter.presort_ratlines(autorouter, &input_configuration.ratlines),
+            ratlines: presorter.presort_ratlines(autorouter, &input.ratlines),
         };
         let reconfigurer =
-            PlanarReconfigurer::new(autorouter, input_configuration, presorter, &options);
+            PlanarReconfigurer::new(autorouter, preconfiguration.clone(), presorter, &options);
 
         Ok(Self {
             stepper: PlanarAutorouteExecutionStepper::new(autorouter, preconfiguration, options)?,