Refactor offset functions: update polyline translation logic and adjust offset reconnecting methods for improved clarity and functionality.

Author: radevgit

examples/offset_pline1.rs

@@ -11,7 +11,8 @@ fn main() {
 
     let poly_orig = pline_01()[0].clone();
     // Translate to fit in the SVG viewport
-    let poly = polyline_translate(&poly_orig, point(100.0, -50.0));
+    let p1 = polyline_reverse(&poly_orig);
+    let poly = polyline_translate(&p1, point(100.0, -50.0));
 
     // Offset the polyline
     // let offset_polylines = offset_polyline_to_polyline(&poly, 15.0, &mut cfg);
@@ -21,7 +22,8 @@ fn main() {
 
     // Internal offsetting
     let poly = polyline_reverse(&poly);
-    let _offset_polylines = offset_polyline_to_polyline(&poly, 15.5600615, &mut cfg);
+    //let _offset_polylines = offset_polyline_to_polyline(&poly, 15.5600615, &mut cfg);
+    let _offset_polylines = offset_polyline_to_polyline(&poly, 16.0, &mut cfg);
 
     if let Some(svg) = cfg.svg.as_deref_mut() {
         // Write svg to file

src/offset.rs

@@ -91,12 +91,10 @@ impl<'a> Default for OffsetCfg<'a> {
 ///
 /// The offsetting process involves several stages:
 /// 1. Convert input polyline to raw offset segments (lines and arcs)
-/// 2. Compute offset for each segment
-/// 3. Connect adjacent offset segments with transition arcs
-/// 4. Split overlapping segments at intersection points
-/// 5. Prune invalid segments that are too close to the original
-/// 6. Reconnect valid segments into continuous paths
-/// 7. Convert final arcs back to polylines with pvertex segments
+/// 2. Connect adjacent offset segments with transition arcs
+/// 3. Split overlapping segments at intersection points
+/// 4. Prune invalid segments that are too close to the original
+/// 5. Reconnect valid segments into continuous paths
 ///
 /// # Notes
 ///
@@ -114,8 +112,14 @@ pub fn offset_polyline_to_polyline(
     }
     let offset_arcs = offset_polyline_to_polyline_impl(poly, off, cfg);
 
+    // remove bridges
+    let offset_arcs = remove_bridge_arcs(&offset_arcs);
+
+    // Slightly adjust arc endpoints
+    let offset_arcs = find_middle_points(&offset_arcs);
+
     // Always reconnect arcs
-    let reconnect_arcs = offset_reconnect_arcs(&mut offset_arcs.clone());
+    let reconnect_arcs = offset_reconnect_arcs(&offset_arcs);
     // println!(
     //     "DEBUG: offset_reconnect_arcs returned {} components",
     //     reconnect_arcs.len()
@@ -181,12 +185,10 @@ pub fn offset_polyline_to_polyline(
 /// The offsetting process follows the same stages as polyline offsetting but preserves
 /// arc geometry throughout:
 /// 1. Convert input arcline to raw offset segments (lines and arcs)
-/// 2. Compute precise offset for each segment maintaining arc properties
-/// 3. Connect adjacent offset segments with transition arcs
-/// 4. Split overlapping segments at intersection points
-/// 5. Prune invalid segments that are too close to the original
-/// 6. Reconnect valid segments into continuous arc-preserving paths
-/// 7. Return final result as arclines (no conversion to line segments)
+/// 2. Connect adjacent offset segments with transition arcs
+/// 3. Split overlapping segments at intersection points
+/// 4. Prune invalid segments that are too close to the original
+/// 5. Reconnect valid segments into continuous arc-paths
 ///
 pub fn offset_arcline_to_arcline(arcs: &Arcline, off: f64, cfg: &mut OffsetCfg) -> Vec<Arcline> {
     if let Some(svg) = cfg.svg.as_deref_mut()
@@ -196,15 +198,15 @@ pub fn offset_arcline_to_arcline(arcs: &Arcline, off: f64, cfg: &mut OffsetCfg)
     }
     let offset_arcs = offset_arcline_to_arcline_impl(arcs, off, cfg);
 
-    // Slightly adjust arc endpoints
-    let mut mod_arcs = find_middle_points(&mut offset_arcs.clone());
-
     // remove bridges
-    remove_bridge_arcs(&mut mod_arcs);
+    let offset_arcs = remove_bridge_arcs(&offset_arcs);
+
+    // Slightly adjust arc endpoints
+    let offset_arcs = find_middle_points(&offset_arcs);
 
     let mut final_arcs = Vec::new();
     if cfg.reconnect {
-        final_arcs = offset_reconnect_arcs(&mut mod_arcs);
+        final_arcs = offset_reconnect_arcs(&offset_arcs);
         println!(
             "offset_reconnect_arcs returned {} components",
             final_arcs.len()
@@ -213,7 +215,7 @@ pub fn offset_arcline_to_arcline(arcs: &Arcline, off: f64, cfg: &mut OffsetCfg)
             println!("  Component {}: {} arcs", i, component.len());
         }
     } else {
-        final_arcs.push(mod_arcs);
+        final_arcs.push(offset_arcs);
     }
 
     if let Some(svg) = cfg.svg.as_deref_mut() {

src/offset_reconnect_arcs.rs

@@ -9,7 +9,7 @@ const EPS_CONNECT: f64 = 1e-8;
 
 #[doc(hidden)]
 /// Reconnects offset segments by merging adjacent arcs vertices.
-pub fn offset_reconnect_arcs(arcs: &mut Vec<Arc>) -> Vec<Vec<Arc>> {
+pub fn offset_reconnect_arcs(arcs: &Arcline) -> Vec<Arcline> {
     let mut result = Vec::new();
 
     let len = arcs.len();
@@ -60,8 +60,6 @@ pub fn offset_reconnect_arcs(arcs: &mut Vec<Arc>) -> Vec<Vec<Arc>> {
         }
     }
 
-    merge_points(&mut arc_map, &merge);
-
     // println!("DEBUG: Merge operations: {:?}", merge);
     // println!("DEBUG: Arc map after merge: {:?}", arc_map);
 
@@ -141,7 +139,7 @@ pub fn find_middle_points(arcs: &Arcline) -> Arcline {
             }
         }
     }
-    res.clone()
+    res
 }
 
 
@@ -297,12 +295,13 @@ fn should_use_forward_direction(from_vertex: usize, to_vertex: usize, len: usize
 /// Removes duplicate arcs that overlap as 2D graphics elements.
 ///
 /// DO NOT CHANGE THIS FUNCTION - it's a critical component for maintaining geometric consistency.
-pub fn remove_bridge_arcs(arcs: &mut Vec<Arc>) {
+pub fn remove_bridge_arcs(arcs: &Arcline) -> Arcline {
+    let mut result = arcs.clone();
     let mut to_remove = Vec::new();
-    for i in 0..arcs.len() {
-        for j in (i + 1)..arcs.len() {
-            let arc0 = &arcs[i];
-            let arc1 = &arcs[j];
+    for i in 0..result.len() {
+        for j in (i + 1)..result.len() {
+            let arc0 = &result[i];
+            let arc1 = &result[j];
             if arc0.is_line() && arc1.is_line() {
                 if (arc0.a.close_enough(arc1.a, EPS_CONNECT)
                     && arc0.b.close_enough(arc1.b, EPS_CONNECT))
@@ -330,8 +329,9 @@ pub fn remove_bridge_arcs(arcs: &mut Vec<Arc>) {
     to_remove.sort_unstable();
     to_remove.dedup();
     for i in to_remove.iter().rev() {
-        arcs.remove(*i);
+        result.remove(*i);
     }
+    result
 }
 
 #[doc(hidden)]