Refactor offset functions and examples: rename bench_offset_multiple to bench_offset_polyline_to_polyline, update README with new example, and add offset_arcline example. Clean up unused code and improve documentation clarity.

Author: radevgit

benches/bench_offset_multiple.rs

@@ -2,7 +2,7 @@
 // 
 
 use geom::prelude::*;
-use offroad::{offset::pline_01, offset_connect_raw, offset_polyline_raw, offset_prune_invalid, offset_raw::OffsetRaw, offset_split_arcs, poly_to_raws};
+use offroad::{offset::{offset_polyline_to_polyline, pline_01, OffsetCfg}};
 
 
 
@@ -11,49 +11,37 @@ fn main() {
     divan::main();
 }
 
-fn offset_multiple_bench(poly_raws: &Vec<Vec<OffsetRaw>>, off: f64) {
-    let offset_raw = offset_polyline_raw(&poly_raws, off);
-
-    let offset_connect = offset_connect_raw(&offset_raw, off);
-
-    let mut offset_split = offset_split_arcs(&offset_raw, &offset_connect);
-
-    let _offset_final = offset_prune_invalid(&poly_raws, &mut offset_split, off);
-}
 
 #[divan::bench(args = [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0], 
     max_time = 1.0, // seconds
     sample_size = 200, // 64 × 84 = 5376
     )]
