oxihuman-export 0.1.2

Export pipeline for OxiHuman — glTF, COLLADA, STL, and streaming formats
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

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

pub struct Tooth {
    pub id: u8,
    pub pos: [f32; 3],
    pub orientation: [f32; 4],
    pub crown_height_mm: f32,
    pub root_length_mm: f32,
    pub shade: String,
}

pub fn new_tooth(id: u8, pos: [f32; 3]) -> Tooth {
    Tooth {
        id,
        pos,
        orientation: [0.0, 0.0, 0.0, 1.0],
        crown_height_mm: 8.5,
        root_length_mm: 13.0,
        shade: String::from("A2"),
    }
}

pub fn tooth_total_length(t: &Tooth) -> f32 {
    t.crown_height_mm + t.root_length_mm
}

pub fn tooth_to_json(t: &Tooth) -> String {
    format!(
        "{{\"id\":{},\"pos\":[{:.4},{:.4},{:.4}],\"crown_mm\":{:.2},\"root_mm\":{:.2},\"shade\":\"{}\"}}",
        t.id,
        t.pos[0],
        t.pos[1],
        t.pos[2],
        t.crown_height_mm,
        t.root_length_mm,
        t.shade
    )
}

pub fn teeth_to_json(teeth: &[Tooth]) -> String {
    let items: Vec<String> = teeth.iter().map(tooth_to_json).collect();
    format!("{{\"teeth\":[{}]}}", items.join(","))
}

/// Molar: id 6, 7, 8, 14, 15, 16 per arch (FDI or UNS 1-based).
pub fn tooth_is_molar(t: &Tooth) -> bool {
    matches!(t.id, 6 | 7 | 8 | 14 | 15 | 16)
}

pub fn tooth_count(teeth: &[Tooth]) -> usize {
    teeth.len()
}

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

    #[test]
    fn test_new_tooth() {
        /* construction */
        let t = new_tooth(1, [0.0, 0.0, 0.0]);
        assert_eq!(t.id, 1);
        assert!((t.crown_height_mm - 8.5).abs() < 1e-6);
    }

    #[test]
    fn test_total_length() {
        /* crown + root */
        let t = new_tooth(1, [0.0; 3]);
        assert!((tooth_total_length(&t) - 21.5).abs() < 1e-6);
    }

    #[test]
    fn test_to_json() {
        /* JSON contains id */
        let t = new_tooth(5, [1.0, 2.0, 3.0]);
        let json = tooth_to_json(&t);
        assert!(json.contains("\"id\":5"));
    }

    #[test]
    fn test_teeth_to_json() {
        /* array in JSON */
        let teeth = vec![new_tooth(1, [0.0; 3]), new_tooth(2, [1.0; 3])];
        let json = teeth_to_json(&teeth);
        assert!(json.contains("teeth"));
    }

    #[test]
    fn test_is_molar() {
        /* id 6 is molar, id 1 is not */
        let molar = new_tooth(6, [0.0; 3]);
        let incisor = new_tooth(1, [0.0; 3]);
        assert!(tooth_is_molar(&molar));
        assert!(!tooth_is_molar(&incisor));
    }

    #[test]
    fn test_count() {
        /* count */
        let teeth: Vec<Tooth> = (1..=4).map(|i| new_tooth(i, [0.0; 3])).collect();
        assert_eq!(tooth_count(&teeth), 4);
    }
}