cmx 0.2.0

Rust Spectral Color Management Library
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

// SPDX-License-Identifier: Apache-2.0 OR MIT
// Copyright (c) 2021-2026, Harbers Bik LLC

use serde::Serialize;
use zerocopy::{BigEndian, Immutable, IntoBytes, Unaligned, U16, U32};

use super::CurveData;

#[derive(Serialize)]
pub struct CurveType {
    #[serde(skip_serializing_if = "Option::is_none")]
    points: Option<Vec<u16>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    gamma: Option<f64>,
}

impl From<&CurveData> for CurveType {
    fn from(curve: &CurveData) -> Self {
        let Some(payload) = curve.0.get(12..) else {
            return CurveType {
                points: None,
                gamma: None,
            };
        };
        // chunks_exact(2) silently drops a trailing odd byte; assert alignment in debug builds.
        debug_assert_eq!(
            payload.len() % 2,
            0,
            "curveType: payload length {} is not a multiple of 2 (malformed tag)",
            payload.len()
        );
        let data: Vec<u16> = {
            // Each chunk is exactly 2 bytes (guaranteed by chunks_exact), so try_into is infallible.
            payload
                .chunks_exact(2)
                .map(|chunk| u16::from_be_bytes(chunk.try_into().unwrap()))
                .collect()
        };
        if data.len() == 1 {
            let value = data[0] as f64 / 256.0;
            CurveType {
                points: None,
                gamma: Some(crate::round_to_precision(value, 4)),
            }
        } else {
            CurveType {
                points: Some(data),
                gamma: None,
            }
        }
    }
}

#[derive(IntoBytes, Unaligned, Immutable)]
#[repr(C, packed)]
struct WriteLayout<const N: usize> {
    signature: [u8; 4],
    reserved: [u8; 4],
    count: U32<BigEndian>,
    data: [U16<BigEndian>; N],
}

impl<const N: usize> WriteLayout<N> {
    /// Creates a new `WriteLayout` with the signature 'curv' and initializes
    /// the count and data fields.
    pub fn new(data: [u16; N]) -> Self {
        let data: [U16<BigEndian>; N] = data.map(U16::<BigEndian>::new);
        Self {
            signature: super::DataSignature::CurveData.into(),
            reserved: [0; 4],
            count: U32::<BigEndian>::new(data.len() as u32),
            data,
        }
    }
}

impl CurveData {
    /// Converts a `Vec<u16>` into raw big-endian bytes and sets it as the tag's data.
    pub fn set_data<const N: usize>(&mut self, data: [u16; N]) {
        let data_bytes = WriteLayout::new(data);
        self.0 = data_bytes.as_bytes().to_vec();
    }

    /// Sets the gamma value for the curve.
    /// This will convert the gamma value to a single point curve.
    /// If the curve already has points, it will replace them with a single point.
    ///
    pub fn set_gamma(&mut self, gamma: f64) {
        let value = (gamma * 256.0).round() as u16;
        self.set_data([value]);
    }
}