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

use crate::data::{AnyDataArray, DataArray, ImageData};

/// Threshold an ImageData scalar field, replacing values outside [lower, upper]
/// with a replacement value.
///
/// Modifies the named scalar array in-place. Values inside the range are
/// kept; values outside are set to `replacement`.
pub fn image_threshold(
    input: &ImageData,
    scalars: &str,
    lower: f64,
    upper: f64,
    replacement: f64,
) -> ImageData {
    let arr = match input.point_data().get_array(scalars) {
        Some(a) => a,
        None => return input.clone(),
    };

    let n = arr.num_tuples();
    let mut values = vec![0.0f64; n];
    let mut buf = [0.0f64];
    for i in 0..n {
        arr.tuple_as_f64(i, &mut buf);
        values[i] = if buf[0] >= lower && buf[0] <= upper {
            buf[0]
        } else {
            replacement
        };
    }

    let mut img = input.clone();
    // Replace the array
    let mut new_attrs = crate::data::DataSetAttributes::new();
    for i in 0..input.point_data().num_arrays() {
        let a = input.point_data().get_array_by_index(i).unwrap();
        if a.name() == scalars {
            new_attrs.add_array(AnyDataArray::F64(
                DataArray::from_vec(scalars, values.clone(), 1),
            ));
        } else {
            new_attrs.add_array(a.clone());
        }
    }
    *img.point_data_mut() = new_attrs;
    img
}

/// Create a binary mask from an ImageData scalar field.
///
/// Adds a "Mask" array where values in [lower, upper] are 1.0 and others 0.0.
pub fn image_binary_threshold(
    input: &ImageData,
    scalars: &str,
    lower: f64,
    upper: f64,
) -> ImageData {
    let arr = match input.point_data().get_array(scalars) {
        Some(a) => a,
        None => return input.clone(),
    };

    let n = arr.num_tuples();
    let mut mask = vec![0.0f64; n];
    let mut buf = [0.0f64];
    for i in 0..n {
        arr.tuple_as_f64(i, &mut buf);
        mask[i] = if buf[0] >= lower && buf[0] <= upper { 1.0 } else { 0.0 };
    }

    let mut img = input.clone();
    img.point_data_mut().add_array(AnyDataArray::F64(
        DataArray::from_vec("Mask", mask, 1),
    ));
    img
}

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

    fn make_image() -> ImageData {
        let mut img = ImageData::with_dimensions(3, 3, 1);
        let values: Vec<f64> = (0..9).map(|i| i as f64).collect();
        img.point_data_mut().add_array(AnyDataArray::F64(
            DataArray::from_vec("val", values, 1),
        ));
        img
    }

    #[test]
    fn threshold_range() {
        let img = make_image();
        let result = image_threshold(&img, "val", 3.0, 6.0, 0.0);
        let arr = result.point_data().get_array("val").unwrap();
        let mut buf = [0.0f64];
        arr.tuple_as_f64(0, &mut buf);
        assert_eq!(buf[0], 0.0); // below range -> replacement
        arr.tuple_as_f64(4, &mut buf);
        assert_eq!(buf[0], 4.0); // in range -> kept
        arr.tuple_as_f64(8, &mut buf);
        assert_eq!(buf[0], 0.0); // above range -> replacement
    }

    #[test]
    fn binary_mask() {
        let img = make_image();
        let result = image_binary_threshold(&img, "val", 3.0, 5.0);
        let arr = result.point_data().get_array("Mask").unwrap();
        let mut buf = [0.0f64];
        arr.tuple_as_f64(0, &mut buf);
        assert_eq!(buf[0], 0.0);
        arr.tuple_as_f64(4, &mut buf);
        assert_eq!(buf[0], 1.0);
    }

    #[test]
    fn missing_scalars() {
        let img = make_image();
        let result = image_threshold(&img, "nope", 0.0, 1.0, 0.0);
        assert!(result.point_data().get_array("val").is_some());
    }
}