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

//! Utilities to compute histogram

use serde_derive::Serialize;

/// Configuration to generate histogram. Can be constructed
/// from min, max and either step-size or number of bins.
#[derive(Debug, PartialEq, Clone, Serialize)]
pub struct Config {
    min: f64,
    max: f64,
    step: f64,
    len: usize,
}

impl Config {
    pub fn from_min_max_step(min: f64, max: f64, step: f64) -> Self {
        assert!(min <= max, "min must be smaller than max");
        let len = ((max - min) / step).ceil() as usize;
        Config {
            min,
            max,
            step,
            len,
        }
    }
    pub fn from_min_max_bins(min: f64, max: f64, len: usize) -> Self {
        assert!(min <= max, "min must be smaller than max");
        let step = (max - min) / len as f64;
        Config {
            min,
            max,
            step,
            len,
        }
    }

    #[inline]
    pub fn len(&self) -> usize {
        self.len
    }

    #[inline]
    pub fn step(&self) -> f64 {
        self.step
    }

    #[inline]
    pub fn max(&self) -> f64 {
        self.max
    }

    #[inline]
    pub fn min(&self) -> f64 {
        self.min
    }

    #[inline]
    pub fn bin_for(&self, val: f64) -> HistBin {
        use HistBin::*;
        if val >= self.max {
            Max
        } else if val < self.min {
            Min
        } else {
            let bin = ((val - self.min) / self.step).floor() as usize;
            if bin >= self.len {
                Max
            } else {
                Bin(bin)
            }
        }
    }
}

/// Represent the location of a value with respect to a
/// histogram configuration.
#[derive(Debug)]
pub enum HistBin {
    Min,
    Max,
    Bin(usize),
}

/// A histogram that can be built by accumulating individual
/// values, or other histograms.
#[derive(Debug, Clone, Serialize)]
pub struct Histogram<'a> {
    cfg: &'a Config,
    hist: Vec<usize>,
    min: usize,
    max: usize,
    count: usize,
}
impl<'a> Histogram<'a> {
    pub fn new(cfg: &'a Config) -> Self {
        Histogram {
            cfg,
            hist: vec![0; cfg.len()],
            min: 0,
            max: 0,
            count: 0,
        }
    }
}

use std::ops::AddAssign;
impl<'a, 'b> AddAssign<Histogram<'b>> for Histogram<'a> {
    fn add_assign(&mut self, other: Histogram<'b>) {
        assert!(
            self.cfg == other.cfg,
            "adding histogram with a different config"
        );
        for (a, b) in self.hist.iter_mut().zip(other.hist.iter()) {
            *a += *b;
        }
        self.min += other.min;
        self.max += other.max;
        self.count += other.count;
    }
}
impl<'a> AddAssign<f64> for Histogram<'a> {
    fn add_assign(&mut self, other: f64) {
        use HistBin::*;
        match self.cfg.bin_for(other) {
            Min => {
                self.min += 1;
            }
            Max => {
                self.max += 1;
            }
            Bin(bin) => {
                self.hist[bin] += 1;
            }
        }
        self.count += 1;
    }
}