root / ImageMagick / trunk / magick / colorspace.c

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%     CCCC   OOO   L       OOO   RRRR   SSSSS  PPPP    AAA    CCCC  EEEEE     %
%    C      O   O  L      O   O  R   R  SS     P   P  A   A  C      E         %
%    C      O   O  L      O   O  RRRR    SSS   PPPP   AAAAA  C      EEE       %
%    C      O   O  L      O   O  R R       SS  P      A   A  C      E         %
%     CCCC   OOO   LLLLL   OOO   R  R   SSSSS  P      A   A   CCCC  EEEEE     %
%                                                                             %
%                                                                             %
%                     MagickCore Image Colorspace Methods                     %
%                                                                             %
%                              Software Design                                %
%                                John Cristy                                  %
%                                 July 1992                                   %
%                                                                             %
%                                                                             %
%  Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization      %
%  dedicated to making software imaging solutions freely available.           %
%                                                                             %
%  You may not use this file except in compliance with the License.  You may  %
%  obtain a copy of the License at                                            %
%                                                                             %
%    http://www.imagemagick.org/script/license.php                            %
%                                                                             %
%  Unless required by applicable law or agreed to in writing, software        %
%  distributed under the License is distributed on an "AS IS" BASIS,          %
%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
%  See the License for the specific language governing permissions and        %
%  limitations under the License.                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/

/*
  Include declarations.
*/
#include "magick/studio.h"
#include "magick/property.h"
#include "magick/cache.h"
#include "magick/cache-view.h"
#include "magick/color.h"
#include "magick/color-private.h"
#include "magick/colorspace.h"
#include "magick/colorspace-private.h"
#include "magick/exception.h"
#include "magick/exception-private.h"
#include "magick/image.h"
#include "magick/image-private.h"
#include "magick/gem.h"
#include "magick/memory_.h"
#include "magick/monitor.h"
#include "magick/monitor-private.h"
#include "magick/pixel-private.h"
#include "magick/quantize.h"
#include "magick/quantum.h"
#include "magick/string_.h"
#include "magick/utility.h"

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
+     R G B T r a n s f o r m I m a g e                                       %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  RGBTransformImage() converts the reference image from RGB to an alternate
%  colorspace.  The transformation matrices are not the standard ones: the
%  weights are rescaled to normalized the range of the transformed values to
%  be [0..QuantumRange].
%
%  The format of the RGBTransformImage method is:
%
%      MagickBooleanType RGBTransformImage(Image *image,
%        const ColorspaceType colorspace)
%
%  A description of each parameter follows:
%
%    o image: the image.
%
%    o colorspace: the colorspace to transform the image to.
%
*/

static inline void ConvertRGBToXYZ(const Quantum red,const Quantum green,
  const Quantum blue,double *X,double *Y,double *Z)
{
  double
    b,
    g,
    r;

  assert(X != (double *) NULL);
  assert(Y != (double *) NULL);
  assert(Z != (double *) NULL);
  r=QuantumScale*red;
  g=QuantumScale*green;
  b=QuantumScale*blue;
  *X=0.4124240*r+0.3575790*g+0.1804640*b;
  *Y=0.2126560*r+0.7151580*g+0.0721856*b;
  *Z=0.0193324*r+0.1191930*g+0.9504440*b;
}

static inline void ConvertXYZToLab(const double X,const double Y,const double Z,
  double *L,double *a,double *b)
{
  double
    x,
    y,
    z;

  assert(L != (double *) NULL);
  assert(a != (double *) NULL);
  assert(b != (double *) NULL);
  x=X/0.9504559271;
  if (x > (216/24389.0))
    x=pow(x,1.0/3.0);
  else 
    x=(7.787*x)+(16.0/116.0);
  y=Y/1.00000;
  if (y > (216/24389.0))
    y=pow(y,1.0/3.0);
  else
    y=(7.787*y)+(16.0/116.0);
  z=Z/1.0890577508;
  if (z > (216/24389.0))
    z=pow(z,1.0/3.0);
  else
    z=(7.787*z)+(16.0/116.0);
  *L=0.5*((1.160*y)-0.160+1.0);
  *a=0.5*(5.000*(x-y)+1.0);
  *b=0.5*(2.000*(y-z)+1.0);
}

