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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

//! Path cut: cut a mesh along a vertex path.

/// A path of vertex indices describing a cut.
#[derive(Debug, Clone, Default)]
pub struct PathCut {
    pub vertex_path: Vec<usize>,
}

/// Create a new empty `PathCut`.
pub fn new_path_cut() -> PathCut {
    PathCut::default()
}

/// Total path length (sum of edge lengths along path).
pub fn path_cut_length(positions: &[[f32; 3]], cut: &PathCut) -> f32 {
    if cut.vertex_path.len() < 2 {
        return 0.0;
    }
    cut.vertex_path
        .windows(2)
        .map(|w| {
            let a = positions[w[0]];
            let b = positions[w[1]];
            let dx = b[0] - a[0];
            let dy = b[1] - a[1];
            let dz = b[2] - a[2];
            (dx * dx + dy * dy + dz * dz).sqrt()
        })
        .sum()
}

/// True if the path forms a closed loop (first == last vertex).
pub fn path_cut_is_closed(cut: &PathCut) -> bool {
    cut.vertex_path.len() >= 2 && cut.vertex_path.first() == cut.vertex_path.last()
}

/// Number of vertices in the path.
pub fn path_cut_vertex_count(cut: &PathCut) -> usize {
    cut.vertex_path.len()
}

/// List of edges (pairs of vertex indices) in the path.
pub fn path_cut_edges(cut: &PathCut) -> Vec<[usize; 2]> {
    if cut.vertex_path.len() < 2 {
        return vec![];
    }
    cut.vertex_path.windows(2).map(|w| [w[0], w[1]]).collect()
}

/// Stub shortest-path: returns a direct two-vertex path.
pub fn path_shortest(from: usize, to: usize) -> PathCut {
    PathCut {
        vertex_path: vec![from, to],
    }
}

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

    fn line_positions() -> Vec<[f32; 3]> {
        vec![
            [0.0, 0.0, 0.0],
            [1.0, 0.0, 0.0],
            [2.0, 0.0, 0.0],
            [3.0, 0.0, 0.0],
        ]
    }

    #[test]
    fn test_path_cut_length() {
        let pos = line_positions();
        let cut = PathCut {
            vertex_path: vec![0, 1, 2, 3],
        };
        let l = path_cut_length(&pos, &cut);
        assert!((l - 3.0).abs() < 1e-5);
    }

    #[test]
    fn test_path_cut_is_closed_false() {
        let cut = PathCut {
            vertex_path: vec![0, 1, 2],
        };
        assert!(!path_cut_is_closed(&cut));
    }

    #[test]
    fn test_path_cut_is_closed_true() {
        let cut = PathCut {
            vertex_path: vec![0, 1, 2, 0],
        };
        assert!(path_cut_is_closed(&cut));
    }

    #[test]
    fn test_path_cut_vertex_count() {
        let cut = PathCut {
            vertex_path: vec![0, 1, 2],
        };
        assert_eq!(path_cut_vertex_count(&cut), 3);
    }

    #[test]
    fn test_path_cut_edges() {
        let cut = PathCut {
            vertex_path: vec![0, 1, 2],
        };
        let edges = path_cut_edges(&cut);
        assert_eq!(edges.len(), 2);
        assert_eq!(edges[0], [0, 1]);
    }

    #[test]
    fn test_path_shortest() {
        let cut = path_shortest(0, 5);
        assert_eq!(cut.vertex_path.len(), 2);
        assert_eq!(cut.vertex_path[1], 5);
    }
}