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

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

// --- new API (Wave 151B) ---

pub struct CatenaryParams {
    pub a: f32,
    pub num_segments: usize,
    pub x_range: [f32; 2],
}

pub fn new_catenary(a: f32, x_min: f32, x_max: f32, segments: usize) -> CatenaryParams {
    CatenaryParams {
        a,
        num_segments: segments,
        x_range: [x_min, x_max],
    }
}

pub fn catenary_y(a: f32, x: f32) -> f32 {
    a * (x / a).cosh()
}

pub fn catenary_arc_length(a: f32, x0: f32, x1: f32) -> f32 {
    a * (x1 / a).sinh() - a * (x0 / a).sinh()
}

pub fn catenary_to_polyline(p: &CatenaryParams) -> Vec<[f32; 2]> {
    let n = p.num_segments.max(1);
    let x0 = p.x_range[0];
    let x1 = p.x_range[1];
    (0..=n)
        .map(|i| {
            let t = i as f32 / n as f32;
            let x = x0 + t * (x1 - x0);
            [x, catenary_y(p.a, x)]
        })
        .collect()
}

pub fn catenary_sag(p: &CatenaryParams) -> f32 {
    let y_mid = catenary_y(p.a, (p.x_range[0] + p.x_range[1]) * 0.5);
    let y_end = catenary_y(p.a, p.x_range[0]).max(catenary_y(p.a, p.x_range[1]));
    y_end - y_mid
}

// --- legacy API stubs (previously expected by lib.rs) ---

pub struct CatenaryPoint {
    pub x: f32,
    pub y: f32,
}

pub fn default_catenary_params() -> CatenaryParams {
    new_catenary(1.0, -1.0, 1.0, 32)
}

pub fn euler_number() -> f32 {
    std::f32::consts::E
}

pub fn lowest_point(p: &CatenaryParams) -> [f32; 2] {
    let x = (p.x_range[0] + p.x_range[1]) * 0.5;
    [x, catenary_y(p.a, x)]
}

pub fn point_count(p: &CatenaryParams) -> usize {
    p.num_segments + 1
}

pub fn sample_catenary(p: &CatenaryParams, t: f32) -> CatenaryPoint {
    let x = p.x_range[0] + t * (p.x_range[1] - p.x_range[0]);
    CatenaryPoint {
        x,
        y: catenary_y(p.a, x),
    }
}

pub fn to_positions(p: &CatenaryParams) -> Vec<[f32; 3]> {
    catenary_to_polyline(p)
        .iter()
        .map(|&[x, y]| [x, y, 0.0])
        .collect()
}

pub fn catenary_tube_vertex_count(p: &CatenaryParams, tube_segments: u32) -> usize {
    (p.num_segments + 1) * tube_segments as usize
}

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

    #[test]
    fn test_new_catenary() {
        /* basic construction */
        let p = new_catenary(1.0, -1.0, 1.0, 10);
        assert_eq!(p.num_segments, 10);
        assert!((p.a - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_catenary_y_at_zero() {
        /* y(0) = a for any a */
        let y = catenary_y(2.0, 0.0);
        assert!((y - 2.0).abs() < 1e-5);
    }

    #[test]
    fn test_catenary_y_symmetric() {
        /* y is even */
        let y_pos = catenary_y(1.0, 1.0);
        let y_neg = catenary_y(1.0, -1.0);
        assert!((y_pos - y_neg).abs() < 1e-5);
    }

    #[test]
    fn test_catenary_arc_length_positive() {
        /* arc length from -1 to 1 is positive */
        let len = catenary_arc_length(1.0, -1.0, 1.0);
        assert!(len > 0.0);
    }

    #[test]
    fn test_catenary_to_polyline_count() {
        /* polyline has segments+1 points */
        let p = new_catenary(1.0, -2.0, 2.0, 8);
        let pts = catenary_to_polyline(&p);
        assert_eq!(pts.len(), 9);
    }

    #[test]
    fn test_catenary_sag_positive() {
        /* sag is non-negative for symmetric range */
        let p = new_catenary(1.0, -2.0, 2.0, 20);
        let sag = catenary_sag(&p);
        assert!(sag >= 0.0);
    }
}