granicus.if.org Git - imagemagick/blob - MagickCore/colorspace.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %     CCCC   OOO   L       OOO   RRRR   SSSSS  PPPP    AAA    CCCC  EEEEE     %
   7 %    C      O   O  L      O   O  R   R  SS     P   P  A   A  C      E         %
   8 %    C      O   O  L      O   O  RRRR    SSS   PPPP   AAAAA  C      EEE       %
   9 %    C      O   O  L      O   O  R R       SS  P      A   A  C      E         %
  10 %     CCCC   OOO   LLLLL   OOO   R  R   SSSSS  P      A   A   CCCC  EEEEE     %
  11 %                                                                             %
  12 %                                                                             %
  13 %                     MagickCore Image Colorspace Methods                     %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  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"
  69 \f
  70 /*
  71   Typedef declarations.
  72 */
  73 typedef struct _TransformPacket
  74 {
  75   MagickRealType
  76     x,
  77     y,
  78     z;
  79 } TransformPacket;
  80 \f
  81 /*
  82   Forward declarations.
  83 */
  84 static MagickBooleanType
  85   TransformsRGBImage(Image *,const ColorspaceType,ExceptionInfo *);
  86 \f
  87 /*
  88 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  89 %                                                                             %
  90 %                                                                             %
  91 %                                                                             %
  92 +     s R G B T r a n s f o r m I m a g e                                     %
  93 %                                                                             %
  94 %                                                                             %
  95 %                                                                             %
  96 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  97 %
  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].
 102 %
 103 %  The format of the sRGBTransformImage method is:
 104 %
 105 %      MagickBooleanType sRGBTransformImage(Image *image,
 106 %        const ColorspaceType colorspace,EsceptionInfo *exception)
 107 %
 108 %  A description of each parameter follows:
 109 %
 110 %    o image: the image.
 111 %
 112 %    o colorspace: the colorspace to transform the image to.
 113 %
 114 %   o exception: return any errors or warnings in this structure.
 115 %
 116 */
 117
 118 static inline void ConvertXYZToLMS(const double x,const double y,
 119   const double z,double *L,double *M,double *S)
 120 {
 121   double
 122     l,
 123     m,
 124     s;
 125
 126   /*
 127     Convert XYZ to LMS colorspace.
 128   */
 129   assert(L != (double *) NULL);
 130   assert(M != (double *) NULL);
 131   assert(S != (double *) NULL);
 132   l=0.7328f*x+0.4296f*y-0.1624f*z;
 133   m=(-0.7036f*x+1.6975f*y+0.0.0061f*z);
 134   s=0.0030f*x+0.0136f*y+0.9834f*z;
 135   *L=QuantumRange*l;
 136   *M=QuantumRange*m;
 137   *S=QuantumRange*s;
 138 }
 139
 140 static MagickBooleanType sRGBTransformImage(Image *image,
 141   const ColorspaceType colorspace,ExceptionInfo *exception)
 142 {
 143 #define sRGBTransformImageTag  "RGBTransform/Image"
 144
 145   CacheView
 146     *image_view;
 147
 148   MagickBooleanType
 149     status;
 150
 151   MagickOffsetType
 152     progress;
 153
 154   PrimaryInfo
 155     primary_info;
 156
 157   register ssize_t
 158     i;
 159
 160   ssize_t
 161     y;
 162
 163   TransformPacket
 164     *x_map,
 165     *y_map,
 166     *z_map;
 167
 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);
 175   status=MagickTrue;
 176   progress=0;
 177   switch (colorspace)
 178   {
 179     case CMYColorspace:
 180     {
 181       /*
 182         Convert RGB to CMY colorspace.
 183       */
 184       if (image->storage_class == PseudoClass)
 185         {
 186           if (SyncImage(image,exception) == MagickFalse)
 187             return(MagickFalse);
 188           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 189             return(MagickFalse);
 190         }
 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)
 195 #endif
 196       for (y=0; y < (ssize_t) image->rows; y++)
 197       {
 198         MagickBooleanType
 199           sync;
 200
 201         register ssize_t
 202           x;
 203
 204         register Quantum
 205           *restrict q;
 206
 207         if (status == MagickFalse)
 208           continue;
 209         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 210           exception);
 211         if (q == (Quantum *) NULL)
 212           {
 213             status=MagickFalse;
 214             continue;
 215           }
 216         for (x=0; x < (ssize_t) image->columns; x++)
 217         {
 218           double
 219             cyan,
 220             magenta,
 221             yellow;
 222
 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);
 230         }
 231         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 232         if (sync == MagickFalse)
 233           status=MagickFalse;
 234       }
 235       image_view=DestroyCacheView(image_view);
 236       image->type=image->alpha_trait != BlendPixelTrait ? ColorSeparationType :
 237         ColorSeparationMatteType;
 238       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 239         return(MagickFalse);
 240       return(status);
 241     }
 242     case CMYKColorspace:
 243     {
 244       PixelInfo
 245         zero;
 246
 247       /*
 248         Convert RGB to CMYK colorspace.
 249       */
 250       if (image->storage_class == PseudoClass)
 251         {
 252           if (SyncImage(image,exception) == MagickFalse)
 253             return(MagickFalse);
 254           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 255             return(MagickFalse);
 256         }
 257       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 258         return(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)
 264 #endif
 265       for (y=0; y < (ssize_t) image->rows; y++)
 266       {
 267         MagickBooleanType
 268           sync;
 269
 270         PixelInfo
 271           pixel;
 272
 273         register ssize_t
 274           x;
 275
 276         register Quantum
 277           *restrict q;
 278
 279         if (status == MagickFalse)
 280           continue;
 281         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 282           exception);
 283         if (q == (Quantum *) NULL)
 284           {
 285             status=MagickFalse;
 286             continue;
 287           }
 288         pixel=zero;
 289         for (x=0; x < (ssize_t) image->columns; x++)
 290         {
 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);
 298         }
 299         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 300         if (sync == MagickFalse)
 301           status=MagickFalse;
 302       }
 303       image_view=DestroyCacheView(image_view);
 304       image->type=image->alpha_trait != BlendPixelTrait ? ColorSeparationType :
 305         ColorSeparationMatteType;
 306       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 307         return(MagickFalse);
 308       return(status);
 309     }
 310     case GRAYColorspace:
 311     {
 312       /*
 313         Transform image from sRGB to GRAY.
 314       */
 315       if (image->storage_class == PseudoClass)
 316         {
 317           if (SyncImage(image,exception) == MagickFalse)
 318             return(MagickFalse);
 319           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 320             return(MagickFalse);
 321         }
 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)
 326 #endif
 327       for (y=0; y < (ssize_t) image->rows; y++)
 328       {
 329         MagickBooleanType
 330           sync;
 331
 332         register ssize_t
 333           x;
 334
 335         register Quantum
 336           *restrict q;
 337
 338         if (status == MagickFalse)
 339           continue;
 340         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 341           exception);
 342         if (q == (Quantum *) NULL)
 343           {
 344             status=MagickFalse;
 345             continue;
 346           }
 347         for (x=0; x < (ssize_t) image->columns; x++)
 348         {
 349           SetPixelGray(image,ClampToQuantum(GetPixelIntensity(image,q)),q);
 350           q+=GetPixelChannels(image);
 351         }
 352         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 353         if (sync == MagickFalse)
 354           status=MagickFalse;
 355       }
 356       image_view=DestroyCacheView(image_view);
 357       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 358         return(MagickFalse);
 359       image->type=GrayscaleType;
 360       return(status);
 361     }
 362     case HCLColorspace:
 363     {
 364       /*
 365         Transform image from sRGB to HCL.
 366       */
 367       if (image->storage_class == PseudoClass)
 368         {
 369           if (SyncImage(image,exception) == MagickFalse)
 370             return(MagickFalse);
 371           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 372             return(MagickFalse);
 373         }
 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)
 378 #endif
 379       for (y=0; y < (ssize_t) image->rows; y++)
 380       {
 381         MagickBooleanType
 382           sync;
 383
 384         register ssize_t
 385           x;
 386
 387         register Quantum
 388           *restrict q;
 389
 390         if (status == MagickFalse)
 391           continue;
 392         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 393           exception);
 394         if (q == (Quantum *) NULL)
 395           {
 396             status=MagickFalse;
 397             continue;
 398           }
 399         for (x=0; x < (ssize_t) image->columns; x++)
 400         {
 401           double
 402             blue,
 403             chroma,
 404             green,
 405             hue,
 406             luma,
 407             red;
 408
 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);
 417         }
 418         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 419         if (sync == MagickFalse)
 420           status=MagickFalse;
 421       }
 422       image_view=DestroyCacheView(image_view);
 423       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 424         return(MagickFalse);
 425       return(status);
 426     }
 427     case HSBColorspace:
 428     {
 429       /*
 430         Transform image from sRGB to HSB.
 431       */
 432       if (image->storage_class == PseudoClass)
 433         {
 434           if (SyncImage(image,exception) == MagickFalse)
 435             return(MagickFalse);
 436           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 437             return(MagickFalse);
 438         }
 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)
 443 #endif
 444       for (y=0; y < (ssize_t) image->rows; y++)
 445       {
 446         MagickBooleanType
 447           sync;
 448
 449         register ssize_t
 450           x;
 451
 452         register Quantum
 453           *restrict q;
 454
 455         if (status == MagickFalse)
 456           continue;
 457         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 458           exception);
 459         if (q == (Quantum *) NULL)
 460           {
 461             status=MagickFalse;
 462             continue;
 463           }
 464         for (x=0; x < (ssize_t) image->columns; x++)
 465         {
 466           double
 467             blue,
 468             brightness,
 469             green,
 470             hue,
 471             red,
 472             saturation;
 473
 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);
 482         }
 483         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 484         if (sync == MagickFalse)
 485           status=MagickFalse;
 486       }
 487       image_view=DestroyCacheView(image_view);
 488       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 489         return(MagickFalse);
 490       return(status);
 491     }
 492     case HSLColorspace:
 493     {
 494       /*
 495         Transform image from sRGB to HSL.
 496       */
 497       if (image->storage_class == PseudoClass)
 498         {
 499           if (SyncImage(image,exception) == MagickFalse)
 500             return(MagickFalse);
 501           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 502             return(MagickFalse);
 503         }
 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)
 508 #endif
 509       for (y=0; y < (ssize_t) image->rows; y++)
 510       {
 511         MagickBooleanType
 512           sync;
 513
 514         register ssize_t
 515           x;
 516
 517         register Quantum
 518           *restrict q;
 519
 520         if (status == MagickFalse)
 521           continue;
 522         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 523           exception);
 524         if (q == (Quantum *) NULL)
 525           {
 526             status=MagickFalse;
 527             continue;
 528           }
 529         for (x=0; x < (ssize_t) image->columns; x++)
 530         {
 531           double
 532             blue,
 533             green,
 534             hue,
 535             lightness,
 536             red,
 537             saturation;
 538
 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);
 547         }
 548         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 549         if (sync == MagickFalse)
 550           status=MagickFalse;
 551       }
 552       image_view=DestroyCacheView(image_view);
 553       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 554         return(MagickFalse);
 555       return(status);
 556     }
 557     case HWBColorspace:
 558     {
 559       /*
 560         Transform image from sRGB to HWB.
 561       */
 562       if (image->storage_class == PseudoClass)
 563         {
 564           if (SyncImage(image,exception) == MagickFalse)
 565             return(MagickFalse);
 566           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 567             return(MagickFalse);
 568         }
 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)
 573 #endif
 574       for (y=0; y < (ssize_t) image->rows; y++)
 575       {
 576         MagickBooleanType
 577           sync;
 578
 579         register ssize_t
 580           x;
 581
 582         register Quantum
 583           *restrict q;
 584
 585         if (status == MagickFalse)
 586           continue;
 587         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 588           exception);
 589         if (q == (Quantum *) NULL)
 590           {
 591             status=MagickFalse;
 592             continue;
 593           }
 594         for (x=0; x < (ssize_t) image->columns; x++)
 595         {
 596           double
 597             blackness,
 598             blue,
 599             green,
 600             hue,
 601             red,
 602             whiteness;
 603
 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);
 612         }
 613         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 614         if (sync == MagickFalse)
 615           status=MagickFalse;
 616       }
 617       image_view=DestroyCacheView(image_view);
 618       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 619         return(MagickFalse);
 620       return(status);
 621     }
 622     case LabColorspace:
 623     {
 624       /*
 625         Transform image from sRGB to Lab.
 626       */
 627       if (image->storage_class == PseudoClass)
 628         {
 629           if (SyncImage(image,exception) == MagickFalse)
 630             return(MagickFalse);
 631           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 632             return(MagickFalse);
 633         }
 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)
 638 #endif
 639       for (y=0; y < (ssize_t) image->rows; y++)
 640       {
 641         MagickBooleanType
 642           sync;
 643
 644         register ssize_t
 645           x;
 646
 647         register Quantum
 648           *restrict q;
 649
 650         if (status == MagickFalse)
 651           continue;
 652         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 653           exception);
 654         if (q == (Quantum *) NULL)
 655           {
 656             status=MagickFalse;
 657             continue;
 658           }
 659         for (x=0; x < (ssize_t) image->columns; x++)
 660         {
 661           double
 662             a,
 663             b,
 664             blue,
 665             green,
 666             L,
 667             red,
 668             X,
 669             Y,
 670             Z;
 671
 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);
 681         }
 682         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 683         if (sync == MagickFalse)
 684           status=MagickFalse;
 685       }
 686       image_view=DestroyCacheView(image_view);
 687       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 688         return(MagickFalse);
 689       return(status);
 690     }
 691     case LCHabColorspace:
 692     {
 693       /*
 694         Transform image from sRGB to LCHab.
 695       */
 696       if (image->storage_class == PseudoClass)
 697         {
 698           if (SyncImage(image,exception) == MagickFalse)
 699             return(MagickFalse);
 700           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 701             return(MagickFalse);
 702         }
 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)
 707 #endif
 708       for (y=0; y < (ssize_t) image->rows; y++)
 709       {
 710         MagickBooleanType
 711           sync;
 712
 713         register ssize_t
 714           x;
 715
 716         register Quantum
 717           *restrict q;
 718
 719         if (status == MagickFalse)
 720           continue;
 721         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 722           exception);
 723         if (q == (Quantum *) NULL)
 724           {
 725             status=MagickFalse;
 726             continue;
 727           }
 728         for (x=0; x < (ssize_t) image->columns; x++)
 729         {
 730           double
 731             blue,
 732             chroma,
 733             green,
 734             hue,
 735             luma,
 736             red;
 737
 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);
 746         }
 747         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 748         if (sync == MagickFalse)
 749           status=MagickFalse;
 750       }
 751       image_view=DestroyCacheView(image_view);
 752       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 753         return(MagickFalse);
 754       return(status);
 755     }
 756     case LCHColorspace:
 757     case LCHuvColorspace:
 758     {
 759       /*
 760         Transform image from sRGB to LCHuv.
 761       */
 762       if (image->storage_class == PseudoClass)
 763         {
 764           if (SyncImage(image,exception) == MagickFalse)
 765             return(MagickFalse);
 766           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 767             return(MagickFalse);
 768         }
 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)
 773 #endif
 774       for (y=0; y < (ssize_t) image->rows; y++)
 775       {
 776         MagickBooleanType
 777           sync;
 778
 779         register ssize_t
 780           x;
 781
 782         register Quantum
 783           *restrict q;
 784
 785         if (status == MagickFalse)
 786           continue;
 787         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 788           exception);
 789         if (q == (Quantum *) NULL)
 790           {
 791             status=MagickFalse;
 792             continue;
 793           }
 794         for (x=0; x < (ssize_t) image->columns; x++)
 795         {
 796           double
 797             blue,
 798             chroma,
 799             green,
 800             hue,
 801             luma,
 802             red;
 803
 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);
 812         }
 813         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 814         if (sync == MagickFalse)
 815           status=MagickFalse;
 816       }
 817       image_view=DestroyCacheView(image_view);
 818       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 819         return(MagickFalse);
 820       return(status);
 821     }
 822     case LMSColorspace:
 823     {
 824       /*
 825         Transform image from sRGB to LMS.
 826       */
 827       if (image->storage_class == PseudoClass)
 828         {
 829           if (SyncImage(image,exception) == MagickFalse)
 830             return(MagickFalse);
 831           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
 832             return(MagickFalse);
 833         }
 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)
 838 #endif
 839       for (y=0; y < (ssize_t) image->rows; y++)
 840       {
 841         MagickBooleanType
 842           sync;
 843
 844         register ssize_t
 845           x;
 846
 847         register Quantum
 848           *restrict q;
 849
 850         if (status == MagickFalse)
 851           continue;
 852         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 853           exception);
 854         if (q == (Quantum *) NULL)
 855           {
 856             status=MagickFalse;
 857             continue;
 858           }
 859         for (x=0; x < (ssize_t) image->columns; x++)
 860         {
 861           double
 862             blue,
 863             green,
 864             L,
 865             M,
 866             red,
 867             S,
 868             X,
 869             Y,
 870             Z;
 871
 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);
 881         }
 882         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 883         if (sync == MagickFalse)
 884           status=MagickFalse;
 885       }
 886       image_view=DestroyCacheView(image_view);
 887       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 888         return(MagickFalse);
 889       return(status);
 890     }
 891     case LogColorspace:
 892     {
 893 #define DisplayGamma  (1.0f/1.7f)
 894 #define FilmGamma  0.6f
 895 #define ReferenceBlack  95.0f
 896 #define ReferenceWhite  685.0f
 897
 898       const char
 899         *value;
 900
 901       double
 902         black,
 903         density,
 904         film_gamma,
 905         gamma,
 906         reference_black,
 907         reference_white;
 908
 909       Quantum
 910         *logmap;
 911
 912       /*
 913         Transform RGB to Log colorspace.
 914       */
 915       density=DisplayGamma;
 916       gamma=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,
 933         sizeof(*logmap));
 934       if (logmap == (Quantum *) NULL)
 935         ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
 936           image->filename);
 937       black=pow(10.0,(reference_black-reference_white)*(gamma/density)*0.002f/
 938         film_gamma);
 939 #if defined(MAGICKCORE_OPENMP_SUPPORT)
 940       #pragma omp parallel for schedule(static,4) \
 941         magick_threads(image,image,1,1)
 942 #endif
 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.002f/
 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)
 951 #endif
 952       for (y=0; y < (ssize_t) image->rows; y++)
 953       {
 954         MagickBooleanType
 955           sync;
 956
 957         register ssize_t
 958           x;
 959
 960         register Quantum
 961           *restrict q;
 962
 963         if (status == MagickFalse)
 964           continue;
 965         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
 966           exception);
 967         if (q == (Quantum *) NULL)
 968           {
 969             status=MagickFalse;
 970             continue;
 971           }
 972         for (x=(ssize_t) image->columns; x != 0; x--)
 973         {
 974           double
 975             blue,
 976             green,
 977             red;
 978
 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);
 989         }
 990         sync=SyncCacheViewAuthenticPixels(image_view,exception);
 991         if (sync == MagickFalse)
 992           status=MagickFalse;
 993       }
 994       image_view=DestroyCacheView(image_view);
 995       logmap=(Quantum *) RelinquishMagickMemory(logmap);
 996       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
 997         return(MagickFalse);
 998       return(status);
 999     }
