axiolid-reference 0.1.0

Portable scalar reference implementation and certified predicates
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
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Shared validation for compact non-uniform B-spline axes.
//!
//! Imported CAD data stores distinct knots and parallel multiplicities. Validate
//! that compact encoding before expanding it: `zip`-then-check silently drops
//! unmatched entries, and expanding an attacker-controlled multiplicity before
//! checking the expected total is an allocation denial of service.

use axiolid_contracts::{GeomError, GeomResult};
use axiolid_core::Scalar;

/// Validated expanded knot axis used by the scalar de Boor evaluators.
pub(crate) struct SplineAxis {
    pub(crate) knots: Vec<Scalar>,
    pub(crate) count: usize,
    pub(crate) degree: usize,
}

impl SplineAxis {
    pub(crate) fn new(
        knots: &[Scalar],
        multiplicities: &[u32],
        degree: u16,
        count: usize,
        label: &str,
    ) -> GeomResult<Self> {
        let degree = usize::from(degree);
        if degree == 0 {
            return Err(GeomError::InvalidInput(format!(
                "{label} degree must be at least 1"
            )));
        }
        if count <= degree {
            return Err(GeomError::InvalidInput(format!(
                "{label} degree {degree} requires at least {} control points, got {count}",
                degree + 1
            )));
        }
        if knots.len() != multiplicities.len() {
            return Err(GeomError::InvalidInput(format!(
                "{label} has {} distinct knots but {} multiplicities",
                knots.len(),
                multiplicities.len()
            )));
        }
        if knots.len() < 2 {
            return Err(GeomError::InvalidInput(format!(
                "{label} needs at least two distinct knots"
            )));
        }
        if knots.iter().any(|knot| !knot.is_finite()) {
            return Err(GeomError::InvalidInput(format!(
                "{label} knots must be finite"
            )));
        }
        if knots.windows(2).any(|pair| pair[1] <= pair[0]) {
            return Err(GeomError::InvalidInput(format!(
                "{label} distinct knots must be strictly increasing"
            )));
        }

        let expected = count
            .checked_add(degree)
            .and_then(|value| value.checked_add(1))
            .ok_or_else(|| GeomError::InvalidInput(format!("{label} size overflows usize")))?;
        let maximum_multiplicity = degree + 1;
        let mut total = 0usize;
        for &multiplicity in multiplicities {
            let multiplicity = usize::try_from(multiplicity).map_err(|_| {
                GeomError::InvalidInput(format!("{label} multiplicity does not fit usize"))
            })?;
            if multiplicity == 0 || multiplicity > maximum_multiplicity {
                return Err(GeomError::InvalidInput(format!(
                    "{label} multiplicity {multiplicity} is outside 1..={maximum_multiplicity}"
                )));
            }
            total = total.checked_add(multiplicity).ok_or_else(|| {
                GeomError::InvalidInput(format!("{label} multiplicity sum overflows usize"))
            })?;
            if total > expected {
                return Err(GeomError::InvalidInput(format!(
                    "{label} knot vector has more than the expected {expected} entries"
                )));
            }
        }
        if total != expected {
            return Err(GeomError::InvalidInput(format!(
                "{label} knot vector has {total} entries, expected {expected}"
            )));
        }

        // Capacity is now bounded by the control count and degree, not raw
        // imported multiplicities.
        let mut expanded = Vec::with_capacity(expected);
        for (&knot, &multiplicity) in knots.iter().zip(multiplicities) {
            expanded.extend(core::iter::repeat_n(knot, multiplicity as usize));
        }
        let lo = expanded[degree];
        let hi = expanded[count];
        if hi <= lo {
            return Err(GeomError::Degenerate(format!("{label} domain is empty")));
        }

        Ok(Self {
            knots: expanded,
            count,
            degree,
        })
    }

    pub(crate) fn domain(&self) -> (Scalar, Scalar) {
        (self.knots[self.degree], self.knots[self.count])
    }

    pub(crate) fn clamp(&self, parameter: Scalar) -> Scalar {
        let (lo, hi) = self.domain();
        parameter.clamp(lo, hi)
    }
}