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 *) AcquireAlignedMemory(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 M a g i c k P i x e l P a c k e t                                   %
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,
1752   PixelInfo *pixel)
1753 {
1754   pixel->storage_class=DirectClass;
1755   pixel->colorspace=RGBColorspace;
1756   pixel->matte=MagickFalse;
1757   pixel->fuzz=0.0;
1758   pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
1759   pixel->red=0.0;
1760   pixel->green=0.0;
1761   pixel->blue=0.0;
1762   pixel->black=0.0;
1763   pixel->alpha=(MagickRealType) OpaqueAlpha;
1764   pixel->index=0.0;
1765   if (image == (const Image *) NULL)
1766     return;
1767   pixel->storage_class=image->storage_class;
1768   pixel->colorspace=image->colorspace;
1769   pixel->matte=image->matte;
1770   pixel->depth=image->depth;
1771   pixel->fuzz=image->fuzz;
1772 }
1773 \f
1774 /*
1775 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1776 %                                                                             %
1777 %                                                                             %
1778 %                                                                             %
1779 %   I m p o r t I m a g e P i x e l s                                         %
1780 %                                                                             %
1781 %                                                                             %
1782 %                                                                             %
1783 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1784 %
1785 %  ImportImagePixels() accepts pixel data and stores in the image at the
1786 %  location you specify.  The method returns MagickTrue on success otherwise
1787 %  MagickFalse if an error is encountered.  The pixel data can be either char,
1788 %  short int, int, ssize_t, float, or double in the order specified by map.
1789 %
1790 %  Suppose your want to upload the first scanline of a 640x480 image from
1791 %  character data in red-green-blue order:
1792 %
1793 %      ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
1794 %
1795 %  The format of the ImportImagePixels method is:
1796 %
1797 %      MagickBooleanType ImportImagePixels(Image *image,const ssize_t x_offset,
1798 %        const ssize_t y_offset,const size_t columns,
1799 %        const size_t rows,const char *map,const StorageType type,
1800 %        const void *pixels,ExceptionInfo *exception)
1801 %
1802 %  A description of each parameter follows:
1803 %
1804 %    o image: the image.
1805 %
1806 %    o x_offset,y_offset,columns,rows:  These values define the perimeter
1807 %      of a region of pixels you want to define.
1808 %
1809 %    o map:  This string reflects the expected ordering of the pixel array.
1810 %      It can be any combination or order of R = red, G = green, B = blue,
1811 %      A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
1812 %      Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
1813 %      P = pad.
1814 %
1815 %    o type: Define the data type of the pixels.  Float and double types are
1816 %      normalized to [0..1] otherwise [0..QuantumRange].  Choose from these
1817 %      types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or
1818 %      DoublePixel.
1819 %
1820 %    o pixels: This array of values contain the pixel components as defined by
1821 %      map and type.  You must preallocate this array where the expected
1822 %      length varies depending on the values of width, height, map, and type.
1823 %
1824 %    o exception: return any errors or warnings in this structure.
1825 %
1826 */
1827 MagickExport MagickBooleanType ImportImagePixels(Image *image,
1828   const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
1829   const size_t rows,const char *map,const StorageType type,
1830   const void *pixels,ExceptionInfo *exception)
1831 {
1832   QuantumType
1833     *quantum_map;
1834
1835   register Quantum
1836     *q;
1837
1838   register ssize_t
1839     i,
1840     x;
1841
1842   size_t
1843     length;
1844
1845   ssize_t
1846     y;
1847
1848   /*
1849     Allocate image structure.
1850   */
1851   assert(image != (Image *) NULL);
1852   assert(image->signature == MagickSignature);
1853   if (image->debug != MagickFalse)
1854     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1855   length=strlen(map);
1856   quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1857   if (quantum_map == (QuantumType *) NULL)
1858     ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1859       image->filename);
1860   for (i=0; i < (ssize_t) length; i++)
1861   {
1862     switch (map[i])
1863     {
1864       case 'a':
1865       case 'A':
1866       {
1867         quantum_map[i]=AlphaQuantum;
1868         image->matte=MagickTrue;
1869         break;
1870       }
1871       case 'B':
1872       case 'b':
1873       {
1874         quantum_map[i]=BlueQuantum;
1875         break;
1876       }
1877       case 'C':
1878       case 'c':
1879       {
1880         quantum_map[i]=CyanQuantum;
1881         (void) SetImageColorspace(image,CMYKColorspace,exception);
1882         break;
1883       }
1884       case 'g':
1885       case 'G':
1886       {
1887         quantum_map[i]=GreenQuantum;
1888         break;
1889       }
1890       case 'K':
1891       case 'k':
1892       {
1893         quantum_map[i]=BlackQuantum;
1894         (void) SetImageColorspace(image,CMYKColorspace,exception);
1895         break;
1896       }
1897       case 'I':
1898       case 'i':
1899       {
1900         quantum_map[i]=IndexQuantum;
1901         break;
1902       }
1903       case 'm':
1904       case 'M':
1905       {
1906         quantum_map[i]=MagentaQuantum;
1907         (void) SetImageColorspace(image,CMYKColorspace,exception);
1908         break;
1909       }
1910       case 'O':
1911       case 'o':
1912       {
1913         quantum_map[i]=OpacityQuantum;
1914         image->matte=MagickTrue;
1915         break;
1916       }
1917       case 'P':
1918       case 'p':
1919       {
1920         quantum_map[i]=UndefinedQuantum;
1921         break;
1922       }
1923       case 'R':
1924       case 'r':
1925       {
1926         quantum_map[i]=RedQuantum;
1927         break;
1928       }
1929       case 'Y':
1930       case 'y':
1931       {
1932         quantum_map[i]=YellowQuantum;
1933         (void) SetImageColorspace(image,CMYKColorspace,exception);
1934         break;
1935       }
1936       default:
1937       {
1938         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1939         (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1940           "UnrecognizedPixelMap","`%s'",map);
1941         return(MagickFalse);
1942       }
1943     }
1944   }
1945   if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1946     return(MagickFalse);
1947   /*
1948     Transfer the pixels from the pixel datarray to the image.
1949   */
1950   switch (type)
1951   {
1952     case CharPixel:
1953     {
1954       register const unsigned char
1955         *p;
1956
1957       p=(const unsigned char *) pixels;
1958       if (LocaleCompare(map,"BGR") == 0)
1959         {
1960           for (y=0; y < (ssize_t) rows; y++)
1961           {
1962             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1963             if (q == (Quantum *) NULL)
1964               break;
1965             for (x=0; x < (ssize_t) columns; x++)
1966             {
1967               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
1968               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
1969               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
1970               q+=GetPixelChannels(image);
1971             }
1972             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1973               break;
1974           }
1975           break;
1976         }
1977       if (LocaleCompare(map,"BGRA") == 0)
1978         {
1979           for (y=0; y < (ssize_t) rows; y++)
1980           {
1981             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1982             if (q == (Quantum *) NULL)
1983               break;
1984             for (x=0; x < (ssize_t) columns; x++)
1985             {
1986               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
1987               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
1988               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
1989               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
1990               q+=GetPixelChannels(image);
1991             }
1992             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1993               break;
1994           }
1995           break;
1996         }
1997       if (LocaleCompare(map,"BGRO") == 0)
1998         {
1999           for (y=0; y < (ssize_t) rows; y++)
2000           {
2001             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2002             if (q == (Quantum *) NULL)
2003               break;
2004             for (x=0; x < (ssize_t) columns; x++)
2005             {
2006               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2007               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2008               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2009               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2010               q+=GetPixelChannels(image);
2011             }
2012             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2013               break;
2014           }
2015           break;
2016         }
2017       if (LocaleCompare(map,"BGRP") == 0)
2018         {
2019           for (y=0; y < (ssize_t) rows; y++)
2020           {
2021             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2022             if (q == (Quantum *) NULL)
2023               break;
2024             for (x=0; x < (ssize_t) columns; x++)
2025             {
2026               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2027               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2028               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2029               p++;
2030               q+=GetPixelChannels(image);
2031             }
2032             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2033               break;
2034           }
2035           break;
2036         }
2037       if (LocaleCompare(map,"I") == 0)
2038         {
2039           for (y=0; y < (ssize_t) rows; y++)
2040           {
2041             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2042             if (q == (Quantum *) NULL)
2043               break;
2044             for (x=0; x < (ssize_t) columns; x++)
2045             {
2046               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2047               SetPixelGreen(image,GetPixelRed(image,q),q);
2048               SetPixelBlue(image,GetPixelRed(image,q),q);
2049               q+=GetPixelChannels(image);
2050             }
2051             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2052               break;
2053           }
2054           break;
2055         }
2056       if (LocaleCompare(map,"RGB") == 0)
2057         {
2058           for (y=0; y < (ssize_t) rows; y++)
2059           {
2060             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2061             if (q == (Quantum *) NULL)
2062               break;
2063             for (x=0; x < (ssize_t) columns; x++)
2064             {
2065               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2066               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2067               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2068               q+=GetPixelChannels(image);
2069             }
2070             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2071               break;
2072           }
2073           break;
2074         }
2075       if (LocaleCompare(map,"RGBA") == 0)
2076         {
2077           for (y=0; y < (ssize_t) rows; y++)
2078           {
2079             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2080             if (q == (Quantum *) NULL)
2081               break;
2082             for (x=0; x < (ssize_t) columns; x++)
2083             {
2084               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2085               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2086               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2087               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2088               q+=GetPixelChannels(image);
2089             }
2090             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2091               break;
2092           }
2093           break;
2094         }
2095       if (LocaleCompare(map,"RGBO") == 0)
2096         {
2097           for (y=0; y < (ssize_t) rows; y++)
2098           {
2099             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2100             if (q == (Quantum *) NULL)
2101               break;
2102             for (x=0; x < (ssize_t) columns; x++)
2103             {
2104               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2105               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2106               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2107               SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2108               q+=GetPixelChannels(image);
2109             }
2110             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2111               break;
2112           }
2113           break;
2114         }
2115       if (LocaleCompare(map,"RGBP") == 0)
2116         {
2117           for (y=0; y < (ssize_t) rows; y++)
2118           {
2119             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2120             if (q == (Quantum *) NULL)
2121               break;
2122             for (x=0; x < (ssize_t) columns; x++)
2123             {
2124               SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2125               SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2126               SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2127               p++;
2128               q+=GetPixelChannels(image);
2129             }
2130             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2131               break;
2132           }
2133           break;
2134         }
2135       for (y=0; y < (ssize_t) rows; y++)
2136       {
2137         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2138         if (q == (Quantum *) NULL)
2139           break;
2140         for (x=0; x < (ssize_t) columns; x++)
2141         {
2142           for (i=0; i < (ssize_t) length; i++)
2143           {
2144             switch (quantum_map[i])
2145             {
2146               case RedQuantum:
2147               case CyanQuantum:
2148               {
2149                 SetPixelRed(image,ScaleCharToQuantum(*p),q);
2150                 break;
2151               }
2152               case GreenQuantum:
2153               case MagentaQuantum:
2154               {
2155                 SetPixelGreen(image,ScaleCharToQuantum(*p),q);
2156                 break;
2157               }
2158               case BlueQuantum:
2159               case YellowQuantum:
2160               {
2161                 SetPixelBlue(image,ScaleCharToQuantum(*p),q);
2162                 break;
2163               }
2164               case AlphaQuantum:
2165               {
2166                 SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2167                 break;
2168               }
2169               case OpacityQuantum:
2170               {
2171                 SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2172                 break;
2173               }
2174               case BlackQuantum:
2175               {
2176                 SetPixelBlack(image,ScaleCharToQuantum(*p),q);
2177                 break;
2178               }
2179               case IndexQuantum:
2180               {
2181                 SetPixelRed(image,ScaleCharToQuantum(*p),q);
2182                 SetPixelGreen(image,GetPixelRed(image,q),q);
2183                 SetPixelBlue(image,GetPixelRed(image,q),q);
2184                 break;
2185               }
2186               default:
2187                 break;
2188             }
2189             p++;
2190           }
2191           q+=GetPixelChannels(image);
2192         }
2193         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2194           break;
2195       }
2196       break;
2197     }
2198     case DoublePixel:
2199     {
2200       register const double
2201         *p;
2202
2203       p=(const double *) pixels;
2204       if (LocaleCompare(map,"BGR") == 0)
2205         {
2206           for (y=0; y < (ssize_t) rows; y++)
2207           {
2208             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2209             if (q == (Quantum *) NULL)
2210               break;
2211             for (x=0; x < (ssize_t) columns; x++)
2212             {
2213               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2214                 (*p)),q);
2215               p++;
2216               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2217                 (*p)),q);
2218               p++;
2219               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2220                 (*p)),q);
2221               p++;
2222               q+=GetPixelChannels(image);
2223             }
2224             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2225               break;
2226           }
2227           break;
2228         }
2229       if (LocaleCompare(map,"BGRA") == 0)
2230         {
2231           for (y=0; y < (ssize_t) rows; y++)
2232           {
2233             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2234             if (q == (Quantum *) NULL)
2235               break;
2236             for (x=0; x < (ssize_t) columns; x++)
2237             {
2238               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2239                 (*p)),q);
2240               p++;
2241               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2242                 (*p)),q);
2243               p++;
2244               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2245                 (*p)),q);
2246               p++;
2247               SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2248                 (*p)),q);
2249               p++;
2250               q+=GetPixelChannels(image);
2251             }
2252             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2253               break;
2254           }
2255           break;
2256         }
2257       if (LocaleCompare(map,"BGRP") == 0)
2258         {
2259           for (y=0; y < (ssize_t) rows; y++)
2260           {
2261             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2262             if (q == (Quantum *) NULL)
2263               break;
2264             for (x=0; x < (ssize_t) columns; x++)
2265             {
2266               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2267                 (*p)),q);
2268               p++;
2269               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2270                 (*p)),q);
2271               p++;
2272               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2273                 (*p)),q);
2274               p++;
2275               p++;
2276               q+=GetPixelChannels(image);
2277             }
2278             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2279               break;
2280           }
2281           break;
2282         }
2283       if (LocaleCompare(map,"I") == 0)
2284         {
2285           for (y=0; y < (ssize_t) rows; y++)
2286           {
2287             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2288             if (q == (Quantum *) NULL)
2289               break;
2290             for (x=0; x < (ssize_t) columns; x++)
2291             {
2292               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2293                 (*p)),q);
2294               SetPixelGreen(image,GetPixelRed(image,q),q);
2295               SetPixelBlue(image,GetPixelRed(image,q),q);
2296               p++;
2297               q+=GetPixelChannels(image);
2298             }
2299             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2300               break;
2301           }
2302           break;
2303         }
2304       if (LocaleCompare(map,"RGB") == 0)
2305         {
2306           for (y=0; y < (ssize_t) rows; y++)
2307           {
2308             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2309             if (q == (Quantum *) NULL)
2310               break;
2311             for (x=0; x < (ssize_t) columns; x++)
2312             {
2313               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2314                 (*p)),q);
2315               p++;
2316               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2317                 (*p)),q);
2318               p++;
2319               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2320                 (*p)),q);
2321               p++;
2322               q+=GetPixelChannels(image);
2323             }
2324             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2325               break;
2326           }
2327           break;
2328         }
2329       if (LocaleCompare(map,"RGBA") == 0)
2330         {
2331           for (y=0; y < (ssize_t) rows; y++)
2332           {
2333             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2334             if (q == (Quantum *) NULL)
2335               break;
2336             for (x=0; x < (ssize_t) columns; x++)
2337             {
2338               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2339                 (*p)),q);
2340               p++;
2341               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2342                 (*p)),q);
2343               p++;
2344               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2345                 (*p)),q);
2346               p++;
2347               SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2348                 (*p)),q);
2349               p++;
2350               q+=GetPixelChannels(image);
2351             }
2352             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2353               break;
2354           }
2355           break;
2356         }
2357       if (LocaleCompare(map,"RGBP") == 0)
2358         {
2359           for (y=0; y < (ssize_t) rows; y++)
2360           {
2361             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2362             if (q == (Quantum *) NULL)
2363               break;
2364             for (x=0; x < (ssize_t) columns; x++)
2365             {
2366               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2367                 (*p)),q);
2368               p++;
2369               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2370                 (*p)),q);
2371               p++;
2372               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2373                 (*p)),q);
2374               p++;
2375               q+=GetPixelChannels(image);
2376             }
2377             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2378               break;
2379           }
2380           break;
2381         }
2382       for (y=0; y < (ssize_t) rows; y++)
2383       {
2384         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2385         if (q == (Quantum *) NULL)
2386           break;
2387         for (x=0; x < (ssize_t) columns; x++)
2388         {
2389           for (i=0; i < (ssize_t) length; i++)
2390           {
2391             switch (quantum_map[i])
2392             {
2393               case RedQuantum:
2394               case CyanQuantum:
2395               {
2396                 SetPixelRed(image,ClampToQuantum((MagickRealType)
2397                   QuantumRange*(*p)),q);
2398                 break;
2399               }
2400               case GreenQuantum:
2401               case MagentaQuantum:
2402               {
2403                 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2404                   QuantumRange*(*p)),q);
2405                 break;
2406               }
2407               case BlueQuantum:
2408               case YellowQuantum:
2409               {
2410                 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2411                   QuantumRange*(*p)),q);
2412                 break;
2413               }
2414               case AlphaQuantum:
2415               {
2416                 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2417                   QuantumRange*(*p)),q);
2418                 break;
2419               }
2420               case OpacityQuantum:
2421               {
2422                 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2423                   QuantumRange*(*p)),q);
2424                 break;
2425               }
2426               case BlackQuantum:
2427               {
2428                 SetPixelBlack(image,ClampToQuantum((MagickRealType)
2429                   QuantumRange*(*p)),q);
2430                 break;
2431               }
2432               case IndexQuantum:
2433               {
2434                 SetPixelRed(image,ClampToQuantum((MagickRealType)
2435                   QuantumRange*(*p)),q);
2436                 SetPixelGreen(image,GetPixelRed(image,q),q);
2437                 SetPixelBlue(image,GetPixelRed(image,q),q);
2438                 break;
2439               }
2440               default:
2441                 break;
2442             }
2443             p++;
2444           }
2445           q+=GetPixelChannels(image);
2446         }
2447         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2448           break;
2449       }
2450       break;
2451     }
2452     case FloatPixel:
2453     {
2454       register const float
2455         *p;
2456
2457       p=(const float *) pixels;
2458       if (LocaleCompare(map,"BGR") == 0)
2459         {
2460           for (y=0; y < (ssize_t) rows; y++)
2461           {
2462             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2463             if (q == (Quantum *) NULL)
2464               break;
2465             for (x=0; x < (ssize_t) columns; x++)
2466             {
2467               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2468                 (*p)),q);
2469               p++;
2470               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2471                 (*p)),q);
2472               p++;
2473               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2474                 (*p)),q);
2475               p++;
2476               q+=GetPixelChannels(image);
2477             }
2478             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2479               break;
2480           }
2481           break;
2482         }
2483       if (LocaleCompare(map,"BGRA") == 0)
2484         {
2485           for (y=0; y < (ssize_t) rows; y++)
2486           {
2487             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2488             if (q == (Quantum *) NULL)
2489               break;
2490             for (x=0; x < (ssize_t) columns; x++)
2491             {
2492               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2493                 (*p)),q);
2494               p++;
2495               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2496                 (*p)),q);
2497               p++;
2498               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2499                 (*p)),q);
2500               p++;
2501               SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2502                 (*p)),q);
2503               p++;
2504               q+=GetPixelChannels(image);
2505             }
2506             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2507               break;
2508           }
2509           break;
2510         }
2511       if (LocaleCompare(map,"BGRP") == 0)
2512         {
2513           for (y=0; y < (ssize_t) rows; y++)
2514           {
2515             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2516             if (q == (Quantum *) NULL)
2517               break;
2518             for (x=0; x < (ssize_t) columns; x++)
2519             {
2520               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2521                 (*p)),q);
2522               p++;
2523               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2524                 (*p)),q);
2525               p++;
2526               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2527                 (*p)),q);
2528               p++;
2529               p++;
2530               q+=GetPixelChannels(image);
2531             }
2532             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2533               break;
2534           }
2535           break;
2536         }
2537       if (LocaleCompare(map,"I") == 0)
2538         {
2539           for (y=0; y < (ssize_t) rows; y++)
2540           {
2541             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2542             if (q == (Quantum *) NULL)
2543               break;
2544             for (x=0; x < (ssize_t) columns; x++)
2545             {
2546               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2547                 (*p)),q);
2548               SetPixelGreen(image,GetPixelRed(image,q),q);
2549               SetPixelBlue(image,GetPixelRed(image,q),q);
2550               p++;
2551               q+=GetPixelChannels(image);
2552             }
2553             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2554               break;
2555           }
2556           break;
2557         }
2558       if (LocaleCompare(map,"RGB") == 0)
2559         {
2560           for (y=0; y < (ssize_t) rows; y++)
2561           {
2562             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2563             if (q == (Quantum *) NULL)
2564               break;
2565             for (x=0; x < (ssize_t) columns; x++)
2566             {
2567               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2568                 (*p)),q);
2569               p++;
2570               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2571                 (*p)),q);
2572               p++;
2573               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2574                 (*p)),q);
2575               p++;
2576               q+=GetPixelChannels(image);
2577             }
2578             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2579               break;
2580           }
2581           break;
2582         }
2583       if (LocaleCompare(map,"RGBA") == 0)
2584         {
2585           for (y=0; y < (ssize_t) rows; y++)
2586           {
2587             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2588             if (q == (Quantum *) NULL)
2589               break;
2590             for (x=0; x < (ssize_t) columns; x++)
2591             {
2592               SetPixelRed(image,ClampToQuantum((MagickRealType)
2593                 QuantumRange*(*p)),q);
2594               p++;
2595               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2596                 (*p)),q);
2597               p++;
2598               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2599                 (*p)),q);
2600               p++;
2601               SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2602                 (*p)),q);
2603               p++;
2604               q+=GetPixelChannels(image);
2605             }
2606             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2607               break;
2608           }
2609           break;
2610         }
2611       if (LocaleCompare(map,"RGBP") == 0)
2612         {
2613           for (y=0; y < (ssize_t) rows; y++)
2614           {
2615             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2616             if (q == (Quantum *) NULL)
2617               break;
2618             for (x=0; x < (ssize_t) columns; x++)
2619             {
2620               SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2621                 (*p)),q);
2622               p++;
2623               SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2624                 (*p)),q);
2625               p++;
2626               SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2627                 (*p)),q);
2628               p++;
2629               q+=GetPixelChannels(image);
2630             }
2631             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2632               break;
2633           }
2634           break;
2635         }
2636       for (y=0; y < (ssize_t) rows; y++)
2637       {
2638         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2639         if (q == (Quantum *) NULL)
2640           break;
2641         for (x=0; x < (ssize_t) columns; x++)
2642         {
2643           for (i=0; i < (ssize_t) length; i++)
2644           {
2645             switch (quantum_map[i])
2646             {
2647               case RedQuantum:
2648               case CyanQuantum:
2649               {
2650                 SetPixelRed(image,ClampToQuantum((MagickRealType)
2651                   QuantumRange*(*p)),q);
2652                 break;
2653               }
2654               case GreenQuantum:
2655               case MagentaQuantum:
2656               {
2657                 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2658                   QuantumRange*(*p)),q);
2659                 break;
2660               }
2661               case BlueQuantum:
2662               case YellowQuantum:
2663               {
2664                 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2665                   QuantumRange*(*p)),q);
2666                 break;
2667               }
2668               case AlphaQuantum:
2669               {
2670                 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2671                   QuantumRange*(*p)),q);
2672                 break;
2673               }
2674               case OpacityQuantum:
2675               {
2676                 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2677                   QuantumRange*(*p)),q);
2678                 break;
2679               }
2680               case BlackQuantum:
2681               {
2682                 SetPixelBlack(image,ClampToQuantum((MagickRealType)
2683                   QuantumRange*(*p)),q);
2684                 break;
2685               }
2686               case IndexQuantum:
2687               {
2688                 SetPixelRed(image,ClampToQuantum((MagickRealType)
2689                   QuantumRange*(*p)),q);
2690                 SetPixelGreen(image,GetPixelRed(image,q),q);
2691                 SetPixelBlue(image,GetPixelRed(image,q),q);
2692                 break;
2693               }
2694               default:
2695                 break;
2696             }
2697             p++;
2698           }
2699           q+=GetPixelChannels(image);
2700         }
2701         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2702           break;
2703       }
2704       break;
2705     }
2706     case IntegerPixel:
2707     {
2708       register const unsigned int
2709         *p;
2710
2711       p=(const unsigned int *) pixels;
2712       if (LocaleCompare(map,"BGR") == 0)
2713         {
2714           for (y=0; y < (ssize_t) rows; y++)
2715           {
2716             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2717             if (q == (Quantum *) NULL)
2718               break;
2719             for (x=0; x < (ssize_t) columns; x++)
2720             {
2721               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2722               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2723               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2724               q+=GetPixelChannels(image);
2725             }
2726             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2727               break;
2728           }
2729           break;
2730         }
2731       if (LocaleCompare(map,"BGRA") == 0)
2732         {
2733           for (y=0; y < (ssize_t) rows; y++)
2734           {
2735             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2736             if (q == (Quantum *) NULL)
2737               break;
2738             for (x=0; x < (ssize_t) columns; x++)
2739             {
2740               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2741               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2742               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2743               SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2744               q+=GetPixelChannels(image);
2745             }
2746             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2747               break;
2748           }
2749           break;
2750         }
2751       if (LocaleCompare(map,"BGRP") == 0)
2752         {
2753           for (y=0; y < (ssize_t) rows; y++)
2754           {
2755             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2756             if (q == (Quantum *) NULL)
2757               break;
2758             for (x=0; x < (ssize_t) columns; x++)
2759             {
2760               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2761               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2762               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2763               p++;
2764               q+=GetPixelChannels(image);
2765             }
2766             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2767               break;
2768           }
2769           break;
2770         }
2771       if (LocaleCompare(map,"I") == 0)
2772         {
2773           for (y=0; y < (ssize_t) rows; y++)
2774           {
2775             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2776             if (q == (Quantum *) NULL)
2777               break;
2778             for (x=0; x < (ssize_t) columns; x++)
2779             {
2780               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2781               SetPixelGreen(image,GetPixelRed(image,q),q);
2782               SetPixelBlue(image,GetPixelRed(image,q),q);
2783               q+=GetPixelChannels(image);
2784             }
2785             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2786               break;
2787           }
2788           break;
2789         }
2790       if (LocaleCompare(map,"RGB") == 0)
2791         {
2792           for (y=0; y < (ssize_t) rows; y++)
2793           {
2794             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2795             if (q == (Quantum *) NULL)
2796               break;
2797             for (x=0; x < (ssize_t) columns; x++)
2798             {
2799               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2800               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2801               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2802               q+=GetPixelChannels(image);
2803             }
2804             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2805               break;
2806           }
2807           break;
2808         }
2809       if (LocaleCompare(map,"RGBA") == 0)
2810         {
2811           for (y=0; y < (ssize_t) rows; y++)
2812           {
2813             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2814             if (q == (Quantum *) NULL)
2815               break;
2816             for (x=0; x < (ssize_t) columns; x++)
2817             {
2818               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2819               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2820               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2821               SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2822               q+=GetPixelChannels(image);
2823             }
2824             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2825               break;
2826           }
2827           break;
2828         }
2829       if (LocaleCompare(map,"RGBP") == 0)
2830         {
2831           for (y=0; y < (ssize_t) rows; y++)
2832           {
2833             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2834             if (q == (Quantum *) NULL)
2835               break;
2836             for (x=0; x < (ssize_t) columns; x++)
2837             {
2838               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2839               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2840               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2841               p++;
2842               q+=GetPixelChannels(image);
2843             }
2844             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2845               break;
2846           }
2847           break;
2848         }
2849       for (y=0; y < (ssize_t) rows; y++)
2850       {
2851         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2852         if (q == (Quantum *) NULL)
2853           break;
2854         for (x=0; x < (ssize_t) columns; x++)
2855         {
2856           for (i=0; i < (ssize_t) length; i++)
2857           {
2858             switch (quantum_map[i])
2859             {
2860               case RedQuantum:
2861               case CyanQuantum:
2862               {
2863                 SetPixelRed(image,ScaleLongToQuantum(*p),q);
2864                 break;
2865               }
2866               case GreenQuantum:
2867               case MagentaQuantum:
2868               {
2869                 SetPixelGreen(image,ScaleLongToQuantum(*p),q);
2870                 break;
2871               }
2872               case BlueQuantum:
2873               case YellowQuantum:
2874               {
2875                 SetPixelBlue(image,ScaleLongToQuantum(*p),q);
2876                 break;
2877               }
2878               case AlphaQuantum:
2879               {
2880                 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
2881                 break;
2882               }
2883               case OpacityQuantum:
2884               {
2885                 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
2886                 break;
2887               }
2888               case BlackQuantum:
2889               {
2890                 SetPixelBlack(image,ScaleLongToQuantum(*p),q);
2891                 break;
2892               }
2893               case IndexQuantum:
2894               {
2895                 SetPixelRed(image,ScaleLongToQuantum(*p),q);
2896                 SetPixelGreen(image,GetPixelRed(image,q),q);
2897                 SetPixelBlue(image,GetPixelRed(image,q),q);
2898                 break;
2899               }
2900               default:
2901                 break;
2902             }
2903             p++;
2904           }
2905           q+=GetPixelChannels(image);
2906         }
2907         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2908           break;
2909       }
2910       break;
2911     }
2912     case LongPixel:
2913     {
2914       register const unsigned int
2915         *p;
2916
2917       p=(const unsigned int *) pixels;
2918       if (LocaleCompare(map,"BGR") == 0)
2919         {
2920           for (y=0; y < (ssize_t) rows; y++)
2921           {
2922             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2923             if (q == (Quantum *) NULL)
2924               break;
2925             for (x=0; x < (ssize_t) columns; x++)
2926             {
2927               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2928               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2929               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2930               q+=GetPixelChannels(image);
2931             }
2932             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2933               break;
2934           }
2935           break;
2936         }
2937       if (LocaleCompare(map,"BGRA") == 0)
2938         {
2939           for (y=0; y < (ssize_t) rows; y++)
2940           {
2941             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2942             if (q == (Quantum *) NULL)
2943               break;
2944             for (x=0; x < (ssize_t) columns; x++)
2945             {
2946               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2947               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2948               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2949               SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2950               q+=GetPixelChannels(image);
2951             }
2952             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2953               break;
2954           }
2955           break;
2956         }
2957       if (LocaleCompare(map,"BGRP") == 0)
2958         {
2959           for (y=0; y < (ssize_t) rows; y++)
2960           {
2961             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2962             if (q == (Quantum *) NULL)
2963               break;
2964             for (x=0; x < (ssize_t) columns; x++)
2965             {
2966               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2967               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2968               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2969               p++;
2970               q+=GetPixelChannels(image);
2971             }
2972             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2973               break;
2974           }
2975           break;
2976         }
2977       if (LocaleCompare(map,"I") == 0)
2978         {
2979           for (y=0; y < (ssize_t) rows; y++)
2980           {
2981             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2982             if (q == (Quantum *) NULL)
2983               break;
2984             for (x=0; x < (ssize_t) columns; x++)
2985             {
2986               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2987               SetPixelGreen(image,GetPixelRed(image,q),q);
2988               SetPixelBlue(image,GetPixelRed(image,q),q);
2989               q+=GetPixelChannels(image);
2990             }
2991             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2992               break;
2993           }
2994           break;
2995         }
2996       if (LocaleCompare(map,"RGB") == 0)
2997         {
2998           for (y=0; y < (ssize_t) rows; y++)
2999           {
3000             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3001             if (q == (Quantum *) NULL)
3002               break;
3003             for (x=0; x < (ssize_t) columns; x++)
3004             {
3005               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3006               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3007               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3008               q+=GetPixelChannels(image);
3009             }
3010             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3011               break;
3012           }
3013           break;
3014         }
3015       if (LocaleCompare(map,"RGBA") == 0)
3016         {
3017           for (y=0; y < (ssize_t) rows; y++)
3018           {
3019             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3020             if (q == (Quantum *) NULL)
3021               break;
3022             for (x=0; x < (ssize_t) columns; x++)
3023             {
3024               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3025               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3026               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3027               SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
3028               q+=GetPixelChannels(image);
3029             }
3030             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3031               break;
3032           }
3033           break;
3034         }
3035       if (LocaleCompare(map,"RGBP") == 0)
3036         {
3037           for (y=0; y < (ssize_t) rows; y++)
3038           {
3039             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3040             if (q == (Quantum *) NULL)
3041               break;
3042             for (x=0; x < (ssize_t) columns; x++)
3043             {
3044               SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3045               SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3046               SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3047               p++;
3048               q+=GetPixelChannels(image);
3049             }
3050             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3051               break;
3052           }
3053           break;
3054         }
3055       for (y=0; y < (ssize_t) rows; y++)
3056       {
3057         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3058         if (q == (Quantum *) NULL)
3059           break;
3060         for (x=0; x < (ssize_t) columns; x++)
3061         {
3062           for (i=0; i < (ssize_t) length; i++)
3063           {
3064             switch (quantum_map[i])
3065             {
3066               case RedQuantum:
3067               case CyanQuantum:
3068               {
3069                 SetPixelRed(image,ScaleLongToQuantum(*p),q);
3070                 break;
3071               }
3072               case GreenQuantum:
3073               case MagentaQuantum:
3074               {
3075                 SetPixelGreen(image,ScaleLongToQuantum(*p),q);
3076                 break;
3077               }
3078               case BlueQuantum:
3079               case YellowQuantum:
3080               {
3081                 SetPixelBlue(image,ScaleLongToQuantum(*p),q);
3082                 break;
3083               }
3084               case AlphaQuantum:
3085               {
3086                 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3087                 break;
3088               }
3089               case OpacityQuantum:
3090               {
3091                 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3092                 break;
3093               }
3094               case BlackQuantum:
3095               {
3096                 SetPixelBlack(image,ScaleLongToQuantum(*p),q);
3097                 break;
3098               }
3099               case IndexQuantum:
3100               {
3101                 SetPixelRed(image,ScaleLongToQuantum(*p),q);
3102                 SetPixelGreen(image,GetPixelRed(image,q),q);
3103                 SetPixelBlue(image,GetPixelRed(image,q),q);
3104                 break;
3105               }
3106               default:
3107                 break;
3108             }
3109             p++;
3110           }
3111           q+=GetPixelChannels(image);
3112         }
3113         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3114           break;
3115       }
3116       break;
3117     }
3118     case QuantumPixel:
3119     {
3120       register const Quantum
3121         *p;
3122
3123       p=(const Quantum *) pixels;
3124       if (LocaleCompare(map,"BGR") == 0)
3125         {
3126           for (y=0; y < (ssize_t) rows; y++)
3127           {
3128             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3129             if (q == (Quantum *) NULL)
3130               break;
3131             for (x=0; x < (ssize_t) columns; x++)
3132             {
3133               SetPixelBlue(image,*p++,q);
3134               SetPixelGreen(image,*p++,q);
3135               SetPixelRed(image,*p++,q);
3136               q+=GetPixelChannels(image);
3137             }
3138             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3139               break;
3140           }
3141           break;
3142         }
3143       if (LocaleCompare(map,"BGRA") == 0)
3144         {
3145           for (y=0; y < (ssize_t) rows; y++)
3146           {
3147             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3148             if (q == (Quantum *) NULL)
3149               break;
3150             for (x=0; x < (ssize_t) columns; x++)
3151             {
3152               SetPixelBlue(image,*p++,q);
3153               SetPixelGreen(image,*p++,q);
3154               SetPixelRed(image,*p++,q);
3155               SetPixelAlpha(image,*p++,q);
3156               q+=GetPixelChannels(image);
3157             }
3158             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3159               break;
3160           }
3161           break;
3162         }
3163       if (LocaleCompare(map,"BGRP") == 0)
3164         {
3165           for (y=0; y < (ssize_t) rows; y++)
3166           {
3167             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3168             if (q == (Quantum *) NULL)
3169               break;
3170             for (x=0; x < (ssize_t) columns; x++)
3171             {
3172               SetPixelBlue(image,*p++,q);
3173               SetPixelGreen(image,*p++,q);
3174               SetPixelRed(image,*p++,q);
3175               p++;
3176               q+=GetPixelChannels(image);
3177             }
3178             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3179               break;
3180           }
3181           break;
3182         }
3183       if (LocaleCompare(map,"I") == 0)
3184         {
3185           for (y=0; y < (ssize_t) rows; y++)
3186           {
3187             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3188             if (q == (Quantum *) NULL)
3189               break;
3190             for (x=0; x < (ssize_t) columns; x++)
3191             {
3192               SetPixelRed(image,*p++,q);
3193               SetPixelGreen(image,GetPixelRed(image,q),q);
3194               SetPixelBlue(image,GetPixelRed(image,q),q);
3195               q+=GetPixelChannels(image);
3196             }
3197             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3198               break;
3199           }
3200           break;
3201         }
3202       if (LocaleCompare(map,"RGB") == 0)
3203         {
3204           for (y=0; y < (ssize_t) rows; y++)
3205           {
3206             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3207             if (q == (Quantum *) NULL)
3208               break;
3209             for (x=0; x < (ssize_t) columns; x++)
3210             {
3211               SetPixelRed(image,*p++,q);
3212               SetPixelGreen(image,*p++,q);
3213               SetPixelBlue(image,*p++,q);
3214               q+=GetPixelChannels(image);
3215             }
3216             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3217               break;
3218           }
3219           break;
3220         }
3221       if (LocaleCompare(map,"RGBA") == 0)
3222         {
3223           for (y=0; y < (ssize_t) rows; y++)
3224           {
3225             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3226             if (q == (Quantum *) NULL)
3227               break;
3228             for (x=0; x < (ssize_t) columns; x++)
3229             {
3230               SetPixelRed(image,*p++,q);
3231               SetPixelGreen(image,*p++,q);
3232               SetPixelBlue(image,*p++,q);
3233               SetPixelAlpha(image,*p++,q);
3234               q+=GetPixelChannels(image);
3235             }
3236             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3237               break;
3238           }
3239           break;
3240         }
3241       if (LocaleCompare(map,"RGBP") == 0)
3242         {
3243           for (y=0; y < (ssize_t) rows; y++)
3244           {
3245             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3246             if (q == (Quantum *) NULL)
3247               break;
3248             for (x=0; x < (ssize_t) columns; x++)
3249             {
3250               SetPixelRed(image,*p++,q);
3251               SetPixelGreen(image,*p++,q);
3252               SetPixelBlue(image,*p++,q);
3253               p++;
3254               q+=GetPixelChannels(image);
3255             }
3256             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3257               break;
3258           }
3259           break;
3260         }
3261       for (y=0; y < (ssize_t) rows; y++)
3262       {
3263         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3264         if (q == (Quantum *) NULL)
3265           break;
3266         for (x=0; x < (ssize_t) columns; x++)
3267         {
3268           for (i=0; i < (ssize_t) length; i++)
3269           {
3270             switch (quantum_map[i])
3271             {
3272               case RedQuantum:
3273               case CyanQuantum:
3274               {
3275                 SetPixelRed(image,*p,q);
3276                 break;
3277               }
3278               case GreenQuantum:
3279               case MagentaQuantum:
3280               {
3281                 SetPixelGreen(image,*p,q);
3282                 break;
3283               }
3284               case BlueQuantum:
3285               case YellowQuantum:
3286               {
3287                 SetPixelBlue(image,*p,q);
3288                 break;
3289               }
3290               case AlphaQuantum:
3291               {
3292                 SetPixelAlpha(image,*p,q);
3293                 break;
3294               }
3295               case OpacityQuantum:
3296               {
3297                 SetPixelAlpha(image,*p,q);
3298                 break;
3299               }
3300               case BlackQuantum:
3301               {
3302                 SetPixelBlack(image,*p,q);
3303                 break;
3304               }
3305               case IndexQuantum:
3306               {
3307                 SetPixelRed(image,*p,q);
3308                 SetPixelGreen(image,GetPixelRed(image,q),q);
3309                 SetPixelBlue(image,GetPixelRed(image,q),q);
3310                 break;
3311               }
3312               default:
3313                 break;
3314             }
3315             p++;
3316           }
3317           q+=GetPixelChannels(image);
3318         }
3319         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3320           break;
3321       }
3322       break;
3323     }
3324     case ShortPixel:
3325     {
3326       register const unsigned short
3327         *p;
3328
3329       p=(const unsigned short *) pixels;
3330       if (LocaleCompare(map,"BGR") == 0)
3331         {
3332           for (y=0; y < (ssize_t) rows; y++)
3333           {
3334             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3335             if (q == (Quantum *) NULL)
3336               break;
3337             for (x=0; x < (ssize_t) columns; x++)
3338             {
3339               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3340               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3341               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3342               q+=GetPixelChannels(image);
3343             }
3344             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3345               break;
3346           }
3347           break;
3348         }
3349       if (LocaleCompare(map,"BGRA") == 0)
3350         {
3351           for (y=0; y < (ssize_t) rows; y++)
3352           {
3353             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3354             if (q == (Quantum *) NULL)
3355               break;
3356             for (x=0; x < (ssize_t) columns; x++)
3357             {
3358               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3359               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3360               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3361               SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3362               q+=GetPixelChannels(image);
3363             }
3364             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3365               break;
3366           }
3367           break;
3368         }
3369       if (LocaleCompare(map,"BGRP") == 0)
3370         {
3371           for (y=0; y < (ssize_t) rows; y++)
3372           {
3373             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3374             if (q == (Quantum *) NULL)
3375               break;
3376             for (x=0; x < (ssize_t) columns; x++)
3377             {
3378               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3379               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3380               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3381               p++;
3382               q+=GetPixelChannels(image);
3383             }
3384             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3385               break;
3386           }
3387           break;
3388         }
3389       if (LocaleCompare(map,"I") == 0)
3390         {
3391           for (y=0; y < (ssize_t) rows; y++)
3392           {
3393             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3394             if (q == (Quantum *) NULL)
3395               break;
3396             for (x=0; x < (ssize_t) columns; x++)
3397             {
3398               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3399               SetPixelGreen(image,GetPixelRed(image,q),q);
3400               SetPixelBlue(image,GetPixelRed(image,q),q);
3401               q+=GetPixelChannels(image);
3402             }
3403             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3404               break;
3405           }
3406           break;
3407         }
3408       if (LocaleCompare(map,"RGB") == 0)
3409         {
3410           for (y=0; y < (ssize_t) rows; y++)
3411           {
3412             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3413             if (q == (Quantum *) NULL)
3414               break;
3415             for (x=0; x < (ssize_t) columns; x++)
3416             {
3417               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3418               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3419               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3420               q+=GetPixelChannels(image);
3421             }
3422             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3423               break;
3424           }
3425           break;
3426         }
3427       if (LocaleCompare(map,"RGBA") == 0)
3428         {
3429           for (y=0; y < (ssize_t) rows; y++)
3430           {
3431             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3432             if (q == (Quantum *) NULL)
3433               break;
3434             for (x=0; x < (ssize_t) columns; x++)
3435             {
3436               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3437               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3438               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3439               SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3440               q+=GetPixelChannels(image);
3441             }
3442             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3443               break;
3444           }
3445           break;
3446         }
3447       if (LocaleCompare(map,"RGBP") == 0)
3448         {
3449           for (y=0; y < (ssize_t) rows; y++)
3450           {
3451             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3452             if (q == (Quantum *) NULL)
3453               break;
3454             for (x=0; x < (ssize_t) columns; x++)
3455             {
3456               SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3457               SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3458               SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3459               p++;
3460               q+=GetPixelChannels(image);
3461             }
3462             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3463               break;
3464           }
3465           break;
3466         }
3467       for (y=0; y < (ssize_t) rows; y++)
3468       {
3469         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3470         if (q == (Quantum *) NULL)
3471           break;
3472         for (x=0; x < (ssize_t) columns; x++)
3473         {
3474           for (i=0; i < (ssize_t) length; i++)
3475           {
3476             switch (quantum_map[i])
3477             {
3478               case RedQuantum:
3479               case CyanQuantum:
3480               {
3481                 SetPixelRed(image,ScaleShortToQuantum(*p),q);
3482                 break;
3483               }
3484               case GreenQuantum:
3485               case MagentaQuantum:
3486               {
3487                 SetPixelGreen(image,ScaleShortToQuantum(*p),q);
3488                 break;
3489               }
3490               case BlueQuantum:
3491               case YellowQuantum:
3492               {
3493                 SetPixelBlue(image,ScaleShortToQuantum(*p),q);
3494                 break;
3495               }
3496               case AlphaQuantum:
3497               {
3498                 SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
3499                 break;
3500               }
3501               case OpacityQuantum:
3502               {
3503                 SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
3504                 break;
3505               }
3506               case BlackQuantum:
3507               {
3508                 SetPixelBlack(image,ScaleShortToQuantum(*p),q);
3509                 break;
3510               }
3511               case IndexQuantum:
3512               {
3513                 SetPixelRed(image,ScaleShortToQuantum(*p),q);
3514                 SetPixelGreen(image,GetPixelRed(image,q),q);
3515                 SetPixelBlue(image,GetPixelRed(image,q),q);
3516                 break;
3517               }
3518               default:
3519                 break;
3520             }
3521             p++;
3522           }
3523           q+=GetPixelChannels(image);
3524         }
3525         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3526           break;
3527       }
3528       break;
3529     }
3530     default:
3531     {
3532       quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3533       (void) ThrowMagickException(&image->exception,GetMagickModule(),
3534         OptionError,"UnrecognizedPixelMap","`%s'",map);
3535       break;
3536     }
3537   }
3538   quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3539   return(MagickTrue);
3540 }
3541 \f
3542 /*
3543 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3544 %                                                                             %
3545 %                                                                             %
3546 %                                                                             %
3547 +   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                         %
3548 %                                                                             %
3549 %                                                                             %
3550 %                                                                             %
3551 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3552 %
3553 %  InitializePixelChannelMap() defines the standard pixel component map.
3554 %
3555 %  The format of the InitializePixelChannelMap() method is:
3556 %
3557 %      void InitializePixelChannelMap(Image *image)
3558 %
3559 %  A description of each parameter follows:
3560 %
3561 %    o image: the image.
3562 %
3563 */
3564 MagickExport void InitializePixelChannelMap(Image *image)
3565 {
3566   PixelChannel
3567     alpha_channel;
3568
3569   register ssize_t
3570     i;
3571
3572   for (i=0; i < (ssize_t) MaxPixelChannels; i++)
3573   {
3574     SetPixelChannelMapChannel(image,(PixelChannel) i,(PixelChannel) i);
3575     SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
3576   }
3577   image->sync=MagickTrue;
3578   image->number_channels=4;
3579   if (0 && image->colorspace == GRAYColorspace)
3580     image->number_channels=2;
3581   if (image->colorspace == CMYKColorspace)
3582     image->number_channels++;
3583   if (image->storage_class == PseudoClass)
3584     image->number_channels++;
3585   for (i=0; i < (ssize_t) image->number_channels; i++)
3586     SetPixelChannelMapTraits(image,(PixelChannel) i,(PixelTrait)
3587       UpdatePixelTrait);
3588   alpha_channel=GetPixelChannelMapChannel(image,AlphaPixelChannel);
3589   if (image->matte == MagickFalse)
3590     SetPixelChannelMapTraits(image,AlphaPixelChannel,CopyPixelTrait);
3591   else
3592     for (i=0; i < (ssize_t) image->number_channels; i++)
3593       if ((PixelChannel) i != alpha_channel)
3594         SetPixelChannelMapTraits(image,(PixelChannel) i,(PixelTrait)
3595           (UpdatePixelTrait | BlendPixelTrait));
3596   if (0 && image->colorspace == GRAYColorspace)
3597     {
3598       image->number_channels=2;
3599       SetPixelChannelMapChannel(image,GreenPixelChannel,RedPixelChannel);
3600       SetPixelChannelMapChannel(image,BluePixelChannel,RedPixelChannel);
3601     }
3602   if (image->storage_class == PseudoClass)
3603     {
3604       SetPixelChannelMapChannel(image,IndexPixelChannel,IndexPixelChannel);
3605       SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
3606     }
3607   image->number_channels+=image->number_meta_channels;
3608   for ( ; i < (ssize_t) image->number_channels; i++)
3609     SetPixelChannelMapTraits(image,(PixelChannel) i,CopyPixelTrait);
3610   (void) SetPixelChannelMask(image,image->channel_mask);
3611 }
3612 \f
3613 /*
3614 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3615 %                                                                             %
3616 %                                                                             %
3617 %                                                                             %
3618 %   I n t e r p o l a t e P i x e l C h a n n e l                             %
3619 %                                                                             %
3620 %                                                                             %
3621 %                                                                             %
3622 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3623 %
3624 %  InterpolatePixelChannel() applies a pixel interpolation method between a
3625 %  floating point coordinate and the pixels surrounding that coordinate.  No
3626 %  pixel area resampling, or scaling of the result is performed.
3627 %
3628 %  The format of the InterpolatePixelChannel method is:
3629 %
3630 %      MagickBooleanType InterpolatePixelChannel(const Image *image,
3631 %        const CacheView *image_view,const PixelChannel channel,
3632 %        const PixelInterpolateMethod method,const double x,const double y,
3633 %        double *pixel,ExceptionInfo *exception)
3634 %
3635 %  A description of each parameter follows:
3636 %
3637 %    o image: the image.
3638 %
3639 %    o image_view: the image view.
3640 %
3641 %    o channel: the pixel channel to interpolate.
3642 %
3643 %    o method: the pixel color interpolation method.
3644 %
3645 %    o x,y: A double representing the current (x,y) position of the pixel.
3646 %
3647 %    o pixel: return the interpolated pixel here.
3648 %
3649 %    o exception: return any errors or warnings in this structure.
3650 %
3651 */
3652
3653 static inline double MagickMax(const MagickRealType x,const MagickRealType y)
3654 {
3655   if (x > y)
3656     return(x);
3657   return(y);
3658 }
3659
3660 static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
3661 {
3662   MagickRealType
3663     alpha,
3664     gamma;
3665
3666   alpha=MagickMax(x+2.0,0.0);
3667   gamma=1.0*alpha*alpha*alpha;
3668   alpha=MagickMax(x+1.0,0.0);
3669   gamma-=4.0*alpha*alpha*alpha;
3670   alpha=MagickMax(x+0.0,0.0);
3671   gamma+=6.0*alpha*alpha*alpha;
3672   alpha=MagickMax(x-1.0,0.0);
3673   gamma-=4.0*alpha*alpha*alpha;
3674   return(gamma/6.0);
3675 }
3676
3677 static inline double MeshInterpolate(const PointInfo *delta,const double p,
3678   const double x,const double y)
3679 {
3680   return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3681 }
3682
3683 static inline ssize_t NearestNeighbor(const MagickRealType x)
3684 {
3685   if (x >= 0.0)
3686     return((ssize_t) (x+0.5));
3687   return((ssize_t) (x-0.5));
3688 }
3689
3690 MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
3691   const CacheView *image_view,const PixelChannel channel,
3692   const PixelInterpolateMethod method,const double x,const double y,
3693   double *pixel,ExceptionInfo *exception)
3694 {
3695   MagickBooleanType
3696     status;
3697
3698   MagickRealType
3699     alpha[16],
3700     gamma,
3701     pixels[16];
3702
3703   PixelTrait
3704     traits;
3705
3706   register const Quantum
3707     *p;
3708
3709   register ssize_t
3710     i;
3711
3712   ssize_t
3713     x_offset,
3714     y_offset;
3715
3716   assert(image != (Image *) NULL);
3717   assert(image != (Image *) NULL);
3718   assert(image->signature == MagickSignature);
3719   assert(image_view != (CacheView *) NULL);
3720   status=MagickTrue;
3721   *pixel=0.0;
3722   traits=GetPixelChannelMapTraits(image,channel);
3723   x_offset=(ssize_t) floor(x);
3724   y_offset=(ssize_t) floor(y);
3725   switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
3726   {
3727     case AverageInterpolatePixel:
3728     {
3729       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3730         exception);
3731       if (p == (const Quantum *) NULL)
3732         {
3733           status=MagickFalse;
3734           break;
3735         }
3736       if ((traits & BlendPixelTrait) == 0)
3737         for (i=0; i < 16; i++)
3738         {
3739           alpha[i]=1.0;
3740           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3741         }
3742       else
3743         for (i=0; i < 16; i++)
3744         {
3745           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3746             GetPixelChannels(image));
3747           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3748         }
3749       for (i=0; i < 16; i++)
3750       {
3751         gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
3752         *pixel+=gamma*0.0625*pixels[i];
3753       }
3754       break;
3755     }
3756     case BicubicInterpolatePixel:
3757     {
3758       MagickRealType
3759         u[4],
3760         v[4];
3761
3762       PointInfo
3763         delta;
3764
3765       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3766         exception);
3767       if (p == (const Quantum *) NULL)
3768         {
3769           status=MagickFalse;
3770           break;
3771         }
3772       if ((traits & BlendPixelTrait) == 0)
3773         for (i=0; i < 16; i++)
3774         {
3775           alpha[i]=1.0;
3776           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3777         }
3778       else
3779         for (i=0; i < 16; i++)
3780         {
3781           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3782             GetPixelChannels(image));
3783           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3784         }
3785       delta.x=x-x_offset;
3786       delta.y=y-y_offset;
3787       for (i=0; i < 4; i++)
3788       {
3789         u[0]=(pixels[4*i+3]-pixels[4*i+2])-(pixels[4*i+0]-pixels[4*i+1]);
3790         u[1]=(pixels[4*i+0]-pixels[4*i+1])-u[0];
3791         u[2]=pixels[4*i+2]-pixels[4*i+0];
3792         u[3]=pixels[4*i+1];
3793         v[i]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
3794           u[2])+u[3];
3795       }
3796       u[0]=(v[3]-v[2])-(v[0]-v[1]);
3797       u[1]=(v[0]-v[1])-u[0];
3798       u[2]=v[2]-v[0];
3799       u[3]=v[1];
3800       *pixel=(delta.y*delta.y*delta.y*u[0])+(delta.y*delta.y*u[1])+(delta.y*
3801         u[2])+u[3];
3802       break;
3803     }
3804     case BilinearInterpolatePixel:
3805     default:
3806     {
3807       PointInfo
3808         delta,
3809         epsilon;
3810
3811       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3812       if (p == (const Quantum *) NULL)
3813         {
3814           status=MagickFalse;
3815           break;
3816         }
3817       if ((traits & BlendPixelTrait) == 0)
3818         for (i=0; i < 4; i++)
3819         {
3820           alpha[i]=1.0;
3821           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3822         }
3823       else
3824         for (i=0; i < 4; i++)
3825         {
3826           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3827             GetPixelChannels(image));
3828           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3829         }
3830       delta.x=x-x_offset;
3831       delta.y=y-y_offset;
3832       epsilon.x=1.0-delta.x;
3833       epsilon.y=1.0-delta.y;
3834       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
3835         (epsilon.x*alpha[2]+delta.x*alpha[3])));
3836       gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3837       *pixel=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
3838         (epsilon.x*pixels[2]+delta.x*pixels[3]));
3839       break;
3840     }
3841     case FilterInterpolatePixel:
3842     {
3843       CacheView
3844         *filter_view;
3845
3846       Image
3847         *excerpt_image,
3848         *filter_image;
3849
3850       RectangleInfo
3851         geometry;
3852
3853       geometry.width=4L;
3854       geometry.height=4L;
3855       geometry.x=x_offset-1;
3856       geometry.y=y_offset-1;
3857       excerpt_image=ExcerptImage(image,&geometry,exception);
3858       if (excerpt_image == (Image *) NULL)
3859         {
3860           status=MagickFalse;
3861           break;
3862         }
3863       filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
3864         exception);
3865       excerpt_image=DestroyImage(excerpt_image);
3866       if (filter_image == (Image *) NULL)
3867         break;
3868       filter_view=AcquireCacheView(filter_image);
3869       p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
3870       if (p == (const Quantum *) NULL)
3871         status=MagickFalse;
3872       else
3873         *pixel=(double) p[channel];
3874       filter_view=DestroyCacheView(filter_view);
3875       filter_image=DestroyImage(filter_image);
3876       break;
3877     }
3878     case IntegerInterpolatePixel:
3879     {
3880       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
3881       if (p == (const Quantum *) NULL)
3882         {
3883           status=MagickFalse;
3884           break;
3885         }
3886       *pixel=(double) p[channel];
3887       break;
3888     }
3889     case NearestNeighborInterpolatePixel:
3890     {
3891       p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
3892         NearestNeighbor(y),1,1,exception);
3893       if (p == (const Quantum *) NULL)
3894         {
3895           status=MagickFalse;
3896           break;
3897         }
3898       *pixel=(double) p[channel];
3899       break;
3900     }
3901     case MeshInterpolatePixel:
3902     {
3903       PointInfo
3904         delta,
3905         luminance;
3906
3907       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3908       if (p == (const Quantum *) NULL)
3909         {
3910           status=MagickFalse;
3911           break;
3912         }
3913       if ((traits & BlendPixelTrait) == 0)
3914         for (i=0; i < 4; i++)
3915         {
3916           alpha[i]=1.0;
3917           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3918         }
3919       else
3920         for (i=0; i < 4; i++)
3921         {
3922           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3923             GetPixelChannels(image));
3924           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3925         }
3926       delta.x=x-x_offset;
3927       delta.y=y-y_offset;
3928       luminance.x=GetPixelLuminance(image,p)-(double)
3929         GetPixelLuminance(image,p+3*GetPixelChannels(image));
3930       luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
3931         GetPixelLuminance(image,p+2*GetPixelChannels(image));
3932       if (fabs(luminance.x) < fabs(luminance.y))
3933         {
3934           /*
3935             Diagonal 0-3 NW-SE.
3936           */
3937           if (delta.x <= delta.y)
3938             {
3939               /*
3940                 Bottom-left triangle (pixel: 2, diagonal: 0-3).
3941               */
3942               delta.y=1.0-delta.y;
3943               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
3944               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3945               *pixel=gamma*MeshInterpolate(&delta,pixels[2],pixels[3],
3946                 pixels[0]);
3947             }
3948           else
3949             {
3950               /*
3951                 Top-right triangle (pixel: 1, diagonal: 0-3).
3952               */
3953               delta.x=1.0-delta.x;
3954               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
3955               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3956               *pixel=gamma*MeshInterpolate(&delta,pixels[1],pixels[0],
3957                 pixels[3]);
3958             }
3959         }
3960       else
3961         {
3962           /*
3963             Diagonal 1-2 NE-SW.
3964           */
3965           if (delta.x <= (1.0-delta.y))
3966             {
3967               /*
3968                 Top-left triangle (pixel: 0, diagonal: 1-2).
3969               */
3970               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
3971               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3972               *pixel=gamma*MeshInterpolate(&delta,pixels[0],pixels[1],
3973                 pixels[2]);
3974             }
3975           else
3976             {
3977               /*
3978                 Bottom-right triangle (pixel: 3, diagonal: 1-2).
3979               */
3980               delta.x=1.0-delta.x;
3981               delta.y=1.0-delta.y;
3982               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
3983               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3984               *pixel=gamma*MeshInterpolate(&delta,pixels[3],pixels[2],
3985                 pixels[1]);
3986             }
3987         }
3988       break;
3989     }
3990     case SplineInterpolatePixel:
3991     {
3992       MagickRealType
3993         dx,
3994         dy;
3995
3996       PointInfo
3997         delta;
3998
3999       ssize_t
4000         j,
4001         n;
4002
4003       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4004         exception);
4005       if (p == (const Quantum *) NULL)
4006         {
4007           status=MagickFalse;
4008           break;
4009         }
4010       if ((traits & BlendPixelTrait) == 0)
4011         for (i=0; i < 16; i++)
4012         {
4013           alpha[i]=1.0;
4014           pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4015         }
4016       else
4017         for (i=0; i < 16; i++)
4018         {
4019           alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4020             GetPixelChannels(image));
4021           pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4022         }
4023       delta.x=x-x_offset;
4024       delta.y=y-y_offset;
4025       n=0;
4026       for (i=(-1); i < 3L; i++)
4027       {
4028         dy=CubicWeightingFunction((MagickRealType) i-delta.y);
4029         for (j=(-1); j < 3L; j++)
4030         {
4031           dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
4032           gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
4033           *pixel+=gamma*dx*dy*pixels[n];
4034           n++;
4035         }
4036       }
4037       break;
4038     }
4039   }
4040   return(status);
4041 }
4042 \f
4043 /*
4044 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4045 %                                                                             %
4046 %                                                                             %
4047 %                                                                             %
4048 %   I n t e r p o l a t e P i x e l C h a n n e l s                           %
4049 %                                                                             %
4050 %                                                                             %
4051 %                                                                             %
4052 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4053 %
4054 %  InterpolatePixelChannels() applies a pixel interpolation method between a
4055 %  floating point coordinate and the pixels surrounding that coordinate.  No
4056 %  pixel area resampling, or scaling of the result is performed.
4057 %
4058 %  The format of the InterpolatePixelChannels method is:
4059 %
4060 %      MagickBooleanType InterpolatePixelChannels(const Image *source,
4061 %        const CacheView *source_view,const Image *destination,
4062 %        const PixelInterpolateMethod method,const double x,const double y,
4063 %        Quantum *pixel,ExceptionInfo *exception)
4064 %
4065 %  A description of each parameter follows:
4066 %
4067 %    o source: the source.
4068 %
4069 %    o source_view: the source view.
4070 %
4071 %    o destination: the destination image.
4072 %
4073 %    o method: the pixel color interpolation method.
4074 %
4075 %    o x,y: A double representing the current (x,y) position of the pixel.
4076 %
4077 %    o pixel: return the interpolated pixel here.
4078 %
4079 %    o exception: return any errors or warnings in this structure.
4080 %
4081 */
4082 MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
4083   const CacheView *source_view,const Image *destination,
4084   const PixelInterpolateMethod method,const double x,const double y,
4085   Quantum *pixel,ExceptionInfo *exception)
4086 {
4087   MagickBooleanType
4088     status;
4089
4090   MagickRealType
4091     alpha[16],
4092     gamma,
4093     pixels[16];
4094
4095   PixelChannel
4096     channel;
4097
4098   PixelTrait
4099     destination_traits,
4100     traits;
4101
4102   register const Quantum
4103     *p;
4104
4105   register ssize_t
4106     i;
4107
4108   ssize_t
4109     x_offset,
4110     y_offset;
4111
4112   assert(source != (Image *) NULL);
4113   assert(source != (Image *) NULL);
4114   assert(source->signature == MagickSignature);
4115   assert(source_view != (CacheView *) NULL);
4116   status=MagickTrue;
4117   x_offset=(ssize_t) floor(x);
4118   y_offset=(ssize_t) floor(y);
4119   switch (method == UndefinedInterpolatePixel ? source->interpolate : method)
4120   {
4121     case AverageInterpolatePixel:
4122     {
4123       p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4124         exception);
4125       if (p == (const Quantum *) NULL)
4126         {
4127           status=MagickFalse;
4128           break;
4129         }
4130       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4131       {
4132         double
4133           sum;
4134
4135         register ssize_t
4136           j;
4137
4138         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4139         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4140         destination_traits=GetPixelChannelMapTraits(destination,channel);
4141         if ((traits == UndefinedPixelTrait) ||
4142             (destination_traits == UndefinedPixelTrait))
4143           continue;
4144         for (j=0; j < 16; j++)
4145           pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4146         if ((traits & BlendPixelTrait) == 0)
4147           {
4148             for (j=0; j < 16; j++)
4149               pixel[channel]+=0.0625*pixels[j];
4150             continue;
4151           }
4152         sum=0.0;
4153         for (j=0; j < 16; j++)
4154         {
4155           alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4156             GetPixelChannels(source));
4157           pixels[j]*=alpha[j];
4158           gamma=1.0/(fabs((double) alpha[j]) <= MagickEpsilon ? 1.0 : alpha[j]);
4159           sum+=gamma*0.0625*pixels[j];
4160         }
4161         pixel[channel]=ClampToQuantum(sum);
4162       }
4163       break;
4164     }
4165     case BicubicInterpolatePixel:
4166     {
4167       MagickRealType
4168         u[4],
4169         v[4];
4170
4171       PointInfo
4172         delta;
4173
4174       p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4175         exception);
4176       if (p == (const Quantum *) NULL)
4177         {
4178           status=MagickFalse;
4179           break;
4180         }
4181       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4182       {
4183         register ssize_t
4184           j;
4185
4186         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4187         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4188         destination_traits=GetPixelChannelMapTraits(destination,channel);
4189         if ((traits == UndefinedPixelTrait) ||
4190             (destination_traits == UndefinedPixelTrait))
4191           continue;
4192         if ((traits & BlendPixelTrait) == 0)
4193           for (j=0; j < 16; j++)
4194           {
4195             alpha[j]=1.0;
4196             pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4197           }
4198         else
4199           for (j=0; j < 16; j++)
4200           {
4201             alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4202               GetPixelChannels(source));
4203             pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
4204           }
4205         delta.x=x-x_offset;
4206         delta.y=y-y_offset;
4207         for (j=0; j < 4; j++)
4208         {
4209           u[0]=(pixels[4*j+3]-pixels[4*j+2])-(pixels[4*j+0]-pixels[4*j+1]);
4210           u[1]=(pixels[4*j+0]-pixels[4*j+1])-u[0];
4211           u[2]=pixels[4*j+2]-pixels[4*j+0];
4212           u[3]=pixels[4*j+1];
4213           v[j]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
4214             u[2])+u[3];
4215         }
4216         u[0]=(v[3]-v[2])-(v[0]-v[1]);
4217         u[1]=(v[0]-v[1])-u[0];
4218         u[2]=v[2]-v[0];
4219         u[3]=v[1];
4220         pixel[channel]=ClampToQuantum((delta.y*delta.y*delta.y*u[0])+(delta.y*
4221           delta.y*u[1])+(delta.y*u[2])+u[3]);
4222       }
4223       break;
4224     }
4225     case BilinearInterpolatePixel:
4226     default:
4227     {
4228       p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
4229       if (p == (const Quantum *) NULL)
4230         {
4231           status=MagickFalse;
4232           break;
4233         }
4234       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4235       {
4236         PointInfo
4237           delta,
4238           epsilon;
4239
4240         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4241         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4242         destination_traits=GetPixelChannelMapTraits(destination,channel);
4243         if ((traits == UndefinedPixelTrait) ||
4244             (destination_traits == UndefinedPixelTrait))
4245           continue;
4246         delta.x=x-x_offset;
4247         delta.y=y-y_offset;
4248         epsilon.x=1.0-delta.x;
4249         epsilon.y=1.0-delta.y;
4250         pixels[0]=(MagickRealType) p[i];
4251         pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
4252         pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
4253         pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
4254         if ((traits & BlendPixelTrait) == 0)
4255           {
4256             gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4257             gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4258             pixel[channel]=ClampToQuantum(gamma*(epsilon.y*(epsilon.x*pixels[0]+
4259               delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+delta.x*
4260               pixels[3])));
4261             continue;
4262           }
4263         alpha[0]=QuantumScale*GetPixelAlpha(source,p);
4264         alpha[1]=QuantumScale*GetPixelAlpha(source,p+GetPixelChannels(source));
4265         alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
4266           GetPixelChannels(source));
4267         alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
4268           GetPixelChannels(source));
4269         pixels[0]*=alpha[0];
4270         pixels[1]*=alpha[1];
4271         pixels[2]*=alpha[2];
4272         pixels[3]*=alpha[3];
4273         gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4274           (epsilon.x*alpha[2]+delta.x*alpha[3])));
4275         gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4276         pixel[channel]=ClampToQuantum(gamma*(epsilon.y*(epsilon.x*pixels[0]+
4277           delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+delta.x*pixels[3])));
4278       }
4279       break;
4280     }
4281     case FilterInterpolatePixel:
4282     {
4283       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4284       {
4285         CacheView
4286           *filter_view;
4287
4288         Image
4289           *excerpt_source,
4290           *filter_source;
4291
4292         RectangleInfo
4293           geometry;
4294
4295         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4296         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4297         destination_traits=GetPixelChannelMapTraits(destination,channel);
4298         if ((traits == UndefinedPixelTrait) ||
4299             (destination_traits == UndefinedPixelTrait))
4300           continue;
4301         geometry.width=4L;
4302         geometry.height=4L;
4303         geometry.x=x_offset-1;
4304         geometry.y=y_offset-1;
4305         excerpt_source=ExcerptImage(source,&geometry,exception);
4306         if (excerpt_source == (Image *) NULL)
4307           {
4308             status=MagickFalse;
4309             continue;
4310           }
4311         filter_source=ResizeImage(excerpt_source,1,1,source->filter,
4312           source->blur,exception);
4313         excerpt_source=DestroyImage(excerpt_source);
4314         if (filter_source == (Image *) NULL)
4315           continue;
4316         filter_view=AcquireCacheView(filter_source);
4317         p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4318         if (p == (const Quantum *) NULL)
4319           status=MagickFalse;
4320         else
4321           pixel[channel]=p[i];
4322         filter_view=DestroyCacheView(filter_view);
4323         filter_source=DestroyImage(filter_source);
4324       }
4325       break;
4326     }
4327     case IntegerInterpolatePixel:
4328     {
4329       p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
4330       if (p == (const Quantum *) NULL)
4331         {
4332           status=MagickFalse;
4333           break;
4334         }
4335       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4336       {
4337         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4338         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4339         destination_traits=GetPixelChannelMapTraits(destination,channel);
4340         if ((traits == UndefinedPixelTrait) ||
4341             (destination_traits == UndefinedPixelTrait))
4342           continue;
4343         pixel[channel]=p[i];
4344       }
4345       break;
4346     }
4347     case NearestNeighborInterpolatePixel:
4348     {
4349       p=GetCacheViewVirtualPixels(source_view,NearestNeighbor(x),
4350         NearestNeighbor(y),1,1,exception);
4351       if (p == (const Quantum *) NULL)
4352         {
4353           status=MagickFalse;
4354           break;
4355         }
4356       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4357       {
4358         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4359         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4360         destination_traits=GetPixelChannelMapTraits(destination,channel);
4361         if ((traits == UndefinedPixelTrait) ||
4362             (destination_traits == UndefinedPixelTrait))
4363           continue;
4364         pixel[channel]=p[i];
4365       }
4366       break;
4367     }
4368     case MeshInterpolatePixel:
4369     {
4370       p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
4371       if (p == (const Quantum *) NULL)
4372         {
4373           status=MagickFalse;
4374           break;
4375         }
4376       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4377       {
4378         PointInfo
4379           delta,
4380           luminance;
4381
4382         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4383         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4384         destination_traits=GetPixelChannelMapTraits(destination,channel);
4385         if ((traits == UndefinedPixelTrait) ||
4386             (destination_traits == UndefinedPixelTrait))
4387           continue;
4388        pixels[0]=(MagickRealType) p[i];
4389        pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
4390        pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
4391        pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
4392        if ((traits & BlendPixelTrait) == 0)
4393          {
4394            alpha[0]=1.0;
4395            alpha[1]=1.0;
4396            alpha[2]=1.0;
4397            alpha[3]=1.0;
4398          }
4399        else
4400          {
4401            alpha[0]=QuantumScale*GetPixelAlpha(source,p);
4402            alpha[1]=QuantumScale*GetPixelAlpha(source,p+
4403              GetPixelChannels(source));
4404            alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
4405              GetPixelChannels(source));
4406            alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
4407              GetPixelChannels(source));
4408          }
4409        delta.x=x-x_offset;
4410        delta.y=y-y_offset;
4411        luminance.x=GetPixelLuminance(source,p)-(double)
4412          GetPixelLuminance(source,p+3*GetPixelChannels(source));
4413        luminance.y=GetPixelLuminance(source,p+GetPixelChannels(source))-
4414          (double) GetPixelLuminance(source,p+2*GetPixelChannels(source));
4415        if (fabs(luminance.x) < fabs(luminance.y))
4416          {
4417            /*
4418              Diagonal 0-3 NW-SE.
4419            */
4420            if (delta.x <= delta.y)
4421              {
4422                /*
4423                  Bottom-left triangle (pixel: 2, diagonal: 0-3).
4424                */
4425                delta.y=1.0-delta.y;
4426                gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4427                gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4428                pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4429                  pixels[2],pixels[3],pixels[0]));
4430              }
4431            else
4432              {
4433                /*
4434                  Top-right triangle (pixel: 1, diagonal: 0-3).
4435                */
4436                delta.x=1.0-delta.x;
4437                gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4438                gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4439                pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4440                  pixels[1],pixels[0],pixels[3]));
4441              }
4442          }
4443        else
4444          {
4445            /*
4446              Diagonal 1-2 NE-SW.
4447            */
4448            if (delta.x <= (1.0-delta.y))
4449              {
4450                /*
4451                  Top-left triangle (pixel: 0, diagonal: 1-2).
4452                */
4453                gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4454                gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4455                pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4456                  pixels[0],pixels[1],pixels[2]));
4457              }
4458            else
4459              {
4460                /*
4461                  Bottom-right triangle (pixel: 3, diagonal: 1-2).
4462                */
4463                delta.x=1.0-delta.x;
4464                delta.y=1.0-delta.y;
4465                gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4466                gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4467                pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4468                  pixels[3],pixels[2],pixels[1]));
4469              }
4470          }
4471       }
4472       break;
4473     }
4474     case SplineInterpolatePixel:
4475     {
4476       p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4477         exception);
4478       if (p == (const Quantum *) NULL)
4479         {
4480           status=MagickFalse;
4481           break;
4482         }
4483       for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4484       {
4485         double
4486           sum;
4487
4488         MagickRealType
4489           dx,
4490           dy;
4491
4492         PointInfo
4493           delta;
4494
4495         register ssize_t
4496           j;
4497
4498         ssize_t
4499           k,
4500           n;
4501
4502         traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4503         channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4504         destination_traits=GetPixelChannelMapTraits(destination,channel);
4505         if ((traits == UndefinedPixelTrait) ||
4506             (destination_traits == UndefinedPixelTrait))
4507           continue;
4508         if ((traits & BlendPixelTrait) == 0)
4509           for (j=0; j < 16; j++)
4510           {
4511             alpha[j]=1.0;
4512             pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4513           }
4514         else
4515           for (j=0; j < 16; j++)
4516           {
4517             alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4518               GetPixelChannels(source));
4519             pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
4520           }
4521         delta.x=x-x_offset;
4522         delta.y=y-y_offset;
4523         sum=0.0;
4524         n=0;
4525         for (j=(-1); j < 3L; j++)
4526         {
4527           dy=CubicWeightingFunction((MagickRealType) j-delta.y);
4528           for (k=(-1); k < 3L; k++)
4529           {
4530             dx=CubicWeightingFunction(delta.x-(MagickRealType) k);
4531             gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 :
4532               alpha[n]);
4533             sum+=gamma*dx*dy*pixels[n];
4534             n++;
4535           }
4536         }
4537         pixel[channel]=ClampToQuantum(sum);
4538       }
4539       break;
4540     }
4541   }
4542   return(status);
4543 }
4544 \f
4545 /*
4546 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4547 %                                                                             %
4548 %                                                                             %
4549 %                                                                             %
4550 %   I n t e r p o l a t e P i x e l I n f o                                   %
4551 %                                                                             %
4552 %                                                                             %
4553 %                                                                             %
4554 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4555 %
4556 %  InterpolatePixelInfo() applies a pixel interpolation method between a
4557 %  floating point coordinate and the pixels surrounding that coordinate.  No
4558 %  pixel area resampling, or scaling of the result is performed.
4559 %
4560 %  The format of the InterpolatePixelInfo method is:
4561 %
4562 %      MagickBooleanType InterpolatePixelInfo(const Image *image,
4563 %        const CacheView *image_view,const PixelInterpolateMethod method,
4564 %        const double x,const double y,PixelInfo *pixel,
4565 %        ExceptionInfo *exception)
4566 %
4567 %  A description of each parameter follows:
4568 %
4569 %    o image: the image.
4570 %
4571 %    o image_view: the image view.
4572 %
4573 %    o method: the pixel color interpolation method.
4574 %
4575 %    o x,y: A double representing the current (x,y) position of the pixel.
4576 %
4577 %    o pixel: return the interpolated pixel here.
4578 %
4579 %    o exception: return any errors or warnings in this structure.
4580 %
4581 */
4582
4583 static inline void AlphaBlendPixelInfo(const Image *image,
4584   const Quantum *pixel,PixelInfo *pixel_info,MagickRealType *alpha)
4585 {
4586   if (image->matte == MagickFalse)
4587     {
4588       *alpha=1.0;
4589       pixel_info->red=(MagickRealType) GetPixelRed(image,pixel);
4590       pixel_info->green=(MagickRealType) GetPixelGreen(image,pixel);
4591       pixel_info->blue=(MagickRealType) GetPixelBlue(image,pixel);
4592       pixel_info->black=0.0;
4593       if (image->colorspace == CMYKColorspace)
4594         pixel_info->black=(MagickRealType) GetPixelBlack(image,pixel);
4595       pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
4596       return;
4597     }
4598   *alpha=QuantumScale*GetPixelAlpha(image,pixel);
4599   pixel_info->red=(*alpha*GetPixelRed(image,pixel));
4600   pixel_info->green=(*alpha*GetPixelGreen(image,pixel));
4601   pixel_info->blue=(*alpha*GetPixelBlue(image,pixel));
4602   pixel_info->black=0.0;
4603   if (image->colorspace == CMYKColorspace)
4604     pixel_info->black=(*alpha*GetPixelBlack(image,pixel));
4605   pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
4606 }
4607
4608 static void BicubicInterpolate(const PixelInfo *pixels,const double dx,
4609   PixelInfo *pixel)
4610 {
4611   MagickRealType
4612     dx2,
4613     p,
4614     q,
4615     r,
4616     s;
4617
4618   dx2=dx*dx;
4619   p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
4620   q=(pixels[0].red-pixels[1].red)-p;
4621   r=pixels[2].red-pixels[0].red;
4622   s=pixels[1].red;
4623   pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4624   p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
4625   q=(pixels[0].green-pixels[1].green)-p;
4626   r=pixels[2].green-pixels[0].green;
4627   s=pixels[1].green;
4628   pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4629   p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
4630   q=(pixels[0].blue-pixels[1].blue)-p;
4631   r=pixels[2].blue-pixels[0].blue;
4632   s=pixels[1].blue;
4633   pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4634   p=(pixels[3].alpha-pixels[2].alpha)-(pixels[0].alpha-pixels[1].alpha);
4635   q=(pixels[0].alpha-pixels[1].alpha)-p;
4636   r=pixels[2].alpha-pixels[0].alpha;
4637   s=pixels[1].alpha;
4638   pixel->alpha=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4639   if (pixel->colorspace == CMYKColorspace)
4640     {
4641       p=(pixels[3].black-pixels[2].black)-(pixels[0].black-pixels[1].black);
4642       q=(pixels[0].black-pixels[1].black)-p;
4643       r=pixels[2].black-pixels[0].black;
4644       s=pixels[1].black;
4645       pixel->black=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4646     }
4647 }
4648
4649 MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
4650   const CacheView *image_view,const PixelInterpolateMethod method,
4651   const double x,const double y,PixelInfo *pixel,ExceptionInfo *exception)
4652 {
4653   MagickBooleanType
4654     status;
4655
4656   MagickRealType
4657     alpha[16],
4658     gamma;
4659
4660   PixelInfo
4661     pixels[16];
4662
4663   register const Quantum
4664     *p;
4665
4666   register ssize_t
4667     i;
4668
4669   ssize_t
4670     x_offset,
4671     y_offset;
4672
4673   assert(image != (Image *) NULL);
4674   assert(image->signature == MagickSignature);
4675   assert(image_view != (CacheView *) NULL);
4676   status=MagickTrue;
4677   x_offset=(ssize_t) floor(x);
4678   y_offset=(ssize_t) floor(y);
4679   switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
4680   {
4681     case AverageInterpolatePixel:
4682     {
4683       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4684         exception);
4685       if (p == (const Quantum *) NULL)
4686         {
4687           status=MagickFalse;
4688           break;
4689         }
4690       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4691       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4692       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4693       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4694       AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4695       AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4696       AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4697       AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4698       AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4699       AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4700       AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4701         10);
4702       AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4703         11);
4704       AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4705         12);
4706       AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4707         13);
4708       AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4709         14);
4710       AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4711         15);
4712       pixel->red=0.0;
4713       pixel->green=0.0;
4714       pixel->blue=0.0;
4715       pixel->black=0.0;
4716       pixel->alpha=0.0;
4717       for (i=0; i < 16L; i++)
4718       {
4719         gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
4720         pixel->red+=gamma*0.0625*pixels[i].red;
4721         pixel->green+=gamma*0.0625*pixels[i].green;
4722         pixel->blue+=gamma*0.0625*pixels[i].blue;
4723         if (image->colorspace == CMYKColorspace)
4724           pixel->black+=gamma*0.0625*pixels[i].black;
4725         pixel->alpha+=0.0625*pixels[i].alpha;
4726       }
4727       break;
4728     }
4729     case BicubicInterpolatePixel:
4730     {
4731       PixelInfo
4732         u[4];
4733
4734       PointInfo
4735         delta;
4736
4737       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4738         exception);
4739       if (p == (const Quantum *) NULL)
4740         {
4741           status=MagickFalse;
4742           break;
4743         }
4744       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4745       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4746       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4747       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4748       AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4749       AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4750       AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4751       AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4752       AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4753       AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4754       AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4755         10);
4756       AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4757         11);
4758       AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4759         12);
4760       AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4761         13);
4762       AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4763         14);
4764       AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4765         15);
4766       delta.x=x-x_offset;
4767       delta.y=y-y_offset;
4768       for (i=0; i < 4L; i++)
4769         BicubicInterpolate(pixels+4*i,delta.x,u+i);
4770       BicubicInterpolate(u,delta.y,pixel);
4771       break;
4772     }
4773     case BilinearInterpolatePixel:
4774     default:
4775     {
4776       PointInfo
4777         delta,
4778         epsilon;
4779
4780       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4781       if (p == (const Quantum *) NULL)
4782         {
4783           status=MagickFalse;
4784           break;
4785         }
4786       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4787       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4788       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4789       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4790       delta.x=x-x_offset;
4791       delta.y=y-y_offset;
4792       epsilon.x=1.0-delta.x;
4793       epsilon.y=1.0-delta.y;
4794       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4795         (epsilon.x*alpha[2]+delta.x*alpha[3])));
4796       gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4797       pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
4798         pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
4799       pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
4800         pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
4801         pixels[3].green));
4802       pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
4803         pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
4804         pixels[3].blue));
4805       if (image->colorspace == CMYKColorspace)
4806         pixel->black=gamma*(epsilon.y*(epsilon.x*pixels[0].black+delta.x*
4807           pixels[1].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
4808           pixels[3].black));
4809       gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4810       gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4811       pixel->alpha=(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
4812         pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
4813         pixels[3].alpha));
4814       break;
4815     }
4816     case FilterInterpolatePixel:
4817     {
4818       CacheView
4819         *filter_view;
4820
4821       Image
4822         *excerpt_image,
4823         *filter_image;
4824
4825       RectangleInfo
4826         geometry;
4827
4828       geometry.width=4L;
4829       geometry.height=4L;
4830       geometry.x=x_offset-1;
4831       geometry.y=y_offset-1;
4832       excerpt_image=ExcerptImage(image,&geometry,exception);
4833       if (excerpt_image == (Image *) NULL)
4834         {
4835           status=MagickFalse;
4836           break;
4837         }
4838       filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
4839         exception);
4840       excerpt_image=DestroyImage(excerpt_image);
4841       if (filter_image == (Image *) NULL)
4842         break;
4843       filter_view=AcquireCacheView(filter_image);
4844       p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4845       if (p != (const Quantum *) NULL)
4846         SetPixelInfo(image,p,pixel);
4847       filter_view=DestroyCacheView(filter_view);
4848       filter_image=DestroyImage(filter_image);
4849       break;
4850     }
4851     case IntegerInterpolatePixel:
4852     {
4853       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4854       if (p == (const Quantum *) NULL)
4855         {
4856           status=MagickFalse;
4857           break;
4858         }
4859       SetPixelInfo(image,p,pixel);
4860       break;
4861     }
4862     case MeshInterpolatePixel:
4863     {
4864       PointInfo
4865         delta,
4866         luminance;
4867
4868       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4869       if (p == (const Quantum *) NULL)
4870         {
4871           status=MagickFalse;
4872           break;
4873         }
4874       delta.x=x-x_offset;
4875       delta.y=y-y_offset;
4876       luminance.x=GetPixelLuminance(image,p)-(double)
4877         GetPixelLuminance(image,p+3*GetPixelChannels(image));
4878       luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
4879         GetPixelLuminance(image,p+2*GetPixelChannels(image));
4880       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4881       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4882       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4883       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4884       if (fabs(luminance.x) < fabs(luminance.y))
4885         {
4886           /*
4887             Diagonal 0-3 NW-SE.
4888           */
4889           if (delta.x <= delta.y)
4890             {
4891               /*
4892                 Bottom-left triangle (pixel: 2, diagonal: 0-3).
4893               */
4894               delta.y=1.0-delta.y;
4895               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4896               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4897               pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
4898                 pixels[3].red,pixels[0].red);
4899               pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
4900                 pixels[3].green,pixels[0].green);
4901               pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
4902                 pixels[3].blue,pixels[0].blue);
4903               if (image->colorspace == CMYKColorspace)
4904                 pixel->black=gamma*MeshInterpolate(&delta,pixels[2].black,
4905                   pixels[3].black,pixels[0].black);
4906               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4907               pixel->alpha=gamma*MeshInterpolate(&delta,pixels[2].alpha,
4908                 pixels[3].alpha,pixels[0].alpha);
4909             }
4910           else
4911             {
4912               /*
4913                 Top-right triangle (pixel:1 , diagonal: 0-3).
4914               */
4915               delta.x=1.0-delta.x;
4916               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4917               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4918               pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
4919                 pixels[0].red,pixels[3].red);
4920               pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
4921                 pixels[0].green,pixels[3].green);
4922               pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
4923                 pixels[0].blue,pixels[3].blue);
4924               if (image->colorspace == CMYKColorspace)
4925                 pixel->black=gamma*MeshInterpolate(&delta,pixels[1].black,
4926                   pixels[0].black,pixels[3].black);
4927               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4928               pixel->alpha=gamma*MeshInterpolate(&delta,pixels[1].alpha,
4929                 pixels[0].alpha,pixels[3].alpha);
4930             }
4931         }
4932       else
4933         {
4934           /*
4935             Diagonal 1-2 NE-SW.
4936           */
4937           if (delta.x <= (1.0-delta.y))
4938             {
4939               /*
4940                 Top-left triangle (pixel: 0, diagonal: 1-2).
4941               */
4942               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4943               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4944               pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
4945                 pixels[1].red,pixels[2].red);
4946               pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
4947                 pixels[1].green,pixels[2].green);
4948               pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
4949                 pixels[1].blue,pixels[2].blue);
4950               if (image->colorspace == CMYKColorspace)
4951                 pixel->black=gamma*MeshInterpolate(&delta,pixels[0].black,
4952                   pixels[1].black,pixels[2].black);
4953               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4954               pixel->alpha=gamma*MeshInterpolate(&delta,pixels[0].alpha,
4955                 pixels[1].alpha,pixels[2].alpha);
4956             }
4957           else
4958             {
4959               /*
4960                 Bottom-right triangle (pixel: 3, diagonal: 1-2).
4961               */
4962               delta.x=1.0-delta.x;
4963               delta.y=1.0-delta.y;
4964               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4965               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4966               pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
4967                 pixels[2].red,pixels[1].red);
4968               pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
4969                 pixels[2].green,pixels[1].green);
4970               pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
4971                 pixels[2].blue,pixels[1].blue);
4972               if (image->colorspace == CMYKColorspace)
4973                 pixel->black=gamma*MeshInterpolate(&delta,pixels[3].black,
4974                   pixels[2].black,pixels[1].black);
4975               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4976               pixel->alpha=gamma*MeshInterpolate(&delta,pixels[3].alpha,
4977                 pixels[2].alpha,pixels[1].alpha);
4978             }
4979         }
4980       break;
4981     }
4982     case NearestNeighborInterpolatePixel:
4983     {
4984       p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
4985         NearestNeighbor(y),1,1,exception);
4986       if (p == (const Quantum *) NULL)
4987         {
4988           status=MagickFalse;
4989           break;
4990         }
4991       SetPixelInfo(image,p,pixel);
4992       break;
4993     }
4994     case SplineInterpolatePixel:
4995     {
4996       MagickRealType
4997         dx,
4998         dy;
4999
5000       PointInfo
5001         delta;
5002
5003       ssize_t
5004         j,
5005         n;
5006
5007       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
5008         exception);
5009       if (p == (const Quantum *) NULL)
5010         {
5011           status=MagickFalse;
5012           break;
5013         }
5014       AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
5015       AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
5016       AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
5017       AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
5018       AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
5019       AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
5020       AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
5021       AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
5022       AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
5023       AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
5024       AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
5025         10);
5026       AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
5027         11);
5028       AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
5029         12);
5030       AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
5031         13);
5032       AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
5033         14);
5034       AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
5035         15);
5036       pixel->red=0.0;
5037       pixel->green=0.0;
5038       pixel->blue=0.0;
5039       pixel->black=0.0;
5040       pixel->alpha=0.0;
5041       delta.x=x-x_offset;
5042       delta.y=y-y_offset;
5043       n=0;
5044       for (i=(-1); i < 3L; i++)
5045       {
5046         dy=CubicWeightingFunction((MagickRealType) i-delta.y);
5047         for (j=(-1); j < 3L; j++)
5048         {
5049           dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
5050           gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
5051           pixel->red+=gamma*dx*dy*pixels[n].red;
5052           pixel->green+=gamma*dx*dy*pixels[n].green;
5053           pixel->blue+=gamma*dx*dy*pixels[n].blue;
5054           if (image->colorspace == CMYKColorspace)
5055             pixel->black+=gamma*dx*dy*pixels[n].black;
5056           pixel->alpha+=dx*dy*pixels[n].alpha;
5057           n++;
5058         }
5059       }
5060       break;
5061     }
5062   }
5063   return(status);
5064 }
5065 \f
5066 /*
5067 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5068 %                                                                             %
5069 %                                                                             %
5070 %                                                                             %
5071 +   I s F u z z y E q u i v a l e n c e P i x e l                             %
5072 %                                                                             %
5073 %                                                                             %
5074 %                                                                             %
5075 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5076 %
5077 %  IsFuzzyEquivalencePixel() returns MagickTrue if the distance between two
5078 %  pixels is less than the specified distance in a linear three (or four)u
5079 %  dimensional color space.
5080 %
5081 %  The format of the IsFuzzyEquivalencePixel method is:
5082 %
5083 %      void IsFuzzyEquivalencePixel(const Image *image,const Quantum *p,
5084 %        const Quantum *q)
5085 %
5086 %  A description of each parameter follows:
5087 %
5088 %    o image: the image.
5089 %
5090 %    o p: Pixel p.
5091 %
5092 %    o q: Pixel q.
5093 %
5094 */
5095 MagickExport MagickBooleanType IsFuzzyEquivalencePixel(const Image *image,
5096   const Quantum *p,const Quantum *q)
5097 {
5098   MagickRealType
5099     fuzz,
5100     pixel;
5101
5102   register MagickRealType
5103     distance,
5104     scale;
5105
5106   fuzz=MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2)*
5107     MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2);
5108   scale=1.0;
5109   distance=0.0;
5110   if (image->matte != MagickFalse)
5111     {
5112       /*
5113         Transparencies are involved - set alpha distance
5114       */
5115       pixel=(MagickRealType) ((image->matte != MagickFalse ?
5116         GetPixelAlpha(image,p) : OpaqueAlpha)-(image->matte != MagickFalse ?
5117         GetPixelAlpha(image,q) : OpaqueAlpha));
5118       distance=pixel*pixel;
5119       if (distance > fuzz)
5120         return(MagickFalse);
5121       /*
5122         Generate a alpha scaling factor to generate a 4D cone on colorspace
5123         Note that if one color is transparent, distance has no color component.
5124       */
5125       scale=QuantumScale*GetPixelAlpha(image,p);
5126       scale*=QuantumScale*GetPixelAlpha(image,q);
5127       if (scale <= MagickEpsilon)
5128         return(MagickTrue);
5129     }
5130   /*
5131     RGB or CMY color cube
5132   */
5133   distance*=3.0;  /* rescale appropriately */
5134   fuzz*=3.0;
5135   pixel=GetPixelRed(image,p)-(MagickRealType) GetPixelRed(image,q);
5136   if ((image->colorspace == HSLColorspace) ||
5137       (image->colorspace == HSBColorspace) ||
5138       (image->colorspace == HWBColorspace))
5139     {
5140       /*
5141         Compute an arc distance for hue.  It should be a vector angle of
5142         'S'/'W' length with 'L'/'B' forming appropriate cones.
5143       */
5144       if (fabs((double) pixel) > (QuantumRange/2))
5145         pixel-=QuantumRange;
5146       pixel*=2;
5147     }
5148   distance+=scale*pixel*pixel;
5149   if (distance > fuzz)
5150     return(MagickFalse);
5151   pixel=GetPixelGreen(image,p)-(MagickRealType) GetPixelGreen(image,q);
5152   distance+=scale*pixel*pixel;
5153   if (distance > fuzz)
5154     return(MagickFalse);
5155   pixel=GetPixelBlue(image,p)-(MagickRealType) GetPixelBlue(image,q);
5156   distance+=scale*pixel*pixel;
5157   if (distance > fuzz)
5158     return(MagickFalse);
5159   return(MagickTrue);
5160 }
5161 \f
5162 /*
5163 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5164 %                                                                             %
5165 %                                                                             %
5166 %                                                                             %
5167 +   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                     %
5168 %                                                                             %
5169 %                                                                             %
5170 %                                                                             %
5171 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5172 %
5173 %  IsFuzzyEquivalencePixelInfo() returns true if the distance between two
5174 %  colors is less than the specified distance in a linear three (or four)
5175 %  dimensional color space.
5176 %
5177 %  This implements the equivalent of...
5178 %    fuzz < sqrt( color_distance^2 * u.a*v.a  + alpha_distance^2 )
5179 %
5180 %  Which produces a multi-dimensional cone for that colorspace along the
5181 %  transparency vector.
5182 %
5183 %  For example for an RGB
5184 %    color_distance^2  = ( (u.r-v.r)^2 + (u.g-v.g)^2 + (u.b-v.b)^2 ) / 3
5185 %
5186 %  See http://www.imagemagick.org/Usage/bugs/fuzz_distance/
5187 %
5188 %  Hue colorspace distances need more work.  Hue is not a distance, it is an
5189 %  angle!
5190 %
5191 %  A check that q is in the same color space as p should be made and the
5192 %  appropriate mapping made.  -- Anthony Thyssen  8 December 2010
5193 %
5194 %  The format of the IsFuzzyEquivalencePixelInfo method is:
5195 %
5196 %      MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
5197 %        const PixelInfo *q)
5198 %
5199 %  A description of each parameter follows:
5200 %
5201 %    o p: Pixel p.
5202 %
5203 %    o q: Pixel q.
5204 %
5205 */
5206 MagickExport MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
5207   const PixelInfo *q)
5208 {
5209   MagickRealType
5210     fuzz,
5211     pixel;
5212
5213   register MagickRealType
5214     scale,
5215     distance;
5216
5217   if ((p->fuzz == 0.0) && (q->fuzz == 0.0))
5218     return(IsPixelInfoEquivalent(p,q));
5219   if (p->fuzz == 0.0)
5220     fuzz=MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2)*
5221       MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
5222   else if (q->fuzz == 0.0)
5223     fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*
5224       MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2);
5225   else
5226     fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*
5227       MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
5228   scale=1.0;
5229   distance=0.0;
5230   if ((p->matte != MagickFalse) || (q->matte != MagickFalse))
5231     {
5232       /*
5233         Transparencies are involved - set alpha distance.
5234       */
5235       pixel=(p->matte != MagickFalse ? p->alpha : OpaqueAlpha)-
5236         (q->matte != MagickFalse ? q->alpha : OpaqueAlpha);
5237       distance=pixel*pixel;
5238       if (distance > fuzz)
5239         return(MagickFalse);
5240       /*
5241         Generate a alpha scaling factor to generate a 4D cone on colorspace.
5242         Note that if one color is transparent, distance has no color component.
5243       */
5244       if (p->matte != MagickFalse)
5245         scale=(QuantumScale*p->alpha);
5246       if (q->matte != MagickFalse)
5247         scale*=(QuantumScale*q->alpha);
5248       if (scale <= MagickEpsilon )
5249         return(MagickTrue);
5250     }
5251   /*
5252     CMYK create a CMY cube with a multi-dimensional cone toward black.
5253   */
5254   if (p->colorspace == CMYKColorspace)
5255     {
5256       pixel=p->black-q->black;
5257       distance+=pixel*pixel*scale;
5258       if (distance > fuzz)
5259         return(MagickFalse);
5260       scale*=(MagickRealType) (QuantumScale*(QuantumRange-p->black));
5261       scale*=(MagickRealType) (QuantumScale*(QuantumRange-q->black));
5262     }
5263   /*
5264     RGB or CMY color cube.
5265   */
5266   distance*=3.0;  /* rescale appropriately */
5267   fuzz*=3.0;
5268   pixel=p->red-q->red;
5269   if ((p->colorspace == HSLColorspace) || (p->colorspace == HSBColorspace) ||
5270       (p->colorspace == HWBColorspace))
5271     {
5272       /* This calculates a arc distance for hue
5273          Really if should be a vector angle of 'S'/'W' length
5274          with 'L'/'B' forming appropriate cones.
5275          In other words this is a hack - Anthony
5276       */
5277       if (fabs((double) pixel) > (QuantumRange/2))
5278         pixel-=QuantumRange;
5279       pixel*=2;
5280     }
5281   distance+=pixel*pixel*scale;
5282   if (distance > fuzz)
5283     return(MagickFalse);
5284   pixel=p->green-q->green;
5285   distance+=pixel*pixel*scale;
5286   if (distance > fuzz)
5287     return(MagickFalse);
5288   pixel=p->blue-q->blue;
5289   distance+=pixel*pixel*scale;
5290   if (distance > fuzz)
5291     return(MagickFalse);
5292   return(MagickTrue);
5293 }
5294 \f
5295 /*
5296 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5297 %                                                                             %
5298 %                                                                             %
5299 %                                                                             %
5300 +   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                 %
5301 %                                                                             %
5302 %                                                                             %
5303 %                                                                             %
5304 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5305 %
5306 %  IsFuzzyEquivalencePixelPacket() returns MagickTrue if the distance between
5307 %  two pixels is less than the specified distance in a linear three (or four)
5308 %  dimensional color space.
5309 %
5310 %  The format of the IsFuzzyEquivalencePixelPacket method is:
5311 %
5312 %      void IsFuzzyEquivalencePixelPacket(const Image *image,
5313 %        const PixelPacket *p,const PixelPacket *q)
5314 %
5315 %  A description of each parameter follows:
5316 %
5317 %    o image: the image.
5318 %
5319 %    o p: Pixel p.
5320 %
5321 %    o q: Pixel q.
5322 %
5323 */
5324 MagickExport MagickBooleanType IsFuzzyEquivalencePixelPacket(const Image *image,
5325   const PixelPacket *p,const PixelPacket *q)
5326 {
5327   MagickRealType
5328     fuzz,
5329     pixel;
5330
5331   register MagickRealType
5332     distance,
5333     scale;
5334
5335   if ((image->fuzz == 0.0) && (image->matte == MagickFalse))
5336     return(IsPixelPacketEquivalent(p,q));
5337   fuzz=MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2)*
5338     MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2);
5339   scale=1.0;
5340   distance=0.0;
5341   if (image->matte != MagickFalse)
5342     {
5343       /*
5344         Transparencies are involved - set alpha distance
5345       */
5346       pixel=(MagickRealType) ((image->matte != MagickFalse ? p->alpha :
5347         OpaqueAlpha)-(image->matte != MagickFalse ? q->alpha : OpaqueAlpha));
5348       distance=pixel*pixel;
5349       if (distance > fuzz)
5350         return(MagickFalse);
5351       /*
5352         Generate a alpha scaling factor to generate a 4D cone on colorspace
5353         Note that if one color is transparent, distance has no color component.
5354       */
5355       scale=QuantumScale*p->alpha;
5356       scale*=QuantumScale*q->alpha;
5357       if (scale <= MagickEpsilon)
5358         return(MagickTrue);
5359     }
5360   /*
5361     RGB or CMY color cube
5362   */
5363   distance*=3.0;  /* rescale appropriately */
5364   fuzz*=3.0;
5365   pixel=p->red-(MagickRealType) q->red;
5366   if ((image->colorspace == HSLColorspace) ||
5367       (image->colorspace == HSBColorspace) ||
5368       (image->colorspace == HWBColorspace))
5369     {
5370       /*
5371         Compute an arc distance for hue.  It should be a vector angle of
5372         'S'/'W' length with 'L'/'B' forming appropriate cones.
5373       */
5374       if (fabs((double) pixel) > (QuantumRange/2))
5375         pixel-=QuantumRange;
5376       pixel*=2;
5377     }
5378   distance+=scale*pixel*pixel;
5379   if (distance > fuzz)
5380     return(MagickFalse);
5381   pixel=(MagickRealType) p->green-q->green;
5382   distance+=scale*pixel*pixel;
5383   if (distance > fuzz)
5384     return(MagickFalse);
5385   pixel=(MagickRealType) p->blue-q->blue;
5386   distance+=scale*pixel*pixel;
5387   if (distance > fuzz)
5388     return(MagickFalse);
5389   return(MagickTrue);
5390 }
5391 \f
5392 /*
5393 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5394 %                                                                             %
5395 %                                                                             %
5396 %                                                                             %
5397 %   S e t P i x e l C h a n n e l M a p                                       %
5398 %                                                                             %
5399 %                                                                             %
5400 %                                                                             %
5401 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5402 %
5403 %  SetPixelChannelMap() sets the pixel channel map from the specified channel
5404 %  mask.
5405 %
5406 %  The format of the SetPixelChannelMap method is:
5407 %
5408 %      void SetPixelChannelMap(Image *image,const ChannelType channel_mask)
5409 %
5410 %  A description of each parameter follows:
5411 %
5412 %    o image: the image.
5413 %
5414 %    o mask: the channel mask.
5415 %
5416 */
5417 MagickExport void SetPixelChannelMap(Image *image,
5418   const ChannelType channel_mask)
5419 {
5420 #define GetChannelBit(mask,bit)  (((size_t) (mask) >> (size_t) (bit)) & 0x01)
5421
5422   register ssize_t
5423     i;
5424
5425   image->sync=channel_mask == DefaultChannels ? MagickTrue : MagickFalse;
5426   for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
5427     SetPixelChannelMapTraits(image,(PixelChannel) i,
5428       GetChannelBit(channel_mask,i) != 0 ? UpdatePixelTrait : CopyPixelTrait);
5429   for ( ; i < MaxPixelChannels; i++)
5430     SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
5431   if (image->storage_class == PseudoClass)
5432     SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
5433 }
5434 \f
5435 /*
5436 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5437 %                                                                             %
5438 %                                                                             %
5439 %                                                                             %
5440 %   S e t P i x e l C h a n n e l M a s k                                     %
5441 %                                                                             %
5442 %                                                                             %
5443 %                                                                             %
5444 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5445 %
5446 %  SetPixelChannelMask() sets the pixel channel mask from the specified
5447 %  channel mask.
5448 %
5449 %  The format of the SetPixelChannelMask method is:
5450 %
5451 %      ChannelType SetPixelChannelMask(Image *image,
5452 %        const ChannelType channel_mask)
5453 %
5454 %  A description of each parameter follows:
5455 %
5456 %    o image: the image.
5457 %
5458 %    o channel_mask: the channel mask.
5459 %
5460 */
5461 MagickExport ChannelType SetPixelChannelMask(Image *image,
5462   const ChannelType channel_mask)
5463 {
5464   ChannelType
5465     mask;
5466
5467   mask=image->channel_mask;
5468   image->channel_mask=channel_mask;
5469   SetPixelChannelMap(image,channel_mask);
5470   return(mask);
5471 }