refimage 1.0.0-pre6

Imaging library. Provides image storage using CoW-like structures to avoid re-allocation in image-aquisition scenarios. Supports rich metadata and serdes.
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

#[cfg(feature = "rayon")]
use rayon::{iter::ParallelIterator, slice::ParallelSliceMut};

use crate::{
    demosaic::ColorFilterArray, BayerError, BayerPattern, ColorSpace, ImageError, PixelStor,
    PixelType,
};

impl TryFrom<i8> for PixelType {
    type Error = ImageError;

    fn try_from(value: i8) -> Result<Self, Self::Error> {
        match value {
            8 => Ok(Self::U8),
            10 => Ok(Self::U10),
            12 => Ok(Self::U12),
            14 => Ok(Self::U14),
            16 => Ok(Self::U16),
            -32 => Ok(Self::F32),
            other => Err(ImageError::InvalidPixelType(other)),
        }
    }
}

impl TryFrom<ColorSpace> for ColorFilterArray {
    type Error = BayerError;

    fn try_from(value: ColorSpace) -> Result<ColorFilterArray, Self::Error> {
        match value {
            ColorSpace::Bayer(pat) => Ok(match pat {
                BayerPattern::Bggr => ColorFilterArray::Bggr,
                BayerPattern::Gbrg => ColorFilterArray::Gbrg,
                BayerPattern::Grbg => ColorFilterArray::Grbg,
                BayerPattern::Rggb => ColorFilterArray::Rggb,
            }),
            other => Err(BayerError::InvalidColorSpace(other)),
        }
    }
}

#[allow(clippy::from_over_into)]
impl Into<ColorSpace> for BayerPattern {
    fn into(self) -> ColorSpace {
        ColorSpace::Bayer(self)
    }
}

/// Run the luminance conversion on a slice of pixel data.
///
/// The caller (the pipeline) guarantees `channels == wts.len()`.
pub(crate) fn run_luma<T: PixelStor>(channels: usize, len: usize, data: &mut [T], wts: &[f64]) {
    debug_assert_eq!(channels, wts.len());
    #[cfg(not(feature = "rayon"))]
    {
        let len = len / channels;
        for i in 0..len {
            let v = T::from_f64(
                data[i * channels..(i + 1) * channels]
                    .iter()
                    .zip(wts.iter())
                    .fold(0f64, |acc, (px, &w)| acc + (*px).to_f64() * w),
            );
            data[i] = v;
        }
    }
    #[cfg(feature = "rayon")]
    {
        if len > 1024 * 1024 {
            // for large images, use parallel processing
            data[..len]
                .par_chunks_exact_mut(channels)
                .for_each(|chunk| {
                    let v = T::from_f64(
                        chunk
                            .iter()
                            .zip(wts.iter())
                            .fold(0f64, |acc, (px, &w)| acc + (*px).to_f64() * w),
                    );
                    chunk[0] = v;
                });
            let len = len / channels;
            for i in 0..len {
                data[i] = data[i * channels];
            }
        } else {
            // for small images, use sequential processing
            let len = len / channels;
            for i in 0..len {
                let v = T::from_f64(
                    data[i * channels..(i + 1) * channels]
                        .iter()
                        .zip(wts.iter())
                        .fold(0f64, |acc, (px, &w)| acc + (*px).to_f64() * w),
                );
                data[i] = v;
            }
        }
    }
}

impl ColorSpace {
    /// Check if the color space is a Bayer pattern.
    pub fn is_bayer(&self) -> bool {
        matches!(self, Self::Bayer(_))
    }
}