MagickExport MagickBooleanType RGBTransformImage(Image *image,
  const ColorspaceType colorspace)
{
#define RGBTransformImageTag  "RGBTransform/Image"

  long
    y;

  MagickBooleanType
    proceed;

  PrimaryInfo
    primary_info,
    *x_map,
    *y_map,
    *z_map;

  register long
    i;

  ViewInfo
    **image_view;

  volatile MagickBooleanType
    status;

  assert(image != (Image *) NULL);
  assert(image->signature == MagickSignature);
  if (image->debug != MagickFalse)
    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
  assert(colorspace != RGBColorspace);
  assert(colorspace != TransparentColorspace);
  assert(colorspace != UndefinedColorspace);
  switch (image->colorspace)
  {
    case GRAYColorspace:
    case Rec601LumaColorspace:
    case Rec709LumaColorspace:
    case RGBColorspace:
    case TransparentColorspace:
      break;
    default:
    {
      (void) SetImageColorspace(image,image->colorspace);
      break;
    }
  }
  image->colorspace=colorspace;
  status=MagickTrue;
  switch (colorspace)
  {
    case CMYColorspace:
    {
      /*
        Convert RGB to CMY colorspace.
      */
      if (image->storage_class == PseudoClass)
        {
          if (SyncImage(image) == MagickFalse)
            return(MagickFalse);
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
            return(MagickFalse);
        }
      image_view=AcquireCacheViewThreadSet(image);
      #pragma omp parallel for schedule(static,64)
      for (y=0; y < (long) image->rows; y++)
      {
        register long
          id,
          x;

        register PixelPacket
          *q;

        if (status == MagickFalse)
          continue;
        id=GetCacheViewThreadId();
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
        if (q == (PixelPacket *) NULL)
          {
            status=MagickFalse;
            continue;
          }
        for (x=0; x < (long) image->columns; x++)
        {
          q->red=RoundToQuantum((MagickRealType) (QuantumRange-q->red));
          q->green=RoundToQuantum((MagickRealType) (QuantumRange-q->green));
          q->blue=RoundToQuantum((MagickRealType) (QuantumRange-q->blue));
          q++;
        }
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
          status=MagickFalse;
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      image->type=image->matte == MagickFalse ? ColorSeparationType :
        ColorSeparationMatteType;
      return(status);
    }
    case CMYKColorspace:
    {
      MagickPixelPacket
        zero;

      /*
        Convert RGB to CMYK colorspace.
      */
      if (image->storage_class == PseudoClass)
        {
          if (SyncImage(image) == MagickFalse)
            return(MagickFalse);
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
            return(MagickFalse);
        }
      GetMagickPixelPacket(image,&zero);
      image_view=AcquireCacheViewThreadSet(image);
      #pragma omp parallel for schedule(static,64)
      for (y=0; y < (long) image->rows; y++)
      {
        MagickPixelPacket
          pixel;

        register IndexPacket
          *indexes;

        register long
          id,
          x;

        register PixelPacket
          *q;

        if (status == MagickFalse)
          continue;
        id=GetCacheViewThreadId();
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
        if (q == (PixelPacket *) NULL)
          {
            status=MagickFalse;
            continue;
          }
        indexes=GetCacheViewIndexes(image_view[id]);
        pixel=zero;
        for (x=0; x < (long) image->columns; x++)
        {
          SetMagickPixelPacket(image,q,indexes+x,&pixel);
          ConvertRGBToCMYK(&pixel);
          SetPixelPacket(image,&pixel,q,indexes+x);
          q++;
        }
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
          status=MagickFalse;
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      image->type=image->matte == MagickFalse ? ColorSeparationType :
        ColorSeparationMatteType;
      return(status);
    }
    case HSBColorspace:
    {
      /*
        Transform image from RGB to HSB.
      */
      if (image->storage_class == PseudoClass)
        {
          if (SyncImage(image) == MagickFalse)
            return(MagickFalse);
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
            return(MagickFalse);
        }
      image_view=AcquireCacheViewThreadSet(image);
      #pragma omp parallel for schedule(static,64)
      for (y=0; y < (long) image->rows; y++)
      {
        double
          brightness,
          hue,
          saturation;

        register long
          id,
          x;

        register PixelPacket
          *q;

        if (status == MagickFalse)
          continue;
        id=GetCacheViewThreadId();
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
        if (q == (PixelPacket *) NULL)
          {
            status=MagickFalse;
            continue;
          }
        hue=0.0;
        saturation=0.0;
        brightness=0.0;
        for (x=0; x < (long) image->columns; x++)
        {
          ConvertRGBToHSB(q->red,q->green,q->blue,&hue,&saturation,&brightness);
          q->red=RoundToQuantum((MagickRealType) QuantumRange*hue);
          q->green=RoundToQuantum((MagickRealType) QuantumRange*saturation);
          q->blue=RoundToQuantum((MagickRealType) QuantumRange*brightness);
          q++;
        }
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
          status=MagickFalse;
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      return(status);
    }
    case HSLColorspace:
    {
      /*
        Transform image from RGB to HSL.
      */
      if (image->storage_class == PseudoClass)
        {
          if (SyncImage(image) == MagickFalse)
            return(MagickFalse);
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
            return(MagickFalse);
        }
      image_view=AcquireCacheViewThreadSet(image);
      #pragma omp parallel for schedule(static,64)
      for (y=0; y < (long) image->rows; y++)
      {
        double
          hue,
          lightness,
          saturation;

        register long
          id,
          x;

        register PixelPacket
          *q;

        if (status == MagickFalse)
          continue;
        id=GetCacheViewThreadId();
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
        if (q == (PixelPacket *) NULL)
          {
            status=MagickFalse;
            continue;
          }
        hue=0.0;
        saturation=0.0;
        lightness=0.0;
        for (x=0; x < (long) image->columns; x++)
        {
          ConvertRGBToHSL(q->red,q->green,q->blue,&hue,&saturation,&lightness);
          q->red=RoundToQuantum((MagickRealType) QuantumRange*hue);
          q->green=RoundToQuantum((MagickRealType) QuantumRange*saturation);
          q->blue=RoundToQuantum((MagickRealType) QuantumRange*lightness);
          q++;
        }
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
          status=MagickFalse;
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      return(status);
    }
    case HWBColorspace:
    {
      /*
        Transform image from RGB to HWB.
      */
      if (image->storage_class == PseudoClass)
        {
          if (SyncImage(image) == MagickFalse)
            return(MagickFalse);
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
            return(MagickFalse);
        }
      image_view=AcquireCacheViewThreadSet(image);
      #pragma omp parallel for schedule(static,64)
      for (y=0; y < (long) image->rows; y++)
      {
        double
          blackness,
          hue,
          whiteness;

        register long
          id,
          x;

        register PixelPacket
          *q;

        if (status == MagickFalse)
          continue;
        id=GetCacheViewThreadId();
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
        if (q == (PixelPacket *) NULL)
          {
            status=MagickFalse;
            continue;
          }
        hue=0.0;
        whiteness=0.0;
        blackness=0.0;
        for (x=0; x < (long) image->columns; x++)
        {
          ConvertRGBToHWB(q->red,q->green,q->blue,&hue,&whiteness,&blackness);
          q->red=RoundToQuantum((MagickRealType) QuantumRange*hue);
          q->green=RoundToQuantum((MagickRealType) QuantumRange*whiteness);
          q->blue=RoundToQuantum((MagickRealType) QuantumRange*blackness);
          q++;
        }
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
          status=MagickFalse;
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      return(status);
    }
    case LabColorspace:
    {
      /*
        Transform image from RGB to Lab.
      */
      if (image->storage_class == PseudoClass)
        {
          if (SyncImage(image) == MagickFalse)
            return(MagickFalse);
          if (SetImageStorageClass(image,DirectClass) == MagickFalse)
            return(MagickFalse);
        }
      image_view=AcquireCacheViewThreadSet(image);
      #pragma omp parallel for schedule(static,64)
      for (y=0; y < (long) image->rows; y++)
      {
        double
          a,
          b,
          L,
          X,
          Y,
          Z;

        register long
          id,
          x;

        register PixelPacket
          *q;

        if (status == MagickFalse)
          continue;
        id=GetCacheViewThreadId();
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
        if (q == (PixelPacket *) NULL)
          {
            status=MagickFalse;
            continue;
          }
        L=0.0;
        a=0.0;
        b=0.0;
        X=0.0;
        Y=0.0;
        Z=0.0;
        for (x=0; x < (long) image->columns; x++)
        {
          ConvertRGBToXYZ(q->red,q->green,q->blue,&X,&Y,&Z);
          ConvertXYZToLab(X,Y,Z,&L,&a,&b);
          q->red=RoundToQuantum((MagickRealType) QuantumRange*L);
          q->green=RoundToQuantum((MagickRealType) QuantumRange*a);
          q->blue=RoundToQuantum((MagickRealType) QuantumRange*b);
          q++;
        }
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
          status=MagickFalse;
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      return(status);
    }
    case LogColorspace:
    {
#define ReferenceBlack  95.0
#define ReferenceWhite  685.0
#define DisplayGamma  (1.0/1.7)

      const char
        *value;

      double
        black,
        density,
        gamma,
        reference_black,
        reference_white;

      Quantum
        *logmap;

      /*
        Transform RGB to Log colorspace.
      */
      density=2.03728;
      gamma=DisplayGamma;
      value=GetImageProperty(image,"gamma");
      if (value != (const char *) NULL)
        gamma=1.0/atof(value) != 0.0 ? atof(value) : 1.0;
      reference_black=ReferenceBlack;
      value=GetImageProperty(image,"reference-black");
      if (value != (const char *) NULL)
        reference_black=atof(value);
      reference_white=ReferenceWhite;
      value=GetImageProperty(image,"reference-white");
      if (value != (const char *) NULL)
        reference_white=atof(value);
      logmap=(Quantum *) AcquireQuantumMemory((size_t) MaxMap+1UL,
        sizeof(*logmap));
      if (logmap == (Quantum *) NULL)
        ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
          image->filename);
      black=pow(10.0,(reference_black-reference_white)*(gamma/density)*
        0.002/0.6);
      for (i=0; i <= (long) MaxMap; i++)
        logmap[i]=ScaleMapToQuantum((MagickRealType) (MaxMap*(reference_white+
          log10(black+((double) i/MaxMap)*(1.0-black))/((gamma/density)*
          0.002/0.6))/1024.0+0.5));
      image_view=AcquireCacheViewThreadSet(image);
      #pragma omp parallel for schedule(static,64)
      for (y=0; y < (long) image->rows; y++)
      {
        register long
          id,
          x;

        register PixelPacket
          *q;

        if (status == MagickFalse)
          continue;
        id=GetCacheViewThreadId();
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
        if (q == (PixelPacket *) NULL)
          {
            status=MagickFalse;
            continue;
          }
        for (x=(long) image->columns; x != 0; x--)
        {
          q->red=logmap[ScaleQuantumToMap(q->red)];
          q->green=logmap[ScaleQuantumToMap(q->green)];
          q->blue=logmap[ScaleQuantumToMap(q->blue)];
          q++;
        }
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
          status=MagickFalse;
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      logmap=(Quantum *) RelinquishMagickMemory(logmap);
      return(status);
    }
    default:
      break;
  }
  /*
    Allocate the tables.
  */
  x_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
    sizeof(*x_map));
  y_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
    sizeof(*y_map));
  z_map=(PrimaryInfo *) AcquireQuantumMemory((size_t) MaxMap+1UL,
    sizeof(*z_map));
  if ((x_map == (PrimaryInfo *) NULL) || (y_map == (PrimaryInfo *) NULL) ||
      (z_map == (PrimaryInfo *) NULL))
    ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
      image->filename);
  (void) ResetMagickMemory(&primary_info,0,sizeof(primary_info));
  switch (colorspace)
  {
    case OHTAColorspace:
    {
      /*
        Initialize OHTA tables:

          I1 = 0.33333*R+0.33334*G+0.33333*B
          I2 = 0.50000*R+0.00000*G-0.50000*B
          I3 =-0.25000*R+0.50000*G-0.25000*B

        I and Q, normally -0.5 through 0.5, are normalized to the range 0
        through QuantumRange.
      */
      primary_info.y=(double) (MaxMap+1.0)/2.0;
      primary_info.z=(double) (MaxMap+1.0)/2.0;
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.33333*i;
        y_map[i].x=0.33334*i;
        z_map[i].x=0.33333*i;
        x_map[i].y=0.50000*i;
        y_map[i].y=0.00000*i;
        z_map[i].y=(-0.50000)*i;
        x_map[i].z=(-0.25000)*i;
        y_map[i].z=0.50000*i;
        z_map[i].z=(-0.25000)*i;
      }
      break;
    }
    case Rec601LumaColorspace:
    case GRAYColorspace:
    {
      /*
        Initialize Rec601 luma tables:

          G = 0.29900*R+0.58700*G+0.11400*B
      */
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.29900*i;
        y_map[i].x=0.58700*i;
        z_map[i].x=0.11400*i;
        x_map[i].y=0.29900*i;
        y_map[i].y=0.58700*i;
        z_map[i].y=0.11400*i;
        x_map[i].z=0.29900*i;
        y_map[i].z=0.58700*i;
        z_map[i].z=0.11400*i;
      }
      image->type=GrayscaleType;
      break;
    }
    case Rec601YCbCrColorspace:
    case YCbCrColorspace:
    {
      /*
        Initialize YCbCr tables (ITU-R BT.601):

          Y =  0.299000*R+0.587000*G+0.114000*B
          Cb= -0.168736*R-0.331264*G+0.500000*B
          Cr=  0.500000*R-0.418688*G-0.081312*B

        Cb and Cr, normally -0.5 through 0.5, are normalized to the range 0
        through QuantumRange.
      */
      primary_info.y=(double) (MaxMap+1.0)/2.0;
      primary_info.z=(double) (MaxMap+1.0)/2.0;
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.299000*i;
        y_map[i].x=0.587000*i;
        z_map[i].x=0.114000*i;
        x_map[i].y=(-0.168730)*i;
        y_map[i].y=(-0.331264)*i;
        z_map[i].y=0.500000*i;
        x_map[i].z=0.500000*i;
        y_map[i].z=(-0.418688)*i;
        z_map[i].z=(-0.081312)*i;
      }
      break;
    }
    case Rec709LumaColorspace:
    {
      /*
        Initialize Rec709 luma tables:

          G = 0.21260*R+0.71520*G+0.07220*B
      */
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.21260*i;
        y_map[i].x=0.71520*i;
        z_map[i].x=0.07220*i;
        x_map[i].y=0.21260*i;
        y_map[i].y=0.71520*i;
        z_map[i].y=0.07220*i;
        x_map[i].z=0.21260*i;
        y_map[i].z=0.71520*i;
        z_map[i].z=0.07220*i;
      }
      break;
    }
    case Rec709YCbCrColorspace:
    {
      /*
        Initialize YCbCr tables (ITU-R BT.709):

          Y =  0.212600*R+0.715200*G+0.072200*B
          Cb= -0.114572*R-0.385428*G+0.500000*B
          Cr=  0.500000*R-0.454153*G-0.045847*B

        Cb and Cr, normally -0.5 through 0.5, are normalized to the range 0
        through QuantumRange.
      */
      primary_info.y=(double) (MaxMap+1.0)/2.0;
      primary_info.z=(double) (MaxMap+1.0)/2.0;
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.212600*i;
        y_map[i].x=0.715200*i;
        z_map[i].x=0.072200*i;
        x_map[i].y=(-0.114572)*i;
        y_map[i].y=(-0.385428)*i;
        z_map[i].y=0.500000*i;
        x_map[i].z=0.500000*i;
        y_map[i].z=(-0.454153)*i;
        z_map[i].z=(-0.045847)*i;
      }
      break;
    }
    case sRGBColorspace:
    {
      /*
        Linear RGB to nonlinear sRGB (http://www.w3.org/Graphics/Color/sRGB):

          R = 1.0*R+0.0*G+0.0*B
          G = 0.0*R+0.1*G+0.0*B
          B = 0.0*R+0.0*G+1.0*B
      */
      for (i=0; i <= (long) MaxMap; i++)
      {
        double
          v;

        v=(double) i/MaxMap;
        if (((double) i/MaxMap) <= 0.03928)
          v/=12.92;
        else
          v=(double) MaxMap*pow((((double) i/MaxMap)+0.055)/1.055,2.4);
        x_map[i].x=1.0*v;
        y_map[i].x=0.0*v;
        z_map[i].x=0.0*v;
        x_map[i].y=0.0*v;
        y_map[i].y=1.0*v;
        z_map[i].y=0.0*v;
        x_map[i].z=0.0*v;
        y_map[i].z=0.0*v;
        z_map[i].z=1.0*v;
      }
      break;
    }
    case XYZColorspace:
    {
      /*
        Initialize CIE XYZ tables (ITU-R 709 RGB):

          X = 0.4124240*R+0.3575790*G+0.1804640*B
          Y = 0.2126560*R+0.7151580*G+0.0721856*B
          Z = 0.0193324*R+0.1191930*G+0.9504440*B
      */
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.4124240*i;
        y_map[i].x=0.3575790*i;
        z_map[i].x=0.1804640*i;
        x_map[i].y=0.2126560*i;
        y_map[i].y=0.7151580*i;
        z_map[i].y=0.0721856*i;
        x_map[i].z=0.0193324*i;
        y_map[i].z=0.1191930*i;
        z_map[i].z=0.9504440*i;
      }
      break;
    }
    case YCCColorspace:
    {
      /*
        Initialize YCC tables:

          Y =  0.29900*R+0.58700*G+0.11400*B
          C1= -0.29900*R-0.58700*G+0.88600*B
          C2=  0.70100*R-0.58700*G-0.11400*B

        YCC is scaled by 1.3584.  C1 zero is 156 and C2 is at 137.
      */
      primary_info.y=(double) ScaleQuantumToMap(ScaleCharToQuantum(156));
      primary_info.z=(double) ScaleQuantumToMap(ScaleCharToQuantum(137));
      for (i=0; i <= (long) (0.018*MaxMap); i++)
      {
        x_map[i].x=0.003962014134275617*i;
        y_map[i].x=0.007778268551236748*i;
        z_map[i].x=0.001510600706713781*i;
        x_map[i].y=(-0.002426619775463276)*i;
        y_map[i].y=(-0.004763965913702149)*i;
        z_map[i].y=0.007190585689165425*i;
        x_map[i].z=0.006927257754597858*i;
        y_map[i].z=(-0.005800713697502058)*i;
        z_map[i].z=(-0.0011265440570958)*i;
      }
      for ( ; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.2201118963486454*(1.099*i-0.099);
        y_map[i].x=0.4321260306242638*(1.099*i-0.099);
        z_map[i].x=0.08392226148409894*(1.099*i-0.099);
        x_map[i].y=(-0.1348122097479598)*(1.099*i-0.099);
        y_map[i].y=(-0.2646647729834528)*(1.099*i-0.099);
        z_map[i].y=0.3994769827314126*(1.099*i-0.099);
        x_map[i].z=0.3848476530332144*(1.099*i-0.099);
        y_map[i].z=(-0.3222618720834477)*(1.099*i-0.099);
        z_map[i].z=(-0.06258578094976668)*(1.099*i-0.099);
      }
      break;
    }
    case YIQColorspace:
    {
      /*
        Initialize YIQ tables:

          Y = 0.29900*R+0.58700*G+0.11400*B
          I = 0.59600*R-0.27400*G-0.32200*B
          Q = 0.21100*R-0.52300*G+0.31200*B

        I and Q, normally -0.5 through 0.5, are normalized to the range 0
        through QuantumRange.
      */
      primary_info.y=(double) (MaxMap+1.0)/2.0;
      primary_info.z=(double) (MaxMap+1.0)/2.0;
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.29900*i;
        y_map[i].x=0.58700*i;
        z_map[i].x=0.11400*i;
        x_map[i].y=0.59600*i;
        y_map[i].y=(-0.27400)*i;
        z_map[i].y=(-0.32200)*i;
        x_map[i].z=0.21100*i;
        y_map[i].z=(-0.52300)*i;
        z_map[i].z=0.31200*i;
      }
      break;
    }
    case YPbPrColorspace:
    {
      /*
        Initialize YPbPr tables (ITU-R BT.601):

          Y =  0.299000*R+0.587000*G+0.114000*B
          Pb= -0.168736*R-0.331264*G+0.500000*B
          Pr=  0.500000*R-0.418688*G-0.081312*B

        Pb and Pr, normally -0.5 through 0.5, are normalized to the range 0
        through QuantumRange.
      */
      primary_info.y=(double) (MaxMap+1.0)/2.0;
      primary_info.z=(double) (MaxMap+1.0)/2.0;
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.299000*i;
        y_map[i].x=0.587000*i;
        z_map[i].x=0.114000*i;
        x_map[i].y=(-0.168736)*i;
        y_map[i].y=(-0.331264)*i;
        z_map[i].y=0.500000*i;
        x_map[i].z=0.500000*i;
        y_map[i].z=(-0.418688)*i;
        z_map[i].z=(-0.081312)*i;
      }
      break;
    }
    case YUVColorspace:
    default:
    {
      /*
        Initialize YUV tables:

          Y =  0.29900*R+0.58700*G+0.11400*B
          U = -0.14740*R-0.28950*G+0.43690*B
          V =  0.61500*R-0.51500*G-0.10000*B

        U and V, normally -0.5 through 0.5, are normalized to the range 0
        through QuantumRange.  Note that U = 0.493*(B-Y), V = 0.877*(R-Y).
      */
      primary_info.y=(double) (MaxMap+1.0)/2.0;
      primary_info.z=(double) (MaxMap+1.0)/2.0;
      for (i=0; i <= (long) MaxMap; i++)
      {
        x_map[i].x=0.29900*i;
        y_map[i].x=0.58700*i;
        z_map[i].x=0.11400*i;
        x_map[i].y=(-0.14740)*i;
        y_map[i].y=(-0.28950)*i;
        z_map[i].y=0.43690*i;
        x_map[i].z=0.61500*i;
        y_map[i].z=(-0.51500)*i;
        z_map[i].z=(-0.10000)*i;
      }
      break;
    }
  }
  /*
    Convert from RGB.
  */
  switch (image->storage_class)
  {
    case DirectClass:
    default:
    {
      MagickPixelPacket
        zero;

      /*
        Convert DirectClass image.
      */
      GetMagickPixelPacket(image,&zero);
      image_view=AcquireCacheViewThreadSet(image);
      #pragma omp parallel for schedule(static,64)
      for (y=0; y < (long) image->rows; y++)
      {
        MagickPixelPacket
          pixel;

        register long
          id,
          x;

        register PixelPacket
          *q;

        if (status == MagickFalse)
          continue;
        id=GetCacheViewThreadId();
        q=GetCacheViewPixels(image_view[id],0,y,image->columns,1);
        if (q == (PixelPacket *) NULL)
          {
            status=MagickFalse;
            continue;
          }
        pixel=zero;
        for (x=0; x < (long) image->columns; x++)
        {
          pixel.red=x_map[ScaleQuantumToMap(q->red)].x+
            y_map[ScaleQuantumToMap(q->green)].x+
            z_map[ScaleQuantumToMap(q->blue)].x+primary_info.x;
          pixel.green=x_map[ScaleQuantumToMap(q->red)].y+
            y_map[ScaleQuantumToMap(q->green)].y+
            z_map[ScaleQuantumToMap(q->blue)].y+primary_info.y;
          pixel.blue=x_map[ScaleQuantumToMap(q->red)].z+
            y_map[ScaleQuantumToMap(q->green)].z+
            z_map[ScaleQuantumToMap(q->blue)].z+primary_info.z;
          q->red=ScaleMapToQuantum(pixel.red);
          q->green=ScaleMapToQuantum(pixel.green);
          q->blue=ScaleMapToQuantum(pixel.blue);
          q++;
        }
        if (SyncCacheViewPixels(image_view[id]) == MagickFalse)
          status=MagickFalse;
        proceed=SetImageProgress(image,RGBTransformImageTag,y,image->rows);
        if (proceed == MagickFalse)
          status=MagickFalse;
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      break;
    }
    case PseudoClass:
    {
      MagickPixelPacket
        zero;

      /*
        Convert PseudoClass image.
      */
      GetMagickPixelPacket(image,&zero);
      image_view=AcquireCacheViewThreadSet(image);
      for (i=0; i < (long) image->colors; i++)
      {
        MagickPixelPacket
          pixel;

        pixel=zero;
        pixel.red=x_map[ScaleQuantumToMap(image->colormap[i].red)].x+
          y_map[ScaleQuantumToMap(image->colormap[i].green)].x+
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].x+primary_info.x;
        pixel.green=x_map[ScaleQuantumToMap(image->colormap[i].red)].y+
          y_map[ScaleQuantumToMap(image->colormap[i].green)].y+
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].y+primary_info.y;
        pixel.blue=x_map[ScaleQuantumToMap(image->colormap[i].red)].z+
          y_map[ScaleQuantumToMap(image->colormap[i].green)].z+
          z_map[ScaleQuantumToMap(image->colormap[i].blue)].z+primary_info.z;
        image->colormap[i].red=ScaleMapToQuantum(pixel.red);
        image->colormap[i].green=ScaleMapToQuantum(pixel.green);
        image->colormap[i].blue=ScaleMapToQuantum(pixel.blue);
      }
      image_view=DestroyCacheViewThreadSet(image_view);
      (void) SyncImage(image);
      break;
    }
  }
  /*
    Relinquish resources.
  */
  z_map=(PrimaryInfo *) RelinquishMagickMemory(z_map);
  y_map=(PrimaryInfo *) RelinquishMagickMemory(y_map);
  x_map=(PrimaryInfo *) RelinquishMagickMemory(x_map);
  return(status);
}

/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                                                                             %
%                                                                             %
%                                                                             %
%   S e t I m a g e C o l o r s p a c e                                       %
%                                                                             %
%                                                                             %
%                                                                             %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%  SetImageColorspace() sets the colorspace member of the Image structure.
%
%  The format of the SetImageColorspace method is:
%
%      MagickBooleanType SetImageColorspace(Image *image,
%        const ColorspaceType colorspace)
%
%  A description of each parameter follows:
%
%    o image: the image.
%
%    o colorspace: the colorspace.
%
*/
MagickExport MagickBooleanType SetImageColorspace(Image *image,
  const ColorspaceType colorspace)
{
  MagickBooleanType
    status;

  assert(image != (Image *) NULL);