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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                      PPPP   IIIII  X   X  EEEEE  L                          %
   7 %                      P   P    I     X X   E      L                          %
   8 %                      PPPP     I      X    EEE    L                          %
   9 %                      P        I     X X   E      L                          %
  10 %                      P      IIIII  X   X  EEEEE  LLLLL                      %
  11 %                                                                             %
  12 %                  MagickCore Methods to Import/Export Pixels                 %
  13 %                                                                             %
  14 %                             Software Design                                 %
  15 %                               John Cristy                                   %
  16 %                               October 1998                                  %
  17 %                                                                             %
  18 %                                                                             %
  19 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  20 %  dedicated to making software imaging solutions freely available.           %
  21 %                                                                             %
  22 %  You may not use this file except in compliance with the License.  You may  %
  23 %  obtain a copy of the License at                                            %
  24 %                                                                             %
  25 %    http://www.imagemagick.org/script/license.php                            %
  26 %                                                                             %
  27 %  Unless required by applicable law or agreed to in writing, software        %
  28 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  29 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  30 %  See the License for the specific language governing permissions and        %
  31 %  limitations under the License.                                             %
  32 %                                                                             %
  33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  34 %
  35 %
  36 */
  37 \f
  38 /*
  39   Include declarations.
  40 */
  41 #include "MagickCore/studio.h"
  42 #include "MagickCore/property.h"
  43 #include "MagickCore/blob.h"
  44 #include "MagickCore/blob-private.h"
  45 #include "MagickCore/color-private.h"
  46 #include "MagickCore/draw.h"
  47 #include "MagickCore/exception.h"
  48 #include "MagickCore/exception-private.h"
  49 #include "MagickCore/cache.h"
  50 #include "MagickCore/constitute.h"
  51 #include "MagickCore/delegate.h"
  52 #include "MagickCore/geometry.h"
  53 #include "MagickCore/image-private.h"
  54 #include "MagickCore/list.h"
  55 #include "MagickCore/magick.h"
  56 #include "MagickCore/memory_.h"
  57 #include "MagickCore/monitor.h"
  58 #include "MagickCore/option.h"
  59 #include "MagickCore/pixel.h"
  60 #include "MagickCore/pixel-accessor.h"
  61 #include "MagickCore/quantum.h"
  62 #include "MagickCore/quantum-private.h"
  63 #include "MagickCore/resource_.h"
  64 #include "MagickCore/semaphore.h"
  65 #include "MagickCore/statistic.h"
  66 #include "MagickCore/stream.h"
  67 #include "MagickCore/string_.h"
  68 #include "MagickCore/transform.h"
  69 #include "MagickCore/utility.h"
  70 \f
  71 /*
  72   Define declarations.
  73 */
  74 #define LogPixelChannels(image) \
  75 { \
  76   register ssize_t \
  77     i; \
  78  \
  79   (void) LogMagickEvent(PixelEvent,GetMagickModule(),"%s[%.20g]", \
  80     image->filename,(double) image->number_channels); \
  81   for (i=0; i < (ssize_t) image->number_channels; i++) \
  82   { \
  83     char \
  84       traits[MaxTextExtent]; \
  85  \
  86     const char \
  87       *channel; \
  88  \
  89     switch (image->channel_map[i].channel) \
  90     { \
  91       case RedPixelChannel: \
  92       { \
  93         channel="red"; \
  94         if (image->colorspace == CMYKColorspace) \
  95           channel="cyan"; \
  96         if (image->colorspace == GRAYColorspace) \
  97           channel="gray"; \
  98         break; \
  99       } \
 100       case GreenPixelChannel: \
 101       { \
 102         channel="green"; \
 103         if (image->colorspace == CMYKColorspace) \
 104           channel="magenta"; \
 105         break; \
 106       } \
 107       case BluePixelChannel: \
 108       { \
 109         channel="blue"; \
 110         if (image->colorspace == CMYKColorspace) \
 111           channel="yellow"; \
 112         break; \
 113       } \
 114       case BlackPixelChannel: \
 115       { \
 116         channel="black"; \
 117         if (image->storage_class == PseudoClass) \
 118           channel="index"; \
 119         break; \
 120       } \
 121       case AlphaPixelChannel: \
 122       { \
 123         channel="alpha"; \
 124         break; \
 125       } \
 126       case MaskPixelChannel: \
 127       { \
 128         channel="mask"; \
 129         break; \
 130       } \
 131       default: \
 132       { \
 133         channel="undefined"; \
 134       } \
 135     } \
 136     *traits='\0'; \
 137     if ((image->channel_map[i].traits & UpdatePixelTrait) != 0) \
 138       (void) ConcatenateMagickString(traits,"update,",MaxTextExtent); \
 139     if ((image->channel_map[i].traits & BlendPixelTrait) != 0) \
 140       (void) ConcatenateMagickString(traits,"blend,",MaxTextExtent); \
 141     if ((image->channel_map[i].traits & CopyPixelTrait) != 0) \
 142       (void) ConcatenateMagickString(traits,"copy,",MaxTextExtent); \
 143     if (*traits == '\0') \
 144       (void) ConcatenateMagickString(traits,"undefined,",MaxTextExtent); \
 145     traits[strlen(traits)-1]='\0'; \
 146     (void) LogMagickEvent(PixelEvent,GetMagickModule(),"  %.20g: %s (%s)", \
 147       (double) i,channel,traits); \
 148   } \
 149 }
 150 \f
 151 /*
 152 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 153 %                                                                             %
 154 %                                                                             %
 155 %                                                                             %
 156 +   A c q u i r e P i x e l C h a n n e l M a p                               %
 157 %                                                                             %
 158 %                                                                             %
 159 %                                                                             %
 160 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 161 %
 162 %  AcquirePixelChannelMap() acquires a pixel component map.
 163 %
 164 %  The format of the AcquirePixelChannelMap() method is:
 165 %
 166 %      PixelChannelMap *AcquirePixelChannelMap(void)
 167 %
 168 */
 169 MagickExport PixelChannelMap *AcquirePixelChannelMap(void)
 170 {
 171   PixelChannelMap
 172     *channel_map;
 173
 174   register ssize_t
 175     i;
 176
 177   channel_map=(PixelChannelMap *) AcquireQuantumMemory(MaxPixelChannels,
 178     sizeof(*channel_map));
 179   if (channel_map == (PixelChannelMap *) NULL)
 180     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 181   (void) ResetMagickMemory(channel_map,0,MaxPixelChannels*sizeof(*channel_map));
 182   for (i=0; i < MaxPixelChannels; i++)
 183     channel_map[i].channel=(PixelChannel) i;
 184   return(channel_map);
 185 }
 186 \f
 187 /*
 188 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 189 %                                                                             %
 190 %                                                                             %
 191 %                                                                             %
 192 +   C l o n e P i x e l C h a n n e l M a p                                   %
 193 %                                                                             %
 194 %                                                                             %
 195 %                                                                             %
 196 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 197 %
 198 %  ClonePixelChannelMap() clones a pixel component map.
 199 %
 200 %  The format of the ClonePixelChannelMap() method is:
 201 %
 202 %      PixelChannelMap *ClonePixelChannelMap(PixelChannelMap *channel_map)
 203 %
 204 %  A description of each parameter follows:
 205 %
 206 %    o channel_map: the pixel component map.
 207 %
 208 */
 209 MagickExport PixelChannelMap *ClonePixelChannelMap(PixelChannelMap *channel_map)
 210 {
 211   PixelChannelMap
 212     *clone_map;
 213
 214   assert(channel_map != (PixelChannelMap *) NULL);
 215   clone_map=AcquirePixelChannelMap();
 216   if (clone_map == (PixelChannelMap *) NULL)
 217     return((PixelChannelMap *) NULL);
 218   (void) CopyMagickMemory(clone_map,channel_map,MaxPixelChannels*
 219     sizeof(*channel_map));
 220   return(clone_map);
 221 }
 222 \f
 223 /*
 224 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 225 %                                                                             %
 226 %                                                                             %
 227 %                                                                             %
 228 +   C l o n e P i x e l I n f o                                               %
 229 %                                                                             %
 230 %                                                                             %
 231 %                                                                             %
 232 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 233 %
 234 %  ClonePixelInfo() makes a duplicate of the given pixel info structure, or if
 235 %  pixel info is NULL, a new one.
 236 %
 237 %  The format of the ClonePixelInfo method is:
 238 %
 239 %      PixelInfo *ClonePixelInfo(const PixelInfo *pixel_info)
 240 %
 241 %  A description of each parameter follows:
 242 %
 243 %    o pixel_info: the pixel info.
 244 %
 245 */
 246 MagickExport PixelInfo *ClonePixelInfo(const PixelInfo *pixel)
 247 {
 248   PixelInfo
 249     *pixel_info;
 250
 251   pixel_info=(PixelInfo *) AcquireQuantumMemory(1,sizeof(*pixel_info));
 252   if (pixel_info == (PixelInfo *) NULL)
 253     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 254   *pixel_info=(*pixel);
 255   return(pixel_info);
 256 }
 257 \f
 258 /*
 259 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 260 %                                                                             %
 261 %                                                                             %
 262 %                                                                             %
 263 +   D e s t r o y P i x e l C h a n n e l M a p                               %
 264 %                                                                             %
 265 %                                                                             %
 266 %                                                                             %
 267 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 268 %
 269 %  DestroyPixelChannelMap() deallocates memory associated with the pixel
 270 %  channel map.
 271 %
 272 %  The format of the DestroyPixelChannelMap() method is:
 273 %
 274 %      PixelChannelMap *DestroyPixelChannelMap(PixelChannelMap *channel_map)
 275 %
 276 %  A description of each parameter follows:
 277 %
 278 %    o channel_map: the pixel component map.
 279 %
 280 */
 281 MagickExport PixelChannelMap *DestroyPixelChannelMap(
 282   PixelChannelMap *channel_map)
 283 {
 284   assert(channel_map != (PixelChannelMap *) NULL);
 285   channel_map=(PixelChannelMap *) RelinquishMagickMemory(channel_map);
 286   return((PixelChannelMap *) RelinquishMagickMemory(channel_map));
 287 }
 288 \f
 289 /*
 290 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 291 %                                                                             %
 292 %                                                                             %
 293 %                                                                             %
 294 %   E x p o r t I m a g e P i x e l s                                         %
 295 %                                                                             %
 296 %                                                                             %
 297 %                                                                             %
 298 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 299 %
 300 %  ExportImagePixels() extracts pixel data from an image and returns it to you.
 301 %  The method returns MagickTrue on success otherwise MagickFalse if an error is
 302 %  encountered.  The data is returned as char, short int, int, ssize_t, float,
 303 %  or double in the order specified by map.
 304 %
 305 %  Suppose you want to extract the first scanline of a 640x480 image as
 306 %  character data in red-green-blue order:
 307 %
 308 %      ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
 309 %
 310 %  The format of the ExportImagePixels method is:
 311 %
 312 %      MagickBooleanType ExportImagePixels(const Image *image,
 313 %        const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
 314 %        const size_t rows,const char *map,const StorageType type,
 315 %        void *pixels,ExceptionInfo *exception)
 316 %
 317 %  A description of each parameter follows:
 318 %
 319 %    o image: the image.
 320 %
 321 %    o x_offset,y_offset,columns,rows:  These values define the perimeter
 322 %      of a region of pixels you want to extract.
 323 %
 324 %    o map:  This string reflects the expected ordering of the pixel array.
 325 %      It can be any combination or order of R = red, G = green, B = blue,
 326 %      A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
 327 %      Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
 328 %      P = pad.
 329 %
 330 %    o type: Define the data type of the pixels.  Float and double types are
 331 %      normalized to [0..1] otherwise [0..QuantumRange].  Choose from these
 332 %      types: CharPixel, DoublePixel, FloatPixel, IntegerPixel, LongPixel,
 333 %      QuantumPixel, or ShortPixel.
 334 %
 335 %    o pixels: This array of values contain the pixel components as defined by
 336 %      map and type.  You must preallocate this array where the expected
 337 %      length varies depending on the values of width, height, map, and type.
 338 %
 339 %    o exception: return any errors or warnings in this structure.
 340 %
 341 */
 342 MagickExport MagickBooleanType ExportImagePixels(const Image *image,
 343   const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
 344   const size_t rows,const char *map,const StorageType type,void *pixels,
 345   ExceptionInfo *exception)
 346 {
 347   QuantumType
 348     *quantum_map;
 349
 350   register ssize_t
 351     i,
 352     x;
 353
 354   register const Quantum
 355     *p;
 356
 357   size_t
 358     length;
 359
 360   ssize_t
 361     y;
 362
 363   assert(image != (Image *) NULL);
 364   assert(image->signature == MagickSignature);
 365   if (image->debug != MagickFalse)
 366     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 367   length=strlen(map);
 368   quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
 369   if (quantum_map == (QuantumType *) NULL)
 370     {
 371       (void) ThrowMagickException(exception,GetMagickModule(),
 372         ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
 373       return(MagickFalse);
 374     }
 375   for (i=0; i < (ssize_t) length; i++)
 376   {
 377     switch (map[i])
 378     {
 379       case 'A':
 380       case 'a':
 381       {
 382         quantum_map[i]=AlphaQuantum;
 383         break;
 384       }
 385       case 'B':
 386       case 'b':
 387       {
 388         quantum_map[i]=BlueQuantum;
 389         break;
 390       }
 391       case 'C':
 392       case 'c':
 393       {
 394         quantum_map[i]=CyanQuantum;
 395         if (image->colorspace == CMYKColorspace)
 396           break;
 397         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 398         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 399           "ColorSeparatedImageRequired","`%s'",map);
 400         return(MagickFalse);
 401       }
 402       case 'g':
 403       case 'G':
 404       {
 405         quantum_map[i]=GreenQuantum;
 406         break;
 407       }
 408       case 'I':
 409       case 'i':
 410       {
 411         quantum_map[i]=IndexQuantum;
 412         break;
 413       }
 414       case 'K':
 415       case 'k':
 416       {
 417         quantum_map[i]=BlackQuantum;
 418         if (image->colorspace == CMYKColorspace)
 419           break;
 420         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 421         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 422           "ColorSeparatedImageRequired","`%s'",map);
 423         return(MagickFalse);
 424       }
 425       case 'M':
 426       case 'm':
 427       {
 428         quantum_map[i]=MagentaQuantum;
 429         if (image->colorspace == CMYKColorspace)
 430           break;
 431         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 432         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 433           "ColorSeparatedImageRequired","`%s'",map);
 434         return(MagickFalse);
 435       }
 436       case 'o':
 437       case 'O':
 438       {
 439         quantum_map[i]=OpacityQuantum;
 440         break;
 441       }
 442       case 'P':
 443       case 'p':
 444       {
 445         quantum_map[i]=UndefinedQuantum;
 446         break;
 447       }
 448       case 'R':
 449       case 'r':
 450       {
 451         quantum_map[i]=RedQuantum;
 452         break;
 453       }
 454       case 'Y':
 455       case 'y':
 456       {
 457         quantum_map[i]=YellowQuantum;
 458         if (image->colorspace == CMYKColorspace)
 459           break;
 460         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 461         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 462           "ColorSeparatedImageRequired","`%s'",map);
 463         return(MagickFalse);
 464       }
 465       default:
 466       {
 467         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 468         (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
 469           "UnrecognizedPixelMap","`%s'",map);
 470         return(MagickFalse);
 471       }
 472     }
 473   }
 474   switch (type)
 475   {
 476     case CharPixel:
 477     {
 478       register unsigned char
 479         *q;
 480
 481       q=(unsigned char *) pixels;
 482       if (LocaleCompare(map,"BGR") == 0)
 483         {
 484           for (y=0; y < (ssize_t) rows; y++)
 485           {
 486             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 487             if (p == (const Quantum *) NULL)
 488               break;
 489             for (x=0; x < (ssize_t) columns; x++)
 490             {
 491               *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
 492               *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
 493               *q++=ScaleQuantumToChar(GetPixelRed(image,p));
 494               p+=GetPixelChannels(image);
 495             }
 496           }
 497           break;
 498         }
 499       if (LocaleCompare(map,"BGRA") == 0)
 500         {
 501           for (y=0; y < (ssize_t) rows; y++)
 502           {
 503             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 504             if (p == (const Quantum *) NULL)
 505               break;
 506             for (x=0; x < (ssize_t) columns; x++)
 507             {
 508               *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
 509               *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
 510               *q++=ScaleQuantumToChar(GetPixelRed(image,p));
 511               *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
 512               p+=GetPixelChannels(image);
 513             }
 514           }
 515           break;
 516         }
 517       if (LocaleCompare(map,"BGRP") == 0)
 518         {
 519           for (y=0; y < (ssize_t) rows; y++)
 520           {
 521             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 522             if (p == (const Quantum *) NULL)
 523               break;
 524             for (x=0; x < (ssize_t) columns; x++)
 525             {
 526               *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
 527               *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
 528               *q++=ScaleQuantumToChar(GetPixelRed(image,p));
 529               *q++=ScaleQuantumToChar((Quantum) 0);
 530               p+=GetPixelChannels(image);
 531             }
 532           }
 533           break;
 534         }
 535       if (LocaleCompare(map,"I") == 0)
 536         {
 537           for (y=0; y < (ssize_t) rows; y++)
 538           {
 539             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 540             if (p == (const Quantum *) NULL)
 541               break;
 542             for (x=0; x < (ssize_t) columns; x++)
 543             {
 544               *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
 545               p+=GetPixelChannels(image);
 546             }
 547           }
 548           break;
 549         }
 550       if (LocaleCompare(map,"RGB") == 0)
 551         {
 552           for (y=0; y < (ssize_t) rows; y++)
 553           {
 554             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 555             if (p == (const Quantum *) NULL)
 556               break;
 557             for (x=0; x < (ssize_t) columns; x++)
 558             {
 559               *q++=ScaleQuantumToChar(GetPixelRed(image,p));
 560               *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
 561               *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
 562               p+=GetPixelChannels(image);
 563             }
 564           }
 565           break;
 566         }
 567       if (LocaleCompare(map,"RGBA") == 0)
 568         {
 569           for (y=0; y < (ssize_t) rows; y++)
 570           {
 571             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 572             if (p == (const Quantum *) NULL)
 573               break;
 574             for (x=0; x < (ssize_t) columns; x++)
 575             {
 576               *q++=ScaleQuantumToChar(GetPixelRed(image,p));
 577               *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
 578               *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
 579               *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
 580               p+=GetPixelChannels(image);
 581             }
 582           }
 583           break;
 584         }
 585       if (LocaleCompare(map,"RGBP") == 0)
 586         {
 587           for (y=0; y < (ssize_t) rows; y++)
 588           {
 589             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 590             if (p == (const Quantum *) NULL)
 591               break;
 592             for (x=0; x < (ssize_t) columns; x++)
 593             {
 594               *q++=ScaleQuantumToChar(GetPixelRed(image,p));
 595               *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
 596               *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
 597               *q++=ScaleQuantumToChar((Quantum) 0);
 598               p+=GetPixelChannels(image);
 599             }
 600           }
 601           break;
 602         }
 603       for (y=0; y < (ssize_t) rows; y++)
 604       {
 605         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 606         if (p == (const Quantum *) NULL)
 607           break;
 608         for (x=0; x < (ssize_t) columns; x++)
 609         {
 610           for (i=0; i < (ssize_t) length; i++)
 611           {
 612             *q=0;
 613             switch (quantum_map[i])
 614             {
 615               case RedQuantum:
 616               case CyanQuantum:
 617               {
 618                 *q=ScaleQuantumToChar(GetPixelRed(image,p));
 619                 break;
 620               }
 621               case GreenQuantum:
 622               case MagentaQuantum:
 623               {
 624                 *q=ScaleQuantumToChar(GetPixelGreen(image,p));
 625                 break;
 626               }
 627               case BlueQuantum:
 628               case YellowQuantum:
 629               {
 630                 *q=ScaleQuantumToChar(GetPixelBlue(image,p));
 631                 break;
 632               }
 633               case AlphaQuantum:
 634               {
 635                 *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
 636                 break;
 637               }
 638               case OpacityQuantum:
 639               {
 640                 *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
 641                 break;
 642               }
 643               case BlackQuantum:
 644               {
 645                 if (image->colorspace == CMYKColorspace)
 646                   *q=ScaleQuantumToChar(GetPixelBlack(image,p));
 647                 break;
 648               }
 649               case IndexQuantum:
 650               {
 651                 *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
 652                 break;
 653               }
 654               default:
 655                 break;
 656             }
 657             q++;
 658           }
 659           p+=GetPixelChannels(image);
 660         }
 661       }
 662       break;
 663     }
 664     case DoublePixel:
 665     {
 666       register double
 667         *q;
 668
 669       q=(double *) pixels;
 670       if (LocaleCompare(map,"BGR") == 0)
 671         {
 672           for (y=0; y < (ssize_t) rows; y++)
 673           {
 674             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 675             if (p == (const Quantum *) NULL)
 676               break;
 677             for (x=0; x < (ssize_t) columns; x++)
 678             {
 679               *q++=(double) (QuantumScale*GetPixelBlue(image,p));
 680               *q++=(double) (QuantumScale*GetPixelGreen(image,p));
 681               *q++=(double) (QuantumScale*GetPixelRed(image,p));
 682               p+=GetPixelChannels(image);
 683             }
 684           }
 685           break;
 686         }
 687       if (LocaleCompare(map,"BGRA") == 0)
 688         {
 689           for (y=0; y < (ssize_t) rows; y++)
 690           {
 691             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 692             if (p == (const Quantum *) NULL)
 693               break;
 694             for (x=0; x < (ssize_t) columns; x++)
 695             {
 696               *q++=(double) (QuantumScale*GetPixelBlue(image,p));
 697               *q++=(double) (QuantumScale*GetPixelGreen(image,p));
 698               *q++=(double) (QuantumScale*GetPixelRed(image,p));
 699               *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
 700               p+=GetPixelChannels(image);
 701             }
 702           }
 703           break;
 704         }
 705       if (LocaleCompare(map,"BGRP") == 0)
 706         {
 707           for (y=0; y < (ssize_t) rows; y++)
 708           {
 709             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 710             if (p == (const Quantum *) NULL)
 711               break;
 712             for (x=0; x < (ssize_t) columns; x++)
 713             {
 714               *q++=(double) (QuantumScale*GetPixelBlue(image,p));
 715               *q++=(double) (QuantumScale*GetPixelGreen(image,p));
 716               *q++=(double) (QuantumScale*GetPixelRed(image,p));
 717               *q++=0.0;
 718               p+=GetPixelChannels(image);
 719             }
 720           }
 721           break;
 722         }
 723       if (LocaleCompare(map,"I") == 0)
 724         {
 725           for (y=0; y < (ssize_t) rows; y++)
 726           {
 727             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 728             if (p == (const Quantum *) NULL)
 729               break;
 730             for (x=0; x < (ssize_t) columns; x++)
 731             {
 732               *q++=(double) (QuantumScale*GetPixelIntensity(image,p));
 733               p+=GetPixelChannels(image);
 734             }
 735           }
 736           break;
 737         }
 738       if (LocaleCompare(map,"RGB") == 0)
 739         {
 740           for (y=0; y < (ssize_t) rows; y++)
 741           {
 742             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 743             if (p == (const Quantum *) NULL)
 744               break;
 745             for (x=0; x < (ssize_t) columns; x++)
 746             {
 747               *q++=(double) (QuantumScale*GetPixelRed(image,p));
 748               *q++=(double) (QuantumScale*GetPixelGreen(image,p));
 749               *q++=(double) (QuantumScale*GetPixelBlue(image,p));
 750               p+=GetPixelChannels(image);
 751             }
 752           }
 753           break;
 754         }
 755       if (LocaleCompare(map,"RGBA") == 0)
 756         {
 757           for (y=0; y < (ssize_t) rows; y++)
 758           {
 759             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 760             if (p == (const Quantum *) NULL)
 761               break;
 762             for (x=0; x < (ssize_t) columns; x++)
 763             {
 764               *q++=(double) (QuantumScale*GetPixelRed(image,p));
 765               *q++=(double) (QuantumScale*GetPixelGreen(image,p));
 766               *q++=(double) (QuantumScale*GetPixelBlue(image,p));
 767               *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
 768               p+=GetPixelChannels(image);
 769             }
 770           }
 771           break;
 772         }
 773       if (LocaleCompare(map,"RGBP") == 0)
 774         {
 775           for (y=0; y < (ssize_t) rows; y++)
 776           {
 777             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 778             if (p == (const Quantum *) NULL)
 779               break;
 780             for (x=0; x < (ssize_t) columns; x++)
 781             {
 782               *q++=(double) (QuantumScale*GetPixelRed(image,p));
 783               *q++=(double) (QuantumScale*GetPixelGreen(image,p));
 784               *q++=(double) (QuantumScale*GetPixelBlue(image,p));
 785               *q++=0.0;
 786               p+=GetPixelChannels(image);
 787             }
 788           }
 789           break;
 790         }
 791       for (y=0; y < (ssize_t) rows; y++)
 792       {
 793         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 794         if (p == (const Quantum *) NULL)
 795           break;
 796         for (x=0; x < (ssize_t) columns; x++)
 797         {
 798           for (i=0; i < (ssize_t) length; i++)
 799           {
 800             *q=0;
 801             switch (quantum_map[i])
 802             {
 803               case RedQuantum:
 804               case CyanQuantum:
 805               {
 806                 *q=(double) (QuantumScale*GetPixelRed(image,p));
 807                 break;
 808               }
 809               case GreenQuantum:
 810               case MagentaQuantum:
 811               {
 812                 *q=(double) (QuantumScale*GetPixelGreen(image,p));
 813                 break;
 814               }
 815               case BlueQuantum:
 816               case YellowQuantum:
 817               {
 818                 *q=(double) (QuantumScale*GetPixelBlue(image,p));
 819                 break;
 820               }
 821               case AlphaQuantum:
 822               {
 823                 *q=(double) (QuantumScale*GetPixelAlpha(image,p));
 824                 break;
 825               }
 826               case OpacityQuantum:
 827               {
 828                 *q=(double) (QuantumScale*GetPixelAlpha(image,p));
 829                 break;
 830               }
 831               case BlackQuantum:
 832               {
 833                 if (image->colorspace == CMYKColorspace)
 834                   *q=(double) (QuantumScale*
 835                     GetPixelBlack(image,p));
 836                 break;
 837               }
 838               case IndexQuantum:
 839               {
 840                 *q=(double) (QuantumScale*GetPixelIntensity(image,p));
 841                 break;
 842               }
 843               default:
 844                 *q=0;
 845             }
 846             q++;
 847           }
 848           p+=GetPixelChannels(image);
 849         }
 850       }
 851       break;
 852     }
 853     case FloatPixel:
 854     {
 855       register float
 856         *q;
 857
 858       q=(float *) pixels;
 859       if (LocaleCompare(map,"BGR") == 0)
 860         {
 861           for (y=0; y < (ssize_t) rows; y++)
 862           {
 863             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 864             if (p == (const Quantum *) NULL)
 865               break;
 866             for (x=0; x < (ssize_t) columns; x++)
 867             {
 868               *q++=(float) (QuantumScale*GetPixelBlue(image,p));
 869               *q++=(float) (QuantumScale*GetPixelGreen(image,p));
 870               *q++=(float) (QuantumScale*GetPixelRed(image,p));
 871               p+=GetPixelChannels(image);
 872             }
 873           }
 874           break;
 875         }
 876       if (LocaleCompare(map,"BGRA") == 0)
 877         {
 878           for (y=0; y < (ssize_t) rows; y++)
 879           {
 880             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 881             if (p == (const Quantum *) NULL)
 882               break;
 883             for (x=0; x < (ssize_t) columns; x++)
 884             {
 885               *q++=(float) (QuantumScale*GetPixelBlue(image,p));
 886               *q++=(float) (QuantumScale*GetPixelGreen(image,p));
 887               *q++=(float) (QuantumScale*GetPixelRed(image,p));
 888               *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
 889               p+=GetPixelChannels(image);
 890             }
 891           }
 892           break;
 893         }
 894       if (LocaleCompare(map,"BGRP") == 0)
 895         {
 896           for (y=0; y < (ssize_t) rows; y++)
 897           {
 898             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 899             if (p == (const Quantum *) NULL)
 900               break;
 901             for (x=0; x < (ssize_t) columns; x++)
 902             {
 903               *q++=(float) (QuantumScale*GetPixelBlue(image,p));
 904               *q++=(float) (QuantumScale*GetPixelGreen(image,p));
 905               *q++=(float) (QuantumScale*GetPixelRed(image,p));
 906               *q++=0.0;
 907               p+=GetPixelChannels(image);
 908             }
 909           }
 910           break;
 911         }
 912       if (LocaleCompare(map,"I") == 0)
 913         {
 914           for (y=0; y < (ssize_t) rows; y++)
 915           {
 916             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 917             if (p == (const Quantum *) NULL)
 918               break;
 919             for (x=0; x < (ssize_t) columns; x++)
 920             {
 921               *q++=(float) (QuantumScale*GetPixelIntensity(image,p));
 922               p+=GetPixelChannels(image);
 923             }
 924           }
 925           break;
 926         }
 927       if (LocaleCompare(map,"RGB") == 0)
 928         {
 929           for (y=0; y < (ssize_t) rows; y++)
 930           {
 931             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 932             if (p == (const Quantum *) NULL)
 933               break;
 934             for (x=0; x < (ssize_t) columns; x++)
 935             {
 936               *q++=(float) (QuantumScale*GetPixelRed(image,p));
 937               *q++=(float) (QuantumScale*GetPixelGreen(image,p));
 938               *q++=(float) (QuantumScale*GetPixelBlue(image,p));
 939               p+=GetPixelChannels(image);
 940             }
 941           }
 942           break;
 943         }
 944       if (LocaleCompare(map,"RGBA") == 0)
 945         {
 946           for (y=0; y < (ssize_t) rows; y++)
 947           {
 948             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 949             if (p == (const Quantum *) NULL)
 950               break;
 951             for (x=0; x < (ssize_t) columns; x++)
 952             {
 953               *q++=(float) (QuantumScale*GetPixelRed(image,p));
 954               *q++=(float) (QuantumScale*GetPixelGreen(image,p));
 955               *q++=(float) (QuantumScale*GetPixelBlue(image,p));
 956               *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
 957               p+=GetPixelChannels(image);
 958             }
 959           }
 960           break;
 961         }
 962       if (LocaleCompare(map,"RGBP") == 0)
 963         {
 964           for (y=0; y < (ssize_t) rows; y++)
 965           {
 966             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 967             if (p == (const Quantum *) NULL)
 968               break;
 969             for (x=0; x < (ssize_t) columns; x++)
 970             {
 971               *q++=(float) (QuantumScale*GetPixelRed(image,p));
 972               *q++=(float) (QuantumScale*GetPixelGreen(image,p));
 973               *q++=(float) (QuantumScale*GetPixelBlue(image,p));
 974               *q++=0.0;
 975               p+=GetPixelChannels(image);
 976             }
 977           }
 978           break;
 979         }
 980       for (y=0; y < (ssize_t) rows; y++)
 981       {
 982         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 983         if (p == (const Quantum *) NULL)
 984           break;
 985         for (x=0; x < (ssize_t) columns; x++)
 986         {
 987           for (i=0; i < (ssize_t) length; i++)
 988           {
 989             *q=0;
 990             switch (quantum_map[i])
 991             {
 992               case RedQuantum:
 993               case CyanQuantum:
 994               {
 995                 *q=(float) (QuantumScale*GetPixelRed(image,p));
 996                 break;
 997               }
 998               case GreenQuantum:
 999               case MagentaQuantum:
1000               {
1001                 *q=(float) (QuantumScale*GetPixelGreen(image,p));
1002                 break;
1003               }
1004               case BlueQuantum:
1005               case YellowQuantum:
1006               {
1007                 *q=(float) (QuantumScale*GetPixelBlue(image,p));
1008                 break;
1009               }
1010               case AlphaQuantum:
1011               {
1012                 *q=(float) (QuantumScale*((Quantum) (GetPixelAlpha(image,p))));
1013                 break;
1014               }
1015               case OpacityQuantum:
1016               {
1017                 *q=(float) (QuantumScale*GetPixelAlpha(image,p));
1018                 break;
1019               }
1020               case BlackQuantum:
1021               {
1022                 if (image->colorspace == CMYKColorspace)
1023                   *q=(float) (QuantumScale* GetPixelBlack(image,p));
1024                 break;
1025               }
1026               case IndexQuantum:
1027               {
1028                 *q=(float) (QuantumScale*GetPixelIntensity(image,p));
1029                 break;
1030               }
1031               default:
1032                 *q=0;
1033             }
1034             q++;
1035           }
1036           p+=GetPixelChannels(image);
1037         }
1038       }
1039       break;
1040     }
1041     case IntegerPixel:
1042     {
1043       register unsigned int
1044         *q;
1045
1046       q=(unsigned int *) pixels;
1047       if (LocaleCompare(map,"BGR") == 0)
1048         {
1049           for (y=0; y < (ssize_t) rows; y++)
1050           {
1051             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1052             if (p == (const Quantum *) NULL)
1053               break;
1054             for (x=0; x < (ssize_t) columns; x++)
1055             {
1056               *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1057               *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1058               *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1059               p+=GetPixelChannels(image);
1060             }
1061           }
1062           break;
1063         }
1064       if (LocaleCompare(map,"BGRA") == 0)
1065         {
1066           for (y=0; y < (ssize_t) rows; y++)
1067           {
1068             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1069             if (p == (const Quantum *) NULL)
1070               break;
1071             for (x=0; x < (ssize_t) columns; x++)
1072             {
1073               *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1074               *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1075               *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1076               *q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
1077               p+=GetPixelChannels(image);
1078             }
1079           }
1080           break;
1081         }
1082       if (LocaleCompare(map,"BGRP") == 0)
1083         {
1084           for (y=0; y < (ssize_t) rows; y++)
1085           {
1086             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1087             if (p == (const Quantum *) NULL)
1088               break;
1089             for (x=0; x < (ssize_t) columns; x++)
1090             {
1091               *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1092               *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1093               *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1094               *q++=0U;
1095               p+=GetPixelChannels(image);
1096             }
1097           }
1098           break;
1099         }
1100       if (LocaleCompare(map,"I") == 0)
1101         {
1102           for (y=0; y < (ssize_t) rows; y++)
1103           {
1104             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1105             if (p == (const Quantum *) NULL)
1106               break;
1107             for (x=0; x < (ssize_t) columns; x++)
1108             {
1109               *q++=(unsigned int) ScaleQuantumToLong(
1110                 GetPixelIntensity(image,p));
1111               p+=GetPixelChannels(image);
1112             }
1113           }
1114           break;
1115         }
1116       if (LocaleCompare(map,"RGB") == 0)
1117         {
1118           for (y=0; y < (ssize_t) rows; y++)
1119           {
1120             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1121             if (p == (const Quantum *) NULL)
1122               break;
1123             for (x=0; x < (ssize_t) columns; x++)
1124             {
1125               *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1126               *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1127               *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1128               p+=GetPixelChannels(image);
1129             }
1130           }
1131           break;
1132         }
1133       if (LocaleCompare(map,"RGBA") == 0)
1134         {
1135           for (y=0; y < (ssize_t) rows; y++)
1136           {
1137             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1138             if (p == (const Quantum *) NULL)
1139               break;
1140             for (x=0; x < (ssize_t) columns; x++)
1141             {
1142               *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1143               *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1144               *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1145               *q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
1146               p+=GetPixelChannels(image);
1147             }
1148           }
1149           break;
1150         }
1151       if (LocaleCompare(map,"RGBP") == 0)
1152         {
1153           for (y=0; y < (ssize_t) rows; y++)
1154           {
1155             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1156             if (p == (const Quantum *) NULL)
1157               break;
1158             for (x=0; x < (ssize_t) columns; x++)
1159             {
1160               *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1161               *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1162               *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1163               *q++=0U;
1164               p+=GetPixelChannels(image);
1165             }
1166           }
1167           break;
1168         }
1169       for (y=0; y < (ssize_t) rows; y++)
1170       {
1171         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1172         if (p == (const Quantum *) NULL)
1173           break;
1174         for (x=0; x < (ssize_t) columns; x++)
1175         {
1176           for (i=0; i < (ssize_t) length; i++)
1177           {
1178             *q=0;
1179             switch (quantum_map[i])
1180             {
1181               case RedQuantum:
1182               case CyanQuantum:
1183               {
1184                 *q=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1185                 break;
1186               }
1187               case GreenQuantum:
1188               case MagentaQuantum:
1189               {
1190                 *q=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1191                 break;
1192               }
1193               case BlueQuantum:
1194               case YellowQuantum:
1195               {
1196                 *q=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1197                 break;
1198               }
1199               case AlphaQuantum:
1200               {
1201                 *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
1202                 break;
1203               }
1204               case OpacityQuantum:
1205               {
1206                 *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
1207                 break;
1208               }
1209               case BlackQuantum:
1210               {
1211                 if (image->colorspace == CMYKColorspace)
1212                   *q=(unsigned int) ScaleQuantumToLong(GetPixelBlack(image,p));
1213                 break;
1214               }
1215               case IndexQuantum:
1216               {
1217                 *q=(unsigned int) ScaleQuantumToLong(
1218                   GetPixelIntensity(image,p));
1219                 break;
1220               }
1221               default:
1222                 *q=0;
1223             }
1224             q++;
1225           }
1226           p+=GetPixelChannels(image);
1227         }
1228       }
1229       break;
1230     }
1231     case LongPixel:
1232     {
1233       register size_t
1234         *q;
1235
1236       q=(size_t *) pixels;
1237       if (LocaleCompare(map,"BGR") == 0)
1238         {
1239           for (y=0; y < (ssize_t) rows; y++)
1240           {
1241             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1242             if (p == (const Quantum *) NULL)
1243               break;
1244             for (x=0; x < (ssize_t) columns; x++)
1245             {
1246               *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1247               *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1248               *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1249               p+=GetPixelChannels(image);
1250             }
1251           }
1252           break;
1253         }
1254       if (LocaleCompare(map,"BGRA") == 0)
1255         {
1256           for (y=0; y < (ssize_t) rows; y++)
1257           {
1258             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1259             if (p == (const Quantum *) NULL)
1260               break;
1261             for (x=0; x < (ssize_t) columns; x++)
1262             {
1263               *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1264               *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1265               *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1266               *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
1267               p+=GetPixelChannels(image);
1268             }
1269           }
1270           break;
1271         }
1272       if (LocaleCompare(map,"BGRP") == 0)
1273         {
1274           for (y=0; y < (ssize_t) rows; y++)
1275           {
1276             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1277             if (p == (const Quantum *) NULL)
1278               break;
1279             for (x=0; x < (ssize_t) columns; x++)
1280             {
1281               *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1282               *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1283               *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1284               *q++=0;
1285               p+=GetPixelChannels(image);
1286             }
1287           }
1288           break;
1289         }
1290       if (LocaleCompare(map,"I") == 0)
1291         {
1292           for (y=0; y < (ssize_t) rows; y++)
1293           {
1294             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1295             if (p == (const Quantum *) NULL)
1296               break;
1297             for (x=0; x < (ssize_t) columns; x++)
1298             {
1299               *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
1300               p+=GetPixelChannels(image);
1301             }
1302           }
1303           break;
1304         }
1305       if (LocaleCompare(map,"RGB") == 0)
1306         {
1307           for (y=0; y < (ssize_t) rows; y++)
1308           {
1309             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1310             if (p == (const Quantum *) NULL)
1311               break;
1312             for (x=0; x < (ssize_t) columns; x++)
1313             {
1314               *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1315               *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1316               *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1317               p+=GetPixelChannels(image);
1318             }
1319           }
1320           break;
1321         }
1322       if (LocaleCompare(map,"RGBA") == 0)
1323         {
1324           for (y=0; y < (ssize_t) rows; y++)
1325           {
1326             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1327             if (p == (const Quantum *) NULL)
1328               break;
1329             for (x=0; x < (ssize_t) columns; x++)
1330             {
1331               *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1332               *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1333               *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1334               *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
1335               p+=GetPixelChannels(image);
1336             }
1337           }
1338           break;
1339         }
1340       if (LocaleCompare(map,"RGBP") == 0)
1341         {
1342           for (y=0; y < (ssize_t) rows; y++)
1343           {
1344             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1345             if (p == (const Quantum *) NULL)
1346               break;
1347             for (x=0; x < (ssize_t) columns; x++)
1348             {
1349               *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1350               *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1351               *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1352               *q++=0;
1353               p+=GetPixelChannels(image);
1354             }
1355           }
1356           break;
1357         }
1358       for (y=0; y < (ssize_t) rows; y++)
1359       {
1360         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1361         if (p == (const Quantum *) NULL)
1362           break;
1363         for (x=0; x < (ssize_t) columns; x++)
1364         {
1365           for (i=0; i < (ssize_t) length; i++)
1366           {
1367             *q=0;
1368             switch (quantum_map[i])
1369             {
1370               case RedQuantum:
1371               case CyanQuantum:
1372               {
1373                 *q=ScaleQuantumToLong(GetPixelRed(image,p));
1374                 break;
1375               }
1376               case GreenQuantum:
1377               case MagentaQuantum:
1378               {
1379                 *q=ScaleQuantumToLong(GetPixelGreen(image,p));
1380                 break;
1381               }
1382               case BlueQuantum:
1383               case YellowQuantum:
1384               {
1385                 *q=ScaleQuantumToLong(GetPixelBlue(image,p));
1386                 break;
1387               }
1388               case AlphaQuantum:
1389               {
1390                 *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
1391                 break;
1392               }
1393               case OpacityQuantum:
1394               {
1395                 *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
1396                 break;
1397               }
1398               case BlackQuantum:
1399               {
1400                 if (image->colorspace == CMYKColorspace)
1401                   *q=ScaleQuantumToLong(GetPixelBlack(image,p));
1402                 break;
1403               }
1404               case IndexQuantum:
1405               {
1406                 *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
1407                 break;
1408               }
1409               default:
1410                 break;
1411             }
1412             q++;
1413           }
1414           p+=GetPixelChannels(image);
1415         }
1416       }
1417       break;
1418     }
1419     case QuantumPixel:
1420     {
1421       register Quantum
1422         *q;
1423
1424       q=(Quantum *) pixels;
1425       if (LocaleCompare(map,"BGR") == 0)
1426         {
1427           for (y=0; y < (ssize_t) rows; y++)
1428           {
1429             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1430             if (p == (const Quantum *) NULL)
1431               break;
1432             for (x=0; x < (ssize_t) columns; x++)
1433             {
1434               *q++=GetPixelBlue(image,p);
1435               *q++=GetPixelGreen(image,p);
1436               *q++=GetPixelRed(image,p);
1437               p+=GetPixelChannels(image);
1438             }
1439           }
1440           break;
1441         }
1442       if (LocaleCompare(map,"BGRA") == 0)
1443         {
1444           for (y=0; y < (ssize_t) rows; y++)
1445           {
1446             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1447             if (p == (const Quantum *) NULL)
1448               break;
1449             for (x=0; x < (ssize_t) columns; x++)
1450             {
1451               *q++=GetPixelBlue(image,p);
1452               *q++=GetPixelGreen(image,p);
1453               *q++=GetPixelRed(image,p);
1454               *q++=(Quantum) (GetPixelAlpha(image,p));
1455               p+=GetPixelChannels(image);
1456             }
1457           }
1458           break;
1459         }
1460       if (LocaleCompare(map,"BGRP") == 0)
1461         {
1462           for (y=0; y < (ssize_t) rows; y++)
1463           {
1464             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1465             if (p == (const Quantum *) NULL)
1466               break;
1467             for (x=0; x < (ssize_t) columns; x++)
1468             {
1469               *q++=GetPixelBlue(image,p);
1470               *q++=GetPixelGreen(image,p);
1471               *q++=GetPixelRed(image,p);
1472               *q++=(Quantum) 0;
1473               p+=GetPixelChannels(image);
1474             }
1475           }
1476           break;
1477         }
1478       if (LocaleCompare(map,"I") == 0)
1479         {
1480           for (y=0; y < (ssize_t) rows; y++)
1481           {
1482             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1483             if (p == (const Quantum *) NULL)
1484               break;
1485             for (x=0; x < (ssize_t) columns; x++)
1486             {
1487               *q++=GetPixelIntensity(image,p);
1488               p+=GetPixelChannels(image);
1489             }
1490           }
1491           break;
1492         }
1493       if (LocaleCompare(map,"RGB") == 0)
1494         {
1495           for (y=0; y < (ssize_t) rows; y++)
1496           {
1497             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1498             if (p == (const Quantum *) NULL)
1499               break;
1500             for (x=0; x < (ssize_t) columns; x++)
1501             {
1502               *q++=GetPixelRed(image,p);
1503               *q++=GetPixelGreen(image,p);
1504               *q++=GetPixelBlue(image,p);
1505               p+=GetPixelChannels(image);
1506             }
1507           }
1508           break;
1509         }
1510       if (LocaleCompare(map,"RGBA") == 0)
1511         {
1512           for (y=0; y < (ssize_t) rows; y++)
1513           {
1514             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1515             if (p == (const Quantum *) NULL)
1516               break;
1517             for (x=0; x < (ssize_t) columns; x++)
1518             {
1519               *q++=GetPixelRed(image,p);
1520               *q++=GetPixelGreen(image,p);
1521               *q++=GetPixelBlue(image,p);
1522               *q++=(Quantum) (GetPixelAlpha(image,p));
1523               p+=GetPixelChannels(image);
1524             }
1525           }
1526           break;
1527         }
1528       if (LocaleCompare(map,"RGBP") == 0)
1529         {
1530           for (y=0; y < (ssize_t) rows; y++)
1531           {
1532             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1533             if (p == (const Quantum *) NULL)
1534               break;
1535             for (x=0; x < (ssize_t) columns; x++)
1536             {
1537               *q++=GetPixelRed(image,p);
1538               *q++=GetPixelGreen(image,p);
1539               *q++=GetPixelBlue(image,p);
1540               *q++=(Quantum) 0;
1541               p+=GetPixelChannels(image);
1542             }
1543           }
1544           break;
1545         }
1546       for (y=0; y < (ssize_t) rows; y++)
1547       {
1548         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1549         if (p == (const Quantum *) NULL)
1550           break;
1551         for (x=0; x < (ssize_t) columns; x++)
1552         {
1553           for (i=0; i < (ssize_t) length; i++)
1554           {
1555             *q=(Quantum) 0;
1556             switch (quantum_map[i])
1557             {
1558               case RedQuantum:
1559               case CyanQuantum:
1560               {
1561                 *q=GetPixelRed(image,p);
1562                 break;
1563               }
1564               case GreenQuantum:
1565               case MagentaQuantum:
1566               {
1567                 *q=GetPixelGreen(image,p);
1568                 break;
1569               }
1570               case BlueQuantum:
1571               case YellowQuantum:
1572               {
1573                 *q=GetPixelBlue(image,p);
1574                 break;
1575               }
1576               case AlphaQuantum:
1577               {
1578                 *q=(Quantum) (GetPixelAlpha(image,p));
1579                 break;
1580               }
1581               case OpacityQuantum:
1582               {
1583                 *q=GetPixelAlpha(image,p);
1584                 break;
1585               }
1586               case BlackQuantum:
1587               {
1588                 if (image->colorspace == CMYKColorspace)
1589                   *q=GetPixelBlack(image,p);
1590                 break;
1591               }
1592               case IndexQuantum:
1593               {
1594                 *q=(GetPixelIntensity(image,p));
1595                 break;
1596               }
1597               default:
1598                 *q=(Quantum) 0;
1599             }
1600             q++;
1601           }
1602           p+=GetPixelChannels(image);
1603         }
1604       }
1605       break;
1606     }
1607     case ShortPixel:
1608     {
1609       register unsigned short
1610         *q;
1611
1612       q=(unsigned short *) pixels;
1613       if (LocaleCompare(map,"BGR") == 0)
1614         {
1615           for (y=0; y < (ssize_t) rows; y++)
1616           {
1617             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1618             if (p == (const Quantum *) NULL)
1619               break;
1620             for (x=0; x < (ssize_t) columns; x++)
1621             {
1622               *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1623               *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1624               *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1625               p+=GetPixelChannels(image);
1626             }
1627           }
1628           break;
1629         }
1630       if (LocaleCompare(map,"BGRA") == 0)
1631         {
1632           for (y=0; y < (ssize_t) rows; y++)
1633           {
1634             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1635             if (p == (const Quantum *) NULL)
1636               break;
1637             for (x=0; x < (ssize_t) columns; x++)
1638             {
1639               *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1640               *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1641               *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1642               *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
1643               p+=GetPixelChannels(image);
1644             }
1645           }
1646           break;
1647         }
1648       if (LocaleCompare(map,"BGRP") == 0)
1649         {
1650           for (y=0; y < (ssize_t) rows; y++)
1651           {
1652             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1653             if (p == (const Quantum *) NULL)
1654               break;
1655             for (x=0; x < (ssize_t) columns; x++)
1656             {
1657               *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1658               *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1659               *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1660               *q++=0;
1661               p+=GetPixelChannels(image);
1662             }
1663           }
1664           break;
1665         }
1666       if (LocaleCompare(map,"I") == 0)
1667         {
1668           for (y=0; y < (ssize_t) rows; y++)
1669           {
1670             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1671             if (p == (const Quantum *) NULL)
1672               break;
1673             for (x=0; x < (ssize_t) columns; x++)
1674             {
1675               *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
1676               p+=GetPixelChannels(image);
1677             }
1678           }
1679           break;
1680         }
1681       if (LocaleCompare(map,"RGB") == 0)
1682         {
1683           for (y=0; y < (ssize_t) rows; y++)
1684           {
1685             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1686             if (p == (const Quantum *) NULL)
1687               break;
1688             for (x=0; x < (ssize_t) columns; x++)
1689             {
1690               *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1691               *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1692               *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1693               p+=GetPixelChannels(image);
1694             }
1695           }
1696           break;
1697         }
1698       if (LocaleCompare(map,"RGBA") == 0)
1699         {
1700           for (y=0; y < (ssize_t) rows; y++)
1701           {
1702             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1703             if (p == (const Quantum *) NULL)
1704               break;
1705             for (x=0; x < (ssize_t) columns; x++)
1706             {
1707               *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1708               *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1709               *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1710               *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
1711               p+=GetPixelChannels(image);
1712             }
1713           }
1714           break;
1715         }
1716       if (LocaleCompare(map,"RGBP") == 0)
1717         {
1718           for (y=0; y < (ssize_t) rows; y++)
1719           {
1720             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1721             if (p == (const Quantum *) NULL)
1722               break;
1723             for (x=0; x < (ssize_t) columns; x++)
1724             {
1725               *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1726               *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1727               *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1728               *q++=0;
1729               p+=GetPixelChannels(image);
1730             }
1731           }
1732           break;
1733         }
1734       for (y=0; y < (ssize_t) rows; y++)
1735       {
1736         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1737         if (p == (const Quantum *) NULL)
1738           break;
1739         for (x=0; x < (ssize_t) columns; x++)
1740         {
1741           for (i=0; i < (ssize_t) length; i++)
1742           {
1743             *q=0;
1744             switch (quantum_map[i])
1745             {
1746               case RedQuantum:
1747               case CyanQuantum:
1748               {
1749                 *q=ScaleQuantumToShort(GetPixelRed(image,p));
1750                 break;
1751               }
1752               case GreenQuantum:
1753               case MagentaQuantum:
1754               {
1755                 *q=ScaleQuantumToShort(GetPixelGreen(image,p));
1756                 break;
1757               }
1758               case BlueQuantum:
1759               case YellowQuantum:
1760               {
1761                 *q=ScaleQuantumToShort(GetPixelBlue(image,p));
1762                 break;
1763               }
1764               case AlphaQuantum:
1765               {
1766                 *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
1767                 break;
1768               }
1769               case OpacityQuantum:
1770               {
1771                 *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
1772                 break;
1773               }
1774               case BlackQuantum:
1775               {
1776                 if (image->colorspace == CMYKColorspace)
1777                   *q=ScaleQuantumToShort(GetPixelBlack(image,p));
1778                 break;
1779               }
1780               case IndexQuantum:
1781               {
1782                 *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
1783                 break;
1784               }
1785               default:
1786                 break;
1787             }
1788             q++;
1789           }
1790           p+=GetPixelChannels(image);
1791         }
1792       }
1793       break;
1794     }
1795     default:
1796     {
1797       quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1798       (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1799         "UnrecognizedPixelMap","`%s'",map);
1800       break;
1801     }
1802   }
1803   quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1804   return(MagickTrue);
1805 }
1806 \f
1807 /*
1808 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1809 %                                                                             %
1810 %                                                                             %
1811 %                                                                             %
1812 %   G e t P i x e l I n f o                                                   %
1813 %                                                                             %
1814 %                                                                             %
1815 %                                                                             %
1816 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1817 %
1818 %  GetPixelInfo() initializes the PixelInfo structure.
1819 %
1820 %  The format of the GetPixelInfo method is:
1821 %
1822 %      GetPixelInfo(const Image *image,PixelInfo *pixel)
1823 %
1824 %  A description of each parameter follows:
1825 %
1826 %    o image: the image.
1827 %
1828 %    o pixel: Specifies a pointer to a PixelInfo structure.
1829 %
1830 */
1831 MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
1832 {
1833   pixel->storage_class=DirectClass;
1834   pixel->colorspace=RGBColorspace;
1835   pixel->matte=MagickFalse;
1836   pixel->fuzz=0.0;
1837   pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
1838   pixel->red=0.0;
1839   pixel->green=0.0;
1840   pixel->blue=0.0;
1841   pixel->black=0.0;
1842   pixel->alpha=(MagickRealType) OpaqueAlpha;
1843   pixel->index=0.0;
1844   if (image == (const Image *) NULL)
1845     return;
1846   pixel->storage_class=image->storage_class;
1847   pixel->colorspace=image->colorspace;
1848   pixel->matte=image->matte;
1849   pixel->depth=image->depth;
1850   pixel->fuzz=image->fuzz;
1851 }
1852 \f
1853 /*
1854 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1855 %                                                                             %
1856 %                                                                             %
1857 %                                                                             %
1858 %   I m p o r t I m a g e P i x e l s                                         %
1859 %                                                                             %
1860 %                                                                             %
1861 %                                                                             %
1862 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1863 %
1864 %  ImportImagePixels() accepts pixel data and stores in the image at the
1865 %  location you specify.  The method returns MagickTrue on success otherwise
1866 %  MagickFalse if an error is encountered.  The pixel data can be either char,
1867 %  short int, int, ssize_t, float, or double in the order specified by map.
1868 %
1869 %  Suppose your want to upload the first scanline of a 640x480 image from
1870 %  character data in red-green-blue order:
1871 %
1872 %      ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
1873 %
1874 %  The format of the ImportImagePixels method is:
1875 %
1876 %      MagickBooleanType ImportImagePixels(Image *image,const ssize_t x_offset,
1877 %        const ssize_t y_offset,const size_t columns,
1878 %        const size_t rows,const char *map,const StorageType type,
1879 %        const void *pixels,ExceptionInfo *exception)
1880 %
1881 %  A description of each parameter follows:
1882 %
1883 %    o image: the image.
1884 %
1885 %    o x_offset,y_offset,columns,rows:  These values define the perimeter
1886 %      of a region of pixels you want to define.
1887 %
1888 %    o map:  This string reflects the expected ordering of the pixel array.
1889 %      It can be any combination or order of R = red, G = green, B = blue,
1890 %      A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
1891 %      Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
1892 %      P = pad.
1893 %
1894 %    o type: Define the data type of the pixels.  Float and double types are
1895 %      normalized to [0..1] otherwise [0..QuantumRange].  Choose from these
1896 %      types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or
1897 %      DoublePixel.
1898 %
1899 %    o pixels: This array of values contain the pixel components as defined by
1900 %      map and type.  You must preallocate this array where the expected
1901 %      length varies depending on the values of width, height, map, and type.
1902 %
1903 %    o exception: return any errors or warnings in this structure.
1904 %
1905 */
1906 MagickExport MagickBooleanType ImportImagePixels(Image *image,
1907   const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
1908   const size_t rows,const char *map,const StorageType type,
1909   const void *pixels,ExceptionInfo *exception)
1910 {
1911   QuantumType
1912     *quantum_map;
1913
1914   register Quantum
1915     *q;
1916
1917   register ssize_t
1918     i,
1919     x;
1920
1921   size_t
1922     length;
1923
1924   ssize_t
1925     y;
1926
1927   /*
1928     Allocate image structure.
1929   */
1930   assert(image != (Image *) NULL);
1931   assert(image->signature == MagickSignature);
1932   if (image->debug != MagickFalse)
1933     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1934   length=strlen(map);
1935   quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1936   if (quantum_map == (QuantumType *) NULL)
1937     ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1938       image->filename);
1939   for (i=0; i < (ssize_t) length; i++)
1940   {
1941     switch (map[i])
1942     {
1943       case 'a':
1944       case 'A':
1945       {
1946         quantum_map[i]=AlphaQuantum;
1947         image->matte=MagickTrue;
1948         break;
1949       }
1950       case 'B':
1951       case 'b':
1952       {
1953         quantum_map[i]=BlueQuantum;
1954         break;
1955       }
1956       case 'C':
1957       case 'c':
1958       {
1959         quantum_map[i]=CyanQuantum;
1960         (void) SetImageColorspace(image,CMYKColorspace,exception);
1961         break;
1962       }
1963       case 'g':
1964       case 'G':
1965       {
1966         quantum_map[i]=GreenQuantum;
1967         break;
1968       }
1969       case 'K':
1970       case 'k':
1971       {
1972         quantum_map[i]=BlackQuantum;
1973         (void) SetImageColorspace(image,CMYKColorspace,exception);
1974         break;
1975       }
1976       case 'I':
1977       case 'i':
1978       {
1979         quantum_map[i]=IndexQuantum;
1980         break;
1981       }
1982       case 'm':
1983       case 'M':
1984       {
1985         quantum_map[i]=MagentaQuantum;
1986         (void) SetImageColorspace(image,CMYKColorspace,exception);
1987         break;
1988       }
1989       case 'O':
1990       case 'o':
1991       {
1992         quantum_map[i]=OpacityQuantum;
1993         image->matte=MagickTrue;
1994         break;
1995       }
1996       case 'P':
1997       case 'p':
1998       {
1999         quantum_map[i]=UndefinedQuantum;
2000         break;
2001       }
2002       case 'R':
2003       case 'r':
2004       {
2005         quantum_map[i]=RedQuantum;
2006         break;
2007       }
2008       case 'Y':
2009       case 'y':
2010       {
2011         quantum_map[i]=YellowQuantum;
2012         (void) SetImageColorspace(image,CMYKColorspace,exception);
2013         break;
2014       }
2015       default:
2016       {
2017         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2018         (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2019           "UnrecognizedPixelMap","`%s'",map);
2020         return(MagickFalse);
2021       }
2022     }
2023   }
2024   if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
2025     return(MagickFalse);
2026   /*
2027     Transfer the pixels from the pixel datarray to the image.
2028   */
2029   switch (type)
2030   {
2031     case CharPixel:
2032     {
2033       register const unsigned char
2034         *p;
2035
2036       p=(const unsigned char *) pixels;
2037       if (LocaleCompare(map,"BGR") == 0)
2038         {
2039           for (y=0; y < (ssize_t) rows; y++)
2040           {
2041             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2042             if (q == (Quantum *) NULL)
2043               break;
2044             for (x=0; x < (ssize_t) columns; x++)
2045             {
2046               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2047               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2048               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2049               q+=GetPixelChannels(image);
2050             }
2051             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2052               break;
2053           }
2054           break;
2055         }
2056       if (LocaleCompare(map,"BGRA") == 0)
2057         {
2058           for (y=0; y < (ssize_t) rows; y++)
2059           {
2060             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2061             if (q == (Quantum *) NULL)
2062               break;
2063             for (x=0; x < (ssize_t) columns; x++)
2064             {
2065               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2066               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2067               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2068               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2069               q+=GetPixelChannels(image);
2070             }
2071             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2072               break;
2073           }
2074           break;
2075         }
2076       if (LocaleCompare(map,"BGRO") == 0)
2077         {
2078           for (y=0; y < (ssize_t) rows; y++)
2079           {
2080             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2081             if (q == (Quantum *) NULL)
2082               break;
2083             for (x=0; x < (ssize_t) columns; x++)
2084             {
2085               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2086               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2087               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2088               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2089               q+=GetPixelChannels(image);
2090             }
2091             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2092               break;
2093           }
2094           break;
2095         }
2096       if (LocaleCompare(map,"BGRP") == 0)
2097         {
2098           for (y=0; y < (ssize_t) rows; y++)
2099           {
2100             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2101             if (q == (Quantum *) NULL)
2102               break;
2103             for (x=0; x < (ssize_t) columns; x++)
2104             {
2105               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2106               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2107               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2108               p++;
2109               q+=GetPixelChannels(image);
2110             }
2111             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2112               break;
2113           }
2114           break;
2115         }
2116       if (LocaleCompare(map,"I") == 0)
2117         {
2118           for (y=0; y < (ssize_t) rows; y++)
2119           {
2120             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2121             if (q == (Quantum *) NULL)
2122               break;
2123             for (x=0; x < (ssize_t) columns; x++)
2124             {
2125               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2126               SetPixelGreen(image,GetPixelRed(image,q),q);
2127               SetPixelBlue(image,GetPixelRed(image,q),q);
2128               q+=GetPixelChannels(image);
2129             }
2130             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2131               break;
2132           }
2133           break;
2134         }
2135       if (LocaleCompare(map,"RGB") == 0)
2136         {
2137           for (y=0; y < (ssize_t) rows; y++)
2138           {
2139             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2140             if (q == (Quantum *) NULL)
2141               break;
2142             for (x=0; x < (ssize_t) columns; x++)
2143             {
2144               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2145               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2146               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2147               q+=GetPixelChannels(image);
2148             }
2149             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2150               break;
2151           }
2152           break;
2153         }
2154       if (LocaleCompare(map,"RGBA") == 0)
2155         {
2156           for (y=0; y < (ssize_t) rows; y++)
2157           {
2158             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2159             if (q == (Quantum *) NULL)
2160               break;
2161             for (x=0; x < (ssize_t) columns; x++)
2162             {
2163               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2164               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2165               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2166               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2167               q+=GetPixelChannels(image);
2168             }
2169             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2170               break;
2171           }
2172           break;
2173         }
2174       if (LocaleCompare(map,"RGBO") == 0)
2175         {
2176           for (y=0; y < (ssize_t) rows; y++)
2177           {
2178             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2179             if (q == (Quantum *) NULL)
2180               break;
2181             for (x=0; x < (ssize_t) columns; x++)
2182             {
2183               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2184               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2185               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2186               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2187               q+=GetPixelChannels(image);
2188             }
2189             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2190               break;
2191           }
2192           break;
2193         }
2194       if (LocaleCompare(map,"RGBP") == 0)
2195         {
2196           for (y=0; y < (ssize_t) rows; y++)
2197           {
2198             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2199             if (q == (Quantum *) NULL)
2200               break;
2201             for (x=0; x < (ssize_t) columns; x++)
2202             {
2203               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2204               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2205               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2206               p++;
2207               q+=GetPixelChannels(image);
2208             }
2209             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2210               break;
2211           }
2212           break;
2213         }
2214       for (y=0; y < (ssize_t) rows; y++)
2215       {
2216         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2217         if (q == (Quantum *) NULL)
2218           break;
2219         for (x=0; x < (ssize_t) columns; x++)
2220         {
2221           for (i=0; i < (ssize_t) length; i++)
2222           {
2223             switch (quantum_map[i])
2224             {
2225               case RedQuantum:
2226               case CyanQuantum:
2227               {
2228                 SetPixelRed(image,ScaleCharToQuantum(*p),q);
2229                 break;
2230               }
2231               case GreenQuantum:
2232               case MagentaQuantum:
2233               {
2234                 SetPixelGreen(image,ScaleCharToQuantum(*p),q);
2235                 break;
2236               }
2237               case BlueQuantum:
2238               case YellowQuantum:
2239               {
2240                 SetPixelBlue(image,ScaleCharToQuantum(*p),q);
2241                 break;
2242               }
2243               case AlphaQuantum:
2244               {
2245                 SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2246                 break;
2247               }
2248               case OpacityQuantum:
2249               {
2250                 SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2251                 break;
2252               }
2253               case BlackQuantum:
2254               {
2255                 SetPixelBlack(image,ScaleCharToQuantum(*p),q);
2256                 break;
2257               }
2258               case IndexQuantum:
2259               {
2260                 SetPixelRed(image,ScaleCharToQuantum(*p),q);
2261                 SetPixelGreen(image,GetPixelRed(image,q),q);
2262                 SetPixelBlue(image,GetPixelRed(image,q),q);
2263                 break;
2264               }
2265               default:
2266                 break;
2267             }
2268             p++;
2269           }
2270           q+=GetPixelChannels(image);
2271         }
2272         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2273           break;
2274       }
2275       break;
2276     }
2277     case DoublePixel:
2278     {
2279       register const double
2280         *p;
2281
2282       p=(const double *) pixels;
2283       if (LocaleCompare(map,"BGR") == 0)
2284         {
2285           for (y=0; y < (ssize_t) rows; y++)
2286           {
2287             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2288             if (q == (Quantum *) NULL)
2289               break;
2290             for (x=0; x < (ssize_t) columns; x++)
2291             {
2292               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2293                 (*p)),q);
2294               p++;
2295               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2296                 (*p)),q);
2297               p++;
2298               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2299                 (*p)),q);
2300               p++;
2301               q+=GetPixelChannels(image);
2302             }
2303             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2304               break;
2305           }
2306           break;
2307         }
2308       if (LocaleCompare(map,"BGRA") == 0)
2309         {
2310           for (y=0; y < (ssize_t) rows; y++)
2311           {
2312             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2313             if (q == (Quantum *) NULL)
2314               break;
2315             for (x=0; x < (ssize_t) columns; x++)
2316             {
2317               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2318                 (*p)),q);
2319               p++;
2320               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2321                 (*p)),q);
2322               p++;
2323               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2324                 (*p)),q);
2325               p++;
2326               SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2327                 (*p)),q);
2328               p++;
2329               q+=GetPixelChannels(image);
2330             }
2331             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2332               break;
2333           }
2334           break;
2335         }
2336       if (LocaleCompare(map,"BGRP") == 0)
2337         {
2338           for (y=0; y < (ssize_t) rows; y++)
2339           {
2340             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2341             if (q == (Quantum *) NULL)
2342               break;
2343             for (x=0; x < (ssize_t) columns; x++)
2344             {
2345               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2346                 (*p)),q);
2347               p++;
2348               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2349                 (*p)),q);
2350               p++;
2351               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2352                 (*p)),q);
2353               p++;
2354               p++;
2355               q+=GetPixelChannels(image);
2356             }
2357             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2358               break;
2359           }
2360           break;
2361         }
2362       if (LocaleCompare(map,"I") == 0)
2363         {
2364           for (y=0; y < (ssize_t) rows; y++)
2365           {
2366             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2367             if (q == (Quantum *) NULL)
2368               break;
2369             for (x=0; x < (ssize_t) columns; x++)
2370             {
2371               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2372                 (*p)),q);
2373               SetPixelGreen(image,GetPixelRed(image,q),q);
2374               SetPixelBlue(image,GetPixelRed(image,q),q);
2375               p++;
2376               q+=GetPixelChannels(image);
2377             }
2378             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2379               break;
2380           }
2381           break;
2382         }
2383       if (LocaleCompare(map,"RGB") == 0)
2384         {
2385           for (y=0; y < (ssize_t) rows; y++)
2386           {
2387             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2388             if (q == (Quantum *) NULL)
2389               break;
2390             for (x=0; x < (ssize_t) columns; x++)
2391             {
2392               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2393                 (*p)),q);
2394               p++;
2395               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2396                 (*p)),q);
2397               p++;
2398               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2399                 (*p)),q);
2400               p++;
2401               q+=GetPixelChannels(image);
2402             }
2403             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2404               break;
2405           }
2406           break;
2407         }
2408       if (LocaleCompare(map,"RGBA") == 0)
2409         {
2410           for (y=0; y < (ssize_t) rows; y++)
2411           {
2412             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2413             if (q == (Quantum *) NULL)
2414               break;
2415             for (x=0; x < (ssize_t) columns; x++)
2416             {
2417               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2418                 (*p)),q);
2419               p++;
2420               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2421                 (*p)),q);
2422               p++;
2423               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2424                 (*p)),q);
2425               p++;
2426               SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2427                 (*p)),q);
2428               p++;
2429               q+=GetPixelChannels(image);
2430             }
2431             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2432               break;
2433           }
2434           break;
2435         }
2436       if (LocaleCompare(map,"RGBP") == 0)
2437         {
2438           for (y=0; y < (ssize_t) rows; y++)
2439           {
2440             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2441             if (q == (Quantum *) NULL)
2442               break;
2443             for (x=0; x < (ssize_t) columns; x++)
2444             {
2445               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2446                 (*p)),q);
2447               p++;
2448               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2449                 (*p)),q);
2450               p++;
2451               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2452                 (*p)),q);
2453               p++;
2454               q+=GetPixelChannels(image);
2455             }
2456             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2457               break;
2458           }
2459           break;
2460         }
2461       for (y=0; y < (ssize_t) rows; y++)
2462       {
2463         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2464         if (q == (Quantum *) NULL)
2465           break;
2466         for (x=0; x < (ssize_t) columns; x++)
2467         {
2468           for (i=0; i < (ssize_t) length; i++)
2469           {
2470             switch (quantum_map[i])
2471             {
2472               case RedQuantum:
2473               case CyanQuantum:
2474               {
2475                 SetPixelRed(image,ClampToQuantum((MagickRealType)
2476                   QuantumRange*(*p)),q);
2477                 break;
2478               }
2479               case GreenQuantum:
2480               case MagentaQuantum:
2481               {
2482                 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2483                   QuantumRange*(*p)),q);
2484                 break;
2485               }
2486               case BlueQuantum:
2487               case YellowQuantum:
2488               {
2489                 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2490                   QuantumRange*(*p)),q);
2491                 break;
2492               }
2493               case AlphaQuantum:
2494               {
2495                 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2496                   QuantumRange*(*p)),q);
2497                 break;
2498               }
2499               case OpacityQuantum:
2500               {
2501                 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2502                   QuantumRange*(*p)),q);
2503                 break;
2504               }
2505               case BlackQuantum:
2506               {
2507                 SetPixelBlack(image,ClampToQuantum((MagickRealType)
2508                   QuantumRange*(*p)),q);
2509                 break;
2510               }
2511               case IndexQuantum:
2512               {
2513                 SetPixelRed(image,ClampToQuantum((MagickRealType)
2514                   QuantumRange*(*p)),q);
2515                 SetPixelGreen(image,GetPixelRed(image,q),q);
2516                 SetPixelBlue(image,GetPixelRed(image,q),q);
2517                 break;
2518               }
2519               default:
2520                 break;
2521             }
2522             p++;
2523           }
2524           q+=GetPixelChannels(image);
2525         }
2526         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2527           break;
2528       }
2529       break;
2530     }
2531     case FloatPixel:
2532     {
2533       register const float
2534         *p;
2535
2536       p=(const float *) pixels;
2537       if (LocaleCompare(map,"BGR") == 0)
2538         {
2539           for (y=0; y < (ssize_t) rows; y++)
2540           {
2541             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2542             if (q == (Quantum *) NULL)
2543               break;
2544             for (x=0; x < (ssize_t) columns; x++)
2545             {
2546               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2547                 (*p)),q);
2548               p++;
2549               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2550                 (*p)),q);
2551               p++;
2552               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2553                 (*p)),q);
2554               p++;
2555               q+=GetPixelChannels(image);
2556             }
2557             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2558               break;
2559           }
2560           break;
2561         }
2562       if (LocaleCompare(map,"BGRA") == 0)
2563         {
2564           for (y=0; y < (ssize_t) rows; y++)
2565           {
2566             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2567             if (q == (Quantum *) NULL)
2568               break;
2569             for (x=0; x < (ssize_t) columns; x++)
2570             {
2571               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2572                 (*p)),q);
2573               p++;
2574               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2575                 (*p)),q);
2576               p++;
2577               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2578                 (*p)),q);
2579               p++;
2580               SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2581                 (*p)),q);
2582               p++;
2583               q+=GetPixelChannels(image);
2584             }
2585             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2586               break;
2587           }
2588           break;
2589         }
2590       if (LocaleCompare(map,"BGRP") == 0)
2591         {
2592           for (y=0; y < (ssize_t) rows; y++)
2593           {
2594             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2595             if (q == (Quantum *) NULL)
2596               break;
2597             for (x=0; x < (ssize_t) columns; x++)
2598             {
2599               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2600                 (*p)),q);
2601               p++;
2602               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2603                 (*p)),q);
2604               p++;
2605               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2606                 (*p)),q);
2607               p++;
2608               p++;
2609               q+=GetPixelChannels(image);
2610             }
2611             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2612               break;
2613           }
2614           break;
2615         }
2616       if (LocaleCompare(map,"I") == 0)
2617         {
2618           for (y=0; y < (ssize_t) rows; y++)
2619           {
2620             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2621             if (q == (Quantum *) NULL)
2622               break;
2623             for (x=0; x < (ssize_t) columns; x++)
2624             {
2625               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2626                 (*p)),q);
2627               SetPixelGreen(image,GetPixelRed(image,q),q);
2628               SetPixelBlue(image,GetPixelRed(image,q),q);
2629               p++;
2630               q+=GetPixelChannels(image);
2631             }
2632             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2633               break;
2634           }
2635           break;
2636         }
2637       if (LocaleCompare(map,"RGB") == 0)
2638         {
2639           for (y=0; y < (ssize_t) rows; y++)
2640           {
2641             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2642             if (q == (Quantum *) NULL)
2643               break;
2644             for (x=0; x < (ssize_t) columns; x++)
2645             {
2646               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2647                 (*p)),q);
2648               p++;
2649               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2650                 (*p)),q);
2651               p++;
2652               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2653                 (*p)),q);
2654               p++;
2655               q+=GetPixelChannels(image);
2656             }
2657             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2658               break;
2659           }
2660           break;
2661         }
2662       if (LocaleCompare(map,"RGBA") == 0)
2663         {
2664           for (y=0; y < (ssize_t) rows; y++)
2665           {
2666             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2667             if (q == (Quantum *) NULL)
2668               break;
2669             for (x=0; x < (ssize_t) columns; x++)
2670             {
2671               SetPixelRed(image,ClampToQuantum((MagickRealType)
2672                 QuantumRange*(*p)),q);
2673               p++;
2674               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2675                 (*p)),q);
2676               p++;
2677               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2678                 (*p)),q);
2679               p++;
2680               SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2681                 (*p)),q);
2682               p++;
2683               q+=GetPixelChannels(image);
2684             }
2685             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2686               break;
2687           }
2688           break;
2689         }
2690       if (LocaleCompare(map,"RGBP") == 0)
2691         {
2692           for (y=0; y < (ssize_t) rows; y++)
2693           {
2694             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2695             if (q == (Quantum *) NULL)
2696               break;
2697             for (x=0; x < (ssize_t) columns; x++)
2698             {
2699               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2700                 (*p)),q);
2701               p++;
2702               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2703                 (*p)),q);
2704               p++;
2705               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2706                 (*p)),q);
2707               p++;
2708               q+=GetPixelChannels(image);
2709             }
2710             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2711               break;
2712           }
2713           break;
2714         }
2715       for (y=0; y < (ssize_t) rows; y++)
2716       {
2717         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2718         if (q == (Quantum *) NULL)
2719           break;
2720         for (x=0; x < (ssize_t) columns; x++)
2721         {
2722           for (i=0; i < (ssize_t) length; i++)
2723           {
2724             switch (quantum_map[i])
2725             {
2726               case RedQuantum:
2727               case CyanQuantum:
2728               {
2729                 SetPixelRed(image,ClampToQuantum((MagickRealType)
2730                   QuantumRange*(*p)),q);
2731                 break;
2732               }
2733               case GreenQuantum:
2734               case MagentaQuantum:
2735               {
2736                 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2737                   QuantumRange*(*p)),q);
2738                 break;
2739               }
2740               case BlueQuantum:
2741               case YellowQuantum:
2742               {
2743                 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2744                   QuantumRange*(*p)),q);
2745                 break;
2746               }
2747               case AlphaQuantum:
2748               {
2749                 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2750                   QuantumRange*(*p)),q);
2751                 break;
2752               }
2753               case OpacityQuantum:
2754               {
2755                 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2756                   QuantumRange*(*p)),q);
2757                 break;
2758               }
2759               case BlackQuantum:
2760               {
2761                 SetPixelBlack(image,ClampToQuantum((MagickRealType)
2762                   QuantumRange*(*p)),q);
2763                 break;
2764               }
2765               case IndexQuantum:
2766               {
2767                 SetPixelRed(image,ClampToQuantum((MagickRealType)
2768                   QuantumRange*(*p)),q);
2769                 SetPixelGreen(image,GetPixelRed(image,q),q);
2770                 SetPixelBlue(image,GetPixelRed(image,q),q);
2771                 break;
2772               }
2773               default:
2774                 break;
2775             }
2776             p++;
2777           }
2778           q+=GetPixelChannels(image);
2779         }
2780         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2781           break;
2782       }
2783       break;
2784     }
2785     case IntegerPixel:
2786     {
2787       register const unsigned int
2788         *p;
2789
2790       p=(const unsigned int *) pixels;
2791       if (LocaleCompare(map,"BGR") == 0)
2792         {
2793           for (y=0; y < (ssize_t) rows; y++)
2794           {
2795             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2796             if (q == (Quantum *) NULL)
2797               break;
2798             for (x=0; x < (ssize_t) columns; x++)
2799             {
2800               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2801               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2802               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2803               q+=GetPixelChannels(image);
2804             }
2805             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2806               break;
2807           }
2808           break;
2809         }
2810       if (LocaleCompare(map,"BGRA") == 0)
2811         {
2812           for (y=0; y < (ssize_t) rows; y++)
2813           {
2814             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2815             if (q == (Quantum *) NULL)
2816               break;
2817             for (x=0; x < (ssize_t) columns; x++)
2818             {
2819               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2820               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2821               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2822               SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2823               q+=GetPixelChannels(image);
2824             }
2825             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2826               break;
2827           }
2828           break;
2829         }
2830       if (LocaleCompare(map,"BGRP") == 0)
2831         {
2832           for (y=0; y < (ssize_t) rows; y++)
2833           {
2834             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2835             if (q == (Quantum *) NULL)
2836               break;
2837             for (x=0; x < (ssize_t) columns; x++)
2838             {
2839               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2840               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2841               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2842               p++;
2843               q+=GetPixelChannels(image);
2844             }
2845             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2846               break;
2847           }
2848           break;
2849         }
2850       if (LocaleCompare(map,"I") == 0)
2851         {
2852           for (y=0; y < (ssize_t) rows; y++)
2853           {
2854             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2855             if (q == (Quantum *) NULL)
2856               break;
2857             for (x=0; x < (ssize_t) columns; x++)
2858             {
2859               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2860               SetPixelGreen(image,GetPixelRed(image,q),q);
2861               SetPixelBlue(image,GetPixelRed(image,q),q);
2862               q+=GetPixelChannels(image);
2863             }
2864             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2865               break;
2866           }
2867           break;
2868         }
2869       if (LocaleCompare(map,"RGB") == 0)
2870         {
2871           for (y=0; y < (ssize_t) rows; y++)
2872           {
2873             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2874             if (q == (Quantum *) NULL)
2875               break;
2876             for (x=0; x < (ssize_t) columns; x++)
2877             {
2878               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2879               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2880               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2881               q+=GetPixelChannels(image);
2882             }
2883             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2884               break;
2885           }
2886           break;
2887         }
2888       if (LocaleCompare(map,"RGBA") == 0)
2889         {
2890           for (y=0; y < (ssize_t) rows; y++)
2891           {
2892             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2893             if (q == (Quantum *) NULL)
2894               break;
2895             for (x=0; x < (ssize_t) columns; x++)
2896             {
2897               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2898               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2899               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2900               SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2901               q+=GetPixelChannels(image);
2902             }
2903             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2904               break;
2905           }
2906           break;
2907         }
2908       if (LocaleCompare(map,"RGBP") == 0)
2909         {
2910           for (y=0; y < (ssize_t) rows; y++)
2911           {
2912             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2913             if (q == (Quantum *) NULL)
2914               break;
2915             for (x=0; x < (ssize_t) columns; x++)
2916             {
2917               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2918               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2919               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2920               p++;
2921               q+=GetPixelChannels(image);
2922             }
2923             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2924               break;
2925           }
2926           break;
2927         }
2928       for (y=0; y < (ssize_t) rows; y++)
2929       {
2930         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2931         if (q == (Quantum *) NULL)
2932           break;
2933         for (x=0; x < (ssize_t) columns; x++)
2934         {
2935           for (i=0; i < (ssize_t) length; i++)
2936           {
2937             switch (quantum_map[i])
2938             {
2939               case RedQuantum:
2940               case CyanQuantum:
2941               {
2942                 SetPixelRed(image,ScaleLongToQuantum(*p),q);
2943                 break;
2944               }
2945               case GreenQuantum:
2946               case MagentaQuantum:
2947               {
2948                 SetPixelGreen(image,ScaleLongToQuantum(*p),q);
2949                 break;
2950               }
2951               case BlueQuantum:
2952               case YellowQuantum:
2953               {
2954                 SetPixelBlue(image,ScaleLongToQuantum(*p),q);
2955                 break;
2956               }
2957               case AlphaQuantum:
2958               {
2959                 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
2960                 break;
2961               }
2962               case OpacityQuantum:
2963               {
2964                 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
2965                 break;
2966               }
2967               case BlackQuantum:
2968               {
2969                 SetPixelBlack(image,ScaleLongToQuantum(*p),q);
2970                 break;
2971               }
2972               case IndexQuantum:
2973               {
2974                 SetPixelRed(image,ScaleLongToQuantum(*p),q);
2975                 SetPixelGreen(image,GetPixelRed(image,q),q);
2976                 SetPixelBlue(image,GetPixelRed(image,q),q);
2977                 break;
2978               }
2979               default:
2980                 break;
2981             }
2982             p++;
2983           }
2984           q+=GetPixelChannels(image);
2985         }
2986         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2987           break;
2988       }
2989       break;
2990     }
2991     case LongPixel:
2992     {
2993       register const unsigned int
2994         *p;
2995
2996       p=(const unsigned int *) pixels;
2997       if (LocaleCompare(map,"BGR") == 0)
2998         {
2999           for (y=0; y < (ssize_t) rows; y++)
3000           {
3001             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3002             if (q == (Quantum *) NULL)
3003               break;
3004             for (x=0; x < (ssize_t) columns; x++)
3005             {
3006               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3007               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3008               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3009               q+=GetPixelChannels(image);
3010             }
3011             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3012               break;
3013           }
3014           break;
3015         }
3016       if (LocaleCompare(map,"BGRA") == 0)
3017         {
3018           for (y=0; y < (ssize_t) rows; y++)
3019           {
3020             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3021             if (q == (Quantum *) NULL)
3022               break;
3023             for (x=0; x < (ssize_t) columns; x++)
3024             {
3025               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3026               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3027               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3028               SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
3029               q+=GetPixelChannels(image);
3030             }
3031             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3032               break;
3033           }
3034           break;
3035         }
3036       if (LocaleCompare(map,"BGRP") == 0)
3037         {
3038           for (y=0; y < (ssize_t) rows; y++)
3039           {
3040             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3041             if (q == (Quantum *) NULL)
3042               break;
3043             for (x=0; x < (ssize_t) columns; x++)
3044             {
3045               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3046               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3047               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3048               p++;
3049               q+=GetPixelChannels(image);
3050             }
3051             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3052               break;
3053           }
3054           break;
3055         }
3056       if (LocaleCompare(map,"I") == 0)
3057         {
3058           for (y=0; y < (ssize_t) rows; y++)
3059           {
3060             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3061             if (q == (Quantum *) NULL)
3062               break;
3063             for (x=0; x < (ssize_t) columns; x++)
3064             {
3065               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3066               SetPixelGreen(image,GetPixelRed(image,q),q);
3067               SetPixelBlue(image,GetPixelRed(image,q),q);
3068               q+=GetPixelChannels(image);
3069             }
3070             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3071               break;
3072           }
3073           break;
3074         }
3075       if (LocaleCompare(map,"RGB") == 0)
3076         {
3077           for (y=0; y < (ssize_t) rows; y++)
3078           {
3079             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3080             if (q == (Quantum *) NULL)
3081               break;
3082             for (x=0; x < (ssize_t) columns; x++)
3083             {
3084               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3085               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3086               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3087               q+=GetPixelChannels(image);
3088             }
3089             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3090               break;
3091           }
3092           break;
3093         }
3094       if (LocaleCompare(map,"RGBA") == 0)
3095         {
3096           for (y=0; y < (ssize_t) rows; y++)
3097           {
3098             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3099             if (q == (Quantum *) NULL)
3100               break;
3101             for (x=0; x < (ssize_t) columns; x++)
3102             {
3103               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3104               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3105               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3106               SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
3107               q+=GetPixelChannels(image);
3108             }
3109             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3110               break;
3111           }
3112           break;
3113         }
3114       if (LocaleCompare(map,"RGBP") == 0)
3115         {
3116           for (y=0; y < (ssize_t) rows; y++)
3117           {
3118             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3119             if (q == (Quantum *) NULL)
3120               break;
3121             for (x=0; x < (ssize_t) columns; x++)
3122             {
3123               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3124               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3125               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3126               p++;
3127               q+=GetPixelChannels(image);
3128             }
3129             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3130               break;
3131           }
3132           break;
3133         }
3134       for (y=0; y < (ssize_t) rows; y++)
3135       {
3136         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3137         if (q == (Quantum *) NULL)
3138           break;
3139         for (x=0; x < (ssize_t) columns; x++)
3140         {
3141           for (i=0; i < (ssize_t) length; i++)
3142           {
3143             switch (quantum_map[i])
3144             {
3145               case RedQuantum:
3146               case CyanQuantum:
3147               {
3148                 SetPixelRed(image,ScaleLongToQuantum(*p),q);
3149                 break;
3150               }
3151               case GreenQuantum:
3152               case MagentaQuantum:
3153               {
3154                 SetPixelGreen(image,ScaleLongToQuantum(*p),q);
3155                 break;
3156               }
3157               case BlueQuantum:
3158               case YellowQuantum:
3159               {
3160                 SetPixelBlue(image,ScaleLongToQuantum(*p),q);
3161                 break;
3162               }
3163               case AlphaQuantum:
3164               {
3165                 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3166                 break;
3167               }
3168               case OpacityQuantum:
3169               {
3170                 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3171                 break;
3172               }
3173               case BlackQuantum:
3174               {
3175                 SetPixelBlack(image,ScaleLongToQuantum(*p),q);
3176                 break;
3177               }
3178               case IndexQuantum:
3179               {
3180                 SetPixelRed(image,ScaleLongToQuantum(*p),q);
3181                 SetPixelGreen(image,GetPixelRed(image,q),q);
3182                 SetPixelBlue(image,GetPixelRed(image,q),q);
3183                 break;
3184               }
3185               default:
3186                 break;
3187             }
3188             p++;
3189           }
3190           q+=GetPixelChannels(image);
3191         }
3192         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3193           break;
3194       }
3195       break;
3196     }
3197     case QuantumPixel:
3198     {
3199       register const Quantum
3200         *p;
3201
3202       p=(const Quantum *) pixels;
3203       if (LocaleCompare(map,"BGR") == 0)
3204         {
3205           for (y=0; y < (ssize_t) rows; y++)
3206           {
3207             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3208             if (q == (Quantum *) NULL)
3209               break;
3210             for (x=0; x < (ssize_t) columns; x++)
3211             {
3212               SetPixelBlue(image,*p++,q);
3213               SetPixelGreen(image,*p++,q);
3214               SetPixelRed(image,*p++,q);
3215               q+=GetPixelChannels(image);
3216             }
3217             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3218               break;
3219           }
3220           break;
3221         }
3222       if (LocaleCompare(map,"BGRA") == 0)
3223         {
3224           for (y=0; y < (ssize_t) rows; y++)
3225           {
3226             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3227             if (q == (Quantum *) NULL)
3228               break;
3229             for (x=0; x < (ssize_t) columns; x++)
3230             {
3231               SetPixelBlue(image,*p++,q);
3232               SetPixelGreen(image,*p++,q);
3233               SetPixelRed(image,*p++,q);
3234               SetPixelAlpha(image,*p++,q);
3235               q+=GetPixelChannels(image);
3236             }
3237             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3238               break;
3239           }
3240           break;
3241         }
3242       if (LocaleCompare(map,"BGRP") == 0)
3243         {
3244           for (y=0; y < (ssize_t) rows; y++)
3245           {
3246             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3247             if (q == (Quantum *) NULL)
3248               break;
3249             for (x=0; x < (ssize_t) columns; x++)
3250             {
3251               SetPixelBlue(image,*p++,q);
3252               SetPixelGreen(image,*p++,q);
3253               SetPixelRed(image,*p++,q);
3254               p++;
3255               q+=GetPixelChannels(image);
3256             }
3257             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3258               break;
3259           }
3260           break;
3261         }
3262       if (LocaleCompare(map,"I") == 0)
3263         {
3264           for (y=0; y < (ssize_t) rows; y++)
3265           {
3266             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3267             if (q == (Quantum *) NULL)
3268               break;
3269             for (x=0; x < (ssize_t) columns; x++)
3270             {
3271               SetPixelRed(image,*p++,q);
3272               SetPixelGreen(image,GetPixelRed(image,q),q);
3273               SetPixelBlue(image,GetPixelRed(image,q),q);
3274               q+=GetPixelChannels(image);
3275             }
3276             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3277               break;
3278           }
3279           break;
3280         }
3281       if (LocaleCompare(map,"RGB") == 0)
3282         {
3283           for (y=0; y < (ssize_t) rows; y++)
3284           {
3285             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3286             if (q == (Quantum *) NULL)
3287               break;
3288             for (x=0; x < (ssize_t) columns; x++)
3289             {
3290               SetPixelRed(image,*p++,q);
3291               SetPixelGreen(image,*p++,q);
3292               SetPixelBlue(image,*p++,q);
3293               q+=GetPixelChannels(image);
3294             }
3295             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3296               break;
3297           }
3298           break;
3299         }
3300       if (LocaleCompare(map,"RGBA") == 0)
3301         {
3302           for (y=0; y < (ssize_t) rows; y++)
3303           {
3304             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3305             if (q == (Quantum *) NULL)
3306               break;
3307             for (x=0; x < (ssize_t) columns; x++)
3308             {
3309               SetPixelRed(image,*p++,q);
3310               SetPixelGreen(image,*p++,q);
3311               SetPixelBlue(image,*p++,q);
3312               SetPixelAlpha(image,*p++,q);
3313               q+=GetPixelChannels(image);
3314             }
3315             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3316               break;
3317           }
3318           break;
3319         }
3320       if (LocaleCompare(map,"RGBP") == 0)
3321         {
3322           for (y=0; y < (ssize_t) rows; y++)
3323           {
3324             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3325             if (q == (Quantum *) NULL)
3326               break;
3327             for (x=0; x < (ssize_t) columns; x++)
3328             {
3329               SetPixelRed(image,*p++,q);
3330               SetPixelGreen(image,*p++,q);
3331               SetPixelBlue(image,*p++,q);
3332               p++;
3333               q+=GetPixelChannels(image);
3334             }
3335             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3336               break;
3337           }
3338           break;
3339         }
3340       for (y=0; y < (ssize_t) rows; y++)
3341       {
3342         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3343         if (q == (Quantum *) NULL)
3344           break;
3345         for (x=0; x < (ssize_t) columns; x++)
3346         {
3347           for (i=0; i < (ssize_t) length; i++)
3348           {
3349             switch (quantum_map[i])
3350             {
3351               case RedQuantum:
3352               case CyanQuantum:
3353               {
3354                 SetPixelRed(image,*p,q);
3355                 break;
3356               }
3357               case GreenQuantum:
3358               case MagentaQuantum:
3359               {
3360                 SetPixelGreen(image,*p,q);
3361                 break;
3362               }
3363               case BlueQuantum:
3364               case YellowQuantum:
3365               {
3366                 SetPixelBlue(image,*p,q);
3367                 break;
3368               }
3369               case AlphaQuantum:
3370               {
3371                 SetPixelAlpha(image,*p,q);
3372                 break;
3373               }
3374               case OpacityQuantum:
3375               {
3376                 SetPixelAlpha(image,*p,q);
3377                 break;
3378               }
3379               case BlackQuantum:
3380               {
3381                 SetPixelBlack(image,*p,q);
3382                 break;
3383               }
3384               case IndexQuantum:
3385               {
3386                 SetPixelRed(image,*p,q);
3387                 SetPixelGreen(image,GetPixelRed(image,q),q);
3388                 SetPixelBlue(image,GetPixelRed(image,q),q);
3389                 break;
3390               }
3391               default:
3392                 break;
3393             }
3394             p++;
3395           }
3396           q+=GetPixelChannels(image);
3397         }
3398         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3399           break;
3400       }
3401       break;
3402     }
3403     case ShortPixel:
3404     {
3405       register const unsigned short
3406         *p;
3407
3408       p=(const unsigned short *) pixels;
3409       if (LocaleCompare(map,"BGR") == 0)
3410         {
3411           for (y=0; y < (ssize_t) rows; y++)
3412           {
3413             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3414             if (q == (Quantum *) NULL)
3415               break;
3416             for (x=0; x < (ssize_t) columns; x++)
3417             {
3418               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3419               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3420               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3421               q+=GetPixelChannels(image);
3422             }
3423             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3424               break;
3425           }
3426           break;
3427         }
3428       if (LocaleCompare(map,"BGRA") == 0)
3429         {
3430           for (y=0; y < (ssize_t) rows; y++)
3431           {
3432             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3433             if (q == (Quantum *) NULL)
3434               break;
3435             for (x=0; x < (ssize_t) columns; x++)
3436             {
3437               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3438               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3439               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3440               SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3441               q+=GetPixelChannels(image);
3442             }
3443             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3444               break;
3445           }
3446           break;
3447         }
3448       if (LocaleCompare(map,"BGRP") == 0)
3449         {
3450           for (y=0; y < (ssize_t) rows; y++)
3451           {
3452             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3453             if (q == (Quantum *) NULL)
3454               break;
3455             for (x=0; x < (ssize_t) columns; x++)
3456             {
3457               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3458               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3459               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3460               p++;
3461               q+=GetPixelChannels(image);
3462             }
3463             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3464               break;
3465           }
3466           break;
3467         }
3468       if (LocaleCompare(map,"I") == 0)
3469         {
3470           for (y=0; y < (ssize_t) rows; y++)
3471           {
3472             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3473             if (q == (Quantum *) NULL)
3474               break;
3475             for (x=0; x < (ssize_t) columns; x++)
3476             {
3477               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3478               SetPixelGreen(image,GetPixelRed(image,q),q);
3479               SetPixelBlue(image,GetPixelRed(image,q),q);
3480               q+=GetPixelChannels(image);
3481             }
3482             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3483               break;
3484           }
3485           break;
3486         }
3487       if (LocaleCompare(map,"RGB") == 0)
3488         {
3489           for (y=0; y < (ssize_t) rows; y++)
3490           {
3491             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3492             if (q == (Quantum *) NULL)
3493               break;
3494             for (x=0; x < (ssize_t) columns; x++)
3495             {
3496               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3497               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3498               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3499               q+=GetPixelChannels(image);
3500             }
3501             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3502               break;
3503           }
3504           break;
3505         }
3506       if (LocaleCompare(map,"RGBA") == 0)
3507         {
3508           for (y=0; y < (ssize_t) rows; y++)
3509           {
3510             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3511             if (q == (Quantum *) NULL)
3512               break;
3513             for (x=0; x < (ssize_t) columns; x++)
3514             {
3515               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3516               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3517               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3518               SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3519               q+=GetPixelChannels(image);
3520             }
3521             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3522               break;
3523           }
3524           break;
3525         }
3526       if (LocaleCompare(map,"RGBP") == 0)
3527         {
3528           for (y=0; y < (ssize_t) rows; y++)
3529           {
3530             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3531             if (q == (Quantum *) NULL)
3532               break;
3533             for (x=0; x < (ssize_t) columns; x++)
3534             {
3535               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3536               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3537               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3538               p++;
3539               q+=GetPixelChannels(image);
3540             }
3541             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3542               break;
3543           }
3544           break;
3545         }
3546       for (y=0; y < (ssize_t) rows; y++)
3547       {
3548         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3549         if (q == (Quantum *) NULL)
3550           break;
3551         for (x=0; x < (ssize_t) columns; x++)
3552         {
3553           for (i=0; i < (ssize_t) length; i++)
3554           {
3555             switch (quantum_map[i])
3556             {
3557               case RedQuantum:
3558               case CyanQuantum:
3559               {
3560                 SetPixelRed(image,ScaleShortToQuantum(*p),q);
3561                 break;
3562               }
3563               case GreenQuantum:
3564               case MagentaQuantum:
3565               {
3566                 SetPixelGreen(image,ScaleShortToQuantum(*p),q);
3567                 break;
3568               }
3569               case BlueQuantum:
3570               case YellowQuantum:
3571               {
3572                 SetPixelBlue(image,ScaleShortToQuantum(*p),q);
3573                 break;
3574               }
3575               case AlphaQuantum:
3576               {
3577                 SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
3578                 break;
3579               }
3580               case OpacityQuantum:
3581               {
3582                 SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
3583                 break;
3584               }
3585               case BlackQuantum:
3586               {
3587                 SetPixelBlack(image,ScaleShortToQuantum(*p),q);
3588                 break;
3589               }
3590               case IndexQuantum:
3591               {
3592                 SetPixelRed(image,ScaleShortToQuantum(*p),q);
3593                 SetPixelGreen(image,GetPixelRed(image,q),q);
3594                 SetPixelBlue(image,GetPixelRed(image,q),q);
3595                 break;
3596               }
3597               default:
3598                 break;
3599             }
3600             p++;
3601           }
3602           q+=GetPixelChannels(image);
3603         }
3604         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3605           break;
3606       }
3607       break;
3608     }
3609     default:
3610     {
3611       quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3612       (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
3613         "UnrecognizedPixelMap","`%s'",map);
3614       break;
3615     }
3616   }
3617   quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3618   return(MagickTrue);
3619 }
3620 \f
3621 /*
3622 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3623 %                                                                             %
3624 %                                                                             %
3625 %                                                                             %
3626 +   I n i t i a l i z e P i x e l C h a n n e l M a p                         %
3627 %                                                                             %
3628 %                                                                             %
3629 %                                                                             %
3630 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3631 %
3632 %  InitializePixelChannelMap() defines the standard pixel component map.
3633 %
3634 %  The format of the InitializePixelChannelMap() method is:
3635 %
3636 %      void InitializePixelChannelMap(Image *image)
3637 %
3638 %  A description of each parameter follows:
3639 %
3640 %    o image: the image.
3641 %
3642 */
3643 MagickExport void InitializePixelChannelMap(Image *image)
3644 {
3645   PixelChannel
3646     alpha_channel;
3647
3648   register ssize_t
3649     i;
3650
3651   assert(image != (Image *) NULL);
3652   assert(image->signature == MagickSignature);
3653   for (i=0; i < (ssize_t) MaxPixelChannels; i++)
3654   {
3655     SetPixelChannelMapChannel(image,(PixelChannel) i,(PixelChannel) i);
3656     SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
3657   }
3658   image->number_channels=4;
3659   if (0 && image->colorspace == GRAYColorspace)
3660     image->number_channels=2;
3661   if (image->colorspace == CMYKColorspace)
3662     image->number_channels++;
3663   if (image->storage_class == PseudoClass)
3664     image->number_channels++;
3665   for (i=0; i < (ssize_t) image->number_channels; i++)
3666     SetPixelChannelMapTraits(image,(PixelChannel) i,(PixelTrait)
3667       UpdatePixelTrait);
3668   alpha_channel=GetPixelChannelMapChannel(image,AlphaPixelChannel);
3669   if (image->matte == MagickFalse)
3670     SetPixelChannelMapTraits(image,AlphaPixelChannel,CopyPixelTrait);
3671   else
3672     for (i=0; i < (ssize_t) image->number_channels; i++)
3673       if ((PixelChannel) i != alpha_channel)
3674         SetPixelChannelMapTraits(image,(PixelChannel) i,(PixelTrait)
3675           (UpdatePixelTrait | BlendPixelTrait));
3676   if (0 && image->colorspace == GRAYColorspace)
3677     {
3678       image->number_channels=2;
3679       SetPixelChannelMapChannel(image,GreenPixelChannel,RedPixelChannel);
3680       SetPixelChannelMapChannel(image,BluePixelChannel,RedPixelChannel);
3681     }
3682   if (image->storage_class == PseudoClass)
3683     {
3684       SetPixelChannelMapChannel(image,IndexPixelChannel,IndexPixelChannel);
3685       SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
3686     }
3687   image->number_channels+=image->number_meta_channels;
3688   for ( ; i < (ssize_t) image->number_channels; i++)
3689     SetPixelChannelMapTraits(image,(PixelChannel) i,CopyPixelTrait);
3690   if (image->debug != MagickFalse)
3691     LogPixelChannels(image);
3692   (void) SetPixelChannelMask(image,image->channel_mask);
3693 }
3694 \f
3695 /*
3696 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3697 %                                                                             %
3698 %                                                                             %
3699 %                                                                             %
3700 %   I n t e r p o l a t e P i x e l C h a n n e l                             %
3701 %                                                                             %
3702 %                                                                             %
3703 %                                                                             %
3704 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3705 %
3706 %  InterpolatePixelChannel() applies a pixel interpolation method between a
3707 %  floating point coordinate and the pixels surrounding that coordinate.  No
3708 %  pixel area resampling, or scaling of the result is performed.
3709 %
3710 %  The format of the InterpolatePixelChannel method is:
3711 %
3712 %      MagickBooleanType InterpolatePixelChannel(const Image *image,
3713 %        const CacheView *image_view,const PixelChannel channel,
3714 %        const PixelInterpolateMethod method,const double x,const double y,
3715 %        double *pixel,ExceptionInfo *exception)
3716 %
3717 %  A description of each parameter follows:
3718 %
3719 %    o image: the image.
3720 %
3721 %    o image_view: the image view.
3722 %
3723 %    o channel: the pixel channel to interpolate.
3724 %
3725 %    o method: the pixel color interpolation method.
3726 %
3727 %    o x,y: A double representing the current (x,y) position of the pixel.
3728 %
3729 %    o pixel: return the interpolated pixel here.
3730 %
3731 %    o exception: return any errors or warnings in this structure.
3732 %
3733 */
3734
3735 static inline double MagickMax(const MagickRealType x,const MagickRealType y)
3736 {
3737   if (x > y)
3738     return(x);
3739   return(y);
3740 }
3741
3742 static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
3743 {
3744   MagickRealType
3745     alpha,
3746     gamma;
3747
3748   alpha=MagickMax(x+2.0,0.0);
3749   gamma=1.0*alpha*alpha*alpha;
3750   alpha=MagickMax(x+1.0,0.0);
3751   gamma-=4.0*alpha*alpha*alpha;
3752   alpha=MagickMax(x+0.0,0.0);
3753   gamma+=6.0*alpha*alpha*alpha;
3754   alpha=MagickMax(x-1.0,0.0);
3755   gamma-=4.0*alpha*alpha*alpha;
3756   return(gamma/6.0);
3757 }
3758
3759 static inline double MeshInterpolate(const PointInfo *delta,const double p,
3760   const double x,const double y)
3761 {
3762   return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3763 }
3764
3765 static inline ssize_t NearestNeighbor(const MagickRealType x)
3766 {
3767   if (x >= 0.0)
3768     return((ssize_t) (x+0.5));
3769   return((ssize_t) (x-0.5));
3770 }
3771
3772 MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
3773   const CacheView *image_view,const PixelChannel channel,
3774   const PixelInterpolateMethod method,const double x,const double y,
3775   double *pixel,ExceptionInfo *exception)
3776 {
3777   MagickBooleanType
3778     status;
3779
3780   MagickRealType
3781     alpha[16],
3782     gamma,
3783     pixels[16];
3784
3785   PixelTrait
3786     traits;
3787
3788   register const Quantum
3789     *p;
3790
3791   register ssize_t
3792     i;
3793
3794   ssize_t
3795     x_offset,
3796     y_offset;
3797
3798   assert(image != (Image *) NULL);
3799   assert(image != (Image *) NULL);
3800   assert(image->signature == MagickSignature);
3801   assert(image_view != (CacheView *) NULL);
3802   status=MagickTrue;
3803   *pixel=0.0;
3804   traits=GetPixelChannelMapTraits(image,channel);
3805   x_offset=(ssize_t) floor(x);
3806   y_offset=(ssize_t) floor(y);
3807   switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
3808   {
3809     case AverageInterpolatePixel:
3810     {
3811       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3812         exception);
3813       if (p == (const Quantum *) NULL)
3814         {
3815           status=MagickFalse;
3816           break;
3817         }
3818       if ((traits & BlendPixelTrait) == 0)
3819         for (i=0; i < 16; i++)
3820         {
3821           alpha[i]=1.0;
3822           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3823         }
3824       else
3825         for (i=0; i < 16; i++)
3826         {
3827           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3828             GetPixelChannels(image));
3829           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3830         }
3831       for (i=0; i < 16; i++)
3832       {
3833         gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
3834         *pixel+=gamma*0.0625*pixels[i];
3835       }
3836       break;
3837     }
3838     case BicubicInterpolatePixel:
3839     {
3840       MagickRealType
3841         u[4],
3842         v[4];
3843
3844       PointInfo
3845         delta;
3846
3847       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3848         exception);
3849       if (p == (const Quantum *) NULL)
3850         {
3851           status=MagickFalse;
3852           break;
3853         }
3854       if ((traits & BlendPixelTrait) == 0)
3855         for (i=0; i < 16; i++)
3856         {
3857           alpha[i]=1.0;
3858           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3859         }
3860       else
3861         for (i=0; i < 16; i++)
3862         {
3863           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3864             GetPixelChannels(image));
3865           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3866         }
3867       delta.x=x-x_offset;
3868       delta.y=y-y_offset;
3869       for (i=0; i < 4; i++)
3870       {
3871         u[0]=(pixels[4*i+3]-pixels[4*i+2])-(pixels[4*i+0]-pixels[4*i+1]);
3872         u[1]=(pixels[4*i+0]-pixels[4*i+1])-u[0];
3873         u[2]=pixels[4*i+2]-pixels[4*i+0];
3874         u[3]=pixels[4*i+1];
3875         v[i]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
3876           u[2])+u[3];
3877       }
3878       u[0]=(v[3]-v[2])-(v[0]-v[1]);
3879       u[1]=(v[0]-v[1])-u[0];
3880       u[2]=v[2]-v[0];
3881       u[3]=v[1];
3882       *pixel=(delta.y*delta.y*delta.y*u[0])+(delta.y*delta.y*u[1])+(delta.y*
3883         u[2])+u[3];
3884       break;
3885     }
3886     case BilinearInterpolatePixel:
3887     default:
3888     {
3889       PointInfo
3890         delta,
3891         epsilon;
3892
3893       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3894       if (p == (const Quantum *) NULL)
3895         {
3896           status=MagickFalse;
3897           break;
3898         }
3899       if ((traits & BlendPixelTrait) == 0)
3900         for (i=0; i < 4; i++)
3901         {
3902           alpha[i]=1.0;
3903           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3904         }
3905       else
3906         for (i=0; i < 4; i++)
3907         {
3908           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3909             GetPixelChannels(image));
3910           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3911         }
3912       delta.x=x-x_offset;
3913       delta.y=y-y_offset;
3914       epsilon.x=1.0-delta.x;
3915       epsilon.y=1.0-delta.y;
3916       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
3917         (epsilon.x*alpha[2]+delta.x*alpha[3])));
3918       gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3919       *pixel=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
3920         (epsilon.x*pixels[2]+delta.x*pixels[3]));
3921       break;
3922     }
3923     case FilterInterpolatePixel:
3924     {
3925       CacheView
3926         *filter_view;
3927
3928       Image
3929         *excerpt_image,
3930         *filter_image;
3931
3932       RectangleInfo
3933         geometry;
3934
3935       geometry.width=4L;
3936       geometry.height=4L;
3937       geometry.x=x_offset-1;
3938       geometry.y=y_offset-1;
3939       excerpt_image=ExcerptImage(image,&geometry,exception);
3940       if (excerpt_image == (Image *) NULL)
3941         {
3942           status=MagickFalse;
3943           break;
3944         }
3945       filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
3946         exception);
3947       excerpt_image=DestroyImage(excerpt_image);
3948       if (filter_image == (Image *) NULL)
3949         break;
3950       filter_view=AcquireCacheView(filter_image);
3951       p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
3952       if (p == (const Quantum *) NULL)
3953         status=MagickFalse;
3954       else
3955         *pixel=(double) GetPixelChannel(image,channel,p);
3956       filter_view=DestroyCacheView(filter_view);
3957       filter_image=DestroyImage(filter_image);
3958       break;
3959     }
3960     case IntegerInterpolatePixel:
3961     {
3962       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
3963       if (p == (const Quantum *) NULL)
3964         {
3965           status=MagickFalse;
3966           break;
3967         }
3968       *pixel=(double) GetPixelChannel(image,channel,p);
3969       break;
3970     }
3971     case NearestNeighborInterpolatePixel:
3972     {
3973       p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
3974         NearestNeighbor(y),1,1,exception);
3975       if (p == (const Quantum *) NULL)
3976         {
3977           status=MagickFalse;
3978           break;
3979         }
3980       *pixel=(double) GetPixelChannel(image,channel,p);
3981       break;
3982     }
3983     case MeshInterpolatePixel:
3984     {
3985       PointInfo
3986         delta,
3987         luminance;
3988
3989       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3990       if (p == (const Quantum *) NULL)
3991         {
3992           status=MagickFalse;
3993           break;
3994         }
3995       if ((traits & BlendPixelTrait) == 0)
3996         for (i=0; i < 4; i++)
3997         {
3998           alpha[i]=1.0;
3999           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4000         }
4001       else
4002         for (i=0; i < 4; i++)
4003         {
4004           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4005             GetPixelChannels(image));
4006           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4007         }
4008       delta.x=x-x_offset;
4009       delta.y=y-y_offset;
4010       luminance.x=GetPixelLuminance(image,p)-(double)
4011         GetPixelLuminance(image,p+3*GetPixelChannels(image));
4012       luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
4013         GetPixelLuminance(image,p+2*GetPixelChannels(image));
4014       if (fabs(luminance.x) < fabs(luminance.y))
4015         {
4016           /*
4017             Diagonal 0-3 NW-SE.
4018           */
4019           if (delta.x <= delta.y)
4020             {
4021               /*
4022                 Bottom-left triangle (pixel: 2, diagonal: 0-3).
4023               */
4024               delta.y=1.0-delta.y;
4025               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4026               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4027               *pixel=gamma*MeshInterpolate(&delta,pixels[2],pixels[3],
4028                 pixels[0]);
4029             }
4030           else
4031             {
4032               /*
4033                 Top-right triangle (pixel: 1, diagonal: 0-3).
4034               */
4035               delta.x=1.0-delta.x;
4036               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4037               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4038               *pixel=gamma*MeshInterpolate(&delta,pixels[1],pixels[0],
4039                 pixels[3]);
4040             }
4041         }
4042       else
4043         {
4044           /*
4045             Diagonal 1-2 NE-SW.
4046           */
4047           if (delta.x <= (1.0-delta.y))
4048             {
4049               /*
4050                 Top-left triangle (pixel: 0, diagonal: 1-2).
4051               */
4052               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4053               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4054               *pixel=gamma*MeshInterpolate(&delta,pixels[0],pixels[1],
4055                 pixels[2]);
4056             }
4057           else
4058             {
4059               /*
4060                 Bottom-right triangle (pixel: 3, diagonal: 1-2).
4061               */
4062               delta.x=1.0-delta.x;
4063               delta.y=1.0-delta.y;
4064               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4065               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4066               *pixel=gamma*MeshInterpolate(&delta,pixels[3],pixels[2],
4067                 pixels[1]);
4068             }
4069         }
4070       break;
4071     }
4072     case SplineInterpolatePixel:
4073     {
4074       MagickRealType
4075         dx,
4076         dy;
4077
4078       PointInfo
4079         delta;
4080
4081       ssize_t
4082         j,
4083         n;
4084
4085       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4086         exception);
4087       if (p == (const Quantum *) NULL)
4088         {
4089           status=MagickFalse;
4090           break;
4091         }
4092       if ((traits & BlendPixelTrait) == 0)
4093         for (i=0; i < 16; i++)
4094         {
4095           alpha[i]=1.0;
4096           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4097         }
4098       else
4099         for (i=0; i < 16; i++)
4100         {
4101           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4102             GetPixelChannels(image));
4103           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4104         }
4105       delta.x=x-x_offset;
4106       delta.y=y-y_offset;
4107       n=0;
4108       for (i=(-1); i < 3L; i++)
4109       {
4110         dy=CubicWeightingFunction((MagickRealType) i-delta.y);
4111         for (j=(-1); j < 3L; j++)
4112         {
4113           dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
4114           gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
4115           *pixel+=gamma*dx*dy*pixels[n];
4116           n++;
4117         }
4118       }
4119       break;
4120     }
4121   }
4122   return(status);
4123 }
4124 \f
4125 /*
4126 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4127 %                                                                             %
4128 %                                                                             %
4129 %                                                                             %
4130 %   I n t e r p o l a t e P i x e l C h a n n e l s                           %
4131 %                                                                             %
4132 %                                                                             %
4133 %                                                                             %
4134 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4135 %
4136 %  InterpolatePixelChannels() applies a pixel interpolation method between a
4137 %  floating point coordinate and the pixels surrounding that coordinate.  No
4138 %  pixel area resampling, or scaling of the result is performed.
4139 %
4140 %  The format of the InterpolatePixelChannels method is:
4141 %
4142 %      MagickBooleanType InterpolatePixelChannels(const Image *source,
4143 %        const CacheView *source_view,const Image *destination,
4144 %        const PixelInterpolateMethod method,const double x,const double y,
4145 %        Quantum *pixel,ExceptionInfo *exception)
4146 %
4147 %  A description of each parameter follows:
4148 %
4149 %    o source: the source.
4150 %
4151 %    o source_view: the source view.
4152 %
4153 %    o destination: the destination image.
4154 %
4155 %    o method: the pixel color interpolation method.
4156 %
4157 %    o x,y: A double representing the current (x,y) position of the pixel.
4158 %
4159 %    o pixel: return the interpolated pixel here.
4160 %
4161 %    o exception: return any errors or warnings in this structure.
4162 %
4163 */
4164 MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
4165   const CacheView *source_view,const Image *destination,
4166   const PixelInterpolateMethod method,const double x,const double y,
4167   Quantum *pixel,ExceptionInfo *exception)
4168 {
4169   MagickBooleanType
4170     status;
4171
4172   MagickRealType
4173     alpha[16],
4174     gamma,
4175     pixels[16];
4176
4177   PixelChannel
4178     channel;
4179
4180   PixelTrait
4181     destination_traits,
4182     traits;
4183
4184   register const Quantum
4185     *p;
4186
4187   register ssize_t
4188     i;
4189
4190   ssize_t
4191     x_offset,
4192     y_offset;
4193
4194   assert(source != (Image *) NULL);
4195   assert(source != (Image *) NULL);
4196   assert(source->signature == MagickSignature);
4197   assert(source_view != (CacheView *) NULL);
4198   status=MagickTrue;
4199   x_offset=(ssize_t) floor(x);
4200   y_offset=(ssize_t) floor(y);
4201   switch (method == UndefinedInterpolatePixel ? source->interpolate : method)
4202   {
4203     case AverageInterpolatePixel:
4204     {
4205       p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4206         exception);
4207       if (p == (const Quantum *) NULL)
4208         {
4209           status=MagickFalse;
4210           break;
4211         }
4212       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4213       {
4214         double
4215           sum;
4216
4217         register ssize_t
4218           j;
4219
4220         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4221         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4222         destination_traits=GetPixelChannelMapTraits(destination,channel);
4223         if ((traits == UndefinedPixelTrait) ||
4224             (destination_traits == UndefinedPixelTrait))
4225           continue;
4226         for (j=0; j < 16; j++)
4227           pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4228         if ((traits & BlendPixelTrait) == 0)
4229           {
4230             for (j=0; j < 16; j++)
4231               pixel[channel]+=0.0625*pixels[j];
4232             continue;
4233           }
4234         sum=0.0;
4235         for (j=0; j < 16; j++)
4236         {
4237           alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4238             GetPixelChannels(source));
4239           pixels[j]*=alpha[j];
4240           gamma=1.0/(fabs((double) alpha[j]) <= MagickEpsilon ? 1.0 : alpha[j]);
4241           sum+=gamma*0.0625*pixels[j];
4242         }
4243         pixel[channel]=ClampToQuantum(sum);
4244       }
4245       break;
4246     }
4247     case BicubicInterpolatePixel:
4248     {
4249       MagickRealType
4250         u[4],
4251         v[4];
4252
4253       PointInfo
4254         delta;
4255
4256       p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4257         exception);
4258       if (p == (const Quantum *) NULL)
4259         {
4260           status=MagickFalse;
4261           break;
4262         }
4263       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4264       {
4265         register ssize_t
4266           j;
4267
4268         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4269         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4270         destination_traits=GetPixelChannelMapTraits(destination,channel);
4271         if ((traits == UndefinedPixelTrait) ||
4272             (destination_traits == UndefinedPixelTrait))
4273           continue;
4274         if ((traits & BlendPixelTrait) == 0)
4275           for (j=0; j < 16; j++)
4276           {
4277             alpha[j]=1.0;
4278             pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4279           }
4280         else
4281           for (j=0; j < 16; j++)
4282           {
4283             alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4284               GetPixelChannels(source));
4285             pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
4286           }
4287         delta.x=x-x_offset;
4288         delta.y=y-y_offset;
4289         for (j=0; j < 4; j++)
4290         {
4291           u[0]=(pixels[4*j+3]-pixels[4*j+2])-(pixels[4*j+0]-pixels[4*j+1]);
4292           u[1]=(pixels[4*j+0]-pixels[4*j+1])-u[0];
4293           u[2]=pixels[4*j+2]-pixels[4*j+0];
4294           u[3]=pixels[4*j+1];
4295           v[j]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
4296             u[2])+u[3];
4297         }
4298         u[0]=(v[3]-v[2])-(v[0]-v[1]);
4299         u[1]=(v[0]-v[1])-u[0];
4300         u[2]=v[2]-v[0];
4301         u[3]=v[1];
4302         pixel[channel]=ClampToQuantum((delta.y*delta.y*delta.y*u[0])+(delta.y*
4303           delta.y*u[1])+(delta.y*u[2])+u[3]);
4304       }
4305       break;
4306     }
4307     case BilinearInterpolatePixel:
4308     default:
4309     {
4310       p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
4311       if (p == (const Quantum *) NULL)
4312         {
4313           status=MagickFalse;
4314           break;
4315         }
4316       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4317       {
4318         PointInfo
4319           delta,
4320           epsilon;
4321
4322         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4323         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4324         destination_traits=GetPixelChannelMapTraits(destination,channel);
4325         if ((traits == UndefinedPixelTrait) ||
4326             (destination_traits == UndefinedPixelTrait))
4327           continue;
4328         delta.x=x-x_offset;
4329         delta.y=y-y_offset;
4330         epsilon.x=1.0-delta.x;
4331         epsilon.y=1.0-delta.y;
4332         pixels[0]=(MagickRealType) p[i];
4333         pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
4334         pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
4335         pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
4336         if ((traits & BlendPixelTrait) == 0)
4337           {
4338             gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4339             gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4340             pixel[channel]=ClampToQuantum(gamma*(epsilon.y*(epsilon.x*pixels[0]+
4341               delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+delta.x*
4342               pixels[3])));
4343             continue;
4344           }
4345         alpha[0]=QuantumScale*GetPixelAlpha(source,p);
4346         alpha[1]=QuantumScale*GetPixelAlpha(source,p+GetPixelChannels(source));
4347         alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
4348           GetPixelChannels(source));
4349         alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
4350           GetPixelChannels(source));
4351         pixels[0]*=alpha[0];
4352         pixels[1]*=alpha[1];
4353         pixels[2]*=alpha[2];
4354         pixels[3]*=alpha[3];
4355         gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4356           (epsilon.x*alpha[2]+delta.x*alpha[3])));
4357         gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4358         pixel[channel]=ClampToQuantum(gamma*(epsilon.y*(epsilon.x*pixels[0]+
4359           delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+delta.x*pixels[3])));
4360       }
4361       break;
4362     }
4363     case FilterInterpolatePixel:
4364     {
4365       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4366       {
4367         CacheView
4368           *filter_view;
4369
4370         Image
4371           *excerpt_source,
4372           *filter_source;
4373
4374         RectangleInfo
4375           geometry;
4376
4377         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4378         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4379         destination_traits=GetPixelChannelMapTraits(destination,channel);
4380         if ((traits == UndefinedPixelTrait) ||
4381             (destination_traits == UndefinedPixelTrait))
4382           continue;
4383         geometry.width=4L;
4384         geometry.height=4L;
4385         geometry.x=x_offset-1;
4386         geometry.y=y_offset-1;
4387         excerpt_source=ExcerptImage(source,&geometry,exception);
4388         if (excerpt_source == (Image *) NULL)
4389           {
4390             status=MagickFalse;
4391             continue;
4392           }
4393         filter_source=ResizeImage(excerpt_source,1,1,source->filter,
4394           source->blur,exception);
4395         excerpt_source=DestroyImage(excerpt_source);
4396         if (filter_source == (Image *) NULL)
4397           continue;
4398         filter_view=AcquireCacheView(filter_source);
4399         p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4400         if (p == (const Quantum *) NULL)
4401           status=MagickFalse;
4402         else
4403           pixel[channel]=p[i];
4404         filter_view=DestroyCacheView(filter_view);
4405         filter_source=DestroyImage(filter_source);
4406       }
4407       break;
4408     }
4409     case IntegerInterpolatePixel:
4410     {
4411       p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
4412       if (p == (const Quantum *) NULL)
4413         {
4414           status=MagickFalse;
4415           break;
4416         }
4417       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4418       {
4419         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4420         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4421         destination_traits=GetPixelChannelMapTraits(destination,channel);
4422         if ((traits == UndefinedPixelTrait) ||
4423             (destination_traits == UndefinedPixelTrait))
4424           continue;
4425         pixel[channel]=p[i];
4426       }
4427       break;
4428     }
4429     case NearestNeighborInterpolatePixel:
4430     {
4431       p=GetCacheViewVirtualPixels(source_view,NearestNeighbor(x),
4432         NearestNeighbor(y),1,1,exception);
4433       if (p == (const Quantum *) NULL)
4434         {
4435           status=MagickFalse;
4436           break;
4437         }
4438       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4439       {
4440         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4441         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4442         destination_traits=GetPixelChannelMapTraits(destination,channel);
4443         if ((traits == UndefinedPixelTrait) ||
4444             (destination_traits == UndefinedPixelTrait))
4445           continue;
4446         pixel[channel]=p[i];
4447       }
4448       break;
4449     }
4450     case MeshInterpolatePixel:
4451     {
4452       p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
4453       if (p == (const Quantum *) NULL)
4454         {
4455           status=MagickFalse;
4456           break;
4457         }
4458       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4459       {
4460         PointInfo
4461           delta,
4462           luminance;
4463
4464         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4465         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4466         destination_traits=GetPixelChannelMapTraits(destination,channel);
4467         if ((traits == UndefinedPixelTrait) ||
4468             (destination_traits == UndefinedPixelTrait))
4469           continue;
4470        pixels[0]=(MagickRealType) p[i];
4471        pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
4472        pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
4473        pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
4474        if ((traits & BlendPixelTrait) == 0)
4475          {
4476            alpha[0]=1.0;
4477            alpha[1]=1.0;
4478            alpha[2]=1.0;
4479            alpha[3]=1.0;
4480          }
4481        else
4482          {
4483            alpha[0]=QuantumScale*GetPixelAlpha(source,p);
4484            alpha[1]=QuantumScale*GetPixelAlpha(source,p+
4485              GetPixelChannels(source));
4486            alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
4487              GetPixelChannels(source));
4488            alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
4489              GetPixelChannels(source));
4490          }
4491        delta.x=x-x_offset;
4492        delta.y=y-y_offset;
4493        luminance.x=GetPixelLuminance(source,p)-(double)
4494          GetPixelLuminance(source,p+3*GetPixelChannels(source));
4495        luminance.y=GetPixelLuminance(source,p+GetPixelChannels(source))-
4496          (double) GetPixelLuminance(source,p+2*GetPixelChannels(source));
4497        if (fabs(luminance.x) < fabs(luminance.y))
4498          {
4499            /*
4500              Diagonal 0-3 NW-SE.
4501            */
4502            if (delta.x <= delta.y)
4503              {
4504                /*
4505                  Bottom-left triangle (pixel: 2, diagonal: 0-3).
4506                */
4507                delta.y=1.0-delta.y;
4508                gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4509                gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4510                pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4511                  pixels[2],pixels[3],pixels[0]));
4512              }
4513            else
4514              {
4515                /*
4516                  Top-right triangle (pixel: 1, diagonal: 0-3).
4517                */
4518                delta.x=1.0-delta.x;
4519                gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4520                gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4521                pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4522                  pixels[1],pixels[0],pixels[3]));
4523              }
4524          }
4525        else
4526          {
4527            /*
4528              Diagonal 1-2 NE-SW.
4529            */
4530            if (delta.x <= (1.0-delta.y))
4531              {
4532                /*
4533                  Top-left triangle (pixel: 0, diagonal: 1-2).
4534                */
4535                gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4536                gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4537                pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4538                  pixels[0],pixels[1],pixels[2]));
4539              }
4540            else
4541              {
4542                /*
4543                  Bottom-right triangle (pixel: 3, diagonal: 1-2).
4544                */
4545                delta.x=1.0-delta.x;
4546                delta.y=1.0-delta.y;
4547                gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4548                gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4549                pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4550                  pixels[3],pixels[2],pixels[1]));
4551              }
4552          }
4553       }
4554       break;
4555     }
4556     case SplineInterpolatePixel:
4557     {
4558       p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4559         exception);
4560       if (p == (const Quantum *) NULL)
4561         {
4562           status=MagickFalse;
4563           break;
4564         }
4565       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4566       {
4567         double
4568           sum;
4569
4570         MagickRealType
4571           dx,
4572           dy;
4573
4574         PointInfo
4575           delta;
4576
4577         register ssize_t
4578           j;
4579
4580         ssize_t
4581           k,
4582           n;
4583
4584         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4585         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4586         destination_traits=GetPixelChannelMapTraits(destination,channel);
4587         if ((traits == UndefinedPixelTrait) ||
4588             (destination_traits == UndefinedPixelTrait))
4589           continue;
4590         if ((traits & BlendPixelTrait) == 0)
4591           for (j=0; j < 16; j++)
4592           {
4593             alpha[j]=1.0;
4594             pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4595           }
4596         else
4597           for (j=0; j < 16; j++)
4598           {
4599             alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4600               GetPixelChannels(source));
4601             pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
4602           }
4603         delta.x=x-x_offset;
4604         delta.y=y-y_offset;
4605         sum=0.0;
4606         n=0;
4607         for (j=(-1); j < 3L; j++)
4608         {
4609           dy=CubicWeightingFunction((MagickRealType) j-delta.y);
4610           for (k=(-1); k < 3L; k++)
4611           {
4612             dx=CubicWeightingFunction(delta.x-(MagickRealType) k);
4613             gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 :
4614               alpha[n]);
4615             sum+=gamma*dx*dy*pixels[n];
4616             n++;
4617           }
4618         }
4619         pixel[channel]=ClampToQuantum(sum);
4620       }
4621       break;
4622     }
4623   }
4624   return(status);
4625 }
4626 \f
4627 /*
4628 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4629 %                                                                             %
4630 %                                                                             %
4631 %                                                                             %
4632 %   I n t e r p o l a t e P i x e l I n f o                                   %
4633 %                                                                             %
4634 %                                                                             %
4635 %                                                                             %
4636 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4637 %
4638 %  InterpolatePixelInfo() applies a pixel interpolation method between a
4639 %  floating point coordinate and the pixels surrounding that coordinate.  No
4640 %  pixel area resampling, or scaling of the result is performed.
4641 %
4642 %  The format of the InterpolatePixelInfo method is:
4643 %
4644 %      MagickBooleanType InterpolatePixelInfo(const Image *image,
4645 %        const CacheView *image_view,const PixelInterpolateMethod method,
4646 %        const double x,const double y,PixelInfo *pixel,
4647 %        ExceptionInfo *exception)
4648 %
4649 %  A description of each parameter follows:
4650 %
4651 %    o image: the image.
4652 %
4653 %    o image_view: the image view.
4654 %
4655 %    o method: the pixel color interpolation method.
4656 %
4657 %    o x,y: A double representing the current (x,y) position of the pixel.
4658 %
4659 %    o pixel: return the interpolated pixel here.
4660 %
4661 %    o exception: return any errors or warnings in this structure.
4662 %
4663 */
4664
4665 static inline void AlphaBlendPixelInfo(const Image *image,
4666   const Quantum *pixel,PixelInfo *pixel_info,MagickRealType *alpha)
4667 {
4668   if (image->matte == MagickFalse)
4669     {
4670       *alpha=1.0;
4671       pixel_info->red=(MagickRealType) GetPixelRed(image,pixel);
4672       pixel_info->green=(MagickRealType) GetPixelGreen(image,pixel);
4673       pixel_info->blue=(MagickRealType) GetPixelBlue(image,pixel);
4674       pixel_info->black=0.0;
4675       if (image->colorspace == CMYKColorspace)
4676         pixel_info->black=(MagickRealType) GetPixelBlack(image,pixel);
4677       pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
4678       return;
4679     }
4680   *alpha=QuantumScale*GetPixelAlpha(image,pixel);
4681   pixel_info->red=(*alpha*GetPixelRed(image,pixel));
4682   pixel_info->green=(*alpha*GetPixelGreen(image,pixel));
4683   pixel_info->blue=(*alpha*GetPixelBlue(image,pixel));
4684   pixel_info->black=0.0;
4685   if (image->colorspace == CMYKColorspace)
4686     pixel_info->black=(*alpha*GetPixelBlack(image,pixel));
4687   pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
4688 }
4689
4690 static void BicubicInterpolate(const PixelInfo *pixels,const double dx,
4691   PixelInfo *pixel)
4692 {
4693   MagickRealType
4694     dx2,
4695     p,
4696     q,
4697     r,
4698     s;
4699
4700   dx2=dx*dx;
4701   p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
4702   q=(pixels[0].red-pixels[1].red)-p;
4703   r=pixels[2].red-pixels[0].red;
4704   s=pixels[1].red;
4705   pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4706   p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
4707   q=(pixels[0].green-pixels[1].green)-p;
4708   r=pixels[2].green-pixels[0].green;
4709   s=pixels[1].green;
4710   pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4711   p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
4712   q=(pixels[0].blue-pixels[1].blue)-p;
4713   r=pixels[2].blue-pixels[0].blue;
4714   s=pixels[1].blue;
4715   pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4716   p=(pixels[3].alpha-pixels[2].alpha)-(pixels[0].alpha-pixels[1].alpha);
4717   q=(pixels[0].alpha-pixels[1].alpha)-p;
4718   r=pixels[2].alpha-pixels[0].alpha;
4719   s=pixels[1].alpha;
4720   pixel->alpha=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4721   if (pixel->colorspace == CMYKColorspace)
4722     {
4723       p=(pixels[3].black-pixels[2].black)-(pixels[0].black-pixels[1].black);
4724       q=(pixels[0].black-pixels[1].black)-p;
4725       r=pixels[2].black-pixels[0].black;
4726       s=pixels[1].black;
4727       pixel->black=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4728     }
4729 }
4730
4731 MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
4732   const CacheView *image_view,const PixelInterpolateMethod method,
4733   const double x,const double y,PixelInfo *pixel,ExceptionInfo *exception)
4734 {
4735   MagickBooleanType
4736     status;
4737
4738   MagickRealType
4739     alpha[16],
4740     gamma;
4741
4742   PixelInfo
4743     pixels[16];
4744
4745   register const Quantum
4746     *p;
4747
4748   register ssize_t
4749     i;
4750
4751   ssize_t
4752     x_offset,
4753     y_offset;
4754
4755   assert(image != (Image *) NULL);
4756   assert(image->signature == MagickSignature);
4757   assert(image_view != (CacheView *) NULL);
4758   status=MagickTrue;
4759   x_offset=(ssize_t) floor(x);
4760   y_offset=(ssize_t) floor(y);
4761   switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
4762   {
4763     case AverageInterpolatePixel:
4764     {
4765       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4766         exception);
4767       if (p == (const Quantum *) NULL)
4768         {
4769           status=MagickFalse;
4770           break;
4771         }
4772       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4773       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4774       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4775       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4776       AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4777       AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4778       AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4779       AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4780       AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4781       AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4782       AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4783         10);
4784       AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4785         11);
4786       AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4787         12);
4788       AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4789         13);
4790       AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4791         14);
4792       AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4793         15);
4794       pixel->red=0.0;
4795       pixel->green=0.0;
4796       pixel->blue=0.0;
4797       pixel->black=0.0;
4798       pixel->alpha=0.0;
4799       for (i=0; i < 16L; i++)
4800       {
4801         gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
4802         pixel->red+=gamma*0.0625*pixels[i].red;
4803         pixel->green+=gamma*0.0625*pixels[i].green;
4804         pixel->blue+=gamma*0.0625*pixels[i].blue;
4805         if (image->colorspace == CMYKColorspace)
4806           pixel->black+=gamma*0.0625*pixels[i].black;
4807         pixel->alpha+=0.0625*pixels[i].alpha;
4808       }
4809       break;
4810     }
4811     case BicubicInterpolatePixel:
4812     {
4813       PixelInfo
4814         u[4];
4815
4816       PointInfo
4817         delta;
4818
4819       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4820         exception);
4821       if (p == (const Quantum *) NULL)
4822         {
4823           status=MagickFalse;
4824           break;
4825         }
4826       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4827       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4828       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4829       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4830       AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4831       AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4832       AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4833       AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4834       AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4835       AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4836       AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4837         10);
4838       AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4839         11);
4840       AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4841         12);
4842       AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4843         13);
4844       AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4845         14);
4846       AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4847         15);
4848       delta.x=x-x_offset;
4849       delta.y=y-y_offset;
4850       for (i=0; i < 4L; i++)
4851         BicubicInterpolate(pixels+4*i,delta.x,u+i);
4852       BicubicInterpolate(u,delta.y,pixel);
4853       break;
4854     }
4855     case BilinearInterpolatePixel:
4856     default:
4857     {
4858       PointInfo
4859         delta,
4860         epsilon;
4861
4862       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4863       if (p == (const Quantum *) NULL)
4864         {
4865           status=MagickFalse;
4866           break;
4867         }
4868       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4869       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4870       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4871       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4872       delta.x=x-x_offset;
4873       delta.y=y-y_offset;
4874       epsilon.x=1.0-delta.x;
4875       epsilon.y=1.0-delta.y;
4876       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4877         (epsilon.x*alpha[2]+delta.x*alpha[3])));
4878       gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4879       pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
4880         pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
4881       pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
4882         pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
4883         pixels[3].green));
4884       pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
4885         pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
4886         pixels[3].blue));
4887       if (image->colorspace == CMYKColorspace)
4888         pixel->black=gamma*(epsilon.y*(epsilon.x*pixels[0].black+delta.x*
4889           pixels[1].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
4890           pixels[3].black));
4891       gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4892       gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4893       pixel->alpha=(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
4894         pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
4895         pixels[3].alpha));
4896       break;
4897     }
4898     case FilterInterpolatePixel:
4899     {
4900       CacheView
4901         *filter_view;
4902
4903       Image
4904         *excerpt_image,
4905         *filter_image;
4906
4907       RectangleInfo
4908         geometry;
4909
4910       geometry.width=4L;
4911       geometry.height=4L;
4912       geometry.x=x_offset-1;
4913       geometry.y=y_offset-1;
4914       excerpt_image=ExcerptImage(image,&geometry,exception);
4915       if (excerpt_image == (Image *) NULL)
4916         {
4917           status=MagickFalse;
4918           break;
4919         }
4920       filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
4921         exception);
4922       excerpt_image=DestroyImage(excerpt_image);
4923       if (filter_image == (Image *) NULL)
4924         break;
4925       filter_view=AcquireCacheView(filter_image);
4926       p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4927       if (p != (const Quantum *) NULL)
4928         SetPixelInfo(image,p,pixel);
4929       filter_view=DestroyCacheView(filter_view);
4930       filter_image=DestroyImage(filter_image);
4931       break;
4932     }
4933     case IntegerInterpolatePixel:
4934     {
4935       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4936       if (p == (const Quantum *) NULL)
4937         {
4938           status=MagickFalse;
4939           break;
4940         }
4941       SetPixelInfo(image,p,pixel);
4942       break;
4943     }
4944     case MeshInterpolatePixel:
4945     {
4946       PointInfo
4947         delta,
4948         luminance;
4949
4950       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4951       if (p == (const Quantum *) NULL)
4952         {
4953           status=MagickFalse;
4954           break;
4955         }
4956       delta.x=x-x_offset;
4957       delta.y=y-y_offset;
4958       luminance.x=GetPixelLuminance(image,p)-(double)
4959         GetPixelLuminance(image,p+3*GetPixelChannels(image));
4960       luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
4961         GetPixelLuminance(image,p+2*GetPixelChannels(image));
4962       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4963       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4964       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4965       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4966       if (fabs(luminance.x) < fabs(luminance.y))
4967         {
4968           /*
4969             Diagonal 0-3 NW-SE.
4970           */
4971           if (delta.x <= delta.y)
4972             {
4973               /*
4974                 Bottom-left triangle (pixel: 2, diagonal: 0-3).
4975               */
4976               delta.y=1.0-delta.y;
4977               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4978               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4979               pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
4980                 pixels[3].red,pixels[0].red);
4981               pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
4982                 pixels[3].green,pixels[0].green);
4983               pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
4984                 pixels[3].blue,pixels[0].blue);
4985               if (image->colorspace == CMYKColorspace)
4986                 pixel->black=gamma*MeshInterpolate(&delta,pixels[2].black,
4987                   pixels[3].black,pixels[0].black);
4988               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4989               pixel->alpha=gamma*MeshInterpolate(&delta,pixels[2].alpha,
4990                 pixels[3].alpha,pixels[0].alpha);
4991             }
4992           else
4993             {
4994               /*
4995                 Top-right triangle (pixel:1 , diagonal: 0-3).
4996               */
4997               delta.x=1.0-delta.x;
4998               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4999               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
5000               pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
5001                 pixels[0].red,pixels[3].red);
5002               pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
5003                 pixels[0].green,pixels[3].green);
5004               pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
5005                 pixels[0].blue,pixels[3].blue);
5006               if (image->colorspace == CMYKColorspace)
5007                 pixel->black=gamma*MeshInterpolate(&delta,pixels[1].black,
5008                   pixels[0].black,pixels[3].black);
5009               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
5010               pixel->alpha=gamma*MeshInterpolate(&delta,pixels[1].alpha,
5011                 pixels[0].alpha,pixels[3].alpha);
5012             }
5013         }
5014       else
5015         {
5016           /*
5017             Diagonal 1-2 NE-SW.
5018           */
5019           if (delta.x <= (1.0-delta.y))
5020             {
5021               /*
5022                 Top-left triangle (pixel: 0, diagonal: 1-2).
5023               */
5024               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
5025               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
5026               pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
5027                 pixels[1].red,pixels[2].red);
5028               pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
5029                 pixels[1].green,pixels[2].green);
5030               pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
5031                 pixels[1].blue,pixels[2].blue);
5032               if (image->colorspace == CMYKColorspace)
5033                 pixel->black=gamma*MeshInterpolate(&delta,pixels[0].black,
5034                   pixels[1].black,pixels[2].black);
5035               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
5036               pixel->alpha=gamma*MeshInterpolate(&delta,pixels[0].alpha,
5037                 pixels[1].alpha,pixels[2].alpha);
5038             }
5039           else
5040             {
5041               /*
5042                 Bottom-right triangle (pixel: 3, diagonal: 1-2).
5043               */
5044               delta.x=1.0-delta.x;
5045               delta.y=1.0-delta.y;
5046               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
5047               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
5048               pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
5049                 pixels[2].red,pixels[1].red);
5050               pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
5051                 pixels[2].green,pixels[1].green);
5052               pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
5053                 pixels[2].blue,pixels[1].blue);
5054               if (image->colorspace == CMYKColorspace)
5055                 pixel->black=gamma*MeshInterpolate(&delta,pixels[3].black,
5056                   pixels[2].black,pixels[1].black);
5057               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
5058               pixel->alpha=gamma*MeshInterpolate(&delta,pixels[3].alpha,
5059                 pixels[2].alpha,pixels[1].alpha);
5060             }
5061         }
5062       break;
5063     }
5064     case NearestNeighborInterpolatePixel:
5065     {
5066       p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
5067         NearestNeighbor(y),1,1,exception);
5068       if (p == (const Quantum *) NULL)
5069         {
5070           status=MagickFalse;
5071           break;
5072         }
5073       SetPixelInfo(image,p,pixel);
5074       break;
5075     }
5076     case SplineInterpolatePixel:
5077     {
5078       MagickRealType
5079         dx,
5080         dy;
5081
5082       PointInfo
5083         delta;
5084
5085       ssize_t
5086         j,
5087         n;
5088
5089       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
5090         exception);
5091       if (p == (const Quantum *) NULL)
5092         {
5093           status=MagickFalse;
5094           break;
5095         }
5096       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
5097       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
5098       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
5099       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
5100       AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
5101       AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
5102       AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
5103       AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
5104       AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
5105       AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
5106       AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
5107         10);
5108       AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
5109         11);
5110       AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
5111         12);
5112       AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
5113         13);
5114       AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
5115         14);
5116       AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
5117         15);
5118       pixel->red=0.0;
5119       pixel->green=0.0;
5120       pixel->blue=0.0;
5121       pixel->black=0.0;
5122       pixel->alpha=0.0;
5123       delta.x=x-x_offset;
5124       delta.y=y-y_offset;
5125       n=0;
5126       for (i=(-1); i < 3L; i++)
5127       {
5128         dy=CubicWeightingFunction((MagickRealType) i-delta.y);
5129         for (j=(-1); j < 3L; j++)
5130         {
5131           dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
5132           gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
5133           pixel->red+=gamma*dx*dy*pixels[n].red;
5134           pixel->green+=gamma*dx*dy*pixels[n].green;
5135           pixel->blue+=gamma*dx*dy*pixels[n].blue;
5136           if (image->colorspace == CMYKColorspace)
5137             pixel->black+=gamma*dx*dy*pixels[n].black;
5138           pixel->alpha+=dx*dy*pixels[n].alpha;
5139           n++;
5140         }
5141       }
5142       break;
5143     }
5144   }
5145   return(status);
5146 }
5147 \f
5148 /*
5149 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5150 %                                                                             %
5151 %                                                                             %
5152 %                                                                             %
5153 +   I s F u z z y E q u i v a l e n c e P i x e l                             %
5154 %                                                                             %
5155 %                                                                             %
5156 %                                                                             %
5157 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5158 %
5159 %  IsFuzzyEquivalencePixel() returns MagickTrue if the distance between two
5160 %  pixels is less than the specified distance in a linear three (or four)u
5161 %  dimensional color space.
5162 %
5163 %  The format of the IsFuzzyEquivalencePixel method is:
5164 %
5165 %      void IsFuzzyEquivalencePixel(const Image *image,const Quantum *p,
5166 %        const Quantum *q)
5167 %
5168 %  A description of each parameter follows:
5169 %
5170 %    o image: the image.
5171 %
5172 %    o p: Pixel p.
5173 %
5174 %    o q: Pixel q.
5175 %
5176 */
5177 MagickExport MagickBooleanType IsFuzzyEquivalencePixel(const Image *image,
5178   const Quantum *p,const Quantum *q)
5179 {
5180   MagickRealType
5181     fuzz,
5182     pixel;
5183
5184   register MagickRealType
5185     distance,
5186     scale;
5187
5188   fuzz=MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(
5189     image->fuzz,(MagickRealType) MagickSQ1_2);
5190   scale=1.0;
5191   distance=0.0;
5192   if (image->matte != MagickFalse)
5193     {
5194       /*
5195         Transparencies are involved - set alpha distance
5196       */
5197       pixel=(MagickRealType) ((image->matte != MagickFalse ?
5198         GetPixelAlpha(image,p) : OpaqueAlpha)-(image->matte != MagickFalse ?
5199         GetPixelAlpha(image,q) : OpaqueAlpha));
5200       distance=pixel*pixel;
5201       if (distance > fuzz)
5202         return(MagickFalse);
5203       /*
5204         Generate a alpha scaling factor to generate a 4D cone on colorspace
5205         Note that if one color is transparent, distance has no color component.
5206       */
5207       scale=QuantumScale*GetPixelAlpha(image,p);
5208       scale*=QuantumScale*GetPixelAlpha(image,q);
5209       if (scale <= MagickEpsilon)
5210         return(MagickTrue);
5211     }
5212   /*
5213     RGB or CMY color cube
5214   */
5215   distance*=3.0;  /* rescale appropriately */
5216   fuzz*=3.0;
5217   pixel=GetPixelRed(image,p)-(MagickRealType) GetPixelRed(image,q);
5218   if ((image->colorspace == HSLColorspace) ||
5219       (image->colorspace == HSBColorspace) ||
5220       (image->colorspace == HWBColorspace))
5221     {
5222       /*
5223         Compute an arc distance for hue.  It should be a vector angle of
5224         'S'/'W' length with 'L'/'B' forming appropriate cones.
5225       */
5226       if (fabs((double) pixel) > (QuantumRange/2))
5227         pixel-=QuantumRange;
5228       pixel*=2;
5229     }
5230   distance+=scale*pixel*pixel;
5231   if (distance > fuzz)
5232     return(MagickFalse);
5233   pixel=GetPixelGreen(image,p)-(MagickRealType) GetPixelGreen(image,q);
5234   distance+=scale*pixel*pixel;
5235   if (distance > fuzz)
5236     return(MagickFalse);
5237   pixel=GetPixelBlue(image,p)-(MagickRealType) GetPixelBlue(image,q);
5238   distance+=scale*pixel*pixel;
5239   if (distance > fuzz)
5240     return(MagickFalse);
5241   return(MagickTrue);
5242 }
5243 \f
5244 /*
5245 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5246 %                                                                             %
5247 %                                                                             %
5248 %                                                                             %
5249 +   I s F u z z y E q u i v a l e n c e P i x e l I n f o                     %
5250 %                                                                             %
5251 %                                                                             %
5252 %                                                                             %
5253 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5254 %
5255 %  IsFuzzyEquivalencePixelInfo() returns true if the distance between two
5256 %  colors is less than the specified distance in a linear three (or four)
5257 %  dimensional color space.
5258 %
5259 %  This implements the equivalent of:
5260 %    fuzz < sqrt(color_distance^2 * u.a*v.a  + alpha_distance^2)
5261 %
5262 %  Which produces a multi-dimensional cone for that colorspace along the
5263 %  transparency vector.
5264 %
5265 %  For example for an RGB:
5266 %    color_distance^2  = ( (u.r-v.r)^2 + (u.g-v.g)^2 + (u.b-v.b)^2 ) / 3
5267 %
5268 %  See http://www.imagemagick.org/Usage/bugs/fuzz_distance/
5269 %
5270 %  Hue colorspace distances need more work.  Hue is not a distance, it is an
5271 %  angle!
5272 %
5273 %  A check that q is in the same color space as p should be made and the
5274 %  appropriate mapping made.  -- Anthony Thyssen  8 December 2010
5275 %
5276 %  The format of the IsFuzzyEquivalencePixelInfo method is:
5277 %
5278 %      MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
5279 %        const PixelInfo *q)
5280 %
5281 %  A description of each parameter follows:
5282 %
5283 %    o p: Pixel p.
5284 %
5285 %    o q: Pixel q.
5286 %
5287 */
5288 MagickExport MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
5289   const PixelInfo *q)
5290 {
5291   MagickRealType
5292     fuzz,
5293     pixel;
5294
5295   register MagickRealType
5296     scale,
5297     distance;
5298
5299   if ((p->fuzz == 0.0) && (q->fuzz == 0.0))
5300     return(IsPixelInfoEquivalent(p,q));
5301   if (p->fuzz == 0.0)
5302     fuzz=MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(q->fuzz,
5303       (MagickRealType) MagickSQ1_2);
5304   else if (q->fuzz == 0.0)
5305     fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(p->fuzz,
5306       (MagickRealType) MagickSQ1_2);
5307   else
5308     fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(q->fuzz,
5309       (MagickRealType) MagickSQ1_2);
5310   scale=1.0;
5311   distance=0.0;
5312   if ((p->matte != MagickFalse) || (q->matte != MagickFalse))
5313     {
5314       /*
5315         Transparencies are involved - set alpha distance.
5316       */
5317       pixel=(p->matte != MagickFalse ? p->alpha : OpaqueAlpha)-
5318         (q->matte != MagickFalse ? q->alpha : OpaqueAlpha);
5319       distance=pixel*pixel;
5320       if (distance > fuzz)
5321         return(MagickFalse);
5322       /*
5323         Generate a alpha scaling factor to generate a 4D cone on colorspace.
5324         If one color is transparent, distance has no color component.
5325       */
5326       if (p->matte != MagickFalse)
5327         scale=(QuantumScale*p->alpha);
5328       if (q->matte != MagickFalse)
5329         scale*=(QuantumScale*q->alpha);
5330       if (scale <= MagickEpsilon )
5331         return(MagickTrue);
5332     }
5333   /*
5334     CMYK create a CMY cube with a multi-dimensional cone toward black.
5335   */
5336   if (p->colorspace == CMYKColorspace)
5337     {
5338       pixel=p->black-q->black;
5339       distance+=pixel*pixel*scale;
5340       if (distance > fuzz)
5341         return(MagickFalse);
5342       scale*=(MagickRealType) (QuantumScale*(QuantumRange-p->black));
5343       scale*=(MagickRealType) (QuantumScale*(QuantumRange-q->black));
5344     }
5345   /*
5346     RGB or CMY color cube.
5347   */
5348   distance*=3.0;  /* rescale appropriately */
5349   fuzz*=3.0;
5350   pixel=p->red-q->red;
5351   if ((p->colorspace == HSLColorspace) || (p->colorspace == HSBColorspace) ||
5352       (p->colorspace == HWBColorspace))
5353     {
5354       /*
5355         This calculates a arc distance for hue-- it should be a vector angle
5356         of 'S'/'W' length with 'L'/'B' forming appropriate cones.  In other
5357         words this is a hack - Anthony.
5358       */
5359       if (fabs((double) pixel) > (QuantumRange/2))
5360         pixel-=QuantumRange;
5361       pixel*=2;
5362     }
5363   distance+=pixel*pixel*scale;
5364   if (distance > fuzz)
5365     return(MagickFalse);
5366   pixel=p->green-q->green;
5367   distance+=pixel*pixel*scale;
5368   if (distance > fuzz)
5369     return(MagickFalse);
5370   pixel=p->blue-q->blue;
5371   distance+=pixel*pixel*scale;
5372   if (distance > fuzz)
5373     return(MagickFalse);
5374   return(MagickTrue);
5375 }
5376 \f
5377 /*
5378 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5379 %                                                                             %
5380 %                                                                             %
5381 %                                                                             %
5382 %   S e t P i x e l C h a n n e l M a p                                       %
5383 %                                                                             %
5384 %                                                                             %
5385 %                                                                             %
5386 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5387 %
5388 %  SetPixelChannelMap() sets the pixel channel map from the specified channel
5389 %  mask.
5390 %
5391 %  The format of the SetPixelChannelMap method is:
5392 %
5393 %      void SetPixelChannelMap(Image *image,const ChannelType channel_mask)
5394 %
5395 %  A description of each parameter follows:
5396 %
5397 %    o image: the image.
5398 %
5399 %    o mask: the channel mask.
5400 %
5401 */
5402 MagickExport void SetPixelChannelMap(Image *image,
5403   const ChannelType channel_mask)
5404 {
5405 #define GetChannelBit(mask,bit)  (((size_t) (mask) >> (size_t) (bit)) & 0x01)
5406
5407   register ssize_t
5408     i;
5409
5410   for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
5411     SetPixelChannelMapTraits(image,(PixelChannel) i,
5412       GetChannelBit(channel_mask,i) != 0 ? UpdatePixelTrait : CopyPixelTrait);
5413   for ( ; i < MaxPixelChannels; i++)
5414     SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
5415   if (image->storage_class == PseudoClass)
5416     SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
5417   if (image->debug != MagickFalse)
5418     LogPixelChannels(image);
5419 }
5420 \f
5421 /*
5422 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5423 %                                                                             %
5424 %                                                                             %
5425 %                                                                             %
5426 %   S e t P i x e l C h a n n e l M a s k                                     %
5427 %                                                                             %
5428 %                                                                             %
5429 %                                                                             %
5430 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5431 %
5432 %  SetPixelChannelMask() sets the pixel channel mask from the specified channel
5433 %  mask.
5434 %
5435 %  The format of the SetPixelChannelMask method is:
5436 %
5437 %      ChannelType SetPixelChannelMask(Image *image,
5438 %        const ChannelType channel_mask)
5439 %
5440 %  A description of each parameter follows:
5441 %
5442 %    o image: the image.
5443 %
5444 %    o channel_mask: the channel mask.
5445 %
5446 */
5447 MagickExport ChannelType SetPixelChannelMask(Image *image,
5448   const ChannelType channel_mask)
5449 {
5450   ChannelType
5451     mask;
5452
5453   mask=image->channel_mask;
5454   image->channel_mask=channel_mask;
5455   SetPixelChannelMap(image,channel_mask);
5456   return(mask);
5457 }