rasters 0.8.0

Raster processing library
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

use super::{mod_ceil, ChunkConfig};

/// Constructors
impl ChunkConfig {
    /// Construct a `ChunkConfig` with a given raster size.
    pub fn with_dims(width: usize, height: usize) -> Self {
        if width < 1 || height < 1 {
            panic!("dimensions must both be at least 1");
        }
        ChunkConfig {
            width,
            height,

            block_size: 1,
            data_height: 1,
            padding: 0,

            start: 0,
            end: height,
        }
    }

    #[cfg(feature = "gdal")]
    /// Construct a `ChunkConfig` from a raster [`Dataset`],
    /// reading the size from it. An optional list of bands
    /// may be specified to configure the `block_size`.
    pub fn for_dataset<I: IntoIterator<Item = isize>>(
        ds: &gdal::Dataset,
        bands: Option<I>,
    ) -> crate::Result<Self> {
        use anyhow::Context;
        let size = ds.raster_size();
        let mut cfg = ChunkConfig::with_dims(size.0, size.1);

        if let Some(bands) = bands {
            for band_idx in bands {
                let band = ds
                    .rasterband(band_idx)
                    .with_context(|| format!("unable to open rasterband {}", band_idx))?;
                cfg = cfg.add_block_size(band.block_size().1);
            }
        }

        Ok(cfg)
    }
}

/// Builder methods to configure the parameters
impl ChunkConfig {
    /// Accumulate the given `block_size` to the
    /// configuration by calculating the least common
    /// multiple with the current value.
    pub fn add_block_size(mut self, block_size: usize) -> Self {
        if block_size < 1 {
            panic!("block_size should be at least 1");
        }
        self.block_size = lcm(self.block_size, block_size);
        self.adjust_block_height();
        self
    }
    /// Set the minimum `data_height` for the chunking. The
    /// actual `data_height` is the least multiple of
    /// `block_size` larger or equal to the given value.
    pub fn with_min_data_height(mut self, min_data_height: usize) -> Self {
        self.data_height = min_data_height.max(1);
        self.adjust_block_height();
        self
    }
    /// Set the minimum `data_height` by specifying minimum
    /// number of data pixels expected in each chunk.
    pub fn with_min_data_size(self, min_data_size: usize) -> Self {
        let min_height = (min_data_size + self.width - 1) / self.width;
        self.with_min_data_height(min_height)
    }

    /// Set the padding required for each chunk.
    pub fn with_padding(mut self, padding: usize) -> Self {
        self.padding = padding;
        self.adjust_start();
        self
    }

    /// Set the start index of the iteration range.
    pub fn with_start(mut self, start: usize) -> Self {
        self.start = start;
        self.adjust_start();
        self
    }

    /// Set the end (not included) index of the iteration
    /// range.
    pub fn with_end(mut self, end: usize) -> Self {
        self.end = end.min(self.height);
        self
    }

    /// Ensure that block height is non-zero, and a multiple
    /// of block size.
    #[inline]
    fn adjust_block_height(&mut self) {
        self.data_height = mod_ceil(self.data_height, self.block_size);
    }

    /// Ensure start is always greater than padding
    #[inline]
    fn adjust_start(&mut self) {
        self.start = self.start.max(self.padding);
    }
}

/// Getter methods to read the parameters of the config
impl ChunkConfig {
    pub fn width(&self) -> usize {
        self.width
    }
    pub fn height(&self) -> usize {
        self.height
    }

    pub fn block_size(&self) -> usize {
        self.block_size
    }
    pub fn data_height(&self) -> usize {
        self.data_height
    }
    pub fn padding(&self) -> usize {
        self.padding
    }

    pub fn start(&self) -> usize {
        self.start
    }
    pub fn end(&self) -> usize {
        self.end
    }
}

#[inline]
fn lcm(a: usize, b: usize) -> usize {
    a / gcd(a, b) * b
}

fn gcd(a: usize, b: usize) -> usize {
    if b == 0 {
        return a;
    }
    gcd(b, a % b)
}