2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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 %
13 % MagickCore Image Colorspace Methods %
20 % Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
26 % http://www.imagemagick.org/script/license.php %
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. %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
42 #include "MagickCore/studio.h"
43 #include "MagickCore/property.h"
44 #include "MagickCore/cache.h"
45 #include "MagickCore/cache-private.h"
46 #include "MagickCore/cache-view.h"
47 #include "MagickCore/color.h"
48 #include "MagickCore/color-private.h"
49 #include "MagickCore/colorspace.h"
50 #include "MagickCore/colorspace-private.h"
51 #include "MagickCore/exception.h"
52 #include "MagickCore/exception-private.h"
53 #include "MagickCore/image.h"
54 #include "MagickCore/image-private.h"
55 #include "MagickCore/gem.h"
56 #include "MagickCore/gem-private.h"
57 #include "MagickCore/memory_.h"
58 #include "MagickCore/monitor.h"
59 #include "MagickCore/monitor-private.h"
60 #include "MagickCore/pixel-accessor.h"
61 #include "MagickCore/pixel-private.h"
62 #include "MagickCore/quantize.h"
63 #include "MagickCore/quantum.h"
64 #include "MagickCore/quantum-private.h"
65 #include "MagickCore/resource_.h"
66 #include "MagickCore/string_.h"
67 #include "MagickCore/string-private.h"
68 #include "MagickCore/utility.h"
73 typedef struct _TransformPacket
84 static MagickBooleanType
85 TransformsRGBImage(Image *,const ColorspaceType,ExceptionInfo *);
88 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
92 + s R G B T r a n s f o r m I m a g e %
96 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
98 % sRGBTransformImage() converts the reference image from sRGB to an alternate
99 % colorspace. The transformation matrices are not the standard ones: the
100 % weights are rescaled to normalized the range of the transformed values to
101 % be [0..QuantumRange].
103 % The format of the sRGBTransformImage method is:
105 % MagickBooleanType sRGBTransformImage(Image *image,
106 % const ColorspaceType colorspace,EsceptionInfo *exception)
108 % A description of each parameter follows:
110 % o image: the image.
112 % o colorspace: the colorspace to transform the image to.
114 % o exception: return any errors or warnings in this structure.
118 static inline void ConvertXYZToLMS(const double x,const double y,
119 const double z,double *L,double *M,double *S)
127 Convert XYZ to LMS colorspace.
129 assert(L != (double *) NULL);
130 assert(M != (double *) NULL);
131 assert(S != (double *) NULL);
132 l=0.7328*x+0.4296*y-0.1624*z;
133 m=(-0.7036*x+1.6975*y+0.0061*z);
134 s=0.0030*x+0.0136*y+0.9834*z;
140 static MagickBooleanType sRGBTransformImage(Image *image,
141 const ColorspaceType colorspace,ExceptionInfo *exception)
143 #define sRGBTransformImageTag "RGBTransform/Image"
168 assert(image != (Image *) NULL);
169 assert(image->signature == MagickSignature);
170 if (image->debug != MagickFalse)
171 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
172 assert(colorspace != sRGBColorspace);
173 assert(colorspace != TransparentColorspace);
174 assert(colorspace != UndefinedColorspace);
182 Convert RGB to CMY colorspace.
184 if (image->storage_class == PseudoClass)
186 if (SyncImage(image,exception) == MagickFalse)
188 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
191 image_view=AcquireAuthenticCacheView(image,exception);
192 #if defined(MAGICKCORE_OPENMP_SUPPORT)
193 #pragma omp parallel for schedule(static,4) shared(status) \
194 magick_threads(image,image,image->rows,1)
196 for (y=0; y < (ssize_t) image->rows; y++)
207 if (status == MagickFalse)
209 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
211 if (q == (Quantum *) NULL)
216 for (x=0; x < (ssize_t) image->columns; x++)
223 cyan=DecodePixelGamma((MagickRealType) GetPixelCyan(image,q));
224 magenta=DecodePixelGamma((MagickRealType) GetPixelMagenta(image,q));
225 yellow=DecodePixelGamma((MagickRealType) GetPixelYellow(image,q));
226 SetPixelCyan(image,ClampToQuantum(QuantumRange-cyan),q);
227 SetPixelMagenta(image,ClampToQuantum(QuantumRange-magenta),q);
228 SetPixelYellow(image,ClampToQuantum(QuantumRange-yellow),q);
229 q+=GetPixelChannels(image);
231 sync=SyncCacheViewAuthenticPixels(image_view,exception);
232 if (sync == MagickFalse)
235 image_view=DestroyCacheView(image_view);
236 image->type=image->alpha_trait != BlendPixelTrait ? ColorSeparationType :
237 ColorSeparationMatteType;
238 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
248 Convert RGB to CMYK colorspace.
250 if (image->storage_class == PseudoClass)
252 if (SyncImage(image,exception) == MagickFalse)
254 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
257 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
259 GetPixelInfo(image,&zero);
260 image_view=AcquireAuthenticCacheView(image,exception);
261 #if defined(MAGICKCORE_OPENMP_SUPPORT)
262 #pragma omp parallel for schedule(static,4) shared(status) \
263 magick_threads(image,image,image->rows,1)
265 for (y=0; y < (ssize_t) image->rows; y++)
279 if (status == MagickFalse)
281 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
283 if (q == (Quantum *) NULL)
289 for (x=0; x < (ssize_t) image->columns; x++)
291 GetPixelInfoPixel(image,q,&pixel);
292 pixel.red=DecodePixelGamma(pixel.red);
293 pixel.green=DecodePixelGamma(pixel.green);
294 pixel.blue=DecodePixelGamma(pixel.blue);
295 ConvertRGBToCMYK(&pixel);
296 SetPixelInfoPixel(image,&pixel,q);
297 q+=GetPixelChannels(image);
299 sync=SyncCacheViewAuthenticPixels(image_view,exception);
300 if (sync == MagickFalse)
303 image_view=DestroyCacheView(image_view);
304 image->type=image->alpha_trait != BlendPixelTrait ? ColorSeparationType :
305 ColorSeparationMatteType;
306 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
313 Transform image from sRGB to GRAY.
315 if (image->storage_class == PseudoClass)
317 if (SyncImage(image,exception) == MagickFalse)
319 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
322 image_view=AcquireAuthenticCacheView(image,exception);
323 #if defined(MAGICKCORE_OPENMP_SUPPORT)
324 #pragma omp parallel for schedule(static,4) shared(status) \
325 magick_threads(image,image,image->rows,1)
327 for (y=0; y < (ssize_t) image->rows; y++)
338 if (status == MagickFalse)
340 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
342 if (q == (Quantum *) NULL)
347 for (x=0; x < (ssize_t) image->columns; x++)
349 SetPixelGray(image,ClampToQuantum(GetPixelIntensity(image,q)),q);
350 q+=GetPixelChannels(image);
352 sync=SyncCacheViewAuthenticPixels(image_view,exception);
353 if (sync == MagickFalse)
356 image_view=DestroyCacheView(image_view);
357 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
359 image->type=GrayscaleType;
365 Transform image from sRGB to HCL.
367 if (image->storage_class == PseudoClass)
369 if (SyncImage(image,exception) == MagickFalse)
371 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
374 image_view=AcquireAuthenticCacheView(image,exception);
375 #if defined(MAGICKCORE_OPENMP_SUPPORT)
376 #pragma omp parallel for schedule(static,4) shared(status) \
377 magick_threads(image,image,image->rows,1)
379 for (y=0; y < (ssize_t) image->rows; y++)
390 if (status == MagickFalse)
392 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
394 if (q == (Quantum *) NULL)
399 for (x=0; x < (ssize_t) image->columns; x++)
409 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
410 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
411 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
412 ConvertRGBToHCL(red,green,blue,&hue,&chroma,&luma);
413 SetPixelRed(image,ClampToQuantum(QuantumRange*hue),q);
414 SetPixelGreen(image,ClampToQuantum(QuantumRange*chroma),q);
415 SetPixelBlue(image,ClampToQuantum(QuantumRange*luma),q);
416 q+=GetPixelChannels(image);
418 sync=SyncCacheViewAuthenticPixels(image_view,exception);
419 if (sync == MagickFalse)
422 image_view=DestroyCacheView(image_view);
423 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
430 Transform image from sRGB to HSB.
432 if (image->storage_class == PseudoClass)
434 if (SyncImage(image,exception) == MagickFalse)
436 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
439 image_view=AcquireAuthenticCacheView(image,exception);
440 #if defined(MAGICKCORE_OPENMP_SUPPORT)
441 #pragma omp parallel for schedule(static,4) shared(status) \
442 magick_threads(image,image,image->rows,1)
444 for (y=0; y < (ssize_t) image->rows; y++)
455 if (status == MagickFalse)
457 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
459 if (q == (Quantum *) NULL)
464 for (x=0; x < (ssize_t) image->columns; x++)
474 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
475 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
476 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
477 ConvertRGBToHSB(red,green,blue,&hue,&saturation,&brightness);
478 SetPixelRed(image,ClampToQuantum(QuantumRange*hue),q);
479 SetPixelGreen(image,ClampToQuantum(QuantumRange*saturation),q);
480 SetPixelBlue(image,ClampToQuantum(QuantumRange*brightness),q);
481 q+=GetPixelChannels(image);
483 sync=SyncCacheViewAuthenticPixels(image_view,exception);
484 if (sync == MagickFalse)
487 image_view=DestroyCacheView(image_view);
488 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
495 Transform image from sRGB to HSL.
497 if (image->storage_class == PseudoClass)
499 if (SyncImage(image,exception) == MagickFalse)
501 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
504 image_view=AcquireAuthenticCacheView(image,exception);
505 #if defined(MAGICKCORE_OPENMP_SUPPORT)
506 #pragma omp parallel for schedule(static,4) shared(status) \
507 magick_threads(image,image,image->rows,1)
509 for (y=0; y < (ssize_t) image->rows; y++)
520 if (status == MagickFalse)
522 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
524 if (q == (Quantum *) NULL)
529 for (x=0; x < (ssize_t) image->columns; x++)
539 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
540 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
541 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
542 ConvertRGBToHSL(red,green,blue,&hue,&saturation,&lightness);
543 SetPixelRed(image,ClampToQuantum(QuantumRange*hue),q);
544 SetPixelGreen(image,ClampToQuantum(QuantumRange*saturation),q);
545 SetPixelBlue(image,ClampToQuantum(QuantumRange*lightness),q);
546 q+=GetPixelChannels(image);
548 sync=SyncCacheViewAuthenticPixels(image_view,exception);
549 if (sync == MagickFalse)
552 image_view=DestroyCacheView(image_view);
553 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
560 Transform image from sRGB to HWB.
562 if (image->storage_class == PseudoClass)
564 if (SyncImage(image,exception) == MagickFalse)
566 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
569 image_view=AcquireAuthenticCacheView(image,exception);
570 #if defined(MAGICKCORE_OPENMP_SUPPORT)
571 #pragma omp parallel for schedule(static,4) shared(status) \
572 magick_threads(image,image,image->rows,1)
574 for (y=0; y < (ssize_t) image->rows; y++)
585 if (status == MagickFalse)
587 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
589 if (q == (Quantum *) NULL)
594 for (x=0; x < (ssize_t) image->columns; x++)
604 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
605 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
606 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
607 ConvertRGBToHWB(red,green,blue,&hue,&whiteness,&blackness);
608 SetPixelRed(image,ClampToQuantum(QuantumRange*hue),q);
609 SetPixelGreen(image,ClampToQuantum(QuantumRange*whiteness),q);
610 SetPixelBlue(image,ClampToQuantum(QuantumRange*blackness),q);
611 q+=GetPixelChannels(image);
613 sync=SyncCacheViewAuthenticPixels(image_view,exception);
614 if (sync == MagickFalse)
617 image_view=DestroyCacheView(image_view);
618 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
625 Transform image from sRGB to Lab.
627 if (image->storage_class == PseudoClass)
629 if (SyncImage(image,exception) == MagickFalse)
631 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
634 image_view=AcquireAuthenticCacheView(image,exception);
635 #if defined(MAGICKCORE_OPENMP_SUPPORT)
636 #pragma omp parallel for schedule(static,4) shared(status) \
637 magick_threads(image,image,image->rows,1)
639 for (y=0; y < (ssize_t) image->rows; y++)
650 if (status == MagickFalse)
652 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
654 if (q == (Quantum *) NULL)
659 for (x=0; x < (ssize_t) image->columns; x++)
672 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
673 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
674 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
675 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
676 ConvertXYZToLab(X,Y,Z,&L,&a,&b);
677 SetPixelRed(image,ClampToQuantum(QuantumRange*L),q);
678 SetPixelGreen(image,ClampToQuantum(QuantumRange*a),q);
679 SetPixelBlue(image,ClampToQuantum(QuantumRange*b),q);
680 q+=GetPixelChannels(image);
682 sync=SyncCacheViewAuthenticPixels(image_view,exception);
683 if (sync == MagickFalse)
686 image_view=DestroyCacheView(image_view);
687 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
691 case LCHabColorspace:
694 Transform image from sRGB to LCHab.
696 if (image->storage_class == PseudoClass)
698 if (SyncImage(image,exception) == MagickFalse)
700 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
703 image_view=AcquireAuthenticCacheView(image,exception);
704 #if defined(MAGICKCORE_OPENMP_SUPPORT)
705 #pragma omp parallel for schedule(static,4) shared(status) \
706 magick_threads(image,image,image->rows,1)
708 for (y=0; y < (ssize_t) image->rows; y++)
719 if (status == MagickFalse)
721 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
723 if (q == (Quantum *) NULL)
728 for (x=0; x < (ssize_t) image->columns; x++)
738 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
739 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
740 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
741 ConvertRGBToLCHab(red,green,blue,&luma,&chroma,&hue);
742 SetPixelRed(image,ClampToQuantum(QuantumRange*luma),q);
743 SetPixelGreen(image,ClampToQuantum(QuantumRange*chroma),q);
744 SetPixelBlue(image,ClampToQuantum(QuantumRange*hue),q);
745 q+=GetPixelChannels(image);
747 sync=SyncCacheViewAuthenticPixels(image_view,exception);
748 if (sync == MagickFalse)
751 image_view=DestroyCacheView(image_view);
752 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
757 case LCHuvColorspace:
760 Transform image from sRGB to LCHuv.
762 if (image->storage_class == PseudoClass)
764 if (SyncImage(image,exception) == MagickFalse)
766 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
769 image_view=AcquireAuthenticCacheView(image,exception);
770 #if defined(MAGICKCORE_OPENMP_SUPPORT)
771 #pragma omp parallel for schedule(static,4) shared(status) \
772 magick_threads(image,image,image->rows,1)
774 for (y=0; y < (ssize_t) image->rows; y++)
785 if (status == MagickFalse)
787 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
789 if (q == (Quantum *) NULL)
794 for (x=0; x < (ssize_t) image->columns; x++)
804 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
805 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
806 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
807 ConvertRGBToLCHuv(red,green,blue,&luma,&chroma,&hue);
808 SetPixelRed(image,ClampToQuantum(QuantumRange*luma),q);
809 SetPixelGreen(image,ClampToQuantum(QuantumRange*chroma),q);
810 SetPixelBlue(image,ClampToQuantum(QuantumRange*hue),q);
811 q+=GetPixelChannels(image);
813 sync=SyncCacheViewAuthenticPixels(image_view,exception);
814 if (sync == MagickFalse)
817 image_view=DestroyCacheView(image_view);
818 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
825 Transform image from sRGB to LMS.
827 if (image->storage_class == PseudoClass)
829 if (SyncImage(image,exception) == MagickFalse)
831 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
834 image_view=AcquireAuthenticCacheView(image,exception);
835 #if defined(MAGICKCORE_OPENMP_SUPPORT)
836 #pragma omp parallel for schedule(static,4) shared(status) \
837 magick_threads(image,image,image->rows,1)
839 for (y=0; y < (ssize_t) image->rows; y++)
850 if (status == MagickFalse)
852 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
854 if (q == (Quantum *) NULL)
859 for (x=0; x < (ssize_t) image->columns; x++)
872 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
873 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
874 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
875 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
876 ConvertXYZToLMS(X,Y,Z,&L,&M,&S);
877 SetPixelRed(image,ClampToQuantum(QuantumRange*L),q);
878 SetPixelGreen(image,ClampToQuantum(QuantumRange*M),q);
879 SetPixelBlue(image,ClampToQuantum(QuantumRange*S),q);
880 q+=GetPixelChannels(image);
882 sync=SyncCacheViewAuthenticPixels(image_view,exception);
883 if (sync == MagickFalse)
886 image_view=DestroyCacheView(image_view);
887 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
893 #define DisplayGamma (1.0/1.7)
894 #define FilmGamma 0.6
895 #define ReferenceBlack 95.0
896 #define ReferenceWhite 685.0
913 Transform RGB to Log colorspace.
915 density=DisplayGamma;
917 value=GetImageProperty(image,"gamma",exception);
918 if (value != (const char *) NULL)
919 gamma=PerceptibleReciprocal(StringToDouble(value,(char **) NULL));
920 film_gamma=FilmGamma;
921 value=GetImageProperty(image,"film-gamma",exception);
922 if (value != (const char *) NULL)
923 film_gamma=StringToDouble(value,(char **) NULL);
924 reference_black=ReferenceBlack;
925 value=GetImageProperty(image,"reference-black",exception);
926 if (value != (const char *) NULL)
927 reference_black=StringToDouble(value,(char **) NULL);
928 reference_white=ReferenceWhite;
929 value=GetImageProperty(image,"reference-white",exception);
930 if (value != (const char *) NULL)
931 reference_white=StringToDouble(value,(char **) NULL);
932 logmap=(Quantum *) AcquireQuantumMemory((size_t) MaxMap+1UL,
934 if (logmap == (Quantum *) NULL)
935 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
937 black=pow(10.0,(reference_black-reference_white)*(gamma/density)*0.002/
939 #if defined(MAGICKCORE_OPENMP_SUPPORT)
940 #pragma omp parallel for schedule(static,4) \
941 magick_threads(image,image,1,1)
943 for (i=0; i <= (ssize_t) MaxMap; i++)
944 logmap[i]=ScaleMapToQuantum((double) (MaxMap*(reference_white+
945 log10(black+(1.0*i/MaxMap)*(1.0-black))/((gamma/density)*0.002/
946 film_gamma))/1024.0));
947 image_view=AcquireAuthenticCacheView(image,exception);
948 #if defined(MAGICKCORE_OPENMP_SUPPORT)
949 #pragma omp parallel for schedule(static,4) shared(status) \
950 magick_threads(image,image,image->rows,1)
952 for (y=0; y < (ssize_t) image->rows; y++)
963 if (status == MagickFalse)
965 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
967 if (q == (Quantum *) NULL)
972 for (x=(ssize_t) image->columns; x != 0; x--)
979 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
980 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
981 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
982 SetPixelRed(image,logmap[ScaleQuantumToMap(
983 ClampToQuantum(red))],q);
984 SetPixelGreen(image,logmap[ScaleQuantumToMap(
985 ClampToQuantum(green))],q);
986 SetPixelBlue(image,logmap[ScaleQuantumToMap(
987 ClampToQuantum(blue))],q);
988 q+=GetPixelChannels(image);
990 sync=SyncCacheViewAuthenticPixels(image_view,exception);
991 if (sync == MagickFalse)
994 image_view=DestroyCacheView(image_view);
995 logmap=(Quantum *) RelinquishMagickMemory(logmap);
996 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1003 Transform image from sRGB to Luv.
1005 if (image->storage_class == PseudoClass)
1007 if (SyncImage(image,exception) == MagickFalse)
1008 return(MagickFalse);
1009 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1010 return(MagickFalse);
1012 image_view=AcquireAuthenticCacheView(image,exception);
1013 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1014 #pragma omp parallel for schedule(static,4) shared(status) \
1015 magick_threads(image,image,image->rows,1)
1017 for (y=0; y < (ssize_t) image->rows; y++)
1028 if (status == MagickFalse)
1030 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1032 if (q == (Quantum *) NULL)
1037 for (x=0; x < (ssize_t) image->columns; x++)
1050 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
1051 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
1052 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
1053 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1054 ConvertXYZToLuv(X,Y,Z,&L,&u,&v);
1055 SetPixelRed(image,ClampToQuantum(QuantumRange*L),q);
1056 SetPixelGreen(image,ClampToQuantum(QuantumRange*u),q);
1057 SetPixelBlue(image,ClampToQuantum(QuantumRange*v),q);
1058 q+=GetPixelChannels(image);
1060 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1061 if (sync == MagickFalse)
1064 image_view=DestroyCacheView(image_view);
1065 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1066 return(MagickFalse);
1070 case scRGBColorspace:
1073 Transform image from sRGB to linear RGB.
1075 if (image->storage_class == PseudoClass)
1077 if (SyncImage(image,exception) == MagickFalse)
1078 return(MagickFalse);
1079 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1080 return(MagickFalse);
1082 image_view=AcquireAuthenticCacheView(image,exception);
1083 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1084 #pragma omp parallel for schedule(static,4) shared(status) \
1085 magick_threads(image,image,image->rows,1)
1087 for (y=0; y < (ssize_t) image->rows; y++)
1098 if (status == MagickFalse)
1100 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1102 if (q == (Quantum *) NULL)
1107 for (x=0; x < (ssize_t) image->columns; x++)
1114 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
1115 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
1116 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
1117 SetPixelRed(image,ClampToQuantum(red),q);
1118 SetPixelGreen(image,ClampToQuantum(green),q);
1119 SetPixelBlue(image,ClampToQuantum(blue),q);
1120 q+=GetPixelChannels(image);
1122 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1123 if (sync == MagickFalse)
1126 image_view=DestroyCacheView(image_view);
1127 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1128 return(MagickFalse);
1134 Transform image from sRGB to XYZ.
1136 if (image->storage_class == PseudoClass)
1138 if (SyncImage(image,exception) == MagickFalse)
1139 return(MagickFalse);
1140 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1141 return(MagickFalse);
1143 image_view=AcquireAuthenticCacheView(image,exception);
1144 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1145 #pragma omp parallel for schedule(static,4) shared(status) \
1146 magick_threads(image,image,image->rows,1)
1148 for (y=0; y < (ssize_t) image->rows; y++)
1159 if (status == MagickFalse)
1161 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1163 if (q == (Quantum *) NULL)
1168 for (x=0; x < (ssize_t) image->columns; x++)
1178 red=DecodePixelGamma((MagickRealType) GetPixelRed(image,q));
1179 green=DecodePixelGamma((MagickRealType) GetPixelGreen(image,q));
1180 blue=DecodePixelGamma((MagickRealType) GetPixelBlue(image,q));
1181 ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1182 SetPixelRed(image,ClampToQuantum(QuantumRange*X),q);
1183 SetPixelGreen(image,ClampToQuantum(QuantumRange*Y),q);
1184 SetPixelBlue(image,ClampToQuantum(QuantumRange*Z),q);
1185 q+=GetPixelChannels(image);
1187 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1188 if (sync == MagickFalse)
1191 image_view=DestroyCacheView(image_view);
1192 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1193 return(MagickFalse);
1200 Allocate the tables.
1202 x_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1204 y_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1206 z_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1208 if ((x_map == (TransformPacket *) NULL) ||
1209 (y_map == (TransformPacket *) NULL) ||
1210 (z_map == (TransformPacket *) NULL))
1211 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1213 (void) ResetMagickMemory(&primary_info,0,sizeof(primary_info));
1216 case OHTAColorspace:
1219 Initialize OHTA tables:
1221 I1 = 0.33333*R+0.33334*G+0.33333*B
1222 I2 = 0.50000*R+0.00000*G-0.50000*B
1223 I3 =-0.25000*R+0.50000*G-0.25000*B
1225 I and Q, normally -0.5 through 0.5, are normalized to the range 0
1226 through QuantumRange.
1228 primary_info.y=(double) (MaxMap+1.0)/2.0;
1229 primary_info.z=(double) (MaxMap+1.0)/2.0;
1230 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1231 #pragma omp parallel for schedule(static,4) \
1232 magick_threads(image,image,1,1)
1234 for (i=0; i <= (ssize_t) MaxMap; i++)
1236 x_map[i].x=(MagickRealType) (0.33333*(double) i);
1237 y_map[i].x=(MagickRealType) (0.33334*(double) i);
1238 z_map[i].x=(MagickRealType) (0.33333*(double) i);
1239 x_map[i].y=(MagickRealType) (0.50000*(double) i);
1240 y_map[i].y=(MagickRealType) (0.00000*(double) i);
1241 z_map[i].y=(MagickRealType) (-0.50000*(double) i);
1242 x_map[i].z=(MagickRealType) (-0.25000*(double) i);
1243 y_map[i].z=(MagickRealType) (0.50000*(double) i);
1244 z_map[i].z=(MagickRealType) (-0.25000*(double) i);
1248 case Rec601YCbCrColorspace:
1249 case YCbCrColorspace:
1252 Initialize YCbCr tables (ITU-R BT.601):
1254 Y = 0.2988390*R+0.5868110*G+0.1143500*B
1255 Cb= -0.1687367*R-0.3312640*G+0.5000000*B
1256 Cr= 0.5000000*R-0.4186880*G-0.0813120*B
1258 Cb and Cr, normally -0.5 through 0.5, are normalized to the range 0
1259 through QuantumRange.
1261 primary_info.y=(double) (MaxMap+1.0)/2.0;
1262 primary_info.z=(double) (MaxMap+1.0)/2.0;
1263 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1264 #pragma omp parallel for schedule(static,4) \
1265 magick_threads(image,image,1,1)
1267 for (i=0; i <= (ssize_t) MaxMap; i++)
1269 x_map[i].x=(MagickRealType) (0.298839*(double) i);
1270 y_map[i].x=(MagickRealType) (0.586811*(double) i);
1271 z_map[i].x=(MagickRealType) (0.114350*(double) i);
1272 x_map[i].y=(MagickRealType) (-0.1687367*(double) i);
1273 y_map[i].y=(MagickRealType) (-0.331264*(double) i);
1274 z_map[i].y=(MagickRealType) (0.500000*(double) i);
1275 x_map[i].z=(MagickRealType) (0.500000*(double) i);
1276 y_map[i].z=(MagickRealType) (-0.418688*(double) i);
1277 z_map[i].z=(MagickRealType) (-0.081312*(double) i);
1281 case Rec709YCbCrColorspace:
1284 Initialize YCbCr tables (ITU-R BT.709):
1286 Y = 0.212600*R+0.715200*G+0.072200*B
1287 Cb= -0.114572*R-0.385428*G+0.500000*B
1288 Cr= 0.500000*R-0.454153*G-0.045847*B
1290 Cb and Cr, normally -0.5 through 0.5, are normalized to the range 0
1291 through QuantumRange.
1293 primary_info.y=(double) (MaxMap+1.0)/2.0;
1294 primary_info.z=(double) (MaxMap+1.0)/2.0;
1295 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1296 #pragma omp parallel for schedule(static,4) \
1297 magick_threads(image,image,1,1)
1299 for (i=0; i <= (ssize_t) MaxMap; i++)
1301 x_map[i].x=(MagickRealType) (0.212600*(double) i);
1302 y_map[i].x=(MagickRealType) (0.715200*(double) i);
1303 z_map[i].x=(MagickRealType) (0.072200*(double) i);
1304 x_map[i].y=(MagickRealType) (-0.114572*(double) i);
1305 y_map[i].y=(MagickRealType) (-0.385428*(double) i);
1306 z_map[i].y=(MagickRealType) (0.500000*(double) i);
1307 x_map[i].z=(MagickRealType) (0.500000*(double) i);
1308 y_map[i].z=(MagickRealType) (-0.454153*(double) i);
1309 z_map[i].z=(MagickRealType) (-0.045847*(double) i);
1316 Initialize YCC tables:
1318 Y = 0.298839*R+0.586811*G+0.114350*B
1319 C1= -0.298839*R-0.586811*G+0.88600*B
1320 C2= 0.70100*R-0.586811*G-0.114350*B
1322 YCC is scaled by 1.3584. C1 zero is 156 and C2 is at 137.
1324 primary_info.y=(double) ScaleQuantumToMap(ScaleCharToQuantum(156));
1325 primary_info.z=(double) ScaleQuantumToMap(ScaleCharToQuantum(137));
1326 for (i=0; i <= (ssize_t) (0.018*MaxMap); i++)
1328 x_map[i].x=0.003962014134275617*i;
1329 y_map[i].x=0.007778268551236748*i;
1330 z_map[i].x=0.001510600706713781*i;
1331 x_map[i].y=(-0.002426619775463276)*i;
1332 y_map[i].y=(-0.004763965913702149)*i;
1333 z_map[i].y=0.007190585689165425*i;
1334 x_map[i].z=0.006927257754597858*i;
1335 y_map[i].z=(-0.005800713697502058)*i;
1336 z_map[i].z=(-0.0011265440570958)*i;
1338 for ( ; i <= (ssize_t) MaxMap; i++)
1340 x_map[i].x=0.2201118963486454*(1.099*i-0.099);
1341 y_map[i].x=0.4321260306242638*(1.099*i-0.099);
1342 z_map[i].x=0.08392226148409894*(1.099*i-0.099);
1343 x_map[i].y=(-0.1348122097479598)*(1.099*i-0.099);
1344 y_map[i].y=(-0.2646647729834528)*(1.099*i-0.099);
1345 z_map[i].y=0.3994769827314126*(1.099*i-0.099);
1346 x_map[i].z=0.3848476530332144*(1.099*i-0.099);
1347 y_map[i].z=(-0.3222618720834477)*(1.099*i-0.099);
1348 z_map[i].z=(-0.06258578094976668)*(1.099*i-0.099);
1355 Initialize YIQ tables:
1357 Y = 0.298839*R+0.586811*G+0.114350*B
1358 I = 0.595716*R-0.274453*G-0.321263*B
1359 Q = 0.211456*R-0.522591*G+0.311135*B
1361 I and Q, normally -0.5 through 0.5, are normalized to the range 0
1362 through QuantumRange.
1364 primary_info.y=(double) (MaxMap+1.0)/2.0;
1365 primary_info.z=(double) (MaxMap+1.0)/2.0;
1366 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1367 #pragma omp parallel for schedule(static,4) \
1368 magick_threads(image,image,1,1)
1370 for (i=0; i <= (ssize_t) MaxMap; i++)
1372 x_map[i].x=(MagickRealType) (0.298839*(double) i);
1373 y_map[i].x=(MagickRealType) (0.586811*(double) i);
1374 z_map[i].x=(MagickRealType) (0.114350*(double) i);
1375 x_map[i].y=(MagickRealType) (0.595716*(double) i);
1376 y_map[i].y=(MagickRealType) (-0.274453*(double) i);
1377 z_map[i].y=(MagickRealType) (-0.321263*(double) i);
1378 x_map[i].z=(MagickRealType) (0.211456*(double) i);
1379 y_map[i].z=(MagickRealType) (-0.522591*(double) i);
1380 z_map[i].z=(MagickRealType) (0.311135*(double) i);
1384 case YPbPrColorspace:
1387 Initialize YPbPr tables (ITU-R BT.601):
1389 Y = 0.2988390*R+0.5868110*G+0.1143500*B
1390 Pb= -0.1687367*R-0.3312640*G+0.5000000*B
1391 Pr= 0.5000000*R-0.4186880*G-0.0813120*B
1393 Pb and Pr, normally -0.5 through 0.5, are normalized to the range 0
1394 through QuantumRange.
1396 primary_info.y=(double) (MaxMap+1.0)/2.0;
1397 primary_info.z=(double) (MaxMap+1.0)/2.0;
1398 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1399 #pragma omp parallel for schedule(static,4) \
1400 magick_threads(image,image,1,1)
1402 for (i=0; i <= (ssize_t) MaxMap; i++)
1404 x_map[i].x=(MagickRealType) (0.298839*(double) i);
1405 y_map[i].x=(MagickRealType) (0.586811*(double) i);
1406 z_map[i].x=(MagickRealType) (0.114350*(double) i);
1407 x_map[i].y=(MagickRealType) (-0.1687367*(double) i);
1408 y_map[i].y=(MagickRealType) (-0.331264*(double) i);
1409 z_map[i].y=(MagickRealType) (0.500000*(double) i);
1410 x_map[i].z=(MagickRealType) (0.500000*(double) i);
1411 y_map[i].z=(MagickRealType) (-0.418688*(double) i);
1412 z_map[i].z=(MagickRealType) (-0.081312*(double) i);
1419 Initialize YUV tables:
1421 Y = 0.298839*R+0.586811*G+0.114350*B
1422 U = -0.147130*R-0.288860*G+0.436000*B
1423 V = 0.615000*R-0.514990*G-0.100010*B
1425 U and V, normally -0.5 through 0.5, are normalized to the range 0
1426 through QuantumRange. Note that U = 0.493*(B-Y), V = 0.877*(R-Y).
1428 primary_info.y=(double) (MaxMap+1.0)/2.0;
1429 primary_info.z=(double) (MaxMap+1.0)/2.0;
1430 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1431 #pragma omp parallel for schedule(static,4) \
1432 magick_threads(image,image,1,1)
1434 for (i=0; i <= (ssize_t) MaxMap; i++)
1436 x_map[i].x=(MagickRealType) (0.298839*(double) i);
1437 y_map[i].x=(MagickRealType) (0.586811*(double) i);
1438 z_map[i].x=(MagickRealType) (0.114350*(double) i);
1439 x_map[i].y=(MagickRealType) (-0.147130*(double) i);
1440 y_map[i].y=(MagickRealType) (-0.288860*(double) i);
1441 z_map[i].y=(MagickRealType) (0.436000*(double) i);
1442 x_map[i].z=(MagickRealType) (0.615000*(double) i);
1443 y_map[i].z=(MagickRealType) (-0.514990*(double) i);
1444 z_map[i].z=(MagickRealType) (-0.100001*(double) i);
1451 Linear conversion tables.
1453 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1454 #pragma omp parallel for schedule(static,4) \
1455 magick_threads(image,image,1,1)
1457 for (i=0; i <= (ssize_t) MaxMap; i++)
1459 x_map[i].x=(MagickRealType) (1.0*(double) i);
1460 y_map[i].x=(MagickRealType) 0.0;
1461 z_map[i].x=(MagickRealType) 0.0;
1462 x_map[i].y=(MagickRealType) 0.0;
1463 y_map[i].y=(MagickRealType) (1.0*(double) i);
1464 z_map[i].y=(MagickRealType) 0.0;
1465 x_map[i].z=(MagickRealType) 0.0;
1466 y_map[i].z=(MagickRealType) 0.0;
1467 z_map[i].z=(MagickRealType) (1.0*(double) i);
1475 switch (image->storage_class)
1481 Convert DirectClass image.
1483 image_view=AcquireAuthenticCacheView(image,exception);
1484 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1485 #pragma omp parallel for schedule(static,4) shared(status) \
1486 magick_threads(image,image,image->rows,1)
1488 for (y=0; y < (ssize_t) image->rows; y++)
1502 register unsigned int
1507 if (status == MagickFalse)
1509 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1511 if (q == (Quantum *) NULL)
1516 for (x=0; x < (ssize_t) image->columns; x++)
1518 red=ScaleQuantumToMap(ClampToQuantum(DecodePixelGamma(
1519 (MagickRealType) GetPixelRed(image,q))));
1520 green=ScaleQuantumToMap(ClampToQuantum(DecodePixelGamma(
1521 (MagickRealType) GetPixelGreen(image,q))));
1522 blue=ScaleQuantumToMap(ClampToQuantum(DecodePixelGamma(
1523 (MagickRealType) GetPixelBlue(image,q))));
1524 pixel.red=(x_map[red].x+y_map[green].x+z_map[blue].x)+
1526 pixel.green=(x_map[red].y+y_map[green].y+z_map[blue].y)+
1528 pixel.blue=(x_map[red].z+y_map[green].z+z_map[blue].z)+
1530 SetPixelRed(image,ScaleMapToQuantum(pixel.red),q);
1531 SetPixelGreen(image,ScaleMapToQuantum(pixel.green),q);
1532 SetPixelBlue(image,ScaleMapToQuantum(pixel.blue),q);
1533 q+=GetPixelChannels(image);
1535 sync=SyncCacheViewAuthenticPixels(image_view,exception);
1536 if (sync == MagickFalse)
1538 if (image->progress_monitor != (MagickProgressMonitor) NULL)
1543 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1544 #pragma omp critical (MagickCore_sRGBTransformImage)
1546 proceed=SetImageProgress(image,sRGBTransformImageTag,progress++,
1548 if (proceed == MagickFalse)
1552 image_view=DestroyCacheView(image_view);
1557 register unsigned int
1563 Convert PseudoClass image.
1565 for (i=0; i < (ssize_t) image->colors; i++)
1570 red=ScaleQuantumToMap(ClampToQuantum(DecodePixelGamma(
1571 image->colormap[i].red)));
1572 green=ScaleQuantumToMap(ClampToQuantum(DecodePixelGamma(
1573 image->colormap[i].green)));
1574 blue=ScaleQuantumToMap(ClampToQuantum(DecodePixelGamma(
1575 image->colormap[i].blue)));
1576 pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x+primary_info.x;
1577 pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y+primary_info.y;
1578 pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z+primary_info.z;
1579 image->colormap[i].red=(double) ScaleMapToQuantum(pixel.red);
1580 image->colormap[i].green=(double) ScaleMapToQuantum(pixel.green);
1581 image->colormap[i].blue=(double) ScaleMapToQuantum(pixel.blue);
1583 (void) SyncImage(image,exception);
1588 Relinquish resources.
1590 z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
1591 y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
1592 x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
1593 if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1594 return(MagickFalse);
1599 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1603 % S e t I m a g e C o l o r s p a c e %
1607 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1609 % SetImageColorspace() sets the colorspace member of the Image structure.
1611 % The format of the SetImageColorspace method is:
1613 % MagickBooleanType SetImageColorspace(Image *image,
1614 % const ColorspaceType colorspace,ExceptiionInfo *exception)
1616 % A description of each parameter follows:
1618 % o image: the image.
1620 % o colorspace: the colorspace.
1622 % o exception: return any errors or warnings in this structure.
1625 MagickExport MagickBooleanType SetImageColorspace(Image *image,
1626 const ColorspaceType colorspace,ExceptionInfo *exception)
1628 if (image->colorspace == colorspace)
1630 image->colorspace=colorspace;
1631 image->rendering_intent=UndefinedIntent;
1633 (void) ResetMagickMemory(&image->chromaticity,0,sizeof(image->chromaticity));
1634 if (IsGrayColorspace(colorspace) != MagickFalse)
1636 if ((image->intensity != Rec601LuminancePixelIntensityMethod) &&
1637 (image->intensity != Rec709LuminancePixelIntensityMethod) &&
1638 (image->intensity != UndefinedPixelIntensityMethod))
1639 image->gamma=1.000/2.200;
1640 image->type=GrayscaleType;
1643 if (IssRGBColorspace(colorspace) != MagickFalse)
1644 image->gamma=1.000/2.200;
1645 if (image->gamma == (1.000/2.200))
1647 image->rendering_intent=PerceptualIntent;
1648 image->gamma=1.000/2.200;
1649 image->chromaticity.red_primary.x=0.6400;
1650 image->chromaticity.red_primary.y=0.3300;
1651 image->chromaticity.red_primary.z=0.0300;
1652 image->chromaticity.green_primary.x=0.3000;
1653 image->chromaticity.green_primary.y=0.6000;
1654 image->chromaticity.green_primary.z=0.1000;
1655 image->chromaticity.blue_primary.x=0.1500;
1656 image->chromaticity.blue_primary.y=0.0600;
1657 image->chromaticity.blue_primary.z=0.7900;
1658 image->chromaticity.white_point.x=0.3127;
1659 image->chromaticity.white_point.y=0.3290;
1660 image->chromaticity.white_point.z=0.3583;
1662 if (IsGrayColorspace(colorspace) != MagickFalse)
1663 image->type=GrayscaleType;
1664 return(SyncImagePixelCache(image,exception));
1668 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1672 % T r a n s f o r m I m a g e C o l o r s p a c e %
1676 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1678 % TransformImageColorspace() transforms an image colorspace, changing the
1679 % image data to reflect the new colorspace.
1681 % The format of the TransformImageColorspace method is:
1683 % MagickBooleanType TransformImageColorspace(Image *image,
1684 % const ColorspaceType colorspace,ExceptionInfo *exception)
1686 % A description of each parameter follows:
1688 % o image: the image.
1690 % o colorspace: the colorspace.
1692 % o exception: return any errors or warnings in this structure.
1695 MagickExport MagickBooleanType TransformImageColorspace(Image *image,
1696 const ColorspaceType colorspace,ExceptionInfo *exception)
1701 assert(image != (Image *) NULL);
1702 assert(image->signature == MagickSignature);
1703 if (image->debug != MagickFalse)
1704 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1705 if (colorspace == UndefinedColorspace)
1706 return(SetImageColorspace(image,colorspace,exception));
1707 if (image->colorspace == colorspace)
1708 return(MagickTrue); /* same colorspace: no op */
1710 Convert the reference image from an alternate colorspace to sRGB.
1712 (void) DeleteImageProfile(image,"icc");
1713 (void) DeleteImageProfile(image,"icm");
1714 if (IssRGBColorspace(colorspace) != MagickFalse)
1715 return(TransformsRGBImage(image,colorspace,exception));
1717 if (IssRGBColorspace(image->colorspace) == MagickFalse)
1718 status=TransformsRGBImage(image,image->colorspace,exception);
1719 if (status == MagickFalse)
1722 Convert the reference image from sRGB to an alternate colorspace.
1724 if (sRGBTransformImage(image,colorspace,exception) == MagickFalse)
1730 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1734 + T r a n s f o r m s R G B I m a g e %
1738 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1740 % TransformsRGBImage() converts the reference image from an alternate
1741 % colorspace to sRGB. The transformation matrices are not the standard ones:
1742 % the weights are rescaled to normalize the range of the transformed values
1743 % to be [0..QuantumRange].
1745 % The format of the TransformsRGBImage method is:
1747 % MagickBooleanType TransformsRGBImage(Image *image,
1748 % const ColorspaceType colorspace,ExceptionInfo *exception)
1750 % A description of each parameter follows:
1752 % o image: the image.
1754 % o colorspace: the colorspace to transform the image to.
1756 % o exception: return any errors or warnings in this structure.
1760 static inline void ConvertLMSToXYZ(const double L,const double M,const double S,
1761 double *X,double *Y,double *Z)
1768 assert(X != (double *) NULL);
1769 assert(Y != (double *) NULL);
1770 assert(Z != (double *) NULL);
1774 *X=1.096123820835514*l-0.278869000218287*m+0.182745179382773*s;
1775 *Y=0.454369041975359*l+0.473533154307412*m+0.072097803717229*s;
1776 *Z=(-0.009627608738429)*l-0.005698031216113*m+1.015325639954543*s;
1779 static inline ssize_t RoundToYCC(const double value)
1783 if (value >= 1388.0)
1785 return((ssize_t) (value+0.5));
1788 static inline void ConvertCMYKToRGB(PixelInfo *pixel)
1790 pixel->red=((QuantumRange-(QuantumScale*pixel->red*
1791 (QuantumRange-pixel->black)+pixel->black)));
1792 pixel->green=((QuantumRange-(QuantumScale*pixel->green*
1793 (QuantumRange-pixel->black)+pixel->black)));
1794 pixel->blue=((QuantumRange-(QuantumScale*pixel->blue*
1795 (QuantumRange-pixel->black)+pixel->black)));
1798 static MagickBooleanType TransformsRGBImage(Image *image,
1799 const ColorspaceType colorspace,ExceptionInfo *exception)
1801 #define TransformsRGBImageTag "Transform/Image"
1806 0.000000f, 0.000720f, 0.001441f, 0.002161f, 0.002882f, 0.003602f,
1807 0.004323f, 0.005043f, 0.005764f, 0.006484f, 0.007205f, 0.007925f,
1808 0.008646f, 0.009366f, 0.010086f, 0.010807f, 0.011527f, 0.012248f,
1809 0.012968f, 0.013689f, 0.014409f, 0.015130f, 0.015850f, 0.016571f,
1810 0.017291f, 0.018012f, 0.018732f, 0.019452f, 0.020173f, 0.020893f,
1811 0.021614f, 0.022334f, 0.023055f, 0.023775f, 0.024496f, 0.025216f,
1812 0.025937f, 0.026657f, 0.027378f, 0.028098f, 0.028818f, 0.029539f,
1813 0.030259f, 0.030980f, 0.031700f, 0.032421f, 0.033141f, 0.033862f,
1814 0.034582f, 0.035303f, 0.036023f, 0.036744f, 0.037464f, 0.038184f,
1815 0.038905f, 0.039625f, 0.040346f, 0.041066f, 0.041787f, 0.042507f,
1816 0.043228f, 0.043948f, 0.044669f, 0.045389f, 0.046110f, 0.046830f,
1817 0.047550f, 0.048271f, 0.048991f, 0.049712f, 0.050432f, 0.051153f,
1818 0.051873f, 0.052594f, 0.053314f, 0.054035f, 0.054755f, 0.055476f,
1819 0.056196f, 0.056916f, 0.057637f, 0.058357f, 0.059078f, 0.059798f,
1820 0.060519f, 0.061239f, 0.061960f, 0.062680f, 0.063401f, 0.064121f,
1821 0.064842f, 0.065562f, 0.066282f, 0.067003f, 0.067723f, 0.068444f,
1822 0.069164f, 0.069885f, 0.070605f, 0.071326f, 0.072046f, 0.072767f,
1823 0.073487f, 0.074207f, 0.074928f, 0.075648f, 0.076369f, 0.077089f,
1824 0.077810f, 0.078530f, 0.079251f, 0.079971f, 0.080692f, 0.081412f,
1825 0.082133f, 0.082853f, 0.083573f, 0.084294f, 0.085014f, 0.085735f,
1826 0.086455f, 0.087176f, 0.087896f, 0.088617f, 0.089337f, 0.090058f,
1827 0.090778f, 0.091499f, 0.092219f, 0.092939f, 0.093660f, 0.094380f,
1828 0.095101f, 0.095821f, 0.096542f, 0.097262f, 0.097983f, 0.098703f,
1829 0.099424f, 0.100144f, 0.100865f, 0.101585f, 0.102305f, 0.103026f,
1830 0.103746f, 0.104467f, 0.105187f, 0.105908f, 0.106628f, 0.107349f,
1831 0.108069f, 0.108790f, 0.109510f, 0.110231f, 0.110951f, 0.111671f,
1832 0.112392f, 0.113112f, 0.113833f, 0.114553f, 0.115274f, 0.115994f,
1833 0.116715f, 0.117435f, 0.118156f, 0.118876f, 0.119597f, 0.120317f,
1834 0.121037f, 0.121758f, 0.122478f, 0.123199f, 0.123919f, 0.124640f,
1835 0.125360f, 0.126081f, 0.126801f, 0.127522f, 0.128242f, 0.128963f,
1836 0.129683f, 0.130403f, 0.131124f, 0.131844f, 0.132565f, 0.133285f,
1837 0.134006f, 0.134726f, 0.135447f, 0.136167f, 0.136888f, 0.137608f,
1838 0.138329f, 0.139049f, 0.139769f, 0.140490f, 0.141210f, 0.141931f,
1839 0.142651f, 0.143372f, 0.144092f, 0.144813f, 0.145533f, 0.146254f,
1840 0.146974f, 0.147695f, 0.148415f, 0.149135f, 0.149856f, 0.150576f,
1841 0.151297f, 0.152017f, 0.152738f, 0.153458f, 0.154179f, 0.154899f,
1842 0.155620f, 0.156340f, 0.157061f, 0.157781f, 0.158501f, 0.159222f,
1843 0.159942f, 0.160663f, 0.161383f, 0.162104f, 0.162824f, 0.163545f,
1844 0.164265f, 0.164986f, 0.165706f, 0.166427f, 0.167147f, 0.167867f,
1845 0.168588f, 0.169308f, 0.170029f, 0.170749f, 0.171470f, 0.172190f,
1846 0.172911f, 0.173631f, 0.174352f, 0.175072f, 0.175793f, 0.176513f,
1847 0.177233f, 0.177954f, 0.178674f, 0.179395f, 0.180115f, 0.180836f,
1848 0.181556f, 0.182277f, 0.182997f, 0.183718f, 0.184438f, 0.185159f,
1849 0.185879f, 0.186599f, 0.187320f, 0.188040f, 0.188761f, 0.189481f,
1850 0.190202f, 0.190922f, 0.191643f, 0.192363f, 0.193084f, 0.193804f,
1851 0.194524f, 0.195245f, 0.195965f, 0.196686f, 0.197406f, 0.198127f,
1852 0.198847f, 0.199568f, 0.200288f, 0.201009f, 0.201729f, 0.202450f,
1853 0.203170f, 0.203890f, 0.204611f, 0.205331f, 0.206052f, 0.206772f,
1854 0.207493f, 0.208213f, 0.208934f, 0.209654f, 0.210375f, 0.211095f,
1855 0.211816f, 0.212536f, 0.213256f, 0.213977f, 0.214697f, 0.215418f,
1856 0.216138f, 0.216859f, 0.217579f, 0.218300f, 0.219020f, 0.219741f,
1857 0.220461f, 0.221182f, 0.221902f, 0.222622f, 0.223343f, 0.224063f,
1858 0.224784f, 0.225504f, 0.226225f, 0.226945f, 0.227666f, 0.228386f,
1859 0.229107f, 0.229827f, 0.230548f, 0.231268f, 0.231988f, 0.232709f,
1860 0.233429f, 0.234150f, 0.234870f, 0.235591f, 0.236311f, 0.237032f,
1861 0.237752f, 0.238473f, 0.239193f, 0.239914f, 0.240634f, 0.241354f,
1862 0.242075f, 0.242795f, 0.243516f, 0.244236f, 0.244957f, 0.245677f,
1863 0.246398f, 0.247118f, 0.247839f, 0.248559f, 0.249280f, 0.250000f,
1864 0.250720f, 0.251441f, 0.252161f, 0.252882f, 0.253602f, 0.254323f,
1865 0.255043f, 0.255764f, 0.256484f, 0.257205f, 0.257925f, 0.258646f,
1866 0.259366f, 0.260086f, 0.260807f, 0.261527f, 0.262248f, 0.262968f,
1867 0.263689f, 0.264409f, 0.265130f, 0.265850f, 0.266571f, 0.267291f,
1868 0.268012f, 0.268732f, 0.269452f, 0.270173f, 0.270893f, 0.271614f,
1869 0.272334f, 0.273055f, 0.273775f, 0.274496f, 0.275216f, 0.275937f,
1870 0.276657f, 0.277378f, 0.278098f, 0.278818f, 0.279539f, 0.280259f,
1871 0.280980f, 0.281700f, 0.282421f, 0.283141f, 0.283862f, 0.284582f,
1872 0.285303f, 0.286023f, 0.286744f, 0.287464f, 0.288184f, 0.288905f,
1873 0.289625f, 0.290346f, 0.291066f, 0.291787f, 0.292507f, 0.293228f,
1874 0.293948f, 0.294669f, 0.295389f, 0.296109f, 0.296830f, 0.297550f,
1875 0.298271f, 0.298991f, 0.299712f, 0.300432f, 0.301153f, 0.301873f,
1876 0.302594f, 0.303314f, 0.304035f, 0.304755f, 0.305476f, 0.306196f,
1877 0.306916f, 0.307637f, 0.308357f, 0.309078f, 0.309798f, 0.310519f,
1878 0.311239f, 0.311960f, 0.312680f, 0.313401f, 0.314121f, 0.314842f,
1879 0.315562f, 0.316282f, 0.317003f, 0.317723f, 0.318444f, 0.319164f,
1880 0.319885f, 0.320605f, 0.321326f, 0.322046f, 0.322767f, 0.323487f,
1881 0.324207f, 0.324928f, 0.325648f, 0.326369f, 0.327089f, 0.327810f,
1882 0.328530f, 0.329251f, 0.329971f, 0.330692f, 0.331412f, 0.332133f,
1883 0.332853f, 0.333573f, 0.334294f, 0.335014f, 0.335735f, 0.336455f,
1884 0.337176f, 0.337896f, 0.338617f, 0.339337f, 0.340058f, 0.340778f,
1885 0.341499f, 0.342219f, 0.342939f, 0.343660f, 0.344380f, 0.345101f,
1886 0.345821f, 0.346542f, 0.347262f, 0.347983f, 0.348703f, 0.349424f,
1887 0.350144f, 0.350865f, 0.351585f, 0.352305f, 0.353026f, 0.353746f,
1888 0.354467f, 0.355187f, 0.355908f, 0.356628f, 0.357349f, 0.358069f,
1889 0.358790f, 0.359510f, 0.360231f, 0.360951f, 0.361671f, 0.362392f,
1890 0.363112f, 0.363833f, 0.364553f, 0.365274f, 0.365994f, 0.366715f,
1891 0.367435f, 0.368156f, 0.368876f, 0.369597f, 0.370317f, 0.371037f,
1892 0.371758f, 0.372478f, 0.373199f, 0.373919f, 0.374640f, 0.375360f,
1893 0.376081f, 0.376801f, 0.377522f, 0.378242f, 0.378963f, 0.379683f,
1894 0.380403f, 0.381124f, 0.381844f, 0.382565f, 0.383285f, 0.384006f,
1895 0.384726f, 0.385447f, 0.386167f, 0.386888f, 0.387608f, 0.388329f,
1896 0.389049f, 0.389769f, 0.390490f, 0.391210f, 0.391931f, 0.392651f,
1897 0.393372f, 0.394092f, 0.394813f, 0.395533f, 0.396254f, 0.396974f,
1898 0.397695f, 0.398415f, 0.399135f, 0.399856f, 0.400576f, 0.401297f,
1899 0.402017f, 0.402738f, 0.403458f, 0.404179f, 0.404899f, 0.405620f,
1900 0.406340f, 0.407061f, 0.407781f, 0.408501f, 0.409222f, 0.409942f,
1901 0.410663f, 0.411383f, 0.412104f, 0.412824f, 0.413545f, 0.414265f,
1902 0.414986f, 0.415706f, 0.416427f, 0.417147f, 0.417867f, 0.418588f,
1903 0.419308f, 0.420029f, 0.420749f, 0.421470f, 0.422190f, 0.422911f,
1904 0.423631f, 0.424352f, 0.425072f, 0.425793f, 0.426513f, 0.427233f,
1905 0.427954f, 0.428674f, 0.429395f, 0.430115f, 0.430836f, 0.431556f,
1906 0.432277f, 0.432997f, 0.433718f, 0.434438f, 0.435158f, 0.435879f,
1907 0.436599f, 0.437320f, 0.438040f, 0.438761f, 0.439481f, 0.440202f,
1908 0.440922f, 0.441643f, 0.442363f, 0.443084f, 0.443804f, 0.444524f,
1909 0.445245f, 0.445965f, 0.446686f, 0.447406f, 0.448127f, 0.448847f,
1910 0.449568f, 0.450288f, 0.451009f, 0.451729f, 0.452450f, 0.453170f,
1911 0.453891f, 0.454611f, 0.455331f, 0.456052f, 0.456772f, 0.457493f,
1912 0.458213f, 0.458934f, 0.459654f, 0.460375f, 0.461095f, 0.461816f,
1913 0.462536f, 0.463256f, 0.463977f, 0.464697f, 0.465418f, 0.466138f,
1914 0.466859f, 0.467579f, 0.468300f, 0.469020f, 0.469741f, 0.470461f,
1915 0.471182f, 0.471902f, 0.472622f, 0.473343f, 0.474063f, 0.474784f,
1916 0.475504f, 0.476225f, 0.476945f, 0.477666f, 0.478386f, 0.479107f,
1917 0.479827f, 0.480548f, 0.481268f, 0.481988f, 0.482709f, 0.483429f,
1918 0.484150f, 0.484870f, 0.485591f, 0.486311f, 0.487032f, 0.487752f,
1919 0.488473f, 0.489193f, 0.489914f, 0.490634f, 0.491354f, 0.492075f,
1920 0.492795f, 0.493516f, 0.494236f, 0.494957f, 0.495677f, 0.496398f,
1921 0.497118f, 0.497839f, 0.498559f, 0.499280f, 0.500000f, 0.500720f,
1922 0.501441f, 0.502161f, 0.502882f, 0.503602f, 0.504323f, 0.505043f,
1923 0.505764f, 0.506484f, 0.507205f, 0.507925f, 0.508646f, 0.509366f,
1924 0.510086f, 0.510807f, 0.511527f, 0.512248f, 0.512968f, 0.513689f,
1925 0.514409f, 0.515130f, 0.515850f, 0.516571f, 0.517291f, 0.518012f,
1926 0.518732f, 0.519452f, 0.520173f, 0.520893f, 0.521614f, 0.522334f,
1927 0.523055f, 0.523775f, 0.524496f, 0.525216f, 0.525937f, 0.526657f,
1928 0.527378f, 0.528098f, 0.528818f, 0.529539f, 0.530259f, 0.530980f,
1929 0.531700f, 0.532421f, 0.533141f, 0.533862f, 0.534582f, 0.535303f,
1930 0.536023f, 0.536744f, 0.537464f, 0.538184f, 0.538905f, 0.539625f,
1931 0.540346f, 0.541066f, 0.541787f, 0.542507f, 0.543228f, 0.543948f,
1932 0.544669f, 0.545389f, 0.546109f, 0.546830f, 0.547550f, 0.548271f,
1933 0.548991f, 0.549712f, 0.550432f, 0.551153f, 0.551873f, 0.552594f,
1934 0.553314f, 0.554035f, 0.554755f, 0.555476f, 0.556196f, 0.556916f,
1935 0.557637f, 0.558357f, 0.559078f, 0.559798f, 0.560519f, 0.561239f,
1936 0.561960f, 0.562680f, 0.563401f, 0.564121f, 0.564842f, 0.565562f,
1937 0.566282f, 0.567003f, 0.567723f, 0.568444f, 0.569164f, 0.569885f,
1938 0.570605f, 0.571326f, 0.572046f, 0.572767f, 0.573487f, 0.574207f,
1939 0.574928f, 0.575648f, 0.576369f, 0.577089f, 0.577810f, 0.578530f,
1940 0.579251f, 0.579971f, 0.580692f, 0.581412f, 0.582133f, 0.582853f,
1941 0.583573f, 0.584294f, 0.585014f, 0.585735f, 0.586455f, 0.587176f,
1942 0.587896f, 0.588617f, 0.589337f, 0.590058f, 0.590778f, 0.591499f,
1943 0.592219f, 0.592939f, 0.593660f, 0.594380f, 0.595101f, 0.595821f,
1944 0.596542f, 0.597262f, 0.597983f, 0.598703f, 0.599424f, 0.600144f,
1945 0.600865f, 0.601585f, 0.602305f, 0.603026f, 0.603746f, 0.604467f,
1946 0.605187f, 0.605908f, 0.606628f, 0.607349f, 0.608069f, 0.608790f,
1947 0.609510f, 0.610231f, 0.610951f, 0.611671f, 0.612392f, 0.613112f,
1948 0.613833f, 0.614553f, 0.615274f, 0.615994f, 0.616715f, 0.617435f,
1949 0.618156f, 0.618876f, 0.619597f, 0.620317f, 0.621037f, 0.621758f,
1950 0.622478f, 0.623199f, 0.623919f, 0.624640f, 0.625360f, 0.626081f,
1951 0.626801f, 0.627522f, 0.628242f, 0.628963f, 0.629683f, 0.630403f,
1952 0.631124f, 0.631844f, 0.632565f, 0.633285f, 0.634006f, 0.634726f,
1953 0.635447f, 0.636167f, 0.636888f, 0.637608f, 0.638329f, 0.639049f,
1954 0.639769f, 0.640490f, 0.641210f, 0.641931f, 0.642651f, 0.643372f,
1955 0.644092f, 0.644813f, 0.645533f, 0.646254f, 0.646974f, 0.647695f,
1956 0.648415f, 0.649135f, 0.649856f, 0.650576f, 0.651297f, 0.652017f,
1957 0.652738f, 0.653458f, 0.654179f, 0.654899f, 0.655620f, 0.656340f,
1958 0.657061f, 0.657781f, 0.658501f, 0.659222f, 0.659942f, 0.660663f,
1959 0.661383f, 0.662104f, 0.662824f, 0.663545f, 0.664265f, 0.664986f,
1960 0.665706f, 0.666427f, 0.667147f, 0.667867f, 0.668588f, 0.669308f,
1961 0.670029f, 0.670749f, 0.671470f, 0.672190f, 0.672911f, 0.673631f,
1962 0.674352f, 0.675072f, 0.675793f, 0.676513f, 0.677233f, 0.677954f,
1963 0.678674f, 0.679395f, 0.680115f, 0.680836f, 0.681556f, 0.682277f,
1964 0.682997f, 0.683718f, 0.684438f, 0.685158f, 0.685879f, 0.686599f,
1965 0.687320f, 0.688040f, 0.688761f, 0.689481f, 0.690202f, 0.690922f,
1966 0.691643f, 0.692363f, 0.693084f, 0.693804f, 0.694524f, 0.695245f,
1967 0.695965f, 0.696686f, 0.697406f, 0.698127f, 0.698847f, 0.699568f,
1968 0.700288f, 0.701009f, 0.701729f, 0.702450f, 0.703170f, 0.703891f,
1969 0.704611f, 0.705331f, 0.706052f, 0.706772f, 0.707493f, 0.708213f,
1970 0.708934f, 0.709654f, 0.710375f, 0.711095f, 0.711816f, 0.712536f,
1971 0.713256f, 0.713977f, 0.714697f, 0.715418f, 0.716138f, 0.716859f,
1972 0.717579f, 0.718300f, 0.719020f, 0.719741f, 0.720461f, 0.721182f,
1973 0.721902f, 0.722622f, 0.723343f, 0.724063f, 0.724784f, 0.725504f,
1974 0.726225f, 0.726945f, 0.727666f, 0.728386f, 0.729107f, 0.729827f,
1975 0.730548f, 0.731268f, 0.731988f, 0.732709f, 0.733429f, 0.734150f,
1976 0.734870f, 0.735591f, 0.736311f, 0.737032f, 0.737752f, 0.738473f,
1977 0.739193f, 0.739914f, 0.740634f, 0.741354f, 0.742075f, 0.742795f,
1978 0.743516f, 0.744236f, 0.744957f, 0.745677f, 0.746398f, 0.747118f,
1979 0.747839f, 0.748559f, 0.749280f, 0.750000f, 0.750720f, 0.751441f,
1980 0.752161f, 0.752882f, 0.753602f, 0.754323f, 0.755043f, 0.755764f,
1981 0.756484f, 0.757205f, 0.757925f, 0.758646f, 0.759366f, 0.760086f,
1982 0.760807f, 0.761527f, 0.762248f, 0.762968f, 0.763689f, 0.764409f,
1983 0.765130f, 0.765850f, 0.766571f, 0.767291f, 0.768012f, 0.768732f,
1984 0.769452f, 0.770173f, 0.770893f, 0.771614f, 0.772334f, 0.773055f,
1985 0.773775f, 0.774496f, 0.775216f, 0.775937f, 0.776657f, 0.777378f,
1986 0.778098f, 0.778818f, 0.779539f, 0.780259f, 0.780980f, 0.781700f,
1987 0.782421f, 0.783141f, 0.783862f, 0.784582f, 0.785303f, 0.786023f,
1988 0.786744f, 0.787464f, 0.788184f, 0.788905f, 0.789625f, 0.790346f,
1989 0.791066f, 0.791787f, 0.792507f, 0.793228f, 0.793948f, 0.794669f,
1990 0.795389f, 0.796109f, 0.796830f, 0.797550f, 0.798271f, 0.798991f,
1991 0.799712f, 0.800432f, 0.801153f, 0.801873f, 0.802594f, 0.803314f,
1992 0.804035f, 0.804755f, 0.805476f, 0.806196f, 0.806916f, 0.807637f,
1993 0.808357f, 0.809078f, 0.809798f, 0.810519f, 0.811239f, 0.811960f,
1994 0.812680f, 0.813401f, 0.814121f, 0.814842f, 0.815562f, 0.816282f,
1995 0.817003f, 0.817723f, 0.818444f, 0.819164f, 0.819885f, 0.820605f,
1996 0.821326f, 0.822046f, 0.822767f, 0.823487f, 0.824207f, 0.824928f,
1997 0.825648f, 0.826369f, 0.827089f, 0.827810f, 0.828530f, 0.829251f,
1998 0.829971f, 0.830692f, 0.831412f, 0.832133f, 0.832853f, 0.833573f,
1999 0.834294f, 0.835014f, 0.835735f, 0.836455f, 0.837176f, 0.837896f,
2000 0.838617f, 0.839337f, 0.840058f, 0.840778f, 0.841499f, 0.842219f,
2001 0.842939f, 0.843660f, 0.844380f, 0.845101f, 0.845821f, 0.846542f,
2002 0.847262f, 0.847983f, 0.848703f, 0.849424f, 0.850144f, 0.850865f,
2003 0.851585f, 0.852305f, 0.853026f, 0.853746f, 0.854467f, 0.855187f,
2004 0.855908f, 0.856628f, 0.857349f, 0.858069f, 0.858790f, 0.859510f,
2005 0.860231f, 0.860951f, 0.861671f, 0.862392f, 0.863112f, 0.863833f,
2006 0.864553f, 0.865274f, 0.865994f, 0.866715f, 0.867435f, 0.868156f,
2007 0.868876f, 0.869597f, 0.870317f, 0.871037f, 0.871758f, 0.872478f,
2008 0.873199f, 0.873919f, 0.874640f, 0.875360f, 0.876081f, 0.876801f,
2009 0.877522f, 0.878242f, 0.878963f, 0.879683f, 0.880403f, 0.881124f,
2010 0.881844f, 0.882565f, 0.883285f, 0.884006f, 0.884726f, 0.885447f,
2011 0.886167f, 0.886888f, 0.887608f, 0.888329f, 0.889049f, 0.889769f,
2012 0.890490f, 0.891210f, 0.891931f, 0.892651f, 0.893372f, 0.894092f,
2013 0.894813f, 0.895533f, 0.896254f, 0.896974f, 0.897695f, 0.898415f,
2014 0.899135f, 0.899856f, 0.900576f, 0.901297f, 0.902017f, 0.902738f,
2015 0.903458f, 0.904179f, 0.904899f, 0.905620f, 0.906340f, 0.907061f,
2016 0.907781f, 0.908501f, 0.909222f, 0.909942f, 0.910663f, 0.911383f,
2017 0.912104f, 0.912824f, 0.913545f, 0.914265f, 0.914986f, 0.915706f,
2018 0.916427f, 0.917147f, 0.917867f, 0.918588f, 0.919308f, 0.920029f,
2019 0.920749f, 0.921470f, 0.922190f, 0.922911f, 0.923631f, 0.924352f,
2020 0.925072f, 0.925793f, 0.926513f, 0.927233f, 0.927954f, 0.928674f,
2021 0.929395f, 0.930115f, 0.930836f, 0.931556f, 0.932277f, 0.932997f,
2022 0.933718f, 0.934438f, 0.935158f, 0.935879f, 0.936599f, 0.937320f,
2023 0.938040f, 0.938761f, 0.939481f, 0.940202f, 0.940922f, 0.941643f,
2024 0.942363f, 0.943084f, 0.943804f, 0.944524f, 0.945245f, 0.945965f,
2025 0.946686f, 0.947406f, 0.948127f, 0.948847f, 0.949568f, 0.950288f,
2026 0.951009f, 0.951729f, 0.952450f, 0.953170f, 0.953891f, 0.954611f,
2027 0.955331f, 0.956052f, 0.956772f, 0.957493f, 0.958213f, 0.958934f,
2028 0.959654f, 0.960375f, 0.961095f, 0.961816f, 0.962536f, 0.963256f,
2029 0.963977f, 0.964697f, 0.965418f, 0.966138f, 0.966859f, 0.967579f,
2030 0.968300f, 0.969020f, 0.969741f, 0.970461f, 0.971182f, 0.971902f,
2031 0.972622f, 0.973343f, 0.974063f, 0.974784f, 0.975504f, 0.976225f,
2032 0.976945f, 0.977666f, 0.978386f, 0.979107f, 0.979827f, 0.980548f,
2033 0.981268f, 0.981988f, 0.982709f, 0.983429f, 0.984150f, 0.984870f,
2034 0.985591f, 0.986311f, 0.987032f, 0.987752f, 0.988473f, 0.989193f,
2035 0.989914f, 0.990634f, 0.991354f, 0.992075f, 0.992795f, 0.993516f,
2036 0.994236f, 0.994957f, 0.995677f, 0.996398f, 0.997118f, 0.997839f,
2037 0.998559f, 0.999280f, 1.000000f
2060 assert(image != (Image *) NULL);
2061 assert(image->signature == MagickSignature);
2062 if (image->debug != MagickFalse)
2063 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2066 switch (image->colorspace)
2071 Transform image from CMY to sRGB.
2073 if (image->storage_class == PseudoClass)
2075 if (SyncImage(image,exception) == MagickFalse)
2076 return(MagickFalse);
2077 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2078 return(MagickFalse);
2080 image_view=AcquireAuthenticCacheView(image,exception);
2081 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2082 #pragma omp parallel for schedule(static,4) shared(status) \
2083 magick_threads(image,image,image->rows,1)
2085 for (y=0; y < (ssize_t) image->rows; y++)
2096 if (status == MagickFalse)
2098 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2100 if (q == (Quantum *) NULL)
2105 for (x=0; x < (ssize_t) image->columns; x++)
2112 cyan=EncodePixelGamma((MagickRealType) (QuantumRange-
2113 GetPixelCyan(image,q)));
2114 magenta=EncodePixelGamma((MagickRealType) (QuantumRange-
2115 GetPixelMagenta(image,q)));
2116 yellow=EncodePixelGamma((MagickRealType) (QuantumRange-
2117 GetPixelYellow(image,q)));
2118 SetPixelCyan(image,ClampToQuantum(cyan),q);
2119 SetPixelMagenta(image,ClampToQuantum(magenta),q);
2120 SetPixelYellow(image,ClampToQuantum(yellow),q);
2121 q+=GetPixelChannels(image);
2123 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2124 if (sync == MagickFalse)
2127 image_view=DestroyCacheView(image_view);
2128 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2129 return(MagickFalse);
2132 case CMYKColorspace:
2138 Transform image from CMYK to sRGB.
2140 if (image->storage_class == PseudoClass)
2142 if (SyncImage(image,exception) == MagickFalse)
2143 return(MagickFalse);
2144 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2145 return(MagickFalse);
2147 GetPixelInfo(image,&zero);
2148 image_view=AcquireAuthenticCacheView(image,exception);
2149 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2150 #pragma omp parallel for schedule(static,4) shared(status) \
2151 magick_threads(image,image,image->rows,1)
2153 for (y=0; y < (ssize_t) image->rows; y++)
2167 if (status == MagickFalse)
2169 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2171 if (q == (Quantum *) NULL)
2177 for (x=0; x < (ssize_t) image->columns; x++)
2179 GetPixelInfoPixel(image,q,&pixel);
2180 ConvertCMYKToRGB(&pixel);
2181 pixel.red=EncodePixelGamma(pixel.red);
2182 pixel.green=EncodePixelGamma(pixel.green);
2183 pixel.blue=EncodePixelGamma(pixel.blue);
2184 SetPixelInfoPixel(image,&pixel,q);
2185 q+=GetPixelChannels(image);
2187 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2188 if (sync == MagickFalse)
2191 image_view=DestroyCacheView(image_view);
2192 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2193 return(MagickFalse);
2196 case GRAYColorspace:
2199 Transform linear GRAY to sRGB colorspace.
2201 if (image->storage_class == PseudoClass)
2203 if (SyncImage(image,exception) == MagickFalse)
2204 return(MagickFalse);
2205 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2206 return(MagickFalse);
2208 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2209 return(MagickFalse);
2210 image_view=AcquireAuthenticCacheView(image,exception);
2211 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2212 #pragma omp parallel for schedule(static,4) shared(status) \
2213 magick_threads(image,image,image->rows,1)
2215 for (y=0; y < (ssize_t) image->rows; y++)
2226 if (status == MagickFalse)
2228 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2230 if (q == (Quantum *) NULL)
2235 for (x=(ssize_t) image->columns; x != 0; x--)
2240 gray=EncodePixelGamma((MagickRealType) GetPixelGray(image,q));
2241 SetPixelRed(image,ClampToQuantum(gray),q);
2242 SetPixelGreen(image,ClampToQuantum(gray),q);
2243 SetPixelBlue(image,ClampToQuantum(gray),q);
2244 q+=GetPixelChannels(image);
2246 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2247 if (sync == MagickFalse)
2250 image_view=DestroyCacheView(image_view);
2251 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2252 return(MagickFalse);
2258 Transform image from HCL to sRGB.
2260 if (image->storage_class == PseudoClass)
2262 if (SyncImage(image,exception) == MagickFalse)
2263 return(MagickFalse);
2264 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2265 return(MagickFalse);
2267 image_view=AcquireAuthenticCacheView(image,exception);
2268 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2269 #pragma omp parallel for schedule(static,4) shared(status) \
2270 magick_threads(image,image,image->rows,1)
2272 for (y=0; y < (ssize_t) image->rows; y++)
2283 if (status == MagickFalse)
2285 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2287 if (q == (Quantum *) NULL)
2292 for (x=0; x < (ssize_t) image->columns; x++)
2302 hue=(double) (QuantumScale*GetPixelRed(image,q));
2303 chroma=(double) (QuantumScale*GetPixelGreen(image,q));
2304 luma=(double) (QuantumScale*GetPixelBlue(image,q));
2305 ConvertHCLToRGB(hue,chroma,luma,&red,&green,&blue);
2306 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2307 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2308 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2309 q+=GetPixelChannels(image);
2311 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2312 if (sync == MagickFalse)
2315 image_view=DestroyCacheView(image_view);
2316 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2317 return(MagickFalse);
2323 Transform image from HSB to sRGB.
2325 if (image->storage_class == PseudoClass)
2327 if (SyncImage(image,exception) == MagickFalse)
2328 return(MagickFalse);
2329 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2330 return(MagickFalse);
2332 image_view=AcquireAuthenticCacheView(image,exception);
2333 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2334 #pragma omp parallel for schedule(static,4) shared(status) \
2335 magick_threads(image,image,image->rows,1)
2337 for (y=0; y < (ssize_t) image->rows; y++)
2348 if (status == MagickFalse)
2350 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2352 if (q == (Quantum *) NULL)
2357 for (x=0; x < (ssize_t) image->columns; x++)
2367 hue=(double) (QuantumScale*GetPixelRed(image,q));
2368 saturation=(double) (QuantumScale*GetPixelGreen(image,q));
2369 brightness=(double) (QuantumScale*GetPixelBlue(image,q));
2370 ConvertHSBToRGB(hue,saturation,brightness,&red,&green,&blue);
2371 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2372 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2373 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2374 q+=GetPixelChannels(image);
2376 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2377 if (sync == MagickFalse)
2380 image_view=DestroyCacheView(image_view);
2381 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2382 return(MagickFalse);
2388 Transform image from HSL to sRGB.
2390 if (image->storage_class == PseudoClass)
2392 if (SyncImage(image,exception) == MagickFalse)
2393 return(MagickFalse);
2394 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2395 return(MagickFalse);
2397 image_view=AcquireAuthenticCacheView(image,exception);
2398 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2399 #pragma omp parallel for schedule(static,4) shared(status) \
2400 magick_threads(image,image,image->rows,1)
2402 for (y=0; y < (ssize_t) image->rows; y++)
2413 if (status == MagickFalse)
2415 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2417 if (q == (Quantum *) NULL)
2422 for (x=0; x < (ssize_t) image->columns; x++)
2432 hue=(double) (QuantumScale*GetPixelRed(image,q));
2433 saturation=(double) (QuantumScale*GetPixelGreen(image,q));
2434 lightness=(double) (QuantumScale*GetPixelBlue(image,q));
2435 ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
2436 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2437 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2438 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2439 q+=GetPixelChannels(image);
2441 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2442 if (sync == MagickFalse)
2445 image_view=DestroyCacheView(image_view);
2446 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2447 return(MagickFalse);
2453 Transform image from HWB to sRGB.
2455 if (image->storage_class == PseudoClass)
2457 if (SyncImage(image,exception) == MagickFalse)
2458 return(MagickFalse);
2459 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2460 return(MagickFalse);
2462 image_view=AcquireAuthenticCacheView(image,exception);
2463 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2464 #pragma omp parallel for schedule(static,4) shared(status) \
2465 magick_threads(image,image,image->rows,1)
2467 for (y=0; y < (ssize_t) image->rows; y++)
2478 if (status == MagickFalse)
2480 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2482 if (q == (Quantum *) NULL)
2487 for (x=0; x < (ssize_t) image->columns; x++)
2497 hue=(double) (QuantumScale*GetPixelRed(image,q));
2498 whiteness=(double) (QuantumScale*GetPixelGreen(image,q));
2499 blackness=(double) (QuantumScale*GetPixelBlue(image,q));
2500 ConvertHWBToRGB(hue,whiteness,blackness,&red,&green,&blue);
2501 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2502 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2503 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2504 q+=GetPixelChannels(image);
2506 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2507 if (sync == MagickFalse)
2510 image_view=DestroyCacheView(image_view);
2511 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2512 return(MagickFalse);
2518 Transform image from Lab to sRGB.
2520 if (image->storage_class == PseudoClass)
2522 if (SyncImage(image,exception) == MagickFalse)
2523 return(MagickFalse);
2524 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2525 return(MagickFalse);
2527 image_view=AcquireAuthenticCacheView(image,exception);
2528 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2529 #pragma omp parallel for schedule(static,4) shared(status) \
2530 magick_threads(image,image,image->rows,1)
2532 for (y=0; y < (ssize_t) image->rows; y++)
2543 if (status == MagickFalse)
2545 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2547 if (q == (Quantum *) NULL)
2552 for (x=0; x < (ssize_t) image->columns; x++)
2565 L=QuantumScale*GetPixelRed(image,q);
2566 a=QuantumScale*GetPixelGreen(image,q);
2567 b=QuantumScale*GetPixelBlue(image,q);
2568 ConvertLabToXYZ(L,a,b,&X,&Y,&Z);
2569 ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
2570 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2571 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2572 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2573 q+=GetPixelChannels(image);
2575 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2576 if (sync == MagickFalse)
2579 image_view=DestroyCacheView(image_view);
2580 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2581 return(MagickFalse);
2584 case LCHabColorspace:
2587 Transform image from LCHab to sRGB.
2589 if (image->storage_class == PseudoClass)
2591 if (SyncImage(image,exception) == MagickFalse)
2592 return(MagickFalse);
2593 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2594 return(MagickFalse);
2596 image_view=AcquireAuthenticCacheView(image,exception);
2597 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2598 #pragma omp parallel for schedule(static,4) shared(status) \
2599 magick_threads(image,image,image->rows,1)
2601 for (y=0; y < (ssize_t) image->rows; y++)
2612 if (status == MagickFalse)
2614 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2616 if (q == (Quantum *) NULL)
2621 for (x=0; x < (ssize_t) image->columns; x++)
2631 luma=(double) (QuantumScale*GetPixelRed(image,q));
2632 chroma=(double) (QuantumScale*GetPixelGreen(image,q));
2633 hue=(double) (QuantumScale*GetPixelBlue(image,q));
2634 ConvertLCHabToRGB(luma,chroma,hue,&red,&green,&blue);
2635 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2636 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2637 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2638 q+=GetPixelChannels(image);
2640 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2641 if (sync == MagickFalse)
2644 image_view=DestroyCacheView(image_view);
2645 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2646 return(MagickFalse);
2650 case LCHuvColorspace:
2653 Transform image from LCHuv to sRGB.
2655 if (image->storage_class == PseudoClass)
2657 if (SyncImage(image,exception) == MagickFalse)
2658 return(MagickFalse);
2659 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2660 return(MagickFalse);
2662 image_view=AcquireAuthenticCacheView(image,exception);
2663 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2664 #pragma omp parallel for schedule(static,4) shared(status) \
2665 magick_threads(image,image,image->rows,1)
2667 for (y=0; y < (ssize_t) image->rows; y++)
2678 if (status == MagickFalse)
2680 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2682 if (q == (Quantum *) NULL)
2687 for (x=0; x < (ssize_t) image->columns; x++)
2697 luma=(double) (QuantumScale*GetPixelRed(image,q));
2698 chroma=(double) (QuantumScale*GetPixelGreen(image,q));
2699 hue=(double) (QuantumScale*GetPixelBlue(image,q));
2700 ConvertLCHuvToRGB(luma,chroma,hue,&red,&green,&blue);
2701 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2702 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2703 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2704 q+=GetPixelChannels(image);
2706 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2707 if (sync == MagickFalse)
2710 image_view=DestroyCacheView(image_view);
2711 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2712 return(MagickFalse);
2718 Transform image from LMS to sRGB.
2720 if (image->storage_class == PseudoClass)
2722 if (SyncImage(image,exception) == MagickFalse)
2723 return(MagickFalse);
2724 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2725 return(MagickFalse);
2727 image_view=AcquireAuthenticCacheView(image,exception);
2728 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2729 #pragma omp parallel for schedule(static,4) shared(status) \
2730 magick_threads(image,image,image->rows,1)
2732 for (y=0; y < (ssize_t) image->rows; y++)
2743 if (status == MagickFalse)
2745 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2747 if (q == (Quantum *) NULL)
2752 for (x=0; x < (ssize_t) image->columns; x++)
2765 L=QuantumScale*GetPixelRed(image,q);
2766 M=QuantumScale*GetPixelGreen(image,q);
2767 S=QuantumScale*GetPixelBlue(image,q);
2768 ConvertLMSToXYZ(L,M,S,&X,&Y,&Z);
2769 ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
2770 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2771 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2772 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2773 q+=GetPixelChannels(image);
2775 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2776 if (sync == MagickFalse)
2779 image_view=DestroyCacheView(image_view);
2780 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2781 return(MagickFalse);
2801 Transform Log to sRGB colorspace.
2803 density=DisplayGamma;
2805 value=GetImageProperty(image,"gamma",exception);
2806 if (value != (const char *) NULL)
2807 gamma=PerceptibleReciprocal(StringToDouble(value,(char **) NULL));
2808 film_gamma=FilmGamma;
2809 value=GetImageProperty(image,"film-gamma",exception);
2810 if (value != (const char *) NULL)
2811 film_gamma=StringToDouble(value,(char **) NULL);
2812 reference_black=ReferenceBlack;
2813 value=GetImageProperty(image,"reference-black",exception);
2814 if (value != (const char *) NULL)
2815 reference_black=StringToDouble(value,(char **) NULL);
2816 reference_white=ReferenceWhite;
2817 value=GetImageProperty(image,"reference-white",exception);
2818 if (value != (const char *) NULL)
2819 reference_white=StringToDouble(value,(char **) NULL);
2820 logmap=(Quantum *) AcquireQuantumMemory((size_t) MaxMap+1UL,
2822 if (logmap == (Quantum *) NULL)
2823 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
2825 black=pow(10.0,(reference_black-reference_white)*(gamma/density)*0.002/
2827 for (i=0; i <= (ssize_t) (reference_black*MaxMap/1024.0); i++)
2828 logmap[i]=(Quantum) 0;
2829 for ( ; i < (ssize_t) (reference_white*MaxMap/1024.0); i++)
2830 logmap[i]=ClampToQuantum(QuantumRange/(1.0-black)*
2831 (pow(10.0,(1024.0*i/MaxMap-reference_white)*(gamma/density)*0.002/
2832 film_gamma)-black));
2833 for ( ; i <= (ssize_t) MaxMap; i++)
2834 logmap[i]=QuantumRange;
2835 if (image->storage_class == PseudoClass)
2837 if (SyncImage(image,exception) == MagickFalse)
2838 return(MagickFalse);
2839 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2840 return(MagickFalse);
2842 image_view=AcquireAuthenticCacheView(image,exception);
2843 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2844 #pragma omp parallel for schedule(static,4) shared(status) \
2845 magick_threads(image,image,image->rows,1)
2847 for (y=0; y < (ssize_t) image->rows; y++)
2858 if (status == MagickFalse)
2860 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2862 if (q == (Quantum *) NULL)
2867 for (x=(ssize_t) image->columns; x != 0; x--)
2874 red=EncodePixelGamma((MagickRealType) logmap[ScaleQuantumToMap(
2875 GetPixelRed(image,q))]);
2876 green=EncodePixelGamma((MagickRealType) logmap[ScaleQuantumToMap(
2877 GetPixelGreen(image,q))]);
2878 blue=EncodePixelGamma((MagickRealType) logmap[ScaleQuantumToMap(
2879 GetPixelBlue(image,q))]);
2880 SetPixelRed(image,ClampToQuantum(red),q);
2881 SetPixelGreen(image,ClampToQuantum(green),q);
2882 SetPixelBlue(image,ClampToQuantum(blue),q);
2883 q+=GetPixelChannels(image);
2885 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2886 if (sync == MagickFalse)
2889 image_view=DestroyCacheView(image_view);
2890 logmap=(Quantum *) RelinquishMagickMemory(logmap);
2891 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2892 return(MagickFalse);
2898 Transform image from Luv to sRGB.
2900 if (image->storage_class == PseudoClass)
2902 if (SyncImage(image,exception) == MagickFalse)
2903 return(MagickFalse);
2904 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2905 return(MagickFalse);
2907 image_view=AcquireAuthenticCacheView(image,exception);
2908 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2909 #pragma omp parallel for schedule(static,4) shared(status) \
2910 magick_threads(image,image,image->rows,1)
2912 for (y=0; y < (ssize_t) image->rows; y++)
2923 if (status == MagickFalse)
2925 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2927 if (q == (Quantum *) NULL)
2932 for (x=0; x < (ssize_t) image->columns; x++)
2945 L=QuantumScale*GetPixelRed(image,q);
2946 u=QuantumScale*GetPixelGreen(image,q);
2947 v=QuantumScale*GetPixelBlue(image,q);
2948 ConvertLuvToXYZ(L,u,v,&X,&Y,&Z);
2949 ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
2950 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
2951 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
2952 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
2953 q+=GetPixelChannels(image);
2955 sync=SyncCacheViewAuthenticPixels(image_view,exception);
2956 if (sync == MagickFalse)
2959 image_view=DestroyCacheView(image_view);
2960 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2961 return(MagickFalse);
2965 case scRGBColorspace:
2968 Transform linear RGB to sRGB colorspace.
2970 if (image->storage_class == PseudoClass)
2972 if (SyncImage(image,exception) == MagickFalse)
2973 return(MagickFalse);
2974 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2975 return(MagickFalse);
2977 image_view=AcquireAuthenticCacheView(image,exception);
2978 #if defined(MAGICKCORE_OPENMP_SUPPORT)
2979 #pragma omp parallel for schedule(static,4) shared(status) \
2980 magick_threads(image,image,image->rows,1)
2982 for (y=0; y < (ssize_t) image->rows; y++)
2993 if (status == MagickFalse)
2995 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2997 if (q == (Quantum *) NULL)
3002 for (x=(ssize_t) image->columns; x != 0; x--)
3009 red=EncodePixelGamma((MagickRealType) GetPixelRed(image,q));
3010 green=EncodePixelGamma((MagickRealType) GetPixelGreen(image,q));
3011 blue=EncodePixelGamma((MagickRealType) GetPixelBlue(image,q));
3012 SetPixelRed(image,ClampToQuantum(red),q);
3013 SetPixelGreen(image,ClampToQuantum(green),q);
3014 SetPixelBlue(image,ClampToQuantum(blue),q);
3015 q+=GetPixelChannels(image);
3017 sync=SyncCacheViewAuthenticPixels(image_view,exception);
3018 if (sync == MagickFalse)
3021 image_view=DestroyCacheView(image_view);
3022 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
3023 return(MagickFalse);
3029 Transform image from XYZ to sRGB.
3031 if (image->storage_class == PseudoClass)
3033 if (SyncImage(image,exception) == MagickFalse)
3034 return(MagickFalse);
3035 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
3036 return(MagickFalse);
3038 image_view=AcquireAuthenticCacheView(image,exception);
3039 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3040 #pragma omp parallel for schedule(static,4) shared(status) \
3041 magick_threads(image,image,image->rows,1)
3043 for (y=0; y < (ssize_t) image->rows; y++)
3054 if (status == MagickFalse)
3056 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
3058 if (q == (Quantum *) NULL)
3063 for (x=0; x < (ssize_t) image->columns; x++)
3073 X=QuantumScale*GetPixelRed(image,q);
3074 Y=QuantumScale*GetPixelGreen(image,q);
3075 Z=QuantumScale*GetPixelBlue(image,q);
3076 ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
3077 SetPixelRed(image,ClampToQuantum(EncodePixelGamma(red)),q);
3078 SetPixelGreen(image,ClampToQuantum(EncodePixelGamma(green)),q);
3079 SetPixelBlue(image,ClampToQuantum(EncodePixelGamma(blue)),q);
3080 q+=GetPixelChannels(image);
3082 sync=SyncCacheViewAuthenticPixels(image_view,exception);
3083 if (sync == MagickFalse)
3086 image_view=DestroyCacheView(image_view);
3087 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
3088 return(MagickFalse);
3095 Allocate the tables.
3097 x_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
3099 y_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
3101 z_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
3103 if ((x_map == (TransformPacket *) NULL) ||
3104 (y_map == (TransformPacket *) NULL) ||
3105 (z_map == (TransformPacket *) NULL))
3107 if (z_map != (TransformPacket *) NULL)
3108 z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
3109 if (y_map != (TransformPacket *) NULL)
3110 y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
3111 if (x_map != (TransformPacket *) NULL)
3112 x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
3113 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
3116 switch (image->colorspace)
3118 case OHTAColorspace:
3121 Initialize OHTA tables:
3123 R = I1+1.00000*I2-0.66668*I3
3124 G = I1+0.00000*I2+1.33333*I3
3125 B = I1-1.00000*I2-0.66668*I3
3127 I and Q, normally -0.5 through 0.5, must be normalized to the range 0
3128 through QuantumRange.
3130 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3131 #pragma omp parallel for schedule(static,4) \
3132 magick_threads(image,image,1,1)
3134 for (i=0; i <= (ssize_t) MaxMap; i++)
3136 x_map[i].x=(MagickRealType) (1.0*(double) i);
3137 y_map[i].x=(MagickRealType) (0.5*1.00000*(2.0*(double) i-MaxMap));
3138 z_map[i].x=(MagickRealType) (-0.5*0.66668*(2.0*(double) i-MaxMap));
3139 x_map[i].y=(MagickRealType) (1.0*(double) i);
3140 y_map[i].y=(MagickRealType) (0.5*0.00000*(2.0*(double) i-MaxMap));
3141 z_map[i].y=(MagickRealType) (0.5*1.33333*(2.0*(double) i-MaxMap));
3142 x_map[i].z=(MagickRealType) (1.0*(double) i);
3143 y_map[i].z=(MagickRealType) (-0.5*1.00000*(2.0*(double) i-MaxMap));
3144 z_map[i].z=(MagickRealType) (-0.5*0.66668*(2.0*(double) i-MaxMap));
3148 case Rec601YCbCrColorspace:
3149 case YCbCrColorspace:
3152 Initialize YCbCr tables:
3155 G = Y-0.344136*Cb-0.714136*Cr
3158 Cb and Cr, normally -0.5 through 0.5, must be normalized to the range 0
3159 through QuantumRange.
3161 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3162 #pragma omp parallel for schedule(static,4) \
3163 magick_threads(image,image,1,1)
3165 for (i=0; i <= (ssize_t) MaxMap; i++)
3167 x_map[i].x=0.99999999999914679361*(double) i;
3168 y_map[i].x=0.5*(-1.2188941887145875e-06)*(2.00*(double) i-MaxMap)
3169 z_map[i].x=0.5*1.4019995886561440468*(2.00*(double) i-MaxMap);
3170 x_map[i].y=0.99999975910502514331*(double) i;
3171 y_map[i].y=0.5*(-0.34413567816504303521)*(2.00*(double) i-MaxMap);
3172 z_map[i].y=0.5*(-0.71413649331646789076)*(2.00*(double) i-MaxMap);
3173 x_map[i].z=1.00000124040004623180*(double) i;
3174 y_map[i].z=0.5*1.77200006607230409200*(2.00*(double) i-MaxMap);
3175 z_map[i].z=0.5*2.1453384174593273e-06*(2.00*(double) i-MaxMap);
3179 case Rec709YCbCrColorspace:
3182 Initialize YCbCr tables:
3185 G = Y-0.187324*Cb-0.468124*Cr
3188 Cb and Cr, normally -0.5 through 0.5, must be normalized to the range 0
3189 through QuantumRange.
3191 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3192 #pragma omp parallel for schedule(static,4) \
3193 magick_threads(image,image,1,1)
3195 for (i=0; i <= (ssize_t) MaxMap; i++)
3197 x_map[i].x=(MagickRealType) (1.0*i);
3198 y_map[i].x=(MagickRealType) (0.5*0.000000*(2.0*i-MaxMap));
3199 z_map[i].x=(MagickRealType) (0.5*1.574800*(2.0*i-MaxMap));
3200 x_map[i].y=(MagickRealType) (1.0*i);
3201 y_map[i].y=(MagickRealType) (0.5*(-0.187324)*(2.0*i-MaxMap));
3202 z_map[i].y=(MagickRealType) (0.5*(-0.468124)*(2.0*i-MaxMap));
3203 x_map[i].z=(MagickRealType) (1.0*i);
3204 y_map[i].z=(MagickRealType) (0.5*1.855600*(2.0*i-MaxMap));
3205 z_map[i].z=(MagickRealType) (0.5*0.000000*(2.0*i-MaxMap));
3212 Initialize YCC tables:
3215 G = Y-0.317038*C1-0.682243*C2
3218 YCC is scaled by 1.3584. C1 zero is 156 and C2 is at 137.
3220 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3221 #pragma omp parallel for schedule(static,4) \
3222 magick_threads(image,image,1,1)
3224 for (i=0; i <= (ssize_t) MaxMap; i++)
3226 x_map[i].x=(MagickRealType) (1.3584000*(double) i);
3227 y_map[i].x=(MagickRealType) 0.0000000;
3228 z_map[i].x=(MagickRealType) (1.8215000*(1.0*(double) i-(double)
3229 ScaleQuantumToMap(ScaleCharToQuantum(137))));
3230 x_map[i].y=(MagickRealType) (1.3584000*(double) i);
3231 y_map[i].y=(MagickRealType) (-0.4302726*(1.0*(double) i-(double)
3232 ScaleQuantumToMap(ScaleCharToQuantum(156))));
3233 z_map[i].y=(MagickRealType) (-0.9271435*(1.0*(double) i-(double)
3234 ScaleQuantumToMap(ScaleCharToQuantum(137))));
3235 x_map[i].z=(MagickRealType) (1.3584000*(double) i);
3236 y_map[i].z=(MagickRealType) (2.2179000*(1.0*(double) i-(double)
3237 ScaleQuantumToMap(ScaleCharToQuantum(156))));
3238 z_map[i].z=(MagickRealType) 0.0000000;
3245 Initialize YIQ tables:
3247 R = Y+0.95620*I+0.62140*Q
3248 G = Y-0.27270*I-0.64680*Q
3249 B = Y-1.10370*I+1.70060*Q
3251 I and Q, normally -0.5 through 0.5, must be normalized to the range 0
3252 through QuantumRange.
3254 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3255 #pragma omp parallel for schedule(static,4) \
3256 magick_threads(image,image,1,1)
3258 for (i=0; i <= (ssize_t) MaxMap; i++)
3260 x_map[i].x=1.0*(double) i;
3261 y_map[i].x=0.5*0.9562957197589482261*(2.00000*(double) i-MaxMap);
3262 z_map[i].x=0.5*0.6210244164652610754*(2.00000*(double) i-MaxMap);
3263 x_map[i].y=1.0*(double) i;
3264 y_map[i].y=0.5*(-0.2721220993185104464)*(2.00000*(double) i-MaxMap);
3265 z_map[i].y=0.5*(-0.6473805968256950427)*(2.00000*(double) i-MaxMap);
3266 x_map[i].z=1.0*(double) i;
3267 y_map[i].z=0.5*(-1.1069890167364901945)*(2.00000*(double) i-MaxMap);
3268 z_map[i].z=0.5*1.7046149983646481374*(2.00000*(double) i-MaxMap);
3272 case YPbPrColorspace:
3275 Initialize YPbPr tables:
3278 G = Y-0.344136*C1+0.714136*C2
3281 Pb and Pr, normally -0.5 through 0.5, must be normalized to the range 0
3282 through QuantumRange.
3284 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3285 #pragma omp parallel for schedule(static,4) \
3286 magick_threads(image,image,1,1)
3288 for (i=0; i <= (ssize_t) MaxMap; i++)
3290 x_map[i].x=0.99999999999914679361*(double) i;
3291 y_map[i].x=0.5*(-1.2188941887145875e-06)*(2.0*(double) i-MaxMap);
3292 z_map[i].x=0.5*1.4019995886561440468*(2.0*(double) i-MaxMap);
3293 x_map[i].y=0.99999975910502514331*(double) i;
3294 y_map[i].y=0.5*(-0.34413567816504303521)*(2.0*(double) i-MaxMap);
3295 z_map[i].y=0.5*(-0.71413649331646789076)*(2.0*(double) i-MaxMap);
3296 x_map[i].z=1.00000124040004623180*(double) i;
3297 y_map[i].z=0.5*1.77200006607230409200*(2.0*(double) i-MaxMap);
3298 z_map[i].z=0.5*2.1453384174593273e-06*(2.0*(double) i-MaxMap);
3305 Initialize YUV tables:
3308 G = Y-0.39464*U-0.58060*V
3311 U and V, normally -0.5 through 0.5, must be normalized to the range 0
3312 through QuantumRange.
3314 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3315 #pragma omp parallel for schedule(static,4) \
3316 magick_threads(image,image,1,1)
3318 for (i=0; i <= (ssize_t) MaxMap; i++)
3320 x_map[i].x=1.0*(double) i;
3321 y_map[i].x=0.5*(-3.945707070708279e-05)*(2.0*(double) i-MaxMap);
3322 z_map[i].x=0.5*1.1398279671717170825*(2.0*(double) i-MaxMap);
3323 x_map[i].y=1.0*(double) i;
3324 y_map[i].y=0.5*(-0.3946101641414141437)*(2.0*(double) i-MaxMap);
3325 z_map[i].y=0.5*(-0.5805003156565656797)*(2.0*(double) i-MaxMap);
3326 x_map[i].z=1.0*(double) i;
3327 y_map[i].z=0.5*2.0319996843434342537*(2.0*(double) i-MaxMap);
3328 z_map[i].z=0.5*(-4.813762626262513e-04)*(2.0*(double) i-MaxMap);
3335 Linear conversion tables.
3337 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3338 #pragma omp parallel for schedule(static,4) \
3339 magick_threads(image,image,1,1)
3341 for (i=0; i <= (ssize_t) MaxMap; i++)
3343 x_map[i].x=(MagickRealType) (1.0*(double) i);
3344 y_map[i].x=(MagickRealType) 0.0;
3345 z_map[i].x=(MagickRealType) 0.0;
3346 x_map[i].y=(MagickRealType) 0.0;
3347 y_map[i].y=(MagickRealType) (1.0*(double) i);
3348 z_map[i].y=(MagickRealType) 0.0;
3349 x_map[i].z=(MagickRealType) 0.0;
3350 y_map[i].z=(MagickRealType) 0.0;
3351 z_map[i].z=(MagickRealType) (1.0*(double) i);
3359 switch (image->storage_class)
3365 Convert DirectClass image.
3367 image_view=AcquireAuthenticCacheView(image,exception);
3368 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3369 #pragma omp parallel for schedule(static,4) shared(status) \
3370 magick_threads(image,image,image->rows,1)
3372 for (y=0; y < (ssize_t) image->rows; y++)
3386 if (status == MagickFalse)
3388 q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
3390 if (q == (Quantum *) NULL)
3395 for (x=0; x < (ssize_t) image->columns; x++)
3402 red=ScaleQuantumToMap(GetPixelRed(image,q));
3403 green=ScaleQuantumToMap(GetPixelGreen(image,q));
3404 blue=ScaleQuantumToMap(GetPixelBlue(image,q));
3405 pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
3406 pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
3407 pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
3408 if (image->colorspace == YCCColorspace)
3410 pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.red/
3412 pixel.green=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.green/
3414 pixel.blue=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.blue/
3419 pixel.red=EncodePixelGamma((MagickRealType)
3420 ScaleMapToQuantum(pixel.red));
3421 pixel.green=EncodePixelGamma((MagickRealType)
3422 ScaleMapToQuantum(pixel.green));
3423 pixel.blue=EncodePixelGamma((MagickRealType)
3424 ScaleMapToQuantum(pixel.blue));
3426 SetPixelRed(image,ClampToQuantum(pixel.red),q);
3427 SetPixelGreen(image,ClampToQuantum(pixel.green),q);
3428 SetPixelBlue(image,ClampToQuantum(pixel.blue),q);
3429 q+=GetPixelChannels(image);
3431 sync=SyncCacheViewAuthenticPixels(image_view,exception);
3432 if (sync == MagickFalse)
3434 if (image->progress_monitor != (MagickProgressMonitor) NULL)
3439 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3440 #pragma omp critical (MagickCore_TransformsRGBImage)
3442 proceed=SetImageProgress(image,TransformsRGBImageTag,progress++,
3444 if (proceed == MagickFalse)
3448 image_view=DestroyCacheView(image_view);
3454 Convert PseudoClass image.
3456 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3457 #pragma omp parallel for schedule(static,4) shared(status) \
3458 magick_threads(image,image,1,1)
3460 for (i=0; i < (ssize_t) image->colors; i++)
3470 red=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].red));
3471 green=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].green));
3472 blue=ScaleQuantumToMap(ClampToQuantum(image->colormap[i].blue));
3473 pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
3474 pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
3475 pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
3476 if (image->colorspace == YCCColorspace)
3478 pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.red/
3480 pixel.green=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.green/
3482 pixel.blue=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.blue/
3487 pixel.red=EncodePixelGamma((MagickRealType)
3488 ScaleMapToQuantum(pixel.red));
3489 pixel.green=EncodePixelGamma((MagickRealType)
3490 ScaleMapToQuantum(pixel.green));
3491 pixel.blue=EncodePixelGamma((MagickRealType)
3492 ScaleMapToQuantum(pixel.blue));
3494 image->colormap[i].red=(double) ClampToQuantum(pixel.red);
3495 image->colormap[i].green=(double) ClampToQuantum(pixel.green);
3496 image->colormap[i].blue=(double) ClampToQuantum(pixel.blue);
3498 (void) SyncImage(image,exception);
3503 Relinquish resources.
3505 z_map=(TransformPacket *) RelinquishMagickMemory(z_map);
3506 y_map=(TransformPacket *) RelinquishMagickMemory(y_map);
3507 x_map=(TransformPacket *) RelinquishMagickMemory(x_map);
3508 if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
3509 return(MagickFalse);