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

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

pub struct UvSeam {
    pub vertex_pairs: Vec<(usize, usize)>,
}

pub fn new_uv_seam() -> UvSeam {
    UvSeam {
        vertex_pairs: Vec::new(),
    }
}

pub fn seam_add_pair(s: &mut UvSeam, a: usize, b: usize) {
    s.vertex_pairs.push((a, b));
}

pub fn seam_pair_count(s: &UvSeam) -> usize {
    s.vertex_pairs.len()
}

pub fn seam_contains_vertex(s: &UvSeam, v: usize) -> bool {
    s.vertex_pairs.iter().any(|&(a, b)| a == v || b == v)
}

pub fn seam_flatten_uv(uvs: &[[f32; 2]], _seam: &UvSeam) -> Vec<[f32; 2]> {
    /* stub: return copy */
    uvs.to_vec()
}

pub fn seam_boundary_length(positions: &[[f32; 3]], seam: &UvSeam) -> f32 {
    seam.vertex_pairs
        .iter()
        .map(|&(a, b)| {
            if a < positions.len() && b < positions.len() {
                let pa = positions[a];
                let pb = positions[b];
                ((pa[0] - pb[0]).powi(2) + (pa[1] - pb[1]).powi(2) + (pa[2] - pb[2]).powi(2)).sqrt()
            } else {
                0.0
            }
        })
        .sum()
}

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

    #[test]
    fn test_new_uv_seam() {
        /* starts empty */
        let s = new_uv_seam();
        assert_eq!(seam_pair_count(&s), 0);
    }

    #[test]
    fn test_seam_add_pair() {
        /* pair count increases */
        let mut s = new_uv_seam();
        seam_add_pair(&mut s, 0, 1);
        assert_eq!(seam_pair_count(&s), 1);
    }

    #[test]
    fn test_seam_contains_vertex() {
        /* finds vertex in pair */
        let mut s = new_uv_seam();
        seam_add_pair(&mut s, 3, 7);
        assert!(seam_contains_vertex(&s, 3));
        assert!(!seam_contains_vertex(&s, 5));
    }

    #[test]
    fn test_seam_flatten_uv_returns_copy() {
        /* flatten returns identical copy */
        let uvs = vec![[0.1f32, 0.2], [0.5, 0.6]];
        let s = new_uv_seam();
        let out = seam_flatten_uv(&uvs, &s);
        assert_eq!(out.len(), 2);
        assert!((out[0][0] - 0.1).abs() < 1e-6);
    }

    #[test]
    fn test_seam_boundary_length() {
        /* computes edge length between pair */
        let positions = vec![[0.0f32, 0.0, 0.0], [3.0, 4.0, 0.0]];
        let mut s = new_uv_seam();
        seam_add_pair(&mut s, 0, 1);
        let len = seam_boundary_length(&positions, &s);
        assert!((len - 5.0).abs() < 1e-5);
    }

    #[test]
    fn test_seam_boundary_length_empty() {
        /* empty seam has zero length */
        let positions = vec![[0.0f32, 0.0, 0.0]];
        let s = new_uv_seam();
        assert!(seam_boundary_length(&positions, &s).abs() < 1e-6);
    }
}