add a starting-point parameter

change behavior when optimizing path , we take care of starting point in some optimisation operations

Author: ErwanMAS

cli/src/main.rs

@@ -102,6 +102,9 @@ struct Opt {
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/Guides/Selectors>
     #[arg(long)]
     selector_filter: Option<String>,
+    /// Starting point , usefull only if try optimize path 
+    #[arg(long)]
+    starting_point: Option<String>,
 }
 
 fn main() -> io::Result<()> {
@@ -164,6 +167,24 @@ fn main() -> io::Result<()> {
                 }
             }
         }
+        {
+            if let Some(starting_point) = opt.starting_point {
+                for (i, dimension_starting_point) in starting_point
+                    .split(',')
+                    .map(|point| {
+                        if point.is_empty() {
+                            Default::default()
+                        } else {
+                            point.parse::<f64>().expect("could not parse coordinate")
+                        }
+                    })
+                    .take(2)
+                    .enumerate()
+                {
+		    settings.conversion.starting_point[i] =dimension_starting_point ;
+                }
+            }
+        }
 
         if let Some(line_numbers) = opt.line_numbers {
             settings.postprocess.line_numbers = line_numbers;

lib/src/converter/mod.rs

@@ -55,6 +55,7 @@ pub struct ConversionConfig {
     /// <https://developer.mozilla.org/en-US/docs/Web/CSS/Guides/Selectors>
     #[cfg_attr(feature = "serde", serde(default))]
     pub selector_filter: Option<String>,
+    pub starting_point: [f64; 2],
 }
 
 const fn zero_origin() -> [Option<f64>; 2] {
@@ -71,6 +72,7 @@ impl Default for ConversionConfig {
             extra_attribute_name: None,
             optimize_path_order: false,
             selector_filter: None,
+	    starting_point: [0.0 , 0.0 ] ,
         }
     }
 }
