oximedia-calibrate 0.1.8

Professional color calibration and matching tools for OxiMedia
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

//! Custom white balance from reference patches.
//!
//! This module provides tools for custom white balance from user-selected reference areas.

use crate::error::{CalibrationError, CalibrationResult};
use crate::Rgb;

/// Custom white balance from a reference patch.
pub struct CustomWhiteBalance;

impl CustomWhiteBalance {
    /// Compute white balance from a reference gray/white patch.
    ///
    /// # Arguments
    ///
    /// * `patch_rgb` - Average RGB color of the reference patch
    ///
    /// # Errors
    ///
    /// Returns an error if the patch color is invalid.
    pub fn from_gray_patch(patch_rgb: &Rgb) -> CalibrationResult<[f64; 3]> {
        // Check that patch is not too dark
        let luminance = (patch_rgb[0] + patch_rgb[1] + patch_rgb[2]) / 3.0;

        if luminance < 0.1 {
            return Err(CalibrationError::WhiteBalanceFailed(
                "Reference patch is too dark".to_string(),
            ));
        }

        // Use the maximum channel as reference
        let max_channel = patch_rgb[0].max(patch_rgb[1]).max(patch_rgb[2]);

        if max_channel < 1e-10 {
            return Err(CalibrationError::WhiteBalanceFailed(
                "Reference patch is black".to_string(),
            ));
        }

        Ok([
            max_channel / patch_rgb[0],
            max_channel / patch_rgb[1],
            max_channel / patch_rgb[2],
        ])
    }

    /// Compute white balance from a manually specified white point.
    ///
    /// # Arguments
    ///
    /// * `white_point` - Desired white point RGB values
    #[must_use]
    pub fn from_white_point(white_point: &Rgb) -> [f64; 3] {
        let max_channel = white_point[0].max(white_point[1]).max(white_point[2]);

        if max_channel < 1e-10 {
            return [1.0, 1.0, 1.0];
        }

        [
            max_channel / white_point[0],
            max_channel / white_point[1],
            max_channel / white_point[2],
        ]
    }

    /// Apply custom white balance to an RGB color.
    #[must_use]
    pub fn apply(multipliers: &[f64; 3], rgb: &Rgb) -> Rgb {
        [
            (rgb[0] * multipliers[0]).clamp(0.0, 1.0),
            (rgb[1] * multipliers[1]).clamp(0.0, 1.0),
            (rgb[2] * multipliers[2]).clamp(0.0, 1.0),
        ]
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_from_gray_patch_neutral() {
        let patch = [0.5, 0.5, 0.5];
        let result = CustomWhiteBalance::from_gray_patch(&patch);

        assert!(result.is_ok());
        let mult = result.expect("expected successful result");

        assert!((mult[0] - 1.0).abs() < 1e-10);
        assert!((mult[1] - 1.0).abs() < 1e-10);
        assert!((mult[2] - 1.0).abs() < 1e-10);
    }

    #[test]
    fn test_from_gray_patch_warm() {
        let patch = [0.6, 0.5, 0.4];
        let result = CustomWhiteBalance::from_gray_patch(&patch);

        assert!(result.is_ok());
        let mult = result.expect("expected successful result");

        // Should boost blue and green relative to red
        assert!(mult[0] < mult[2]);
    }

    #[test]
    fn test_from_gray_patch_too_dark() {
        let patch = [0.05, 0.05, 0.05];
        let result = CustomWhiteBalance::from_gray_patch(&patch);

        assert!(result.is_err());
    }

    #[test]
    fn test_from_white_point() {
        let white_point = [1.0, 1.0, 1.0];
        let mult = CustomWhiteBalance::from_white_point(&white_point);

        assert!((mult[0] - 1.0).abs() < 1e-10);
        assert!((mult[1] - 1.0).abs() < 1e-10);
        assert!((mult[2] - 1.0).abs() < 1e-10);
    }

    #[test]
    fn test_apply() {
        let multipliers = [1.2, 1.0, 0.8];
        let rgb = [0.5, 0.5, 0.5];
        let result = CustomWhiteBalance::apply(&multipliers, &rgb);

        assert!((result[0] - 0.6).abs() < 1e-10);
        assert!((result[1] - 0.5).abs() < 1e-10);
        assert!((result[2] - 0.4).abs() < 1e-10);
    }
}