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
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
132
133

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

/// Exported lattice (free-form deformation cage) data.
#[allow(dead_code)]
pub struct LatticeExport {
    pub name: String,
    pub u: u32,
    pub v: u32,
    pub w: u32,
    pub points: Vec<[f32; 3]>,
    pub interpolation: u8,
}

/// Create a new lattice export; generates default grid points.
#[allow(dead_code)]
pub fn new_lattice_export(name: &str, u: u32, v: u32, w: u32) -> LatticeExport {
    let mut points = Vec::new();
    let u = u.max(2);
    let v = v.max(2);
    let w = w.max(2);
    for wi in 0..w {
        for vi in 0..v {
            for ui in 0..u {
                let x = (ui as f32) / (u - 1) as f32 - 0.5;
                let y = (vi as f32) / (v - 1) as f32 - 0.5;
                let z = (wi as f32) / (w - 1) as f32 - 0.5;
                points.push([x, y, z]);
            }
        }
    }
    LatticeExport {
        name: name.to_string(),
        u,
        v,
        w,
        points,
        interpolation: 0,
    }
}

/// Number of lattice control points.
#[allow(dead_code)]
pub fn lattice_point_count(l: &LatticeExport) -> usize {
    l.points.len()
}

/// Export the lattice to a JSON string.
#[allow(dead_code)]
pub fn export_lattice_to_json(l: &LatticeExport) -> String {
    let pts: String = l
        .points
        .iter()
        .map(|p| format!("[{},{},{}]", p[0], p[1], p[2]))
        .collect::<Vec<_>>()
        .join(",");
    format!(
        r#"{{"name":"{}","u":{},"v":{},"w":{},"interpolation":{},"points":[{}]}}"#,
        l.name, l.u, l.v, l.w, l.interpolation, pts
    )
}

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

    #[test]
    fn test_new_lattice_export_name() {
        let l = new_lattice_export("Lattice", 2, 2, 2);
        assert_eq!(l.name, "Lattice");
    }

    #[test]
    fn test_new_lattice_export_point_count_2x2x2() {
        let l = new_lattice_export("L", 2, 2, 2);
        assert_eq!(lattice_point_count(&l), 8);
    }

    #[test]
    fn test_new_lattice_export_point_count_3x2x2() {
        let l = new_lattice_export("L", 3, 2, 2);
        assert_eq!(lattice_point_count(&l), 12);
    }

    #[test]
    fn test_new_lattice_minimum_dimensions() {
        // dimensions below 2 are clamped to 2
        let l = new_lattice_export("L", 1, 1, 1);
        assert_eq!(lattice_point_count(&l), 8);
    }

    #[test]
    fn test_lattice_point_count_helper() {
        let l = new_lattice_export("L", 2, 3, 2);
        assert_eq!(lattice_point_count(&l), l.points.len());
    }

    #[test]
    fn test_export_lattice_to_json_name() {
        let l = new_lattice_export("MyLattice", 2, 2, 2);
        let json = export_lattice_to_json(&l);
        assert!(json.contains("MyLattice"));
    }

    #[test]
    fn test_export_lattice_to_json_has_points() {
        let l = new_lattice_export("L", 2, 2, 2);
        let json = export_lattice_to_json(&l);
        assert!(json.contains("points"));
    }

    #[test]
    fn test_export_lattice_to_json_structure() {
        let l = new_lattice_export("L", 2, 2, 2);
        let json = export_lattice_to_json(&l);
        assert!(json.starts_with('{') && json.ends_with('}'));
    }

    #[test]
    fn test_lattice_corner_positions() {
        let l = new_lattice_export("L", 2, 2, 2);
        // first point is at (-0.5, -0.5, -0.5)
        assert!((l.points[0][0] + 0.5).abs() < 1e-5);
    }

    #[test]
    fn test_export_lattice_dimensions() {
        let l = new_lattice_export("L", 3, 3, 2);
        let json = export_lattice_to_json(&l);
        assert!(json.contains("\"u\":3"));
    }
}