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