vtk-pure-rs 0.2.0

Pure Rust visualization toolkit — data structures, filters, I/O, rendering
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

use crate::data::{CellArray, PolyData};

/// Convert all polygons to triangles using fan triangulation.
///
/// Triangles pass through unchanged. Quads and larger polygons are decomposed
/// into triangle fans from the first vertex. Triangle strips are also decomposed.
pub fn triangulate(input: &PolyData) -> PolyData {
    // Fast path: if already all triangles and no strips, just clone
    let has_strips = !input.strips.is_empty();
    let all_tri = input.polys.is_empty() || input.polys.iter().all(|c| c.len() == 3);
    if all_tri && !has_strips {
        return input.clone();
    }

    let mut output = input.clone();

    // Triangulate polygons
    if !input.polys.is_empty() {
        output.polys = triangulate_cells(&input.polys);
    }

    // Decompose triangle strips
    if has_strips {
        let tri_from_strips = decompose_strips(&input.strips);
        // Append strip-derived triangles to polys
        for cell in tri_from_strips.iter() {
            output.polys.push_cell(cell);
        }
        output.strips = CellArray::new();
    }

    output
}

fn triangulate_cells(polys: &CellArray) -> CellArray {
    // Fast path: if all cells are already triangles, return a clone directly.
    // This matches VTK's TriangleFilter behavior which is a no-op on triangle meshes.
    let all_triangles = polys.iter().all(|cell| cell.len() == 3);
    if all_triangles {
        return polys.clone();
    }

    let mut out = CellArray::new();

    for cell in polys.iter() {
        if cell.len() < 3 {
            // Degenerate, skip
            continue;
        }
        if cell.len() == 3 {
            // Already a triangle
            out.push_cell(cell);
        } else {
            // Fan triangulation from vertex 0
            for i in 1..cell.len() - 1 {
                out.push_cell(&[cell[0], cell[i], cell[i + 1]]);
            }
        }
    }

    out
}

fn decompose_strips(strips: &CellArray) -> CellArray {
    let mut out = CellArray::new();

    for strip in strips.iter() {
        if strip.len() < 3 {
            continue;
        }
        for i in 0..strip.len() - 2 {
            if i % 2 == 0 {
                out.push_cell(&[strip[i], strip[i + 1], strip[i + 2]]);
            } else {
                // Flip winding for odd triangles to maintain consistent orientation
                out.push_cell(&[strip[i + 1], strip[i], strip[i + 2]]);
            }
        }
    }

    out
}

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

    #[test]
    fn triangle_passthrough() {
        let pd = PolyData::from_triangles(
            vec![[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]],
            vec![[0, 1, 2]],
        );
        let result = triangulate(&pd);
        assert_eq!(result.polys.num_cells(), 1);
        assert_eq!(result.polys.cell(0), &[0, 1, 2]);
    }

    #[test]
    fn quad_to_triangles() {
        let mut pd = PolyData::new();
        pd.points = crate::data::Points::from_vec(vec![
            [0.0, 0.0, 0.0],
            [1.0, 0.0, 0.0],
            [1.0, 1.0, 0.0],
            [0.0, 1.0, 0.0],
        ]);
        pd.polys.push_cell(&[0, 1, 2, 3]);

        let result = triangulate(&pd);
        assert_eq!(result.polys.num_cells(), 2);
        assert_eq!(result.polys.cell(0), &[0, 1, 2]);
        assert_eq!(result.polys.cell(1), &[0, 2, 3]);
    }

    #[test]
    fn strip_decomposition() {
        let mut pd = PolyData::new();
        pd.points = crate::data::Points::from_vec(vec![
            [0.0, 0.0, 0.0],
            [1.0, 0.0, 0.0],
            [0.5, 1.0, 0.0],
            [1.5, 1.0, 0.0],
        ]);
        pd.strips.push_cell(&[0, 1, 2, 3]);

        let result = triangulate(&pd);
        assert!(result.strips.is_empty());
        assert_eq!(result.polys.num_cells(), 2);
    }
}