@@ -208,7 +210,7 @@ pub fn svg2program<'a, 'input: 'a>(
 
     if config.optimize_path_order {
         let strokes =
-            svg2strokes_optimized(doc, config, options, origin_transform, selector_filter);
+            svg2strokes_optimized(doc, config, options, origin_transform, selector_filter,config.starting_point);
         let turtle = &mut conversion_visitor.terrarium.turtle;
         for stroke in strokes {
             turtle.move_to(stroke.start_point());
@@ -260,6 +262,7 @@ pub fn svg2preview(
             options,
             Transform2D::identity(),
             selector_filter,
+	    config.starting_point,
         );
         let turtle = &mut conversion_visitor.terrarium.turtle;
         for stroke in strokes {
@@ -283,6 +286,7 @@ fn svg2strokes_optimized(
     options: ConversionOptions,
     origin_transform: Transform2D<f64>,
     selector_filter: Option<SelectorList>,
+    starting_point: [f64;2] 
 ) -> Vec<crate::turtle::Stroke> {
     let mut collect_visitor = ConversionVisitor {
         terrarium: Terrarium::new(StrokeCollectingTurtle::default()),
@@ -298,7 +302,7 @@ fn svg2strokes_optimized(
     collect_visitor.end();
     collect_visitor.terrarium.pop_transform();
     let strokes = collect_visitor.terrarium.turtle.into_strokes();
-    tsp::minimize_travel_time(strokes)
+    tsp::minimize_travel_time(strokes,starting_point)
 }
 
 fn node_name(node: &Node, attr_to_print: &Option<String>) -> String {

lib/src/tsp.rs

@@ -24,21 +24,23 @@ fn dist(a: Point<f64>, b: Point<f64>) -> f64 {
 ///
 /// <https://github.com/sameer/raster2svg>
 /// <https://www.mdpi.com/2076-3417/9/19/3985/pdf>
-pub fn minimize_travel_time(strokes: Vec<Stroke>) -> Vec<Stroke> {
+pub fn minimize_travel_time(strokes: Vec<Stroke>,starting_point: [f64; 2] ) -> Vec<Stroke> {
     if strokes.len() <= 1 {
         return strokes;
     }
-    let path = nearest_neighbor_greedy(strokes);
-    local_improvement_with_tabu_search(&path)
+    let the_starting_point : Point<f64> = Point::new(starting_point[0]*96.0/25.4,starting_point[1]*96.0/25.4);
+
+    let path = nearest_neighbor_greedy(strokes,the_starting_point);
+    local_improvement_with_tabu_search(&path,the_starting_point)
 }
 
 /// Greedy nearest-neighbour ordering with flips.
 ///
 /// Repeatedly chooses the [Stroke] or [Stroke::reversed] closest to the current point until none remain.
-fn nearest_neighbor_greedy(mut remaining: Vec<Stroke>) -> Vec<Stroke> {
+fn nearest_neighbor_greedy(mut remaining: Vec<Stroke>,the_starting_point: Point<f64> ) -> Vec<Stroke> {
     let mut result = Vec::with_capacity(remaining.len());
     // TODO: this assumption may be incorrect? depends on the GCode begin sequence, which this can't account for.
-    let mut pos = Point::zero();
+    let mut pos : Point<f64> = the_starting_point ;
 
     while !remaining.is_empty() {
         let mut best_idx = 0;
@@ -129,9 +131,9 @@ fn reverse_and_flip(strokes: &mut [Stroke]) {
 /// - TwoOpt and LinkSwap reversals also flip each stroke in the reversed range.
 /// - Relocate tries both the normal and reversed orientation of the moved stroke.
 /// - Distances are `f64` Euclidean rather than squared integers.
-fn local_improvement_with_tabu_search(path: &[Stroke]) -> Vec<Stroke> {
+fn local_improvement_with_tabu_search(path: &[Stroke],the_starting_point: Point<f64> ) -> Vec<Stroke> {
     let mut best = path.to_owned();
-    let mut best_sum: f64 = stroke_distances(&best).iter().sum();
+    let mut best_sum: f64 = stroke_distances(&best).iter().sum::<f64>() + dist(the_starting_point,best[0].start_point()) ;
 
     let mut current = best.clone();
     let mut current_distances = stroke_distances(&current);
@@ -279,8 +281,8 @@ fn local_improvement_with_tabu_search(path: &[Stroke]) -> Vec<Stroke> {
                         //   2 = [first_start, last_end]: both
                         let candidates = [
                             (0usize, dist(from, last_end)),
-                            (1usize, dist(first_start, to)),
-                            (2usize, dist(first_start, last_end)),
+                            (1usize, dist(first_start, to)      +dist(the_starting_point,to)-dist(the_starting_point,first_start)),
+                            (2usize, dist(first_start, last_end)+dist(the_starting_point,last_end)-dist(the_starting_point,first_start)),
                         ];
                         let (opt, best_new_dist) = candidates
                             .into_iter()
@@ -319,14 +321,8 @@ fn local_improvement_with_tabu_search(path: &[Stroke]) -> Vec<Stroke> {
             }
         }
 
-        let prev_sum = current_sum;
         current_distances = stroke_distances(&current);
-        current_sum = current_distances.iter().sum::<f64>();
-
-        debug_assert!(
-            prev_sum > current_sum - f64::EPSILON,
-            "operator={operator:?} prev={prev_sum} current={current_sum}"
-        );
+        current_sum = current_distances.iter().sum::<f64>() +dist(the_starting_point,current[0].start_point()) ;
 
         if current_sum < best_sum {
             best = current.clone();

web/src/state.rs

@@ -57,6 +57,10 @@ impl TryInto<Settings> for &FormState {
                 extra_attribute_name: None,
                 optimize_path_order: self.optimize_path_order,
                 selector_filter: None,
+		starting_point: [
+                    self.starting_point[0].clone().transpose()?,
+                    self.starting_point[1].clone().transpose()?,
+                ],
             },
             machine: MachineConfig {
                 supported_functionality: SupportedFunctionality {