MagickCore 7.1.2-37
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
colorspace-private.h
1/*
2 Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization
3 dedicated to making software imaging solutions freely available.
4
5 You may not use this file except in compliance with the License. You may
6 obtain a copy of the License at
7
8 https://imagemagick.org/license/
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15
16 MagickCore image colorspace private methods.
17*/
18#ifndef MAGICKCORE_COLORSPACE_PRIVATE_H
19#define MAGICKCORE_COLORSPACE_PRIVATE_H
20
21#include "MagickCore/image.h"
22#include "MagickCore/image-private.h"
23#include "MagickCore/pixel.h"
24#include "MagickCore/pixel-accessor.h"
25
26#define IlluminantX 0.95047
27#define IlluminantY 1.0
28#define IlluminantZ 1.08883
29#define CIEEpsilon (216.0/24389.0)
30#define CIEK (24389.0/27.0)
31
32static const PrimaryInfo
33 illuminant_tristimulus[] =
34 {
35 { 1.09850, 1.00000, 0.35585 }, /* A */
36 { 0.99072, 1.00000, 0.85223 }, /* B */
37 { 0.98074, 1.00000, 1.18232 }, /* C */
38 { 0.96422, 1.00000, 0.82521 }, /* D50 */
39 { 0.95682, 1.00000, 0.92149 }, /* D55 */
40 { 0.95047, 1.00000, 1.08883 }, /* D65 */
41 { 0.94972, 1.00000, 1.22638 }, /* D75 */
42 { 1.00000, 1.00000, 1.00000 }, /* E */
43 { 0.99186, 1.00000, 0.67393 }, /* F2 */
44 { 0.95041, 1.00000, 1.08747 }, /* F7 */
45 { 1.00962, 1.00000, 0.64350 } /* F11 */
46 };
47
48#if defined(__cplusplus) || defined(c_plusplus)
49extern "C" {
50#endif
51
52
53static inline void ConvertAdobe98ToXYZ(const double red,const double green,
54 const double blue,double *X,double *Y,double *Z)
55{
56 double
57 b,
58 g,
59 r;
60
61 /*
62 Convert Adobe '98 to XYZ colorspace.
63 */
64 r=QuantumScale*DecodePixelGamma((double) QuantumRange*red);
65 g=QuantumScale*DecodePixelGamma((double) QuantumRange*green);
66 b=QuantumScale*DecodePixelGamma((double) QuantumRange*blue);
67 *X=0.57666904291013050*r+0.18555823790654630*g+0.18822864623499470*b;
68 *Y=0.29734497525053605*r+0.62736356625546610*g+0.07529145849399788*b;
69 *Z=0.02703136138641234*r+0.07068885253582723*g+0.99133753683763880*b;
70}
71
72static inline void ConvertXYZToRGB(const double X,const double Y,const double Z,
73 double *red,double *green,double *blue)
74{
75 double
76 b,
77 g,
78 r;
79
80 r=(3.240969941904521*X)+(-1.537383177570093*Y)+(-0.498610760293*Z);
81 g=(-0.96924363628087*X)+(1.87596750150772*Y)+(0.041555057407175*Z);
82 b=(0.055630079696993*X)+(-0.20397695888897*Y)+(1.056971514242878*Z);
83 *red=EncodePixelGamma((double) QuantumRange*r);
84 *green=EncodePixelGamma((double) QuantumRange*g);
85 *blue=EncodePixelGamma((double) QuantumRange*b);
86}
87
88static inline void ConvertAdobe98ToRGB(const double r,const double g,
89 const double b,double *red,double *green,double *blue)
90{
91 double
92 X,
93 Y,
94 Z;
95
96 ConvertAdobe98ToXYZ(r,g,b,&X,&Y,&Z);
97 ConvertXYZToRGB(X,Y,Z,red,green,blue);
98}
99
100static inline void ConvertCAT02LMSToXYZ(const double L,const double M,
101 const double S,double *X,double *Y,double *Z)
102{
103 /*
104 Convert CAT02LMS to XYZ colorspace.
105 */
106 *X=1.096123820835514*L-0.278869000218287*M+0.182745179382773*S;
107 *Y=0.454369041975359*L+0.473533154307412*M+0.072097803717229*S;
108 *Z=(-0.009627608738429)*L-0.005698031216113*M+1.015325639954543*S;
109}
110
111static inline void ConvertCAT02LMSToRGB(const double L,const double M,
112 const double S,double *R,double *G,double *B)
113{
114 double
115 X,
116 Y,
117 Z;
118
119 ConvertCAT02LMSToXYZ(L,M,S,&X,&Y,&Z);
120 ConvertXYZToRGB(X,Y,Z,R,G,B);
121}
122
123static inline void ConvertCMYKToRGB(PixelInfo *pixel)
124{
125 pixel->red=(((double) QuantumRange-(QuantumScale*pixel->red*
126 ((double) QuantumRange-pixel->black)+pixel->black)));
127 pixel->green=(((double) QuantumRange-(QuantumScale*pixel->green*
128 ((double) QuantumRange-pixel->black)+pixel->black)));
129 pixel->blue=(((double) QuantumRange-(QuantumScale*pixel->blue*
130 ((double) QuantumRange-pixel->black)+pixel->black)));
131}
132
133static inline void ConvertCMYToRGB(const double cyan,const double magenta,
134 const double yellow,double *red,double *green,double *blue)
135{
136 *red=(double) QuantumRange*(1.0-cyan);
137 *green=(double) QuantumRange*(1.0-magenta);
138 *blue=(double) QuantumRange*(1.0-yellow);
139}
140
141static inline void ConvertHCLToRGB(const double hue,const double chroma,
142 const double luma,double *red,double *green,double *blue)
143{
144 double
145 b,
146 c,
147 g,
148 h,
149 m,
150 r,
151 x;
152
153 /*
154 Convert HCL to RGB colorspace.
155 */
156 assert(red != (double *) NULL);
157 assert(green != (double *) NULL);
158 assert(blue != (double *) NULL);
159 h=6.0*hue;
160 c=chroma;
161 x=c*(1.0-fabs(fmod(h,2.0)-1.0));
162 r=0.0;
163 g=0.0;
164 b=0.0;
165 if ((0.0 <= h) && (h < 1.0))
166 {
167 r=c;
168 g=x;
169 }
170 else
171 if ((1.0 <= h) && (h < 2.0))
172 {
173 r=x;
174 g=c;
175 }
176 else
177 if ((2.0 <= h) && (h < 3.0))
178 {
179 g=c;
180 b=x;
181 }
182 else
183 if ((3.0 <= h) && (h < 4.0))
184 {
185 g=x;
186 b=c;
187 }
188 else
189 if ((4.0 <= h) && (h < 5.0))
190 {
191 r=x;
192 b=c;
193 }
194 else
195 if ((5.0 <= h) && (h < 6.0))
196 {
197 r=c;
198 b=x;
199 }
200 m=luma-(0.298839*r+0.586811*g+0.114350*b);
201 *red=(double) QuantumRange*(r+m);
202 *green=(double) QuantumRange*(g+m);
203 *blue=(double) QuantumRange*(b+m);
204}
205
206static inline void ConvertHCLpToRGB(const double hue,const double chroma,
207 const double luma,double *red,double *green,double *blue)
208{
209 double
210 b,
211 c,
212 g,
213 h,
214 m,
215 r,
216 x,
217 z;
218
219 /*
220 Convert HCLp to RGB colorspace.
221 */
222 assert(red != (double *) NULL);
223 assert(green != (double *) NULL);
224 assert(blue != (double *) NULL);
225 h=6.0*hue;
226 c=chroma;
227 x=c*(1.0-fabs(fmod(h,2.0)-1.0));
228 r=0.0;
229 g=0.0;
230 b=0.0;
231 if ((0.0 <= h) && (h < 1.0))
232 {
233 r=c;
234 g=x;
235 }
236 else
237 if ((1.0 <= h) && (h < 2.0))
238 {
239 r=x;
240 g=c;
241 }
242 else
243 if ((2.0 <= h) && (h < 3.0))
244 {
245 g=c;
246 b=x;
247 }
248 else
249 if ((3.0 <= h) && (h < 4.0))
250 {
251 g=x;
252 b=c;
253 }
254 else
255 if ((4.0 <= h) && (h < 5.0))
256 {
257 r=x;
258 b=c;
259 }
260 else
261 if ((5.0 <= h) && (h < 6.0))
262 {
263 r=c;
264 b=x;
265 }
266 m=luma-(0.298839*r+0.586811*g+0.114350*b);
267 z=1.0;
268 if (m < 0.0)
269 {
270 z=luma/(luma-m);
271 m=0.0;
272 }
273 else
274 if (m+c > 1.0)
275 {
276 z=(1.0-luma)/(m+c-luma);
277 m=1.0-z*c;
278 }
279 *red=(double) QuantumRange*(z*r+m);
280 *green=(double) QuantumRange*(z*g+m);
281 *blue=(double) QuantumRange*(z*b+m);
282}
283
284static inline void ConvertHSBToRGB(const double hue,const double saturation,
285 const double brightness,double *red,double *green,double *blue)
286{
287 double
288 f,
289 h,
290 p,
291 q,
292 t;
293
294 /*
295 Convert HSB to RGB colorspace.
296 */
297 assert(red != (double *) NULL);
298 assert(green != (double *) NULL);
299 assert(blue != (double *) NULL);
300 if (fabs(saturation) < MagickEpsilon)
301 {
302 *red=(double) QuantumRange*brightness;
303 *green=(*red);
304 *blue=(*red);
305 return;
306 }
307 h=6.0*(hue-floor(hue));
308 f=h-floor((double) h);
309 p=brightness*(1.0-saturation);
310 q=brightness*(1.0-saturation*f);
311 t=brightness*(1.0-(saturation*(1.0-f)));
312 switch ((int) h)
313 {
314 case 0:
315 default:
316 {
317 *red=(double) QuantumRange*brightness;
318 *green=(double) QuantumRange*t;
319 *blue=(double) QuantumRange*p;
320 break;
321 }
322 case 1:
323 {
324 *red=(double) QuantumRange*q;
325 *green=(double) QuantumRange*brightness;
326 *blue=(double) QuantumRange*p;
327 break;
328 }
329 case 2:
330 {
331 *red=(double) QuantumRange*p;
332 *green=(double) QuantumRange*brightness;
333 *blue=(double) QuantumRange*t;
334 break;
335 }
336 case 3:
337 {
338 *red=(double) QuantumRange*p;
339 *green=(double) QuantumRange*q;
340 *blue=(double) QuantumRange*brightness;
341 break;
342 }
343 case 4:
344 {
345 *red=(double) QuantumRange*t;
346 *green=(double) QuantumRange*p;
347 *blue=(double) QuantumRange*brightness;
348 break;
349 }
350 case 5:
351 {
352 *red=(double) QuantumRange*brightness;
353 *green=(double) QuantumRange*p;
354 *blue=(double) QuantumRange*q;
355 break;
356 }
357 }
358}
359
360static inline void ConvertHSIToRGB(const double hue,const double saturation,
361 const double intensity,double *red,double *green,double *blue)
362{
363 double
364 b,
365 g,
366 h,
367 r;
368
369 /*
370 Convert HSI to RGB colorspace.
371 */
372 assert(red != (double *) NULL);
373 assert(green != (double *) NULL);
374 assert(blue != (double *) NULL);
375 h=360.0*hue;
376 h-=360.0*floor(h/360.0);
377 if (h < 120.0)
378 {
379 b=intensity*(1.0-saturation);
380 r=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
381 (MagickPI/180.0)));
382 g=3.0*intensity-r-b;
383 }
384 else
385 if (h < 240.0)
386 {
387 h-=120.0;
388 r=intensity*(1.0-saturation);
389 g=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
390 (MagickPI/180.0)));
391 b=3.0*intensity-r-g;
392 }
393 else
394 {
395 h-=240.0;
396 g=intensity*(1.0-saturation);
397 b=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
398 (MagickPI/180.0)));
399 r=3.0*intensity-g-b;
400 }
401 *red=(double) QuantumRange*r;
402 *green=(double) QuantumRange*g;
403 *blue=(double) QuantumRange*b;
404}
405
406static inline void ConvertHSVToRGB(const double hue,const double saturation,
407 const double value,double *red,double *green,double *blue)
408{
409 double
410 c,
411 h,
412 min,
413 x;
414
415 /*
416 Convert HSV to RGB colorspace.
417 */
418 assert(red != (double *) NULL);
419 assert(green != (double *) NULL);
420 assert(blue != (double *) NULL);
421 h=hue*360.0;
422 c=value*saturation;
423 min=value-c;
424 h-=360.0*floor(h/360.0);
425 h/=60.0;
426 x=c*(1.0-fabs(h-2.0*floor(h/2.0)-1.0));
427 switch ((int) floor(h))
428 {
429 case 0:
430 default:
431 {
432 *red=(double) QuantumRange*(min+c);
433 *green=(double) QuantumRange*(min+x);
434 *blue=(double) QuantumRange*min;
435 break;
436 }
437 case 1:
438 {
439 *red=(double) QuantumRange*(min+x);
440 *green=(double) QuantumRange*(min+c);
441 *blue=(double) QuantumRange*min;
442 break;
443 }
444 case 2:
445 {
446 *red=(double) QuantumRange*min;
447 *green=(double) QuantumRange*(min+c);
448 *blue=(double) QuantumRange*(min+x);
449 break;
450 }
451 case 3:
452 {
453 *red=(double) QuantumRange*min;
454 *green=(double) QuantumRange*(min+x);
455 *blue=(double) QuantumRange*(min+c);
456 break;
457 }
458 case 4:
459 {
460 *red=(double) QuantumRange*(min+x);
461 *green=(double) QuantumRange*min;
462 *blue=(double) QuantumRange*(min+c);
463 break;
464 }
465 case 5:
466 {
467 *red=(double) QuantumRange*(min+c);
468 *green=(double) QuantumRange*min;
469 *blue=(double) QuantumRange*(min+x);
470 break;
471 }
472 }
473}
474
475static inline void ConvertHWBToRGB(const double hue,const double whiteness,
476 const double blackness,double *red,double *green,double *blue)
477{
478 double
479 b,
480 f,
481 g,
482 n,
483 r,
484 v;
485
486 ssize_t
487 i;
488
489 /*
490 Convert HWB to RGB colorspace.
491 */
492 assert(red != (double *) NULL);
493 assert(green != (double *) NULL);
494 assert(blue != (double *) NULL);
495 v=1.0-blackness;
496 if (fabs(hue-(-1.0)) < MagickEpsilon)
497 {
498 *red=(double) QuantumRange*v;
499 *green=(double) QuantumRange*v;
500 *blue=(double) QuantumRange*v;
501 return;
502 }
503 i=CastDoubleToSsizeT(floor(6.0*hue));
504 f=6.0*hue-(double) i;
505 if ((i & 0x01) != 0)
506 f=1.0-f;
507 n=whiteness+f*(v-whiteness); /* linear interpolation */
508 switch (i)
509 {
510 case 0:
511 default: r=v; g=n; b=whiteness; break;
512 case 1: r=n; g=v; b=whiteness; break;
513 case 2: r=whiteness; g=v; b=n; break;
514 case 3: r=whiteness; g=n; b=v; break;
515 case 4: r=n; g=whiteness; b=v; break;
516 case 5: r=v; g=whiteness; b=n; break;
517 }
518 *red=(double) QuantumRange*r;
519 *green=(double) QuantumRange*g;
520 *blue=(double) QuantumRange*b;
521}
522
523static inline void ConvertLabToXYZ(const double L,const double a,const double b,
524 const IlluminantType illuminant,double *X,double *Y,double *Z)
525{
526 double
527 x,
528 y,
529 z;
530
531 y=(L+16.0)/116.0;
532 x=y+a/500.0;
533 z=y-b/200.0;
534 if ((x*x*x) > CIEEpsilon)
535 x=(x*x*x);
536 else
537 x=(116.0*x-16.0)/CIEK;
538 if (L > (CIEK*CIEEpsilon))
539 y=(y*y*y);
540 else
541 y=L/CIEK;
542 if ((z*z*z) > CIEEpsilon)
543 z=(z*z*z);
544 else
545 z=(116.0*z-16.0)/CIEK;
546 *X=illuminant_tristimulus[illuminant].x*x;
547 *Y=illuminant_tristimulus[illuminant].y*y;
548 *Z=illuminant_tristimulus[illuminant].z*z;
549}
550
551static inline void ConvertLabToRGB(const double L,const double a,
552 const double b,const IlluminantType illuminant,double *red,double *green,
553 double *blue)
554{
555 double
556 X,
557 Y,
558 Z;
559
560 ConvertLabToXYZ(100.0*L,255.0*(a-0.5),255.0*(b-0.5),illuminant,&X,&Y,&Z);
561 ConvertXYZToRGB(X,Y,Z,red,green,blue);
562}
563
564static inline void ConvertLCHabToXYZ(const double luma,const double chroma,
565 const double hue,const IlluminantType illuminant,double *X,double *Y,
566 double *Z)
567{
568 ConvertLabToXYZ(luma,chroma*cos(DegreesToRadians(hue)),chroma*
569 sin(DegreesToRadians(hue)),illuminant,X,Y,Z);
570}
571
572static inline void ConvertLCHabToRGB(const double luma,const double chroma,
573 const double hue,const IlluminantType illuminant,double *red,double *green,
574 double *blue)
575{
576 double
577 X,
578 Y,
579 Z;
580
581 /*
582 Convert LCHab to RGB colorspace.
583 */
584 assert(red != (double *) NULL);
585 assert(green != (double *) NULL);
586 assert(blue != (double *) NULL);
587 ConvertLCHabToXYZ(100.0*luma,255.0*(chroma-0.5),360.0*hue,illuminant,
588 &X,&Y,&Z);
589 ConvertXYZToRGB(X,Y,Z,red,green,blue);
590}
591
592static inline void ConvertLuvToXYZ(const double L,const double u,const double v,
593 const IlluminantType illuminant,double *X,double *Y,double *Z)
594{
595 double
596 gamma;
597
598 if (L > (CIEK*CIEEpsilon))
599 *Y=(double) pow((L+16.0)/116.0,3.0);
600 else
601 *Y=L/CIEK;
602 gamma=MagickSafeReciprocal((((52.0*L*MagickSafeReciprocal(u+13.0*L*
603 (4.0*illuminant_tristimulus[illuminant].x/
604 (illuminant_tristimulus[illuminant].x+15.0*
605 illuminant_tristimulus[illuminant].y+3.0*
606 illuminant_tristimulus[illuminant].z))))-1.0)/3.0)-(-1.0/3.0));
607 *X=gamma*((*Y*((39.0*L*MagickSafeReciprocal(v+13.0*L*(9.0*
608 illuminant_tristimulus[illuminant].y/
609 (illuminant_tristimulus[illuminant].x+15.0*
610 illuminant_tristimulus[illuminant].y+3.0*
611 illuminant_tristimulus[illuminant].z))))-5.0))+5.0*(*Y));
612 *Z=(*X*(((52.0*L*MagickSafeReciprocal(u+13.0*L*(4.0*
613 illuminant_tristimulus[illuminant].x/
614 (illuminant_tristimulus[illuminant].x+15.0*
615 illuminant_tristimulus[illuminant].y+3.0*
616 illuminant_tristimulus[illuminant].z))))-1.0)/3.0))-5.0*(*Y);
617}
618
619static inline void ConvertLCHuvToXYZ(const double luma,const double chroma,
620 const double hue,const IlluminantType illuminant,double *X,double *Y,
621 double *Z)
622{
623 ConvertLuvToXYZ(luma,chroma*cos(DegreesToRadians(hue)),chroma*
624 sin(DegreesToRadians(hue)),illuminant,X,Y,Z);
625}
626
627static inline void ConvertLCHuvToRGB(const double luma,const double chroma,
628 const double hue,const IlluminantType illuminant,double *red,double *green,
629 double *blue)
630{
631 double
632 X,
633 Y,
634 Z;
635
636 /*
637 Convert LCHuv to RGB colorspace.
638 */
639 assert(red != (double *) NULL);
640 assert(green != (double *) NULL);
641 assert(blue != (double *) NULL);
642 ConvertLCHuvToXYZ(100.0*luma,255.0*(chroma-0.5),360.0*hue,illuminant,
643 &X,&Y,&Z);
644 ConvertXYZToRGB(X,Y,Z,red,green,blue);
645}
646
647static inline void ConvertLMSToXYZ(const double L,const double M,const double S,
648 double *X,double *Y,double *Z)
649{
650 *X=1.096123820835514*L-0.278869000218287*M+0.182745179382773*S;
651 *Y=0.454369041975359*L+0.473533154307412*M+0.072097803717229*S;
652 *Z=(-0.009627608738429)*L-0.005698031216113*M+1.015325639954543*S;
653}
654
655static inline void ConvertLMSToRGB(const double L,const double M,
656 const double S,double *red,double *green,double *blue)
657{
658 double
659 X,
660 Y,
661 Z;
662
663 ConvertLMSToXYZ(L,M,S,&X,&Y,&Z);
664 ConvertXYZToRGB(X,Y,Z,red,green,blue);
665}
666
667static inline void ConvertDisplayP3ToXYZ(const double red,const double green,
668 const double blue,double *X,double *Y,double *Z)
669{
670 double
671 b,
672 g,
673 r;
674
675 /*
676 Convert Display P3 to XYZ colorspace.
677 */
678 r=QuantumScale*DecodePixelGamma((double) QuantumRange*red);
679 g=QuantumScale*DecodePixelGamma((double) QuantumRange*green);
680 b=QuantumScale*DecodePixelGamma((double) QuantumRange*blue);
681 *X=0.4865709486482162*r+0.26566769316909306*g+0.1982172852343625*b;
682 *Y=0.2289745640697488*r+0.69173852183650640*g+0.0792869140937450*b;
683 *Z=0.0000000000000000*r+0.04511338185890264*g+1.0439443689009760*b;
684}
685
686static inline void ConvertDisplayP3ToRGB(const double r,const double g,
687 const double b,double *red,double *green,double *blue)
688{
689 double
690 X,
691 Y,
692 Z;
693
694 ConvertDisplayP3ToXYZ(r,g,b,&X,&Y,&Z);
695 ConvertXYZToRGB(X,Y,Z,red,green,blue);
696}
697
698static inline void ConvertLuvToRGB(const double L,const double u,
699 const double v,const IlluminantType illuminant,double *red,double *green,
700 double *blue)
701{
702 double
703 X,
704 Y,
705 Z;
706
707 ConvertLuvToXYZ(100.0*L,354.0*u-134.0,262.0*v-140.0,illuminant,&X,&Y,&Z);
708 ConvertXYZToRGB(X,Y,Z,red,green,blue);
709}
710
711static inline void ConvertProPhotoToXYZ(const double red,const double green,
712 const double blue,double *X,double *Y,double *Z)
713{
714 double
715 b,
716 g,
717 r;
718
719 /*
720 Convert ProPhoto to XYZ colorspace.
721 */
722 r=QuantumScale*DecodePixelGamma((double) QuantumRange*red);
723 g=QuantumScale*DecodePixelGamma((double) QuantumRange*green);
724 b=QuantumScale*DecodePixelGamma((double) QuantumRange*blue);
725 *X=0.4865709486482162*r+0.26566769316909306*g+0.1982172852343625*b;
726 *X=0.7977604896723027*r+0.13518583717574031*g+0.03134934958152480000*b;
727 *Y=0.2880711282292934*r+0.71184321781010140*g+0.00008565396060525902*b;
728 *Z=0.0000000000000000*r+0.00000000000000000*g+0.82510460251046010000*b;
729}
730
731static inline void ConvertProPhotoToRGB(const double r,const double g,
732 const double b,double *red,double *green,double *blue)
733{
734 double
735 X,
736 Y,
737 Z;
738
739 ConvertProPhotoToXYZ(r,g,b,&X,&Y,&Z);
740 ConvertXYZToRGB(X,Y,Z,red,green,blue);
741}
742
743static inline void ConvertXYZToCAT02LMS(const double X,const double Y,
744 const double Z,double *L,double *M,double *S)
745{
746 *L=0.7328*X+0.4296*Y-0.1624*Z;
747 *M=(-0.7036)*X+1.6975*Y+0.0061*Z;
748 *S=0.0030*X+0.0136*Y+0.9834*Z;
749}
750
751static inline void ConvertRGBToXYZ(const double red,const double green,
752 const double blue,double *X,double *Y,double *Z)
753{
754 double
755 b,
756 g,
757 r;
758
759 /*
760 Convert RGB to XYZ colorspace.
761 */
762 r=QuantumScale*DecodePixelGamma(red);
763 g=QuantumScale*DecodePixelGamma(green);
764 b=QuantumScale*DecodePixelGamma(blue);
765 *X=(0.4123955889674142161*r)+(0.3575834307637148171*g)+
766 (0.1804926473817015735*b);
767 *Y=(0.2125862307855955516*r)+(0.7151703037034108499*g)+
768 (0.07220049864333622685*b);
769 *Z=(0.01929721549174694484*r)+(0.1191838645808485318*g)+
770 (0.9504971251315797660*b);
771}
772
773static inline void ConvertRGBToCAT02LMS(const double R,const double G,
774 const double B,double *L,double *M,double *S)
775{
776 double
777 X,
778 Y,
779 Z;
780
781 ConvertRGBToXYZ(R,G,B,&X,&Y,&Z);
782 ConvertXYZToCAT02LMS(X,Y,Z,L,M,S);
783}
784
785static inline void ConvertRGBToCMY(const double red,const double green,
786 const double blue,double *cyan,double *magenta,double *yellow)
787{
788 *cyan=QuantumScale*((double) QuantumRange-red);
789 *magenta=QuantumScale*((double) QuantumRange-green);
790 *yellow=QuantumScale*((double) QuantumRange-blue);
791}
792
793static inline void ConvertRGBToHCL(const double red,const double green,
794 const double blue,double *hue,double *chroma,double *luma)
795{
796 double
797 c,
798 h,
799 max;
800
801 /*
802 Convert RGB to HCL colorspace.
803 */
804 assert(hue != (double *) NULL);
805 assert(chroma != (double *) NULL);
806 assert(luma != (double *) NULL);
807 max=MagickMax(red,MagickMax(green,blue));
808 c=max-(double) MagickMin(red,MagickMin(green,blue));
809 h=0.0;
810 if (fabs(c) < MagickEpsilon)
811 h=0.0;
812 else
813 if (fabs(red-max) < MagickEpsilon)
814 h=fmod((green-blue)/c+6.0,6.0);
815 else
816 if (fabs(green-max) < MagickEpsilon)
817 h=((blue-red)/c)+2.0;
818 else
819 if (fabs(blue-max) < MagickEpsilon)
820 h=((red-green)/c)+4.0;
821 *hue=(h/6.0);
822 *chroma=QuantumScale*c;
823 *luma=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
824}
825
826static inline void ConvertRGBToHCLp(const double red,const double green,
827 const double blue,double *hue,double *chroma,double *luma)
828{
829 double
830 c,
831 h,
832 max;
833
834 /*
835 Convert RGB to HCL colorspace.
836 */
837 assert(hue != (double *) NULL);
838 assert(chroma != (double *) NULL);
839 assert(luma != (double *) NULL);
840 max=MagickMax(red,MagickMax(green,blue));
841 c=max-MagickMin(red,MagickMin(green,blue));
842 h=0.0;
843 if (fabs(c) < MagickEpsilon)
844 h=0.0;
845 else
846 if (fabs(red-max) < MagickEpsilon)
847 h=fmod((green-blue)/c+6.0,6.0);
848 else
849 if (fabs(green-max) < MagickEpsilon)
850 h=((blue-red)/c)+2.0;
851 else
852 if (fabs(blue-max) < MagickEpsilon)
853 h=((red-green)/c)+4.0;
854 *hue=(h/6.0);
855 *chroma=QuantumScale*c;
856 *luma=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
857}
858
859static inline void ConvertRGBToHSB(const double red,const double green,
860 const double blue,double *hue,double *saturation,double *brightness)
861{
862 double
863 delta,
864 max,
865 min;
866
867 /*
868 Convert RGB to HSB colorspace.
869 */
870 assert(hue != (double *) NULL);
871 assert(saturation != (double *) NULL);
872 assert(brightness != (double *) NULL);
873 *hue=0.0;
874 *saturation=0.0;
875 *brightness=0.0;
876 min=red < green ? red : green;
877 if (blue < min)
878 min=blue;
879 max=red > green ? red : green;
880 if (blue > max)
881 max=blue;
882 if (fabs(max) < MagickEpsilon)
883 return;
884 delta=max-min;
885 *saturation=delta/max;
886 *brightness=QuantumScale*max;
887 if (fabs(delta) < MagickEpsilon)
888 return;
889 if (fabs(red-max) < MagickEpsilon)
890 *hue=(green-blue)/delta;
891 else
892 if (fabs(green-max) < MagickEpsilon)
893 *hue=2.0+(blue-red)/delta;
894 else
895 *hue=4.0+(red-green)/delta;
896 *hue/=6.0;
897 if (*hue < 0.0)
898 *hue+=1.0;
899}
900
901static inline void ConvertRGBToHSI(const double red,const double green,
902 const double blue,double *hue,double *saturation,double *intensity)
903{
904 double
905 alpha,
906 beta;
907
908 /*
909 Convert RGB to HSI colorspace.
910 */
911 assert(hue != (double *) NULL);
912 assert(saturation != (double *) NULL);
913 assert(intensity != (double *) NULL);
914 *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
915 if (*intensity <= 0.0)
916 {
917 *hue=0.0;
918 *saturation=0.0;
919 return;
920 }
921 *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
922 QuantumScale*blue))/(*intensity);
923 alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
924 beta=0.8660254037844385*(QuantumScale*green-QuantumScale*blue);
925 *hue=atan2(beta,alpha)*(180.0/MagickPI)/360.0;
926 if (*hue < 0.0)
927 *hue+=1.0;
928}
929
930static inline void ConvertXYZToAdobe98(const double X,const double Y,
931 const double Z,double *red,double *green,double *blue)
932{
933 double
934 b,
935 g,
936 r;
937
938 r=2.041587903810746500*X-0.56500697427885960*Y-0.34473135077832956*Z;
939 g=(-0.969243636280879500)*X+1.87596750150772020*Y+0.04155505740717557*Z;
940 b=0.013444280632031142*X-0.11836239223101838*Y+1.01517499439120540*Z;
941 *red=QuantumScale*EncodePixelGamma((double) QuantumRange*r);
942 *green=QuantumScale*EncodePixelGamma((double) QuantumRange*g);
943 *blue=QuantumScale*EncodePixelGamma((double) QuantumRange*b);
944}
945
946static inline void ConvertRGBToAdobe98(const double red,const double green,
947 const double blue,double *r,double *g,double *b)
948{
949 double
950 X,
951 Y,
952 Z;
953
954 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
955 ConvertXYZToAdobe98(X,Y,Z,r,g,b);
956}
957
958static inline void ConvertXYZToDisplayP3(const double X,const double Y,
959 const double Z,double *red,double *green,double *blue)
960{
961 double
962 b,
963 g,
964 r;
965
966 r=2.49349691194142500*X-0.93138361791912390*Y-0.402710784450716840*Z;
967 g=(-0.82948896956157470)*X+1.76266406031834630*Y+0.023624685841943577*Z;
968 b=0.03584583024378447*X-0.07617238926804182*Y+0.956884524007687200*Z;
969 *red=QuantumScale*EncodePixelGamma((double) QuantumRange*r);
970 *green=QuantumScale*EncodePixelGamma((double) QuantumRange*g);
971 *blue=QuantumScale*EncodePixelGamma((double) QuantumRange*b);
972}
973
974static inline void ConvertRGBToDisplayP3(const double red,const double green,
975 const double blue,double *r,double *g,double *b)
976{
977 double
978 X,
979 Y,
980 Z;
981
982 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
983 ConvertXYZToDisplayP3(X,Y,Z,r,g,b);
984}
985
986static inline void ConvertRGBToHSV(const double red,const double green,
987 const double blue,double *hue,double *saturation,double *value)
988{
989 double
990 c,
991 max,
992 min;
993
994 /*
995 Convert RGB to HSV colorspace.
996 */
997 assert(hue != (double *) NULL);
998 assert(saturation != (double *) NULL);
999 assert(value != (double *) NULL);
1000 max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
1001 QuantumScale*blue));
1002 min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
1003 QuantumScale*blue));
1004 c=max-min;
1005 *value=max;
1006 if (c <= 0.0)
1007 {
1008 *hue=0.0;
1009 *saturation=0.0;
1010 return;
1011 }
1012 if (fabs(max-QuantumScale*red) < MagickEpsilon)
1013 {
1014 *hue=(QuantumScale*green-QuantumScale*blue)/c;
1015 if ((QuantumScale*green) < (QuantumScale*blue))
1016 *hue+=6.0;
1017 }
1018 else
1019 if (fabs(max-QuantumScale*green) < MagickEpsilon)
1020 *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
1021 else
1022 *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
1023 *hue*=60.0/360.0;
1024 *saturation=c*MagickSafeReciprocal(max);
1025}
1026
1027static inline void ConvertRGBToHWB(const double red,const double green,
1028 const double blue,double *hue,double *whiteness,double *blackness)
1029{
1030 double
1031 f,
1032 p,
1033 v,
1034 w;
1035
1036 /*
1037 Convert RGB to HWB colorspace.
1038 */
1039 assert(hue != (double *) NULL);
1040 assert(whiteness != (double *) NULL);
1041 assert(blackness != (double *) NULL);
1042 w=MagickMin(red,MagickMin(green,blue));
1043 v=MagickMax(red,MagickMax(green,blue));
1044 *blackness=1.0-QuantumScale*v;
1045 *whiteness=QuantumScale*w;
1046 if (fabs(v-w) < MagickEpsilon)
1047 {
1048 *hue=(-1.0);
1049 return;
1050 }
1051 f=(fabs(red-w) < MagickEpsilon) ? green-blue :
1052 ((fabs(green-w) < MagickEpsilon) ? blue-red : red-green);
1053 p=(fabs(red-w) < MagickEpsilon) ? 3.0 :
1054 ((fabs(green-w) < MagickEpsilon) ? 5.0 : 1.0);
1055 *hue=(p-f/(v-1.0*w))/6.0;
1056}
1057
1058static inline void ConvertXYZToLab(const double X,const double Y,const double Z,
1059 const IlluminantType illuminant,double *L,double *a,double *b)
1060{
1061 double
1062 x,
1063 y,
1064 z;
1065
1066 if ((X/illuminant_tristimulus[illuminant].x) > CIEEpsilon)
1067 x=pow(X/illuminant_tristimulus[illuminant].x,1.0/3.0);
1068 else
1069 x=(CIEK*X/illuminant_tristimulus[illuminant].x+16.0)/116.0;
1070 if ((Y/illuminant_tristimulus[illuminant].y) > CIEEpsilon)
1071 y=pow(Y/illuminant_tristimulus[illuminant].y,1.0/3.0);
1072 else
1073 y=(CIEK*Y/illuminant_tristimulus[illuminant].y+16.0)/116.0;
1074 if ((Z/illuminant_tristimulus[illuminant].z) > CIEEpsilon)
1075 z=pow(Z/illuminant_tristimulus[illuminant].z,1.0/3.0);
1076 else
1077 z=(CIEK*Z/illuminant_tristimulus[illuminant].z+16.0)/116.0;
1078 *L=((116.0*y)-16.0)/100.0;
1079 *a=(500.0*(x-y))/255.0+0.5;
1080 *b=(200.0*(y-z))/255.0+0.5;
1081}
1082
1083static inline void ConvertRGBToLab(const double red,const double green,
1084 const double blue,const IlluminantType illuminant,double *L,double *a,
1085 double *b)
1086{
1087 double
1088 X,
1089 Y,
1090 Z;
1091
1092 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1093 ConvertXYZToLab(X,Y,Z,illuminant,L,a,b);
1094}
1095
1096static inline void ConvertXYZToLCHab(const double X,const double Y,
1097 const double Z,const IlluminantType illuminant,double *luma,double *chroma,
1098 double *hue)
1099{
1100 double
1101 a,
1102 b;
1103
1104 ConvertXYZToLab(X,Y,Z,illuminant,luma,&a,&b);
1105 *chroma=hypot(a-0.5,b-0.5)/1.0+0.5;
1106 *hue=180.0*atan2(b-0.5,a-0.5)/MagickPI/360.0;
1107 if (*hue < 0.0)
1108 *hue+=1.0;
1109}
1110
1111static inline void ConvertRGBToLCHab(const double red,const double green,
1112 const double blue,const IlluminantType illuminant,double *luma,double *chroma,
1113 double *hue)
1114{
1115 double
1116 X,
1117 Y,
1118 Z;
1119
1120 /*
1121 Convert RGB to LCHab colorspace.
1122 */
1123 assert(luma != (double *) NULL);
1124 assert(chroma != (double *) NULL);
1125 assert(hue != (double *) NULL);
1126 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1127 ConvertXYZToLCHab(X,Y,Z,illuminant,luma,chroma,hue);
1128}
1129
1130static inline void ConvertXYZToLuv(const double X,const double Y,const double Z,
1131 const IlluminantType illuminant,double *L,double *u,double *v)
1132{
1133 double
1134 alpha;
1135
1136 if ((Y/illuminant_tristimulus[illuminant].y) > CIEEpsilon)
1137 *L=(double) (116.0*pow(Y/illuminant_tristimulus[illuminant].y,
1138 1.0/3.0)-16.0);
1139 else
1140 *L=CIEK*(Y/illuminant_tristimulus[illuminant].y);
1141 alpha=MagickSafeReciprocal(X+15.0*Y+3.0*Z);
1142 *u=13.0*(*L)*((4.0*alpha*X)-(4.0*illuminant_tristimulus[illuminant].x/
1143 (illuminant_tristimulus[illuminant].x+15.0*
1144 illuminant_tristimulus[illuminant].y+3.0*
1145 illuminant_tristimulus[illuminant].z)));
1146 *v=13.0*(*L)*((9.0*alpha*Y)-(9.0*illuminant_tristimulus[illuminant].y/
1147 (illuminant_tristimulus[illuminant].x+15.0*
1148 illuminant_tristimulus[illuminant].y+3.0*
1149 illuminant_tristimulus[illuminant].z)));
1150 *L/=100.0;
1151 *u=(*u+134.0)/354.0;
1152 *v=(*v+140.0)/262.0;
1153}
1154
1155static inline void ConvertXYZToLCHuv(const double X,const double Y,
1156 const double Z,const IlluminantType illuminant,double *luma,double *chroma,
1157 double *hue)
1158{
1159 double
1160 u,
1161 v;
1162
1163 ConvertXYZToLuv(X,Y,Z,illuminant,luma,&u,&v);
1164 *chroma=hypot(354.0*u-134.0,262.0*v-140.0)/255.0+0.5;
1165 *hue=180.0*atan2(262.0*v-140.0,354.0*u-134.0)/MagickPI/360.0;
1166 if (*hue < 0.0)
1167 *hue+=1.0;
1168}
1169
1170static inline void ConvertRGBToLCHuv(const double red,const double green,
1171 const double blue,const IlluminantType illuminant,double *luma,double *chroma,
1172 double *hue)
1173{
1174 double
1175 X,
1176 Y,
1177 Z;
1178
1179 /*
1180 Convert RGB to LCHuv colorspace.
1181 */
1182 assert(luma != (double *) NULL);
1183 assert(chroma != (double *) NULL);
1184 assert(hue != (double *) NULL);
1185 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1186 ConvertXYZToLCHuv(X,Y,Z,illuminant,luma,chroma,hue);
1187}
1188
1189static inline void ConvertXYZToProPhoto(const double X,const double Y,
1190 const double Z,double *red,double *green,double *blue)
1191{
1192 double
1193 b,
1194 g,
1195 r;
1196
1197 r=1.3457989731028281*X-0.25558010007997534*Y-0.05110628506753401*Z;
1198 g=(-0.5446224939028347)*X+1.50823274131327810*Y+0.02053603239147973*Z;
1199 b=0.0000000000000000*X+0.0000000000000000*Y+1.21196754563894540*Z;
1200 *red=QuantumScale*EncodePixelGamma((double) QuantumRange*r);
1201 *green=QuantumScale*EncodePixelGamma((double) QuantumRange*g);
1202 *blue=QuantumScale*EncodePixelGamma((double) QuantumRange*b);
1203}
1204
1205static inline void ConvertRGBToProPhoto(const double red,const double green,
1206 const double blue,double *r,double *g,double *b)
1207{
1208 double
1209 X,
1210 Y,
1211 Z;
1212
1213 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1214 ConvertXYZToProPhoto(X,Y,Z,r,g,b);
1215}
1216
1217static inline void ConvertXYZToLMS(const double x,const double y,
1218 const double z,double *L,double *M,double *S)
1219{
1220 *L=0.7328*x+0.4296*y-0.1624*z;
1221 *M=(-0.7036*x+1.6975*y+0.0061*z);
1222 *S=0.0030*x+0.0136*y+0.9834*z;
1223}
1224
1225static inline void ConvertRGBToLMS(const double red,const double green,
1226 const double blue,double *L,double *M,double *S)
1227{
1228 double
1229 X,
1230 Y,
1231 Z;
1232
1233 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1234 ConvertXYZToLMS(X,Y,Z,L,M,S);
1235}
1236
1237static inline void ConvertRGBToLuv(const double red,const double green,
1238 const double blue,const IlluminantType illuminant,double *L,double *u,
1239 double *v)
1240{
1241 double
1242 X,
1243 Y,
1244 Z;
1245
1246 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1247 ConvertXYZToLuv(X,Y,Z,illuminant,L,u,v);
1248}
1249
1250static inline void ConvertRGBToxyY(const double red,const double green,
1251 const double blue,double *low_x,double *low_y,double *cap_Y)
1252{
1253 double
1254 gamma,
1255 X,
1256 Y,
1257 Z;
1258
1259 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1260 gamma=MagickSafeReciprocal(X+Y+Z);
1261 *low_x=gamma*X;
1262 *low_y=gamma*Y;
1263 *cap_Y=Y;
1264}
1265
1266static inline void ConvertXYZToJzazbz(const double X,const double Y,
1267 const double Z,const double white_luminance,double *Jz,double *az,double *bz)
1268{
1269#define Jzazbz_b (1.15) /* https://observablehq.com/@jrus/jzazbz */
1270#define Jzazbz_g (0.66) /* refactored by N. Robidoux */
1271#define Jzazbz_c1 (3424.0/4096.0)
1272#define Jzazbz_c2 (2413.0/128.0)
1273#define Jzazbz_c3 (2392.0/128.0)
1274#define Jzazbz_n (2610.0/16384.0)
1275#define Jzazbz_p (1.7*2523.0/32.0)
1276#define Jzazbz_d (-0.56)
1277#define Jzazbz_d0 (1.6295499532821566e-11)
1278#define Jzazbz_LX (0.41478972)
1279#define Jzazbz_LY (0.579999)
1280#define Jzazbz_LZ (0.0146480)
1281#define Jzazbz_MX (-0.2015100)
1282#define Jzazbz_MY (1.120649)
1283#define Jzazbz_MZ (0.0531008)
1284#define Jzazbz_SX (-0.0166008)
1285#define Jzazbz_SY (0.264800)
1286#define Jzazbz_SZ (0.6684799)
1287#define Jzazbz_aL (3.52400)
1288#define Jzazbz_aM (-4.066708)
1289#define Jzazbz_aS (0.542708)
1290#define Jzazbz_bL (0.199076)
1291#define Jzazbz_bM (1.096799)
1292#define Jzazbz_bS (-1.295875)
1293
1294 double
1295 a,
1296 b,
1297 dL,
1298 dM,
1299 dS,
1300 gL,
1301 gM,
1302 gS,
1303 nL,
1304 nM,
1305 nS,
1306 Iz,
1307 J,
1308 JdI,
1309 L,
1310 Lp,
1311 M,
1312 Mp,
1313 S,
1314 Sp,
1315 WLr,
1316 Xp,
1317 Yp;
1318
1319 WLr=MagickSafeReciprocal(white_luminance);
1320 Xp=Z+Jzazbz_b*(X-Z); /* If X and Z are vectorized, better done */
1321 Yp=X+Jzazbz_g*(Y-X); /* as Xp=Jzazbz_b*X+(1.0-Jzazbz_b)*Z; etc. */
1322 L=Jzazbz_LZ*Z;
1323 M=Jzazbz_MZ*Z;
1324 S=Jzazbz_SZ*Z;
1325 L+=Jzazbz_LX*Xp;
1326 M+=Jzazbz_MX*Xp;
1327 S+=Jzazbz_SX*Xp;
1328 L+=Jzazbz_LY*Yp;
1329 M+=Jzazbz_MY*Yp;
1330 S+=Jzazbz_SY*Yp;
1331 gL=pow(L*WLr,Jzazbz_n);
1332 gM=pow(M*WLr,Jzazbz_n);
1333 gS=pow(S*WLr,Jzazbz_n);
1334 nL=Jzazbz_c1+Jzazbz_c2*gL;
1335 nM=Jzazbz_c1+Jzazbz_c2*gM;
1336 nS=Jzazbz_c1+Jzazbz_c2*gS;
1337 dL=1.0+Jzazbz_c3*gL;
1338 dM=1.0+Jzazbz_c3*gM;
1339 dS=1.0+Jzazbz_c3*gS;
1340 Lp=pow(nL/dL,Jzazbz_p);
1341 Mp=pow(nM/dM,Jzazbz_p);
1342 Sp=pow(nS/dS,Jzazbz_p);
1343 Iz=(Lp+Mp)*0.5;
1344 JdI=Jzazbz_d*Iz;
1345 J=(JdI+Iz)/(JdI+1.0)-Jzazbz_d0;
1346 a=0.5+Jzazbz_aL*Lp;
1347 b=0.5+Jzazbz_bL*Lp;
1348 a+=Jzazbz_aM*Mp;
1349 b+=Jzazbz_bM*Mp;
1350 a+=Jzazbz_aS*Sp;
1351 b+=Jzazbz_bS*Sp;
1352 *Jz=IsNaN(J) != 0 ? 0.0 : J;
1353 *az=IsNaN(a) != 0 ? 0.5 : a;
1354 *bz=IsNaN(b) != 0 ? 0.5 : b;
1355}
1356
1357static inline void ConvertRGBToJzazbz(const double red,const double green,
1358 const double blue,const double white_luminance,double *Jz,double *az,
1359 double *bz)
1360{
1361 double
1362 X,
1363 Y,
1364 Z;
1365
1366 ConvertRGBToXYZ(red,blue,green,&X,&Y,&Z);
1367 ConvertXYZToJzazbz(X,Y,Z,white_luminance,Jz,az,bz);
1368}
1369
1370static inline void ConvertJzazbzToXYZ(const double Jz,const double az,
1371 const double bz,const double white_luminance,double *X,double *Y,double *Z)
1372{
1373#define Jzazbz_Ca (0.138605043271539)
1374#define Jzazbz_Cb (0.0580473161561189)
1375#define Jzazbz_Sa (-0.0960192420263189)
1376#define Jzazbz_Sb (-0.811891896056039)
1377#define Jzazbz_XL (1.92422643578761)
1378#define Jzazbz_XM (-1.00479231259537)
1379#define Jzazbz_XS (0.037651404030618)
1380#define Jzazbz_YL (0.350316762094999)
1381#define Jzazbz_YM (0.726481193931655)
1382#define Jzazbz_YS (-0.065384422948085)
1383#define Jzazbz_ZL (-0.0909828109828476)
1384#define Jzazbz_ZM (-0.312728290523074)
1385#define Jzazbz_ZS (1.52276656130526)
1386#define mJzazbz_c3 (-2392.0/128.0)
1387
1388 double
1389 azz,
1390 bzz,
1391 C,
1392 dL,
1393 dM,
1394 dS,
1395 g,
1396 gL,
1397 gM,
1398 gS,
1399 Jnr,
1400 Jpr,
1401 L,
1402 Lp,
1403 M,
1404 Mp,
1405 S,
1406 Sp,
1407 nL,
1408 nM,
1409 nS,
1410 Xp,
1411 Zp,
1412 Yp;
1413
1414 g=Jz+Jzazbz_d0;
1415 azz=az-0.5;
1416 bzz=bz-0.5;
1417 C=Jzazbz_Ca*azz+Jzazbz_Cb*bzz;
1418 Sp=g/(1.0+Jzazbz_d*(1.0-g));
1419 Lp=Sp+C;
1420 Mp=Sp-C;
1421 Sp+=Jzazbz_Sa*azz;
1422 Sp+=Jzazbz_Sb*bzz;
1423 Jpr=1.0/Jzazbz_p;
1424 gL=pow(Lp,Jpr);
1425 gM=pow(Mp,Jpr);
1426 gS=pow(Sp,Jpr);
1427 Jnr=1.0/Jzazbz_n;
1428 nL=gL-Jzazbz_c1;
1429 nM=gM-Jzazbz_c1;
1430 nS=gS-Jzazbz_c1;
1431 dL=Jzazbz_c2+mJzazbz_c3*gL;
1432 dM=Jzazbz_c2+mJzazbz_c3*gM;
1433 dS=Jzazbz_c2+mJzazbz_c3*gS;
1434 L=pow(nL/dL,Jnr);
1435 M=pow(nM/dM,Jnr);
1436 S=pow(nS/dS,Jnr);
1437 L*=white_luminance;
1438 M*=white_luminance;
1439 S*=white_luminance;
1440 Zp=Jzazbz_ZL*L;
1441 Xp=Jzazbz_XL*L;
1442 Yp=Jzazbz_YL*L;
1443 Zp+=Jzazbz_ZM*M;
1444 Xp+=Jzazbz_XM*M;
1445 Yp+=Jzazbz_YM*M;
1446 Zp+=Jzazbz_ZS*S;
1447 Xp+=Jzazbz_XS*S;
1448 Yp+=Jzazbz_YS*S;
1449 Zp=IsNaN(Zp) != 0 ? 0.0 : Zp;
1450 Xp=Zp+(Xp-Zp)/Jzazbz_b; /* If Xp and Zp are vectorized, better done */
1451 Xp=IsNaN(Xp) != 0 ? 0.0 : Xp; /* as rJzazbz_b = 1.0/Jzazbz_b; */
1452 Yp=Xp+(Yp-Xp)/Jzazbz_g; /* Xp=rJzazbz_b*Xp+(1.0-rJzazbz_b)*Zp; etc. */
1453 Yp=IsNaN(Yp) != 0 ? 0.0 : Yp;
1454 *Z=Zp;
1455 *X=Xp;
1456 *Y=Yp;
1457}
1458
1459static inline void ConvertJzazbzToRGB(const double Jz,const double az,
1460 const double bz,const double white_luminance,double *red,double *green,
1461 double *blue)
1462{
1463 double
1464 X,
1465 Y,
1466 Z;
1467
1468 ConvertJzazbzToXYZ(Jz,az,bz,white_luminance,&X,&Y,&Z);
1469 ConvertXYZToRGB(X,Y,Z,red,blue,green);
1470}
1471
1472static inline void ConvertOklabToRGB(const double L,const double a,
1473 const double b,double *red,double *green,double *blue)
1474{
1475#define Oklab_la (0.3963377774)
1476#define Oklab_lb (0.2158037573)
1477#define Oklab_ma (-0.1055613458)
1478#define Oklab_mb (-0.0638541728)
1479#define Oklab_sa (-0.0894841775)
1480#define Oklab_sb (-1.2914855480)
1481#define Oklab_Rl (4.0767416621)
1482#define Oklab_Rm (-3.3077115913)
1483#define Oklab_Rs (0.2309699292)
1484#define Oklab_Gl (-1.2684380046)
1485#define Oklab_Gm (2.6097574011)
1486#define Oklab_Gs (-0.3413193965)
1487#define Oklab_Bl (-0.0041960863)
1488#define Oklab_Bm (-0.7034186147)
1489#define Oklab_Bs (1.7076147010)
1490
1491 double
1492 aa,
1493 B,
1494 bb,
1495 Bl,
1496 Bm,
1497 Bs,
1498 G,
1499 Gl,
1500 Gm,
1501 Gs,
1502 l,
1503 m,
1504 R,
1505 Rl,
1506 Rm,
1507 Rs,
1508 s;
1509
1510 aa=a-0.5;
1511 bb=b-0.5;
1512 l=L+Oklab_la*aa+Oklab_lb*bb;
1513 m=L+Oklab_ma*aa+Oklab_mb*bb;
1514 s=L+Oklab_sa*aa+Oklab_sb*bb;
1515 l*=l*l;
1516 m*=m*m;
1517 s*=s*s;
1518 Rl=Oklab_Rl*(double) QuantumRange; /* constant folding */
1519 Rm=Oklab_Rm*(double) QuantumRange;
1520 Rs=Oklab_Rs*(double) QuantumRange;
1521 Gl=Oklab_Gl*(double) QuantumRange;
1522 Gm=Oklab_Gm*(double) QuantumRange;
1523 Gs=Oklab_Gs*(double) QuantumRange;
1524 Bl=Oklab_Bl*(double) QuantumRange;
1525 Bm=Oklab_Bm*(double) QuantumRange;
1526 Bs=Oklab_Bs*(double) QuantumRange;
1527 R=Rl*l+Rm*m+Rs*s;
1528 G=Gl*l+Gm*m+Gs*s;
1529 B=Bl*l+Bm*m+Bs*s;
1530 *red=EncodePixelGamma(R);
1531 *green=EncodePixelGamma(G);
1532 *blue=EncodePixelGamma(B);
1533}
1534
1535static inline void ConvertOklchToRGB(const double L,const double C,
1536 const double H,double *red,double *green,double *blue)
1537{
1538 /* OKLCH → OKLab */
1539 const double a = C*cos(H);
1540 const double b_ = C*sin(H);
1541
1542 /* OKLab → nonlinear LMS */
1543 const double l_ = L+Oklab_la*a+Oklab_lb*b_;
1544 const double m_ = L+Oklab_ma*a+Oklab_mb*b_;
1545 const double s_ = L+Oklab_sa*a+Oklab_sb*b_;
1546
1547 /* Undo nonlinear transform */
1548 const double l = l_*l_*l_;
1549 const double m = m_*m_*m_;
1550 const double s = s_*s_*s_;
1551
1552 /* LMS → linear RGB */
1553 *red=EncodePixelGamma((double) QuantumRange*(Oklab_Rl*l+Oklab_Rm*m+
1554 Oklab_Rs*s));
1555 *green=EncodePixelGamma((double) QuantumRange*(Oklab_Gl*l+Oklab_Gm*m+
1556 Oklab_Gs*s));
1557 *blue=EncodePixelGamma((double) QuantumRange*(Oklab_Bl*l+Oklab_Bm*m+
1558 Oklab_Bs*s));
1559}
1560
1561static inline void ConvertRGBToOklab(const double red,const double green,
1562 const double blue,double *L,double *a,double *b)
1563{
1564#define Oklab_lR (0.4122214708)
1565#define Oklab_lG (0.5363325363)
1566#define Oklab_lB (0.0514459929)
1567#define Oklab_mR (0.2119034982)
1568#define Oklab_mG (0.6806995451)
1569#define Oklab_mB (0.1073969566)
1570#define Oklab_sR (0.0883024619)
1571#define Oklab_sG (0.2817188376)
1572#define Oklab_sB (0.6299787005)
1573#define Oklab_Ll (0.2104542553)
1574#define Oklab_Lm (0.7936177850)
1575#define Oklab_Ls (-0.0040720468)
1576#define Oklab_al (1.9779984951)
1577#define Oklab_am (-2.4285922050)
1578#define Oklab_as (0.4505937099)
1579#define Oklab_bl (0.0259040371)
1580#define Oklab_bm (0.7827717662)
1581#define Oklab_bs (-0.8086757660)
1582
1583 double
1584 B,
1585 G,
1586 l,
1587 lR,
1588 lG,
1589 lB,
1590 m,
1591 mR,
1592 mG,
1593 mB,
1594 R,
1595 s,
1596 sR,
1597 sG,
1598 sB;
1599
1600 R=DecodePixelGamma(red);
1601 G=DecodePixelGamma(green);
1602 B=DecodePixelGamma(blue);
1603 lR=Oklab_lR*QuantumScale; /* constant folding */
1604 lG=Oklab_lG*QuantumScale;
1605 lB=Oklab_lB*QuantumScale;
1606 mR=Oklab_mR*QuantumScale;
1607 mG=Oklab_mG*QuantumScale;
1608 mB=Oklab_mB*QuantumScale;
1609 sR=Oklab_sR*QuantumScale;
1610 sG=Oklab_sG*QuantumScale;
1611 sB=Oklab_sB*QuantumScale;
1612 l=lR*R+lG*G+lB*B;
1613 m=mR*R+mG*G+mB*B;
1614 s=sR*R+sG*G+sB*B;
1615 l=cbrt(l);
1616 m=cbrt(m);
1617 s=cbrt(s);
1618 *L=Oklab_Ll*l+Oklab_Lm*m+Oklab_Ls*s;
1619 *a=Oklab_al*l+Oklab_am*m+Oklab_as*s+0.5;
1620 *b=Oklab_bl*l+Oklab_bm*m+Oklab_bs*s+0.5;
1621}
1622
1623static inline void ConvertRGBToOklch(const double red,const double green,
1624 const double blue,double *L,double *C,double *H)
1625{
1626 /* Linear RGB → LMS */
1627 const double l = Oklab_lR*QuantumScale*DecodePixelGamma(red)+
1628 Oklab_lG*QuantumScale*DecodePixelGamma(green)+
1629 Oklab_lB*QuantumScale*DecodePixelGamma(blue);
1630 const double m = Oklab_mR*QuantumScale*DecodePixelGamma(red)+
1631 Oklab_mG*QuantumScale*DecodePixelGamma(green)+
1632 Oklab_mB*QuantumScale*DecodePixelGamma(blue);
1633 const double s = Oklab_sR*QuantumScale*DecodePixelGamma(red)+
1634 Oklab_sG*QuantumScale*DecodePixelGamma(green)+
1635 Oklab_sB*QuantumScale*DecodePixelGamma(blue);
1636
1637 /* Nonlinear transform */
1638 const double l_ = cbrt(l);
1639 const double m_ = cbrt(m);
1640 const double s_ = cbrt(s);
1641
1642 /* LMS → OKLab */
1643 const double L_ok = Oklab_Ll*l_+Oklab_Lm*m_+Oklab_Ls*s_;
1644 const double a_ok = Oklab_al*l_+Oklab_am*m_+Oklab_as*s_;
1645 const double b_ok = Oklab_bl*l_+Oklab_bm*m_+Oklab_bs*s_;
1646
1647 /* OKLab → OKLCH */
1648 const double C_ok = sqrt(a_ok*a_ok+b_ok*b_ok);
1649 double H_ok = atan2(b_ok,a_ok); /* radians */
1650
1651 if (H_ok < 0.0)
1652 H_ok+=2.0*MagickPI;
1653 *L=L_ok;
1654 *C=C_ok;
1655 *H=H_ok;
1656}
1657
1658static inline void ConvertRGBToYDbDr(const double red,const double green,
1659 const double blue,double *Y,double *Db,double *Dr)
1660{
1661 *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
1662 *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
1663 *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
1664}
1665
1666static inline void ConvertRGBToYIQ(const double red,const double green,
1667 const double blue,double *Y,double *I,double *Q)
1668{
1669 *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
1670 *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
1671 *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
1672}
1673
1674static inline void ConvertRGBToYPbPr(const double red,const double green,
1675 const double blue,double *Y,double *Pb,double *Pr)
1676{
1677 *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
1678 *Pb=QuantumScale*((-0.1687367)*red-0.331264*green+0.5*blue)+0.5;
1679 *Pr=QuantumScale*(0.5*red-0.418688*green-0.081312*blue)+0.5;
1680}
1681
1682static inline void ConvertRGBToYCbCr(const double red,const double green,
1683 const double blue,double *Y,double *Cb,double *Cr)
1684{
1685 ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
1686}
1687
1688static inline void ConvertRGBToYUV(const double red,const double green,
1689 const double blue,double *Y,double *U,double *V)
1690{
1691 *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
1692 *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
1693 *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
1694}
1695
1696static inline void ConvertRGBToCMYK(PixelInfo *pixel)
1697{
1698 MagickRealType
1699 black,
1700 blue,
1701 cyan,
1702 green,
1703 magenta,
1704 red,
1705 yellow;
1706
1707 if (pixel->colorspace != sRGBColorspace)
1708 {
1709 red=QuantumScale*pixel->red;
1710 green=QuantumScale*pixel->green;
1711 blue=QuantumScale*pixel->blue;
1712 }
1713 else
1714 {
1715 red=QuantumScale*DecodePixelGamma(pixel->red);
1716 green=QuantumScale*DecodePixelGamma(pixel->green);
1717 blue=QuantumScale*DecodePixelGamma(pixel->blue);
1718 }
1719 if ((fabs((double) red) < MagickEpsilon) &&
1720 (fabs((double) green) < MagickEpsilon) &&
1721 (fabs((double) blue) < MagickEpsilon))
1722 {
1723 pixel->black=(MagickRealType) QuantumRange;
1724 return;
1725 }
1726 cyan=(MagickRealType) (1.0-red);
1727 magenta=(MagickRealType) (1.0-green);
1728 yellow=(MagickRealType) (1.0-blue);
1729 black=cyan;
1730 if (magenta < black)
1731 black=magenta;
1732 if (yellow < black)
1733 black=yellow;
1734 cyan=(MagickRealType) (MagickSafeReciprocal(1.0-black)*(cyan-black));
1735 magenta=(MagickRealType) (MagickSafeReciprocal(1.0-black)*(magenta-black));
1736 yellow=(MagickRealType) (MagickSafeReciprocal(1.0-black)*(yellow-black));
1737 pixel->colorspace=CMYKColorspace;
1738 pixel->red=(MagickRealType) QuantumRange*cyan;
1739 pixel->green=(MagickRealType) QuantumRange*magenta;
1740 pixel->blue=(MagickRealType) QuantumRange*yellow;
1741 pixel->black=(MagickRealType) QuantumRange*black;
1742}
1743
1744static inline void ConvertYPbPrToRGB(const double Y,const double Pb,
1745 const double Pr,double *red,double *green,double *blue)
1746{
1747 *red=(double) QuantumRange*(0.99999999999914679361*Y-1.2188941887145875e-06*
1748 (Pb-0.5)+1.4019995886561440468*(Pr-0.5));
1749 *green=(double) QuantumRange*(0.99999975910502514331*Y-0.34413567816504303521*
1750 (Pb-0.5)-0.71413649331646789076*(Pr-0.5));
1751 *blue=(double) QuantumRange*(1.00000124040004623180*Y+1.77200006607230409200*
1752 (Pb-0.5)+2.1453384174593273e-06*(Pr-0.5));
1753}
1754
1755static inline void ConvertYCbCrToRGB(const double Y,const double Cb,
1756 const double Cr,double *red,double *green,double *blue)
1757{
1758 ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
1759}
1760
1761static inline void ConvertYDbDrToRGB(const double Y,const double Db,
1762 const double Dr,double *red,double *green,double *blue)
1763{
1764 *red=(double) QuantumRange*(Y+9.2303716147657e-05*(Db-0.5)-
1765 0.52591263066186533*(Dr-0.5));
1766 *green=(double) QuantumRange*(Y-0.12913289889050927*(Db-0.5)+
1767 0.26789932820759876*(Dr-0.5));
1768 *blue=(double) QuantumRange*(Y+0.66467905997895482*(Db-0.5)-
1769 7.9202543533108e-05*(Dr-0.5));
1770}
1771
1772static inline void ConvertYIQToRGB(const double Y,const double I,const double Q,
1773 double *red,double *green,double *blue)
1774{
1775 *red=(double) QuantumRange*(Y+0.9562957197589482261*(I-0.5)+
1776 0.6210244164652610754*(Q-0.5));
1777 *green=(double) QuantumRange*(Y-0.2721220993185104464*(I-0.5)-
1778 0.6473805968256950427*(Q-0.5));
1779 *blue=(double) QuantumRange*(Y-1.1069890167364901945*(I-0.5)+
1780 1.7046149983646481374*(Q-0.5));
1781}
1782
1783static inline void ConvertxyYToRGB(const double low_x,const double low_y,
1784 const double cap_Y,double *red,double *green,double *blue)
1785{
1786 double
1787 gamma,
1788 X,
1789 Y,
1790 Z;
1791
1792 gamma=MagickSafeReciprocal(low_y);
1793 X=gamma*cap_Y*low_x;
1794 Y=cap_Y;
1795 Z=gamma*cap_Y*(1.0-low_x-low_y);
1796 ConvertXYZToRGB(X,Y,Z,red,green,blue);
1797}
1798
1799static inline void ConvertYUVToRGB(const double Y,const double U,const double V,
1800 double *red,double *green,double *blue)
1801{
1802 *red=(double) QuantumRange*(Y-3.945707070708279e-05*(U-0.5)+
1803 1.1398279671717170825*(V-0.5));
1804 *green=(double) QuantumRange*(Y-0.3946101641414141437*(U-0.5)-
1805 0.5805003156565656797*(V-0.5));
1806 *blue=(double) QuantumRange*(Y+2.0319996843434342537*(U-0.5)-
1807 4.813762626262513e-04*(V-0.5));
1808}
1809
1810static inline MagickBooleanType IsCMYKColorspace(
1811 const ColorspaceType colorspace)
1812{
1813 if (colorspace == CMYKColorspace)
1814 return(MagickTrue);
1815 return(MagickFalse);
1816}
1817
1818static inline MagickBooleanType IsGrayColorspace(
1819 const ColorspaceType colorspace)
1820{
1821 if ((colorspace == LinearGRAYColorspace) || (colorspace == GRAYColorspace))
1822 return(MagickTrue);
1823 return(MagickFalse);
1824}
1825
1826static inline MagickBooleanType IsGrayImageType(const ImageType type)
1827{
1828 if ((type == GrayscaleType) || (type == GrayscaleAlphaType) ||
1829 (type == BilevelType))
1830 return(MagickTrue);
1831 return(MagickFalse);
1832}
1833
1834static inline MagickBooleanType IsHueCompatibleColorspace(
1835 const ColorspaceType colorspace)
1836{
1837 if ((colorspace == HCLColorspace) || (colorspace == HCLpColorspace) ||
1838 (colorspace == HSBColorspace) || (colorspace == HSIColorspace) ||
1839 (colorspace == HSLColorspace) || (colorspace == HSVColorspace))
1840 return(MagickTrue);
1841 return(MagickFalse);
1842}
1843
1844static inline MagickBooleanType IsLabCompatibleColorspace(
1845 const ColorspaceType colorspace)
1846{
1847 if ((colorspace == LabColorspace) || (colorspace == LCHColorspace) ||
1848 (colorspace == LCHabColorspace) || (colorspace == LCHuvColorspace) ||
1849 (colorspace == OklabColorspace))
1850 return(MagickTrue);
1851 return(MagickFalse);
1852}
1853
1854static inline MagickBooleanType IsRGBColorspace(const ColorspaceType colorspace)
1855{
1856 if ((colorspace == RGBColorspace) || (colorspace == scRGBColorspace) ||
1857 (colorspace == LinearGRAYColorspace))
1858 return(MagickTrue);
1859 return(MagickFalse);
1860}
1861
1862static inline MagickBooleanType IssRGBColorspace(
1863 const ColorspaceType colorspace)
1864{
1865 if ((colorspace == sRGBColorspace) || (colorspace == TransparentColorspace))
1866 return(MagickTrue);
1867 return(MagickFalse);
1868}
1869
1870static inline MagickBooleanType IssRGBCompatibleColorspace(
1871 const ColorspaceType colorspace)
1872{
1873 if ((colorspace == sRGBColorspace) || (colorspace == RGBColorspace) ||
1874 (colorspace == Adobe98Colorspace) || (colorspace == ProPhotoColorspace) ||
1875 (colorspace == DisplayP3Colorspace) || (colorspace == scRGBColorspace) ||
1876 (colorspace == TransparentColorspace) || (colorspace == GRAYColorspace) ||
1877 (colorspace == LinearGRAYColorspace))
1878 return(MagickTrue);
1879 return(MagickFalse);
1880}
1881
1882static inline MagickBooleanType IsYCbCrCompatibleColorspace(
1883 const ColorspaceType colorspace)
1884{
1885 if ((colorspace == YCbCrColorspace) ||
1886 (colorspace == Rec709YCbCrColorspace) ||
1887 (colorspace == Rec601YCbCrColorspace))
1888 return(MagickTrue);
1889 return(MagickFalse);
1890}
1891
1892extern MagickPrivate void
1893 ConformPixelInfoColorspace(const Image *,PixelInfo *,ExceptionInfo *),
1894 ConvertGenericToRGB(const ColorspaceType,const double,const double,
1895 const double,const double,const IlluminantType,double *,double *,double *),
1896 ConvertRGBToGeneric(const ColorspaceType,const double,const double,
1897 const double,const double,const IlluminantType,double *,double *,double *);
1898
1899#if defined(__cplusplus) || defined(c_plusplus)
1900}
1901#endif
1902
1903#endif