1000     case LuvColorspace:
1001     {
1002       /*
1003         Transform image from sRGB to Luv.
1004       */
1005       if (image->storage_class == PseudoClass)
1006         {
1007           if (SyncImage(image,exception) == MagickFalse)
1008             return(MagickFalse);
1009           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1010             return(MagickFalse);
1011         }
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)
1016 #endif
1017       for (y=0; y < (ssize_t) image->rows; y++)
1018       {
1019         MagickBooleanType
1020           sync;
1021
1022         register ssize_t
1023           x;
1024
1025         register Quantum
1026           *restrict q;
1027
1028         if (status == MagickFalse)
1029           continue;
1030         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1031           exception);
1032         if (q == (Quantum *) NULL)
1033           {
1034             status=MagickFalse;
1035             continue;
1036           }
1037         for (x=0; x < (ssize_t) image->columns; x++)
1038         {
1039           double
1040             blue,
1041             green,
1042             L,
1043             red,
1044             u,
1045             v,
1046             X,
1047             Y,
1048             Z;
1049
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);
1059         }
1060         sync=SyncCacheViewAuthenticPixels(image_view,exception);
1061         if (sync == MagickFalse)
1062           status=MagickFalse;
1063       }
1064       image_view=DestroyCacheView(image_view);
1065       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1066         return(MagickFalse);
1067       return(status);
1068     }
1069     case RGBColorspace:
1070     case scRGBColorspace:
1071     {
1072       /*
1073         Transform image from sRGB to linear RGB.
1074       */
1075       if (image->storage_class == PseudoClass)
1076         {
1077           if (SyncImage(image,exception) == MagickFalse)
1078             return(MagickFalse);
1079           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1080             return(MagickFalse);
1081         }
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)
1086 #endif
1087       for (y=0; y < (ssize_t) image->rows; y++)
1088       {
1089         MagickBooleanType
1090           sync;
1091
1092         register ssize_t
1093           x;
1094
1095         register Quantum
1096           *restrict q;
1097
1098         if (status == MagickFalse)
1099           continue;
1100         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1101           exception);
1102         if (q == (Quantum *) NULL)
1103           {
1104             status=MagickFalse;
1105             continue;
1106           }
1107         for (x=0; x < (ssize_t) image->columns; x++)
1108         {
1109           double
1110             blue,
1111             green,
1112             red;
1113
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);
1121         }
1122         sync=SyncCacheViewAuthenticPixels(image_view,exception);
1123         if (sync == MagickFalse)
1124           status=MagickFalse;
1125       }
1126       image_view=DestroyCacheView(image_view);
1127       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1128         return(MagickFalse);
1129       return(status);
1130     }
1131     case XYZColorspace:
1132     {
1133       /*
1134         Transform image from sRGB to XYZ.
1135       */
1136       if (image->storage_class == PseudoClass)
1137         {
1138           if (SyncImage(image,exception) == MagickFalse)
1139             return(MagickFalse);
1140           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1141             return(MagickFalse);
1142         }
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)
1147 #endif
1148       for (y=0; y < (ssize_t) image->rows; y++)
1149       {
1150         MagickBooleanType
1151           sync;
1152
1153         register ssize_t
1154           x;
1155
1156         register Quantum
1157           *restrict q;
1158
1159         if (status == MagickFalse)
1160           continue;
1161         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1162           exception);
1163         if (q == (Quantum *) NULL)
1164           {
1165             status=MagickFalse;
1166             continue;
1167           }
1168         for (x=0; x < (ssize_t) image->columns; x++)
1169         {
1170           double
1171             blue,
1172             green,
1173             red,
1174             X,
1175             Y,
1176             Z;
1177
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);
1186         }
1187         sync=SyncCacheViewAuthenticPixels(image_view,exception);
1188         if (sync == MagickFalse)
1189           status=MagickFalse;
1190       }
1191       image_view=DestroyCacheView(image_view);
1192       if (SetImageColorspace(image,colorspace,exception) == MagickFalse)
1193         return(MagickFalse);
1194       return(status);
1195     }
1196     default:
1197       break;
1198   }
1199   /*
1200     Allocate the tables.
1201   */
1202   x_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1203     sizeof(*x_map));
1204   y_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1205     sizeof(*y_map));
1206   z_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
1207     sizeof(*z_map));
1208   if ((x_map == (TransformPacket *) NULL) ||
1209       (y_map == (TransformPacket *) NULL) ||
1210       (z_map == (TransformPacket *) NULL))
1211     ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1212       image->filename);
1213   (void) ResetMagickMemory(&primary_info,0,sizeof(primary_info));
1214   switch (colorspace)
1215   {
1216     case OHTAColorspace:
1217     {
1218       /*
1219         Initialize OHTA tables:
1220
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
1224
1225         I and Q, normally -0.5 through 0.5, are normalized to the range 0
1226         through QuantumRange.
1227       */
1228       primary_info.y=(double) (MaxMap+1.0f)/2.0f;
1229       primary_info.z=(double) (MaxMap+1.0f)/2.0f;
1230 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1231       #pragma omp parallel for schedule(static,4) \
1232         magick_threads(image,image,1,1)
1233 #endif
1234       for (i=0; i <= (ssize_t) MaxMap; i++)
1235       {
1236         x_map[i].x=(MagickRealType) (0.33333f*(float) i);
1237         y_map[i].x=(MagickRealType) (0.33334f*(float) i);
1238         z_map[i].x=(MagickRealType) (0.33333f*(float) i);
1239         x_map[i].y=(MagickRealType) (0.50000f*(float) i);
1240         y_map[i].y=(MagickRealType) (0.00000f*(float) i);
1241         z_map[i].y=(MagickRealType) (-0.50000f*(float) i);
1242         x_map[i].z=(MagickRealType) (-0.25000f*(float) i);
1243         y_map[i].z=(MagickRealType) (0.50000f*(float) i);
1244         z_map[i].z=(MagickRealType) (-0.25000f*(float) i);
1245       }
1246       break;
1247     }
1248     case Rec601YCbCrColorspace:
1249     case YCbCrColorspace:
1250     {
1251       /*
1252         Initialize YCbCr tables (ITU-R BT.601):
1253
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
1257
1258         Cb and Cr, normally -0.5 through 0.5, are normalized to the range 0
1259         through QuantumRange.
1260       */
1261       primary_info.y=(double) (MaxMap+1.0f)/2.0f;
1262       primary_info.z=(double) (MaxMap+1.0f)/2.0f;
1263 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1264       #pragma omp parallel for schedule(static,4) \
1265         magick_threads(image,image,1,1)
1266 #endif
1267       for (i=0; i <= (ssize_t) MaxMap; i++)
1268       {
1269         x_map[i].x=(MagickRealType) (0.298839f*(float) i);
1270         y_map[i].x=(MagickRealType) (0.586811f*(float) i);
1271         z_map[i].x=(MagickRealType) (0.114350f*(float) i);
1272         x_map[i].y=(MagickRealType) (-0.1687367f*(float) i);
1273         y_map[i].y=(MagickRealType) (-0.331264f*(float) i);
1274         z_map[i].y=(MagickRealType) (0.500000f*(float) i);
1275         x_map[i].z=(MagickRealType) (0.500000f*(float) i);
1276         y_map[i].z=(MagickRealType) (-0.418688f*(float) i);
1277         z_map[i].z=(MagickRealType) (-0.081312f*(float) i);
1278       }
1279       break;
1280     }
1281     case Rec709YCbCrColorspace:
1282     {
1283       /*
1284         Initialize YCbCr tables (ITU-R BT.709):
1285
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
1289
1290         Cb and Cr, normally -0.5 through 0.5, are normalized to the range 0
1291         through QuantumRange.
1292       */
1293       primary_info.y=(double) (MaxMap+1.0f)/2.0f;
1294       primary_info.z=(double) (MaxMap+1.0f)/2.0f;
1295 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1296       #pragma omp parallel for schedule(static,4) \
1297         magick_threads(image,image,1,1)
1298 #endif
1299       for (i=0; i <= (ssize_t) MaxMap; i++)
1300       {
1301         x_map[i].x=(MagickRealType) (0.212600f*(float) i);
1302         y_map[i].x=(MagickRealType) (0.715200f*(float) i);
1303         z_map[i].x=(MagickRealType) (0.072200f*(float) i);
1304         x_map[i].y=(MagickRealType) (-0.114572f*(float) i);
1305         y_map[i].y=(MagickRealType) (-0.385428f*(float) i);
1306         z_map[i].y=(MagickRealType) (0.500000f*(float) i);
1307         x_map[i].z=(MagickRealType) (0.500000f*(float) i);
1308         y_map[i].z=(MagickRealType) (-0.454153f*(float) i);
1309         z_map[i].z=(MagickRealType) (-0.045847f*(float) i);
1310       }
1311       break;
1312     }
1313     case YCCColorspace:
1314     {
1315       /*
1316         Initialize YCC tables:
1317
1318           Y =  0.298839f*R+0.586811f*G+0.114350f*B
1319           C1= -0.298839f*R-0.586811f*G+0.88600*B
1320           C2=  0.70100*R-0.586811f*G-0.114350f*B
1321
1322         YCC is scaled by 1.3584.  C1 zero is 156 and C2 is at 137.
1323       */
1324       primary_info.y=(double) ScaleQuantumToMap(ScaleCharToQuantum(156));
1325       primary_info.z=(double) ScaleQuantumToMap(ScaleCharToQuantum(137));
1326       for (i=0; i <= (ssize_t) (0.018f*MaxMap); i++)
1327       {
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;
1337       }
1338       for ( ; i <= (ssize_t) MaxMap; i++)
1339       {
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);
1349       }
1350       break;
1351     }
1352     case YIQColorspace:
1353     {
1354       /*
1355         Initialize YIQ tables:
1356
1357           Y = 0.298839f*R+0.586811f*G+0.114350f*B
1358           I = 0.595716*R-0.274453*G-0.321263*B
1359           Q = 0.211456*R-0.522591*G+0.311135*B
1360
1361         I and Q, normally -0.5 through 0.5, are normalized to the range 0
1362         through QuantumRange.
1363       */
1364       primary_info.y=(double) (MaxMap+1.0f)/2.0f;
1365       primary_info.z=(double) (MaxMap+1.0f)/2.0f;
1366 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1367       #pragma omp parallel for schedule(static,4) \
1368         magick_threads(image,image,1,1)
1369 #endif
1370       for (i=0; i <= (ssize_t) MaxMap; i++)
1371       {
1372         x_map[i].x=(MagickRealType) (0.298839f*(float) i);
1373         y_map[i].x=(MagickRealType) (0.586811f*(float) i);
1374         z_map[i].x=(MagickRealType) (0.114350f*(float) i);
1375         x_map[i].y=(MagickRealType) (0.595716*(float) i);
1376         y_map[i].y=(MagickRealType) (-0.274453f*(float) i);
1377         z_map[i].y=(MagickRealType) (-0.321263f*(float) i);
1378         x_map[i].z=(MagickRealType) (0.211456f*(float) i);
1379         y_map[i].z=(MagickRealType) (-0.522591f*(float) i);
1380         z_map[i].z=(MagickRealType) (0.311135f*(float) i);
1381       }
1382       break;
1383     }
1384     case YPbPrColorspace:
1385     {
1386       /*
1387         Initialize YPbPr tables (ITU-R BT.601):
1388
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
1392
1393         Pb and Pr, normally -0.5 through 0.5, are normalized to the range 0
1394         through QuantumRange.
1395       */
1396       primary_info.y=(double) (MaxMap+1.0f)/2.0f;
1397       primary_info.z=(double) (MaxMap+1.0f)/2.0f;
1398 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1399       #pragma omp parallel for schedule(static,4) \
1400         magick_threads(image,image,1,1)
1401 #endif
1402       for (i=0; i <= (ssize_t) MaxMap; i++)
1403       {
1404         x_map[i].x=(MagickRealType) (0.298839f*(float) i);
1405         y_map[i].x=(MagickRealType) (0.586811f*(float) i);
1406         z_map[i].x=(MagickRealType) (0.114350f*(float) i);
1407         x_map[i].y=(MagickRealType) (-0.1687367f*(float) i);
1408         y_map[i].y=(MagickRealType) (-0.331264*(float) i);
1409         z_map[i].y=(MagickRealType) (0.500000f*(float) i);
1410         x_map[i].z=(MagickRealType) (0.500000f*(float) i);
1411         y_map[i].z=(MagickRealType) (-0.418688f*(float) i);
1412         z_map[i].z=(MagickRealType) (-0.081312f*(float) i);
1413       }
1414       break;
1415     }
1416     case YUVColorspace:
1417     {
1418       /*
1419         Initialize YUV tables:
1420
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
1424
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).
1427       */
1428       primary_info.y=(double) (MaxMap+1.0f)/2.0f;
1429       primary_info.z=(double) (MaxMap+1.0f)/2.0f;
1430 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1431       #pragma omp parallel for schedule(static,4) \
1432         magick_threads(image,image,1,1)
1433 #endif
1434       for (i=0; i <= (ssize_t) MaxMap; i++)
1435       {
1436         x_map[i].x=(MagickRealType) (0.298839f*(float) i);
1437         y_map[i].x=(MagickRealType) (0.586811f*(float) i);
1438         z_map[i].x=(MagickRealType) (0.114350f*(float) i);
1439         x_map[i].y=(MagickRealType) (-0.147130f*(float) i);
1440         y_map[i].y=(MagickRealType) (-0.288860f*(float) i);
1441         z_map[i].y=(MagickRealType) (0.436000f*(float) i);
1442         x_map[i].z=(MagickRealType) (0.615000f*(float) i);
1443         y_map[i].z=(MagickRealType) (-0.514990f*(float) i);
1444         z_map[i].z=(MagickRealType) (-0.100001f*(float) i);
1445       }
1446       break;
1447     }
1448     default:
1449     {
1450       /*
1451         Linear conversion tables.
1452       */
1453 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1454       #pragma omp parallel for schedule(static,4) \
1455         magick_threads(image,image,1,1)
1456 #endif
1457       for (i=0; i <= (ssize_t) MaxMap; i++)
1458       {
1459         x_map[i].x=(MagickRealType) (1.0*(float) i);
1460         y_map[i].x=(MagickRealType) 0.0f;
1461         z_map[i].x=(MagickRealType) 0.0f;
1462         x_map[i].y=(MagickRealType) 0.0f;
1463         y_map[i].y=(MagickRealType) (1.0*(float) i);
1464         z_map[i].y=(MagickRealType) 0.0f;
1465         x_map[i].z=(MagickRealType) 0.0f;
1466         y_map[i].z=(MagickRealType) 0.0f;
1467         z_map[i].z=(MagickRealType) (1.0*(float) i);
1468       }
1469       break;
1470     }
1471   }
1472   /*
1473     Convert from sRGB.
1474   */
1475   switch (image->storage_class)
1476   {
1477     case DirectClass:
1478     default:
1479     {
1480       /*
1481         Convert DirectClass image.
1482       */
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)
1487 #endif
1488       for (y=0; y < (ssize_t) image->rows; y++)
1489       {
1490         MagickBooleanType
1491           sync;
1492
1493         PixelInfo
1494           pixel;
1495
1496         register Quantum
1497           *restrict q;
1498
1499         register ssize_t
1500           x;
1501
1502         register unsigned int
1503           blue,
1504           green,
1505           red;
1506
1507         if (status == MagickFalse)
1508           continue;
1509         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
1510           exception);
1511         if (q == (Quantum *) NULL)
1512           {
1513             status=MagickFalse;
1514             continue;
1515           }
1516         for (x=0; x < (ssize_t) image->columns; x++)
1517         {
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)+
1525             primary_info.x;
1526           pixel.green=(x_map[red].y+y_map[green].y+z_map[blue].y)+
1527             primary_info.y;
1528           pixel.blue=(x_map[red].z+y_map[green].z+z_map[blue].z)+
1529             primary_info.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);
1534         }
1535         sync=SyncCacheViewAuthenticPixels(image_view,exception);
1536         if (sync == MagickFalse)
1537           status=MagickFalse;
1538         if (image->progress_monitor != (MagickProgressMonitor) NULL)
1539           {
1540             MagickBooleanType
1541               proceed;
1542
1543 #if defined(MAGICKCORE_OPENMP_SUPPORT)
1544             #pragma omp critical (MagickCore_sRGBTransformImage)
1545 #endif
1546             proceed=SetImageProgress(image,sRGBTransformImageTag,progress++,
1547               image->rows);
1548             if (proceed == MagickFalse)
1549               status=MagickFalse;
1550           }
1551       }
1552       image_view=DestroyCacheView(image_view);
1553       break;
1554     }
1555     case PseudoClass:
1556     {
1557       register unsigned int
1558         blue,
1559         green,
1560         red;
1561
1562       /*
1563         Convert PseudoClass image.
1564       */
1565       for (i=0; i < (ssize_t) image->colors; i++)
1566       {
1567         PixelInfo
1568           pixel;
1569
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);
1582       }
1583       (void) SyncImage(image,exception);
1584       break;
1585     }
1586   }
1587   /*
1588     Relinquish resources.
1589   */
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);
1595   return(status);
1596 }
1597 \f
1598 /*
1599 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1600 %                                                                             %
1601 %                                                                             %
1602 %                                                                             %
1603 %   S e t I m a g e C o l o r s p a c e                                       %
1604 %                                                                             %
1605 %                                                                             %
1606 %                                                                             %
1607 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1608 %
1609 %  SetImageColorspace() sets the colorspace member of the Image structure.
1610 %
1611 %  The format of the SetImageColorspace method is:
1612 %
1613 %      MagickBooleanType SetImageColorspace(Image *image,
1614 %        const ColorspaceType colorspace,ExceptiionInfo *exception)
1615 %
1616 %  A description of each parameter follows:
1617 %
1618 %    o image: the image.
1619 %
1620 %    o colorspace: the colorspace.
1621 %
1622 %   o exception: return any errors or warnings in this structure.
1623 %
1624 */
1625 MagickExport MagickBooleanType SetImageColorspace(Image *image,
1626   const ColorspaceType colorspace,ExceptionInfo *exception)
1627 {
1628   if (image->colorspace == colorspace)
1629     return(MagickTrue);
1630   image->colorspace=colorspace;
1631   image->rendering_intent=UndefinedIntent;
1632   image->gamma=1.000f;
1633   (void) ResetMagickMemory(&image->chromaticity,0,sizeof(image->chromaticity));
1634   if (IsGrayColorspace(colorspace) != MagickFalse)
1635     {
1636       if ((image->intensity != Rec601LuminancePixelIntensityMethod) &&
1637           (image->intensity != Rec709LuminancePixelIntensityMethod) &&
1638           (image->intensity != UndefinedPixelIntensityMethod))
1639         image->gamma=1.000f/2.200f;
1640       image->type=GrayscaleType;
1641     }
1642   else
1643     if (IssRGBColorspace(colorspace) != MagickFalse)
1644       image->gamma=1.000f/2.200f;
1645   if (image->gamma == (1.000f/2.200f))
1646     {
1647       image->rendering_intent=PerceptualIntent;
1648       image->gamma=1.000f/2.200f;
1649       image->chromaticity.red_primary.x=0.6400f;
1650       image->chromaticity.red_primary.y=0.3300f;
1651       image->chromaticity.red_primary.z=0.0300f;
1652       image->chromaticity.green_primary.x=0.3000f;
1653       image->chromaticity.green_primary.y=0.6000f;
1654       image->chromaticity.green_primary.z=0.1000f;
1655       image->chromaticity.blue_primary.x=0.1500f;
1656       image->chromaticity.blue_primary.y=0.0600f;
1657       image->chromaticity.blue_primary.z=0.7900f;
1658       image->chromaticity.white_point.x=0.3127f;
1659       image->chromaticity.white_point.y=0.3290f;
1660       image->chromaticity.white_point.z=0.3583f;
1661     }
1662   if (IsGrayColorspace(colorspace) != MagickFalse)
1663     image->type=GrayscaleType;
1664   return(SyncImagePixelCache(image,exception));
1665 }
1666 \f
1667 /*
1668 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1669 %                                                                             %
1670 %                                                                             %
1671 %                                                                             %
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                           %
1673 %                                                                             %
1674 %                                                                             %
1675 %                                                                             %
1676 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1677 %
1678 %  TransformImageColorspace() transforms an image colorspace, changing the
1679 %  image data to reflect the new colorspace.
1680 %
1681 %  The format of the TransformImageColorspace method is:
1682 %
1683 %      MagickBooleanType TransformImageColorspace(Image *image,
1684 %        const ColorspaceType colorspace,ExceptionInfo *exception)
1685 %
1686 %  A description of each parameter follows:
1687 %
1688 %    o image: the image.
1689 %
1690 %    o colorspace: the colorspace.
1691 %
1692 %   o exception: return any errors or warnings in this structure.
1693 %
1694 */
1695 MagickExport MagickBooleanType TransformImageColorspace(Image *image,
1696   const ColorspaceType colorspace,ExceptionInfo *exception)
1697 {
1698   MagickBooleanType
1699     status;
1700
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 */
1709   /*
1710     Convert the reference image from an alternate colorspace to sRGB.
1711   */
1712   (void) DeleteImageProfile(image,"icc");
1713   (void) DeleteImageProfile(image,"icm");
1714   if (IssRGBColorspace(colorspace) != MagickFalse)
1715     return(TransformsRGBImage(image,colorspace,exception));
1716   status=MagickTrue;
1717   if (IssRGBColorspace(image->colorspace) == MagickFalse)
1718     status=TransformsRGBImage(image,image->colorspace,exception);
1719   if (status == MagickFalse)
1720     return(status);
1721   /*
1722     Convert the reference image from sRGB to an alternate colorspace.
1723   */
1724   if (sRGBTransformImage(image,colorspace,exception) == MagickFalse)
1725     status=MagickFalse;
1726   return(status);
1727 }
1728 \f
1729 /*
1730 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1731 %                                                                             %
1732 %                                                                             %
1733 %                                                                             %
1734 +     T r a n s f o r m s R G B I m a g e                                     %
1735 %                                                                             %
1736 %                                                                             %
1737 %                                                                             %
1738 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1739 %
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].
1744 %
1745 %  The format of the TransformsRGBImage method is:
1746 %
1747 %      MagickBooleanType TransformsRGBImage(Image *image,
1748 %        const ColorspaceType colorspace,ExceptionInfo *exception)
1749 %
1750 %  A description of each parameter follows:
1751 %
1752 %    o image: the image.
1753 %
1754 %    o colorspace: the colorspace to transform the image to.
1755 %
1756 %   o exception: return any errors or warnings in this structure.
1757 %
1758 */
1759
1760 static inline void ConvertLMSToXYZ(const double L,const double M,const double S,
1761   double *X,double *Y,double *Z)
1762 {
1763   double
1764     l,
1765     m,
1766     s;
1767
1768   assert(X != (double *) NULL);
1769   assert(Y != (double *) NULL);
1770   assert(Z != (double *) NULL);
1771   l=QuantumScale*L;
1772   m=QuantumScale*M;
1773   s=QuantumScale*S;
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;
1777 }
1778
1779 static inline ssize_t RoundToYCC(const double value)
1780 {
1781   if (value <= 0.0f)
1782     return(0);
1783   if (value >= 1388.0f)
1784     return(1388);
1785   return((ssize_t) (value+0.5f));
1786 }
1787
1788 static inline void ConvertCMYKToRGB(PixelInfo *pixel)
1789 {
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)));
1796 }
1797
1798 static MagickBooleanType TransformsRGBImage(Image *image,
1799   const ColorspaceType colorspace,ExceptionInfo *exception)
1800 {
1801 #define TransformsRGBImageTag  "Transform/Image"
1802
1803   static const float
1804     YCCMap[1389] =
1805     {
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
2038     };
2039
2040   CacheView
2041     *image_view;
2042
2043   MagickBooleanType
2044     status;
2045
2046   MagickOffsetType
2047     progress;
2048
2049   register ssize_t
2050     i;
2051
2052   ssize_t
2053     y;
2054
2055   TransformPacket
2056     *y_map,
2057     *x_map,
2058     *z_map;
2059
2060   assert(image != (Image *) NULL);
2061   assert(image->signature == MagickSignature);
2062   if (image->debug != MagickFalse)
2063     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2064   status=MagickTrue;
2065   progress=0;
2066   switch (image->colorspace)
2067   {
2068     case CMYColorspace:
2069     {
2070       /*
2071         Transform image from CMY to sRGB.
2072       */
2073       if (image->storage_class == PseudoClass)
2074         {
2075           if (SyncImage(image,exception) == MagickFalse)
2076             return(MagickFalse);
2077           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2078             return(MagickFalse);
2079         }
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)
2084 #endif
2085       for (y=0; y < (ssize_t) image->rows; y++)
2086       {
2087         MagickBooleanType
2088           sync;
2089
2090         register ssize_t
2091           x;
2092
2093         register Quantum
2094           *restrict q;
2095
2096         if (status == MagickFalse)
2097           continue;
2098         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2099           exception);
2100         if (q == (Quantum *) NULL)
2101           {
2102             status=MagickFalse;
2103             continue;
2104           }
2105         for (x=0; x < (ssize_t) image->columns; x++)
2106         {
2107           double
2108             cyan,
2109             magenta,
2110             yellow;
2111
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);
2122         }
2123         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2124         if (sync == MagickFalse)
2125           status=MagickFalse;
2126       }
2127       image_view=DestroyCacheView(image_view);
2128       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2129         return(MagickFalse);
2130       return(status);
2131     }
2132     case CMYKColorspace:
2133     {
2134       PixelInfo
2135         zero;
2136
2137       /*
2138         Transform image from CMYK to sRGB.
2139       */
2140       if (image->storage_class == PseudoClass)
2141         {
2142           if (SyncImage(image,exception) == MagickFalse)
2143             return(MagickFalse);
2144           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2145             return(MagickFalse);
2146         }
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)
2152 #endif
2153       for (y=0; y < (ssize_t) image->rows; y++)
2154       {
2155         MagickBooleanType
2156           sync;
2157
2158         PixelInfo
2159           pixel;
2160
2161         register ssize_t
2162           x;
2163
2164         register Quantum
2165           *restrict q;
2166
2167         if (status == MagickFalse)
2168           continue;
2169         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2170           exception);
2171         if (q == (Quantum *) NULL)
2172           {
2173             status=MagickFalse;
2174             continue;
2175           }
2176         pixel=zero;
2177         for (x=0; x < (ssize_t) image->columns; x++)
2178         {
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);
2186         }
2187         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2188         if (sync == MagickFalse)
2189           status=MagickFalse;
2190       }
2191       image_view=DestroyCacheView(image_view);
2192       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2193         return(MagickFalse);
2194       return(status);
2195     }
2196     case GRAYColorspace:
2197     {
2198       /*
2199         Transform linear GRAY to sRGB colorspace.
2200       */
2201       if (image->storage_class == PseudoClass)
2202         {
2203           if (SyncImage(image,exception) == MagickFalse)
2204             return(MagickFalse);
2205           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2206             return(MagickFalse);
2207         }
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)
2214 #endif
2215       for (y=0; y < (ssize_t) image->rows; y++)
2216       {
2217         MagickBooleanType
2218           sync;
2219
2220         register ssize_t
2221           x;
2222
2223         register Quantum
2224           *restrict q;
2225
2226         if (status == MagickFalse)
2227           continue;
2228         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2229           exception);
2230         if (q == (Quantum *) NULL)
2231           {
2232             status=MagickFalse;
2233             continue;
2234           }
2235         for (x=(ssize_t) image->columns; x != 0; x--)
2236         {
2237           double
2238             gray;
2239
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);
2245         }
2246         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2247         if (sync == MagickFalse)
2248           status=MagickFalse;
2249       }
2250       image_view=DestroyCacheView(image_view);
2251       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2252         return(MagickFalse);
2253       return(status);
2254     }
2255     case HCLColorspace:
2256     {
2257       /*
2258         Transform image from HCL to sRGB.
2259       */
2260       if (image->storage_class == PseudoClass)
2261         {
2262           if (SyncImage(image,exception) == MagickFalse)
2263             return(MagickFalse);
2264           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2265             return(MagickFalse);
2266         }
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)
2271 #endif
2272       for (y=0; y < (ssize_t) image->rows; y++)
2273       {
2274         MagickBooleanType
2275           sync;
2276
2277         register ssize_t
2278           x;
2279
2280         register Quantum
2281           *restrict q;
2282
2283         if (status == MagickFalse)
2284           continue;
2285         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2286           exception);
2287         if (q == (Quantum *) NULL)
2288           {
2289             status=MagickFalse;
2290             continue;
2291           }
2292         for (x=0; x < (ssize_t) image->columns; x++)
2293         {
2294           double
2295             blue,
2296             chroma,
2297             green,
2298             hue,
2299             luma,
2300             red;
2301
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);
2310         }
2311         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2312         if (sync == MagickFalse)
2313           status=MagickFalse;
2314       }
2315       image_view=DestroyCacheView(image_view);
2316       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2317         return(MagickFalse);
2318       return(status);
2319     }
2320     case HSBColorspace:
2321     {
2322       /*
2323         Transform image from HSB to sRGB.
2324       */
2325       if (image->storage_class == PseudoClass)
2326         {
2327           if (SyncImage(image,exception) == MagickFalse)
2328             return(MagickFalse);
2329           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2330             return(MagickFalse);
2331         }
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)
2336 #endif
2337       for (y=0; y < (ssize_t) image->rows; y++)
2338       {
2339         MagickBooleanType
2340           sync;
2341
2342         register ssize_t
2343           x;
2344
2345         register Quantum
2346           *restrict q;
2347
2348         if (status == MagickFalse)
2349           continue;
2350         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2351           exception);
2352         if (q == (Quantum *) NULL)
2353           {
2354             status=MagickFalse;
2355             continue;
2356           }
2357         for (x=0; x < (ssize_t) image->columns; x++)
2358         {
2359           double
2360             blue,
2361             brightness,
2362             green,
2363             hue,
2364             red,
2365             saturation;
2366
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);
2375         }
2376         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2377         if (sync == MagickFalse)
2378           status=MagickFalse;
2379       }
2380       image_view=DestroyCacheView(image_view);
2381       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2382         return(MagickFalse);
2383       return(status);
2384     }
2385     case HSLColorspace:
2386     {
2387       /*
2388         Transform image from HSL to sRGB.
2389       */
2390       if (image->storage_class == PseudoClass)
2391         {
2392           if (SyncImage(image,exception) == MagickFalse)
2393             return(MagickFalse);
2394           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2395             return(MagickFalse);
2396         }
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)
2401 #endif
2402       for (y=0; y < (ssize_t) image->rows; y++)
2403       {
2404         MagickBooleanType
2405           sync;
2406
2407         register ssize_t
2408           x;
2409
2410         register Quantum
2411           *restrict q;
2412
2413         if (status == MagickFalse)
2414           continue;
2415         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2416           exception);
2417         if (q == (Quantum *) NULL)
2418           {
2419             status=MagickFalse;
2420             continue;
2421           }
2422         for (x=0; x < (ssize_t) image->columns; x++)
2423         {
2424           double
2425             blue,
2426             green,
2427             hue,
2428             lightness,
2429             red,
2430             saturation;
2431
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);
2440         }
2441         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2442         if (sync == MagickFalse)
2443           status=MagickFalse;
2444       }
2445       image_view=DestroyCacheView(image_view);
2446       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2447         return(MagickFalse);
2448       return(status);
2449     }
2450     case HWBColorspace:
2451     {
2452       /*
2453         Transform image from HWB to sRGB.
2454       */
2455       if (image->storage_class == PseudoClass)
2456         {
2457           if (SyncImage(image,exception) == MagickFalse)
2458             return(MagickFalse);
2459           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2460             return(MagickFalse);
2461         }
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)
2466 #endif
2467       for (y=0; y < (ssize_t) image->rows; y++)
2468       {
2469         MagickBooleanType
2470           sync;
2471
2472         register ssize_t
2473           x;
2474
2475         register Quantum
2476           *restrict q;
2477
2478         if (status == MagickFalse)
2479           continue;
2480         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2481           exception);
2482         if (q == (Quantum *) NULL)
2483           {
2484             status=MagickFalse;
2485             continue;
2486           }
2487         for (x=0; x < (ssize_t) image->columns; x++)
2488         {
2489           double
2490             blackness,
2491             blue,
2492             green,
2493             hue,
2494             red,
2495             whiteness;
2496
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);
2505         }
2506         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2507         if (sync == MagickFalse)
2508           status=MagickFalse;
2509       }
2510       image_view=DestroyCacheView(image_view);
2511       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2512         return(MagickFalse);
2513       return(status);
2514     }
2515     case LabColorspace:
2516     {
2517       /*
2518         Transform image from Lab to sRGB.
2519       */
2520       if (image->storage_class == PseudoClass)
2521         {
2522           if (SyncImage(image,exception) == MagickFalse)
2523             return(MagickFalse);
2524           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2525             return(MagickFalse);
2526         }
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)
2531 #endif
2532       for (y=0; y < (ssize_t) image->rows; y++)
2533       {
2534         MagickBooleanType
2535           sync;
2536
2537         register ssize_t
2538           x;
2539
2540         register Quantum
2541           *restrict q;
2542
2543         if (status == MagickFalse)
2544           continue;
2545         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2546           exception);
2547         if (q == (Quantum *) NULL)
2548           {
2549             status=MagickFalse;
2550             continue;
2551           }
2552         for (x=0; x < (ssize_t) image->columns; x++)
2553         {
2554           double
2555             a,
2556             b,
2557             blue,
2558             green,
2559             L,
2560             red,
2561             X,
2562             Y,
2563             Z;
2564
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);
2574         }
2575         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2576         if (sync == MagickFalse)
2577           status=MagickFalse;
2578       }
2579       image_view=DestroyCacheView(image_view);
2580       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2581         return(MagickFalse);
2582       return(status);
2583     }
2584     case LCHabColorspace:
2585     {
2586       /*
2587         Transform image from LCHab to sRGB.
2588       */
2589       if (image->storage_class == PseudoClass)
2590         {
2591           if (SyncImage(image,exception) == MagickFalse)
2592             return(MagickFalse);
2593           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2594             return(MagickFalse);
2595         }
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)
2600 #endif
2601       for (y=0; y < (ssize_t) image->rows; y++)
2602       {
2603         MagickBooleanType
2604           sync;
2605
2606         register ssize_t
2607           x;
2608
2609         register Quantum
2610           *restrict q;
2611
2612         if (status == MagickFalse)
2613           continue;
2614         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2615           exception);
2616         if (q == (Quantum *) NULL)
2617           {
2618             status=MagickFalse;
2619             continue;
2620           }
2621         for (x=0; x < (ssize_t) image->columns; x++)
2622         {
2623           double
2624             blue,
2625             chroma,
2626             green,
2627             hue,
2628             luma,
2629             red;
2630
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);
2639         }
2640         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2641         if (sync == MagickFalse)
2642           status=MagickFalse;
2643       }
2644       image_view=DestroyCacheView(image_view);
2645       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2646         return(MagickFalse);
2647       return(status);
2648     }
2649     case LCHColorspace:
2650     case LCHuvColorspace:
2651     {
2652       /*
2653         Transform image from LCHuv to sRGB.
2654       */
2655       if (image->storage_class == PseudoClass)
2656         {
2657           if (SyncImage(image,exception) == MagickFalse)
2658             return(MagickFalse);
2659           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2660             return(MagickFalse);
2661         }
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)
2666 #endif
2667       for (y=0; y < (ssize_t) image->rows; y++)
2668       {
2669         MagickBooleanType
2670           sync;
2671
2672         register ssize_t
2673           x;
2674
2675         register Quantum
2676           *restrict q;
2677
2678         if (status == MagickFalse)
2679           continue;
2680         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2681           exception);
2682         if (q == (Quantum *) NULL)
2683           {
2684             status=MagickFalse;
2685             continue;
2686           }
2687         for (x=0; x < (ssize_t) image->columns; x++)
2688         {
2689           double
2690             blue,
2691             chroma,
2692             green,
2693             hue,
2694             luma,
2695             red;
2696
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);
2705         }
2706         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2707         if (sync == MagickFalse)
2708           status=MagickFalse;
2709       }
2710       image_view=DestroyCacheView(image_view);
2711       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2712         return(MagickFalse);
2713       return(status);
2714     }
2715     case LMSColorspace:
2716     {
2717       /*
2718         Transform image from LMS to sRGB.
2719       */
2720       if (image->storage_class == PseudoClass)
2721         {
2722           if (SyncImage(image,exception) == MagickFalse)
2723             return(MagickFalse);
2724           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2725             return(MagickFalse);
2726         }
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)
2731 #endif
2732       for (y=0; y < (ssize_t) image->rows; y++)
2733       {
2734         MagickBooleanType
2735           sync;
2736
2737         register ssize_t
2738           x;
2739
2740         register Quantum
2741           *restrict q;
2742
2743         if (status == MagickFalse)
2744           continue;
2745         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2746           exception);
2747         if (q == (Quantum *) NULL)
2748           {
2749             status=MagickFalse;
2750             continue;
2751           }
2752         for (x=0; x < (ssize_t) image->columns; x++)
2753         {
2754           double
2755             blue,
2756             green,
2757             L,
2758             M,
2759             red,
2760             S,
2761             X,
2762             Y,
2763             Z;
2764
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);
2774         }
2775         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2776         if (sync == MagickFalse)
2777           status=MagickFalse;
2778       }
2779       image_view=DestroyCacheView(image_view);
2780       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2781         return(MagickFalse);
2782       return(status);
2783     }
2784     case LogColorspace:
2785     {
2786       const char
2787         *value;
2788
2789       double
2790         black,
2791         density,
2792         film_gamma,
2793         gamma,
2794         reference_black,
2795         reference_white;
2796
2797       Quantum
2798         *logmap;
2799
2800       /*
2801         Transform Log to sRGB colorspace.
2802       */
2803       density=DisplayGamma;
2804       gamma=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,
2821         sizeof(*logmap));
2822       if (logmap == (Quantum *) NULL)
2823         ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
2824           image->filename);
2825       black=pow(10.0,(reference_black-reference_white)*(gamma/density)*0.002f/
2826         film_gamma);
2827       for (i=0; i <= (ssize_t) (reference_black*MaxMap/1024.0f); i++)
2828         logmap[i]=(Quantum) 0;
2829       for ( ; i < (ssize_t) (reference_white*MaxMap/1024.0f); i++)
2830         logmap[i]=ClampToQuantum(QuantumRange/(1.0f-black)*
2831           (pow(10.0,(1024.0*i/MaxMap-reference_white)*(gamma/density)*0.002f/
2832           film_gamma)-black));
2833       for ( ; i <= (ssize_t) MaxMap; i++)
2834         logmap[i]=QuantumRange;
2835       if (image->storage_class == PseudoClass)
2836         {
2837           if (SyncImage(image,exception) == MagickFalse)
2838             return(MagickFalse);
2839           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2840             return(MagickFalse);
2841         }
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)
2846 #endif
2847       for (y=0; y < (ssize_t) image->rows; y++)
2848       {
2849         MagickBooleanType
2850           sync;
2851
2852         register ssize_t
2853           x;
2854
2855         register Quantum
2856           *restrict q;
2857
2858         if (status == MagickFalse)
2859           continue;
2860         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2861           exception);
2862         if (q == (Quantum *) NULL)
2863           {
2864             status=MagickFalse;
2865             continue;
2866           }
2867         for (x=(ssize_t) image->columns; x != 0; x--)
2868         {
2869           double
2870             blue,
2871             green,
2872             red;
2873
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);
2884         }
2885         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2886         if (sync == MagickFalse)
2887           status=MagickFalse;
2888       }
2889       image_view=DestroyCacheView(image_view);
2890       logmap=(Quantum *) RelinquishMagickMemory(logmap);
2891       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2892         return(MagickFalse);
2893       return(status);
2894     }
2895     case LuvColorspace:
2896     {
2897       /*
2898         Transform image from Luv to sRGB.
2899       */
2900       if (image->storage_class == PseudoClass)
2901         {
2902           if (SyncImage(image,exception) == MagickFalse)
2903             return(MagickFalse);
2904           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2905             return(MagickFalse);
2906         }
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)
2911 #endif
2912       for (y=0; y < (ssize_t) image->rows; y++)
2913       {
2914         MagickBooleanType
2915           sync;
2916
2917         register ssize_t
2918           x;
2919
2920         register Quantum
2921           *restrict q;
2922
2923         if (status == MagickFalse)
2924           continue;
2925         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2926           exception);
2927         if (q == (Quantum *) NULL)
2928           {
2929             status=MagickFalse;
2930             continue;
2931           }
2932         for (x=0; x < (ssize_t) image->columns; x++)
2933         {
2934           double
2935             blue,
2936             green,
2937             L,
2938             red,
2939             u,
2940             v,
2941             X,
2942             Y,
2943             Z;
2944
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);
2954         }
2955         sync=SyncCacheViewAuthenticPixels(image_view,exception);
2956         if (sync == MagickFalse)
2957           status=MagickFalse;
2958       }
2959       image_view=DestroyCacheView(image_view);
2960       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
2961         return(MagickFalse);
2962       return(status);
2963     }
2964     case RGBColorspace:
2965     case scRGBColorspace:
2966     {
2967       /*
2968         Transform linear RGB to sRGB colorspace.
2969       */
2970       if (image->storage_class == PseudoClass)
2971         {
2972           if (SyncImage(image,exception) == MagickFalse)
2973             return(MagickFalse);
2974           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2975             return(MagickFalse);
2976         }
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)
2981 #endif
2982       for (y=0; y < (ssize_t) image->rows; y++)
2983       {
2984         MagickBooleanType
2985           sync;
2986
2987         register ssize_t
2988           x;
2989
2990         register Quantum
2991           *restrict q;
2992
2993         if (status == MagickFalse)
2994           continue;
2995         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
2996           exception);
2997         if (q == (Quantum *) NULL)
2998           {
2999             status=MagickFalse;
3000             continue;
3001           }
3002         for (x=(ssize_t) image->columns; x != 0; x--)
3003         {
3004           double
3005             blue,
3006             green,
3007             red;
3008
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);
3016         }
3017         sync=SyncCacheViewAuthenticPixels(image_view,exception);
3018         if (sync == MagickFalse)
3019           status=MagickFalse;
3020       }
3021       image_view=DestroyCacheView(image_view);
3022       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
3023         return(MagickFalse);
3024       return(status);
3025     }
3026     case XYZColorspace:
3027     {
3028       /*
3029         Transform image from XYZ to sRGB.
3030       */
3031       if (image->storage_class == PseudoClass)
3032         {
3033           if (SyncImage(image,exception) == MagickFalse)
3034             return(MagickFalse);
3035           if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
3036             return(MagickFalse);
3037         }
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)
3042 #endif
3043       for (y=0; y < (ssize_t) image->rows; y++)
3044       {
3045         MagickBooleanType
3046           sync;
3047
3048         register ssize_t
3049           x;
3050
3051         register Quantum
3052           *restrict q;
3053
3054         if (status == MagickFalse)
3055           continue;
3056         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
3057           exception);
3058         if (q == (Quantum *) NULL)
3059           {
3060             status=MagickFalse;
3061             continue;
3062           }
3063         for (x=0; x < (ssize_t) image->columns; x++)
3064         {
3065           double
3066             blue,
3067             green,
3068             red,
3069             X,
3070             Y,
3071             Z;
3072
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);
3081         }
3082         sync=SyncCacheViewAuthenticPixels(image_view,exception);
3083         if (sync == MagickFalse)
3084           status=MagickFalse;
3085       }
3086       image_view=DestroyCacheView(image_view);
3087       if (SetImageColorspace(image,sRGBColorspace,exception) == MagickFalse)
3088         return(MagickFalse);
3089       return(status);
3090     }
3091     default:
3092       break;
3093   }
3094   /*
3095     Allocate the tables.
3096   */
3097   x_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
3098     sizeof(*x_map));
3099   y_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
3100     sizeof(*y_map));
3101   z_map=(TransformPacket *) AcquireQuantumMemory((size_t) MaxMap+1UL,
3102     sizeof(*z_map));
3103   if ((x_map == (TransformPacket *) NULL) ||
3104       (y_map == (TransformPacket *) NULL) ||
3105       (z_map == (TransformPacket *) NULL))
3106     {
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",
3114         image->filename);
3115     }
3116   switch (image->colorspace)
3117   {
3118     case OHTAColorspace:
3119     {
3120       /*
3121         Initialize OHTA tables:
3122
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
3126
3127         I and Q, normally -0.5 through 0.5, must be normalized to the range 0
3128         through QuantumRange.
3129       */
3130 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3131       #pragma omp parallel for schedule(static,4) \
3132         magick_threads(image,image,1,1)
3133 #endif
3134       for (i=0; i <= (ssize_t) MaxMap; i++)
3135       {
3136         x_map[i].x=(MagickRealType) (1.0f*(float) i);
3137         y_map[i].x=(MagickRealType) (0.5f*(2.0f*(float) i-MaxMap));
3138         z_map[i].x=(MagickRealType) ((-0.333340f)*(2.0f*(float) i-MaxMap));
3139         x_map[i].y=(MagickRealType) (1.0f*(float) i);
3140         y_map[i].y=(MagickRealType) 0.000000f;
3141         z_map[i].y=(MagickRealType) (0.666665f*(2.0f*(float) i-MaxMap));
3142         x_map[i].z=(MagickRealType) (1.0f*(float) i);
3143         y_map[i].z=(MagickRealType) (-0.500000f*(2.0f*(float) i-MaxMap));
3144         z_map[i].z=(MagickRealType) (-0.333340f*(2.0f*(float) i-MaxMap));
3145       }
3146       break;
3147     }
3148     case Rec601YCbCrColorspace:
3149     case YCbCrColorspace:
3150     {
3151       /*
3152         Initialize YCbCr tables:
3153
3154           R = Y            +1.402000*Cr
3155           G = Y-0.344136*Cb-0.714136*Cr
3156           B = Y+1.772000*Cb
3157
3158         Cb and Cr, normally -0.5 through 0.5, must be normalized to the range 0
3159         through QuantumRange.
3160       */
3161 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3162       #pragma omp parallel for schedule(static,4) \
3163         magick_threads(image,image,1,1)
3164 #endif
3165       for (i=0; i <= (ssize_t) MaxMap; i++)
3166       {
3167         x_map[i].x=0.99999999999914679361f*(float) i;
3168         y_map[i].x=(-1.2188941887145875e-06f)*(float) i;
3169         z_map[i].x=0.5f*1.4019995886561440468f*(2.00f*(float) i-MaxMap);
3170         x_map[i].y=0.99999975910502514331f*(float) i;
3171         y_map[i].y=0.5f*(-0.34413567816504303521f)*(2.00f*(float) i-MaxMap);
3172         z_map[i].y=0.5f*(-0.71413649331646789076f)*(2.00f*(float) i-MaxMap);
3173         x_map[i].z=1.00000124040004623180f*(float) i;
3174         y_map[i].z=0.5f*1.77200006607230409200f*(2.00f*(float) i-MaxMap);
3175         z_map[i].z=2.1453384174593273e-06f*(float) i;
3176       }
3177       break;
3178     }
3179     case Rec709YCbCrColorspace:
3180     {
3181       /*
3182         Initialize YCbCr tables:
3183
3184           R = Y            +1.574800*Cr
3185           G = Y-0.187324*Cb-0.468124*Cr
3186           B = Y+1.855600*Cb
3187
3188         Cb and Cr, normally -0.5 through 0.5, must be normalized to the range 0
3189         through QuantumRange.
3190       */
3191 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3192       #pragma omp parallel for schedule(static,4) \
3193         magick_threads(image,image,1,1)
3194 #endif
3195       for (i=0; i <= (ssize_t) MaxMap; i++)
3196       {
3197         x_map[i].x=(MagickRealType) (1.0f*i);
3198         y_map[i].x=(MagickRealType) (0.000000f*(2.0f*i-MaxMap));
3199         z_map[i].x=(MagickRealType) (0.5f*1.574800f*(2.0f*i-MaxMap));
3200         x_map[i].y=(MagickRealType) (1.0f*i);
3201         y_map[i].y=(MagickRealType) (0.5f*(-0.187324f)*(2.0f*i-MaxMap));
3202         z_map[i].y=(MagickRealType) (0.5f*(-0.468124f)*(2.0f*i-MaxMap));
3203         x_map[i].z=(MagickRealType) (1.0f*i);
3204         y_map[i].z=(MagickRealType) (0.5f*1.855600f*(2.0f*i-MaxMap));
3205         z_map[i].z=(MagickRealType) (0.000000f*(2.0f*i-MaxMap));
3206       }
3207       break;
3208     }
3209     case YCCColorspace:
3210     {
3211       /*
3212         Initialize YCC tables:
3213
3214           R = Y            +1.340762*C2
3215           G = Y-0.317038*C1-0.682243*C2
3216           B = Y+1.632639*C1
3217
3218         YCC is scaled by 1.3584.  C1 zero is 156 and C2 is at 137.
3219       */
3220 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3221       #pragma omp parallel for schedule(static,4) \
3222         magick_threads(image,image,1,1)
3223 #endif
3224       for (i=0; i <= (ssize_t) MaxMap; i++)
3225       {
3226         x_map[i].x=(MagickRealType) (1.3584000f*(float) i);
3227         y_map[i].x=(MagickRealType) 0.0000000f;
3228         z_map[i].x=(MagickRealType) (1.8215000f*(1.0f*(float) i-(double)
3229           ScaleQuantumToMap(ScaleCharToQuantum(137))));
3230         x_map[i].y=(MagickRealType) (1.3584000f*(float) i);
3231         y_map[i].y=(MagickRealType) (-0.4302726f*(1.0f*(float) i-(double)
3232           ScaleQuantumToMap(ScaleCharToQuantum(156))));
3233         z_map[i].y=(MagickRealType) (-0.9271435f*(1.0f*(float) i-(double)
3234           ScaleQuantumToMap(ScaleCharToQuantum(137))));
3235         x_map[i].z=(MagickRealType) (1.3584000f*(float) i);
3236         y_map[i].z=(MagickRealType) (2.2179000f*(1.0f*(float) i-(double)
3237           ScaleQuantumToMap(ScaleCharToQuantum(156))));
3238         z_map[i].z=(MagickRealType) 0.0000000f;
3239       }
3240       break;
3241     }
3242     case YIQColorspace:
3243     {
3244       /*
3245         Initialize YIQ tables:
3246
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
3250
3251         I and Q, normally -0.5 through 0.5, must be normalized to the range 0
3252         through QuantumRange.
3253       */
3254 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3255       #pragma omp parallel for schedule(static,4) \
3256         magick_threads(image,image,1,1)
3257 #endif
3258       for (i=0; i <= (ssize_t) MaxMap; i++)
3259       {
3260         x_map[i].x=1.0f*(float) i;
3261         y_map[i].x=0.5f*0.9562957197589482261f*(2.00000f*(float) i-MaxMap);
3262         z_map[i].x=0.5f*0.6210244164652610754f*(2.00000f*(float) i-MaxMap);
3263         x_map[i].y=1.0f*(float) i;
3264         y_map[i].y=0.5f*(-0.2721220993185104464f)*(2.00000f*(float) i-MaxMap);
3265         z_map[i].y=0.5f*(-0.6473805968256950427f)*(2.00000f*(float) i-MaxMap);
3266         x_map[i].z=1.0f*(float) i;
3267         y_map[i].z=0.5f*(-1.1069890167364901945f)*(2.00000f*(float) i-MaxMap);
3268         z_map[i].z=0.5f*1.7046149983646481374f*(2.00000f*(float) i-MaxMap);
3269       }
3270       break;
3271     }
3272     case YPbPrColorspace:
3273     {
3274       /*
3275         Initialize YPbPr tables:
3276
3277           R = Y            +1.402000*C2
3278           G = Y-0.344136*C1+0.714136*C2
3279           B = Y+1.772000*C1
3280
3281         Pb and Pr, normally -0.5 through 0.5, must be normalized to the range 0
3282         through QuantumRange.
3283       */
3284 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3285       #pragma omp parallel for schedule(static,4) \
3286         magick_threads(image,image,1,1)
3287 #endif
3288       for (i=0; i <= (ssize_t) MaxMap; i++)
3289       {
3290         x_map[i].x=0.99999999999914679361f*(float) i;
3291         y_map[i].x=(-1.2188941887145875e-06f)*(2.0f*(float) i-MaxMap);
3292         z_map[i].x=0.5f*1.4019995886561440468f*(2.0f*(float) i-MaxMap);
3293         x_map[i].y=0.99999975910502514331f*(float) i;
3294         y_map[i].y=0.5f*(-0.34413567816504303521f)*(2.0f*(float) i-MaxMap);
3295         z_map[i].y=0.5f*(-0.71413649331646789076f)*(2.0f*(float) i-MaxMap);
3296         x_map[i].z=1.00000124040004623180f*(float) i;
3297         y_map[i].z=0.5f*1.77200006607230409200f*(2.0f*(float) i-MaxMap);
3298         z_map[i].z=2.1453384174593273e-06f*(2.0f*(float) i-MaxMap);
3299       }
3300       break;
3301     }
3302     case YUVColorspace:
3303     {
3304       /*
3305         Initialize YUV tables:
3306
3307           R = Y         +1.13983*V
3308           G = Y-0.39464*U-0.58060*V
3309           B = Y+2.03211*U
3310
3311         U and V, normally -0.5 through 0.5, must be normalized to the range 0
3312         through QuantumRange.
3313       */
3314 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3315       #pragma omp parallel for schedule(static,4) \
3316         magick_threads(image,image,1,1)
3317 #endif
3318       for (i=0; i <= (ssize_t) MaxMap; i++)
3319       {
3320         x_map[i].x=1.0f*(float) i;
3321         y_map[i].x=(-3.945707070708279e-05f)*(2.0f*(float) i-MaxMap);
3322         z_map[i].x=0.5f*1.1398279671717170825f*(2.0f*(float) i-MaxMap);
3323         x_map[i].y=1.0f*(float) i;
3324         y_map[i].y=0.5f*(-0.3946101641414141437f)*(2.0f*(float) i-MaxMap);
3325         z_map[i].y=0.5f*(-0.5805003156565656797f)*(2.0f*(float) i-MaxMap);
3326         x_map[i].z=1.0f*(float) i;
3327         y_map[i].z=0.5f*2.0319996843434342537f*(2.0f*(float) i-MaxMap);
3328         z_map[i].z=(-4.813762626262513e-04)*(2.0f*(float) i-MaxMap);
3329       }
3330       break;
3331     }
3332     default:
3333     {
3334       /*
3335         Linear conversion tables.
3336       */
3337 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3338       #pragma omp parallel for schedule(static,4) \
3339         magick_threads(image,image,1,1)
3340 #endif
3341       for (i=0; i <= (ssize_t) MaxMap; i++)
3342       {
3343         x_map[i].x=(MagickRealType) (1.0*(float) 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*(float) 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*(float) i);
3352       }
3353       break;
3354     }
3355   }
3356   /*
3357     Convert to sRGB.
3358   */
3359   switch (image->storage_class)
3360   {
3361     case DirectClass:
3362     default:
3363     {
3364       /*
3365         Convert DirectClass image.
3366       */
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)
3371 #endif
3372       for (y=0; y < (ssize_t) image->rows; y++)
3373       {
3374         MagickBooleanType
3375           sync;
3376
3377         PixelInfo
3378           pixel;
3379
3380         register ssize_t
3381           x;
3382
3383         register Quantum
3384           *restrict q;
3385
3386         if (status == MagickFalse)
3387           continue;
3388         q=GetCacheViewAuthenticPixels(image_view,0,y,image->columns,1,
3389           exception);
3390         if (q == (Quantum *) NULL)
3391           {
3392             status=MagickFalse;
3393             continue;
3394           }
3395         for (x=0; x < (ssize_t) image->columns; x++)
3396         {
3397           register size_t
3398             blue,
3399             green,
3400             red;
3401
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)
3409             {
3410               pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0f*pixel.red/
3411                 (double) MaxMap)];
3412               pixel.green=QuantumRange*YCCMap[RoundToYCC(1024.0f*pixel.green/
3413                 (double) MaxMap)];
3414               pixel.blue=QuantumRange*YCCMap[RoundToYCC(1024.0f*pixel.blue/
3415                 (double) MaxMap)];
3416             }
3417           else
3418             {
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));
3425             }
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);
3430         }
3431         sync=SyncCacheViewAuthenticPixels(image_view,exception);
3432         if (sync == MagickFalse)
3433           status=MagickFalse;
3434         if (image->progress_monitor != (MagickProgressMonitor) NULL)
3435           {
3436             MagickBooleanType
3437               proceed;
3438
3439 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3440             #pragma omp critical (MagickCore_TransformsRGBImage)
3441 #endif
3442             proceed=SetImageProgress(image,TransformsRGBImageTag,progress++,
3443               image->rows);
3444             if (proceed == MagickFalse)
3445               status=MagickFalse;
3446           }
3447       }
3448       image_view=DestroyCacheView(image_view);
3449       break;
3450     }
3451     case PseudoClass:
3452     {
3453       /*
3454         Convert PseudoClass image.
3455       */
3456 #if defined(MAGICKCORE_OPENMP_SUPPORT)
3457       #pragma omp parallel for schedule(static,4) shared(status) \
3458         magick_threads(image,image,1,1)
3459 #endif
3460       for (i=0; i < (ssize_t) image->colors; i++)
3461       {
3462         PixelInfo
3463           pixel;
3464
3465         register size_t
3466           blue,
3467           green,
3468           red;
3469
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)
3477           {
3478             pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0f*pixel.red/
3479               (double) MaxMap)];
3480             pixel.green=QuantumRange*YCCMap[RoundToYCC(1024.0f*pixel.green/
3481               (double) MaxMap)];
3482             pixel.blue=QuantumRange*YCCMap[RoundToYCC(1024.0f*pixel.blue/
3483               (double) MaxMap)];
3484           }
3485         else
3486           {
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));
3493           }
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);
3497       }
3498       (void) SyncImage(image,exception);
3499       break;
3500     }
3501   }
3502   /*
3503     Relinquish resources.
3504   */
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);
3510   return(MagickTrue);
3511 }