neco-brep 0.1.0

Analytical B-Rep engine with boolean operations
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
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Bezier curve evaluation and frame interpolation utilities.

/// Rational De Casteljau algorithm (2D).
pub fn de_casteljau_rational_2d(
    control_points: &[[f64; 2]],
    weights: &[f64],
    t: f64,
) -> (f64, f64) {
    let n = control_points.len();
    let mut pts: Vec<[f64; 2]> = control_points.to_vec();
    let mut wts: Vec<f64> = weights.to_vec();
    for level in 1..n {
        for i in 0..n - level {
            let w0 = wts[i] * (1.0 - t);
            let w1 = wts[i + 1] * t;
            let w_sum = w0 + w1;
            pts[i][0] = (pts[i][0] * w0 + pts[i + 1][0] * w1) / w_sum;
            pts[i][1] = (pts[i][1] * w0 + pts[i + 1][1] * w1) / w_sum;
            wts[i] = w_sum;
        }
    }
    (pts[0][0], pts[0][1])
}

/// Rational De Casteljau algorithm (3D).
pub fn de_casteljau_rational_3d(control_points: &[[f64; 3]], weights: &[f64], t: f64) -> [f64; 3] {
    let n = control_points.len();
    let mut pts: Vec<[f64; 3]> = control_points.to_vec();
    let mut wts: Vec<f64> = weights.to_vec();
    for level in 1..n {
        for i in 0..n - level {
            let w0 = wts[i] * (1.0 - t);
            let w1 = wts[i + 1] * t;
            let w_sum = w0 + w1;
            pts[i] = [
                (pts[i][0] * w0 + pts[i + 1][0] * w1) / w_sum,
                (pts[i][1] * w0 + pts[i + 1][1] * w1) / w_sum,
                (pts[i][2] * w0 + pts[i + 1][2] * w1) / w_sum,
            ];
            wts[i] = w_sum;
        }
    }
    pts[0]
}

/// Normalize a vector, returning `fallback` if near-zero.
fn normalize_with_fallback(v: [f64; 3], fallback: [f64; 3]) -> [f64; 3] {
    let len = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
    if len < 1e-30 {
        return fallback;
    }
    let inv = 1.0 / len;
    [v[0] * inv, v[1] * inv, v[2] * inv]
}

/// Linearly interpolate between two frames, returning normalized (normal, binormal).
///
/// `frames` layout: `[[normal, binormal, tangent]; 2]`.
/// Falls back to `[0, 0, 1]` on zero vectors.
pub fn interpolate_frame(frames: &[[[f64; 3]; 3]], u: f64) -> ([f64; 3], [f64; 3]) {
    let n0 = frames[0][0];
    let b0 = frames[0][1];
    let n1 = frames[1][0];
    let b1 = frames[1][1];

    let fallback = [0.0, 0.0, 1.0];

    let normal = normalize_with_fallback(
        [
            n0[0] * (1.0 - u) + n1[0] * u,
            n0[1] * (1.0 - u) + n1[1] * u,
            n0[2] * (1.0 - u) + n1[2] * u,
        ],
        fallback,
    );
    let binormal = normalize_with_fallback(
        [
            b0[0] * (1.0 - u) + b1[0] * u,
            b0[1] * (1.0 - u) + b1[1] * u,
            b0[2] * (1.0 - u) + b1[2] * u,
        ],
        fallback,
    );
    (normal, binormal)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_de_casteljau_2d_linear() {
        let pts = [[0.0, 0.0], [1.0, 1.0]];
        let ws = [1.0, 1.0];
        let (x, y) = de_casteljau_rational_2d(&pts, &ws, 0.5);
        assert!((x - 0.5).abs() < 1e-12);
        assert!((y - 0.5).abs() < 1e-12);
    }

    #[test]
    fn test_de_casteljau_3d_linear() {
        let pts = [[0.0, 0.0, 0.0], [2.0, 4.0, 6.0]];
        let ws = [1.0, 1.0];
        let result = de_casteljau_rational_3d(&pts, &ws, 0.25);
        assert!((result[0] - 0.5).abs() < 1e-12);
        assert!((result[1] - 1.0).abs() < 1e-12);
        assert!((result[2] - 1.5).abs() < 1e-12);
    }

    #[test]
    fn test_interpolate_frame_midpoint() {
        let frames = [
            [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
            [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
        ];
        let (n, b) = interpolate_frame(&frames, 0.5);
        assert!((n[0] - 1.0).abs() < 1e-12);
        assert!((b[1] - 1.0).abs() < 1e-12);
    }

    #[test]
    fn test_interpolate_frame_zero_fallback() {
        let frames = [
            [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0]],
            [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0]],
        ];
        let (n, b) = interpolate_frame(&frames, 0.5);
        assert_eq!(n, [0.0, 0.0, 1.0]);
        assert_eq!(b, [0.0, 0.0, 1.0]);
    }
}