18#ifndef MAGICKCORE_COLORSPACE_PRIVATE_H
19#define MAGICKCORE_COLORSPACE_PRIVATE_H
21#include "MagickCore/image.h"
22#include "MagickCore/image-private.h"
23#include "MagickCore/pixel.h"
24#include "MagickCore/pixel-accessor.h"
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)
32static const PrimaryInfo
33 illuminant_tristimulus[] =
35 { 1.09850, 1.00000, 0.35585 },
36 { 0.99072, 1.00000, 0.85223 },
37 { 0.98074, 1.00000, 1.18232 },
38 { 0.96422, 1.00000, 0.82521 },
39 { 0.95682, 1.00000, 0.92149 },
40 { 0.95047, 1.00000, 1.08883 },
41 { 0.94972, 1.00000, 1.22638 },
42 { 1.00000, 1.00000, 1.00000 },
43 { 0.99186, 1.00000, 0.67393 },
44 { 0.95041, 1.00000, 1.08747 },
45 { 1.00962, 1.00000, 0.64350 }
48#if defined(__cplusplus) || defined(c_plusplus)
53static inline void ConvertAdobe98ToXYZ(
const double red,
const double green,
54 const double blue,
double *X,
double *Y,
double *Z)
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;
72static inline void ConvertXYZToRGB(
const double X,
const double Y,
const double Z,
73 double *red,
double *green,
double *blue)
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);
88static inline void ConvertAdobe98ToRGB(
const double r,
const double g,
89 const double b,
double *red,
double *green,
double *blue)
96 ConvertAdobe98ToXYZ(r,g,b,&X,&Y,&Z);
97 ConvertXYZToRGB(X,Y,Z,red,green,blue);
100static inline void ConvertCAT02LMSToXYZ(
const double L,
const double M,
101 const double S,
double *X,
double *Y,
double *Z)
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;
111static inline void ConvertCAT02LMSToRGB(
const double L,
const double M,
112 const double S,
double *R,
double *G,
double *B)
119 ConvertCAT02LMSToXYZ(L,M,S,&X,&Y,&Z);
120 ConvertXYZToRGB(X,Y,Z,R,G,B);
123static inline void ConvertCMYKToRGB(PixelInfo *pixel)
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)));
133static inline void ConvertCMYToRGB(
const double cyan,
const double magenta,
134 const double yellow,
double *red,
double *green,
double *blue)
136 *red=(double) QuantumRange*(1.0-cyan);
137 *green=(double) QuantumRange*(1.0-magenta);
138 *blue=(double) QuantumRange*(1.0-yellow);
141static inline void ConvertHCLToRGB(
const double hue,
const double chroma,
142 const double luma,
double *red,
double *green,
double *blue)
156 assert(red != (
double *) NULL);
157 assert(green != (
double *) NULL);
158 assert(blue != (
double *) NULL);
161 x=c*(1.0-fabs(fmod(h,2.0)-1.0));
165 if ((0.0 <= h) && (h < 1.0))
171 if ((1.0 <= h) && (h < 2.0))
177 if ((2.0 <= h) && (h < 3.0))
183 if ((3.0 <= h) && (h < 4.0))
189 if ((4.0 <= h) && (h < 5.0))
195 if ((5.0 <= h) && (h < 6.0))
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);
206static inline void ConvertHCLpToRGB(
const double hue,
const double chroma,
207 const double luma,
double *red,
double *green,
double *blue)
222 assert(red != (
double *) NULL);
223 assert(green != (
double *) NULL);
224 assert(blue != (
double *) NULL);
227 x=c*(1.0-fabs(fmod(h,2.0)-1.0));
231 if ((0.0 <= h) && (h < 1.0))
237 if ((1.0 <= h) && (h < 2.0))
243 if ((2.0 <= h) && (h < 3.0))
249 if ((3.0 <= h) && (h < 4.0))
255 if ((4.0 <= h) && (h < 5.0))
261 if ((5.0 <= h) && (h < 6.0))
266 m=luma-(0.298839*r+0.586811*g+0.114350*b);
276 z=(1.0-luma)/(m+c-luma);
279 *red=(double) QuantumRange*(z*r+m);
280 *green=(double) QuantumRange*(z*g+m);
281 *blue=(double) QuantumRange*(z*b+m);
284static inline void ConvertHSBToRGB(
const double hue,
const double saturation,
285 const double brightness,
double *red,
double *green,
double *blue)
297 assert(red != (
double *) NULL);
298 assert(green != (
double *) NULL);
299 assert(blue != (
double *) NULL);
300 if (fabs(saturation) < MagickEpsilon)
302 *red=(double) QuantumRange*brightness;
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)));
317 *red=(double) QuantumRange*brightness;
318 *green=(double) QuantumRange*t;
319 *blue=(double) QuantumRange*p;
324 *red=(double) QuantumRange*q;
325 *green=(double) QuantumRange*brightness;
326 *blue=(double) QuantumRange*p;
331 *red=(double) QuantumRange*p;
332 *green=(double) QuantumRange*brightness;
333 *blue=(double) QuantumRange*t;
338 *red=(double) QuantumRange*p;
339 *green=(double) QuantumRange*q;
340 *blue=(double) QuantumRange*brightness;
345 *red=(double) QuantumRange*t;
346 *green=(double) QuantumRange*p;
347 *blue=(double) QuantumRange*brightness;
352 *red=(double) QuantumRange*brightness;
353 *green=(double) QuantumRange*p;
354 *blue=(double) QuantumRange*q;
360static inline void ConvertHSIToRGB(
const double hue,
const double saturation,
361 const double intensity,
double *red,
double *green,
double *blue)
372 assert(red != (
double *) NULL);
373 assert(green != (
double *) NULL);
374 assert(blue != (
double *) NULL);
376 h-=360.0*floor(h/360.0);
379 b=intensity*(1.0-saturation);
380 r=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
388 r=intensity*(1.0-saturation);
389 g=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
396 g=intensity*(1.0-saturation);
397 b=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
401 *red=(double) QuantumRange*r;
402 *green=(double) QuantumRange*g;
403 *blue=(double) QuantumRange*b;
406static inline void ConvertHSVToRGB(
const double hue,
const double saturation,
407 const double value,
double *red,
double *green,
double *blue)
418 assert(red != (
double *) NULL);
419 assert(green != (
double *) NULL);
420 assert(blue != (
double *) NULL);
424 h-=360.0*floor(h/360.0);
426 x=c*(1.0-fabs(h-2.0*floor(h/2.0)-1.0));
427 switch ((
int) floor(h))
432 *red=(double) QuantumRange*(min+c);
433 *green=(double) QuantumRange*(min+x);
434 *blue=(double) QuantumRange*min;
439 *red=(double) QuantumRange*(min+x);
440 *green=(double) QuantumRange*(min+c);
441 *blue=(double) QuantumRange*min;
446 *red=(double) QuantumRange*min;
447 *green=(double) QuantumRange*(min+c);
448 *blue=(double) QuantumRange*(min+x);
453 *red=(double) QuantumRange*min;
454 *green=(double) QuantumRange*(min+x);
455 *blue=(double) QuantumRange*(min+c);
460 *red=(double) QuantumRange*(min+x);
461 *green=(double) QuantumRange*min;
462 *blue=(double) QuantumRange*(min+c);
467 *red=(double) QuantumRange*(min+c);
468 *green=(double) QuantumRange*min;
469 *blue=(double) QuantumRange*(min+x);
475static inline void ConvertHWBToRGB(
const double hue,
const double whiteness,
476 const double blackness,
double *red,
double *green,
double *blue)
492 assert(red != (
double *) NULL);
493 assert(green != (
double *) NULL);
494 assert(blue != (
double *) NULL);
496 if (fabs(hue-(-1.0)) < MagickEpsilon)
498 *red=(double) QuantumRange*v;
499 *green=(double) QuantumRange*v;
500 *blue=(double) QuantumRange*v;
503 i=CastDoubleToSsizeT(floor(6.0*hue));
504 f=6.0*hue-(double) i;
507 n=whiteness+f*(v-whiteness);
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;
518 *red=(double) QuantumRange*r;
519 *green=(double) QuantumRange*g;
520 *blue=(double) QuantumRange*b;
523static inline void ConvertLabToXYZ(
const double L,
const double a,
const double b,
524 const IlluminantType illuminant,
double *X,
double *Y,
double *Z)
534 if ((x*x*x) > CIEEpsilon)
537 x=(116.0*x-16.0)/CIEK;
538 if (L > (CIEK*CIEEpsilon))
542 if ((z*z*z) > CIEEpsilon)
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;
551static inline void ConvertLabToRGB(
const double L,
const double a,
552 const double b,
const IlluminantType illuminant,
double *red,
double *green,
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);
564static inline void ConvertLCHabToXYZ(
const double luma,
const double chroma,
565 const double hue,
const IlluminantType illuminant,
double *X,
double *Y,
568 ConvertLabToXYZ(luma,chroma*cos(DegreesToRadians(hue)),chroma*
569 sin(DegreesToRadians(hue)),illuminant,X,Y,Z);
572static inline void ConvertLCHabToRGB(
const double luma,
const double chroma,
573 const double hue,
const IlluminantType illuminant,
double *red,
double *green,
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,
589 ConvertXYZToRGB(X,Y,Z,red,green,blue);
592static inline void ConvertLuvToXYZ(
const double L,
const double u,
const double v,
593 const IlluminantType illuminant,
double *X,
double *Y,
double *Z)
598 if (L > (CIEK*CIEEpsilon))
599 *Y=(double) pow((L+16.0)/116.0,3.0);
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);
619static inline void ConvertLCHuvToXYZ(
const double luma,
const double chroma,
620 const double hue,
const IlluminantType illuminant,
double *X,
double *Y,
623 ConvertLuvToXYZ(luma,chroma*cos(DegreesToRadians(hue)),chroma*
624 sin(DegreesToRadians(hue)),illuminant,X,Y,Z);
627static inline void ConvertLCHuvToRGB(
const double luma,
const double chroma,
628 const double hue,
const IlluminantType illuminant,
double *red,
double *green,
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,
644 ConvertXYZToRGB(X,Y,Z,red,green,blue);
647static inline void ConvertLMSToXYZ(
const double L,
const double M,
const double S,
648 double *X,
double *Y,
double *Z)
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;
655static inline void ConvertLMSToRGB(
const double L,
const double M,
656 const double S,
double *red,
double *green,
double *blue)
663 ConvertLMSToXYZ(L,M,S,&X,&Y,&Z);
664 ConvertXYZToRGB(X,Y,Z,red,green,blue);
667static inline void ConvertDisplayP3ToXYZ(
const double red,
const double green,
668 const double blue,
double *X,
double *Y,
double *Z)
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;
686static inline void ConvertDisplayP3ToRGB(
const double r,
const double g,
687 const double b,
double *red,
double *green,
double *blue)
694 ConvertDisplayP3ToXYZ(r,g,b,&X,&Y,&Z);
695 ConvertXYZToRGB(X,Y,Z,red,green,blue);
698static inline void ConvertLuvToRGB(
const double L,
const double u,
699 const double v,
const IlluminantType illuminant,
double *red,
double *green,
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);
711static inline void ConvertProPhotoToXYZ(
const double red,
const double green,
712 const double blue,
double *X,
double *Y,
double *Z)
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;
731static inline void ConvertProPhotoToRGB(
const double r,
const double g,
732 const double b,
double *red,
double *green,
double *blue)
739 ConvertProPhotoToXYZ(r,g,b,&X,&Y,&Z);
740 ConvertXYZToRGB(X,Y,Z,red,green,blue);
743static inline void ConvertXYZToCAT02LMS(
const double X,
const double Y,
744 const double Z,
double *L,
double *M,
double *S)
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;
751static inline void ConvertRGBToXYZ(
const double red,
const double green,
752 const double blue,
double *X,
double *Y,
double *Z)
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);
773static inline void ConvertRGBToCAT02LMS(
const double R,
const double G,
774 const double B,
double *L,
double *M,
double *S)
781 ConvertRGBToXYZ(R,G,B,&X,&Y,&Z);
782 ConvertXYZToCAT02LMS(X,Y,Z,L,M,S);
785static inline void ConvertRGBToCMY(
const double red,
const double green,
786 const double blue,
double *cyan,
double *magenta,
double *yellow)
788 *cyan=QuantumScale*((double) QuantumRange-red);
789 *magenta=QuantumScale*((double) QuantumRange-green);
790 *yellow=QuantumScale*((double) QuantumRange-blue);
793static inline void ConvertRGBToHCL(
const double red,
const double green,
794 const double blue,
double *hue,
double *chroma,
double *luma)
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));
810 if (fabs(c) < MagickEpsilon)
813 if (fabs(red-max) < MagickEpsilon)
814 h=fmod((green-blue)/c+6.0,6.0);
816 if (fabs(green-max) < MagickEpsilon)
817 h=((blue-red)/c)+2.0;
819 if (fabs(blue-max) < MagickEpsilon)
820 h=((red-green)/c)+4.0;
822 *chroma=QuantumScale*c;
823 *luma=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
826static inline void ConvertRGBToHCLp(
const double red,
const double green,
827 const double blue,
double *hue,
double *chroma,
double *luma)
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));
843 if (fabs(c) < MagickEpsilon)
846 if (fabs(red-max) < MagickEpsilon)
847 h=fmod((green-blue)/c+6.0,6.0);
849 if (fabs(green-max) < MagickEpsilon)
850 h=((blue-red)/c)+2.0;
852 if (fabs(blue-max) < MagickEpsilon)
853 h=((red-green)/c)+4.0;
855 *chroma=QuantumScale*c;
856 *luma=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
859static inline void ConvertRGBToHSB(
const double red,
const double green,
860 const double blue,
double *hue,
double *saturation,
double *brightness)
870 assert(hue != (
double *) NULL);
871 assert(saturation != (
double *) NULL);
872 assert(brightness != (
double *) NULL);
876 min=red < green ? red : green;
879 max=red > green ? red : green;
882 if (fabs(max) < MagickEpsilon)
885 *saturation=delta/max;
886 *brightness=QuantumScale*max;
887 if (fabs(delta) < MagickEpsilon)
889 if (fabs(red-max) < MagickEpsilon)
890 *hue=(green-blue)/delta;
892 if (fabs(green-max) < MagickEpsilon)
893 *hue=2.0+(blue-red)/delta;
895 *hue=4.0+(red-green)/delta;
901static inline void ConvertRGBToHSI(
const double red,
const double green,
902 const double blue,
double *hue,
double *saturation,
double *intensity)
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)
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;
930static inline void ConvertXYZToAdobe98(
const double X,
const double Y,
931 const double Z,
double *red,
double *green,
double *blue)
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);
946static inline void ConvertRGBToAdobe98(
const double red,
const double green,
947 const double blue,
double *r,
double *g,
double *b)
954 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
955 ConvertXYZToAdobe98(X,Y,Z,r,g,b);
958static inline void ConvertXYZToDisplayP3(
const double X,
const double Y,
959 const double Z,
double *red,
double *green,
double *blue)
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);
974static inline void ConvertRGBToDisplayP3(
const double red,
const double green,
975 const double blue,
double *r,
double *g,
double *b)
982 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
983 ConvertXYZToDisplayP3(X,Y,Z,r,g,b);
986static inline void ConvertRGBToHSV(
const double red,
const double green,
987 const double blue,
double *hue,
double *saturation,
double *value)
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));
1012 if (fabs(max-QuantumScale*red) < MagickEpsilon)
1014 *hue=(QuantumScale*green-QuantumScale*blue)/c;
1015 if ((QuantumScale*green) < (QuantumScale*blue))
1019 if (fabs(max-QuantumScale*green) < MagickEpsilon)
1020 *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
1022 *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
1024 *saturation=c*MagickSafeReciprocal(max);
1027static inline void ConvertRGBToHWB(
const double red,
const double green,
1028 const double blue,
double *hue,
double *whiteness,
double *blackness)
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)
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;
1058static inline void ConvertXYZToLab(
const double X,
const double Y,
const double Z,
1059 const IlluminantType illuminant,
double *L,
double *a,
double *b)
1066 if ((X/illuminant_tristimulus[illuminant].x) > CIEEpsilon)
1067 x=pow(X/illuminant_tristimulus[illuminant].x,1.0/3.0);
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);
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);
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;
1083static inline void ConvertRGBToLab(
const double red,
const double green,
1084 const double blue,
const IlluminantType illuminant,
double *L,
double *a,
1092 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1093 ConvertXYZToLab(X,Y,Z,illuminant,L,a,b);
1096static inline void ConvertXYZToLCHab(
const double X,
const double Y,
1097 const double Z,
const IlluminantType illuminant,
double *luma,
double *chroma,
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;
1111static inline void ConvertRGBToLCHab(
const double red,
const double green,
1112 const double blue,
const IlluminantType illuminant,
double *luma,
double *chroma,
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);
1130static inline void ConvertXYZToLuv(
const double X,
const double Y,
const double Z,
1131 const IlluminantType illuminant,
double *L,
double *u,
double *v)
1136 if ((Y/illuminant_tristimulus[illuminant].y) > CIEEpsilon)
1137 *L=(double) (116.0*pow(Y/illuminant_tristimulus[illuminant].y,
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)));
1151 *u=(*u+134.0)/354.0;
1152 *v=(*v+140.0)/262.0;
1155static inline void ConvertXYZToLCHuv(
const double X,
const double Y,
1156 const double Z,
const IlluminantType illuminant,
double *luma,
double *chroma,
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;
1170static inline void ConvertRGBToLCHuv(
const double red,
const double green,
1171 const double blue,
const IlluminantType illuminant,
double *luma,
double *chroma,
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);
1189static inline void ConvertXYZToProPhoto(
const double X,
const double Y,
1190 const double Z,
double *red,
double *green,
double *blue)
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);
1205static inline void ConvertRGBToProPhoto(
const double red,
const double green,
1206 const double blue,
double *r,
double *g,
double *b)
1213 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1214 ConvertXYZToProPhoto(X,Y,Z,r,g,b);
1217static inline void ConvertXYZToLMS(
const double x,
const double y,
1218 const double z,
double *L,
double *M,
double *S)
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;
1225static inline void ConvertRGBToLMS(
const double red,
const double green,
1226 const double blue,
double *L,
double *M,
double *S)
1233 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1234 ConvertXYZToLMS(X,Y,Z,L,M,S);
1237static inline void ConvertRGBToLuv(
const double red,
const double green,
1238 const double blue,
const IlluminantType illuminant,
double *L,
double *u,
1246 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1247 ConvertXYZToLuv(X,Y,Z,illuminant,L,u,v);
1250static inline void ConvertRGBToxyY(
const double red,
const double green,
1251 const double blue,
double *low_x,
double *low_y,
double *cap_Y)
1259 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1260 gamma=MagickSafeReciprocal(X+Y+Z);
1266static inline void ConvertXYZToJzazbz(
const double X,
const double Y,
1267 const double Z,
const double white_luminance,
double *Jz,
double *az,
double *bz)
1269#define Jzazbz_b (1.15)
1270#define Jzazbz_g (0.66)
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)
1319 WLr=MagickSafeReciprocal(white_luminance);
1320 Xp=Z+Jzazbz_b*(X-Z);
1321 Yp=X+Jzazbz_g*(Y-X);
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);
1345 J=(JdI+Iz)/(JdI+1.0)-Jzazbz_d0;
1352 *Jz=IsNaN(J) != 0 ? 0.0 : J;
1353 *az=IsNaN(a) != 0 ? 0.5 : a;
1354 *bz=IsNaN(b) != 0 ? 0.5 : b;
1357static inline void ConvertRGBToJzazbz(
const double red,
const double green,
1358 const double blue,
const double white_luminance,
double *Jz,
double *az,
1366 ConvertRGBToXYZ(red,blue,green,&X,&Y,&Z);
1367 ConvertXYZToJzazbz(X,Y,Z,white_luminance,Jz,az,bz);
1370static inline void ConvertJzazbzToXYZ(
const double Jz,
const double az,
1371 const double bz,
const double white_luminance,
double *X,
double *Y,
double *Z)
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)
1417 C=Jzazbz_Ca*azz+Jzazbz_Cb*bzz;
1418 Sp=g/(1.0+Jzazbz_d*(1.0-g));
1431 dL=Jzazbz_c2+mJzazbz_c3*gL;
1432 dM=Jzazbz_c2+mJzazbz_c3*gM;
1433 dS=Jzazbz_c2+mJzazbz_c3*gS;
1449 Zp=IsNaN(Zp) != 0 ? 0.0 : Zp;
1450 Xp=Zp+(Xp-Zp)/Jzazbz_b;
1451 Xp=IsNaN(Xp) != 0 ? 0.0 : Xp;
1452 Yp=Xp+(Yp-Xp)/Jzazbz_g;
1453 Yp=IsNaN(Yp) != 0 ? 0.0 : Yp;
1459static inline void ConvertJzazbzToRGB(
const double Jz,
const double az,
1460 const double bz,
const double white_luminance,
double *red,
double *green,
1468 ConvertJzazbzToXYZ(Jz,az,bz,white_luminance,&X,&Y,&Z);
1469 ConvertXYZToRGB(X,Y,Z,red,blue,green);
1472static inline void ConvertOklabToRGB(
const double L,
const double a,
1473 const double b,
double *red,
double *green,
double *blue)
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)
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;
1518 Rl=Oklab_Rl*(double) QuantumRange;
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;
1530 *red=EncodePixelGamma(R);
1531 *green=EncodePixelGamma(G);
1532 *blue=EncodePixelGamma(B);
1535static inline void ConvertOklchToRGB(
const double L,
const double C,
1536 const double H,
double *red,
double *green,
double *blue)
1539 const double a = C*cos(H);
1540 const double b_ = C*sin(H);
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_;
1548 const double l = l_*l_*l_;
1549 const double m = m_*m_*m_;
1550 const double s = s_*s_*s_;
1553 *red=EncodePixelGamma((
double) QuantumRange*(Oklab_Rl*l+Oklab_Rm*m+
1555 *green=EncodePixelGamma((
double) QuantumRange*(Oklab_Gl*l+Oklab_Gm*m+
1557 *blue=EncodePixelGamma((
double) QuantumRange*(Oklab_Bl*l+Oklab_Bm*m+
1561static inline void ConvertRGBToOklab(
const double red,
const double green,
1562 const double blue,
double *L,
double *a,
double *b)
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)
1600 R=DecodePixelGamma(red);
1601 G=DecodePixelGamma(green);
1602 B=DecodePixelGamma(blue);
1603 lR=Oklab_lR*QuantumScale;
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;
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;
1623static inline void ConvertRGBToOklch(
const double red,
const double green,
1624 const double blue,
double *L,
double *C,
double *H)
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);
1638 const double l_ = cbrt(l);
1639 const double m_ = cbrt(m);
1640 const double s_ = cbrt(s);
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_;
1648 const double C_ok = sqrt(a_ok*a_ok+b_ok*b_ok);
1649 double H_ok = atan2(b_ok,a_ok);
1658static inline void ConvertRGBToYDbDr(
const double red,
const double green,
1659 const double blue,
double *Y,
double *Db,
double *Dr)
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;
1666static inline void ConvertRGBToYIQ(
const double red,
const double green,
1667 const double blue,
double *Y,
double *I,
double *Q)
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;
1674static inline void ConvertRGBToYPbPr(
const double red,
const double green,
1675 const double blue,
double *Y,
double *Pb,
double *Pr)
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;
1682static inline void ConvertRGBToYCbCr(
const double red,
const double green,
1683 const double blue,
double *Y,
double *Cb,
double *Cr)
1685 ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
1688static inline void ConvertRGBToYUV(
const double red,
const double green,
1689 const double blue,
double *Y,
double *U,
double *V)
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;
1696static inline void ConvertRGBToCMYK(PixelInfo *pixel)
1707 if (pixel->colorspace != sRGBColorspace)
1709 red=QuantumScale*pixel->red;
1710 green=QuantumScale*pixel->green;
1711 blue=QuantumScale*pixel->blue;
1715 red=QuantumScale*DecodePixelGamma(pixel->red);
1716 green=QuantumScale*DecodePixelGamma(pixel->green);
1717 blue=QuantumScale*DecodePixelGamma(pixel->blue);
1719 if ((fabs((
double) red) < MagickEpsilon) &&
1720 (fabs((
double) green) < MagickEpsilon) &&
1721 (fabs((
double) blue) < MagickEpsilon))
1723 pixel->black=(MagickRealType) QuantumRange;
1726 cyan=(MagickRealType) (1.0-red);
1727 magenta=(MagickRealType) (1.0-green);
1728 yellow=(MagickRealType) (1.0-blue);
1730 if (magenta < black)
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;
1744static inline void ConvertYPbPrToRGB(
const double Y,
const double Pb,
1745 const double Pr,
double *red,
double *green,
double *blue)
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));
1755static inline void ConvertYCbCrToRGB(
const double Y,
const double Cb,
1756 const double Cr,
double *red,
double *green,
double *blue)
1758 ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
1761static inline void ConvertYDbDrToRGB(
const double Y,
const double Db,
1762 const double Dr,
double *red,
double *green,
double *blue)
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));
1772static inline void ConvertYIQToRGB(
const double Y,
const double I,
const double Q,
1773 double *red,
double *green,
double *blue)
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));
1783static inline void ConvertxyYToRGB(
const double low_x,
const double low_y,
1784 const double cap_Y,
double *red,
double *green,
double *blue)
1792 gamma=MagickSafeReciprocal(low_y);
1793 X=gamma*cap_Y*low_x;
1795 Z=gamma*cap_Y*(1.0-low_x-low_y);
1796 ConvertXYZToRGB(X,Y,Z,red,green,blue);
1799static inline void ConvertYUVToRGB(
const double Y,
const double U,
const double V,
1800 double *red,
double *green,
double *blue)
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));
1810static inline MagickBooleanType IsCMYKColorspace(
1811 const ColorspaceType colorspace)
1813 if (colorspace == CMYKColorspace)
1815 return(MagickFalse);
1818static inline MagickBooleanType IsGrayColorspace(
1819 const ColorspaceType colorspace)
1821 if ((colorspace == LinearGRAYColorspace) || (colorspace == GRAYColorspace))
1823 return(MagickFalse);
1826static inline MagickBooleanType IsGrayImageType(
const ImageType type)
1828 if ((type == GrayscaleType) || (type == GrayscaleAlphaType) ||
1829 (type == BilevelType))
1831 return(MagickFalse);
1834static inline MagickBooleanType IsHueCompatibleColorspace(
1835 const ColorspaceType colorspace)
1837 if ((colorspace == HCLColorspace) || (colorspace == HCLpColorspace) ||
1838 (colorspace == HSBColorspace) || (colorspace == HSIColorspace) ||
1839 (colorspace == HSLColorspace) || (colorspace == HSVColorspace))
1841 return(MagickFalse);
1844static inline MagickBooleanType IsLabCompatibleColorspace(
1845 const ColorspaceType colorspace)
1847 if ((colorspace == LabColorspace) || (colorspace == LCHColorspace) ||
1848 (colorspace == LCHabColorspace) || (colorspace == LCHuvColorspace) ||
1849 (colorspace == OklabColorspace))
1851 return(MagickFalse);
1854static inline MagickBooleanType IsRGBColorspace(
const ColorspaceType colorspace)
1856 if ((colorspace == RGBColorspace) || (colorspace == scRGBColorspace) ||
1857 (colorspace == LinearGRAYColorspace))
1859 return(MagickFalse);
1862static inline MagickBooleanType IssRGBColorspace(
1863 const ColorspaceType colorspace)
1865 if ((colorspace == sRGBColorspace) || (colorspace == TransparentColorspace))
1867 return(MagickFalse);
1870static inline MagickBooleanType IssRGBCompatibleColorspace(
1871 const ColorspaceType colorspace)
1873 if ((colorspace == sRGBColorspace) || (colorspace == RGBColorspace) ||
1874 (colorspace == Adobe98Colorspace) || (colorspace == ProPhotoColorspace) ||
1875 (colorspace == DisplayP3Colorspace) || (colorspace == scRGBColorspace) ||
1876 (colorspace == TransparentColorspace) || (colorspace == GRAYColorspace) ||
1877 (colorspace == LinearGRAYColorspace))
1879 return(MagickFalse);
1882static inline MagickBooleanType IsYCbCrCompatibleColorspace(
1883 const ColorspaceType colorspace)
1885 if ((colorspace == YCbCrColorspace) ||
1886 (colorspace == Rec709YCbCrColorspace) ||
1887 (colorspace == Rec601YCbCrColorspace))
1889 return(MagickFalse);
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 *);
1899#if defined(__cplusplus) || defined(c_plusplus)