Remove CubicOffset (#489)

This was deprecated in #427

This PR is easily the most dubious of the three (#488, #487), because
the functionality:
- is expected to be publicly exposed ("as we probably want to iterate on
the exact interface")
- Doesn't have a neat replacement.

This will likely need Raph's sign-off

---------

Co-authored-by: Joe Neeman <joeneeman@gmail.com>

Author: DJMcNab

CHANGELOG.md

@@ -36,6 +36,10 @@ It was increased to support floating point math in const functions.
 - Breaking change: The previously deprecated `BezPath::flatten`, `Ellipse::[with_]x_rotation`, `{Rect, Size}::is_empty`, `Shape::[in]to_bez_path`,
   and `TranslateScale::as_tuple` have been removed.([#487][] by [@DJMcNab][])
 
+### Removed
+
+- Breaking change: The `offset` module amd the deprecated `CubicOffset` have been removed. ([#489][] by [@DJMcNab][])
+
 ## [0.11.3][] (2025-07-21)
 
 This release has an [MSRV][] of 1.65.
@@ -193,6 +197,7 @@ Note: A changelog was not kept for or before this release
 [#486]: https://github.com/linebender/kurbo/pull/486
 [#487]: https://github.com/linebender/kurbo/pull/487
 [#488]: https://github.com/linebender/kurbo/pull/488
+[#489]: https://github.com/linebender/kurbo/pull/489
 [#490]: https://github.com/linebender/kurbo/pull/490
 
 [Unreleased]: https://github.com/linebender/kurbo/compare/v0.11.3...HEAD

kurbo/examples/offset.rs

@@ -388,41 +388,6 @@ impl CubicBez {
             .collect()
     }
 
-    /// Preprocess a cubic Bézier to ease numerical robustness.
-    ///
-    /// If the cubic Bézier segment has zero or near-zero derivatives at the
-    /// endpoints, perturb the control points to make it easier to process
-    /// (especially offset and stroke), avoiding numerical robustness problems.
-    pub(crate) fn regularize_endpoints(&self, dimension: f64) -> CubicBez {
-        let mut c = *self;
-        // First step: if control point is too near the endpoint, nudge it away
-        // along the tangent.
-        let dim2 = dimension * dimension;
-        if c.p0.distance_squared(c.p1) < dim2 {
-            let d02 = c.p0.distance_squared(c.p2);
-            if d02 >= dim2 {
-                // TODO: moderate if this would move closer to p3
-                c.p1 = c.p0.lerp(c.p2, (dim2 / d02).sqrt());
-            } else {
-                c.p1 = c.p0.lerp(c.p3, 1.0 / 3.0);
-                c.p2 = c.p3.lerp(c.p0, 1.0 / 3.0);
-                return c;
-            }
-        }
-        if c.p3.distance_squared(c.p2) < dim2 {
-            let d13 = c.p1.distance_squared(c.p2);
-            if d13 >= dim2 {
-                // TODO: moderate if this would move closer to p0
-                c.p2 = c.p3.lerp(c.p1, (dim2 / d13).sqrt());
-            } else {
-                c.p1 = c.p0.lerp(c.p3, 1.0 / 3.0);
-                c.p2 = c.p3.lerp(c.p0, 1.0 / 3.0);
-                return c;
-            }
-        }
-        c
-    }
-
     /// Preprocess a cubic Bézier to ease numerical robustness.
     ///
     /// If the cubic Bézier segment has zero or near-zero derivatives as an interior

kurbo/src/cubicbez.rs

@@ -4,27 +4,7 @@
 //! Computation of offset curves of cubic Béziers.
 //!
 //! The main algorithm in this module is a new technique designed for robustness
-//! and speed. The details are involved; hopefully there will be a paper. The
-//! method is not publicly exported aside from stroke expansion, as we probably
-//! want to iterate on the exact interface.
-//!
-//! There is also a slower algorithm based on curve fitting, which is deprecated
-//! and not currently used in kurbo's stroke expansion methods. See the [Parallel
-//! curves of cubic Béziers] blog post for a discussion of how this algorithm
-//! works and what kind of results can be expected. In general, it is expected to
-//! perform much better than most published algorithms. The number of curve
-//! segments needed to attain a given accuracy scales as O(n^6) with accuracy.
-//!
-//! In this second algorithm, to compute the offset curve (also known as parallel
-//! curve) of a cubic Bézier segment, create a [`CubicOffset`] struct with the
-//! curve segment and offset, then use [`fit_to_bezpath`] o
-//! [`fit_to_bezpath_opt`] depending on how much time to spend optimizing the
-//! resulting path.
-//!
-//! [`fit_to_bezpath`]: crate::fit_to_bezpath
-//! [`fit_to_bezpath_opt`]: crate::fit_to_bezpath_opt
-//! [Parallel curves of cubic Béziers]: https://raphlinus.github.io/curves/2022/09/09/parallel-beziers.html
-use core::ops::Range;
+//! and speed. The details are involved; hopefully there will be a paper.
 
 use arrayvec::ArrayVec;
 
@@ -33,159 +13,11 @@ use crate::common::FloatFuncs;
 
 use crate::{
     common::{solve_itp, solve_quadratic},
-    BezPath, CubicBez, CurveFitSample, ParamCurve, ParamCurveDeriv, ParamCurveFit, PathSeg, Point,
-    QuadBez, Vec2,
+    BezPath, CubicBez, ParamCurve, ParamCurveDeriv, PathSeg, Point, QuadBez, Vec2,
 };
 
-/// The offset curve of a cubic Bézier.
-///
-/// This is a representation of the offset curve of a cubic Bézier segment, for
-/// purposes of curve fitting.
-///
-/// See the [module-level documentation] for a bit more discussion of the approach,
-/// and how this struct is to be used.
-///
-/// This struct was formerly used by the stroke expansion logic, but has since been
-/// replaced with a higher performance implementation not based on generic curve
-/// fitting. It should be considered deprecated, and may be removed in a future
-/// version.
-///
-/// [module-level documentation]: crate::offset
-#[deprecated(
-    since = "0.11.2",
-    note = "stroke expansion internals are no longer public"
-)]
-pub struct CubicOffset {
-    /// Source curve.
-    c: CubicBez,
-    /// Derivative of source curve.
-    q: QuadBez,
-    /// Offset.
-    d: f64,
-    // c0 + c1 t + c2 t^2 is the cross product of second and first
-    // derivatives of the underlying cubic, multiplied by offset (for
-    // computing cusp).
-    c0: f64,
-    c1: f64,
-    c2: f64,
-}
-
-#[expect(deprecated, reason = "implementation still expected to work")]
-impl CubicOffset {
-    /// Create a new curve from Bézier segment and offset.
-    ///
-    /// This method should only be used if the Bézier is smooth. Use
-    /// [`new_regularized`] instead to deal with a wider range of inputs.
-    ///
-    /// [`new_regularized`]: Self::new_regularized
-    pub fn new(c: CubicBez, d: f64) -> Self {
-        let q = c.deriv();
-        let d0 = q.p0.to_vec2();
-        let d1 = 2.0 * (q.p1 - q.p0);
-        let d2 = q.p0.to_vec2() - 2.0 * q.p1.to_vec2() + q.p2.to_vec2();
-        CubicOffset {
-            c,
-            q,
-            d,
-            c0: d * d1.cross(d0),
-            c1: d * 2.0 * d2.cross(d0),
-            c2: d * d2.cross(d1),
-        }
-    }
-
-    /// Create a new curve from Bézier segment and offset, with numerical robustness tweaks.
-    ///
-    /// The dimension represents a minimum feature size; the regularization is allowed to
-    /// perturb the curve by this amount in order to improve the robustness.
-    pub fn new_regularized(c: CubicBez, d: f64, dimension: f64) -> Self {
-        Self::new(
-            c.regularize_endpoints(dimension).regularize_cusp(dimension),
-            d,
-        )
-    }
-
-    fn eval_offset(&self, t: f64) -> Vec2 {
-        let dp = self.q.eval(t).to_vec2();
-        let norm = Vec2::new(-dp.y, dp.x);
-        // TODO: deal with hypot = 0
-        norm * self.d / dp.hypot()
-    }
-
-    fn eval(&self, t: f64) -> Point {
-        // Point on source curve.
-        self.c.eval(t) + self.eval_offset(t)
-    }
-
-    /// Evaluate derivative of curve.
-    fn eval_deriv(&self, t: f64) -> Vec2 {
-        self.cusp_sign(t) * self.q.eval(t).to_vec2()
-    }
-
-    // Compute a function which has a zero-crossing at cusps, and is
-    // positive at low curvatures on the source curve.
-    fn cusp_sign(&self, t: f64) -> f64 {
-        let ds2 = self.q.eval(t).to_vec2().hypot2();
-        ((self.c2 * t + self.c1) * t + self.c0) / (ds2 * ds2.sqrt()) + 1.0
-    }
-}
-
-#[expect(deprecated, reason = "implementation still expected to work")]
-impl ParamCurveFit for CubicOffset {
-    fn sample_pt_tangent(&self, t: f64, sign: f64) -> CurveFitSample {
-        let p = self.eval(t);
-        const CUSP_EPS: f64 = 1e-8;
-        let mut cusp = self.cusp_sign(t);
-        if cusp.abs() < CUSP_EPS {
-            // This is a numerical derivative, which is probably good enough
-            // for all practical purposes, but an analytical derivative would
-            // be more elegant.
-            //
-            // Also, we're not dealing with second or higher order cusps.
-            cusp = sign * (self.cusp_sign(t + CUSP_EPS) - self.cusp_sign(t - CUSP_EPS));
-        }
-        let tangent = self.q.eval(t).to_vec2() * cusp.signum();
-        CurveFitSample { p, tangent }
-    }
-
-    fn sample_pt_deriv(&self, t: f64) -> (Point, Vec2) {
-        (self.eval(t), self.eval_deriv(t))
-    }
-
-    fn break_cusp(&self, range: Range<f64>) -> Option<f64> {
-        const CUSP_EPS: f64 = 1e-8;
-        // When an endpoint is on (or very near) a cusp, move just far enough
-        // away from the cusp that we're confident we have the right sign.
-        let break_cusp_help = |mut x, mut d| {
-            let mut cusp = self.cusp_sign(x);
-            while cusp.abs() < CUSP_EPS && d < 1.0 {
-                x += d;
-                let old_cusp = cusp;
-                cusp = self.cusp_sign(x);
-                if cusp.abs() > old_cusp.abs() {
-                    break;
-                }
-                d *= 2.0;
-            }
-            (x, cusp)
-        };
-        let (a, cusp0) = break_cusp_help(range.start, 1e-12);
-        let (b, cusp1) = break_cusp_help(range.end, -1e-12);
-        if a >= b || cusp0 * cusp1 >= 0.0 {
-            // Discussion point: maybe we should search for double cusps in the interior
-            // of the range.
-            return None;
-        }
-        let s = cusp1.signum();
-        let f = |t| s * self.cusp_sign(t);
-        let k1 = 0.2 / (b - a);
-        const ITP_EPS: f64 = 1e-12;
-        let x = solve_itp(f, a, b, ITP_EPS, 1, k1, s * cusp0, s * cusp1);
-        Some(x)
-    }
-}
-
 /// State used for computing an offset curve of a single cubic.
-struct CubicOffset2 {
+struct CubicOffset {
     /// The cubic being offset. This has been regularized.
     c: CubicBez,
     /// The derivative of `c`.
@@ -271,10 +103,9 @@ struct SubdivisionPoint {
 /// The parallel curve of `c` offset by `d` is written to the `result` path.
 ///
 /// There is a fair amount of attention to robustness, but this method is not suitable
-/// for degenerate cubics with entirely co-linear control points. Rather, those cases
-/// are handled in the stroking logic, replacing them with linear segments and round
-/// joins as needed.
-pub(crate) fn offset_cubic(c: CubicBez, d: f64, tolerance: f64, result: &mut BezPath) {
+/// for degenerate cubics with entirely co-linear control points. Those cases should be
+/// handled before calling this function, by replacing them with linear segments.
+pub fn offset_cubic(c: CubicBez, d: f64, tolerance: f64, result: &mut BezPath) {
     result.truncate(0);
     // A tuning parameter for regularization. A value too large may distort the curve,
     // while a value too small may fail to generate smooth curves. This is a somewhat
@@ -288,7 +119,7 @@ pub(crate) fn offset_cubic(c: CubicBez, d: f64, tolerance: f64, result: &mut Bez
     // tangent determination to the caller, as those computations are the same for both
     // signs of `d`.
     let c_regularized = c.regularize_cusp(tolerance * DIM_TUNE);
-    let co = CubicOffset2::new(c_regularized, d, tolerance);
+    let co = CubicOffset::new(c_regularized, d, tolerance);
     let (tan0, tan1) = PathSeg::Cubic(c).tangents();
     let utan0 = tan0.normalize();
     let utan1 = tan1.normalize();
@@ -299,15 +130,15 @@ pub(crate) fn offset_cubic(c: CubicBez, d: f64, tolerance: f64, result: &mut Bez
     co.offset_rec(&rec, result);
 }
 
-impl CubicOffset2 {
+impl CubicOffset {
     /// Create a new curve from Bézier segment and offset.
     fn new(c: CubicBez, d: f64, tolerance: f64) -> Self {
         let q = c.deriv();
         let d2 = 2.0 * d;
         let p1xp0 = q.p1.to_vec2().cross(q.p0.to_vec2());
         let p2xp0 = q.p2.to_vec2().cross(q.p0.to_vec2());
         let p2xp1 = q.p2.to_vec2().cross(q.p1.to_vec2());
-        CubicOffset2 {
+        CubicOffset {
             c,
             q,
             d,
@@ -786,11 +617,10 @@ const fn mk_a_weights(rev: bool) -> [f64; N_LSE] {
 const A_WEIGHTS: [f64; N_LSE] = mk_a_weights(false);
 const B_WEIGHTS: [f64; N_LSE] = mk_a_weights(true);
 
-#[expect(deprecated, reason = "tests still valid on deprecated code path")]
 #[cfg(test)]
 mod tests {
-    use super::CubicOffset;
-    use crate::{fit_to_bezpath, fit_to_bezpath_opt, CubicBez, PathEl};
+    use super::offset_cubic;
+    use crate::{BezPath, CubicBez, PathEl};
 
     // This test tries combinations of parameters that have caused problems in the past.
     #[test]
@@ -803,32 +633,36 @@ mod tests {
         };
         let offset = 3603.7267536453924;
         let accuracy = 0.1;
-        let offset_path = CubicOffset::new(curve, offset);
-        let path = fit_to_bezpath_opt(&offset_path, accuracy);
-        assert!(matches!(path.iter().next(), Some(PathEl::MoveTo(_))));
-        let path_opt = fit_to_bezpath(&offset_path, accuracy);
-        assert!(matches!(path_opt.iter().next(), Some(PathEl::MoveTo(_))));
+
+        let mut result = BezPath::new();
+        offset_cubic(curve, offset, accuracy, &mut result);
+        assert!(matches!(result.iter().next(), Some(PathEl::MoveTo(_))));
+
+        let mut result = BezPath::new();
+        offset_cubic(curve, offset, accuracy, &mut result);
+        assert!(matches!(result.iter().next(), Some(PathEl::MoveTo(_))));
     }
 
     /// Cubic offset that used to trigger infinite recursion.
     #[test]
     fn infinite_recursion() {
-        const DIM_TUNE: f64 = 0.25;
         const TOLERANCE: f64 = 0.1;
+        const OFFSET: f64 = -0.5;
         let c = CubicBez::new(
             (1096.2962962962963, 593.90243902439033),
             (1043.6213991769548, 593.90243902439033),
             (1030.4526748971193, 593.90243902439033),
             (1056.7901234567901, 593.90243902439033),
         );
-        let co = CubicOffset::new_regularized(c, -0.5, DIM_TUNE * TOLERANCE);
-        fit_to_bezpath(&co, TOLERANCE);
+
+        let mut result = BezPath::new();
+        offset_cubic(c, OFFSET, TOLERANCE, &mut result);
     }
 
     #[test]
     fn test_cubic_offset_simple_line() {
         let cubic = CubicBez::new((0., 0.), (10., 0.), (20., 0.), (30., 0.));
-        let offset = CubicOffset::new(cubic, 5.);
-        let _optimized = fit_to_bezpath(&offset, 1e-6);
+        let mut result = BezPath::new();
+        offset_cubic(cubic, 5., 1e-6, &mut result);
     }
 }