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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

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

/// A point on a 2D stroke with associated width.
pub struct StrokePoint {
    pub pos: [f32; 2],
    pub width: f32,
}

pub fn new_stroke_point(x: f32, y: f32, width: f32) -> StrokePoint {
    StrokePoint {
        pos: [x, y],
        width: width.max(0.0),
    }
}

pub fn stroke_extrude_quad(a: &StrokePoint, b: &StrokePoint) -> [[f32; 2]; 4] {
    let dx = b.pos[0] - a.pos[0];
    let dy = b.pos[1] - a.pos[1];
    let len = (dx * dx + dy * dy).sqrt().max(1e-9);
    // perpendicular (rotate 90 deg)
    let nx = -dy / len;
    let ny = dx / len;
    let ha = a.width * 0.5;
    let hb = b.width * 0.5;
    [
        [a.pos[0] - nx * ha, a.pos[1] - ny * ha],
        [a.pos[0] + nx * ha, a.pos[1] + ny * ha],
        [b.pos[0] + nx * hb, b.pos[1] + ny * hb],
        [b.pos[0] - nx * hb, b.pos[1] - ny * hb],
    ]
}

pub fn stroke_total_length(points: &[StrokePoint]) -> f32 {
    let n = points.len();
    if n < 2 {
        return 0.0;
    }
    let mut total = 0.0f32;
    for i in 0..n - 1 {
        let dx = points[i + 1].pos[0] - points[i].pos[0];
        let dy = points[i + 1].pos[1] - points[i].pos[1];
        total += (dx * dx + dy * dy).sqrt();
    }
    total
}

pub fn stroke_area(points: &[StrokePoint]) -> f32 {
    let n = points.len();
    if n < 2 {
        return 0.0;
    }
    let mut total = 0.0f32;
    for i in 0..n - 1 {
        let quad = stroke_extrude_quad(&points[i], &points[i + 1]);
        // shoelace on quad
        let area = quad_area(&quad);
        total += area;
    }
    total
}

fn quad_area(q: &[[f32; 2]; 4]) -> f32 {
    // split into two triangles
    let t1 = triangle_area_2d(q[0], q[1], q[2]);
    let t2 = triangle_area_2d(q[0], q[2], q[3]);
    (t1 + t2).abs()
}

fn triangle_area_2d(a: [f32; 2], b: [f32; 2], c: [f32; 2]) -> f32 {
    0.5 * ((b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]))
}

pub fn stroke_vertex_count(point_count: usize) -> usize {
    if point_count < 2 {
        return 0;
    }
    point_count * 2
}

pub fn stroke_face_count(point_count: usize) -> usize {
    if point_count < 2 {
        return 0;
    }
    point_count - 1
}

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

    #[test]
    fn test_new_stroke_point() {
        let p = new_stroke_point(1.0, 2.0, 0.5);
        assert_eq!(p.pos, [1.0, 2.0]);
        assert!((p.width - 0.5).abs() < 1e-6);
    }

    #[test]
    fn test_stroke_extrude_quad_symmetric() {
        /* horizontal stroke: left/right sides should mirror */
        let a = new_stroke_point(0.0, 0.0, 2.0);
        let b = new_stroke_point(4.0, 0.0, 2.0);
        let quad = stroke_extrude_quad(&a, &b);
        assert!((quad[0][1] + quad[1][1]).abs() < 1e-5);
    }

    #[test]
    fn test_stroke_total_length() {
        let pts = vec![
            new_stroke_point(0.0, 0.0, 1.0),
            new_stroke_point(3.0, 4.0, 1.0),
        ];
        assert!((stroke_total_length(&pts) - 5.0).abs() < 1e-5);
    }

    #[test]
    fn test_stroke_area_positive() {
        let pts = vec![
            new_stroke_point(0.0, 0.0, 1.0),
            new_stroke_point(1.0, 0.0, 1.0),
            new_stroke_point(2.0, 0.0, 1.0),
        ];
        assert!(stroke_area(&pts) > 0.0);
    }

    #[test]
    fn test_stroke_vertex_count() {
        assert_eq!(stroke_vertex_count(5), 10);
        assert_eq!(stroke_vertex_count(1), 0);
    }

    #[test]
    fn test_stroke_face_count() {
        assert_eq!(stroke_face_count(5), 4);
        assert_eq!(stroke_face_count(0), 0);
    }

    #[test]
    fn test_stroke_width_clamped() {
        let p = new_stroke_point(0.0, 0.0, -1.0);
        assert!(p.width >= 0.0);
    }
}