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
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

mod args;

use anyhow::Result;
use args::Args;
use rayon::iter::{IntoParallelIterator, ParallelIterator};
use serde_derive::*;

use thermal::cli::{process_paths_par, GenericImage};
use thermal::dji::RJpeg;
use thermal::{image::ThermalImage, stats::Stats};

fn main() -> Result<()> {
    let args = Args::from_cmd_line()?;

    use rayon::prelude::*;

    let Args {
        paths,
        distance,
        is_json,
    } = args;

    let (stats, cumulative) = process_paths_par(paths, is_json)
        .into_par_iter()
        .map(|try_img| -> Result<_> {
            let img = try_img?;
            Ok(ImageStats::from_thermal_image(
                &img.image,
                distance,
                img.filename,
            ))
        })
        .try_fold(
            || (vec![], Stats::default()),
            |mut acc, try_img| -> Result<_> {
                let item = try_img?;
                acc.0.push(item);
                acc.1 += &acc.0.last().unwrap().stats;
                Ok(acc)
            },
        )
        .try_reduce(
            || (vec![], Stats::default()),
            |mut acc1, acc2| -> Result<_> {
                acc1.0.extend(acc2.0);
                acc1.1 += &acc2.1;
                Ok(acc1)
            },
        )?;

    use serde_derive::*;
    #[derive(Debug, Serialize)]
    struct OutputJson {
        image_stats: Vec<ImageStats>,
        cumulative: Stats,
    }

    serde_json::to_writer(
        std::io::stdout().lock(),
        &OutputJson {
            image_stats: stats,
            cumulative,
        },
    )?;

    Ok(())
}

#[derive(Serialize, Debug)]
pub struct ImageStats {
    path: String,
    width: usize,
    height: usize,
    pub(crate) stats: Stats,
}

impl ImageStats {
    pub fn from_thermal_image(thermal: &GenericImage, distance: f64, path: String) -> Self {
        use itertools::Either;
        match thermal {
            Either::Left(ti) => Self::from_flir_image(ti, distance, path),
            Either::Right(dji) => Self::from_dji_image(dji, distance, path),
        }
    }

    pub fn from_dji_image(rjpeg: &RJpeg, _distance: f64, path: String) -> Self {
        let values = rjpeg.temperatures().unwrap();
        let (ht, wid) = values.dim();
        let stats = values
            .into_par_iter()
            .fold(Stats::default, |mut acc, val| {
                acc += *val as f64;
                acc
            })
            .reduce(Stats::default, |mut acc, val| {
                acc += &val;
                acc
            });

        ImageStats {
            width: wid,
            height: ht,
            path,
            stats,
        }
    }

    pub fn from_flir_image(thermal: &ThermalImage, distance: f64, path: String) -> Self {
        let temp_t = thermal.settings.temperature_transform(distance);
        let (ht, wid) = thermal.image.dim();

        let mut stats = Stats::default();
        for row in 0..ht {
            for col in 0..wid {
                let raw = thermal.image[(row, col)] as f64;
                let temp = temp_t(raw);
                stats += temp;
            }
        }
        ImageStats {
            width: wid,
            height: ht,
            path,
            stats,
        }
    }
}