-fn bench_offset_multiple_complex_polyline(off: f64) {
-    let mut plines: Vec<Vec<crate::PVertex>> = Vec::new();
+fn bench_offset_polyline_to_polyline(off: f64) {
+    let mut cfg = OffsetCfg::default();
 
     let mut p = pline_01()[0].clone();
     p = polyline_translate(&p, point(180.0, -60.0));
     p = polyline_scale(&p, 2.5);
-    plines.push(p.clone());
-    let poly_raws = poly_to_raws(&plines);
-    offset_multiple_bench(&poly_raws, off);
+    offset_polyline_to_polyline(&p, 16.0, &mut cfg);
 
     let p2 = polyline_reverse(&p);
-    let poly_raws = poly_to_raws(&vec![p2]);
-    offset_multiple_bench(&poly_raws, off);
+    offset_polyline_to_polyline(&p2, 16.0, &mut cfg);
 }
 
 /*
 > cargo bench
 
 Timer precision: 20 ns
-offset_multiple                            fastest       │ slowest       │ median        │ mean          │ samples │ iters
-╰─ bench_offset_multiple_complex_polyline                │               │               │               │         │
-   ├─ 1                                    222.4 µs      │ 233.6 µs      │ 223.6 µs      │ 224.5 µs      │ 23      │ 4600
-   ├─ 2                                    222.2 µs      │ 229.8 µs      │ 222.9 µs      │ 223.3 µs      │ 23      │ 4600
-   ├─ 4                                    222 µs        │ 233.6 µs      │ 222.6 µs      │ 223.4 µs      │ 23      │ 4600
-   ├─ 8                                    222.9 µs      │ 315.2 µs      │ 225.7 µs      │ 247.6 µs      │ 21      │ 4200
-   ├─ 16                                   352.1 µs      │ 381.9 µs      │ 368.7 µs      │ 369.8 µs      │ 14      │ 2800
-   ├─ 32                                   393.8 µs      │ 410.4 µs      │ 403.3 µs      │ 402.3 µs      │ 13      │ 2600
-   ├─ 64                                   566.3 µs      │ 634.4 µs      │ 586 µs        │ 591.9 µs      │ 9       │ 1800
-   ├─ 128                                  542.7 µs      │ 582.6 µs      │ 571 µs        │ 568 µs        │ 9       │ 1800
-   ╰─ 256                                  650.9 µs      │ 696.5 µs      │ 673.3 µs      │ 670.1 µs      │ 8       │ 1600
+bench_offset_multiple                 fastest       │ slowest       │ median        │ mean          │ samples │ iters
+╰─ bench_offset_polyline_to_polyline                │               │               │               │         │
+   ├─ 1                               373.1 µs      │ 446.2 µs      │ 375.3 µs      │ 388.5 µs      │ 13      │ 2600
+   ├─ 2                               480 µs        │ 565.5 µs      │ 534.3 µs      │ 529 µs        │ 10      │ 2000
+   ├─ 4                               545.9 µs      │ 565 µs        │ 562.8 µs      │ 559.9 µs      │ 9       │ 1800
+   ├─ 8                               566.8 µs      │ 628.3 µs      │ 581.6 µs      │ 584.4 µs      │ 9       │ 1800
+   ├─ 16                              674.7 µs      │ 784.2 µs      │ 715.3 µs      │ 729.3 µs      │ 7       │ 1400
+   ├─ 32                              642.5 µs      │ 917.4 µs      │ 755.8 µs      │ 775.4 µs      │ 7       │ 1400
+   ├─ 64                              568.9 µs      │ 623.1 µs      │ 589.6 µs      │ 595 µs        │ 9       │ 1800
+   ├─ 128                             566.6 µs      │ 585.9 µs      │ 568.6 µs      │ 571.5 µs      │ 9       │ 1800
+   ╰─ 256                             565 µs        │ 585.2 µs      │ 566.5 µs      │ 570.5 µs      │ 9       │ 1800
 
 */

examples/README.md

@@ -5,5 +5,11 @@
 ```
 cargo run --example offset_polyline
 ```
-
 ![](https://raw.githubusercontent.com/radevgit/offroad/refs/heads/main/examples/img/offset_polyline.svg "offset_polyline")
+```
+cargo run --example offset_arcline
+```
+
+
+
+

examples/offset_arcline.rs

@@ -0,0 +1,40 @@
+use geom::prelude::*;
+use offroad::{offset::offset_arcline_to_arcline, prelude::OffsetCfg};
+
+fn main() {
+    // Configuration for offsetting
+    let mut cfg = OffsetCfg::default();
+    let mut svg = SVG::new(300.0, 300.0, "/tmp/arcline.svg");
+    cfg.svg = Some(&mut svg);
+    // Show original arcline in SVG output
+    cfg.debug_orig = true;
+    // Show final offset arclines in SVG output
+    cfg.debug_final = true;
+
+    let arc0 = arc_circle_parametrization(point(0.0, 0.0), point(100.0, 100.0), 0.0);
+    let arc1 = arc_circle_parametrization(point(100.0, 100.0), point(200.0, 0.0), 0.5);
+    let arc2 = arc_circle_parametrization(point(200.0, 0.0), point(0.0, 0.0), 1.3);
+    let arcs_orig = vec![arc0, arc1, arc2];
+
+    // Translate to fit in the SVG viewport
+    //let poly = polyline_translate(&arcs_orig, point(40.0, 100.0));
+
+    // Internal offsetting
+    //let poly = polyline_reverse(&poly);
+    let offset_arclines = offset_arcline_to_arcline(&arcs_orig, 15.0, &mut cfg);
+
+    println!("Input arcline has {} vertices", arcs_orig.len());
+    println!("Output has {} arclines", offset_arclines.len());
+    for (i, arcline) in offset_arclines.iter().enumerate() {
+        println!("Arcline {}: {} vertices", i, arcline.len());
+    }
+
+    if let Some(svg) = cfg.svg.as_deref_mut() {
+        // Write svg to file
+        svg.write_stroke_width(0.1);
+    }
+    assert!(
+        offset_arclines.len() == 1,
+        "Wrong number of offset arclines generated"
+    );
+}

examples/offset_pline1.rs

@@ -1,5 +1,5 @@
 use geom::prelude::*;
-use offroad::prelude::{OffsetCfg, pline_01, offset_polyline_to_polyline};
+use offroad::prelude::{OffsetCfg, offset_polyline_to_polyline, pline_01};
 
 fn main() {
     let mut cfg = OffsetCfg::default();
@@ -22,7 +22,7 @@ fn main() {
     // Internal offsetting
     let poly = polyline_reverse(&poly);
     let _offset_polylines = offset_polyline_to_polyline(&poly, 15.5600615, &mut cfg);
-    
+
     if let Some(svg) = cfg.svg.as_deref_mut() {
         // Write svg to file
         svg.write_stroke_width(0.1);

examples/offset_polyline.rs

@@ -4,7 +4,7 @@ use offroad::prelude::{OffsetCfg, offset_polyline_to_polyline};
 fn main() {
     // Configuration for offsetting
     let mut cfg = OffsetCfg::default();
-    let mut svg = SVG::new(300.0, 300.0, "/tmp/out2.svg");
+    let mut svg = SVG::new(300.0, 300.0, "/tmp/polyline.svg");
     cfg.svg = Some(&mut svg);
     // Show original polyline in SVG output
     cfg.debug_orig = true;
@@ -21,17 +21,20 @@ fn main() {
 
     // Internal offsetting
     let poly = polyline_reverse(&poly);
-    let _offset_polylines = offset_polyline_to_polyline(&poly, 15.0, &mut cfg);
-    
+    let offset_polylines = offset_polyline_to_polyline(&poly, 15.0, &mut cfg);
+
     println!("Input polyline has {} vertices", poly.len());
-    println!("Output has {} polylines", _offset_polylines.len());
-    for (i, polyline) in _offset_polylines.iter().enumerate() {
+    println!("Output has {} polylines", offset_polylines.len());
+    for (i, polyline) in offset_polylines.iter().enumerate() {
         println!("Polyline {}: {} vertices", i, polyline.len());
     }
-    
+
     if let Some(svg) = cfg.svg.as_deref_mut() {
         // Write svg to file
         svg.write_stroke_width(0.1);
     }
-    assert!(_offset_polylines.len() == 2, "Wrong number of offset polylines generated");
+    assert!(
+        offset_polylines.len() == 2,
+        "Wrong number of offset polylines generated"
+    );
 }

src/lib.rs

@@ -9,32 +9,37 @@
 
 // Offsetting algorithm components
 pub mod offset;
-// 
+#[doc(hidden)]
 pub mod offset_raw;
+#[doc(hidden)]
 // raw offsetting components (lines, arcs)
 mod offset_polyline_raw;
+#[doc(hidden)]
 // connect raw offsets with arcs
 mod offset_connect_raw;
+#[doc(hidden)]
 // split raw offsets into segments in intersection points
 mod offset_split_arcs;
+#[doc(hidden)]
 // prune invalid offsets that are close to original polylines
 mod offset_prune_invalid;
+#[doc(hidden)]
 // resulting soup of arcs is ordered and reconnected
 mod offset_reconnect_arcs;
 
 
 // Re-export main offsetting functions
 // For public API
 pub mod prelude {
-    pub use crate::offset::{offset_polyline_to_polyline, offset_arcline_to_arcline, offset_polyline_multiple, OffsetCfg};
+    pub use crate::offset::{offset_polyline_to_polyline, offset_arcline_to_arcline, OffsetCfg};
     pub use crate::offset::{pline_01, pline_02, pline_03, pline_04};
 }
 // For internal use
-pub use crate::offset_polyline_raw::{offset_polyline_raw, poly_to_raws};
-pub use crate::offset_connect_raw::offset_connect_raw;
-pub use crate::offset_split_arcs::offset_split_arcs;
-pub use crate::offset_prune_invalid::offset_prune_invalid;
-pub use crate::offset_reconnect_arcs::{offset_reconnect_arcs, find_connected_components, find_middle_points, remove_bridge_arcs};
+// pub use crate::offset_polyline_raw::{offset_polyline_raw, poly_to_raws};
+// pub use crate::offset_connect_raw::offset_connect_raw;
+// pub use crate::offset_split_arcs::offset_split_arcs;
+// pub use crate::offset_prune_invalid::offset_prune_invalid;
+// pub use crate::offset_reconnect_arcs::{offset_reconnect_arcs, find_connected_components, find_middle_points, remove_bridge_arcs};
 
 #[cfg(test)]
 mod tests;