1#![allow(clippy::excessive_precision)]
11
12use super::color::{Channel, Channels, Color, Model, Predefined, Relative, RelativeChannel};
13use super::math::Leaf;
14use super::units::write_number;
15use crate::parser::ComponentValue;
16use crate::tokenizer::Token;
17
18#[derive(Clone, Copy, Debug, PartialEq, Eq)]
20pub enum Space {
21 Srgb,
22 SrgbLinear,
23 DisplayP3,
24 DisplayP3Linear,
25 A98Rgb,
26 ProphotoRgb,
27 Rec2020,
28 XyzD50,
29 XyzD65,
30 Lab,
31 Lch,
32 Oklab,
33 Oklch,
34 Hsl,
35 Hwb,
36}
37
38impl Space {
39 fn parse(name: &str) -> Option<Space> {
40 Some(match name.to_ascii_lowercase().as_str() {
41 "srgb" => Space::Srgb,
42 "srgb-linear" => Space::SrgbLinear,
43 "display-p3" => Space::DisplayP3,
44 "display-p3-linear" => Space::DisplayP3Linear,
45 "a98-rgb" => Space::A98Rgb,
46 "prophoto-rgb" => Space::ProphotoRgb,
47 "rec2020" => Space::Rec2020,
48 "xyz-d50" => Space::XyzD50,
49 "xyz" | "xyz-d65" => Space::XyzD65,
50 "lab" => Space::Lab,
51 "lch" => Space::Lch,
52 "oklab" => Space::Oklab,
53 "oklch" => Space::Oklch,
54 "hsl" => Space::Hsl,
55 "hwb" => Space::Hwb,
56 _ => return None,
57 })
58 }
59
60 fn from_predefined(p: Predefined) -> Space {
61 match p {
62 Predefined::Srgb => Space::Srgb,
63 Predefined::SrgbLinear => Space::SrgbLinear,
64 Predefined::DisplayP3 => Space::DisplayP3,
65 Predefined::DisplayP3Linear => Space::DisplayP3Linear,
66 Predefined::A98Rgb => Space::A98Rgb,
67 Predefined::ProphotoRgb => Space::ProphotoRgb,
68 Predefined::Rec2020 => Space::Rec2020,
69 Predefined::XyzD50 => Space::XyzD50,
70 Predefined::XyzD65 => Space::XyzD65,
71 }
72 }
73
74 fn predefined_name(self) -> Option<&'static str> {
75 Some(match self {
76 Space::Srgb => "srgb",
77 Space::SrgbLinear => "srgb-linear",
78 Space::DisplayP3 => "display-p3",
79 Space::DisplayP3Linear => "display-p3-linear",
80 Space::A98Rgb => "a98-rgb",
81 Space::ProphotoRgb => "prophoto-rgb",
82 Space::Rec2020 => "rec2020",
83 Space::XyzD50 => "xyz-d50",
84 Space::XyzD65 => "xyz-d65",
85 _ => return None,
86 })
87 }
88
89 fn hue(self) -> Option<usize> {
91 match self {
92 Space::Hsl | Space::Hwb => Some(0),
93 Space::Lch | Space::Oklch => Some(2),
94 _ => None,
95 }
96 }
97
98 fn kinds(self) -> [Category; 3] {
101 use Category::*;
102 match self {
103 Space::Lab | Space::Oklab => [Lightness, Other, Other],
104 Space::Lch | Space::Oklch => [Lightness, Colorfulness, Hue],
105 Space::Hsl => [Hue, Colorfulness, Lightness],
106 Space::Hwb => [Hue, Other, Other],
107 Space::XyzD50 | Space::XyzD65 => [Red, Green, Blue],
108 _ => [Red, Green, Blue],
109 }
110 }
111}
112
113#[derive(Clone, Copy, PartialEq, Eq)]
114enum Category {
115 Red,
116 Green,
117 Blue,
118 Lightness,
119 Colorfulness,
120 Hue,
121 Other,
122}
123
124#[derive(Clone, Copy, Debug, PartialEq)]
126pub struct Absolute {
127 pub space: Space,
128 pub channels: [Option<f64>; 3],
129 pub alpha: Option<f64>,
130}
131
132type M = [[f64; 3]; 3];
133
134fn mul(m: &M, v: [f64; 3]) -> [f64; 3] {
135 [
136 m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2],
137 m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2],
138 m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2],
139 ]
140}
141
142const SRGB_TO_XYZ: M = [
143 [0.41239079926595934, 0.357584339383878, 0.1804807884018343],
144 [0.21263900587151027, 0.715168678767756, 0.07219231536073371],
145 [0.01933081871559182, 0.11919477979462598, 0.9505321522496607],
146];
147const XYZ_TO_SRGB: M = [
148 [3.2409699419045226, -1.537383177570094, -0.4986107602930034],
149 [-0.9692436362808796, 1.8759675015077202, 0.04155505740717559],
150 [
151 0.05563007969699366,
152 -0.20397695888897652,
153 1.0569715142428786,
154 ],
155];
156const P3_TO_XYZ: M = [
157 [0.4865709486482162, 0.26566769316909306, 0.1982172852343625],
158 [0.2289745640697488, 0.6917385218365064, 0.079286914093745],
159 [0.0, 0.04511338185890264, 1.043944368900976],
160];
161const XYZ_TO_P3: M = [
162 [2.493496911941425, -0.9313836179191239, -0.40271078445071684],
163 [
164 -0.8294889695615747,
165 1.7626640603183463,
166 0.023624685841943577,
167 ],
168 [
169 0.03584583024378447,
170 -0.07617238926804182,
171 0.9568845240076872,
172 ],
173];
174const A98_TO_XYZ: M = [
175 [0.5766690429101305, 0.1855582379065463, 0.1882286462349947],
176 [0.29734497525053605, 0.6273635662554661, 0.07529145849399788],
177 [0.02703136138641234, 0.07068885253582723, 0.9913375368376388],
178];
179const XYZ_TO_A98: M = [
180 [
181 2.0415879038107465,
182 -0.5650069742788596,
183 -0.34473135077832956,
184 ],
185 [-0.9692436362808795, 1.8759675015077202, 0.04155505740717557],
186 [
187 0.013444280632031142,
188 -0.11836239223101838,
189 1.0151749943912054,
190 ],
191];
192const PROPHOTO_TO_XYZ50: M = [
193 [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
194 [0.2880748288194013, 0.711835234241873, 0.00008993693872564],
195 [0.0, 0.0, 0.8251046025104602],
196];
197const XYZ50_TO_PROPHOTO: M = [
198 [
199 1.3457868816471583,
200 -0.25557208737979464,
201 -0.05110186497554526,
202 ],
203 [-0.5446307051249019, 1.5082477428451468, 0.02052744743642139],
204 [0.0, 0.0, 1.2119675456389452],
205];
206const REC2020_TO_XYZ: M = [
207 [0.6369580483012914, 0.14461690358620832, 0.1688809751641721],
208 [0.2627002120112671, 0.6779980715188708, 0.05930171646986196],
209 [0.0, 0.028072693049087428, 1.060985057710791],
210];
211const XYZ_TO_REC2020: M = [
212 [1.716651187971268, -0.355670783776392, -0.25336628137366],
213 [-0.666684351832489, 1.616481236634939, 0.0157685458139111],
214 [0.017639857445311, -0.042770613257809, 0.942103121235474],
215];
216const D65_TO_D50: M = [
217 [
218 1.0479298208405488,
219 0.022946793341019088,
220 -0.05019222954313557,
221 ],
222 [
223 0.029627815688159344,
224 0.990434484573249,
225 -0.01707382502938514,
226 ],
227 [
228 -0.009243058152591178,
229 0.015055144896577895,
230 0.7518742899580008,
231 ],
232];
233const D50_TO_D65: M = [
234 [
235 0.9554734527042182,
236 -0.023098536874261423,
237 0.0632593086610217,
238 ],
239 [
240 -0.028369706963208136,
241 1.0099954580058226,
242 0.021041398966943008,
243 ],
244 [
245 0.012314001688319899,
246 -0.020507696433477912,
247 1.3303659366080753,
248 ],
249];
250const XYZ_TO_LMS: M = [
251 [0.8190224379967030, 0.3619062600528904, -0.1288737815209879],
252 [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
253 [0.0481771893596242, 0.2642395317527308, 0.6335478284694309],
254];
255const LMS_TO_OKLAB: M = [
256 [0.2104542683093140, 0.7936177747023054, -0.0040720430116193],
257 [1.9779985324311684, -2.4285922420485799, 0.4505937096174110],
258 [0.0259040424655478, 0.7827717124575296, -0.8086757548750674],
259];
260const OKLAB_TO_LMS: M = [
261 [1.0, 0.3963377773761749, 0.2158037573099136],
262 [1.0, -0.1055613458156586, -0.0638541728258133],
263 [1.0, -0.0894841775298119, -1.2914855480194092],
264];
265const LMS_TO_XYZ: M = [
266 [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
267 [-0.0405757452148008, 1.1122868032803170, -0.0717110580655164],
268 [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816],
269];
270const D50_WHITE: [f64; 3] = [0.3457 / 0.3585, 1.0, (1.0 - 0.3457 - 0.3585) / 0.3585];
271
272fn srgb_to_linear(c: f64) -> f64 {
273 let a = c.abs();
274 if a <= 0.04045 {
275 c / 12.92
276 } else {
277 c.signum() * ((a + 0.055) / 1.055).powf(2.4)
278 }
279}
280
281fn linear_to_srgb(c: f64) -> f64 {
282 let a = c.abs();
283 if a > 0.0031308 {
284 c.signum() * (1.055 * a.powf(1.0 / 2.4) - 0.055)
285 } else {
286 12.92 * c
287 }
288}
289
290fn rec2020_to_linear(c: f64) -> f64 {
291 const A: f64 = 1.09929682680944;
292 const B: f64 = 0.018053968510807;
293 let a = c.abs();
294 if a < B * 4.5 {
295 c / 4.5
296 } else {
297 c.signum() * ((a + A - 1.0) / A).powf(1.0 / 0.45)
298 }
299}
300
301fn linear_to_rec2020(c: f64) -> f64 {
302 const A: f64 = 1.09929682680944;
303 const B: f64 = 0.018053968510807;
304 let a = c.abs();
305 if a > B {
306 c.signum() * (A * a.powf(0.45) - (A - 1.0))
307 } else {
308 4.5 * c
309 }
310}
311
312fn hsl_to_srgb(h: f64, s: f64, l: f64) -> [f64; 3] {
313 let (s, l) = (s / 100.0, l / 100.0);
314 let f = |n: f64| {
315 let k = (n + h / 30.0).rem_euclid(12.0);
316 let a = s * l.min(1.0 - l);
317 l - a * (k - 3.0).min(9.0 - k).clamp(-1.0, 1.0)
318 };
319 [f(0.0), f(8.0), f(4.0)]
320}
321
322fn srgb_to_hsl(rgb: [f64; 3]) -> [Option<f64>; 3] {
323 let [r, g, b] = rgb;
324 let max = r.max(g).max(b);
325 let min = r.min(g).min(b);
326 let l = (min + max) / 2.0;
327 let d = max - min;
328 let mut h = f64::NAN;
329 let mut s = 0.0;
330 if d.abs() > 1e-6 {
332 s = if l == 0.0 || l == 1.0 {
333 0.0
334 } else {
335 (max - l) / l.min(1.0 - l)
336 };
337 h = if max == r {
338 (g - b) / d + if g < b { 6.0 } else { 0.0 }
339 } else if max == g {
340 (b - r) / d + 2.0
341 } else {
342 (r - g) / d + 4.0
343 } * 60.0;
344 }
345 if s < 0.0 {
346 h += 180.0;
347 s = s.abs();
348 }
349 if h >= 360.0 {
350 h -= 360.0;
351 }
352 let hue = if s.abs() < 1e-9 || h.is_nan() {
354 None
355 } else {
356 Some(h)
357 };
358 [hue, Some(s * 100.0), Some(l * 100.0)]
359}
360
361fn hwb_to_srgb(h: f64, w: f64, b: f64) -> [f64; 3] {
362 let (w, b) = (w / 100.0, b / 100.0);
363 if w + b >= 1.0 {
364 let gray = w / (w + b);
365 return [gray; 3];
366 }
367 hsl_to_srgb(h, 100.0, 50.0).map(|c| c * (1.0 - w - b) + w)
368}
369
370fn srgb_to_hwb(rgb: [f64; 3]) -> [Option<f64>; 3] {
371 let hsl = srgb_to_hsl(rgb);
372 let w = rgb[0].min(rgb[1]).min(rgb[2]);
373 let b = 1.0 - rgb[0].max(rgb[1]).max(rgb[2]);
374 let hue = if w + b >= 1.0 - 1e-4 { None } else { hsl[0] };
375 [hue, Some(w * 100.0), Some(b * 100.0)]
376}
377
378fn xyz50_to_lab(v: [f64; 3]) -> [f64; 3] {
379 const E: f64 = 216.0 / 24389.0;
380 const K: f64 = 24389.0 / 27.0;
381 let f = |x: f64| {
382 if x > E {
383 x.cbrt()
384 } else {
385 (K * x + 16.0) / 116.0
386 }
387 };
388 let [x, y, z] = [
389 v[0] / D50_WHITE[0],
390 v[1] / D50_WHITE[1],
391 v[2] / D50_WHITE[2],
392 ]
393 .map(f);
394 [116.0 * y - 16.0, 500.0 * (x - y), 200.0 * (y - z)]
395}
396
397fn lab_to_xyz50(lab: [f64; 3]) -> [f64; 3] {
398 const E: f64 = 216.0 / 24389.0;
399 const K: f64 = 24389.0 / 27.0;
400 let f1 = (lab[0] + 16.0) / 116.0;
401 let f0 = lab[1] / 500.0 + f1;
402 let f2 = f1 - lab[2] / 200.0;
403 let x = if f0.powi(3) > E {
404 f0.powi(3)
405 } else {
406 (116.0 * f0 - 16.0) / K
407 };
408 let y = if lab[0] > K * E {
409 f1.powi(3)
410 } else {
411 lab[0] / K
412 };
413 let z = if f2.powi(3) > E {
414 f2.powi(3)
415 } else {
416 (116.0 * f2 - 16.0) / K
417 };
418 [x * D50_WHITE[0], y * D50_WHITE[1], z * D50_WHITE[2]]
419}
420
421fn xyz_to_oklab(v: [f64; 3]) -> [f64; 3] {
422 let lms = mul(&XYZ_TO_LMS, v).map(f64::cbrt);
423 mul(&LMS_TO_OKLAB, lms)
424}
425
426fn oklab_to_xyz(v: [f64; 3]) -> [f64; 3] {
427 let lms = mul(&OKLAB_TO_LMS, v).map(|x| x * x * x);
428 mul(&LMS_TO_XYZ, lms)
429}
430
431fn to_polar(lab: [f64; 3], powerless: f64) -> [Option<f64>; 3] {
432 let c = (lab[1] * lab[1] + lab[2] * lab[2]).sqrt();
433 let h = lab[2].atan2(lab[1]).to_degrees().rem_euclid(360.0);
434 [
435 Some(lab[0]),
436 Some(c),
437 if c <= powerless { None } else { Some(h) },
438 ]
439}
440
441fn from_polar(lch: [f64; 3]) -> [f64; 3] {
442 let h = lch[2].to_radians();
443 [lch[0], lch[1] * h.cos(), lch[1] * h.sin()]
444}
445
446fn to_xyz(c: &Absolute) -> [f64; 3] {
448 let v = c.channels.map(|x| x.unwrap_or(0.0));
449 match c.space {
450 Space::Srgb => mul(&SRGB_TO_XYZ, v.map(srgb_to_linear)),
451 Space::SrgbLinear => mul(&SRGB_TO_XYZ, v),
452 Space::DisplayP3 => mul(&P3_TO_XYZ, v.map(srgb_to_linear)),
453 Space::DisplayP3Linear => mul(&P3_TO_XYZ, v),
454 Space::A98Rgb => mul(
455 &A98_TO_XYZ,
456 v.map(|x| x.signum() * x.abs().powf(563.0 / 256.0)),
457 ),
458 Space::ProphotoRgb => {
459 let lin = v.map(|x| {
460 if x.abs() <= 16.0 / 512.0 {
461 x / 16.0
462 } else {
463 x.signum() * x.abs().powf(1.8)
464 }
465 });
466 mul(&D50_TO_D65, mul(&PROPHOTO_TO_XYZ50, lin))
467 }
468 Space::Rec2020 => mul(&REC2020_TO_XYZ, v.map(rec2020_to_linear)),
469 Space::XyzD50 => mul(&D50_TO_D65, v),
470 Space::XyzD65 => v,
471 Space::Lab => mul(&D50_TO_D65, lab_to_xyz50(v)),
472 Space::Lch => mul(&D50_TO_D65, lab_to_xyz50(from_polar(v))),
473 Space::Oklab => oklab_to_xyz(v),
474 Space::Oklch => oklab_to_xyz(from_polar(v)),
475 Space::Hsl => mul(
476 &SRGB_TO_XYZ,
477 hsl_to_srgb(v[0], v[1], v[2]).map(srgb_to_linear),
478 ),
479 Space::Hwb => mul(
480 &SRGB_TO_XYZ,
481 hwb_to_srgb(v[0], v[1], v[2]).map(srgb_to_linear),
482 ),
483 }
484}
485
486fn from_xyz(v: [f64; 3], space: Space) -> [Option<f64>; 3] {
487 let some = |a: [f64; 3]| a.map(Some);
488 let srgb = || mul(&XYZ_TO_SRGB, v).map(linear_to_srgb);
489 match space {
490 Space::Srgb => some(srgb()),
491 Space::SrgbLinear => some(mul(&XYZ_TO_SRGB, v)),
492 Space::DisplayP3 => some(mul(&XYZ_TO_P3, v).map(linear_to_srgb)),
493 Space::DisplayP3Linear => some(mul(&XYZ_TO_P3, v)),
494 Space::A98Rgb => {
495 some(mul(&XYZ_TO_A98, v).map(|x| x.signum() * x.abs().powf(256.0 / 563.0)))
496 }
497 Space::ProphotoRgb => some(mul(&XYZ50_TO_PROPHOTO, mul(&D65_TO_D50, v)).map(|x| {
498 if x.abs() >= 1.0 / 512.0 {
499 x.signum() * x.abs().powf(1.0 / 1.8)
500 } else {
501 16.0 * x
502 }
503 })),
504 Space::Rec2020 => some(mul(&XYZ_TO_REC2020, v).map(linear_to_rec2020)),
505 Space::XyzD50 => some(mul(&D65_TO_D50, v)),
506 Space::XyzD65 => some(v),
507 Space::Lab => some(xyz50_to_lab(mul(&D65_TO_D50, v))),
508 Space::Lch => to_polar(xyz50_to_lab(mul(&D65_TO_D50, v)), 0.0015),
509 Space::Oklab => some(xyz_to_oklab(v)),
510 Space::Oklch => to_polar(xyz_to_oklab(v), 0.000004),
511 Space::Hsl => srgb_to_hsl(srgb()),
512 Space::Hwb => srgb_to_hwb(srgb()),
513 }
514}
515
516impl Absolute {
517 pub fn convert(&self, space: Space) -> Absolute {
520 if space == self.space {
521 return *self;
522 }
523 if self.channels.iter().all(Option::is_none) {
525 return Absolute {
526 space,
527 channels: [None; 3],
528 alpha: self.alpha,
529 };
530 }
531 let mut channels = from_xyz(to_xyz(self), space);
532 let (from, to) = (self.space.kinds(), space.kinds());
533 if matches!(self.space, Space::Lab | Space::Oklab)
536 && matches!(space, Space::Lch | Space::Oklch)
537 && self.channels[1].is_none()
538 && self.channels[2].is_none()
539 {
540 channels[1] = None;
541 channels[2] = None;
542 }
543 for (i, k) in to.iter().enumerate() {
544 if *k == Category::Other {
545 continue;
546 }
547 if let Some(j) = from.iter().position(|f| f == k)
548 && self.channels[j].is_none()
549 {
550 channels[i] = None;
551 }
552 }
553 Absolute {
554 space,
555 channels,
556 alpha: self.alpha,
557 }
558 }
559
560 pub fn write(&self) -> String {
563 let mut s = String::new();
564 let n = |s: &mut String, v: Option<f64>, pct: bool| match v {
565 None => s.push_str("none"),
566 Some(v) => {
567 let v = if v.abs() < 5e-7 || v.is_nan() { 0.0 } else { v };
568 write_number(s, v).unwrap();
569 if pct {
570 s.push('%');
571 }
572 }
573 };
574 let (name, pcts, chans) = match self.space {
575 Space::Hsl | Space::Hwb if self.channels.iter().any(Option::is_none) => (
576 if self.space == Space::Hsl {
577 "hsl("
578 } else {
579 "hwb("
580 },
581 [false, true, true],
582 self.channels,
583 ),
584 Space::Hsl | Space::Hwb => (
585 "color(srgb ",
586 [false; 3],
587 self.convert(Space::Srgb).channels,
588 ),
589 Space::Lab => ("lab(", [false; 3], self.channels),
590 Space::Lch => ("lch(", [false; 3], self.channels),
591 Space::Oklab => ("oklab(", [false; 3], self.channels),
592 Space::Oklch => ("oklch(", [false; 3], self.channels),
593 sp => {
594 s.push_str("color(");
595 s.push_str(sp.predefined_name().unwrap());
596 s.push(' ');
597 ("", [false; 3], self.channels)
598 }
599 };
600 s.push_str(name);
601 for (i, (c, p)) in chans.iter().zip(pcts).enumerate() {
602 if i > 0 {
603 s.push(' ');
604 }
605 n(&mut s, *c, p);
606 }
607 match self.alpha {
608 Some(a) if (a - 1.0).abs() < 1e-9 => {}
609 a => {
610 s.push_str(" / ");
611 n(&mut s, a.map(|a| a.clamp(0.0, 1.0)), false);
612 }
613 }
614 s.push(')');
615 s
616 }
617}
618
619pub fn absolute(c: &Color) -> Option<Absolute> {
622 match c {
623 Color::Named(_) => absolute(&c.computed()),
624 Color::Channels(ch) => from_channels(ch),
625 Color::Relative(r) => relative(r),
626 Color::Text(t) => absolute(&Color::parse(crate::parse_component_values(t).first()?)?),
627 Color::Mix(m) => {
628 let (space, hue, items) = m.parts.as_ref()?;
629 let items: Vec<(Absolute, Option<f64>)> = items
630 .iter()
631 .map(|(c, p)| Some((absolute(c)?, *p)))
632 .collect::<Option<_>>()?;
633 mix(*space, hue, &items)
634 }
635 _ => None,
636 }
637}
638
639fn channel(c: &Channel, percent: f64) -> Option<Option<f64>> {
641 match c {
642 Channel::None => Some(None),
643 Channel::Number(v) => Some(Some(*v)),
644 Channel::Math(m) => match m.leaf()? {
645 Leaf::Number(v) => Some(Some(v)),
646 Leaf::Percentage(p) => Some(Some(p * percent)),
647 Leaf::Dimension(v, u) => Some(Some(v * u.to_canonical()?)),
648 },
649 }
650}
651
652fn from_channels(ch: &Channels) -> Option<Absolute> {
653 let percent: [f64; 3] = match ch.model {
654 Model::Rgb => [2.55; 3],
655 Model::Hsl | Model::Hwb => [1.0; 3],
656 Model::Lab => [1.0, 1.25, 1.25],
657 Model::Lch => [1.0, 1.5, 1.0],
658 Model::Oklab => [0.01, 0.004, 0.004],
659 Model::Oklch => [0.01, 0.004, 1.0],
660 _ => [0.01; 3],
661 };
662 let v: Vec<Option<f64>> = ch
663 .channels
664 .iter()
665 .zip(percent)
666 .map(|(c, p)| channel(c, p))
667 .collect::<Option<_>>()?;
668 let alpha = channel(&ch.alpha, 0.01)?;
669 let space = match ch.model {
670 Model::Rgb => {
671 return Some(Absolute {
672 space: Space::Srgb,
673 channels: [
674 v[0].map(|x| x / 255.0),
675 v[1].map(|x| x / 255.0),
676 v[2].map(|x| x / 255.0),
677 ],
678 alpha,
679 });
680 }
681 Model::Hsl => Space::Hsl,
682 Model::Hwb => Space::Hwb,
683 Model::Lab => Space::Lab,
684 Model::Lch => Space::Lch,
685 Model::Oklab => Space::Oklab,
686 Model::Oklch => Space::Oklch,
687 Model::Color(p) => Space::from_predefined(p),
688 Model::DeviceCmyk => return None,
689 };
690 let mut channels = [v[0], v[1], v[2]];
693 let clamp = |c: &mut Option<f64>, lo: f64, hi: f64| {
694 if let Some(x) = c {
695 *x = if x.is_nan() { 0.0 } else { x.clamp(lo, hi) };
696 }
697 };
698 match space {
699 Space::Lab => clamp(&mut channels[0], 0.0, 100.0),
700 Space::Lch => {
701 clamp(&mut channels[0], 0.0, 100.0);
702 clamp(&mut channels[1], 0.0, f64::INFINITY);
703 }
704 Space::Oklab => clamp(&mut channels[0], 0.0, 1.0),
705 Space::Oklch => {
706 clamp(&mut channels[0], 0.0, 1.0);
707 clamp(&mut channels[1], 0.0, f64::INFINITY);
708 }
709 _ => {}
710 }
711 if let Some(h) = space.hue()
712 && let Some(x) = &mut channels[h]
713 {
714 *x = if x.is_finite() {
715 x.rem_euclid(360.0)
716 } else {
717 0.0
718 };
719 }
720 for c in &mut channels {
721 if let Some(x) = c
722 && x.is_nan()
723 {
724 *x = 0.0;
725 }
726 }
727 let mut alpha = alpha;
728 clamp(&mut alpha, 0.0, 1.0);
729 Some(Absolute {
730 space,
731 channels,
732 alpha,
733 })
734}
735
736fn scales(function: &str, space: Space) -> [f64; 3] {
739 match (function, space) {
740 ("rgb", _) => [255.0; 3],
741 ("hsl" | "hwb", _) => [1.0, 100.0, 100.0],
742 (_, Space::Lab) => [100.0, 125.0, 125.0],
743 (_, Space::Lch) => [100.0, 150.0, 1.0],
744 (_, Space::Oklab) => [1.0, 0.4, 0.4],
745 (_, Space::Oklch) => [1.0, 0.4, 1.0],
746 _ => [1.0; 3],
747 }
748}
749
750fn relative(r: &Relative) -> Option<Absolute> {
751 let space = match (r.function, r.space) {
752 ("rgb", _) => Space::Srgb,
753 ("color", Some(p)) => Space::from_predefined(p),
754 ("alpha", _) => absolute(&r.origin)?.space,
755 (f, _) => Space::parse(f)?,
756 };
757 let origin = absolute(&r.origin)?.convert(space);
758 let scale = scales(r.function, space);
759 let names: &[&str] = match r.function {
761 "rgb" => &["r", "g", "b"],
762 "hsl" => &["h", "s", "l"],
763 "hwb" => &["h", "w", "b"],
764 "lab" | "oklab" => &["l", "a", "b"],
765 "lch" | "oklch" => &["l", "c", "h"],
766 "alpha" => &[],
767 _ if matches!(space, Space::XyzD50 | Space::XyzD65) => &["x", "y", "z"],
768 _ => &["r", "g", "b"],
769 };
770 let rgb = r.function == "rgb";
771 let named_missing = |k: &str| -> Option<Option<f64>> {
773 if k == "alpha" {
774 return Some(origin.alpha);
775 }
776 let i = names.iter().position(|n| *n == k)?;
777 Some(origin.channels[i].map(|v| if rgb { v * 255.0 } else { v }))
778 };
779 let named = |k: &str| named_missing(k).map(|v| v.unwrap_or(0.0));
780 let value = |c: &RelativeChannel, i: Option<usize>| -> Option<Option<f64>> {
781 let pct = i.map_or(1.0, |i| scale[i]);
782 Some(match c {
783 RelativeChannel::None => None,
784 RelativeChannel::Number(v) => Some(*v),
785 RelativeChannel::Percentage(p) => Some(p / 100.0 * pct),
786 RelativeChannel::Angle(v, u) => Some(v * u.to_canonical()?),
787 RelativeChannel::Keyword(k) => named_missing(k)?,
788 RelativeChannel::Math(m) => {
789 let m = m.substitute_keywords(&named);
790 Some(match m.leaf()? {
791 Leaf::Number(v) => v,
792 Leaf::Percentage(p) => p / 100.0 * pct,
793 Leaf::Dimension(v, u) => v * u.to_canonical()?,
794 })
795 }
796 })
797 };
798 let mut channels = origin.channels;
799 for (i, c) in r.channels.iter().enumerate() {
800 let mut v = value(c, Some(i))?;
801 if rgb {
802 v = v.map(|x| x / 255.0);
803 }
804 channels[i] = v;
805 }
806 let alpha = match &r.alpha {
807 Some(a) => value(a, None)?.map(|a| a.clamp(0.0, 1.0)),
808 None => origin.alpha,
809 };
810 Some(Absolute {
811 space,
812 channels,
813 alpha,
814 })
815}
816
817pub(crate) fn mix_parts(f: &crate::parser::Function<'_>) -> Option<super::color::MixParts> {
820 if !f.name.eq_ignore_ascii_case("color-mix") {
821 return None;
822 }
823 let parts: Vec<Vec<&ComponentValue<'_>>> = f
824 .arguments
825 .split(|v| matches!(v, ComponentValue::Token(Token::Comma, _)))
826 .map(|p| p.iter().filter(|v| !v.is_whitespace()).collect())
827 .collect();
828 let (mut space, mut hue, mut start) = (Space::Oklab, "shorter", 0);
829 if let Some(ComponentValue::Token(Token::Ident(w), _)) = parts[0].first().copied()
830 && w.eq_ignore_ascii_case("in")
831 {
832 let ComponentValue::Token(Token::Ident(s), _) = parts[0].get(1)? else {
833 return None;
834 };
835 space = Space::parse(s)?;
836 if let Some(ComponentValue::Token(Token::Ident(h), _)) = parts[0].get(2) {
837 hue = match h.to_ascii_lowercase().as_str() {
838 "shorter" => "shorter",
839 "longer" => "longer",
840 "increasing" => "increasing",
841 "decreasing" => "decreasing",
842 _ => return None,
843 };
844 }
845 start = 1;
846 }
847 let mut items = Vec::new();
848 for p in &parts[start..] {
849 let (color, pct) = match p[..] {
850 [c] => (c, None),
851 [c, ComponentValue::Token(Token::Percentage(n), _)]
852 | [ComponentValue::Token(Token::Percentage(n), _), c] => (c, Some(n.value)),
853 [c, ComponentValue::Function(m)] | [ComponentValue::Function(m), c]
854 if super::math::Math::is_math_function(&m.name) =>
855 {
856 match super::math::Math::parse(m)?.leaf()? {
857 Leaf::Percentage(p) => (c, Some(p)),
858 _ => return None,
859 }
860 }
861 _ => return None,
862 };
863 items.push((Color::parse(color)?, pct));
864 }
865 Some((space, hue, items))
866}
867
868fn mix(space: Space, hue: &str, items: &[(Absolute, Option<f64>)]) -> Option<Absolute> {
873 if items.is_empty() {
874 return None;
875 }
876 if items.len() == 1 {
877 return Some(items[0].0.convert(space));
878 }
879 let given: f64 = items.iter().filter_map(|(_, p)| *p).sum();
880 let missing = items.iter().filter(|(_, p)| p.is_none()).count();
881 let share = if missing > 0 {
882 ((100.0 - given) / missing as f64).max(0.0)
883 } else {
884 0.0
885 };
886 let weights: Vec<f64> = items.iter().map(|(_, p)| p.unwrap_or(share)).collect();
887 let sum: f64 = weights.iter().sum();
888 let (multiplier, weights) = if sum == 0.0 {
890 (0.0, vec![1.0; items.len()])
891 } else {
892 (if sum < 100.0 { sum / 100.0 } else { 1.0 }, weights)
893 };
894 let mut acc = items[0].0.convert(space);
895 let mut acc_w = weights[0];
896 for ((c, _), w) in items[1..].iter().zip(&weights[1..]) {
897 let t = if acc_w + w == 0.0 {
898 0.5
899 } else {
900 w / (acc_w + w)
901 };
902 acc = mix2(space, hue, &acc, c, t);
903 acc_w += w;
904 }
905 acc.alpha = acc.alpha.map(|a| a * multiplier);
906 Some(acc)
907}
908
909fn mix2(space: Space, hue: &str, a: &Absolute, b: &Absolute, t: f64) -> Absolute {
910 let (a, b) = (a.convert(space), b.convert(space));
911 let hue_at = space.hue();
912 let (aa, ba) = (a.alpha, b.alpha);
913 let alpha = match (aa, ba) {
914 (None, None) => None,
915 (x, y) => {
916 let (x, y) = (x.or(y).unwrap(), y.or(x).unwrap());
917 Some(x + (y - x) * t)
918 }
919 };
920 let (wa, wb) = (aa.or(ba).unwrap_or(1.0), ba.or(aa).unwrap_or(1.0));
921 let mut out = [None; 3];
922 for (i, slot) in out.iter_mut().enumerate() {
923 let (x, y) = match (a.channels[i], b.channels[i]) {
924 (None, None) => continue,
925 (Some(x), None) => (x, x),
926 (None, Some(y)) => (y, y),
927 (Some(x), Some(y)) => (x, y),
928 };
929 *slot = Some(if Some(i) == hue_at {
930 let (mut x, mut y) = (x.rem_euclid(360.0), y.rem_euclid(360.0));
931 let d = y - x;
932 match hue {
933 "shorter" if d > 180.0 => x += 360.0,
934 "shorter" if d < -180.0 => y += 360.0,
935 "longer" if d > 0.0 && d < 180.0 => x += 360.0,
936 "longer" if d > -180.0 && d <= 0.0 => y += 360.0,
937 "increasing" if y < x => y += 360.0,
938 "decreasing" if x < y => x += 360.0,
939 _ => {}
940 }
941 (x + (y - x) * t).rem_euclid(360.0)
942 } else {
943 let v = x * wa + (y * wb - x * wa) * t;
945 match alpha {
946 Some(al) if al != 0.0 => v / al,
947 _ => v,
948 }
949 });
950 }
951 Absolute {
952 space,
953 channels: out,
954 alpha,
955 }
956}