cleanup

Author: rami3l

crates/monoxide-curves/src/convert/cube_to_quad.rs

@@ -4,21 +4,21 @@
 
 use kurbo::PathSeg;
 
-use crate::{CubicBezier, CubicSegment, QuadBezier, point::Point2D, quad::QuadBezierBuilder};
+use crate::{CubicBezier, CubicSegment, QuadBezier, point::Point2D};
 
 /// Convert a cubic bezier curve into a quadratic bezier curve, with `prec` as
 /// the maximum allowed distance between the original curve and its
 /// approximation.
 pub fn cube_to_quad(cube: CubicBezier, prec: f64) -> QuadBezier<Point2D> {
-    let mut quad = QuadBezierBuilder::new(cube.start);
+    let mut quad = QuadBezier::builder(cube.start);
 
     for seg in cube.segment_iter() {
         match seg.rest {
             CubicSegment::Line(end) => {
                 quad.line_to(end);
             }
             CubicSegment::Curve(..) => {
-                let PathSeg::Cubic(cubic) = seg.to_path_seg() else {
+                let PathSeg::Cubic(cubic) = PathSeg::from(seg) else {
                     unreachable!("CubicSegment::Curve always converts to PathSeg::Cubic");
                 };
                 for (_, _, q) in cubic.to_quads(prec) {

crates/monoxide-curves/src/cube.rs

@@ -55,15 +55,12 @@ pub struct CubicSegmentFull {
     pub rest: CubicSegment,
 }
 
-impl CubicSegmentFull {
-    /// Converts this segment into the equivalent [`kurbo::PathSeg`], so it
-    /// can be used with the various curve algorithms `kurbo` provides (e.g.
-    /// evaluation, arc length).
-    pub fn to_path_seg(&self) -> PathSeg {
-        match self.rest {
-            CubicSegment::Line(end) => PathSeg::Line(Line::new(self.start, end)),
+impl From<CubicSegmentFull> for PathSeg {
+    fn from(seg: CubicSegmentFull) -> Self {
+        match seg.rest {
+            CubicSegment::Line(end) => PathSeg::Line(Line::new(seg.start, end)),
             CubicSegment::Curve(c1, c2, end) => {
-                PathSeg::Cubic(CubicBez::new(self.start, c1, c2, end))
+                PathSeg::Cubic(CubicBez::new(seg.start, c1, c2, end))
             }
         }
     }
@@ -116,10 +113,7 @@ impl CubicBezier {
     /// Evaluates the point at parameter `t` (in `[0, 1]`) on the given
     /// segment.
     pub fn point_at(&self, segment: usize, t: f64) -> Point2D {
-        self.segment(segment)
-            .expect("segment index out of bounds")
-            .to_path_seg()
-            .eval(t)
+        PathSeg::from(self.segment(segment).expect("segment index out of bounds")).eval(t)
     }
 
     pub fn reversed(&self) -> Self {

crates/monoxide-curves/src/stroke/widths.rs

@@ -1,7 +1,7 @@
 use std::{cell::LazyCell, collections::BTreeMap};
 
 use itertools::Itertools;
-use kurbo::ParamCurveArclen;
+use kurbo::{ParamCurveArclen, PathSeg};
 
 use crate::{
     CubicBezier,
@@ -70,23 +70,16 @@ fn calc_curve_lengths(
 ) -> Result<Vec<f64>> {
     let max_error = 0.001;
     let mut lengths = Vec::with_capacity(curve.len());
+    let arclen = |seg| PathSeg::from(cubic.segment(seg).unwrap()).arclen(max_error);
     for &[from, to] in indices.array_windows() {
-        let mut acc = 0.0;
-        for seg in from..to {
-            let seg_length = cubic.segment(seg).unwrap().to_path_seg().arclen(max_error);
-            acc += seg_length;
-        }
-        lengths.push(acc);
+        lengths.push((from..to).map(arclen).sum());
     }
     // last segment
-    {
-        let mut acc = 0.0;
-        for seg in indices.last().copied().unwrap_or(0)..curve.len() {
-            let seg_length = cubic.segment(seg).unwrap().to_path_seg().arclen(max_error);
-            acc += seg_length;
-        }
-        lengths.push(acc);
-    }
+    lengths.push(
+        (indices.last().copied().unwrap_or(0)..curve.len())
+            .map(arclen)
+            .sum(),
+    );
     if lengths.len() != curve.len() {
         return Err(Error::internal("length calculation mismatch"));
     }