hypercurve 0.2.0

Hyperreal-backed planar curves, contours, and regions for CAD topology
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Error types for curve construction and topology operations.

use std::fmt;

/// Result alias used by `hypercurve`.
pub type CurveResult<T> = Result<T, CurveError>;

/// Errors returned by curve constructors and early topology scaffolding.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum CurveError {
    /// A line segment has equal endpoints.
    ZeroLengthLine,
    /// A circular arc has zero radius.
    ZeroRadiusArc,
    /// A rational Bezier weight is structurally zero.
    ZeroRationalBezierWeight,
    /// A circular arc start/end pair does not lie on a common supplied circle.
    RadiusMismatch,
    /// A bulge value is too close to zero to choose line versus arc semantics.
    AmbiguousBulge,
    /// A curve string needs at least two vertices or one segment.
    InsufficientVertices,
    /// A curve string cannot be empty when built through checked constructors.
    EmptyCurveString,
    /// Adjacent curve-string segments are not connected.
    DisconnectedCurveString,
    /// Adjacent curve-string segment connectivity could not be classified.
    AmbiguousCurveStringConnection,
    /// Polyline reconstruction options contain non-finite or unsupported values.
    InvalidReconstructionOptions,
    /// Bezier flattening options cannot certify a positive error budget.
    InvalidFlatteningOptions,
    /// Finite projection options contain non-finite or unsupported values.
    InvalidFiniteProjectionOptions,
    /// A finite affine transform is not a nonsingular planar similarity.
    InvalidSimilarityTransform,
    /// A Bezier parameter is certified outside the closed unit interval.
    InvalidBezierParameter,
    /// A Bezier segment range is outside the stored path facts.
    InvalidBezierRange,
    /// A requested Bezier arc length is certified outside the curve length range.
    InvalidBezierArcLengthTarget,
    /// Polyline reconstruction needs coordinates with finite `f64` approximations.
    NonFiniteReconstructionPoint,
    /// Finite projection needs coordinates with finite `f64` approximations.
    NonFiniteProjectionPoint,
    /// A topology pipeline referenced inconsistent internal state.
    Topology(String),
    /// A `Real` division or elementary operation failed.
    Real(String),
}

impl fmt::Display for CurveError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::ZeroLengthLine => write!(f, "line segment has zero length"),
            Self::ZeroRadiusArc => write!(f, "circular arc has zero radius"),
            Self::ZeroRationalBezierWeight => {
                write!(f, "rational Bezier weight is structurally zero")
            }
            Self::RadiusMismatch => write!(f, "arc endpoints do not share the supplied radius"),
            Self::AmbiguousBulge => write!(f, "bulge sign or zero status is ambiguous"),
            Self::InsufficientVertices => write!(f, "curve string has insufficient vertices"),
            Self::EmptyCurveString => write!(f, "curve string has no segments"),
            Self::DisconnectedCurveString => write!(f, "curve string segments are disconnected"),
            Self::AmbiguousCurveStringConnection => {
                write!(f, "curve string segment connectivity is ambiguous")
            }
            Self::InvalidReconstructionOptions => {
                write!(f, "polyline reconstruction options are invalid")
            }
            Self::InvalidFlatteningOptions => write!(f, "Bezier flattening options are invalid"),
            Self::InvalidFiniteProjectionOptions => {
                write!(f, "finite projection options are invalid")
            }
            Self::InvalidSimilarityTransform => {
                write!(f, "affine transform is not a planar similarity")
            }
            Self::InvalidBezierParameter => {
                write!(f, "Bezier parameter is outside the closed unit interval")
            }
            Self::InvalidBezierRange => write!(f, "Bezier segment range is invalid"),
            Self::InvalidBezierArcLengthTarget => {
                write!(
                    f,
                    "Bezier arc-length target is outside the certified length range"
                )
            }
            Self::NonFiniteReconstructionPoint => {
                write!(f, "polyline reconstruction point is not finite")
            }
            Self::NonFiniteProjectionPoint => write!(f, "finite projection point is not finite"),
            Self::Topology(message) => write!(f, "topology operation failed: {message}"),
            Self::Real(message) => write!(f, "Real operation failed: {message}"),
        }
    }
}

impl std::error::Error for CurveError {}

impl From<hyperreal::Problem> for CurveError {
    fn from(value: hyperreal::Problem) -> Self {
        Self::Real(value.to_string())
    }
}