MagickCore  7.1.2-29
Convert, Edit, Or Compose Bitmap Images
colorspace.c
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % CCCC OOO L OOO RRRR SSSSS PPPP AAA CCCC EEEEE %
7 % C O O L O O R R SS P P A A C E %
8 % C O O L O O RRRR SSS PPPP AAAAA C EEE %
9 % C O O L O O R R SS P A A C E %
10 % CCCC OOO LLLLL OOO R R SSSSS P A A CCCC EEEEE %
11 % %
12 % %
13 % MagickCore Image Colorspace Methods %
14 % %
15 % Software Design %
16 % Cristy %
17 % July 1992 %
18 % %
19 % %
20 % Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
22 % %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
25 % %
26 % https://imagemagick.org/license/ %
27 % %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
33 % %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35 %
36 %
37 */
38 ␌
39 /*
40  Include declarations.
41 */
42 #include "MagickCore/studio.h"
43 #include "MagickCore/artifact.h"
44 #include "MagickCore/attribute.h"
45 #include "MagickCore/property.h"
46 #include "MagickCore/cache.h"
47 #include "MagickCore/cache-private.h"
48 #include "MagickCore/cache-view.h"
49 #include "MagickCore/color.h"
50 #include "MagickCore/color-private.h"
51 #include "MagickCore/colorspace.h"
52 #include "MagickCore/colorspace-private.h"
53 #include "MagickCore/exception.h"
54 #include "MagickCore/exception-private.h"
55 #include "MagickCore/enhance.h"
56 #include "MagickCore/image.h"
57 #include "MagickCore/image-private.h"
58 #include "MagickCore/gem.h"
59 #include "MagickCore/gem-private.h"
60 #include "MagickCore/memory_.h"
61 #include "MagickCore/monitor.h"
62 #include "MagickCore/monitor-private.h"
63 #include "MagickCore/option.h"
64 #include "MagickCore/pixel-accessor.h"
65 #include "MagickCore/quantize.h"
66 #include "MagickCore/quantum.h"
67 #include "MagickCore/quantum-private.h"
68 #include "MagickCore/resource_.h"
69 #include "MagickCore/string_.h"
70 #include "MagickCore/string-private.h"
71 #include "MagickCore/utility.h"
72 ␌
73 /*
74  Define declarations.
75 */
76 #define MaximumLogarithmicColorspace 1024.0
77 ␌
78 /*
79  Typedef declarations.
80 */
81 typedef struct _TransformPacket
82 {
83  MagickRealType
84  x,
85  y,
86  z;
87 } TransformPacket;
88 ␌
89 /*
90  Forward declarations.
91 */
92 static MagickBooleanType
93  TransformsRGBImage(Image *,ExceptionInfo *);
94 ␌
95 /*
96 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
97 % %
98 % %
99 % %
100 % C o n v e r t G e n e r i c T o R G B %
101 % %
102 % %
103 % %
104 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
105 %
106 % ConvertGenericToRGB() transforms a generic pixel (X, Y, Z) to a (red,
107 % green, blue) triple.
108 %
109 % The format of the ConvertGenericToRGBImage method is:
110 %
111 % void ConvertHSLToRGB(const double hue,const double saturation,
112 % const double lightness,const double white_luminance,
113 % const double illuminant,double *red,double *green,double *blue)
114 %
115 % A description of each parameter follows:
116 %
117 % o X, Y, Z: A double value representing a component of a generic color
118 % space.
119 %
120 % o white_luminance: white luminance.
121 %
122 % o illuminant: illuminant, typically D65.
123 %
124 % o red, green, blue: A pointer to a pixel component of type Quantum.
125 %
126 */
127 MagickPrivate void ConvertGenericToRGB(const ColorspaceType colorspace,
128  const double X,const double Y,const double Z,const double white_luminance,
129  const IlluminantType illuminant,double *R,double *G,double *B)
130 {
131  switch (colorspace)
132  {
133  case Adobe98Colorspace:
134  {
135  ConvertAdobe98ToRGB(X,Y,Z,R,G,B);
136  break;
137  }
138  case CAT02LMSColorspace:
139  {
140  double
141  L,
142  M,
143  S;
144 
145  ConvertXYZToCAT02LMS(X,Y,Z,&L,&M,&S);
146  ConvertCAT02LMSToRGB(L,M,S,R,G,B);
147  break;
148  }
149  case CMYColorspace:
150  {
151  ConvertCMYToRGB(X,Y,Z,R,G,B);
152  break;
153  }
154  case DisplayP3Colorspace:
155  {
156  ConvertDisplayP3ToRGB(X,Y,Z,R,G,B);
157  break;
158  }
159  case HCLColorspace:
160  {
161  ConvertHCLToRGB(X,Y,Z,R,G,B);
162  break;
163  }
164  case HCLpColorspace:
165  {
166  ConvertHCLpToRGB(X,Y,Z,R,G,B);
167  break;
168  }
169  case HSBColorspace:
170  {
171  ConvertHSBToRGB(X,Y,Z,R,G,B);
172  break;
173  }
174  case HSIColorspace:
175  {
176  ConvertHSIToRGB(X,Y,Z,R,G,B);
177  break;
178  }
179  case HSLColorspace:
180  {
181  ConvertHSLToRGB(X,Y,Z,R,G,B);
182  break;
183  }
184  case HSVColorspace:
185  {
186  ConvertHSVToRGB(X,Y,Z,R,G,B);
187  break;
188  }
189  case HWBColorspace:
190  {
191  ConvertHWBToRGB(X,Y,Z,R,G,B);
192  break;
193  }
194  case JzazbzColorspace:
195  {
196  ConvertJzazbzToRGB(X,Y,Z,white_luminance,R,G,B);
197  break;
198  }
199  case LabColorspace:
200  {
201  ConvertLabToRGB(X,Y,Z,illuminant,R,G,B);
202  break;
203  }
204  case LCHColorspace:
205  case LCHabColorspace:
206  {
207  ConvertLCHabToRGB(X,Y,Z,illuminant,R,G,B);
208  break;
209  }
210  case LCHuvColorspace:
211  {
212  ConvertLCHuvToRGB(X,Y,Z,illuminant,R,G,B);
213  break;
214  }
215  case LMSColorspace:
216  {
217  ConvertLMSToRGB(X,Y,Z,R,G,B);
218  break;
219  }
220  case LuvColorspace:
221  {
222  ConvertLuvToRGB(X,Y,Z,illuminant,R,G,B);
223  break;
224  }
225  case OklabColorspace:
226  {
227  ConvertOklabToRGB(X,Y,Z,R,G,B);
228  break;
229  }
230  case OklchColorspace:
231  {
232  ConvertOklchToRGB(X,Y,Z,R,G,B);
233  break;
234  }
235  case ProPhotoColorspace:
236  {
237  ConvertProPhotoToRGB(X,Y,Z,R,G,B);
238  break;
239  }
240  case xyYColorspace:
241  {
242  ConvertxyYToRGB(X,Y,Z,R,G,B);
243  break;
244  }
245  case XYZColorspace:
246  {
247  ConvertXYZToRGB(X,Y,Z,R,G,B);
248  break;
249  }
250  case YCbCrColorspace:
251  {
252  ConvertYCbCrToRGB(X,Y,Z,R,G,B);
253  break;
254  }
255  case YDbDrColorspace:
256  {
257  ConvertYDbDrToRGB(X,Y,Z,R,G,B);
258  break;
259  }
260  case YIQColorspace:
261  {
262  ConvertYIQToRGB(X,Y,Z,R,G,B);
263  break;
264  }
265  case YPbPrColorspace:
266  {
267  ConvertYPbPrToRGB(X,Y,Z,R,G,B);
268  break;
269  }
270  case YUVColorspace:
271  {
272  ConvertYUVToRGB(X,Y,Z,R,G,B);
273  break;
274  }
275  default:
276  {
277  *R=(double) QuantumRange*X;
278  *G=(double) QuantumRange*Y;
279  *B=(double) QuantumRange*Z;
280  break;
281  }
282  }
283 }
284 ␌
285 /*
286 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
287 % %
288 % %
289 % %
290 % C o n v e r t H S L T o R G B %
291 % %
292 % %
293 % %
294 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
295 %
296 % ConvertHSLToRGB() transforms a (hue, saturation, lightness) to a (red,
297 % green, blue) triple.
298 %
299 % The format of the ConvertHSLToRGBImage method is:
300 %
301 % void ConvertHSLToRGB(const double hue,const double saturation,
302 % const double lightness,double *red,double *green,double *blue)
303 %
304 % A description of each parameter follows:
305 %
306 % o hue, saturation, lightness: A double value representing a
307 % component of the HSL color space.
308 %
309 % o red, green, blue: A pointer to a pixel component of type Quantum.
310 %
311 */
312 MagickExport void ConvertHSLToRGB(const double hue,const double saturation,
313  const double lightness,double *red,double *green,double *blue)
314 {
315  double
316  c,
317  h,
318  min,
319  x;
320 
321  /*
322  Convert HSL to RGB colorspace.
323  */
324  assert(red != (double *) NULL);
325  assert(green != (double *) NULL);
326  assert(blue != (double *) NULL);
327  h=hue*360.0;
328  if (lightness <= 0.5)
329  c=2.0*lightness*saturation;
330  else
331  c=(2.0-2.0*lightness)*saturation;
332  min=lightness-0.5*c;
333  h-=360.0*floor(h/360.0);
334  h/=60.0;
335  x=c*(1.0-fabs(h-2.0*floor(h/2.0)-1.0));
336  switch ((int) floor(h))
337  {
338  case 0:
339  default:
340  {
341  *red=(double) QuantumRange*(min+c);
342  *green=(double) QuantumRange*(min+x);
343  *blue=(double) QuantumRange*min;
344  break;
345  }
346  case 1:
347  {
348  *red=(double) QuantumRange*(min+x);
349  *green=(double) QuantumRange*(min+c);
350  *blue=(double) QuantumRange*min;
351  break;
352  }
353  case 2:
354  {
355  *red=(double) QuantumRange*min;
356  *green=(double) QuantumRange*(min+c);
357  *blue=(double) QuantumRange*(min+x);
358  break;
359  }
360  case 3:
361  {
362  *red=(double) QuantumRange*min;
363  *green=(double) QuantumRange*(min+x);
364  *blue=(double) QuantumRange*(min+c);
365  break;
366  }
367  case 4:
368  {
369  *red=(double) QuantumRange*(min+x);
370  *green=(double) QuantumRange*min;
371  *blue=(double) QuantumRange*(min+c);
372  break;
373  }
374  case 5:
375  {
376  *red=(double) QuantumRange*(min+c);
377  *green=(double) QuantumRange*min;
378  *blue=(double) QuantumRange*(min+x);
379  break;
380  }
381  }
382 }
383 ␌
384 /*
385 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
386 % %
387 % %
388 % %
389 % C o n v e r t R G B T o G e n e r i c %
390 % %
391 % %
392 % %
393 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
394 %
395 % ConvertRGBToGeneric() transforms a (red, green, blue) to a generic (X, Y, Z)
396 % triple.
397 %
398 % The format of the ConvertRGBToGeneric method is:
399 %
400 % void ConvertRGBToGeneric(const double red,const double green,
401 % const double blue,double *hue,double *saturation,double *lightness)
402 %
403 % A description of each parameter follows:
404 %
405 % o red, green, blue: A Quantum value representing the red, green, and
406 % blue component of a pixel..
407 %
408 % o white_luminance: white luminance.
409 %
410 % o illuminant: illuminant, typically D65.
411 %
412 % o X, Y, Z: A pointer to a double value representing a component of a
413 % generic color space.
414 %
415 */
416 MagickPrivate void ConvertRGBToGeneric(const ColorspaceType colorspace,
417  const double R,const double G,const double B,const double white_luminance,
418  const IlluminantType illuminant,double *X,double *Y,double *Z)
419 {
420  switch (colorspace)
421  {
422  case Adobe98Colorspace:
423  {
424  ConvertRGBToAdobe98(R,G,B,X,Y,Z);
425  break;
426  }
427  case CAT02LMSColorspace:
428  {
429  double
430  L,
431  M,
432  S;
433 
434  ConvertRGBToCAT02LMS(R,G,B,&L,&M,&S);
435  ConvertCAT02LMSToXYZ(L,M,S,X,Y,Z);
436  break;
437  }
438  case CMYColorspace:
439  {
440  ConvertRGBToCMY(R,G,B,X,Y,Z);
441  break;
442  }
443  case DisplayP3Colorspace:
444  {
445  ConvertRGBToDisplayP3(R,G,B,X,Y,Z);
446  break;
447  }
448  case HCLColorspace:
449  {
450  ConvertRGBToHCL(R,G,B,X,Y,Z);
451  break;
452  }
453  case HCLpColorspace:
454  {
455  ConvertRGBToHCLp(R,G,B,X,Y,Z);
456  break;
457  }
458  case HSBColorspace:
459  {
460  ConvertRGBToHSB(R,G,B,X,Y,Z);
461  break;
462  }
463  case HSIColorspace:
464  {
465  ConvertRGBToHSI(R,G,B,X,Y,Z);
466  break;
467  }
468  case HSLColorspace:
469  {
470  ConvertRGBToHSL(R,G,B,X,Y,Z);
471  break;
472  }
473  case HSVColorspace:
474  {
475  ConvertRGBToHSV(R,G,B,X,Y,Z);
476  break;
477  }
478  case HWBColorspace:
479  {
480  ConvertRGBToHWB(R,G,B,X,Y,Z);
481  break;
482  }
483  case JzazbzColorspace:
484  {
485  ConvertRGBToJzazbz(R,G,B,white_luminance,X,Y,Z);
486  break;
487  }
488  case LabColorspace:
489  {
490  ConvertRGBToLab(R,G,B,illuminant,X,Y,Z);
491  break;
492  }
493  case LCHColorspace:
494  case LCHabColorspace:
495  {
496  ConvertRGBToLCHab(R,G,B,illuminant,X,Y,Z);
497  break;
498  }
499  case LCHuvColorspace:
500  {
501  ConvertRGBToLCHuv(R,G,B,illuminant,X,Y,Z);
502  break;
503  }
504  case LMSColorspace:
505  {
506  ConvertRGBToLMS(R,G,B,X,Y,Z);
507  break;
508  }
509  case LuvColorspace:
510  {
511  ConvertRGBToLuv(R,G,B,illuminant,X,Y,Z);
512  break;
513  }
514  case OklabColorspace:
515  {
516  ConvertRGBToOklab(R,G,B,X,Y,Z);
517  break;
518  }
519  case OklchColorspace:
520  {
521  ConvertRGBToOklch(R,G,B,X,Y,Z);
522  break;
523  }
524  case ProPhotoColorspace:
525  {
526  ConvertRGBToProPhoto(R,G,B,X,Y,Z);
527  break;
528  }
529  case xyYColorspace:
530  {
531  ConvertRGBToxyY(R,G,B,X,Y,Z);
532  break;
533  }
534  case XYZColorspace:
535  {
536  ConvertRGBToXYZ(R,G,B,X,Y,Z);
537  break;
538  }
539  case YCbCrColorspace:
540  {
541  ConvertRGBToYCbCr(R,G,B,X,Y,Z);
542  break;
543  }
544  case YDbDrColorspace:
545  {
546  ConvertRGBToYDbDr(R,G,B,X,Y,Z);
547  break;
548  }
549  case YIQColorspace:
550  {
551  ConvertRGBToYIQ(R,G,B,X,Y,Z);
552  break;
553  }
554  case YPbPrColorspace:
555  {
556  ConvertRGBToYPbPr(R,G,B,X,Y,Z);
557  break;
558  }
559  case YUVColorspace:
560  {
561  ConvertRGBToYUV(R,G,B,X,Y,Z);
562  break;
563  }
564  default:
565  {
566  *X=QuantumScale*R;
567  *Y=QuantumScale*G;
568  *Z=QuantumScale*B;
569  break;
570  }
571  }
572 }
573 ␌
574 /*
575 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
576 % %
577 % %
578 % %
579 % C o n v e r t R G B T o H S L %
580 % %
581 % %
582 % %
583 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
584 %
585 % ConvertRGBToHSL() transforms a (red, green, blue) to a (hue, saturation,
586 % lightness) triple.
587 %
588 % The format of the ConvertRGBToHSL method is:
589 %
590 % void ConvertRGBToHSL(const double red,const double green,
591 % const double blue,double *hue,double *saturation,double *lightness)
592 %
593 % A description of each parameter follows:
594 %
595 % o red, green, blue: A Quantum value representing the red, green, and
596 % blue component of a pixel..
597 %
598 % o hue, saturation, lightness: A pointer to a double value representing a
599 % component of the HSL color space.
600 %
601 */
602 MagickExport void ConvertRGBToHSL(const double red,const double green,
603  const double blue,double *hue,double *saturation,double *lightness)
604 {
605  double
606  c,
607  max,
608  min;
609 
610  /*
611  Convert RGB to HSL colorspace.
612  */
613  assert(hue != (double *) NULL);
614  assert(saturation != (double *) NULL);
615  assert(lightness != (double *) NULL);
616  max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
617  QuantumScale*blue));
618  min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
619  QuantumScale*blue));
620  c=max-min;
621  *lightness=(max+min)/2.0;
622  if (c <= 0.0)
623  {
624  *hue=0.0;
625  *saturation=0.0;
626  return;
627  }
628  if (fabs(max-QuantumScale*red) < MagickEpsilon)
629  {
630  *hue=(QuantumScale*green-QuantumScale*blue)/c;
631  if ((QuantumScale*green) < (QuantumScale*blue))
632  *hue+=6.0;
633  }
634  else
635  if (fabs(max-QuantumScale*green) < MagickEpsilon)
636  *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
637  else
638  *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
639  *hue*=60.0/360.0;
640  if (*lightness <= 0.5)
641  *saturation=c*MagickSafeReciprocal(2.0*(*lightness));
642  else
643  *saturation=c*MagickSafeReciprocal(2.0-2.0*(*lightness));
644 }
645 ␌
646 /*
647 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
648 % %
649 % %
650 % %
651 % G e t I m a g e C o l o r s p a c e T y p e %
652 % %
653 % %
654 % %
655 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
656 %
657 % GetImageColorspaceType() returns the potential type of image:
658 % sRGBColorspaceType, RGBColorspaceType, GRAYColorspaceType, etc.
659 %
660 % To ensure the image type matches its potential, use SetImageColorspaceType():
661 %
662 % (void) SetImageColorspaceType(image,GetImageColorspaceType(image),
663 % exception);
664 %
665 % The format of the GetImageColorspaceType method is:
666 %
667 % ColorspaceType GetImageColorspaceType(const Image *image,
668 % ExceptionInfo *exception)
669 %
670 % A description of each parameter follows:
671 %
672 % o image: the image.
673 %
674 % o exception: return any errors or warnings in this structure.
675 %
676 */
677 MagickExport ColorspaceType GetImageColorspaceType(const Image *image,
678  ExceptionInfo *exception)
679 {
680  ColorspaceType
681  colorspace;
682 
683  ImageType
684  type;
685 
686  assert(image != (Image *) NULL);
687  assert(image->signature == MagickCoreSignature);
688  if (IsEventLogging() != MagickFalse)
689  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
690  colorspace=image->colorspace;
691  type=IdentifyImageType(image,exception);
692  if (IsGrayImageType(type))
693  colorspace=GRAYColorspace;
694  return(colorspace);
695 }
696 ␌
697 /*
698 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
699 % %
700 % %
701 % %
702 + s R G B T r a n s f o r m I m a g e %
703 % %
704 % %
705 % %
706 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
707 %
708 % sRGBTransformImage() converts the reference image from sRGB to an alternate
709 % colorspace. The transformation matrices are not the standard ones: the
710 % weights are rescaled to normalized the range of the transformed values to
711 % be [0..QuantumRange].
712 %
713 % The format of the sRGBTransformImage method is:
714 %
715 % MagickBooleanType sRGBTransformImage(Image *image,
716 % const ColorspaceType colorspace,ExceptionInfo *exception)
717 %
718 % A description of each parameter follows:
719 %
720 % o image: the image.
721 %
722 % o colorspace: the colorspace to transform the image to.
723 %
724 % o exception: return any errors or warnings in this structure.
725 %
726 */
727 static MagickBooleanType sRGBTransformImage(Image *image,
728  const ColorspaceType colorspace,ExceptionInfo *exception)
729 {
730 #define sRGBTransformImageTag "RGBTransform/Image"
731 
732  CacheView
733  *image_view;
734 
735  const char
736  *artifact;
737 
738  IlluminantType
739  illuminant = D65Illuminant;
740 
741  MagickBooleanType
742  status;
743 
744  MagickOffsetType
745  progress;
746 
747  PrimaryInfo
748  primary_info;
749 
750  ssize_t
751  i,
752  y;
753 
754  TransformPacket
755  *x_map,
756  *y_map,
757  *z_map;
758 
759  assert(image != (Image *) NULL);
760  assert(image->signature == MagickCoreSignature);
761  assert(colorspace != sRGBColorspace);
762  assert(colorspace != TransparentColorspace);
763  assert(colorspace != UndefinedColorspace);
764  if (IsEventLogging() != MagickFalse)
765  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
766  artifact=GetImageArtifact(image,"color:illuminant");
767  if (artifact != (const char *) NULL)
768  {
769  ssize_t
770  illuminant_type;
771 
772  illuminant_type=ParseCommandOption(MagickIlluminantOptions,MagickFalse,
773  artifact);
774  if (illuminant_type < 0)
775  illuminant=UndefinedIlluminant;
776  else
777  illuminant=(IlluminantType) illuminant_type;
778  }
779  status=MagickTrue;
780  progress=0;
781  switch (colorspace)
782  {
783  case CMYKColorspace:
784  {
785  PixelInfo
786  zero;
787 
788  /*
789  Convert RGB to CMYK colorspace.
790  */
791  if (image->storage_class == PseudoClass)
792  {
793  if (SyncImage(image,exception) == MagickFalse)
794  return(MagickFalse);
795  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
796  return(MagickFalse);
797  }
798  if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
799  return(MagickFalse);
800  GetPixelInfo(image,&zero);
801  image_view=AcquireAuthenticCacheView(image,exception);
802 #if defined(MAGICKCORE_OPENMP_SUPPORT)
803  #pragma omp parallel for schedule(static) shared(status) \
804  magick_number_threads(image,image,image->rows,2)
805 #endif
806  for (y=0; y < (ssize_t) image->rows; y++)
807  {
808  MagickBooleanType
809  sync;
810 
811  PixelInfo
812  pixel;
813 
814  Quantum
815  *magick_restrict q;
816 
817  ssize_t
818  x;
819 
820  if (status == MagickFalse)
821  continue;
822  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
823  exception);
824  if (q == (Quantum *) NULL)
825  {
826  status=MagickFalse;
827  continue;
828  }
829  pixel=zero;
830  for (x=0; x < (ssize_t) image->columns; x++)
831  {
832  GetPixelInfoPixel(image,q,&pixel);
833  ConvertRGBToCMYK(&pixel);
834  SetPixelViaPixelInfo(image,&pixel,q);
835  q+=(ptrdiff_t) GetPixelChannels(image);
836  }
837  sync=SyncCacheViewAuthenticPixels(image_view,exception);
838  if (sync == MagickFalse)
839  status=MagickFalse;
840  }
841  image_view=DestroyCacheView(image_view);
842  image->type=image->alpha_trait == UndefinedPixelTrait ?
843  ColorSeparationType : ColorSeparationAlphaType;
844  if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
845  return(MagickFalse);
846  return(status);
847  }
848  case LinearGRAYColorspace:
849  {
850  /*
851  Transform image from sRGB to GRAY.
852  */
853  if (image->storage_class == PseudoClass)
854  {
855  if (SyncImage(image,exception) == MagickFalse)
856  return(MagickFalse);
857  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
858  return(MagickFalse);
859  }
860  image_view=AcquireAuthenticCacheView(image,exception);
861 #if defined(MAGICKCORE_OPENMP_SUPPORT)
862  #pragma omp parallel for schedule(static) shared(status) \
863  magick_number_threads(image,image,image->rows,2)
864 #endif
865  for (y=0; y < (ssize_t) image->rows; y++)
866  {
867  MagickBooleanType
868  sync;
869 
870  ssize_t
871  x;
872 
873  Quantum
874  *magick_restrict q;
875 
876  if (status == MagickFalse)
877  continue;
878  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
879  exception);
880  if (q == (Quantum *) NULL)
881  {
882  status=MagickFalse;
883  continue;
884  }
885  for (x=0; x < (ssize_t) image->columns; x++)
886  {
887  MagickRealType
888  gray;
889 
890  gray=0.212656*DecodePixelGamma(GetPixelRed(image,q))+0.715158*
891  DecodePixelGamma(GetPixelGreen(image,q))+0.072186*
892  DecodePixelGamma(GetPixelBlue(image,q));
893  SetPixelGray(image,ClampToQuantum(gray),q);
894  q+=(ptrdiff_t) GetPixelChannels(image);
895  }
896  sync=SyncCacheViewAuthenticPixels(image_view,exception);
897  if (sync == MagickFalse)
898  status=MagickFalse;
899  }
900  image_view=DestroyCacheView(image_view);
901  if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
902  return(MagickFalse);
903  image->type=GrayscaleType;
904  return(status);
905  }
906  case GRAYColorspace:
907  {
908  /*
909  Transform image from sRGB to GRAY.
910  */
911  if (image->storage_class == PseudoClass)
912  {
913  if (SyncImage(image,exception) == MagickFalse)
914  return(MagickFalse);
915  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
916  return(MagickFalse);
917  }
918  image_view=AcquireAuthenticCacheView(image,exception);
919 #if defined(MAGICKCORE_OPENMP_SUPPORT)
920  #pragma omp parallel for schedule(static) shared(status) \
921  magick_number_threads(image,image,image->rows,2)
922 #endif
923  for (y=0; y < (ssize_t) image->rows; y++)
924  {
925  MagickBooleanType
926  sync;
927 
928  ssize_t
929  x;
930 
931  Quantum
932  *magick_restrict q;
933 
934  if (status == MagickFalse)
935  continue;
936  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
937  exception);
938  if (q == (Quantum *) NULL)
939  {
940  status=MagickFalse;
941  continue;
942  }
943  for (x=0; x < (ssize_t) image->columns; x++)
944  {
945  MagickRealType
946  gray;
947 
948  gray=0.212656*(double) GetPixelRed(image,q)+0.715158*(double)
949  GetPixelGreen(image,q)+0.072186*(double) GetPixelBlue(image,q);
950  SetPixelGray(image,ClampToQuantum(gray),q);
951  q+=(ptrdiff_t) GetPixelChannels(image);
952  }
953  sync=SyncCacheViewAuthenticPixels(image_view,exception);
954  if (sync == MagickFalse)
955  status=MagickFalse;
956  }
957  image_view=DestroyCacheView(image_view);
958  if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
959  return(MagickFalse);
960  image->type=GrayscaleType;
961  return(status);
962  }
963  case CMYColorspace:
964  case Adobe98Colorspace:
965  case CAT02LMSColorspace:
966  case DisplayP3Colorspace:
967  case HCLColorspace:
968  case HCLpColorspace:
969  case HSBColorspace:
970  case HSIColorspace:
971  case HSLColorspace:
972  case HSVColorspace:
973  case HWBColorspace:
974  case JzazbzColorspace:
975  case LabColorspace:
976  case LCHColorspace:
977  case LCHabColorspace:
978  case LCHuvColorspace:
979  case LMSColorspace:
980  case LuvColorspace:
981  case OklabColorspace:
982  case OklchColorspace:
983  case ProPhotoColorspace:
984  case xyYColorspace:
985  case XYZColorspace:
986  case YCbCrColorspace:
987  case YDbDrColorspace:
988  case YIQColorspace:
989  case YPbPrColorspace:
990  case YUVColorspace:
991  {
992  const char
993  *value;
994 
995  double
996  white_luminance = 10000.0;
997 
998  /*
999  Transform image from sRGB to target colorspace.
1000  */
1001  value=GetImageProperty(image,"white-luminance",exception);
1002  if (value != (const char *) NULL)
1003  white_luminance=StringToDouble(value,(char **) NULL);
1004  if (image->storage_class == PseudoClass)
1005  {
1006  if (SyncImage(image,exception) == MagickFalse)
1007  return(MagickFalse);
1008  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1009  return(MagickFalse);
1010  }
1011  image_view=AcquireAuthenticCacheView(image,exception);
1012 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1013  #pragma omp parallel for schedule(static) shared(status) \
1014  magick_number_threads(image,image,image->rows,2)
1015 #endif
1016  for (y=0; y < (ssize_t) image->rows; y++)
1017  {
1018  MagickBooleanType
1019  sync;
1020 
1021  ssize_t
1022  x;
1023 
1024  Quantum
1025  *magick_restrict q;
1026 
1027  if (status == MagickFalse)
1028  continue;
1029  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1030  exception);
1031  if (q == (Quantum *) NULL)
1032  {
1033  status=MagickFalse;
1034  continue;
1035  }
1036  for (x=0; x < (ssize_t) image->columns; x++)
1037  {
1038  double
1039  X,
1040  Y,
1041  Z;
1042 
1043  ConvertRGBToGeneric(colorspace,(double) GetPixelRed(image,q),
1044  (double) GetPixelGreen(image,q),(double) GetPixelBlue(image,q),
1045  white_luminance,illuminant,&X,&Y,&Z);
1046  SetPixelRed(image,ClampToQuantum((double) QuantumRange*X),q);
1047  SetPixelGreen(image,ClampToQuantum((double) QuantumRange*Y),q);
1048  SetPixelBlue(image,ClampToQuantum((double) QuantumRange*Z),q);
1049  q+=(ptrdiff_t) GetPixelChannels(image);
1050  }
1051  sync=SyncCacheViewAuthenticPixels(image_view,exception);
1052  if (sync == MagickFalse)
1053  status=MagickFalse;
1054  }
1055  image_view=DestroyCacheView(image_view);
1056  if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1057  return(MagickFalse);
1058  return(status);
1059  }
1060  case LogColorspace:
1061  {
1062 #define DisplayGamma (1.0/1.7)
1063 #define FilmGamma 0.6
1064 #define ReferenceBlack 95.0
1065 #define ReferenceWhite 685.0
1066 
1067  const char
1068  *value;
1069 
1070  double
1071  black,
1072  density,
1073  film_gamma,
1074  gamma,
1075  reference_black,
1076  reference_white;
1077 
1078  Quantum
1079  *logmap;
1080 
1081  /*
1082  Transform RGB to Log colorspace.
1083  */
1084  density=DisplayGamma;
1085  gamma=DisplayGamma;
1086  value=GetImageProperty(image,"gamma",exception);
1087  if (value != (const char *) NULL)
1088  gamma=MagickSafeReciprocal(StringToDouble(value,(char **) NULL));
1089  film_gamma=FilmGamma;
1090  value=GetImageProperty(image,"film-gamma",exception);
1091  if (value != (const char *) NULL)
1092  film_gamma=StringToDouble(value,(char **) NULL);
1093  reference_black=ReferenceBlack;
1094  value=GetImageProperty(image,"reference-black",exception);
1095  if (value != (const char *) NULL)
1096  reference_black=StringToDouble(value,(char **) NULL);
1097  reference_white=ReferenceWhite;
1098  value=GetImageProperty(image,"reference-white",exception);
1099  if (value != (const char *) NULL)
1100  reference_white=StringToDouble(value,(char **) NULL);
1101  logmap=(Quantum *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1102  sizeof(*logmap));
1103  if (logmap == (Quantum *) NULL)
1104  ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1105  image->filename);
1106  black=pow(10.0,(reference_black-reference_white)*(gamma/density)*0.002*
1107  MagickSafeReciprocal(film_gamma));
1108 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1109  #pragma omp parallel for schedule(static)
1110 #endif
1111  for (i=0; i <= (ssize_t) MaxMap; i++)
1112  logmap[i]=ScaleMapToQuantum(((double) MaxMap*(reference_white+
1113  log10(black+(1.0*i/MaxMap)*(1.0-black))/((gamma/density)*0.002*
1114  MagickSafeReciprocal(film_gamma)))/MaximumLogarithmicColorspace));
1115  image_view=AcquireAuthenticCacheView(image,exception);
1116 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1117  #pragma omp parallel for schedule(static) shared(status) \
1118  magick_number_threads(image,image,image->rows,2)
1119 #endif
1120  for (y=0; y < (ssize_t) image->rows; y++)
1121  {
1122  MagickBooleanType
1123  sync;
1124 
1125  ssize_t
1126  x;
1127 
1128  Quantum
1129  *magick_restrict q;
1130 
1131  if (status == MagickFalse)
1132  continue;
1133  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1134  exception);
1135  if (q == (Quantum *) NULL)
1136  {
1137  status=MagickFalse;
1138  continue;
1139  }
1140  for (x=(ssize_t) image->columns; x != 0; x--)
1141  {
1142  double
1143  blue,
1144  green,
1145  red;
1146 
1147  red=(double) DecodePixelGamma((MagickRealType)
1148  GetPixelRed(image,q));
1149  green=(double) DecodePixelGamma((MagickRealType)
1150  GetPixelGreen(image,q));
1151  blue=(double) DecodePixelGamma((MagickRealType)
1152  GetPixelBlue(image,q));
1153  SetPixelRed(image,logmap[ScaleQuantumToMap(ClampToQuantum(red))],q);
1154  SetPixelGreen(image,logmap[ScaleQuantumToMap(ClampToQuantum(green))],
1155  q);
1156  SetPixelBlue(image,logmap[ScaleQuantumToMap(ClampToQuantum(blue))],q);
1157  q+=(ptrdiff_t) GetPixelChannels(image);
1158  }
1159  sync=SyncCacheViewAuthenticPixels(image_view,exception);
1160  if (sync == MagickFalse)
1161  status=MagickFalse;
1162  }
1163  image_view=DestroyCacheView(image_view);
1164  logmap=(Quantum *) RelinquishMagickMemory(logmap);
1165  if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1166  return(MagickFalse);
1167  return(status);
1168  }
1169  case RGBColorspace:
1170  case scRGBColorspace:
1171  {
1172  /*
1173  Transform image from sRGB to linear RGB.
1174  */
1175  if (image->storage_class == PseudoClass)
1176  {
1177  if (SyncImage(image,exception) == MagickFalse)
1178  return(MagickFalse);
1179  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1180  return(MagickFalse);
1181  }
1182  image_view=AcquireAuthenticCacheView(image,exception);
1183 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1184  #pragma omp parallel for schedule(static) shared(status) \
1185  magick_number_threads(image,image,image->rows,2)
1186 #endif
1187  for (y=0; y < (ssize_t) image->rows; y++)
1188  {
1189  MagickBooleanType
1190  sync;
1191 
1192  ssize_t
1193  x;
1194 
1195  Quantum
1196  *magick_restrict q;
1197 
1198  if (status == MagickFalse)
1199  continue;
1200  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1201  exception);
1202  if (q == (Quantum *) NULL)
1203  {
1204  status=MagickFalse;
1205  continue;
1206  }
1207  for (x=0; x < (ssize_t) image->columns; x++)
1208  {
1209  double
1210  blue,
1211  green,
1212  red;
1213 
1214  red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
1215  green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
1216  blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
1217  SetPixelRed(image,ClampToQuantum(red),q);
1218  SetPixelGreen(image,ClampToQuantum(green),q);
1219  SetPixelBlue(image,ClampToQuantum(blue),q);
1220  q+=(ptrdiff_t) GetPixelChannels(image);
1221  }
1222  sync=SyncCacheViewAuthenticPixels(image_view,exception);
1223  if (sync == MagickFalse)
1224  status=MagickFalse;
1225  }
1226  image_view=DestroyCacheView(image_view);
1227  if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1228  return(MagickFalse);
1229  return(status);
1230  }
1231  default:
1232  break;
1233  }
1234  /*
1235  Allocate the tables.
1236  */
1237  x_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1238  sizeof(*x_map));
1239  y_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1240  sizeof(*y_map));
1241  z_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1242  sizeof(*z_map));
1243  if ((x_map == (TransformPacket *) NULL) ||
1244  (y_map == (TransformPacket *) NULL) ||
1245  (z_map == (TransformPacket *) NULL))
1246  {
1247  if (x_map != (TransformPacket *) NULL)
1248  x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
1249  if (y_map != (TransformPacket *) NULL)
1250  y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
1251  if (z_map != (TransformPacket *) NULL)
1252  z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
1253  ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1254  image->filename);
1255  }
1256  (void) memset(&primary_info,0,sizeof(primary_info));
1257  switch (colorspace)
1258  {
1259  case OHTAColorspace:
1260  {
1261  /*
1262  Initialize OHTA tables:
1263 
1264  I1 = 0.33333*R+0.33334*G+0.33333*B
1265  I2 = 0.50000*R+0.00000*G-0.50000*B
1266  I3 =-0.25000*R+0.50000*G-0.25000*B
1267 
1268  I and Q, normally -0.5 through 0.5, are normalized to the range 0
1269  through QuantumRange.
1270  */
1271  primary_info.y=(MagickRealType) ((MaxMap+1)/2);
1272  primary_info.z=(MagickRealType) ((MaxMap+1)/2);
1273 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1274  #pragma omp parallel for schedule(static)
1275 #endif
1276  for (i=0; i <= (ssize_t) MaxMap; i++)
1277  {
1278  x_map[i].x=(MagickRealType) (0.33333*(double) i);
1279  x_map[i].y=(MagickRealType) (0.50000*(double) i);
1280  x_map[i].z=(MagickRealType) (-0.25000*(double) i);
1281  y_map[i].x=(MagickRealType) (0.33334*(double) i);
1282  y_map[i].y=(MagickRealType) (0.00000*(double) i);
1283  y_map[i].z=(MagickRealType) (0.50000*(double) i);
1284  z_map[i].x=(MagickRealType) (0.33333*(double) i);
1285  z_map[i].y=(MagickRealType) (-0.50000*(double) i);
1286  z_map[i].z=(MagickRealType) (-0.25000*(double) i);
1287  }
1288  break;
1289  }
1290  case Rec601YCbCrColorspace:
1291  {
1292  /*
1293  Initialize YCbCr tables (ITU-R BT.601):
1294 
1295  Y = 0.2988390*R+0.5868110*G+0.1143500*B
1296  Cb= -0.1687367*R-0.3312640*G+0.5000000*B
1297  Cr= 0.5000000*R-0.4186880*G-0.0813120*B
1298 
1299  Cb and Cr, normally -0.5 through 0.5, are normalized to the range 0
1300  through QuantumRange.
1301  */
1302  primary_info.y=(MagickRealType) ((MaxMap+1)/2);
1303  primary_info.z=(MagickRealType) ((MaxMap+1)/2);
1304 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1305  #pragma omp parallel for schedule(static)
1306 #endif
1307  for (i=0; i <= (ssize_t) MaxMap; i++)
1308  {
1309  x_map[i].x=(MagickRealType) (0.298839*(double) i);
1310  x_map[i].y=(MagickRealType) (-0.1687367*(double) i);
1311  x_map[i].z=(MagickRealType) (0.500000*(double) i);
1312  y_map[i].x=(MagickRealType) (0.586811*(double) i);
1313  y_map[i].y=(MagickRealType) (-0.331264*(double) i);
1314  y_map[i].z=(MagickRealType) (-0.418688*(double) i);
1315  z_map[i].x=(MagickRealType) (0.114350*(double) i);
1316  z_map[i].y=(MagickRealType) (0.500000*(double) i);
1317  z_map[i].z=(MagickRealType) (-0.081312*(double) i);
1318  }
1319  break;
1320  }
1321  case Rec709YCbCrColorspace:
1322  {
1323  /*
1324  Initialize YCbCr tables (ITU-R BT.709):
1325 
1326  Y = 0.212656*R+0.715158*G+0.072186*B
1327  Cb= -0.114572*R-0.385428*G+0.500000*B
1328  Cr= 0.500000*R-0.454153*G-0.045847*B
1329 
1330  Cb and Cr, normally -0.5 through 0.5, are normalized to the range 0
1331  through QuantumRange.
1332  */
1333  primary_info.y=(double) ((MaxMap+1)/2);
1334  primary_info.z=(double) ((MaxMap+1)/2);
1335 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1336  #pragma omp parallel for schedule(static)
1337 #endif
1338  for (i=0; i <= (ssize_t) MaxMap; i++)
1339  {
1340  x_map[i].x=(MagickRealType) (0.212656*(double) i);
1341  x_map[i].y=(MagickRealType) (-0.114572*(double) i);
1342  x_map[i].z=(MagickRealType) (0.500000*(double) i);
1343  y_map[i].x=(MagickRealType) (0.715158*(double) i);
1344  y_map[i].y=(MagickRealType) (-0.385428*(double) i);
1345  y_map[i].z=(MagickRealType) (-0.454153*(double) i);
1346  z_map[i].x=(MagickRealType) (0.072186*(double) i);
1347  z_map[i].y=(MagickRealType) (0.500000*(double) i);
1348  z_map[i].z=(MagickRealType) (-0.045847*(double) i);
1349  }
1350  break;
1351  }
1352  case YCCColorspace:
1353  {
1354  /*
1355  Initialize YCC tables:
1356 
1357  Y = 0.298839*R+0.586811*G+0.114350*B
1358  C1= -0.298839*R-0.586811*G+0.88600*B
1359  C2= 0.70100*R-0.586811*G-0.114350*B
1360 
1361  YCC is scaled by 1.3584. C1 zero is 156 and C2 is at 137.
1362  */
1363  primary_info.y=(MagickRealType) ScaleQuantumToMap(
1364  ScaleCharToQuantum(156));
1365  primary_info.z=(MagickRealType) ScaleQuantumToMap(
1366  ScaleCharToQuantum(137));
1367  for (i=0; i <= (ssize_t) (0.018*MaxMap); i++)
1368  {
1369  x_map[i].x=0.005382*i;
1370  x_map[i].y=(-0.003296)*i;
1371  x_map[i].z=0.009410*i;
1372  y_map[i].x=0.010566*i;
1373  y_map[i].y=(-0.006471)*i;
1374  y_map[i].z=(-0.007880)*i;
1375  z_map[i].x=0.002052*i;
1376  z_map[i].y=0.009768*i;
1377  z_map[i].z=(-0.001530)*i;
1378  }
1379  for ( ; i <= (ssize_t) MaxMap; i++)
1380  {
1381  x_map[i].x=0.298839*(1.099*i-0.099);
1382  x_map[i].y=(-0.298839)*(1.099*i-0.099);
1383  x_map[i].z=0.70100*(1.099*i-0.099);
1384  y_map[i].x=0.586811*(1.099*i-0.099);
1385  y_map[i].y=(-0.586811)*(1.099*i-0.099);
1386  y_map[i].z=(-0.586811)*(1.099*i-0.099);
1387  z_map[i].x=0.114350*(1.099*i-0.099);
1388  z_map[i].y=0.88600*(1.099*i-0.099);
1389  z_map[i].z=(-0.114350)*(1.099*i-0.099);
1390  }
1391  break;
1392  }
1393  default:
1394  {
1395  /*
1396  Linear conversion tables.
1397  */
1398 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1399  #pragma omp parallel for schedule(static)
1400 #endif
1401  for (i=0; i <= (ssize_t) MaxMap; i++)
1402  {
1403  x_map[i].x=(MagickRealType) (1.0*(double) i);
1404  x_map[i].y=(MagickRealType) 0.0;
1405  x_map[i].z=(MagickRealType) 0.0;
1406  y_map[i].x=(MagickRealType) 0.0;
1407  y_map[i].y=(MagickRealType) (1.0*(double) i);
1408  y_map[i].z=(MagickRealType) 0.0;
1409  z_map[i].x=(MagickRealType) 0.0;
1410  z_map[i].y=(MagickRealType) 0.0;
1411  z_map[i].z=(MagickRealType) (1.0*(double) i);
1412  }
1413  break;
1414  }
1415  }
1416  /*
1417  Convert from sRGB.
1418  */
1419  switch (image->storage_class)
1420  {
1421  case DirectClass:
1422  default:
1423  {
1424  /*
1425  Convert DirectClass image.
1426  */
1427  image_view=AcquireAuthenticCacheView(image,exception);
1428 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1429  #pragma omp parallel for schedule(static) shared(status) \
1430  magick_number_threads(image,image,image->rows,2)
1431 #endif
1432  for (y=0; y < (ssize_t) image->rows; y++)
1433  {
1434  MagickBooleanType
1435  sync;
1436 
1437  PixelInfo
1438  pixel;
1439 
1440  Quantum
1441  *magick_restrict q;
1442 
1443  ssize_t
1444  x;
1445 
1446  unsigned int
1447  blue,
1448  green,
1449  red;
1450 
1451  if (status == MagickFalse)
1452  continue;
1453  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1454  exception);
1455  if (q == (Quantum *) NULL)
1456  {
1457  status=MagickFalse;
1458  continue;
1459  }
1460  for (x=0; x < (ssize_t) image->columns; x++)
1461  {
1462  red=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
1463  GetPixelRed(image,q)));
1464  green=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
1465  GetPixelGreen(image,q)));
1466  blue=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
1467  GetPixelBlue(image,q)));
1468  pixel.red=(x_map[red].x+y_map[green].x+z_map[blue].x)+
1469  primary_info.x;
1470  pixel.green=(x_map[red].y+y_map[green].y+z_map[blue].y)+
1471  primary_info.y;
1472  pixel.blue=(x_map[red].z+y_map[green].z+z_map[blue].z)+
1473  primary_info.z;
1474  SetPixelRed(image,ScaleMapToQuantum(pixel.red),q);
1475  SetPixelGreen(image,ScaleMapToQuantum(pixel.green),q);
1476  SetPixelBlue(image,ScaleMapToQuantum(pixel.blue),q);
1477  q+=(ptrdiff_t) GetPixelChannels(image);
1478  }
1479  sync=SyncCacheViewAuthenticPixels(image_view,exception);
1480  if (sync == MagickFalse)
1481  status=MagickFalse;
1482  if (image->progress_monitor != (MagickProgressMonitor) NULL)
1483  {
1484  MagickBooleanType
1485  proceed;
1486 
1487 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1488  #pragma omp atomic
1489 #endif
1490  progress++;
1491  proceed=SetImageProgress(image,sRGBTransformImageTag,progress,
1492  image->rows);
1493  if (proceed == MagickFalse)
1494  status=MagickFalse;
1495  }
1496  }
1497  image_view=DestroyCacheView(image_view);
1498  break;
1499  }
1500  case PseudoClass:
1501  {
1502  unsigned int
1503  blue,
1504  green,
1505  red;
1506 
1507  /*
1508  Convert PseudoClass image.
1509  */
1510  for (i=0; i < (ssize_t) image->colors; i++)
1511  {
1512  PixelInfo
1513  pixel;
1514 
1515  red=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].red));
1516  green=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].green));
1517  blue=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].blue));
1518  pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x+primary_info.x;
1519  pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y+primary_info.y;
1520  pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z+primary_info.z;
1521  image->colormap[i].red=(double) ScaleMapToQuantum(pixel.red);
1522  image->colormap[i].green=(double) ScaleMapToQuantum(pixel.green);
1523  image->colormap[i].blue=(double) ScaleMapToQuantum(pixel.blue);
1524  }
1525  (void) SyncImage(image,exception);
1526  break;
1527  }
1528  }
1529  /*
1530  Relinquish resources.
1531  */
1532  z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
1533  y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
1534  x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
1535  if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1536  return(MagickFalse);
1537  return(status);
1538 }
1539 ␌
1540 /*
1541 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1542 % %
1543 % %
1544 % %
1545 % S e t I m a g e C o l o r s p a c e %
1546 % %
1547 % %
1548 % %
1549 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1550 %
1551 % SetImageColorspace() sets the colorspace member of the Image structure.
1552 %
1553 % The format of the SetImageColorspace method is:
1554 %
1555 % MagickBooleanType SetImageColorspace(Image *image,
1556 % const ColorspaceType colorspace,ExceptionInfo *exception)
1557 %
1558 % A description of each parameter follows:
1559 %
1560 % o image: the image.
1561 %
1562 % o colorspace: the colorspace.
1563 %
1564 % o exception: return any errors or warnings in this structure.
1565 %
1566 */
1567 MagickExport MagickBooleanType SetImageColorspace(Image *image,
1568  const ColorspaceType colorspace,ExceptionInfo *exception)
1569 {
1570  ImageType
1571  type;
1572 
1573  MagickBooleanType
1574  status;
1575 
1576  assert(image != (Image *) NULL);
1577  assert(image->signature == MagickCoreSignature);
1578  assert(exception != (ExceptionInfo *) NULL);
1579  assert(exception->signature == MagickCoreSignature);
1580  if (IsEventLogging() != MagickFalse)
1581  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1582  if (image->colorspace == colorspace)
1583  return(MagickTrue);
1584  image->colorspace=colorspace;
1585  image->rendering_intent=UndefinedIntent;
1586  image->gamma=1.000/2.200;
1587  (void) memset(&image->chromaticity,0,sizeof(image->chromaticity));
1588  type=image->type;
1589  if (IsGrayColorspace(colorspace) != MagickFalse)
1590  {
1591  if (colorspace == LinearGRAYColorspace)
1592  image->gamma=1.000;
1593  type=GrayscaleType;
1594  }
1595  else
1596  if ((IsRGBColorspace(colorspace) != MagickFalse) ||
1597  (colorspace == XYZColorspace) || (colorspace == xyYColorspace))
1598  image->gamma=1.000;
1599  else
1600  {
1601  image->rendering_intent=PerceptualIntent;
1602  image->chromaticity.red_primary.x=0.6400;
1603  image->chromaticity.red_primary.y=0.3300;
1604  image->chromaticity.red_primary.z=0.0300;
1605  image->chromaticity.green_primary.x=0.3000;
1606  image->chromaticity.green_primary.y=0.6000;
1607  image->chromaticity.green_primary.z=0.1000;
1608  image->chromaticity.blue_primary.x=0.1500;
1609  image->chromaticity.blue_primary.y=0.0600;
1610  image->chromaticity.blue_primary.z=0.7900;
1611  image->chromaticity.white_point.x=0.3127;
1612  image->chromaticity.white_point.y=0.3290;
1613  image->chromaticity.white_point.z=0.3583;
1614  }
1615  status=SyncImagePixelCache(image,exception);
1616  image->type=type;
1617  return(status);
1618 }
1619 ␌
1620 /*
1621 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1622 % %
1623 % %
1624 % %
1625 % S e t I m a g e G r a y %
1626 % %
1627 % %
1628 % %
1629 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1630 %
1631 % SetImageGray() returns MagickTrue if all the pixels in the image have the
1632 % same red, green, and blue intensities and changes the type of the image to
1633 % bi-level or grayscale.
1634 %
1635 % The format of the SetImageGray method is:
1636 %
1637 % MagickBooleanType SetImageGray(const Image *image,
1638 % ExceptionInfo *exception)
1639 %
1640 % A description of each parameter follows:
1641 %
1642 % o image: the image.
1643 %
1644 % o exception: return any errors or warnings in this structure.
1645 %
1646 */
1647 MagickExport MagickBooleanType SetImageGray(Image *image,
1648  ExceptionInfo *exception)
1649 {
1650  const char
1651  *value;
1652 
1653  ImageType
1654  type;
1655 
1656  assert(image != (Image *) NULL);
1657  assert(image->signature == MagickCoreSignature);
1658  if (IsEventLogging() != MagickFalse)
1659  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1660  if (IsImageGray(image) != MagickFalse)
1661  return(MagickTrue);
1662  if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
1663  return(MagickFalse);
1664  value=GetImageProperty(image,"colorspace:auto-grayscale",exception);
1665  if (IsStringFalse(value) != MagickFalse)
1666  return(MagickFalse);
1667  type=IdentifyImageGray(image,exception);
1668  if (type == UndefinedType)
1669  return(MagickFalse);
1670  image->colorspace=GRAYColorspace;
1671  if (SyncImagePixelCache(image,exception) == MagickFalse)
1672  return(MagickFalse);
1673  image->type=type;
1674  return(MagickTrue);
1675 }
1676 ␌
1677 /*
1678 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1679 % %
1680 % %
1681 % %
1682 % S e t I m a g e M o n o c h r o m e %
1683 % %
1684 % %
1685 % %
1686 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1687 %
1688 % SetImageMonochrome() returns MagickTrue if all the pixels in the image have
1689 % the same red, green, and blue intensities and the intensity is either
1690 % 0 or QuantumRange and changes the type of the image to bi-level.
1691 %
1692 % The format of the SetImageMonochrome method is:
1693 %
1694 % MagickBooleanType SetImageMonochrome(Image *image,
1695 % ExceptionInfo *exception)
1696 %
1697 % A description of each parameter follows:
1698 %
1699 % o image: the image.
1700 %
1701 % o exception: return any errors or warnings in this structure.
1702 %
1703 */
1704 MagickExport MagickBooleanType SetImageMonochrome(Image *image,
1705  ExceptionInfo *exception)
1706 {
1707  MagickBooleanType
1708  is_bilevel;
1709 
1710  assert(image != (Image *) NULL);
1711  assert(image->signature == MagickCoreSignature);
1712  if (IsEventLogging() != MagickFalse)
1713  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1714  if (IsImageMonochrome(image) != MagickFalse)
1715  return(MagickTrue);
1716  if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
1717  return(MagickFalse);
1718  is_bilevel=IdentifyImageMonochrome(image,exception);
1719  if (is_bilevel == MagickFalse)
1720  return(MagickFalse);
1721  image->colorspace=GRAYColorspace;
1722  if (SyncImagePixelCache((Image *) image,exception) == MagickFalse)
1723  return(MagickFalse);
1724  image->type=BilevelType;
1725  return(MagickTrue);
1726 }
1727 ␌
1728 /*
1729 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1730 % %
1731 % %
1732 % %
1733 % T r a n s f o r m I m a g e C o l o r s p a c e %
1734 % %
1735 % %
1736 % %
1737 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1738 %
1739 % TransformImageColorspace() transforms an image colorspace, changing the
1740 % image data to reflect the new colorspace.
1741 %
1742 % The format of the TransformImageColorspace method is:
1743 %
1744 % MagickBooleanType TransformImageColorspace(Image *image,
1745 % const ColorspaceType colorspace,ExceptionInfo *exception)
1746 %
1747 % A description of each parameter follows:
1748 %
1749 % o image: the image.
1750 %
1751 % o colorspace: the colorspace.
1752 %
1753 % o exception: return any errors or warnings in this structure.
1754 %
1755 */
1756 MagickExport MagickBooleanType TransformImageColorspace(Image *image,
1757  const ColorspaceType colorspace,ExceptionInfo *exception)
1758 {
1759  MagickBooleanType
1760  status;
1761 
1762  assert(image != (Image *) NULL);
1763  assert(image->signature == MagickCoreSignature);
1764  if (IsEventLogging() != MagickFalse)
1765  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1766  if (image->colorspace == colorspace)
1767  return(SetImageColorspace(image,colorspace,exception));
1768  (void) DeleteImageProfile(image,"icc");
1769  (void) DeleteImageProfile(image,"icm");
1770  if (colorspace == UndefinedColorspace)
1771  return(SetImageColorspace(image,colorspace,exception));
1772  /*
1773  Convert the reference image from an alternate colorspace to sRGB.
1774  */
1775  if (IssRGBColorspace(colorspace) != MagickFalse)
1776  return(TransformsRGBImage(image,exception));
1777  status=MagickTrue;
1778  if (IssRGBColorspace(image->colorspace) == MagickFalse)
1779  status=TransformsRGBImage(image,exception);
1780  if (status == MagickFalse)
1781  return(status);
1782  /*
1783  Convert the reference image from sRGB to an alternate colorspace.
1784  */
1785  if (sRGBTransformImage(image,colorspace,exception) == MagickFalse)
1786  status=MagickFalse;
1787  return(status);
1788 }
1789 ␌
1790 /*
1791 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1792 % %
1793 % %
1794 % %
1795 + T r a n s f o r m s R G B I m a g e %
1796 % %
1797 % %
1798 % %
1799 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1800 %
1801 % TransformsRGBImage() converts the reference image from an alternate
1802 % colorspace to sRGB. The transformation matrices are not the standard ones:
1803 % the weights are rescaled to normalize the range of the transformed values
1804 % to be [0..QuantumRange].
1805 %
1806 % The format of the TransformsRGBImage method is:
1807 %
1808 % MagickBooleanType TransformsRGBImage(Image *image,
1809 % ExceptionInfo *exception)
1810 %
1811 % A description of each parameter follows:
1812 %
1813 % o image: the image.
1814 %
1815 % o exception: return any errors or warnings in this structure.
1816 %
1817 */
1818 
1819 static inline ssize_t RoundToYCC(const double value)
1820 {
1821  if (value <= 0.0)
1822  return(0);
1823  if (value >= 1388.0)
1824  return(1388);
1825  return((ssize_t) (value+0.5));
1826 }
1827 
1828 static MagickBooleanType TransformsRGBImage(Image *image,
1829  ExceptionInfo *exception)
1830 {
1831 #define TransformsRGBImageTag "Transform/Image"
1832 
1833  static const float
1834  YCCMap[1389] =
1835  {
1836  0.000000f, 0.000720f, 0.001441f, 0.002161f, 0.002882f, 0.003602f,
1837  0.004323f, 0.005043f, 0.005764f, 0.006484f, 0.007205f, 0.007925f,
1838  0.008646f, 0.009366f, 0.010086f, 0.010807f, 0.011527f, 0.012248f,
1839  0.012968f, 0.013689f, 0.014409f, 0.015130f, 0.015850f, 0.016571f,
1840  0.017291f, 0.018012f, 0.018732f, 0.019452f, 0.020173f, 0.020893f,
1841  0.021614f, 0.022334f, 0.023055f, 0.023775f, 0.024496f, 0.025216f,
1842  0.025937f, 0.026657f, 0.027378f, 0.028098f, 0.028818f, 0.029539f,
1843  0.030259f, 0.030980f, 0.031700f, 0.032421f, 0.033141f, 0.033862f,
1844  0.034582f, 0.035303f, 0.036023f, 0.036744f, 0.037464f, 0.038184f,
1845  0.038905f, 0.039625f, 0.040346f, 0.041066f, 0.041787f, 0.042507f,
1846  0.043228f, 0.043948f, 0.044669f, 0.045389f, 0.046110f, 0.046830f,
1847  0.047550f, 0.048271f, 0.048991f, 0.049712f, 0.050432f, 0.051153f,
1848  0.051873f, 0.052594f, 0.053314f, 0.054035f, 0.054755f, 0.055476f,
1849  0.056196f, 0.056916f, 0.057637f, 0.058357f, 0.059078f, 0.059798f,
1850  0.060519f, 0.061239f, 0.061960f, 0.062680f, 0.063401f, 0.064121f,
1851  0.064842f, 0.065562f, 0.066282f, 0.067003f, 0.067723f, 0.068444f,
1852  0.069164f, 0.069885f, 0.070605f, 0.071326f, 0.072046f, 0.072767f,
1853  0.073487f, 0.074207f, 0.074928f, 0.075648f, 0.076369f, 0.077089f,
1854  0.077810f, 0.078530f, 0.079251f, 0.079971f, 0.080692f, 0.081412f,
1855  0.082133f, 0.082853f, 0.083573f, 0.084294f, 0.085014f, 0.085735f,
1856  0.086455f, 0.087176f, 0.087896f, 0.088617f, 0.089337f, 0.090058f,
1857  0.090778f, 0.091499f, 0.092219f, 0.092939f, 0.093660f, 0.094380f,
1858  0.095101f, 0.095821f, 0.096542f, 0.097262f, 0.097983f, 0.098703f,
1859  0.099424f, 0.100144f, 0.100865f, 0.101585f, 0.102305f, 0.103026f,
1860  0.103746f, 0.104467f, 0.105187f, 0.105908f, 0.106628f, 0.107349f,
1861  0.108069f, 0.108790f, 0.109510f, 0.110231f, 0.110951f, 0.111671f,
1862  0.112392f, 0.113112f, 0.113833f, 0.114553f, 0.115274f, 0.115994f,
1863  0.116715f, 0.117435f, 0.118156f, 0.118876f, 0.119597f, 0.120317f,
1864  0.121037f, 0.121758f, 0.122478f, 0.123199f, 0.123919f, 0.124640f,
1865  0.125360f, 0.126081f, 0.126801f, 0.127522f, 0.128242f, 0.128963f,
1866  0.129683f, 0.130403f, 0.131124f, 0.131844f, 0.132565f, 0.133285f,
1867  0.134006f, 0.134726f, 0.135447f, 0.136167f, 0.136888f, 0.137608f,
1868  0.138329f, 0.139049f, 0.139769f, 0.140490f, 0.141210f, 0.141931f,
1869  0.142651f, 0.143372f, 0.144092f, 0.144813f, 0.145533f, 0.146254f,
1870  0.146974f, 0.147695f, 0.148415f, 0.149135f, 0.149856f, 0.150576f,
1871  0.151297f, 0.152017f, 0.152738f, 0.153458f, 0.154179f, 0.154899f,
1872  0.155620f, 0.156340f, 0.157061f, 0.157781f, 0.158501f, 0.159222f,
1873  0.159942f, 0.160663f, 0.161383f, 0.162104f, 0.162824f, 0.163545f,
1874  0.164265f, 0.164986f, 0.165706f, 0.166427f, 0.167147f, 0.167867f,
1875  0.168588f, 0.169308f, 0.170029f, 0.170749f, 0.171470f, 0.172190f,
1876  0.172911f, 0.173631f, 0.174352f, 0.175072f, 0.175793f, 0.176513f,
1877  0.177233f, 0.177954f, 0.178674f, 0.179395f, 0.180115f, 0.180836f,
1878  0.181556f, 0.182277f, 0.182997f, 0.183718f, 0.184438f, 0.185159f,
1879  0.185879f, 0.186599f, 0.187320f, 0.188040f, 0.188761f, 0.189481f,
1880  0.190202f, 0.190922f, 0.191643f, 0.192363f, 0.193084f, 0.193804f,
1881  0.194524f, 0.195245f, 0.195965f, 0.196686f, 0.197406f, 0.198127f,
1882  0.198847f, 0.199568f, 0.200288f, 0.201009f, 0.201729f, 0.202450f,
1883  0.203170f, 0.203890f, 0.204611f, 0.205331f, 0.206052f, 0.206772f,
1884  0.207493f, 0.208213f, 0.208934f, 0.209654f, 0.210375f, 0.211095f,
1885  0.211816f, 0.212536f, 0.213256f, 0.213977f, 0.214697f, 0.215418f,
1886  0.216138f, 0.216859f, 0.217579f, 0.218300f, 0.219020f, 0.219741f,
1887  0.220461f, 0.221182f, 0.221902f, 0.222622f, 0.223343f, 0.224063f,
1888  0.224784f, 0.225504f, 0.226225f, 0.226945f, 0.227666f, 0.228386f,
1889  0.229107f, 0.229827f, 0.230548f, 0.231268f, 0.231988f, 0.232709f,
1890  0.233429f, 0.234150f, 0.234870f, 0.235591f, 0.236311f, 0.237032f,
1891  0.237752f, 0.238473f, 0.239193f, 0.239914f, 0.240634f, 0.241354f,
1892  0.242075f, 0.242795f, 0.243516f, 0.244236f, 0.244957f, 0.245677f,
1893  0.246398f, 0.247118f, 0.247839f, 0.248559f, 0.249280f, 0.250000f,
1894  0.250720f, 0.251441f, 0.252161f, 0.252882f, 0.253602f, 0.254323f,
1895  0.255043f, 0.255764f, 0.256484f, 0.257205f, 0.257925f, 0.258646f,
1896  0.259366f, 0.260086f, 0.260807f, 0.261527f, 0.262248f, 0.262968f,
1897  0.263689f, 0.264409f, 0.265130f, 0.265850f, 0.266571f, 0.267291f,
1898  0.268012f, 0.268732f, 0.269452f, 0.270173f, 0.270893f, 0.271614f,
1899  0.272334f, 0.273055f, 0.273775f, 0.274496f, 0.275216f, 0.275937f,
1900  0.276657f, 0.277378f, 0.278098f, 0.278818f, 0.279539f, 0.280259f,
1901  0.280980f, 0.281700f, 0.282421f, 0.283141f, 0.283862f, 0.284582f,
1902  0.285303f, 0.286023f, 0.286744f, 0.287464f, 0.288184f, 0.288905f,
1903  0.289625f, 0.290346f, 0.291066f, 0.291787f, 0.292507f, 0.293228f,
1904  0.293948f, 0.294669f, 0.295389f, 0.296109f, 0.296830f, 0.297550f,
1905  0.298271f, 0.298991f, 0.299712f, 0.300432f, 0.301153f, 0.301873f,
1906  0.302594f, 0.303314f, 0.304035f, 0.304755f, 0.305476f, 0.306196f,
1907  0.306916f, 0.307637f, 0.308357f, 0.309078f, 0.309798f, 0.310519f,
1908  0.311239f, 0.311960f, 0.312680f, 0.313401f, 0.314121f, 0.314842f,
1909  0.315562f, 0.316282f, 0.317003f, 0.317723f, 0.318444f, 0.319164f,
1910  0.319885f, 0.320605f, 0.321326f, 0.322046f, 0.322767f, 0.323487f,
1911  0.324207f, 0.324928f, 0.325648f, 0.326369f, 0.327089f, 0.327810f,
1912  0.328530f, 0.329251f, 0.329971f, 0.330692f, 0.331412f, 0.332133f,
1913  0.332853f, 0.333573f, 0.334294f, 0.335014f, 0.335735f, 0.336455f,
1914  0.337176f, 0.337896f, 0.338617f, 0.339337f, 0.340058f, 0.340778f,
1915  0.341499f, 0.342219f, 0.342939f, 0.343660f, 0.344380f, 0.345101f,
1916  0.345821f, 0.346542f, 0.347262f, 0.347983f, 0.348703f, 0.349424f,
1917  0.350144f, 0.350865f, 0.351585f, 0.352305f, 0.353026f, 0.353746f,
1918  0.354467f, 0.355187f, 0.355908f, 0.356628f, 0.357349f, 0.358069f,
1919  0.358790f, 0.359510f, 0.360231f, 0.360951f, 0.361671f, 0.362392f,
1920  0.363112f, 0.363833f, 0.364553f, 0.365274f, 0.365994f, 0.366715f,
1921  0.367435f, 0.368156f, 0.368876f, 0.369597f, 0.370317f, 0.371037f,
1922  0.371758f, 0.372478f, 0.373199f, 0.373919f, 0.374640f, 0.375360f,
1923  0.376081f, 0.376801f, 0.377522f, 0.378242f, 0.378963f, 0.379683f,
1924  0.380403f, 0.381124f, 0.381844f, 0.382565f, 0.383285f, 0.384006f,
1925  0.384726f, 0.385447f, 0.386167f, 0.386888f, 0.387608f, 0.388329f,
1926  0.389049f, 0.389769f, 0.390490f, 0.391210f, 0.391931f, 0.392651f,
1927  0.393372f, 0.394092f, 0.394813f, 0.395533f, 0.396254f, 0.396974f,
1928  0.397695f, 0.398415f, 0.399135f, 0.399856f, 0.400576f, 0.401297f,
1929  0.402017f, 0.402738f, 0.403458f, 0.404179f, 0.404899f, 0.405620f,
1930  0.406340f, 0.407061f, 0.407781f, 0.408501f, 0.409222f, 0.409942f,
1931  0.410663f, 0.411383f, 0.412104f, 0.412824f, 0.413545f, 0.414265f,
1932  0.414986f, 0.415706f, 0.416427f, 0.417147f, 0.417867f, 0.418588f,
1933  0.419308f, 0.420029f, 0.420749f, 0.421470f, 0.422190f, 0.422911f,
1934  0.423631f, 0.424352f, 0.425072f, 0.425793f, 0.426513f, 0.427233f,
1935  0.427954f, 0.428674f, 0.429395f, 0.430115f, 0.430836f, 0.431556f,
1936  0.432277f, 0.432997f, 0.433718f, 0.434438f, 0.435158f, 0.435879f,
1937  0.436599f, 0.437320f, 0.438040f, 0.438761f, 0.439481f, 0.440202f,
1938  0.440922f, 0.441643f, 0.442363f, 0.443084f, 0.443804f, 0.444524f,
1939  0.445245f, 0.445965f, 0.446686f, 0.447406f, 0.448127f, 0.448847f,
1940  0.449568f, 0.450288f, 0.451009f, 0.451729f, 0.452450f, 0.453170f,
1941  0.453891f, 0.454611f, 0.455331f, 0.456052f, 0.456772f, 0.457493f,
1942  0.458213f, 0.458934f, 0.459654f, 0.460375f, 0.461095f, 0.461816f,
1943  0.462536f, 0.463256f, 0.463977f, 0.464697f, 0.465418f, 0.466138f,
1944  0.466859f, 0.467579f, 0.468300f, 0.469020f, 0.469741f, 0.470461f,
1945  0.471182f, 0.471902f, 0.472622f, 0.473343f, 0.474063f, 0.474784f,
1946  0.475504f, 0.476225f, 0.476945f, 0.477666f, 0.478386f, 0.479107f,
1947  0.479827f, 0.480548f, 0.481268f, 0.481988f, 0.482709f, 0.483429f,
1948  0.484150f, 0.484870f, 0.485591f, 0.486311f, 0.487032f, 0.487752f,
1949  0.488473f, 0.489193f, 0.489914f, 0.490634f, 0.491354f, 0.492075f,
1950  0.492795f, 0.493516f, 0.494236f, 0.494957f, 0.495677f, 0.496398f,
1951  0.497118f, 0.497839f, 0.498559f, 0.499280f, 0.500000f, 0.500720f,
1952  0.501441f, 0.502161f, 0.502882f, 0.503602f, 0.504323f, 0.505043f,
1953  0.505764f, 0.506484f, 0.507205f, 0.507925f, 0.508646f, 0.509366f,
1954  0.510086f, 0.510807f, 0.511527f, 0.512248f, 0.512968f, 0.513689f,
1955  0.514409f, 0.515130f, 0.515850f, 0.516571f, 0.517291f, 0.518012f,
1956  0.518732f, 0.519452f, 0.520173f, 0.520893f, 0.521614f, 0.522334f,
1957  0.523055f, 0.523775f, 0.524496f, 0.525216f, 0.525937f, 0.526657f,
1958  0.527378f, 0.528098f, 0.528818f, 0.529539f, 0.530259f, 0.530980f,
1959  0.531700f, 0.532421f, 0.533141f, 0.533862f, 0.534582f, 0.535303f,
1960  0.536023f, 0.536744f, 0.537464f, 0.538184f, 0.538905f, 0.539625f,
1961  0.540346f, 0.541066f, 0.541787f, 0.542507f, 0.543228f, 0.543948f,
1962  0.544669f, 0.545389f, 0.546109f, 0.546830f, 0.547550f, 0.548271f,
1963  0.548991f, 0.549712f, 0.550432f, 0.551153f, 0.551873f, 0.552594f,
1964  0.553314f, 0.554035f, 0.554755f, 0.555476f, 0.556196f, 0.556916f,
1965  0.557637f, 0.558357f, 0.559078f, 0.559798f, 0.560519f, 0.561239f,
1966  0.561960f, 0.562680f, 0.563401f, 0.564121f, 0.564842f, 0.565562f,
1967  0.566282f, 0.567003f, 0.567723f, 0.568444f, 0.569164f, 0.569885f,
1968  0.570605f, 0.571326f, 0.572046f, 0.572767f, 0.573487f, 0.574207f,
1969  0.574928f, 0.575648f, 0.576369f, 0.577089f, 0.577810f, 0.578530f,
1970  0.579251f, 0.579971f, 0.580692f, 0.581412f, 0.582133f, 0.582853f,
1971  0.583573f, 0.584294f, 0.585014f, 0.585735f, 0.586455f, 0.587176f,
1972  0.587896f, 0.588617f, 0.589337f, 0.590058f, 0.590778f, 0.591499f,
1973  0.592219f, 0.592939f, 0.593660f, 0.594380f, 0.595101f, 0.595821f,
1974  0.596542f, 0.597262f, 0.597983f, 0.598703f, 0.599424f, 0.600144f,
1975  0.600865f, 0.601585f, 0.602305f, 0.603026f, 0.603746f, 0.604467f,
1976  0.605187f, 0.605908f, 0.606628f, 0.607349f, 0.608069f, 0.608790f,
1977  0.609510f, 0.610231f, 0.610951f, 0.611671f, 0.612392f, 0.613112f,
1978  0.613833f, 0.614553f, 0.615274f, 0.615994f, 0.616715f, 0.617435f,
1979  0.618156f, 0.618876f, 0.619597f, 0.620317f, 0.621037f, 0.621758f,
1980  0.622478f, 0.623199f, 0.623919f, 0.624640f, 0.625360f, 0.626081f,
1981  0.626801f, 0.627522f, 0.628242f, 0.628963f, 0.629683f, 0.630403f,
1982  0.631124f, 0.631844f, 0.632565f, 0.633285f, 0.634006f, 0.634726f,
1983  0.635447f, 0.636167f, 0.636888f, 0.637608f, 0.638329f, 0.639049f,
1984  0.639769f, 0.640490f, 0.641210f, 0.641931f, 0.642651f, 0.643372f,
1985  0.644092f, 0.644813f, 0.645533f, 0.646254f, 0.646974f, 0.647695f,
1986  0.648415f, 0.649135f, 0.649856f, 0.650576f, 0.651297f, 0.652017f,
1987  0.652738f, 0.653458f, 0.654179f, 0.654899f, 0.655620f, 0.656340f,
1988  0.657061f, 0.657781f, 0.658501f, 0.659222f, 0.659942f, 0.660663f,
1989  0.661383f, 0.662104f, 0.662824f, 0.663545f, 0.664265f, 0.664986f,
1990  0.665706f, 0.666427f, 0.667147f, 0.667867f, 0.668588f, 0.669308f,
1991  0.670029f, 0.670749f, 0.671470f, 0.672190f, 0.672911f, 0.673631f,
1992  0.674352f, 0.675072f, 0.675793f, 0.676513f, 0.677233f, 0.677954f,
1993  0.678674f, 0.679395f, 0.680115f, 0.680836f, 0.681556f, 0.682277f,
1994  0.682997f, 0.683718f, 0.684438f, 0.685158f, 0.685879f, 0.686599f,
1995  0.687320f, 0.688040f, 0.688761f, 0.689481f, 0.690202f, 0.690922f,
1996  0.691643f, 0.692363f, 0.693084f, 0.693804f, 0.694524f, 0.695245f,
1997  0.695965f, 0.696686f, 0.697406f, 0.698127f, 0.698847f, 0.699568f,
1998  0.700288f, 0.701009f, 0.701729f, 0.702450f, 0.703170f, 0.703891f,
1999  0.704611f, 0.705331f, 0.706052f, 0.706772f, 0.707493f, 0.708213f,
2000  0.708934f, 0.709654f, 0.710375f, 0.711095f, 0.711816f, 0.712536f,
2001  0.713256f, 0.713977f, 0.714697f, 0.715418f, 0.716138f, 0.716859f,
2002  0.717579f, 0.718300f, 0.719020f, 0.719741f, 0.720461f, 0.721182f,
2003  0.721902f, 0.722622f, 0.723343f, 0.724063f, 0.724784f, 0.725504f,
2004  0.726225f, 0.726945f, 0.727666f, 0.728386f, 0.729107f, 0.729827f,
2005  0.730548f, 0.731268f, 0.731988f, 0.732709f, 0.733429f, 0.734150f,
2006  0.734870f, 0.735591f, 0.736311f, 0.737032f, 0.737752f, 0.738473f,
2007  0.739193f, 0.739914f, 0.740634f, 0.741354f, 0.742075f, 0.742795f,
2008  0.743516f, 0.744236f, 0.744957f, 0.745677f, 0.746398f, 0.747118f,
2009  0.747839f, 0.748559f, 0.749280f, 0.750000f, 0.750720f, 0.751441f,
2010  0.752161f, 0.752882f, 0.753602f, 0.754323f, 0.755043f, 0.755764f,
2011  0.756484f, 0.757205f, 0.757925f, 0.758646f, 0.759366f, 0.760086f,
2012  0.760807f, 0.761527f, 0.762248f, 0.762968f, 0.763689f, 0.764409f,
2013  0.765130f, 0.765850f, 0.766571f, 0.767291f, 0.768012f, 0.768732f,
2014  0.769452f, 0.770173f, 0.770893f, 0.771614f, 0.772334f, 0.773055f,
2015  0.773775f, 0.774496f, 0.775216f, 0.775937f, 0.776657f, 0.777378f,
2016  0.778098f, 0.778818f, 0.779539f, 0.780259f, 0.780980f, 0.781700f,
2017  0.782421f, 0.783141f, 0.783862f, 0.784582f, 0.785303f, 0.786023f,
2018  0.786744f, 0.787464f, 0.788184f, 0.788905f, 0.789625f, 0.790346f,
2019  0.791066f, 0.791787f, 0.792507f, 0.793228f, 0.793948f, 0.794669f,
2020  0.795389f, 0.796109f, 0.796830f, 0.797550f, 0.798271f, 0.798991f,
2021  0.799712f, 0.800432f, 0.801153f, 0.801873f, 0.802594f, 0.803314f,
2022  0.804035f, 0.804755f, 0.805476f, 0.806196f, 0.806916f, 0.807637f,
2023  0.808357f, 0.809078f, 0.809798f, 0.810519f, 0.811239f, 0.811960f,
2024  0.812680f, 0.813401f, 0.814121f, 0.814842f, 0.815562f, 0.816282f,
2025  0.817003f, 0.817723f, 0.818444f, 0.819164f, 0.819885f, 0.820605f,
2026  0.821326f, 0.822046f, 0.822767f, 0.823487f, 0.824207f, 0.824928f,
2027  0.825648f, 0.826369f, 0.827089f, 0.827810f, 0.828530f, 0.829251f,
2028  0.829971f, 0.830692f, 0.831412f, 0.832133f, 0.832853f, 0.833573f,
2029  0.834294f, 0.835014f, 0.835735f, 0.836455f, 0.837176f, 0.837896f,
2030  0.838617f, 0.839337f, 0.840058f, 0.840778f, 0.841499f, 0.842219f,
2031  0.842939f, 0.843660f, 0.844380f, 0.845101f, 0.845821f, 0.846542f,
2032  0.847262f, 0.847983f, 0.848703f, 0.849424f, 0.850144f, 0.850865f,
2033  0.851585f, 0.852305f, 0.853026f, 0.853746f, 0.854467f, 0.855187f,
2034  0.855908f, 0.856628f, 0.857349f, 0.858069f, 0.858790f, 0.859510f,
2035  0.860231f, 0.860951f, 0.861671f, 0.862392f, 0.863112f, 0.863833f,
2036  0.864553f, 0.865274f, 0.865994f, 0.866715f, 0.867435f, 0.868156f,
2037  0.868876f, 0.869597f, 0.870317f, 0.871037f, 0.871758f, 0.872478f,
2038  0.873199f, 0.873919f, 0.874640f, 0.875360f, 0.876081f, 0.876801f,
2039  0.877522f, 0.878242f, 0.878963f, 0.879683f, 0.880403f, 0.881124f,
2040  0.881844f, 0.882565f, 0.883285f, 0.884006f, 0.884726f, 0.885447f,
2041  0.886167f, 0.886888f, 0.887608f, 0.888329f, 0.889049f, 0.889769f,
2042  0.890490f, 0.891210f, 0.891931f, 0.892651f, 0.893372f, 0.894092f,
2043  0.894813f, 0.895533f, 0.896254f, 0.896974f, 0.897695f, 0.898415f,
2044  0.899135f, 0.899856f, 0.900576f, 0.901297f, 0.902017f, 0.902738f,
2045  0.903458f, 0.904179f, 0.904899f, 0.905620f, 0.906340f, 0.907061f,
2046  0.907781f, 0.908501f, 0.909222f, 0.909942f, 0.910663f, 0.911383f,
2047  0.912104f, 0.912824f, 0.913545f, 0.914265f, 0.914986f, 0.915706f,
2048  0.916427f, 0.917147f, 0.917867f, 0.918588f, 0.919308f, 0.920029f,
2049  0.920749f, 0.921470f, 0.922190f, 0.922911f, 0.923631f, 0.924352f,
2050  0.925072f, 0.925793f, 0.926513f, 0.927233f, 0.927954f, 0.928674f,
2051  0.929395f, 0.930115f, 0.930836f, 0.931556f, 0.932277f, 0.932997f,
2052  0.933718f, 0.934438f, 0.935158f, 0.935879f, 0.936599f, 0.937320f,
2053  0.938040f, 0.938761f, 0.939481f, 0.940202f, 0.940922f, 0.941643f,
2054  0.942363f, 0.943084f, 0.943804f, 0.944524f, 0.945245f, 0.945965f,
2055  0.946686f, 0.947406f, 0.948127f, 0.948847f, 0.949568f, 0.950288f,
2056  0.951009f, 0.951729f, 0.952450f, 0.953170f, 0.953891f, 0.954611f,
2057  0.955331f, 0.956052f, 0.956772f, 0.957493f, 0.958213f, 0.958934f,
2058  0.959654f, 0.960375f, 0.961095f, 0.961816f, 0.962536f, 0.963256f,
2059  0.963977f, 0.964697f, 0.965418f, 0.966138f, 0.966859f, 0.967579f,
2060  0.968300f, 0.969020f, 0.969741f, 0.970461f, 0.971182f, 0.971902f,
2061  0.972622f, 0.973343f, 0.974063f, 0.974784f, 0.975504f, 0.976225f,
2062  0.976945f, 0.977666f, 0.978386f, 0.979107f, 0.979827f, 0.980548f,
2063  0.981268f, 0.981988f, 0.982709f, 0.983429f, 0.984150f, 0.984870f,
2064  0.985591f, 0.986311f, 0.987032f, 0.987752f, 0.988473f, 0.989193f,
2065  0.989914f, 0.990634f, 0.991354f, 0.992075f, 0.992795f, 0.993516f,
2066  0.994236f, 0.994957f, 0.995677f, 0.996398f, 0.997118f, 0.997839f,
2067  0.998559f, 0.999280f, 1.000000f
2068  };
2069 
2070  CacheView
2071  *image_view;
2072 
2073  const char
2074  *artifact;
2075 
2076  IlluminantType
2077  illuminant = D65Illuminant;
2078 
2079  MagickBooleanType
2080  status;
2081 
2082  MagickOffsetType
2083  progress;
2084 
2085  ssize_t
2086  i,
2087  y;
2088 
2089  TransformPacket
2090  *y_map,
2091  *x_map,
2092  *z_map;
2093 
2094  assert(image != (Image *) NULL);
2095  assert(image->signature == MagickCoreSignature);
2096  if (IsEventLogging() != MagickFalse)
2097  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2098  artifact=GetImageArtifact(image,"color:illuminant");
2099  if (artifact != (const char *) NULL)
2100  {
2101  ssize_t
2102  illuminant_type;
2103 
2104  illuminant_type=ParseCommandOption(MagickIlluminantOptions,MagickFalse,
2105  artifact);
2106  if (illuminant_type < 0)
2107  illuminant=UndefinedIlluminant;
2108  else
2109  illuminant=(IlluminantType) illuminant_type;
2110  }
2111  status=MagickTrue;
2112  progress=0;
2113  switch (image->colorspace)
2114  {
2115  case CMYKColorspace:
2116  {
2117  PixelInfo
2118  zero;
2119 
2120  /*
2121  Transform image from CMYK to sRGB.
2122  */
2123  if (image->storage_class == PseudoClass)
2124  {
2125  if (SyncImage(image,exception) == MagickFalse)
2126  return(MagickFalse);
2127  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2128  return(MagickFalse);
2129  }
2130  GetPixelInfo(image,&zero);
2131  image_view=AcquireAuthenticCacheView(image,exception);
2132 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2133  #pragma omp parallel for schedule(static) shared(status) \
2134  magick_number_threads(image,image,image->rows,2)
2135 #endif
2136  for (y=0; y < (ssize_t) image->rows; y++)
2137  {
2138  MagickBooleanType
2139  sync;
2140 
2141  PixelInfo
2142  pixel;
2143 
2144  ssize_t
2145  x;
2146 
2147  Quantum
2148  *magick_restrict q;
2149 
2150  if (status == MagickFalse)
2151  continue;
2152  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2153  exception);
2154  if (q == (Quantum *) NULL)
2155  {
2156  status=MagickFalse;
2157  continue;
2158  }
2159  pixel=zero;
2160  for (x=0; x < (ssize_t) image->columns; x++)
2161  {
2162  GetPixelInfoPixel(image,q,&pixel);
2163  ConvertCMYKToRGB(&pixel);
2164  SetPixelViaPixelInfo(image,&pixel,q);
2165  q+=(ptrdiff_t) GetPixelChannels(image);
2166  }
2167  sync=SyncCacheViewAuthenticPixels(image_view,exception);
2168  if (sync == MagickFalse)
2169  status=MagickFalse;
2170  }
2171  image_view=DestroyCacheView(image_view);
2172  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2173  return(MagickFalse);
2174  return(status);
2175  }
2176  case LinearGRAYColorspace:
2177  {
2178  /*
2179  Transform linear GRAY to sRGB colorspace.
2180  */
2181  if (image->storage_class == PseudoClass)
2182  {
2183  if (SyncImage(image,exception) == MagickFalse)
2184  return(MagickFalse);
2185  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2186  return(MagickFalse);
2187  }
2188  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2189  return(MagickFalse);
2190  image_view=AcquireAuthenticCacheView(image,exception);
2191 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2192  #pragma omp parallel for schedule(static) shared(status) \
2193  magick_number_threads(image,image,image->rows,2)
2194 #endif
2195  for (y=0; y < (ssize_t) image->rows; y++)
2196  {
2197  MagickBooleanType
2198  sync;
2199 
2200  ssize_t
2201  x;
2202 
2203  Quantum
2204  *magick_restrict q;
2205 
2206  if (status == MagickFalse)
2207  continue;
2208  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2209  exception);
2210  if (q == (Quantum *) NULL)
2211  {
2212  status=MagickFalse;
2213  continue;
2214  }
2215  for (x=0; x < (ssize_t) image->columns; x++)
2216  {
2217  MagickRealType
2218  gray;
2219 
2220  gray=0.212656*EncodePixelGamma(GetPixelRed(image,q))+0.715158*
2221  EncodePixelGamma(GetPixelGreen(image,q))+0.072186*
2222  EncodePixelGamma(GetPixelBlue(image,q));
2223  SetPixelRed(image,ClampToQuantum(gray),q);
2224  SetPixelGreen(image,ClampToQuantum(gray),q);
2225  SetPixelBlue(image,ClampToQuantum(gray),q);
2226  q+=(ptrdiff_t) GetPixelChannels(image);
2227  }
2228  sync=SyncCacheViewAuthenticPixels(image_view,exception);
2229  if (sync == MagickFalse)
2230  status=MagickFalse;
2231  }
2232  image_view=DestroyCacheView(image_view);
2233  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2234  return(MagickFalse);
2235  return(status);
2236  }
2237  case GRAYColorspace:
2238  {
2239  /*
2240  Transform linear GRAY to sRGB colorspace.
2241  */
2242  if (image->storage_class == PseudoClass)
2243  {
2244  if (SyncImage(image,exception) == MagickFalse)
2245  return(MagickFalse);
2246  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2247  return(MagickFalse);
2248  }
2249  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2250  return(MagickFalse);
2251  image_view=AcquireAuthenticCacheView(image,exception);
2252 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2253  #pragma omp parallel for schedule(static) shared(status) \
2254  magick_number_threads(image,image,image->rows,2)
2255 #endif
2256  for (y=0; y < (ssize_t) image->rows; y++)
2257  {
2258  MagickBooleanType
2259  sync;
2260 
2261  ssize_t
2262  x;
2263 
2264  Quantum
2265  *magick_restrict q;
2266 
2267  if (status == MagickFalse)
2268  continue;
2269  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2270  exception);
2271  if (q == (Quantum *) NULL)
2272  {
2273  status=MagickFalse;
2274  continue;
2275  }
2276  for (x=0; x < (ssize_t) image->columns; x++)
2277  {
2278  MagickRealType
2279  gray;
2280 
2281  gray=0.212656*(double) GetPixelRed(image,q)+0.715158*(double)
2282  GetPixelGreen(image,q)+0.072186*(double) GetPixelBlue(image,q);
2283  SetPixelRed(image,ClampToQuantum(gray),q);
2284  SetPixelGreen(image,ClampToQuantum(gray),q);
2285  SetPixelBlue(image,ClampToQuantum(gray),q);
2286  q+=(ptrdiff_t) GetPixelChannels(image);
2287  }
2288  sync=SyncCacheViewAuthenticPixels(image_view,exception);
2289  if (sync == MagickFalse)
2290  status=MagickFalse;
2291  }
2292  image_view=DestroyCacheView(image_view);
2293  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2294  return(MagickFalse);
2295  return(status);
2296  }
2297  case Adobe98Colorspace:
2298  case CMYColorspace:
2299  case CAT02LMSColorspace:
2300  case DisplayP3Colorspace:
2301  case HCLColorspace:
2302  case HCLpColorspace:
2303  case HSBColorspace:
2304  case HSIColorspace:
2305  case HSLColorspace:
2306  case HSVColorspace:
2307  case HWBColorspace:
2308  case JzazbzColorspace:
2309  case LabColorspace:
2310  case LCHColorspace:
2311  case LCHabColorspace:
2312  case LCHuvColorspace:
2313  case LMSColorspace:
2314  case LuvColorspace:
2315  case OklabColorspace:
2316  case OklchColorspace:
2317  case ProPhotoColorspace:
2318  case xyYColorspace:
2319  case XYZColorspace:
2320  case YCbCrColorspace:
2321  case YDbDrColorspace:
2322  case YIQColorspace:
2323  case YPbPrColorspace:
2324  case YUVColorspace:
2325  {
2326  const char
2327  *value;
2328 
2329  double
2330  white_luminance;
2331 
2332  /*
2333  Transform image from source colorspace to sRGB.
2334  */
2335  white_luminance=10000.0;
2336  value=GetImageProperty(image,"white-luminance",exception);
2337  if (value != (const char *) NULL)
2338  white_luminance=StringToDouble(value,(char **) NULL);
2339  if (image->storage_class == PseudoClass)
2340  {
2341  if (SyncImage(image,exception) == MagickFalse)
2342  return(MagickFalse);
2343  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2344  return(MagickFalse);
2345  }
2346  image_view=AcquireAuthenticCacheView(image,exception);
2347 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2348  #pragma omp parallel for schedule(static) shared(status) \
2349  magick_number_threads(image,image,image->rows,2)
2350 #endif
2351  for (y=0; y < (ssize_t) image->rows; y++)
2352  {
2353  MagickBooleanType
2354  sync;
2355 
2356  ssize_t
2357  x;
2358 
2359  Quantum
2360  *magick_restrict q;
2361 
2362  if (status == MagickFalse)
2363  continue;
2364  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2365  exception);
2366  if (q == (Quantum *) NULL)
2367  {
2368  status=MagickFalse;
2369  continue;
2370  }
2371  for (x=0; x < (ssize_t) image->columns; x++)
2372  {
2373  double
2374  blue,
2375  green,
2376  red;
2377 
2378  ConvertGenericToRGB(image->colorspace,QuantumScale*
2379  GetPixelRed(image,q),QuantumScale*GetPixelGreen(image,q),
2380  QuantumScale*GetPixelBlue(image,q),white_luminance,illuminant,
2381  &red,&green,&blue);
2382  SetPixelRed(image,ClampToQuantum(red),q);
2383  SetPixelGreen(image,ClampToQuantum(green),q);
2384  SetPixelBlue(image,ClampToQuantum(blue),q);
2385  q+=(ptrdiff_t) GetPixelChannels(image);
2386  }
2387  sync=SyncCacheViewAuthenticPixels(image_view,exception);
2388  if (sync == MagickFalse)
2389  status=MagickFalse;
2390  }
2391  image_view=DestroyCacheView(image_view);
2392  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2393  return(MagickFalse);
2394  return(status);
2395  }
2396  case LogColorspace:
2397  {
2398  const char
2399  *value;
2400 
2401  double
2402  black,
2403  density,
2404  film_gamma,
2405  gamma,
2406  reference_black,
2407  reference_white;
2408 
2409  Quantum
2410  *logmap;
2411 
2412  /*
2413  Transform Log to sRGB colorspace.
2414  */
2415  density=DisplayGamma;
2416  gamma=DisplayGamma;
2417  value=GetImageProperty(image,"gamma",exception);
2418  if (value != (const char *) NULL)
2419  gamma=MagickSafeReciprocal(StringToDouble(value,(char **) NULL));
2420  film_gamma=FilmGamma;
2421  value=GetImageProperty(image,"film-gamma",exception);
2422  if (value != (const char *) NULL)
2423  film_gamma=StringToDouble(value,(char **) NULL);
2424  reference_black=ReferenceBlack;
2425  value=GetImageProperty(image,"reference-black",exception);
2426  if (value != (const char *) NULL)
2427  reference_black=StringToDouble(value,(char **) NULL);
2428  if (reference_black > MaximumLogarithmicColorspace)
2429  reference_black=MaximumLogarithmicColorspace;
2430  reference_white=ReferenceWhite;
2431  value=GetImageProperty(image,"reference-white",exception);
2432  if (value != (const char *) NULL)
2433  reference_white=StringToDouble(value,(char **) NULL);
2434  if (reference_white > MaximumLogarithmicColorspace)
2435  reference_white=MaximumLogarithmicColorspace;
2436  if (reference_black > reference_white)
2437  reference_black=reference_white;
2438  logmap=(Quantum *) AcquireQuantumMemory((size_t) MaxMap+1UL,
2439  sizeof(*logmap));
2440  if (logmap == (Quantum *) NULL)
2441  ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
2442  image->filename);
2443  black=pow(10.0,(reference_black-reference_white)*(gamma/density)*0.002*
2444  MagickSafeReciprocal(film_gamma));
2445  for (i=0; i <= (ssize_t) (reference_black*MaxMap/MaximumLogarithmicColorspace); i++)
2446  logmap[i]=(Quantum) 0;
2447  for ( ; i < (ssize_t) (reference_white*MaxMap/MaximumLogarithmicColorspace); i++)
2448  logmap[i]=ClampToQuantum((double) QuantumRange/(1.0-black)*
2449  (pow(10.0,(MaximumLogarithmicColorspace*i/MaxMap-reference_white)*
2450  (gamma/density)*0.002*MagickSafeReciprocal(film_gamma))-black));
2451  for ( ; i <= (ssize_t) MaxMap; i++)
2452  logmap[i]=QuantumRange;
2453  if (image->storage_class == PseudoClass)
2454  {
2455  if ((SyncImage(image,exception) == MagickFalse) ||
2456  (SetImageStorageClass(image,DirectClass,exception) == MagickFalse))
2457  {
2458  logmap=(Quantum *) RelinquishMagickMemory(logmap);
2459  return(MagickFalse);
2460  }
2461  }
2462  image_view=AcquireAuthenticCacheView(image,exception);
2463 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2464  #pragma omp parallel for schedule(static) shared(status) \
2465  magick_number_threads(image,image,image->rows,2)
2466 #endif
2467  for (y=0; y < (ssize_t) image->rows; y++)
2468  {
2469  MagickBooleanType
2470  sync;
2471 
2472  ssize_t
2473  x;
2474 
2475  Quantum
2476  *magick_restrict q;
2477 
2478  if (status == MagickFalse)
2479  continue;
2480  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2481  exception);
2482  if (q == (Quantum *) NULL)
2483  {
2484  status=MagickFalse;
2485  continue;
2486  }
2487  for (x=(ssize_t) image->columns; x != 0; x--)
2488  {
2489  double
2490  blue,
2491  green,
2492  red;
2493 
2494  red=(double) logmap[ScaleQuantumToMap(GetPixelRed(image,q))];
2495  green=(double) logmap[ScaleQuantumToMap(GetPixelGreen(image,q))];
2496  blue=(double) logmap[ScaleQuantumToMap(GetPixelBlue(image,q))];
2497  SetPixelRed(image,ClampToQuantum(EncodePixelGamma((MagickRealType)
2498  red)),q);
2499  SetPixelGreen(image,ClampToQuantum(EncodePixelGamma((MagickRealType)
2500  green)),q);
2501  SetPixelBlue(image,ClampToQuantum(EncodePixelGamma((MagickRealType)
2502  blue)),q);
2503  q+=(ptrdiff_t) GetPixelChannels(image);
2504  }
2505  sync=SyncCacheViewAuthenticPixels(image_view,exception);
2506  if (sync == MagickFalse)
2507  status=MagickFalse;
2508  }
2509  image_view=DestroyCacheView(image_view);
2510  logmap=(Quantum *) RelinquishMagickMemory(logmap);
2511  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2512  return(MagickFalse);
2513  return(status);
2514  }
2515  case RGBColorspace:
2516  case scRGBColorspace:
2517  {
2518  /*
2519  Transform linear RGB to sRGB colorspace.
2520  */
2521  if (image->storage_class == PseudoClass)
2522  {
2523  if (SyncImage(image,exception) == MagickFalse)
2524  return(MagickFalse);
2525  if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2526  return(MagickFalse);
2527  }
2528  image_view=AcquireAuthenticCacheView(image,exception);
2529 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2530  #pragma omp parallel for schedule(static) shared(status) \
2531  magick_number_threads(image,image,image->rows,2)
2532 #endif
2533  for (y=0; y < (ssize_t) image->rows; y++)
2534  {
2535  MagickBooleanType
2536  sync;
2537 
2538  ssize_t
2539  x;
2540 
2541  Quantum
2542  *magick_restrict q;
2543 
2544  if (status == MagickFalse)
2545  continue;
2546  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2547  exception);
2548  if (q == (Quantum *) NULL)
2549  {
2550  status=MagickFalse;
2551  continue;
2552  }
2553  for (x=(ssize_t) image->columns; x != 0; x--)
2554  {
2555  double
2556  blue,
2557  green,
2558  red;
2559 
2560  red=EncodePixelGamma((MagickRealType) GetPixelRed(image,q));
2561  green=EncodePixelGamma((MagickRealType) GetPixelGreen(image,q));
2562  blue=EncodePixelGamma((MagickRealType) GetPixelBlue(image,q));
2563  SetPixelRed(image,ClampToQuantum(red),q);
2564  SetPixelGreen(image,ClampToQuantum(green),q);
2565  SetPixelBlue(image,ClampToQuantum(blue),q);
2566  q+=(ptrdiff_t) GetPixelChannels(image);
2567  }
2568  sync=SyncCacheViewAuthenticPixels(image_view,exception);
2569  if (sync == MagickFalse)
2570  status=MagickFalse;
2571  }
2572  image_view=DestroyCacheView(image_view);
2573  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2574  return(MagickFalse);
2575  return(status);
2576  }
2577  default:
2578  break;
2579  }
2580  /*
2581  Allocate the tables.
2582  */
2583  x_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
2584  sizeof(*x_map));
2585  y_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
2586  sizeof(*y_map));
2587  z_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
2588  sizeof(*z_map));
2589  if ((x_map == (TransformPacket *) NULL) ||
2590  (y_map == (TransformPacket *) NULL) ||
2591  (z_map == (TransformPacket *) NULL))
2592  {
2593  if (z_map != (TransformPacket *) NULL)
2594  z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
2595  if (y_map != (TransformPacket *) NULL)
2596  y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
2597  if (x_map != (TransformPacket *) NULL)
2598  x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
2599  ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
2600  image->filename);
2601  }
2602  switch (image->colorspace)
2603  {
2604  case OHTAColorspace:
2605  {
2606  /*
2607  Initialize OHTA tables:
2608 
2609  I1 = 0.33333*R+0.33334*G+0.33333*B
2610  I2 = 0.50000*R+0.00000*G-0.50000*B
2611  I3 =-0.25000*R+0.50000*G-0.25000*B
2612  R = I1+1.00000*I2-0.66668*I3
2613  G = I1+0.00000*I2+1.33333*I3
2614  B = I1-1.00000*I2-0.66668*I3
2615 
2616  I and Q, normally -0.5 through 0.5, must be normalized to the range 0
2617  through QuantumRange.
2618  */
2619 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2620  #pragma omp parallel for schedule(static)
2621 #endif
2622  for (i=0; i <= (ssize_t) MaxMap; i++)
2623  {
2624  x_map[i].x=(MagickRealType) (1.0*(double) i);
2625  y_map[i].x=(MagickRealType) (0.5*1.00000*(2.0*(double) i-MaxMap));
2626  z_map[i].x=(MagickRealType) (-0.5*0.66668*(2.0*(double) i-MaxMap));
2627  x_map[i].y=(MagickRealType) (1.0*(double) i);
2628  y_map[i].y=(MagickRealType) (0.5*0.00000*(2.0*(double) i-MaxMap));
2629  z_map[i].y=(MagickRealType) (0.5*1.33333*(2.0*(double) i-MaxMap));
2630  x_map[i].z=(MagickRealType) (1.0*(double) i);
2631  y_map[i].z=(MagickRealType) (-0.5*1.00000*(2.0*(double) i-MaxMap));
2632  z_map[i].z=(MagickRealType) (-0.5*0.66668*(2.0*(double) i-MaxMap));
2633  }
2634  break;
2635  }
2636  case Rec601YCbCrColorspace:
2637  {
2638  /*
2639  Initialize YCbCr tables:
2640 
2641  R = Y +1.402000*Cr
2642  G = Y-0.344136*Cb-0.714136*Cr
2643  B = Y+1.772000*Cb
2644 
2645  Cb and Cr, normally -0.5 through 0.5, must be normalized to the range 0
2646  through QuantumRange.
2647  */
2648 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2649  #pragma omp parallel for schedule(static)
2650 #endif
2651  for (i=0; i <= (ssize_t) MaxMap; i++)
2652  {
2653  x_map[i].x=0.99999999999914679361*(double) i;
2654  y_map[i].x=0.5*(-1.2188941887145875e-06)*(2.00*(double) i-MaxMap);
2655  z_map[i].x=0.5*1.4019995886561440468*(2.00*(double) i-MaxMap);
2656  x_map[i].y=0.99999975910502514331*(double) i;
2657  y_map[i].y=0.5*(-0.34413567816504303521)*(2.00*(double) i-MaxMap);
2658  z_map[i].y=0.5*(-0.71413649331646789076)*(2.00*(double) i-MaxMap);
2659  x_map[i].z=1.00000124040004623180*(double) i;
2660  y_map[i].z=0.5*1.77200006607230409200*(2.00*(double) i-MaxMap);
2661  z_map[i].z=0.5*2.1453384174593273e-06*(2.00*(double) i-MaxMap);
2662  }
2663  break;
2664  }
2665  case Rec709YCbCrColorspace:
2666  {
2667  /*
2668  Initialize YCbCr tables:
2669 
2670  R = Y +1.574800*Cr
2671  G = Y-0.187324*Cb-0.468124*Cr
2672  B = Y+1.855600*Cb
2673 
2674  Cb and Cr, normally -0.5 through 0.5, must be normalized to the range 0
2675  through QuantumRange.
2676  */
2677 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2678  #pragma omp parallel for schedule(static)
2679 #endif
2680  for (i=0; i <= (ssize_t) MaxMap; i++)
2681  {
2682  x_map[i].x=(MagickRealType) (1.0*i);
2683  y_map[i].x=(MagickRealType) (0.5*0.000000*(2.0*i-MaxMap));
2684  z_map[i].x=(MagickRealType) (0.5*1.574800*(2.0*i-MaxMap));
2685  x_map[i].y=(MagickRealType) (1.0*i);
2686  y_map[i].y=(MagickRealType) (0.5*(-0.187324)*(2.0*i-MaxMap));
2687  z_map[i].y=(MagickRealType) (0.5*(-0.468124)*(2.0*i-MaxMap));
2688  x_map[i].z=(MagickRealType) (1.0*i);
2689  y_map[i].z=(MagickRealType) (0.5*1.855600*(2.0*i-MaxMap));
2690  z_map[i].z=(MagickRealType) (0.5*0.000000*(2.0*i-MaxMap));
2691  }
2692  break;
2693  }
2694  case YCCColorspace:
2695  {
2696  /*
2697  Initialize YCC tables:
2698 
2699  R = Y +1.340762*C2
2700  G = Y-0.317038*C1-0.682243*C2
2701  B = Y+1.632639*C1
2702 
2703  YCC is scaled by 1.3584. C1 zero is 156 and C2 is at 137.
2704  */
2705 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2706  #pragma omp parallel for schedule(static)
2707 #endif
2708  for (i=0; i <= (ssize_t) MaxMap; i++)
2709  {
2710  x_map[i].x=(MagickRealType) (1.3584000*(double) i);
2711  y_map[i].x=(MagickRealType) 0.0000000;
2712  z_map[i].x=(MagickRealType) (1.8215000*(1.0*(double) i-(double)
2713  ScaleQuantumToMap(ScaleCharToQuantum(137))));
2714  x_map[i].y=(MagickRealType) (1.3584000*(double) i);
2715  y_map[i].y=(MagickRealType) (-0.4302726*(1.0*(double) i-(double)
2716  ScaleQuantumToMap(ScaleCharToQuantum(156))));
2717  z_map[i].y=(MagickRealType) (-0.9271435*(1.0*(double) i-(double)
2718  ScaleQuantumToMap(ScaleCharToQuantum(137))));
2719  x_map[i].z=(MagickRealType) (1.3584000*(double) i);
2720  y_map[i].z=(MagickRealType) (2.2179000*(1.0*(double) i-(double)
2721  ScaleQuantumToMap(ScaleCharToQuantum(156))));
2722  z_map[i].z=(MagickRealType) 0.0000000;
2723  }
2724  break;
2725  }
2726  default:
2727  {
2728  /*
2729  Linear conversion tables.
2730  */
2731 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2732  #pragma omp parallel for schedule(static)
2733 #endif
2734  for (i=0; i <= (ssize_t) MaxMap; i++)
2735  {
2736  x_map[i].x=(MagickRealType) (1.0*(double) i);
2737  y_map[i].x=(MagickRealType) 0.0;
2738  z_map[i].x=(MagickRealType) 0.0;
2739  x_map[i].y=(MagickRealType) 0.0;
2740  y_map[i].y=(MagickRealType) (1.0*(double) i);
2741  z_map[i].y=(MagickRealType) 0.0;
2742  x_map[i].z=(MagickRealType) 0.0;
2743  y_map[i].z=(MagickRealType) 0.0;
2744  z_map[i].z=(MagickRealType) (1.0*(double) i);
2745  }
2746  break;
2747  }
2748  }
2749  /*
2750  Convert to sRGB.
2751  */
2752  switch (image->storage_class)
2753  {
2754  case DirectClass:
2755  default:
2756  {
2757  /*
2758  Convert DirectClass image.
2759  */
2760  image_view=AcquireAuthenticCacheView(image,exception);
2761 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2762  #pragma omp parallel for schedule(static) shared(status) \
2763  magick_number_threads(image,image,image->rows,2)
2764 #endif
2765  for (y=0; y < (ssize_t) image->rows; y++)
2766  {
2767  MagickBooleanType
2768  sync;
2769 
2770  PixelInfo
2771  pixel;
2772 
2773  ssize_t
2774  x;
2775 
2776  Quantum
2777  *magick_restrict q;
2778 
2779  if (status == MagickFalse)
2780  continue;
2781  q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2782  exception);
2783  if (q == (Quantum *) NULL)
2784  {
2785  status=MagickFalse;
2786  continue;
2787  }
2788  for (x=0; x < (ssize_t) image->columns; x++)
2789  {
2790  size_t
2791  blue,
2792  green,
2793  red;
2794 
2795  red=ScaleQuantumToMap(GetPixelRed(image,q));
2796  green=ScaleQuantumToMap(GetPixelGreen(image,q));
2797  blue=ScaleQuantumToMap(GetPixelBlue(image,q));
2798  pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
2799  pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
2800  pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
2801  if (image->colorspace == YCCColorspace)
2802  {
2803  pixel.red=(double) QuantumRange*(double) YCCMap[RoundToYCC(
2804  MaximumLogarithmicColorspace*pixel.red/(double) MaxMap)];
2805  pixel.green=(double) QuantumRange*(double) YCCMap[RoundToYCC(
2806  MaximumLogarithmicColorspace*pixel.green/(double) MaxMap)];
2807  pixel.blue=(double) QuantumRange*(double) YCCMap[RoundToYCC(
2808  MaximumLogarithmicColorspace*pixel.blue/(double) MaxMap)];
2809  }
2810  else
2811  {
2812  pixel.red=(MagickRealType) ScaleMapToQuantum(pixel.red);
2813  pixel.green=(MagickRealType) ScaleMapToQuantum(pixel.green);
2814  pixel.blue=(MagickRealType) ScaleMapToQuantum(pixel.blue);
2815  }
2816  SetPixelRed(image,ClampToQuantum(pixel.red),q);
2817  SetPixelGreen(image,ClampToQuantum(pixel.green),q);
2818  SetPixelBlue(image,ClampToQuantum(pixel.blue),q);
2819  q+=(ptrdiff_t) GetPixelChannels(image);
2820  }
2821  sync=SyncCacheViewAuthenticPixels(image_view,exception);
2822  if (sync == MagickFalse)
2823  status=MagickFalse;
2824  if (image->progress_monitor != (MagickProgressMonitor) NULL)
2825  {
2826  MagickBooleanType
2827  proceed;
2828 
2829 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2830  #pragma omp atomic
2831 #endif
2832  progress++;
2833  proceed=SetImageProgress(image,TransformsRGBImageTag,progress,
2834  image->rows);
2835  if (proceed == MagickFalse)
2836  status=MagickFalse;
2837  }
2838  }
2839  image_view=DestroyCacheView(image_view);
2840  break;
2841  }
2842  case PseudoClass:
2843  {
2844  /*
2845  Convert PseudoClass image.
2846  */
2847 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2848  #pragma omp parallel for schedule(static) shared(status) \
2849  magick_number_threads(image,image,image->rows,1)
2850 #endif
2851  for (i=0; i < (ssize_t) image->colors; i++)
2852  {
2853  PixelInfo
2854  pixel;
2855 
2856  size_t
2857  blue,
2858  green,
2859  red;
2860 
2861  red=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].red));
2862  green=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].green));
2863  blue=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].blue));
2864  pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
2865  pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
2866  pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
2867  if (image->colorspace == YCCColorspace)
2868  {
2869  pixel.red=(double) QuantumRange*(double) YCCMap[RoundToYCC(
2870  MaximumLogarithmicColorspace*pixel.red/(double) MaxMap)];
2871  pixel.green=(double) QuantumRange*(double) YCCMap[RoundToYCC(
2872  MaximumLogarithmicColorspace*pixel.green/(double) MaxMap)];
2873  pixel.blue=(double) QuantumRange*(double) YCCMap[RoundToYCC(
2874  MaximumLogarithmicColorspace*pixel.blue/(double) MaxMap)];
2875  }
2876  else
2877  {
2878  pixel.red=(MagickRealType) ScaleMapToQuantum(pixel.red);
2879  pixel.green=(MagickRealType) ScaleMapToQuantum(pixel.green);
2880  pixel.blue=(MagickRealType) ScaleMapToQuantum(pixel.blue);
2881  }
2882  image->colormap[i].red=(double) ClampToQuantum(pixel.red);
2883  image->colormap[i].green=(double) ClampToQuantum(pixel.green);
2884  image->colormap[i].blue=(double) ClampToQuantum(pixel.blue);
2885  }
2886  (void) SyncImage(image,exception);
2887  break;
2888  }
2889  }
2890  /*
2891  Relinquish resources.
2892  */
2893  z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
2894  y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
2895  x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
2896  if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2897  return(MagickFalse);
2898  return(MagickTrue);
2899 }
_CacheView
Definition: cache-view.c:66
_ExceptionInfo
Definition: exception.h:102
_Image
Definition: image.h:132
_PixelInfo
Definition: pixel.h:182
_PrimaryInfo
Definition: image.h:77
_TransformPacket
Definition: colorspace.c:82