mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 09:26:43 +00:00
* feat(color): Dot Gain 20%-compatible default working gray, as in Photoshop Photoshop's default working gray is Dot Gain 20%, and its RGB -> Grayscale measured in Photoshop 27.11 (default Color Settings) is D50 luminance encoded with gamma 1.732: sRGB 64 / 128 / 192 grey and pure red become 46 / 105 / 177 / 107. PhotoCraft defaulted to sGray, which kept the sRGB value (64 / 128 / 192 / 130), up to 24 levels off. Adds the built-in "Dot Gain 20%-compatible (gamma 1.732, Photocraft)" gray profile (id dot-gain-20-compat; our own fitted curve, not Adobe's profile, the same gamma PhotoCraft already uses for gray adjustments) and makes it the default working gray and the fallback for untagged gray documents. sGray and Gray Gamma 2.2 stay selectable. This changes a default: untagged gray documents now convert and display as Photoshop shows them (midtones lighter than under sGray); documents with an embedded profile are unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Status bar test: the default working gray is now Dot Gain 20%-compatible Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * .atn test: #202020 in the Dot Gain 20%-compatible working gray Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Brandon Thomas <echelon@gmail.com>
287 lines
12 KiB
Rust
287 lines
12 KiB
Rust
//! Built-in profiles. All are generated by this crate from published colorimetric definitions
|
||
//! (primaries, white points, transfer functions) and dedicated to the public domain (CC0-1.0),
|
||
//! so documents that embed them carry no licence obligations. See the crate README.
|
||
|
||
use std::sync::OnceLock;
|
||
|
||
use crate::Intent;
|
||
use crate::curve::{Curve, srgb_trc};
|
||
use crate::math::{self, Mat3};
|
||
use crate::pipeline::Stage;
|
||
use crate::profile::{ColorSpace, Lut, LutKind, Pcs, Profile, ProfileClass};
|
||
|
||
/// Copyright tag text of every built-in profile.
|
||
pub const COPYRIGHT: &str = "No copyright: CC0-1.0 public domain dedication. Generated by photocraft-cms.";
|
||
|
||
/// Identifiers of the built-in profiles.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||
pub enum Builtin {
|
||
/// sRGB IEC 61966-2.1 (Rec. 709 primaries, D65, sRGB transfer function).
|
||
Srgb,
|
||
/// Display P3 (DCI-P3 primaries, D65, sRGB transfer function).
|
||
DisplayP3,
|
||
/// Adobe RGB (1998)-compatible: its published primaries, D65, gamma 563/256.
|
||
AdobeRgbCompat,
|
||
/// ProPhoto-compatible: ROMM RGB primaries, D50, gamma 1.8.
|
||
ProPhotoCompat,
|
||
/// sRGB primaries with a linear transfer function.
|
||
LinearSrgb,
|
||
/// Rec. 2020 primaries, D65, Rec. 709 transfer function.
|
||
Rec2020,
|
||
/// Gray, gamma 2.2.
|
||
GrayGamma22,
|
||
/// Gray with the sRGB transfer function (sGray): gray `v` looks like RGB `(v, v, v)` in sRGB.
|
||
SGray,
|
||
/// Gray matching Photoshop's default working gray (Dot Gain 20 %) with our own curve: a pure
|
||
/// gamma of 1.732, fitted on Photoshop 27.11's RGB → Grayscale (sRGB 64 / 128 / 192 and pure red
|
||
/// become 46 / 105 / 177 / 107, all within 1 level). Not Adobe's profile.
|
||
DotGain20Compat,
|
||
/// CIE L*a*b* D50 identity (device Lab = PCS Lab, ICC v4 encoding).
|
||
LabD50,
|
||
/// Synthetic coated-offset CMYK (300 % total ink, medium GCR); see [`crate::synth`].
|
||
CoatedCmyk,
|
||
}
|
||
|
||
impl Builtin {
|
||
pub const ALL: [Builtin; 11] = [
|
||
Builtin::Srgb,
|
||
Builtin::DisplayP3,
|
||
Builtin::AdobeRgbCompat,
|
||
Builtin::ProPhotoCompat,
|
||
Builtin::LinearSrgb,
|
||
Builtin::Rec2020,
|
||
Builtin::GrayGamma22,
|
||
Builtin::SGray,
|
||
Builtin::DotGain20Compat,
|
||
Builtin::LabD50,
|
||
Builtin::CoatedCmyk,
|
||
];
|
||
|
||
/// Stable identifier used by commands and settings.
|
||
pub fn id(self) -> &'static str {
|
||
match self {
|
||
Builtin::Srgb => "srgb",
|
||
Builtin::DisplayP3 => "display-p3",
|
||
Builtin::AdobeRgbCompat => "adobe-rgb-compat",
|
||
Builtin::ProPhotoCompat => "prophoto-compat",
|
||
Builtin::LinearSrgb => "linear-srgb",
|
||
Builtin::Rec2020 => "rec2020",
|
||
Builtin::GrayGamma22 => "gray-gamma-2.2",
|
||
Builtin::SGray => "sgray",
|
||
Builtin::DotGain20Compat => "dot-gain-20-compat",
|
||
Builtin::LabD50 => "lab-d50",
|
||
Builtin::CoatedCmyk => "coated-cmyk",
|
||
}
|
||
}
|
||
|
||
/// Profile description (the `desc` tag).
|
||
pub fn description(self) -> &'static str {
|
||
match self {
|
||
Builtin::Srgb => "sRGB IEC61966-2.1",
|
||
Builtin::DisplayP3 => "Display P3",
|
||
Builtin::AdobeRgbCompat => "Adobe RGB (1998)-compatible (Photocraft)",
|
||
Builtin::ProPhotoCompat => "ProPhoto RGB-compatible (ROMM primaries, Photocraft)",
|
||
Builtin::LinearSrgb => "Linear sRGB (Photocraft)",
|
||
Builtin::Rec2020 => "Rec. ITU-R BT.2020 (Photocraft)",
|
||
Builtin::GrayGamma22 => "Gray Gamma 2.2 (Photocraft)",
|
||
Builtin::SGray => "sGray (sRGB tone curve, Photocraft)",
|
||
Builtin::DotGain20Compat => "Dot Gain 20%-compatible (gamma 1.732, Photocraft)",
|
||
Builtin::LabD50 => "Lab D50 identity (Photocraft)",
|
||
Builtin::CoatedCmyk => crate::synth::DESCRIPTION,
|
||
}
|
||
}
|
||
|
||
/// Looks up an id (case-insensitive; a few aliases and the descriptions are accepted).
|
||
pub fn from_id(s: &str) -> Option<Builtin> {
|
||
let n: String = s.to_ascii_lowercase().chars().filter(|c| c.is_ascii_alphanumeric()).collect();
|
||
let alias = match n.as_str() {
|
||
"srgb" | "srgbiec6196621" | "srgbiec61966" => Some(Builtin::Srgb),
|
||
"p3" | "displayp3" => Some(Builtin::DisplayP3),
|
||
"adobergb" | "adobergb1998" | "adobergbcompat" | "clayrgb" => Some(Builtin::AdobeRgbCompat),
|
||
"prophoto" | "prophotorgb" | "prophotocompat" | "romm" | "rommrgb" => Some(Builtin::ProPhotoCompat),
|
||
"linearsrgb" | "srgblinear" | "linear" => Some(Builtin::LinearSrgb),
|
||
"rec2020" | "bt2020" => Some(Builtin::Rec2020),
|
||
"gray" | "graygamma22" | "gamma22" => Some(Builtin::GrayGamma22),
|
||
"sgray" | "graysrgb" => Some(Builtin::SGray),
|
||
"dotgain20" | "dotgain20compat" | "dotgain" => Some(Builtin::DotGain20Compat),
|
||
"lab" | "labd50" | "cielab" => Some(Builtin::LabD50),
|
||
"cmyk" | "coatedcmyk" | "defaultcmyk" | "photocraftcoatedcmyk" => Some(Builtin::CoatedCmyk),
|
||
_ => None,
|
||
};
|
||
alias.or_else(|| Builtin::ALL.into_iter().find(|b| b.description().eq_ignore_ascii_case(s)))
|
||
}
|
||
|
||
/// The profile (built once per process).
|
||
pub fn profile(self) -> &'static Profile {
|
||
static CELLS: [OnceLock<Profile>; 11] = [const { OnceLock::new() }; 11];
|
||
// `ALL` lists the variants in declaration order (checked by `all_in_declaration_order`),
|
||
// so the discriminant is the cell index.
|
||
CELLS[self as usize].get_or_init(|| build(self))
|
||
}
|
||
}
|
||
|
||
/// The default profile for a colour space: sRGB, Dot Gain 20 %-compatible gray (Photoshop's default
|
||
/// working gray), the coated CMYK profile, Lab D50.
|
||
pub fn default_for(cs: ColorSpace) -> Option<&'static Profile> {
|
||
Some(match cs {
|
||
ColorSpace::Rgb => Builtin::Srgb.profile(),
|
||
ColorSpace::Gray => Builtin::DotGain20Compat.profile(),
|
||
ColorSpace::Cmyk => Builtin::CoatedCmyk.profile(),
|
||
ColorSpace::Lab => Builtin::LabD50.profile(),
|
||
_ => return None,
|
||
})
|
||
}
|
||
|
||
pub fn srgb() -> &'static Profile {
|
||
Builtin::Srgb.profile()
|
||
}
|
||
|
||
/// Gray with a linear tone curve: what a grayscale OpenEXR holds. Not a [`Builtin`], as it is
|
||
/// only assigned to such files, never offered as a working space.
|
||
pub fn linear_gray() -> &'static Profile {
|
||
static PROFILE: OnceLock<Profile> = OnceLock::new();
|
||
PROFILE.get_or_init(|| gray("Linear Gray (Photocraft)", Curve::Gamma(1.0)))
|
||
}
|
||
|
||
/// The ICC D65 used for the RGB spaces (chromaticity 0.3127, 0.3290).
|
||
fn d65() -> [f64; 3] {
|
||
math::xy_to_xyz(math::D65_XY)
|
||
}
|
||
|
||
/// Colorant matrix adapted to D50 and quantized to s15Fixed16, with each row nudged so that
|
||
/// RGB (1, 1, 1) maps exactly to the stored D50 white (keeps neutrals neutral).
|
||
fn colorants(r: [f64; 2], g: [f64; 2], b: [f64; 2], white: [f64; 3]) -> (Mat3, Option<Mat3>) {
|
||
// Only called with the constant primaries of the built-in spaces, which are independent
|
||
// (every built-in profile is built in the tests).
|
||
#[allow(clippy::expect_used)]
|
||
let m = math::rgb_to_xyz_matrix(r, g, b, white).expect("built-in primaries are independent");
|
||
let d50 = math::d50_quantized();
|
||
let adapt = if (white[0] - math::D50[0]).abs() < 1e-3 && (white[2] - math::D50[2]).abs() < 1e-3 { None } else { Some(math::bradford(white, math::D50)) };
|
||
let m50 = match &adapt {
|
||
Some(a) => math::mul(a, &m),
|
||
None => {
|
||
// White already (nearly) D50: scale rows onto the exact PCS white.
|
||
let s = math::apply(&m, [1.0, 1.0, 1.0]);
|
||
let mut o = m;
|
||
for (i, row) in o.iter_mut().enumerate() {
|
||
for v in row.iter_mut() {
|
||
*v *= math::D50[i] / s[i];
|
||
}
|
||
}
|
||
o
|
||
}
|
||
};
|
||
let mut q = m50.map(|row| row.map(math::s15f16_round));
|
||
for (i, row) in q.iter_mut().enumerate() {
|
||
let err = d50[i] - row.iter().sum::<f64>();
|
||
let k = (0..3).max_by(|a, b| row[*a].abs().total_cmp(&row[*b].abs())).unwrap_or(0);
|
||
row[k] = math::s15f16_round(row[k] + err);
|
||
}
|
||
(q, adapt.map(|a| a.map(|row| row.map(math::s15f16_round))))
|
||
}
|
||
|
||
fn rgb(desc: &str, prim: [[f64; 2]; 3], white: [f64; 3], trc: Curve) -> Profile {
|
||
let (m, chad) = colorants(prim[0], prim[1], prim[2], white);
|
||
Profile {
|
||
version: (4, 0x30),
|
||
class: ProfileClass::Display,
|
||
color_space: ColorSpace::Rgb,
|
||
pcs: Pcs::Xyz,
|
||
rendering_intent: Intent::Perceptual,
|
||
description: desc.into(),
|
||
copyright: COPYRIGHT.into(),
|
||
white_point: math::d50_quantized(),
|
||
black_point: None,
|
||
chad,
|
||
matrix: Some(m),
|
||
trc: Some([trc.clone(), trc.clone(), trc]),
|
||
gray_trc: None,
|
||
a2b: [None, None, None],
|
||
b2a: [None, None, None],
|
||
bytes: None,
|
||
hash: Default::default(),
|
||
}
|
||
.with_encoded_bytes()
|
||
}
|
||
|
||
fn gray(desc: &str, trc: Curve) -> Profile {
|
||
Profile {
|
||
version: (4, 0x30),
|
||
class: ProfileClass::Display,
|
||
color_space: ColorSpace::Gray,
|
||
pcs: Pcs::Xyz,
|
||
rendering_intent: Intent::Perceptual,
|
||
description: desc.into(),
|
||
copyright: COPYRIGHT.into(),
|
||
white_point: math::d50_quantized(),
|
||
black_point: None,
|
||
chad: None,
|
||
matrix: None,
|
||
trc: None,
|
||
gray_trc: Some(trc),
|
||
a2b: [None, None, None],
|
||
b2a: [None, None, None],
|
||
bytes: None,
|
||
hash: Default::default(),
|
||
}
|
||
.with_encoded_bytes()
|
||
}
|
||
|
||
fn lab() -> Profile {
|
||
let ident = || Lut { kind: LutKind::Ab, inputs: 3, outputs: 3, stages: vec![Stage::Curves(vec![Curve::Identity; 3])] };
|
||
Profile {
|
||
version: (4, 0x30),
|
||
class: ProfileClass::ColorSpace,
|
||
color_space: ColorSpace::Lab,
|
||
pcs: Pcs::Lab,
|
||
rendering_intent: Intent::Perceptual,
|
||
description: Builtin::LabD50.description().into(),
|
||
copyright: COPYRIGHT.into(),
|
||
white_point: math::d50_quantized(),
|
||
black_point: None,
|
||
chad: None,
|
||
matrix: None,
|
||
trc: None,
|
||
gray_trc: None,
|
||
a2b: [Some(ident()), None, None],
|
||
b2a: [Some(ident()), None, None],
|
||
bytes: None,
|
||
hash: Default::default(),
|
||
}
|
||
.with_encoded_bytes()
|
||
}
|
||
|
||
/// The shipped synthetic CMYK profile (generated by [`crate::synth::coated_cmyk`]; regenerate
|
||
/// with `PHOTOCRAFT_REGEN_PROFILES=1 cargo test -p photocraft-cms --release regen`).
|
||
pub const COATED_CMYK_ICC: &[u8] = include_bytes!("../profiles/photocraft-coated-cmyk.icc");
|
||
|
||
fn build(b: Builtin) -> Profile {
|
||
let (srgb_p, p3, adobe, romm, bt2020) = (
|
||
[[0.64, 0.33], [0.30, 0.60], [0.15, 0.06]],
|
||
[[0.680, 0.320], [0.265, 0.690], [0.150, 0.060]],
|
||
[[0.64, 0.33], [0.21, 0.71], [0.15, 0.06]],
|
||
[[0.7347, 0.2653], [0.1596, 0.8404], [0.0366, 0.0001]],
|
||
[[0.708, 0.292], [0.170, 0.797], [0.131, 0.046]],
|
||
);
|
||
match b {
|
||
Builtin::Srgb => rgb(b.description(), srgb_p, d65(), srgb_trc()),
|
||
Builtin::DisplayP3 => rgb(b.description(), p3, d65(), srgb_trc()),
|
||
Builtin::AdobeRgbCompat => rgb(b.description(), adobe, d65(), Curve::Gamma(563.0 / 256.0)),
|
||
Builtin::ProPhotoCompat => rgb(b.description(), romm, math::D50, Curve::Gamma(1.8)),
|
||
Builtin::LinearSrgb => rgb(b.description(), srgb_p, d65(), Curve::Gamma(1.0)),
|
||
Builtin::Rec2020 => {
|
||
// Rec. 709 OETF inverse: V = 1.099 L^0.45 − 0.099 (L ≥ 0.018), 4.5 L below.
|
||
let a = 1.099;
|
||
let trc = Curve::Parametric { kind: 3, p: [1.0 / 0.45, 1.0 / a, (a - 1.0) / a, 1.0 / 4.5, 0.081, 0.0, 0.0] };
|
||
rgb(b.description(), bt2020, d65(), trc)
|
||
}
|
||
Builtin::GrayGamma22 => gray(b.description(), Curve::Gamma(2.2)),
|
||
Builtin::SGray => gray(b.description(), srgb_trc()),
|
||
Builtin::DotGain20Compat => gray(b.description(), Curve::Gamma(1.732)),
|
||
Builtin::LabD50 => lab(),
|
||
// The shipped bytes are `synth::coated_cmyk()` (checked by the `regen` test); rebuild
|
||
// them rather than crash if they ever fail to parse.
|
||
Builtin::CoatedCmyk => Profile::parse(COATED_CMYK_ICC).unwrap_or_else(|_| crate::synth::coated_cmyk()),
|
||
}
|
||
}
|