i_curve 0.1.2

Boolean operations on closed paths of lines, Bezier curves, and rational elliptic arcs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::float::curve::arc::RationalArc;
use i_overlay::i_float::float::compatible::FloatPointCompatible;

/// Segment of a float [`CurvePath`](crate::float::CurvePath).
///
/// The containing path supplies the start point; each variant stores its
/// remaining control data and endpoint.
#[derive(Clone, PartialEq)]
pub enum CurveSegment<P: FloatPointCompatible> {
    /// Straight segment.
    Line {
        /// Endpoint.
        to: P,
    },
    /// Quadratic Bézier segment.
    Quad {
        /// Quadratic control point.
        ctrl: P,
        /// Endpoint.
        to: P,
    },
    /// Cubic Bézier segment.
    Cubic {
        /// First cubic control point.
        ctrl0: P,
        /// Second cubic control point.
        ctrl1: P,
        /// Endpoint.
        to: P,
    },
    /// Authoritative rational quadratic elliptic arc.
    Arc {
        /// Rational arc data, including its own start and end points.
        arc: RationalArc<P>,
    },
}

impl<P> core::fmt::Debug for CurveSegment<P>
where
    P: FloatPointCompatible + core::fmt::Debug,
    P::Scalar: core::fmt::Debug,
{
    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::Line { to } => formatter.debug_struct("Line").field("to", to).finish(),
            Self::Quad { ctrl, to } => formatter
                .debug_struct("Quad")
                .field("ctrl", ctrl)
                .field("to", to)
                .finish(),
            Self::Cubic { ctrl0, ctrl1, to } => formatter
                .debug_struct("Cubic")
                .field("ctrl0", ctrl0)
                .field("ctrl1", ctrl1)
                .field("to", to)
                .finish(),
            Self::Arc { arc } => formatter.debug_struct("Arc").field("arc", arc).finish(),
        }
    }
}

impl<P: FloatPointCompatible> CurveSegment<P> {
    /// Returns this segment's endpoint.
    #[inline]
    pub fn end_point(&self) -> P {
        match self {
            Self::Line { to } | Self::Quad { to, .. } | Self::Cubic { to, .. } => *to,
            Self::Arc { arc } => arc.end_point(),
        }
    }
}