New version of Togo

Author: radevgit

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## [0.2.0] - 2025-10-21
+- update with the new Togo version
+
 ## [0.1.0] - 2025-09-24
 - Implemented graph-based cycle detection algorithm
 - Added arc reconnection system for offset segments

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "offroad"
-version = "0.1.2"
+version = "0.2.0"
 description = "2D offsetting for arc polylines/polygons."
 rust-version = "1.88"
 edition = "2024"
@@ -15,8 +15,8 @@ readme = "README.md"
 
 
 [dependencies]
-togo = "0.4.1"
-robust = "1.2.0"
+togo = "0.5"
+robust = "1.2"
 
 [lib]
 crate-type = ["lib"]

Cargo.toml

@@ -9,7 +9,7 @@ To use the Offroad library in your project, add the following to your `Cargo.tom
 
 ```toml
 [dependencies]
-offroad = "0.1.2"
+offroad = "0.2"
 ```
 
 ## 2D offsetting for arc polylines/polygons

README.md

@@ -11,9 +11,9 @@ fn main() {
     // Show final offset arclines in SVG output
     cfg.svg_final = true;
 
-    let arc0 = arc_circle_parametrization(point(40.0, 100.0), point(140.0, 200.0), 0.0);
-    let arc1 = arc_circle_parametrization(point(140.0, 200.0), point(240.0, 100.0), 0.5);
-    let arc2 = arc_circle_parametrization(point(240.0, 100.0), point(40.0, 100.0), 1.3);
+    let arc0 = arc_from_bulge(point(40.0, 100.0), point(140.0, 200.0), 0.0);
+    let arc1 = arc_from_bulge(point(140.0, 200.0), point(240.0, 100.0), 0.5);
+    let arc2 = arc_from_bulge(point(240.0, 100.0), point(40.0, 100.0), 1.3);
     let arcs_orig = vec![arc0, arc1, arc2];
 
     // Translate to fit in the SVG viewport

examples/offset_arcline.rs

@@ -447,16 +447,15 @@ pub fn find_non_intersecting_cycles(arcs: &[Arc]) -> Vec<Vec<Arc>> {
 
     #[test]
     fn test_double_edges() {
-        // Two arcs between the same points (like two semicircles of a circle)
-        // Use arc_circle_parametrization to create proper arcs
+        // Use arc_from_bulge to create proper arcs
         let p1 = point(0.0, 0.0);
         let p2 = point(2.0, 0.0);
         let bulge1 = 1.0;  // Semicircle bulge
         let bulge2 = 1.0; // Another semicircle bulge (same direction, forms full circle)
 
         let arcs = vec![
-            arc_circle_parametrization(p1, p2, bulge1),
-            arc_circle_parametrization(p2, p1, bulge2),
+            arc_from_bulge(p1, p2, bulge1),
+            arc_from_bulge(p2, p1, bulge2),
         ];
 
         let result = find_non_intersecting_cycles(&arcs);
@@ -494,7 +493,7 @@ pub fn find_non_intersecting_cycles(arcs: &[Arc]) -> Vec<Vec<Arc>> {
         // Combine line segments and curved arcs in a cycle
         let arcs = vec![
             arcseg(point(0.0, 0.0), point(1.0, 0.0)),  // Line segment
-            arc_circle_parametrization(point(1.0, 0.0), point(0.0, 1.0), 0.5), // Curved arc
+            arc_from_bulge(point(1.0, 0.0), point(0.0, 1.0), 0.5), // Curved arc
             arcseg(point(0.0, 1.0), point(0.0, 0.0)),  // Line segment
         ];
 

src/graph/find_cycles.rs

@@ -262,7 +262,7 @@ pub fn arcs_to_polylines_single(arcs: &Vec<Arc>) -> Polyline {
             if arc.is_seg() {
                 (arc.a, arc.b, 0.0)
             } else {
-                let bulge = arc_bulge_from_points(arc.a, arc.b, arc.c, arc.r);
+                let bulge = bulge_from_arc(arc.a, arc.b, arc.c, arc.r);
                 (arc.a, arc.b, bulge)
             }
         } else {
@@ -277,7 +277,7 @@ pub fn arcs_to_polylines_single(arcs: &Vec<Arc>) -> Polyline {
                 if arc.is_seg() {
                     (arc.a, arc.b, 0.0)
                 } else {
-                    let bulge = arc_bulge_from_points(arc.a, arc.b, arc.c, arc.r);
+                    let bulge = bulge_from_arc(arc.a, arc.b, arc.c, arc.r);
                     (arc.a, arc.b, bulge)
                 }
             } else {
@@ -286,7 +286,7 @@ pub fn arcs_to_polylines_single(arcs: &Vec<Arc>) -> Polyline {
                     (arc.b, arc.a, 0.0)
                 } else {
                     // For reversed arc, we need to negate the bulge
-                    let forward_bulge = arc_bulge_from_points(arc.a, arc.b, arc.c, arc.r);
+                    let forward_bulge = bulge_from_arc(arc.a, arc.b, arc.c, arc.r);
                     (arc.b, arc.a, -forward_bulge)
                 }
             }
@@ -310,7 +310,7 @@ mod test_arcs_to_polylines {
             // First arc: from (0,0) to (1,0) - line segment
             arcseg(point(0.0, 0.0), point(1.0, 0.0)),
             // Second arc: from (1,0) to (0,1) - quarter circle
-            arc_circle_parametrization(point(1.0, 0.0), point(0.0, 1.0), 1.0),
+            arc_from_bulge(point(1.0, 0.0), point(0.0, 1.0), 1.0),
             // Third arc: from (0,1) to (0,0) - line segment (completing the loop)
             arcseg(point(0.0, 1.0), point(0.0, 0.0)),
         ];
@@ -342,7 +342,7 @@ mod test_arcs_to_polylines {
             arcseg(point(0.0, 0.0), point(1.0, 0.0)),
             // Second arc: reversed orientation (from (0,1) to (1,0) instead of (1,0) to (0,1))
             // This should be detected and corrected
-            arc_circle_parametrization(point(0.0, 1.0), point(1.0, 0.0), 1.0),
+            arc_from_bulge(point(0.0, 1.0), point(1.0, 0.0), 1.0),
         ];
 
         // Convert to polyline
@@ -2035,12 +2035,12 @@ fn polyline_to_arcs_single(pline: &Polyline) -> Vec<Arc> {
     let mut arcs = Vec::with_capacity(pline.len() + 1);
     let last = pline.len() - 1;
     for i in 0..last {
-        let arc = arc_circle_parametrization(pline[i].p, pline[i + 1].p, pline[i].b);
+        let arc = arc_from_bulge(pline[i].p, pline[i + 1].p, pline[i].b);
         arcs.push(arc);
     }
     // last segment
     let arc =
-        arc_circle_parametrization(pline.last().unwrap().p, pline[0].p, pline.last().unwrap().b);
+        arc_from_bulge(pline.last().unwrap().p, pline[0].p, pline.last().unwrap().b);
     arcs.push(arc);
     arcs
 }

src/offset.rs

@@ -396,8 +396,8 @@ mod test_offset_connect_raw_single {
     #[test]
     fn test_arc_segments() {
         // Test with actual arc segments (not just lines) using valid parametrization
-        let arc1 = arc_circle_parametrization(point(0.0, 0.0), point(2.0, 0.0), 0.3);
-        let arc2 = arc_circle_parametrization(point(3.0, 0.0), point(5.0, 0.0), -0.3);
+        let arc1 = arc_from_bulge(point(0.0, 0.0), point(2.0, 0.0), 0.3);
+        let arc2 = arc_from_bulge(point(3.0, 0.0), point(5.0, 0.0), -0.3);
 
         // Verify arcs are valid
         assert!(arc1.is_valid(1e-10));
@@ -546,8 +546,8 @@ mod test_offset_connect_raw_single {
     #[test] 
     fn test_realistic_curved_segments_with_gaps() {
         // Test with actual arc segments using valid parametrization
-        let arc1 = arc_circle_parametrization(point(0.0, 0.0), point(2.0, 2.0), 0.5);
-        let arc2 = arc_circle_parametrization(point(4.0, 2.0), point(6.0, 0.0), -0.5);
+        let arc1 = arc_from_bulge(point(0.0, 0.0), point(2.0, 2.0), 0.5);
+        let arc2 = arc_from_bulge(point(4.0, 2.0), point(6.0, 0.0), -0.5);
 
         // Verify arcs are geometrically valid
         assert!(arc1.is_valid(1e-10));
@@ -601,8 +601,8 @@ mod test_offset_connect_raw_single {
     #[test]
     fn test_all_g_value_combinations() {
         // Test various g values with curved arcs (not line segments)
-        let arc1 = arc_circle_parametrization(point(0.0, 0.0), point(1.0, 0.0), 0.5);
-        let arc2 = arc_circle_parametrization(point(2.0, 0.0), point(3.0, 0.0), 0.5);
+        let arc1 = arc_from_bulge(point(0.0, 0.0), point(1.0, 0.0), 0.5);
+        let arc2 = arc_from_bulge(point(2.0, 0.0), point(3.0, 0.0), 0.5);
 
         // Verify arcs are geometrically valid
         assert!(arc1.is_valid(1e-10));

src/offset_connect_raw.rs

@@ -95,7 +95,7 @@ pub fn poly_to_raws_single(pline: &Polyline) -> Vec<OffsetRaw> {
     //let last = pline.len() - 1;
     for i in 0..pline.len() - 1 {
         let bulge = pline[i].b;
-        let seg = arc_circle_parametrization(pline[i].p, pline[i + 1].p, bulge);
+        let seg = arc_from_bulge(pline[i].p, pline[i + 1].p, bulge);
         let check = seg.is_valid(EPS_COLLAPSED);
         if !check {
             continue;
@@ -110,7 +110,7 @@ pub fn poly_to_raws_single(pline: &Polyline) -> Vec<OffsetRaw> {
     }
     // last segment
     let bulge = pline.last().unwrap().b;
-    let seg = arc_circle_parametrization(pline.last().unwrap().p, pline[0].p, bulge);
+    let seg = arc_from_bulge(pline.last().unwrap().p, pline[0].p, bulge);
     let check = seg.is_valid(EPS_COLLAPSED);
     if check {
         let orig = if bulge < ZERO { seg.a } else { seg.b };
@@ -143,7 +143,7 @@ pub fn arcs_to_raws_single(arcs: &Arcline) -> Vec<OffsetRaw> {
         if !check {
             continue;
         }
-        let bulge = arc_bulge_from_points(seg.a, seg.b, seg.c, seg.r);
+        let bulge = bulge_from_arc(seg.a, seg.b, seg.c, seg.r);
         let orig = if bulge < ZERO { seg.a } else { seg.b };
         let off = OffsetRaw {
             arc: seg,
@@ -156,7 +156,7 @@ pub fn arcs_to_raws_single(arcs: &Arcline) -> Vec<OffsetRaw> {
     let seg = arcs.last().unwrap();
     let check = seg.is_valid(EPS_COLLAPSED);
     if check {
-        let bulge = arc_bulge_from_points(seg.a, seg.b, seg.c, seg.r);
+        let bulge = bulge_from_arc(seg.a, seg.b, seg.c, seg.r);
         let orig = if bulge < ZERO { seg.a } else { seg.b };
         let off = OffsetRaw {
             arc: *seg,
@@ -199,15 +199,15 @@ mod test_offset_polyline_raw {
 
     #[test]
     fn test_new() {
-        let arc = arc_circle_parametrization(point(1.0, 2.0), point(3.0, 4.0), 3.3);
+        let arc = arc_from_bulge(point(1.0, 2.0), point(3.0, 4.0), 3.3);
         let o0 = offsetraw(arc, point(5.0, 6.0), 3.3);
         let o1 = offsetraw(arc, point(5.0, 6.0), 3.3);
         assert_eq!(o0, o1);
     }
 
     #[test]
     fn test_display_01() {
-        let arc = arc_circle_parametrization(point(0.0, 0.0), point(2.0, 2.0), 1.0);
+        let arc = arc_from_bulge(point(0.0, 0.0), point(2.0, 2.0), 1.0);
         let o0 = offsetraw(arc, point(5.0, 6.0), 3.3);
         assert_eq!(
             "[[[0.00000000000000000000, 0.00000000000000000000], [2.00000000000000000000, 2.00000000000000000000], [1.00000000000000000000, 1.00000000000000000000], 1.41421356237309514547], [5.00000000000000000000, 6.00000000000000000000], 3.3]",
@@ -217,7 +217,7 @@ mod test_offset_polyline_raw {
 
     #[test]
     fn test_display_02() {
-        let arc = arc_circle_parametrization(point(1.0, 2.0), point(3.0, 4.0), 3.3);
+        let arc = arc_from_bulge(point(1.0, 2.0), point(3.0, 4.0), 3.3);
         let o0 = offsetraw(arc, point(5.0, 6.0), 3.3);
         assert_eq!(
             "[[[1.00000000000000000000, 2.00000000000000000000], [3.00000000000000000000, 4.00000000000000000000], [3.49848484848484808651, 1.50151515151515169144], 2.54772716009334887488], [5.00000000000000000000, 6.00000000000000000000], 3.3]",
@@ -297,8 +297,8 @@ mod test_offset_polyline_raw {
 
     #[test]
     #[ignore = "svg output"]
-    fn test_arc_circle_parametrization_plinearc_svg() {
-        let arc0 = arc_circle_parametrization(
+    fn test_arc_from_bulge_plinearc_svg() {
+        let arc0 = arc_from_bulge(
             point(-52.0, 250.0),
             point(-23.429621235520095, 204.88318696736243),
             -0.6068148963145962,