appthere-color 0.1.1

Document-aware color management for Rust — pure Rust ICC transforms, CMYK, soft proofing, and print-ready color policies
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

use appthere_color::{ColorTransform, IccProfile, RenderingIntent};

#[test]
fn srgb_to_adobe_rgb_round_trip() {
    let srgb = IccProfile::new_srgb();
    let adobe = IccProfile::new_adobe_rgb();

    let forward = ColorTransform::builder()
        .source(&srgb)
        .destination(&adobe)
        .intent(RenderingIntent::RelativeColorimetric)
        .build()
        .unwrap();

    let backward = ColorTransform::builder()
        .source(&adobe)
        .destination(&srgb)
        .intent(RenderingIntent::RelativeColorimetric)
        .build()
        .unwrap();

    let original = [0.8_f32, 0.3, 0.5];
    let mut intermediate = [0.0_f32; 3];
    let mut round_trip = [0.0_f32; 3];

    forward.transform(&original, &mut intermediate).unwrap();
    backward.transform(&intermediate, &mut round_trip).unwrap();

    // Round-trip delta must be within 1/255 per channel for 8-bit equivalence
    let tolerance = 1.0 / 255.0;
    for (orig, rt) in original.iter().zip(round_trip.iter()) {
        assert!(
            (orig - rt).abs() <= tolerance,
            "round-trip delta too large: orig={orig}, rt={rt}, delta={}",
            (orig - rt).abs()
        );
    }
}

#[test]
fn srgb_to_display_p3_transform() {
    let srgb = IccProfile::new_srgb();
    let p3 = IccProfile::new_display_p3();

    let xform = ColorTransform::builder()
        .source(&srgb)
        .destination(&p3)
        .intent(RenderingIntent::Perceptual)
        .build()
        .unwrap();

    let input = [0.5_f32, 0.5, 0.5];
    let mut output = [0.0_f32; 3];
    xform.transform(&input, &mut output).unwrap();

    // Mid-gray should remain close to mid-gray
    let tolerance = 0.05;
    for val in &output {
        assert!(
            (*val - 0.5).abs() < tolerance,
            "mid-gray shifted too far: {val}"
        );
    }
}

#[test]
fn transform_channel_counts() {
    let srgb = IccProfile::new_srgb();
    let adobe = IccProfile::new_adobe_rgb();

    let xform = ColorTransform::builder()
        .source(&srgb)
        .destination(&adobe)
        .build()
        .unwrap();

    assert_eq!(xform.source_channels(), 3);
    assert_eq!(xform.destination_channels(), 3);
}

#[test]
fn all_rendering_intents_build() {
    let srgb = IccProfile::new_srgb();
    let adobe = IccProfile::new_adobe_rgb();

    let intents = [
        RenderingIntent::Perceptual,
        RenderingIntent::RelativeColorimetric,
        RenderingIntent::Saturation,
        RenderingIntent::AbsoluteColorimetric,
    ];

    for intent in intents {
        let xform = ColorTransform::builder()
            .source(&srgb)
            .destination(&adobe)
            .intent(intent)
            .build();
        assert!(xform.is_ok(), "failed to build with intent {:?}", intent);
    }
}

#[test]
fn gray_to_srgb_transform() {
    let gray = IccProfile::new_gray(2.2);
    let srgb = IccProfile::new_srgb();

    let xform = ColorTransform::builder()
        .source(&gray)
        .destination(&srgb)
        .build()
        .unwrap();

    assert_eq!(xform.source_channels(), 1);
    assert_eq!(xform.destination_channels(), 3);

    // Pure white in gray should map to white in sRGB
    let input = [1.0_f32];
    let mut output = [0.0_f32; 3];
    xform.transform(&input, &mut output).unwrap();

    let tolerance = 0.05;
    for val in &output {
        assert!(
            (*val - 1.0).abs() < tolerance,
            "white gray should map to white sRGB: {val}"
        );
    }
}