dc_converter_tof/

lib.rs

use std::path::Path;
use std::sync::atomic::{AtomicI64, Ordering};

use rayon::iter::{IntoParallelRefIterator, ParallelIterator};

use tof_image::RAW_FILE_SIZE;

use crate::helper::replace_extension;
use crate::tof_image::TofImage;

pub mod helper;
mod image_meta_data;
mod tof_image;

/// Convert a raw file to infrared and depth.
///
/// * `source_file` - Path of the file to convert.
/// * `keep_name` - Keep original name instead of gray.png and depth.tiff.
/// * `alpha` - Conversion factor Alpha.
/// * `beta` - Conversion factor Beta.
pub fn convert_depth_infrared(source_file: String, keep_name: bool, alpha: f64, beta: f64) {
    let path = Path::new(&source_file);

    let depth_file;
    let infrared_file;

    if keep_name {
        infrared_file = replace_extension(&source_file, ".png");
        depth_file = replace_extension(&source_file, ".tiff");
    } else {
        // Default names:
        infrared_file = path
            .parent()
            .unwrap()
            .join("grey.png")
            .to_string_lossy()
            .to_string();
        depth_file = path
            .parent()
            .unwrap()
            .join("depth.tiff")
            .to_string_lossy()
            .to_string();
    }

    let bytes = std::fs::read(path).unwrap_or_else(|_| panic!("File '{}' not found!", source_file));
    let tof_image = convert_image_buffer(&bytes, true, true);

    // Write the files to flash:
    tof_image.write_depth_image(&depth_file);
    tof_image.write_bw_image(&infrared_file, alpha, beta);
}

pub fn convert_infrared(source_file: String, keep_name: bool, alpha: f64, beta: f64) {
    let path = Path::new(&source_file);

    let infrared_file = if keep_name {
        replace_extension(&source_file, ".png")
    } else {
        // Default names:
        path.parent()
            .unwrap()
            .join("grey.png")
            .to_string_lossy()
            .to_string()
    };

    let bytes = std::fs::read(path).unwrap_or_else(|_| panic!("File '{}' not found!", source_file));
    let tof_image = convert_image_buffer(&bytes, true, true);

    // Write the files to flash:
    tof_image.write_bw_image(&infrared_file, alpha, beta);
}

pub fn convert_depth(source_file: String, target_file: String) {
    let path = Path::new(&source_file);
    let bytes = std::fs::read(path).unwrap();

    let tof_image = convert_image_buffer(&bytes, true, false);

    // Write the files to flash:
    tof_image.write_depth_image(target_file.as_str());
}

/// Convert an image from raw to all layers. "
pub fn convert_image_buffer(
    raw_data: &[u8],
    decode_depth: bool,
    decode_infrared: bool,
) -> TofImage {
    // Check image size for Opnous 8505C:
    if raw_data.len() != RAW_FILE_SIZE {
        panic!("Byte image has wrong length!");
    }

    let mut image = TofImage::decode_image(raw_data, decode_depth, decode_infrared, false);

    if decode_infrared {
        image.get_meta_data();
    }

    image
}

/// Read an image to buffer
pub fn read_image_to_buffer(source_file: String) -> TofImage {
    let path = Path::new(&source_file);

    if !path.is_file() {
        panic!("Source must be a file!");
    }

    let bytes = std::fs::read(path).unwrap();
    convert_image_buffer(&bytes, true, true)
}

pub fn convert_folder(
    source: String,
    keep_names: bool,
    create_infrared: bool,
    depth_skip: bool,
    alpha: f64,
    beta: f64,
    overwrite: bool,
) {
    let files_to_convert = helper::find_files(source, ".raw");
    println!("Converting {} raw files.", files_to_convert.len());

    // Depth only:
    if !depth_skip && !create_infrared {
        files_to_convert.par_iter().for_each(|p| {
            if overwrite || !Path::new(&replace_extension(p, ".tiff")).exists() {
                convert_depth(p.to_string(), replace_extension(&p.to_string(), ".tiff"))
            }
        });
    // Depth and infrared:
    } else if !depth_skip && create_infrared {
        files_to_convert.par_iter().for_each(|p| {
            if overwrite
                || (!Path::new(&replace_extension(p, ".tiff")).exists()
                    || !Path::new(&replace_extension(p, ".png")).exists())
            {
                convert_depth_infrared(p.to_string(), keep_names, alpha, beta)
            }
        });
    } else if depth_skip && create_infrared {
        files_to_convert.par_iter().for_each(|p| {
            if overwrite || !Path::new(&replace_extension(p, ".png")).exists() {
                convert_infrared(p.to_string(), keep_names, alpha, beta)
            }
        });
    } else {
        println!("No conversion requested!!");
        return;
    }
}

