oxihuman-viewer 0.2.1

wgpu/WebGPU rendering adapter 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

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

#[derive(Debug, Clone)]
pub struct StressTensorView {
    pub enabled: bool,
    pub glyph_scale: f32,
    pub show_compression: bool,
    pub show_tension: bool,
}

pub fn new_stress_tensor_view() -> StressTensorView {
    StressTensorView {
        enabled: false,
        glyph_scale: 1.0,
        show_compression: true,
        show_tension: true,
    }
}

pub fn stv_set_glyph_scale(v: &mut StressTensorView, s: f32) {
    v.glyph_scale = s.max(0.0);
}

pub fn stv_enable(v: &mut StressTensorView) {
    v.enabled = true;
}

pub fn stv_toggle_compression(v: &mut StressTensorView) {
    v.show_compression = !v.show_compression;
}

pub fn stv_toggle_tension(v: &mut StressTensorView) {
    v.show_tension = !v.show_tension;
}

pub fn stv_principal_color(eigenvalue: f32) -> [f32; 3] {
    if eigenvalue > 0.0 {
        [1.0, 0.3, 0.3]
    } else {
        [0.3, 0.3, 1.0]
    }
}

pub fn stv_is_enabled(v: &StressTensorView) -> bool {
    v.enabled
}

pub fn stv_to_json(v: &StressTensorView) -> String {
    format!(
        r#"{{"enabled":{},"glyph_scale":{:.4},"show_compression":{},"show_tension":{}}}"#,
        v.enabled, v.glyph_scale, v.show_compression, v.show_tension
    )
}

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

    #[test]
    fn test_new_defaults() {
        /* disabled, scale=1, both on */
        let v = new_stress_tensor_view();
        assert!(!v.enabled);
        assert!((v.glyph_scale - 1.0).abs() < 1e-6);
        assert!(v.show_compression);
        assert!(v.show_tension);
    }

    #[test]
    fn test_set_glyph_scale() {
        /* valid scale */
        let mut v = new_stress_tensor_view();
        stv_set_glyph_scale(&mut v, 2.0);
        assert!((v.glyph_scale - 2.0).abs() < 1e-6);
    }

    #[test]
    fn test_set_glyph_scale_min() {
        /* minimum 0 */
        let mut v = new_stress_tensor_view();
        stv_set_glyph_scale(&mut v, -1.0);
        assert_eq!(v.glyph_scale, 0.0);
    }

    #[test]
    fn test_enable() {
        /* enable sets flag */
        let mut v = new_stress_tensor_view();
        stv_enable(&mut v);
        assert!(stv_is_enabled(&v));
    }

    #[test]
    fn test_toggle_compression() {
        /* toggle flips flag */
        let mut v = new_stress_tensor_view();
        stv_toggle_compression(&mut v);
        assert!(!v.show_compression);
    }

    #[test]
    fn test_toggle_tension() {
        /* toggle flips flag */
        let mut v = new_stress_tensor_view();
        stv_toggle_tension(&mut v);
        assert!(!v.show_tension);
    }

    #[test]
    fn test_principal_color_tension() {
        /* positive eigenvalue -> reddish */
        let c = stv_principal_color(0.5);
        assert!(c[0] > c[2]);
    }

    #[test]
    fn test_principal_color_compression() {
        /* negative eigenvalue -> bluish */
        let c = stv_principal_color(-0.5);
        assert!(c[2] > c[0]);
    }

    #[test]
    fn test_to_json() {
        /* JSON has glyph_scale */
        let v = new_stress_tensor_view();
        assert!(stv_to_json(&v).contains("glyph_scale"));
    }

    #[test]
    fn test_clone() {
        /* clone is independent */
        let v = new_stress_tensor_view();
        let v2 = v.clone();
        assert_eq!(v.glyph_scale, v2.glyph_scale);
    }
}