thermal 0.3.1

Process thermal images from FLIR cameras
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

//! Utilities to accumulate first and second moments; min;
//! and max of a `f64` statistic incrementally.
use serde_derive::Serialize;
use std::ops::AddAssign;

/// Stores the statistics collected from a `f64` random
/// variable. Accumulation of the statistic is done by
/// add-assigning (using `+=`) one of the following.
///
/// - a `f64` value.  Adds a new sample
/// - a `(f64, f64)` tuple.  Adds the first component with weight specified by the second component.
/// - another `PixelStats` value.  Accumulates the statistic from the other into `self`.
#[derive(Debug, Serialize, Clone)]
pub struct Stats {
    max: f64,
    min: f64,
    sum: f64,
    sum_2: f64,
    count: f64,
}

impl Default for Stats {
    fn default() -> Self {
        use std::f64::*;
        Stats {
            max: NEG_INFINITY,
            min: INFINITY,
            sum: 0.,
            sum_2: 0.,
            count: 0.,
        }
    }
}
impl AddAssign<(f64, f64)> for Stats {
    fn add_assign(&mut self, other: (f64, f64)) {
        self.max = self.max.max(other.0);
        self.min = self.min.min(other.0);
        self.sum += other.0;
        self.sum_2 += other.0 * other.0;
        self.count += other.1;
    }
}

impl AddAssign<f64> for Stats {
    fn add_assign(&mut self, other: f64) {
        *self += (other, 1.);
    }
}
impl AddAssign<&Stats> for Stats {
    fn add_assign(&mut self, other: &Stats) {
        self.max = self.max.max(other.max);
        self.min = self.min.min(other.min);
        self.sum += other.sum;
        self.sum_2 += other.sum_2;
        self.count += other.count;
    }
}

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

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

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

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

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

    #[inline]
    pub fn mean(&self) -> f64 {
        self.sum / self.count
    }

    #[inline]
    pub fn variance(&self) -> f64 {
        self.sum_2 / self.count - self.mean().powi(2)
    }

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