pub fn read_folder_temperature(source: String) {
    let files_to_convert = helper::find_files(source, ".raw");
    println!("Reading {} raw files.", files_to_convert.len());

    let cnt = AtomicI64::new(0);
    let sum_ext = AtomicI64::new(0);
    let sum_int = AtomicI64::new(0);

    files_to_convert.par_iter().for_each(|p| {
        let image = read_image_to_buffer(p.to_string());
        // println!("{}", image.meta.t_int);

        // Update count and sum atomically
        cnt.fetch_add(1, Ordering::SeqCst);
        sum_ext.fetch_add(image.meta.t_ext as i64, Ordering::SeqCst);
        sum_int.fetch_add(image.meta.t_int as i64, Ordering::SeqCst);
    });

    // If you need to use the final values of `cnt` and `sum`
    let cnt_value = cnt.load(Ordering::SeqCst) as f32;
    let sum_ext_value = sum_ext.load(Ordering::SeqCst) as f32;
    let sum_int_value = sum_int.load(Ordering::SeqCst) as f32;

    println!(
        "Average temperature: Ext: {} Int: {}",
        sum_ext_value / cnt_value,
        sum_int_value / cnt_value
    );
}

pub fn read_file_temperature(file: String) {
    let image = read_image_to_buffer(file);
    println!(
        "File temperature: Ext: {} Int: {}",
        image.meta.t_ext, image.meta.t_int
    );
}

#[cfg(test)]
mod tests {
    use std::fs;
    use std::path::Path;

    use crate::{
        convert_depth_infrared, convert_folder, convert_image_buffer, read_image_to_buffer,
    };

    #[test]
    #[should_panic]
    fn wrong_raw_image_size() {
        let v: Vec<u8> = vec![0, 1, 2];
        convert_image_buffer(&v, true, true);
    }

    #[test]
    fn convert_raw_image() {
        convert_depth_infrared("./data/data_hot.raw".to_string(), true, 0.1, 0.2);
    }

    #[test]
    fn get_temperatures() {
        let image_hot = read_image_to_buffer("./data/data_hot.raw".to_string());
        assert_eq!(image_hot.meta.t_int, 71);
        assert_eq!(image_hot.meta.t_ext, 51);
        assert_eq!(image_hot.meta.exposure_time, 60000);

        let image_cold = read_image_to_buffer("./data/data_cold.raw".to_string());
        assert_eq!(image_cold.meta.t_int, 60);
        assert_eq!(image_cold.meta.t_ext, 43);
        assert_eq!(image_cold.meta.exposure_time, 60000);
    }

    #[test]
    fn test_depth() {
        let tof_image = read_image_to_buffer("./data/data_hot.raw".to_string());
        let mut depth_sum: u32 = 0;

        // TODO: Use map, check all!
        for d in tof_image.depth_image {
            depth_sum += d as u32;
        }
        assert_eq!(depth_sum, 63723279);

        let mut infrared_sum: u32 = 0;
        for i in tof_image.infrared_image {
            infrared_sum += i as u32;
        }
        assert_eq!(infrared_sum, 36893926);
    }

    #[test]
    fn test_not_overwrite() {
        // Don't care when not exists:
        let _ = fs::remove_file("./data/data_cold.png");
        convert_folder("./data/".to_string(), true, true, false, 0.1, 0.2, false);

        assert!(Path::new("./data/data_cold.png").exists());

        // Don't care when not exists:
        let _ = fs::remove_file("./data/data_cold.tiff");
        convert_folder("./data/".to_string(), true, false, false, 0.1, 0.2, false);

        assert!(Path::new("./data/data_cold.tiff").exists());
    }
}