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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use rayon::prelude::*;
use crate::data::{DataArray, DataSet, PolyData};

/// Compute an elevation scalar for each point, measuring distance along an axis.
///
/// The scalar is the projection of each point onto the line from `low_point` to
/// `high_point`. Values are in `[0, 1]` if points lie between the two endpoints.
pub fn elevation(
    input: &PolyData,
    low_point: [f64; 3],
    high_point: [f64; 3],
) -> PolyData {
    let mut output = input.clone();

    let dir = [
        high_point[0] - low_point[0],
        high_point[1] - low_point[1],
        high_point[2] - low_point[2],
    ];
    let len2 = dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2];
    let inv_len2 = if len2 > 1e-20 { 1.0 / len2 } else { 0.0 };

    // Direct flat slice access + precomputed inverse avoids per-point overhead.
    let pts = input.points.as_flat_slice();
    let n = input.points.len();
    let mut values = Vec::with_capacity(n);

    for i in 0..n {
        let base = i * 3;
        let dx = pts[base]     - low_point[0];
        let dy = pts[base + 1] - low_point[1];
        let dz = pts[base + 2] - low_point[2];
        values.push((dx * dir[0] + dy * dir[1] + dz * dir[2]) * inv_len2);
    }

    let scalars = DataArray::<f64>::from_vec("Elevation", values, 1);
    output.point_data_mut().add_array(scalars.into());
    output.point_data_mut().set_active_scalars("Elevation");
    output
}

/// Parallel version of `elevation` using rayon.
pub fn elevation_par(
    input: &PolyData,
    low_point: [f64; 3],
    high_point: [f64; 3],
) -> PolyData {
    let mut output = input.clone();

    let dir = [
        high_point[0] - low_point[0],
        high_point[1] - low_point[1],
        high_point[2] - low_point[2],
    ];
    let len2 = dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2];

    let values: Vec<f64> = (0..input.num_points())
        .into_par_iter()
        .map(|i| {
            let p = input.point(i);
            let dp = [
                p[0] - low_point[0],
                p[1] - low_point[1],
                p[2] - low_point[2],
            ];
            if len2 > 1e-20 {
                (dp[0] * dir[0] + dp[1] * dir[1] + dp[2] * dir[2]) / len2
            } else {
                0.0
            }
        })
        .collect();

    let scalars = DataArray::<f64>::from_vec("Elevation", values, 1);
    output.point_data_mut().add_array(scalars.into());
    output.point_data_mut().set_active_scalars("Elevation");
    output
}

/// Convenience: compute elevation along the Z axis using the data's bounding box.
pub fn elevation_z(input: &PolyData) -> PolyData {
    let bb = input.bounds();
    elevation(
        input,
        [0.0, 0.0, bb.z_min],
        [0.0, 0.0, bb.z_max],
    )
}

/// Convenience: compute elevation along the Y axis using the data's bounding box.
pub fn elevation_y(input: &PolyData) -> PolyData {
    let bb = input.bounds();
    elevation(
        input,
        [0.0, bb.y_min, 0.0],
        [0.0, bb.y_max, 0.0],
    )
}

/// Convenience: compute elevation along the X axis using the data's bounding box.
pub fn elevation_x(input: &PolyData) -> PolyData {
    let bb = input.bounds();
    elevation(
        input,
        [bb.x_min, 0.0, 0.0],
        [bb.x_max, 0.0, 0.0],
    )
}

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

    #[test]
    fn elevation_along_z() {
        let pd = PolyData::from_triangles(
            vec![[0.0, 0.0, 0.0], [1.0, 0.0, 5.0], [0.0, 1.0, 10.0]],
            vec![[0, 1, 2]],
        );

        let result = elevation(&pd, [0.0, 0.0, 0.0], [0.0, 0.0, 10.0]);
        let scalars = result.point_data().scalars().unwrap();

        let mut buf = [0.0f64];
        scalars.tuple_as_f64(0, &mut buf);
        assert!((buf[0] - 0.0).abs() < 1e-10);

        scalars.tuple_as_f64(1, &mut buf);
        assert!((buf[0] - 0.5).abs() < 1e-10);

        scalars.tuple_as_f64(2, &mut buf);
        assert!((buf[0] - 1.0).abs() < 1e-10);
    }

    #[test]
    fn elevation_z_auto() {
        let pd = PolyData::from_triangles(
            vec![[0.0, 0.0, 0.0], [1.0, 0.0, 5.0], [0.0, 1.0, 10.0]],
            vec![[0, 1, 2]],
        );

        let result = elevation_z(&pd);
        let scalars = result.point_data().scalars().unwrap();

        let mut buf = [0.0f64];
        scalars.tuple_as_f64(0, &mut buf);
        assert!((buf[0] - 0.0).abs() < 1e-10);

        scalars.tuple_as_f64(2, &mut buf);
        assert!((buf[0] - 1.0).abs() < 1e-10);
    }
}