oxihuman-mesh 0.2.1

Mesh processing, topology, and geometry algorithms for OxiHuman
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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]

pub struct CurvatureLine {
    pub points: Vec<[f32; 3]>,
    pub k1: f32,
    pub k2: f32,
    pub is_max: bool,
}

pub fn new_curvature_line(k1: f32, k2: f32, is_max: bool) -> CurvatureLine {
    CurvatureLine {
        points: vec![],
        k1,
        k2,
        is_max,
    }
}

pub fn curvline_push(l: &mut CurvatureLine, p: [f32; 3]) {
    l.points.push(p);
}

pub fn curvline_length(l: &CurvatureLine) -> f32 {
    if l.points.len() < 2 {
        return 0.0;
    }
    let mut total = 0.0_f32;
    for i in 1..l.points.len() {
        let a = l.points[i - 1];
        let b = l.points[i];
        let dx = b[0] - a[0];
        let dy = b[1] - a[1];
        let dz = b[2] - a[2];
        total += (dx * dx + dy * dy + dz * dz).sqrt();
    }
    total
}

pub fn curvline_anisotropy(l: &CurvatureLine) -> f32 {
    (l.k1 - l.k2).abs()
}

pub fn curvline_color(l: &CurvatureLine) -> [f32; 3] {
    if l.is_max {
        [1.0, 0.5, 0.0]
    } else {
        [0.0, 0.5, 1.0]
    }
}

pub fn curvline_point_count(l: &CurvatureLine) -> usize {
    l.points.len()
}

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

    #[test]
    fn test_new_curvature_line() {
        /* construction */
        let l = new_curvature_line(1.0, -1.0, true);
        assert!((l.k1 - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_push_and_count() {
        /* push adds points */
        let mut l = new_curvature_line(1.0, 0.5, false);
        curvline_push(&mut l, [0.0, 0.0, 0.0]);
        curvline_push(&mut l, [1.0, 0.0, 0.0]);
        assert_eq!(curvline_point_count(&l), 2);
    }

    #[test]
    fn test_length() {
        /* two unit points */
        let mut l = new_curvature_line(1.0, 0.5, true);
        curvline_push(&mut l, [0.0, 0.0, 0.0]);
        curvline_push(&mut l, [1.0, 0.0, 0.0]);
        assert!((curvline_length(&l) - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_anisotropy() {
        /* k1-k2 abs */
        let l = new_curvature_line(3.0, 1.0, true);
        assert!((curvline_anisotropy(&l) - 2.0).abs() < 1e-6);
    }

    #[test]
    fn test_color_max() {
        /* max principal => orange */
        let l = new_curvature_line(1.0, 0.5, true);
        let c = curvline_color(&l);
        assert!((c[0] - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_color_min() {
        /* min principal => blue-ish */
        let l = new_curvature_line(1.0, 0.5, false);
        let c = curvline_color(&l);
        assert!(c[2] > 0.0);
        assert!(c[0] < 1e-6);
    }
}