granicus.if.org Git - imagemagick/blob - magick/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 "magick/studio.h"
  42 #include "magick/property.h"
  43 #include "magick/blob.h"
  44 #include "magick/blob-private.h"
  45 #include "magick/color-private.h"
  46 #include "magick/draw.h"
  47 #include "magick/exception.h"
  48 #include "magick/exception-private.h"
  49 #include "magick/cache.h"
  50 #include "magick/constitute.h"
  51 #include "magick/delegate.h"
  52 #include "magick/geometry.h"
  53 #include "magick/list.h"
  54 #include "magick/magick.h"
  55 #include "magick/memory_.h"
  56 #include "magick/monitor.h"
  57 #include "magick/option.h"
  58 #include "magick/pixel.h"
  59 #include "magick/pixel-private.h"
  60 #include "magick/quantum.h"
  61 #include "magick/resource_.h"
  62 #include "magick/semaphore.h"
  63 #include "magick/statistic.h"
  64 #include "magick/stream.h"
  65 #include "magick/string_.h"
  66 #include "magick/transform.h"
  67 #include "magick/utility.h"
  68 \f
  69 /*
  70 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  71 %                                                                             %
  72 %                                                                             %
  73 %                                                                             %
  74 %   E x p o r t I m a g e P i x e l s                                         %
  75 %                                                                             %
  76 %                                                                             %
  77 %                                                                             %
  78 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  79 %
  80 %  ExportImagePixels() extracts pixel data from an image and returns it to you.
  81 %  The method returns MagickTrue on success otherwise MagickFalse if an error is
  82 %  encountered.  The data is returned as char, short int, int, ssize_t, float,
  83 %  or double in the order specified by map.
  84 %
  85 %  Suppose you want to extract the first scanline of a 640x480 image as
  86 %  character data in red-green-blue order:
  87 %
  88 %      ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
  89 %
  90 %  The format of the ExportImagePixels method is:
  91 %
  92 %      MagickBooleanType ExportImagePixels(const Image *image,
  93 %        const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
  94 %        const size_t rows,const char *map,const StorageType type,
  95 %        void *pixels,ExceptionInfo *exception)
  96 %
  97 %  A description of each parameter follows:
  98 %
  99 %    o image: the image.
 100 %
 101 %    o x_offset,y_offset,columns,rows:  These values define the perimeter
 102 %      of a region of pixels you want to extract.
 103 %
 104 %    o map:  This string reflects the expected ordering of the pixel array.
 105 %      It can be any combination or order of R = red, G = green, B = blue,
 106 %      A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
 107 %      Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
 108 %      P = pad.
 109 %
 110 %    o type: Define the data type of the pixels.  Float and double types are
 111 %      normalized to [0..1] otherwise [0..QuantumRange].  Choose from these
 112 %      types: CharPixel, DoublePixel, FloatPixel, IntegerPixel, LongPixel,
 113 %      QuantumPixel, or ShortPixel.
 114 %
 115 %    o pixels: This array of values contain the pixel components as defined by
 116 %      map and type.  You must preallocate this array where the expected
 117 %      length varies depending on the values of width, height, map, and type.
 118 %
 119 %    o exception: return any errors or warnings in this structure.
 120 %
 121 */
 122 MagickExport MagickBooleanType ExportImagePixels(const Image *image,
 123   const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
 124   const size_t rows,const char *map,const StorageType type,void *pixels,
 125   ExceptionInfo *exception)
 126 {
 127   QuantumType
 128     *quantum_map;
 129
 130   register ssize_t
 131     i,
 132     x;
 133
 134   register const IndexPacket
 135     *indexes;
 136
 137   register const PixelPacket
 138     *p;
 139
 140   size_t
 141     length;
 142
 143   ssize_t
 144     y;
 145
 146   assert(image != (Image *) NULL);
 147   assert(image->signature == MagickSignature);
 148   if (image->debug != MagickFalse)
 149     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 150   length=strlen(map);
 151   quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
 152   if (quantum_map == (QuantumType *) NULL)
 153     {
 154       (void) ThrowMagickException(exception,GetMagickModule(),
 155         ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
 156       return(MagickFalse);
 157     }
 158   for (i=0; i < (ssize_t) length; i++)
 159   {
 160     switch (map[i])
 161     {
 162       case 'A':
 163       case 'a':
 164       {
 165         quantum_map[i]=AlphaQuantum;
 166         break;
 167       }
 168       case 'B':
 169       case 'b':
 170       {
 171         quantum_map[i]=BlueQuantum;
 172         break;
 173       }
 174       case 'C':
 175       case 'c':
 176       {
 177         quantum_map[i]=CyanQuantum;
 178         if (image->colorspace == CMYKColorspace)
 179           break;
 180         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 181         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 182           "ColorSeparatedImageRequired","`%s'",map);
 183         return(MagickFalse);
 184       }
 185       case 'g':
 186       case 'G':
 187       {
 188         quantum_map[i]=GreenQuantum;
 189         break;
 190       }
 191       case 'I':
 192       case 'i':
 193       {
 194         quantum_map[i]=IndexQuantum;
 195         break;
 196       }
 197       case 'K':
 198       case 'k':
 199       {
 200         quantum_map[i]=BlackQuantum;
 201         if (image->colorspace == CMYKColorspace)
 202           break;
 203         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 204         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 205           "ColorSeparatedImageRequired","`%s'",map);
 206         return(MagickFalse);
 207       }
 208       case 'M':
 209       case 'm':
 210       {
 211         quantum_map[i]=MagentaQuantum;
 212         if (image->colorspace == CMYKColorspace)
 213           break;
 214         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 215         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 216           "ColorSeparatedImageRequired","`%s'",map);
 217         return(MagickFalse);
 218       }
 219       case 'o':
 220       case 'O':
 221       {
 222         quantum_map[i]=OpacityQuantum;
 223         break;
 224       }
 225       case 'P':
 226       case 'p':
 227       {
 228         quantum_map[i]=UndefinedQuantum;
 229         break;
 230       }
 231       case 'R':
 232       case 'r':
 233       {
 234         quantum_map[i]=RedQuantum;
 235         break;
 236       }
 237       case 'Y':
 238       case 'y':
 239       {
 240         quantum_map[i]=YellowQuantum;
 241         if (image->colorspace == CMYKColorspace)
 242           break;
 243         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 244         (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
 245           "ColorSeparatedImageRequired","`%s'",map);
 246         return(MagickFalse);
 247       }
 248       default:
 249       {
 250         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
 251         (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
 252           "UnrecognizedPixelMap","`%s'",map);
 253         return(MagickFalse);
 254       }
 255     }
 256   }
 257   switch (type)
 258   {
 259     case CharPixel:
 260     {
 261       register unsigned char
 262         *q;
 263
 264       q=(unsigned char *) pixels;
 265       if (LocaleCompare(map,"BGR") == 0)
 266         {
 267           for (y=0; y < (ssize_t) rows; y++)
 268           {
 269             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 270             if (p == (const PixelPacket *) NULL)
 271               break;
 272             for (x=0; x < (ssize_t) columns; x++)
 273             {
 274               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 275               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 276               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 277               p++;
 278             }
 279           }
 280           break;
 281         }
 282       if (LocaleCompare(map,"BGRA") == 0)
 283         {
 284           for (y=0; y < (ssize_t) rows; y++)
 285           {
 286             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 287             if (p == (const PixelPacket *) NULL)
 288               break;
 289             for (x=0; x < (ssize_t) columns; x++)
 290             {
 291               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 292               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 293               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 294               *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
 295               p++;
 296             }
 297           }
 298           break;
 299         }
 300       if (LocaleCompare(map,"BGRP") == 0)
 301         {
 302           for (y=0; y < (ssize_t) rows; y++)
 303           {
 304             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 305             if (p == (const PixelPacket *) NULL)
 306               break;
 307             for (x=0; x < (ssize_t) columns; x++)
 308             {
 309               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 310               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 311               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 312               *q++=ScaleQuantumToChar((Quantum) 0);
 313               p++;
 314             }
 315           }
 316           break;
 317         }
 318       if (LocaleCompare(map,"I") == 0)
 319         {
 320           for (y=0; y < (ssize_t) rows; y++)
 321           {
 322             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 323             if (p == (const PixelPacket *) NULL)
 324               break;
 325             for (x=0; x < (ssize_t) columns; x++)
 326             {
 327               *q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));
 328               p++;
 329             }
 330           }
 331           break;
 332         }
 333       if (LocaleCompare(map,"RGB") == 0)
 334         {
 335           for (y=0; y < (ssize_t) rows; y++)
 336           {
 337             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 338             if (p == (const PixelPacket *) NULL)
 339               break;
 340             for (x=0; x < (ssize_t) columns; x++)
 341             {
 342               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 343               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 344               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 345               p++;
 346             }
 347           }
 348           break;
 349         }
 350       if (LocaleCompare(map,"RGBA") == 0)
 351         {
 352           for (y=0; y < (ssize_t) rows; y++)
 353           {
 354             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 355             if (p == (const PixelPacket *) NULL)
 356               break;
 357             for (x=0; x < (ssize_t) columns; x++)
 358             {
 359               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 360               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 361               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 362               *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
 363               p++;
 364             }
 365           }
 366           break;
 367         }
 368       if (LocaleCompare(map,"RGBP") == 0)
 369         {
 370           for (y=0; y < (ssize_t) rows; y++)
 371           {
 372             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 373             if (p == (const PixelPacket *) NULL)
 374               break;
 375             for (x=0; x < (ssize_t) columns; x++)
 376             {
 377               *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
 378               *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
 379               *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
 380               *q++=ScaleQuantumToChar((Quantum) 0);
 381               p++;
 382             }
 383           }
 384           break;
 385         }
 386       for (y=0; y < (ssize_t) rows; y++)
 387       {
 388         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 389         if (p == (const PixelPacket *) NULL)
 390           break;
 391         indexes=GetVirtualIndexQueue(image);
 392         for (x=0; x < (ssize_t) columns; x++)
 393         {
 394           for (i=0; i < (ssize_t) length; i++)
 395           {
 396             *q=0;
 397             switch (quantum_map[i])
 398             {
 399               case RedQuantum:
 400               case CyanQuantum:
 401               {
 402                 *q=ScaleQuantumToChar(GetRedPixelComponent(p));
 403                 break;
 404               }
 405               case GreenQuantum:
 406               case MagentaQuantum:
 407               {
 408                 *q=ScaleQuantumToChar(GetGreenPixelComponent(p));
 409                 break;
 410               }
 411               case BlueQuantum:
 412               case YellowQuantum:
 413               {
 414                 *q=ScaleQuantumToChar(GetBluePixelComponent(p));
 415                 break;
 416               }
 417               case AlphaQuantum:
 418               {
 419                 *q=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
 420                 break;
 421               }
 422               case OpacityQuantum:
 423               {
 424                 *q=ScaleQuantumToChar(GetOpacityPixelComponent(p));
 425                 break;
 426               }
 427               case BlackQuantum:
 428               {
 429                 if (image->colorspace == CMYKColorspace)
 430                   *q=ScaleQuantumToChar(indexes[x]);
 431                 break;
 432               }
 433               case IndexQuantum:
 434               {
 435                 *q=ScaleQuantumToChar(PixelIntensityToQuantum(p));
 436                 break;
 437               }
 438               default:
 439                 break;
 440             }
 441             q++;
 442           }
 443           p++;
 444         }
 445       }
 446       break;
 447     }
 448     case DoublePixel:
 449     {
 450       register double
 451         *q;
 452
 453       q=(double *) pixels;
 454       if (LocaleCompare(map,"BGR") == 0)
 455         {
 456           for (y=0; y < (ssize_t) rows; y++)
 457           {
 458             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 459             if (p == (const PixelPacket *) NULL)
 460               break;
 461             for (x=0; x < (ssize_t) columns; x++)
 462             {
 463               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 464               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 465               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 466               p++;
 467             }
 468           }
 469           break;
 470         }
 471       if (LocaleCompare(map,"BGRA") == 0)
 472         {
 473           for (y=0; y < (ssize_t) rows; y++)
 474           {
 475             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 476             if (p == (const PixelPacket *) NULL)
 477               break;
 478             for (x=0; x < (ssize_t) columns; x++)
 479             {
 480               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 481               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 482               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 483               *q++=(double) (QuantumScale*((Quantum) (QuantumRange-
 484                 GetOpacityPixelComponent(p))));
 485               p++;
 486             }
 487           }
 488           break;
 489         }
 490       if (LocaleCompare(map,"BGRP") == 0)
 491         {
 492           for (y=0; y < (ssize_t) rows; y++)
 493           {
 494             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 495             if (p == (const PixelPacket *) NULL)
 496               break;
 497             for (x=0; x < (ssize_t) columns; x++)
 498             {
 499               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 500               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 501               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 502               *q++=0.0;
 503               p++;
 504             }
 505           }
 506           break;
 507         }
 508       if (LocaleCompare(map,"I") == 0)
 509         {
 510           for (y=0; y < (ssize_t) rows; y++)
 511           {
 512             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 513             if (p == (const PixelPacket *) NULL)
 514               break;
 515             for (x=0; x < (ssize_t) columns; x++)
 516             {
 517               *q++=(double) (QuantumScale*PixelIntensityToQuantum(p));
 518               p++;
 519             }
 520           }
 521           break;
 522         }
 523       if (LocaleCompare(map,"RGB") == 0)
 524         {
 525           for (y=0; y < (ssize_t) rows; y++)
 526           {
 527             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 528             if (p == (const PixelPacket *) NULL)
 529               break;
 530             for (x=0; x < (ssize_t) columns; x++)
 531             {
 532               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 533               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 534               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 535               p++;
 536             }
 537           }
 538           break;
 539         }
 540       if (LocaleCompare(map,"RGBA") == 0)
 541         {
 542           for (y=0; y < (ssize_t) rows; y++)
 543           {
 544             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 545             if (p == (const PixelPacket *) NULL)
 546               break;
 547             for (x=0; x < (ssize_t) columns; x++)
 548             {
 549               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 550               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 551               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 552               *q++=(double) (QuantumScale*((Quantum) (QuantumRange-
 553                 GetOpacityPixelComponent(p))));
 554               p++;
 555             }
 556           }
 557           break;
 558         }
 559       if (LocaleCompare(map,"RGBP") == 0)
 560         {
 561           for (y=0; y < (ssize_t) rows; y++)
 562           {
 563             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 564             if (p == (const PixelPacket *) NULL)
 565               break;
 566             for (x=0; x < (ssize_t) columns; x++)
 567             {
 568               *q++=(double) (QuantumScale*GetRedPixelComponent(p));
 569               *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
 570               *q++=(double) (QuantumScale*GetBluePixelComponent(p));
 571               *q++=0.0;
 572               p++;
 573             }
 574           }
 575           break;
 576         }
 577       for (y=0; y < (ssize_t) rows; y++)
 578       {
 579         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 580         if (p == (const PixelPacket *) NULL)
 581           break;
 582         indexes=GetVirtualIndexQueue(image);
 583         for (x=0; x < (ssize_t) columns; x++)
 584         {
 585           for (i=0; i < (ssize_t) length; i++)
 586           {
 587             *q=0;
 588             switch (quantum_map[i])
 589             {
 590               case RedQuantum:
 591               case CyanQuantum:
 592               {
 593                 *q=(double) (QuantumScale*GetRedPixelComponent(p));
 594                 break;
 595               }
 596               case GreenQuantum:
 597               case MagentaQuantum:
 598               {
 599                 *q=(double) (QuantumScale*GetGreenPixelComponent(p));
 600                 break;
 601               }
 602               case BlueQuantum:
 603               case YellowQuantum:
 604               {
 605                 *q=(double) (QuantumScale*GetBluePixelComponent(p));
 606                 break;
 607               }
 608               case AlphaQuantum:
 609               {
 610                 *q=(double) (QuantumScale*((Quantum) (QuantumRange-
 611                   GetOpacityPixelComponent(p))));
 612                 break;
 613               }
 614               case OpacityQuantum:
 615               {
 616                 *q=(double) (QuantumScale*GetOpacityPixelComponent(p));
 617                 break;
 618               }
 619               case BlackQuantum:
 620               {
 621                 if (image->colorspace == CMYKColorspace)
 622                   *q=(double) (QuantumScale*indexes[x]);
 623                 break;
 624               }
 625               case IndexQuantum:
 626               {
 627                 *q=(double) (QuantumScale*PixelIntensityToQuantum(p));
 628                 break;
 629               }
 630               default:
 631                 *q=0;
 632             }
 633             q++;
 634           }
 635           p++;
 636         }
 637       }
 638       break;
 639     }
 640     case FloatPixel:
 641     {
 642       register float
 643         *q;
 644
 645       q=(float *) pixels;
 646       if (LocaleCompare(map,"BGR") == 0)
 647         {
 648           for (y=0; y < (ssize_t) rows; y++)
 649           {
 650             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 651             if (p == (const PixelPacket *) NULL)
 652               break;
 653             for (x=0; x < (ssize_t) columns; x++)
 654             {
 655               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 656               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 657               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 658               p++;
 659             }
 660           }
 661           break;
 662         }
 663       if (LocaleCompare(map,"BGRA") == 0)
 664         {
 665           for (y=0; y < (ssize_t) rows; y++)
 666           {
 667             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 668             if (p == (const PixelPacket *) NULL)
 669               break;
 670             for (x=0; x < (ssize_t) columns; x++)
 671             {
 672               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 673               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 674               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 675               *q++=(float) (QuantumScale*(Quantum) (GetAlphaPixelComponent(p)));
 676               p++;
 677             }
 678           }
 679           break;
 680         }
 681       if (LocaleCompare(map,"BGRP") == 0)
 682         {
 683           for (y=0; y < (ssize_t) rows; y++)
 684           {
 685             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 686             if (p == (const PixelPacket *) NULL)
 687               break;
 688             for (x=0; x < (ssize_t) columns; x++)
 689             {
 690               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 691               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 692               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 693               *q++=0.0;
 694               p++;
 695             }
 696           }
 697           break;
 698         }
 699       if (LocaleCompare(map,"I") == 0)
 700         {
 701           for (y=0; y < (ssize_t) rows; y++)
 702           {
 703             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 704             if (p == (const PixelPacket *) NULL)
 705               break;
 706             for (x=0; x < (ssize_t) columns; x++)
 707             {
 708               *q++=(float) (QuantumScale*PixelIntensityToQuantum(p));
 709               p++;
 710             }
 711           }
 712           break;
 713         }
 714       if (LocaleCompare(map,"RGB") == 0)
 715         {
 716           for (y=0; y < (ssize_t) rows; y++)
 717           {
 718             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 719             if (p == (const PixelPacket *) NULL)
 720               break;
 721             for (x=0; x < (ssize_t) columns; x++)
 722             {
 723               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 724               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 725               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 726               p++;
 727             }
 728           }
 729           break;
 730         }
 731       if (LocaleCompare(map,"RGBA") == 0)
 732         {
 733           for (y=0; y < (ssize_t) rows; y++)
 734           {
 735             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 736             if (p == (const PixelPacket *) NULL)
 737               break;
 738             for (x=0; x < (ssize_t) columns; x++)
 739             {
 740               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 741               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 742               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 743               *q++=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p))));
 744               p++;
 745             }
 746           }
 747           break;
 748         }
 749       if (LocaleCompare(map,"RGBP") == 0)
 750         {
 751           for (y=0; y < (ssize_t) rows; y++)
 752           {
 753             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 754             if (p == (const PixelPacket *) NULL)
 755               break;
 756             for (x=0; x < (ssize_t) columns; x++)
 757             {
 758               *q++=(float) (QuantumScale*GetRedPixelComponent(p));
 759               *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
 760               *q++=(float) (QuantumScale*GetBluePixelComponent(p));
 761               *q++=0.0;
 762               p++;
 763             }
 764           }
 765           break;
 766         }
 767       for (y=0; y < (ssize_t) rows; y++)
 768       {
 769         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 770         if (p == (const PixelPacket *) NULL)
 771           break;
 772         indexes=GetVirtualIndexQueue(image);
 773         for (x=0; x < (ssize_t) columns; x++)
 774         {
 775           for (i=0; i < (ssize_t) length; i++)
 776           {
 777             *q=0;
 778             switch (quantum_map[i])
 779             {
 780               case RedQuantum:
 781               case CyanQuantum:
 782               {
 783                 *q=(float) (QuantumScale*GetRedPixelComponent(p));
 784                 break;
 785               }
 786               case GreenQuantum:
 787               case MagentaQuantum:
 788               {
 789                 *q=(float) (QuantumScale*GetGreenPixelComponent(p));
 790                 break;
 791               }
 792               case BlueQuantum:
 793               case YellowQuantum:
 794               {
 795                 *q=(float) (QuantumScale*GetBluePixelComponent(p));
 796                 break;
 797               }
 798               case AlphaQuantum:
 799               {
 800                 *q=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p))));
 801                 break;
 802               }
 803               case OpacityQuantum:
 804               {
 805                 *q=(float) (QuantumScale*GetOpacityPixelComponent(p));
 806                 break;
 807               }
 808               case BlackQuantum:
 809               {
 810                 if (image->colorspace == CMYKColorspace)
 811                   *q=(float) (QuantumScale*indexes[x]);
 812                 break;
 813               }
 814               case IndexQuantum:
 815               {
 816                 *q=(float) (QuantumScale*PixelIntensityToQuantum(p));
 817                 break;
 818               }
 819               default:
 820                 *q=0;
 821             }
 822             q++;
 823           }
 824           p++;
 825         }
 826       }
 827       break;
 828     }
 829     case IntegerPixel:
 830     {
 831       register unsigned int
 832         *q;
 833
 834       q=(unsigned int *) pixels;
 835       if (LocaleCompare(map,"BGR") == 0)
 836         {
 837           for (y=0; y < (ssize_t) rows; y++)
 838           {
 839             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 840             if (p == (const PixelPacket *) NULL)
 841               break;
 842             for (x=0; x < (ssize_t) columns; x++)
 843             {
 844               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 845               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 846               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 847               p++;
 848             }
 849           }
 850           break;
 851         }
 852       if (LocaleCompare(map,"BGRA") == 0)
 853         {
 854           for (y=0; y < (ssize_t) rows; y++)
 855           {
 856             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 857             if (p == (const PixelPacket *) NULL)
 858               break;
 859             for (x=0; x < (ssize_t) columns; x++)
 860             {
 861               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 862               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 863               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 864               *q++=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
 865                 GetOpacityPixelComponent(p)));
 866               p++;
 867             }
 868           }
 869           break;
 870         }
 871       if (LocaleCompare(map,"BGRP") == 0)
 872         {
 873           for (y=0; y < (ssize_t) rows; y++)
 874           {
 875             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 876             if (p == (const PixelPacket *) NULL)
 877               break;
 878             for (x=0; x < (ssize_t) columns; x++)
 879             {
 880               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 881               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 882               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 883               *q++=0U;
 884               p++;
 885             }
 886           }
 887           break;
 888         }
 889       if (LocaleCompare(map,"I") == 0)
 890         {
 891           for (y=0; y < (ssize_t) rows; y++)
 892           {
 893             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 894             if (p == (const PixelPacket *) NULL)
 895               break;
 896             for (x=0; x < (ssize_t) columns; x++)
 897             {
 898               *q++=(unsigned int)
 899                 ScaleQuantumToLong(PixelIntensityToQuantum(p));
 900               p++;
 901             }
 902           }
 903           break;
 904         }
 905       if (LocaleCompare(map,"RGB") == 0)
 906         {
 907           for (y=0; y < (ssize_t) rows; y++)
 908           {
 909             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 910             if (p == (const PixelPacket *) NULL)
 911               break;
 912             for (x=0; x < (ssize_t) columns; x++)
 913             {
 914               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 915               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 916               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 917               p++;
 918             }
 919           }
 920           break;
 921         }
 922       if (LocaleCompare(map,"RGBA") == 0)
 923         {
 924           for (y=0; y < (ssize_t) rows; y++)
 925           {
 926             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 927             if (p == (const PixelPacket *) NULL)
 928               break;
 929             for (x=0; x < (ssize_t) columns; x++)
 930             {
 931               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 932               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 933               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 934               *q++=(unsigned int) ScaleQuantumToLong((Quantum)
 935                 (GetAlphaPixelComponent(p)));
 936               p++;
 937             }
 938           }
 939           break;
 940         }
 941       if (LocaleCompare(map,"RGBP") == 0)
 942         {
 943           for (y=0; y < (ssize_t) rows; y++)
 944           {
 945             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 946             if (p == (const PixelPacket *) NULL)
 947               break;
 948             for (x=0; x < (ssize_t) columns; x++)
 949             {
 950               *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 951               *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 952               *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 953               *q++=0U;
 954               p++;
 955             }
 956           }
 957           break;
 958         }
 959       for (y=0; y < (ssize_t) rows; y++)
 960       {
 961         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
 962         if (p == (const PixelPacket *) NULL)
 963           break;
 964         indexes=GetVirtualIndexQueue(image);
 965         for (x=0; x < (ssize_t) columns; x++)
 966         {
 967           for (i=0; i < (ssize_t) length; i++)
 968           {
 969             *q=0;
 970             switch (quantum_map[i])
 971             {
 972               case RedQuantum:
 973               case CyanQuantum:
 974               {
 975                 *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
 976                 break;
 977               }
 978               case GreenQuantum:
 979               case MagentaQuantum:
 980               {
 981                 *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
 982                 break;
 983               }
 984               case BlueQuantum:
 985               case YellowQuantum:
 986               {
 987                 *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
 988                 break;
 989               }
 990               case AlphaQuantum:
 991               {
 992                 *q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
 993                   GetOpacityPixelComponent(p)));
 994                 break;
 995               }
 996               case OpacityQuantum:
 997               {
 998                 *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p));
 999                 break;
1000               }
1001               case BlackQuantum:
1002               {
1003                 if (image->colorspace == CMYKColorspace)
1004                   *q=(unsigned int) ScaleQuantumToLong(indexes[x]);
1005                 break;
1006               }
1007               case IndexQuantum:
1008               {
1009                 *q=(unsigned int)
1010                   ScaleQuantumToLong(PixelIntensityToQuantum(p));
1011                 break;
1012               }
1013               default:
1014                 *q=0;
1015             }
1016             q++;
1017           }
1018           p++;
1019         }
1020       }
1021       break;
1022     }
1023     case LongPixel:
1024     {
1025       register size_t
1026         *q;
1027
1028       q=(size_t *) pixels;
1029       if (LocaleCompare(map,"BGR") == 0)
1030         {
1031           for (y=0; y < (ssize_t) rows; y++)
1032           {
1033             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1034             if (p == (const PixelPacket *) NULL)
1035               break;
1036             for (x=0; x < (ssize_t) columns; x++)
1037             {
1038               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1039               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1040               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1041               p++;
1042             }
1043           }
1044           break;
1045         }
1046       if (LocaleCompare(map,"BGRA") == 0)
1047         {
1048           for (y=0; y < (ssize_t) rows; y++)
1049           {
1050             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1051             if (p == (const PixelPacket *) NULL)
1052               break;
1053             for (x=0; x < (ssize_t) columns; x++)
1054             {
1055               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1056               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1057               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1058               *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1059               p++;
1060             }
1061           }
1062           break;
1063         }
1064       if (LocaleCompare(map,"BGRP") == 0)
1065         {
1066           for (y=0; y < (ssize_t) rows; y++)
1067           {
1068             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1069             if (p == (const PixelPacket *) NULL)
1070               break;
1071             for (x=0; x < (ssize_t) columns; x++)
1072             {
1073               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1074               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1075               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1076               *q++=0;
1077               p++;
1078             }
1079           }
1080           break;
1081         }
1082       if (LocaleCompare(map,"I") == 0)
1083         {
1084           for (y=0; y < (ssize_t) rows; y++)
1085           {
1086             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1087             if (p == (const PixelPacket *) NULL)
1088               break;
1089             for (x=0; x < (ssize_t) columns; x++)
1090             {
1091               *q++=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1092               p++;
1093             }
1094           }
1095           break;
1096         }
1097       if (LocaleCompare(map,"RGB") == 0)
1098         {
1099           for (y=0; y < (ssize_t) rows; y++)
1100           {
1101             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1102             if (p == (const PixelPacket *) NULL)
1103               break;
1104             for (x=0; x < (ssize_t) columns; x++)
1105             {
1106               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1107               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1108               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1109               p++;
1110             }
1111           }
1112           break;
1113         }
1114       if (LocaleCompare(map,"RGBA") == 0)
1115         {
1116           for (y=0; y < (ssize_t) rows; y++)
1117           {
1118             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1119             if (p == (const PixelPacket *) NULL)
1120               break;
1121             for (x=0; x < (ssize_t) columns; x++)
1122             {
1123               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1124               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1125               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1126               *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1127               p++;
1128             }
1129           }
1130           break;
1131         }
1132       if (LocaleCompare(map,"RGBP") == 0)
1133         {
1134           for (y=0; y < (ssize_t) rows; y++)
1135           {
1136             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1137             if (p == (const PixelPacket *) NULL)
1138               break;
1139             for (x=0; x < (ssize_t) columns; x++)
1140             {
1141               *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1142               *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1143               *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1144               *q++=0;
1145               p++;
1146             }
1147           }
1148           break;
1149         }
1150       for (y=0; y < (ssize_t) rows; y++)
1151       {
1152         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1153         if (p == (const PixelPacket *) NULL)
1154           break;
1155         indexes=GetVirtualIndexQueue(image);
1156         for (x=0; x < (ssize_t) columns; x++)
1157         {
1158           for (i=0; i < (ssize_t) length; i++)
1159           {
1160             *q=0;
1161             switch (quantum_map[i])
1162             {
1163               case RedQuantum:
1164               case CyanQuantum:
1165               {
1166                 *q=ScaleQuantumToLong(GetRedPixelComponent(p));
1167                 break;
1168               }
1169               case GreenQuantum:
1170               case MagentaQuantum:
1171               {
1172                 *q=ScaleQuantumToLong(GetGreenPixelComponent(p));
1173                 break;
1174               }
1175               case BlueQuantum:
1176               case YellowQuantum:
1177               {
1178                 *q=ScaleQuantumToLong(GetBluePixelComponent(p));
1179                 break;
1180               }
1181               case AlphaQuantum:
1182               {
1183                 *q=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1184                 break;
1185               }
1186               case OpacityQuantum:
1187               {
1188                 *q=ScaleQuantumToLong(GetOpacityPixelComponent(p));
1189                 break;
1190               }
1191               case BlackQuantum:
1192               {
1193                 if (image->colorspace == CMYKColorspace)
1194                   *q=ScaleQuantumToLong(indexes[x]);
1195                 break;
1196               }
1197               case IndexQuantum:
1198               {
1199                 *q=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1200                 break;
1201               }
1202               default:
1203                 break;
1204             }
1205             q++;
1206           }
1207           p++;
1208         }
1209       }
1210       break;
1211     }
1212     case QuantumPixel:
1213     {
1214       register Quantum
1215         *q;
1216
1217       q=(Quantum *) pixels;
1218       if (LocaleCompare(map,"BGR") == 0)
1219         {
1220           for (y=0; y < (ssize_t) rows; y++)
1221           {
1222             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1223             if (p == (const PixelPacket *) NULL)
1224               break;
1225             for (x=0; x < (ssize_t) columns; x++)
1226             {
1227               *q++=GetBluePixelComponent(p);
1228               *q++=GetGreenPixelComponent(p);
1229               *q++=GetRedPixelComponent(p);
1230               p++;
1231             }
1232           }
1233           break;
1234         }
1235       if (LocaleCompare(map,"BGRA") == 0)
1236         {
1237           for (y=0; y < (ssize_t) rows; y++)
1238           {
1239             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1240             if (p == (const PixelPacket *) NULL)
1241               break;
1242             for (x=0; x < (ssize_t) columns; x++)
1243             {
1244               *q++=GetBluePixelComponent(p);
1245               *q++=GetGreenPixelComponent(p);
1246               *q++=GetRedPixelComponent(p);
1247               *q++=(Quantum) (GetAlphaPixelComponent(p));
1248               p++;
1249             }
1250           }
1251           break;
1252         }
1253       if (LocaleCompare(map,"BGRP") == 0)
1254         {
1255           for (y=0; y < (ssize_t) rows; y++)
1256           {
1257             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1258             if (p == (const PixelPacket *) NULL)
1259               break;
1260             for (x=0; x < (ssize_t) columns; x++)
1261             {
1262               *q++=GetBluePixelComponent(p);
1263               *q++=GetGreenPixelComponent(p);
1264               *q++=GetRedPixelComponent(p);
1265               *q++=(Quantum) 0;
1266               p++;
1267             }
1268           }
1269           break;
1270         }
1271       if (LocaleCompare(map,"I") == 0)
1272         {
1273           for (y=0; y < (ssize_t) rows; y++)
1274           {
1275             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1276             if (p == (const PixelPacket *) NULL)
1277               break;
1278             for (x=0; x < (ssize_t) columns; x++)
1279             {
1280               *q++=PixelIntensityToQuantum(p);
1281               p++;
1282             }
1283           }
1284           break;
1285         }
1286       if (LocaleCompare(map,"RGB") == 0)
1287         {
1288           for (y=0; y < (ssize_t) rows; y++)
1289           {
1290             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1291             if (p == (const PixelPacket *) NULL)
1292               break;
1293             for (x=0; x < (ssize_t) columns; x++)
1294             {
1295               *q++=GetRedPixelComponent(p);
1296               *q++=GetGreenPixelComponent(p);
1297               *q++=GetBluePixelComponent(p);
1298               p++;
1299             }
1300           }
1301           break;
1302         }
1303       if (LocaleCompare(map,"RGBA") == 0)
1304         {
1305           for (y=0; y < (ssize_t) rows; y++)
1306           {
1307             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1308             if (p == (const PixelPacket *) NULL)
1309               break;
1310             for (x=0; x < (ssize_t) columns; x++)
1311             {
1312               *q++=GetRedPixelComponent(p);
1313               *q++=GetGreenPixelComponent(p);
1314               *q++=GetBluePixelComponent(p);
1315               *q++=(Quantum) (GetAlphaPixelComponent(p));
1316               p++;
1317             }
1318           }
1319           break;
1320         }
1321       if (LocaleCompare(map,"RGBP") == 0)
1322         {
1323           for (y=0; y < (ssize_t) rows; y++)
1324           {
1325             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1326             if (p == (const PixelPacket *) NULL)
1327               break;
1328             for (x=0; x < (ssize_t) columns; x++)
1329             {
1330               *q++=GetRedPixelComponent(p);
1331               *q++=GetGreenPixelComponent(p);
1332               *q++=GetBluePixelComponent(p);
1333               *q++=(Quantum) 0;
1334               p++;
1335             }
1336           }
1337           break;
1338         }
1339       for (y=0; y < (ssize_t) rows; y++)
1340       {
1341         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1342         if (p == (const PixelPacket *) NULL)
1343           break;
1344         indexes=GetVirtualIndexQueue(image);
1345         for (x=0; x < (ssize_t) columns; x++)
1346         {
1347           for (i=0; i < (ssize_t) length; i++)
1348           {
1349             *q=(Quantum) 0;
1350             switch (quantum_map[i])
1351             {
1352               case RedQuantum:
1353               case CyanQuantum:
1354               {
1355                 *q=GetRedPixelComponent(p);
1356                 break;
1357               }
1358               case GreenQuantum:
1359               case MagentaQuantum:
1360               {
1361                 *q=GetGreenPixelComponent(p);
1362                 break;
1363               }
1364               case BlueQuantum:
1365               case YellowQuantum:
1366               {
1367                 *q=GetBluePixelComponent(p);
1368                 break;
1369               }
1370               case AlphaQuantum:
1371               {
1372                 *q=(Quantum) (GetAlphaPixelComponent(p));
1373                 break;
1374               }
1375               case OpacityQuantum:
1376               {
1377                 *q=GetOpacityPixelComponent(p);
1378                 break;
1379               }
1380               case BlackQuantum:
1381               {
1382                 if (image->colorspace == CMYKColorspace)
1383                   *q=indexes[x];
1384                 break;
1385               }
1386               case IndexQuantum:
1387               {
1388                 *q=(PixelIntensityToQuantum(p));
1389                 break;
1390               }
1391               default:
1392                 *q=(Quantum) 0;
1393             }
1394             q++;
1395           }
1396           p++;
1397         }
1398       }
1399       break;
1400     }
1401     case ShortPixel:
1402     {
1403       register unsigned short
1404         *q;
1405
1406       q=(unsigned short *) pixels;
1407       if (LocaleCompare(map,"BGR") == 0)
1408         {
1409           for (y=0; y < (ssize_t) rows; y++)
1410           {
1411             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1412             if (p == (const PixelPacket *) NULL)
1413               break;
1414             for (x=0; x < (ssize_t) columns; x++)
1415             {
1416               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1417               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1418               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1419               p++;
1420             }
1421           }
1422           break;
1423         }
1424       if (LocaleCompare(map,"BGRA") == 0)
1425         {
1426           for (y=0; y < (ssize_t) rows; y++)
1427           {
1428             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1429             if (p == (const PixelPacket *) NULL)
1430               break;
1431             for (x=0; x < (ssize_t) columns; x++)
1432             {
1433               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1434               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1435               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1436               *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1437               p++;
1438             }
1439           }
1440           break;
1441         }
1442       if (LocaleCompare(map,"BGRP") == 0)
1443         {
1444           for (y=0; y < (ssize_t) rows; y++)
1445           {
1446             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1447             if (p == (const PixelPacket *) NULL)
1448               break;
1449             for (x=0; x < (ssize_t) columns; x++)
1450             {
1451               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1452               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1453               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1454               *q++=0;
1455               p++;
1456             }
1457           }
1458           break;
1459         }
1460       if (LocaleCompare(map,"I") == 0)
1461         {
1462           for (y=0; y < (ssize_t) rows; y++)
1463           {
1464             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1465             if (p == (const PixelPacket *) NULL)
1466               break;
1467             for (x=0; x < (ssize_t) columns; x++)
1468             {
1469               *q++=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1470               p++;
1471             }
1472           }
1473           break;
1474         }
1475       if (LocaleCompare(map,"RGB") == 0)
1476         {
1477           for (y=0; y < (ssize_t) rows; y++)
1478           {
1479             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1480             if (p == (const PixelPacket *) NULL)
1481               break;
1482             for (x=0; x < (ssize_t) columns; x++)
1483             {
1484               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1485               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1486               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1487               p++;
1488             }
1489           }
1490           break;
1491         }
1492       if (LocaleCompare(map,"RGBA") == 0)
1493         {
1494           for (y=0; y < (ssize_t) rows; y++)
1495           {
1496             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1497             if (p == (const PixelPacket *) NULL)
1498               break;
1499             for (x=0; x < (ssize_t) columns; x++)
1500             {
1501               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1502               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1503               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1504               *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1505               p++;
1506             }
1507           }
1508           break;
1509         }
1510       if (LocaleCompare(map,"RGBP") == 0)
1511         {
1512           for (y=0; y < (ssize_t) rows; y++)
1513           {
1514             p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1515             if (p == (const PixelPacket *) NULL)
1516               break;
1517             for (x=0; x < (ssize_t) columns; x++)
1518             {
1519               *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1520               *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1521               *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1522               *q++=0;
1523               p++;
1524             }
1525           }
1526           break;
1527         }
1528       for (y=0; y < (ssize_t) rows; y++)
1529       {
1530         p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1531         if (p == (const PixelPacket *) NULL)
1532           break;
1533         indexes=GetVirtualIndexQueue(image);
1534         for (x=0; x < (ssize_t) columns; x++)
1535         {
1536           for (i=0; i < (ssize_t) length; i++)
1537           {
1538             *q=0;
1539             switch (quantum_map[i])
1540             {
1541               case RedQuantum:
1542               case CyanQuantum:
1543               {
1544                 *q=ScaleQuantumToShort(GetRedPixelComponent(p));
1545                 break;
1546               }
1547               case GreenQuantum:
1548               case MagentaQuantum:
1549               {
1550                 *q=ScaleQuantumToShort(GetGreenPixelComponent(p));
1551                 break;
1552               }
1553               case BlueQuantum:
1554               case YellowQuantum:
1555               {
1556                 *q=ScaleQuantumToShort(GetBluePixelComponent(p));
1557                 break;
1558               }
1559               case AlphaQuantum:
1560               {
1561                 *q=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1562                 break;
1563               }
1564               case OpacityQuantum:
1565               {
1566                 *q=ScaleQuantumToShort(GetOpacityPixelComponent(p));
1567                 break;
1568               }
1569               case BlackQuantum:
1570               {
1571                 if (image->colorspace == CMYKColorspace)
1572                   *q=ScaleQuantumToShort(indexes[x]);
1573                 break;
1574               }
1575               case IndexQuantum:
1576               {
1577                 *q=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1578                 break;
1579               }
1580               default:
1581                 break;
1582             }
1583             q++;
1584           }
1585           p++;
1586         }
1587       }
1588       break;
1589     }
1590     default:
1591     {
1592       quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1593       (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1594         "UnrecognizedPixelMap","`%s'",map);
1595       break;
1596     }
1597   }
1598   quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1599   return(MagickTrue);
1600 }
1601 \f
1602 /*
1603 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1604 %                                                                             %
1605 %                                                                             %
1606 %                                                                             %
1607 %   G e t M a g i c k P i x e l P a c k e t                                   %
1608 %                                                                             %
1609 %                                                                             %
1610 %                                                                             %
1611 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1612 %
1613 %  GetMagickPixelPacket() initializes the MagickPixelPacket structure.
1614 %
1615 %  The format of the GetMagickPixelPacket method is:
1616 %
1617 %      GetMagickPixelPacket(const Image *image,MagickPixelPacket *pixel)
1618 %
1619 %  A description of each parameter follows:
1620 %
1621 %    o image: the image.
1622 %
1623 %    o pixel: Specifies a pointer to a PixelPacket structure.
1624 %
1625 */
1626 MagickExport void GetMagickPixelPacket(const Image *image,
1627   MagickPixelPacket *pixel)
1628 {
1629   pixel->storage_class=DirectClass;
1630   pixel->colorspace=RGBColorspace;
1631   pixel->matte=MagickFalse;
1632   pixel->fuzz=0.0;
1633   pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
1634   pixel->red=0.0;
1635   pixel->green=0.0;
1636   pixel->blue=0.0;
1637   pixel->opacity=(MagickRealType) OpaqueOpacity;
1638   pixel->index=0.0;
1639   if (image == (const Image *) NULL)
1640     return;
1641   pixel->storage_class=image->storage_class;
1642   pixel->colorspace=image->colorspace;
1643   pixel->matte=image->matte;
1644   pixel->depth=image->depth;
1645   pixel->fuzz=image->fuzz;
1646 }
1647 \f
1648 /*
1649 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1650 %                                                                             %
1651 %                                                                             %
1652 %                                                                             %
1653 %   I m p o r t I m a g e P i x e l s                                         %
1654 %                                                                             %
1655 %                                                                             %
1656 %                                                                             %
1657 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1658 %
1659 %  ImportImagePixels() accepts pixel data and stores in the image at the
1660 %  location you specify.  The method returns MagickTrue on success otherwise
1661 %  MagickFalse if an error is encountered.  The pixel data can be either char,
1662 %  short int, int, ssize_t, float, or double in the order specified by map.
1663 %
1664 %  Suppose your want to upload the first scanline of a 640x480 image from
1665 %  character data in red-green-blue order:
1666 %
1667 %      ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
1668 %
1669 %  The format of the ImportImagePixels method is:
1670 %
1671 %      MagickBooleanType ImportImagePixels(Image *image,const ssize_t x_offset,
1672 %        const ssize_t y_offset,const size_t columns,
1673 %        const size_t rows,const char *map,const StorageType type,
1674 %        const void *pixels)
1675 %
1676 %  A description of each parameter follows:
1677 %
1678 %    o image: the image.
1679 %
1680 %    o x_offset,y_offset,columns,rows:  These values define the perimeter
1681 %      of a region of pixels you want to define.
1682 %
1683 %    o map:  This string reflects the expected ordering of the pixel array.
1684 %      It can be any combination or order of R = red, G = green, B = blue,
1685 %      A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
1686 %      Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
1687 %      P = pad.
1688 %
1689 %    o type: Define the data type of the pixels.  Float and double types are
1690 %      normalized to [0..1] otherwise [0..QuantumRange].  Choose from these
1691 %      types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or
1692 %      DoublePixel.
1693 %
1694 %    o pixels: This array of values contain the pixel components as defined by
1695 %      map and type.  You must preallocate this array where the expected
1696 %      length varies depending on the values of width, height, map, and type.
1697 %
1698 */
1699 MagickExport MagickBooleanType ImportImagePixels(Image *image,
1700   const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
1701   const size_t rows,const char *map,const StorageType type,
1702   const void *pixels)
1703 {
1704   ExceptionInfo
1705     *exception;
1706
1707   PixelPacket
1708     *q;
1709
1710   QuantumType
1711     *quantum_map;
1712
1713   register IndexPacket
1714     *indexes;
1715
1716   register ssize_t
1717     i,
1718     x;
1719
1720   size_t
1721     length;
1722
1723   ssize_t
1724     y;
1725
1726   /*
1727     Allocate image structure.
1728   */
1729   assert(image != (Image *) NULL);
1730   assert(image->signature == MagickSignature);
1731   if (image->debug != MagickFalse)
1732     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1733   length=strlen(map);
1734   quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1735   if (quantum_map == (QuantumType *) NULL)
1736     ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1737       image->filename);
1738   for (i=0; i < (ssize_t) length; i++)
1739   {
1740     switch (map[i])
1741     {
1742       case 'a':
1743       case 'A':
1744       {
1745         quantum_map[i]=AlphaQuantum;
1746         image->matte=MagickTrue;
1747         break;
1748       }
1749       case 'B':
1750       case 'b':
1751       {
1752         quantum_map[i]=BlueQuantum;
1753         break;
1754       }
1755       case 'C':
1756       case 'c':
1757       {
1758         quantum_map[i]=CyanQuantum;
1759         (void) SetImageColorspace(image,CMYKColorspace);
1760         break;
1761       }
1762       case 'g':
1763       case 'G':
1764       {
1765         quantum_map[i]=GreenQuantum;
1766         break;
1767       }
1768       case 'K':
1769       case 'k':
1770       {
1771         quantum_map[i]=BlackQuantum;
1772         (void) SetImageColorspace(image,CMYKColorspace);
1773         break;
1774       }
1775       case 'I':
1776       case 'i':
1777       {
1778         quantum_map[i]=IndexQuantum;
1779         break;
1780       }
1781       case 'm':
1782       case 'M':
1783       {
1784         quantum_map[i]=MagentaQuantum;
1785         (void) SetImageColorspace(image,CMYKColorspace);
1786         break;
1787       }
1788       case 'O':
1789       case 'o':
1790       {
1791         quantum_map[i]=OpacityQuantum;
1792         image->matte=MagickTrue;
1793         break;
1794       }
1795       case 'P':
1796       case 'p':
1797       {
1798         quantum_map[i]=UndefinedQuantum;
1799         break;
1800       }
1801       case 'R':
1802       case 'r':
1803       {
1804         quantum_map[i]=RedQuantum;
1805         break;
1806       }
1807       case 'Y':
1808       case 'y':
1809       {
1810         quantum_map[i]=YellowQuantum;
1811         (void) SetImageColorspace(image,CMYKColorspace);
1812         break;
1813       }
1814       default:
1815       {
1816         quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1817         (void) ThrowMagickException(&image->exception,GetMagickModule(),
1818           OptionError,"UnrecognizedPixelMap","`%s'",map);
1819         return(MagickFalse);
1820       }
1821     }
1822   }
1823   if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1824     return(MagickFalse);
1825   /*
1826     Transfer the pixels from the pixel datarray to the image.
1827   */
1828   exception=(&image->exception);
1829   switch (type)
1830   {
1831     case CharPixel:
1832     {
1833       register const unsigned char
1834         *p;
1835
1836       p=(const unsigned char *) pixels;
1837       if (LocaleCompare(map,"BGR") == 0)
1838         {
1839           for (y=0; y < (ssize_t) rows; y++)
1840           {
1841             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1842             if (q == (PixelPacket *) NULL)
1843               break;
1844             for (x=0; x < (ssize_t) columns; x++)
1845             {
1846               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1847               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1848               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1849               q++;
1850             }
1851             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1852               break;
1853           }
1854           break;
1855         }
1856       if (LocaleCompare(map,"BGRA") == 0)
1857         {
1858           for (y=0; y < (ssize_t) rows; y++)
1859           {
1860             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1861             if (q == (PixelPacket *) NULL)
1862               break;
1863             for (x=0; x < (ssize_t) columns; x++)
1864             {
1865               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1866               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1867               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1868               q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
1869               q++;
1870             }
1871             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1872               break;
1873           }
1874           break;
1875         }
1876       if (LocaleCompare(map,"BGRO") == 0)
1877         {
1878           for (y=0; y < (ssize_t) rows; y++)
1879           {
1880             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1881             if (q == (PixelPacket *) NULL)
1882               break;
1883             for (x=0; x < (ssize_t) columns; x++)
1884             {
1885               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1886               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1887               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1888               SetOpacityPixelComponent(q,ScaleCharToQuantum(*p++));
1889               q++;
1890             }
1891             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1892               break;
1893           }
1894           break;
1895         }
1896       if (LocaleCompare(map,"BGRP") == 0)
1897         {
1898           for (y=0; y < (ssize_t) rows; y++)
1899           {
1900             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1901             if (q == (PixelPacket *) NULL)
1902               break;
1903             for (x=0; x < (ssize_t) columns; x++)
1904             {
1905               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1906               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1907               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1908               p++;
1909               q++;
1910             }
1911             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1912               break;
1913           }
1914           break;
1915         }
1916       if (LocaleCompare(map,"I") == 0)
1917         {
1918           for (y=0; y < (ssize_t) rows; y++)
1919           {
1920             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1921             if (q == (PixelPacket *) NULL)
1922               break;
1923             for (x=0; x < (ssize_t) columns; x++)
1924             {
1925               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1926               SetGreenPixelComponent(q,GetRedPixelComponent(q));
1927               SetBluePixelComponent(q,GetRedPixelComponent(q));
1928               q++;
1929             }
1930             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1931               break;
1932           }
1933           break;
1934         }
1935       if (LocaleCompare(map,"RGB") == 0)
1936         {
1937           for (y=0; y < (ssize_t) rows; y++)
1938           {
1939             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1940             if (q == (PixelPacket *) NULL)
1941               break;
1942             for (x=0; x < (ssize_t) columns; x++)
1943             {
1944               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1945               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1946               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1947               q++;
1948             }
1949             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1950               break;
1951           }
1952           break;
1953         }
1954       if (LocaleCompare(map,"RGBA") == 0)
1955         {
1956           for (y=0; y < (ssize_t) rows; y++)
1957           {
1958             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1959             if (q == (PixelPacket *) NULL)
1960               break;
1961             for (x=0; x < (ssize_t) columns; x++)
1962             {
1963               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1964               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1965               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1966               q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
1967               q++;
1968             }
1969             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1970               break;
1971           }
1972           break;
1973         }
1974       if (LocaleCompare(map,"RGBO") == 0)
1975         {
1976           for (y=0; y < (ssize_t) rows; y++)
1977           {
1978             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1979             if (q == (PixelPacket *) NULL)
1980               break;
1981             for (x=0; x < (ssize_t) columns; x++)
1982             {
1983               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1984               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1985               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1986               SetOpacityPixelComponent(q,ScaleCharToQuantum(*p++));
1987               q++;
1988             }
1989             if (SyncAuthenticPixels(image,exception) == MagickFalse)
1990               break;
1991           }
1992           break;
1993         }
1994       if (LocaleCompare(map,"RGBP") == 0)
1995         {
1996           for (y=0; y < (ssize_t) rows; y++)
1997           {
1998             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1999             if (q == (PixelPacket *) NULL)
2000               break;
2001             for (x=0; x < (ssize_t) columns; x++)
2002             {
2003               SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
2004               SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
2005               SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
2006               p++;
2007               q++;
2008             }
2009             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2010               break;
2011           }
2012           break;
2013         }
2014       for (y=0; y < (ssize_t) rows; y++)
2015       {
2016         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2017         if (q == (PixelPacket *) NULL)
2018           break;
2019         indexes=GetAuthenticIndexQueue(image);
2020         for (x=0; x < (ssize_t) columns; x++)
2021         {
2022           for (i=0; i < (ssize_t) length; i++)
2023           {
2024             switch (quantum_map[i])
2025             {
2026               case RedQuantum:
2027               case CyanQuantum:
2028               {
2029                 SetRedPixelComponent(q,ScaleCharToQuantum(*p));
2030                 break;
2031               }
2032               case GreenQuantum:
2033               case MagentaQuantum:
2034               {
2035                 SetGreenPixelComponent(q,ScaleCharToQuantum(*p));
2036                 break;
2037               }
2038               case BlueQuantum:
2039               case YellowQuantum:
2040               {
2041                 SetBluePixelComponent(q,ScaleCharToQuantum(*p));
2042                 break;
2043               }
2044               case AlphaQuantum:
2045               {
2046                 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
2047                 break;
2048               }
2049               case OpacityQuantum:
2050               {
2051                 SetOpacityPixelComponent(q,ScaleCharToQuantum(*p));
2052                 break;
2053               }
2054               case BlackQuantum:
2055               {
2056                 SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(*p));
2057                 break;
2058               }
2059               case IndexQuantum:
2060               {
2061                 SetRedPixelComponent(q,ScaleCharToQuantum(*p));
2062                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2063                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2064                 break;
2065               }
2066               default:
2067                 break;
2068             }
2069             p++;
2070           }
2071           q++;
2072         }
2073         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2074           break;
2075       }
2076       break;
2077     }
2078     case DoublePixel:
2079     {
2080       register const double
2081         *p;
2082
2083       p=(const double *) pixels;
2084       if (LocaleCompare(map,"BGR") == 0)
2085         {
2086           for (y=0; y < (ssize_t) rows; y++)
2087           {
2088             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2089             if (q == (PixelPacket *) NULL)
2090               break;
2091             for (x=0; x < (ssize_t) columns; x++)
2092             {
2093               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2094                 QuantumRange*(*p)));
2095               p++;
2096               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2097                 QuantumRange*(*p)));
2098               p++;
2099               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2100                 QuantumRange*(*p)));
2101               p++;
2102               q++;
2103             }
2104             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2105               break;
2106           }
2107           break;
2108         }
2109       if (LocaleCompare(map,"BGRA") == 0)
2110         {
2111           for (y=0; y < (ssize_t) rows; y++)
2112           {
2113             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2114             if (q == (PixelPacket *) NULL)
2115               break;
2116             for (x=0; x < (ssize_t) columns; x++)
2117             {
2118               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2119                 QuantumRange*(*p)));
2120               p++;
2121               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2122                 QuantumRange*(*p)));
2123               p++;
2124               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2125                 QuantumRange*(*p)));
2126               p++;
2127               q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2128                 QuantumRange*(*p));
2129               p++;
2130               q++;
2131             }
2132             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2133               break;
2134           }
2135           break;
2136         }
2137       if (LocaleCompare(map,"BGRP") == 0)
2138         {
2139           for (y=0; y < (ssize_t) rows; y++)
2140           {
2141             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2142             if (q == (PixelPacket *) NULL)
2143               break;
2144             for (x=0; x < (ssize_t) columns; x++)
2145             {
2146               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2147                 QuantumRange*(*p)));
2148               p++;
2149               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2150                 QuantumRange*(*p)));
2151               p++;
2152               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2153                 QuantumRange*(*p)));
2154               p++;
2155               p++;
2156               q++;
2157             }
2158             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2159               break;
2160           }
2161           break;
2162         }
2163       if (LocaleCompare(map,"I") == 0)
2164         {
2165           for (y=0; y < (ssize_t) rows; y++)
2166           {
2167             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2168             if (q == (PixelPacket *) NULL)
2169               break;
2170             for (x=0; x < (ssize_t) columns; x++)
2171             {
2172               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2173                 QuantumRange*(*p)));
2174               SetGreenPixelComponent(q,GetRedPixelComponent(q));
2175               SetBluePixelComponent(q,GetRedPixelComponent(q));
2176               p++;
2177               q++;
2178             }
2179             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2180               break;
2181           }
2182           break;
2183         }
2184       if (LocaleCompare(map,"RGB") == 0)
2185         {
2186           for (y=0; y < (ssize_t) rows; y++)
2187           {
2188             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2189             if (q == (PixelPacket *) NULL)
2190               break;
2191             for (x=0; x < (ssize_t) columns; x++)
2192             {
2193               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2194                 QuantumRange*(*p)));
2195               p++;
2196               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2197               p++;
2198               SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2199               p++;
2200               q++;
2201             }
2202             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2203               break;
2204           }
2205           break;
2206         }
2207       if (LocaleCompare(map,"RGBA") == 0)
2208         {
2209           for (y=0; y < (ssize_t) rows; y++)
2210           {
2211             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2212             if (q == (PixelPacket *) NULL)
2213               break;
2214             for (x=0; x < (ssize_t) columns; x++)
2215             {
2216               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2217                 QuantumRange*(*p)));
2218               p++;
2219               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2220                 QuantumRange*(*p)));
2221               p++;
2222               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2223                 QuantumRange*(*p)));
2224               p++;
2225               q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2226                 QuantumRange*(*p));
2227               p++;
2228               q++;
2229             }
2230             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2231               break;
2232           }
2233           break;
2234         }
2235       if (LocaleCompare(map,"RGBP") == 0)
2236         {
2237           for (y=0; y < (ssize_t) rows; y++)
2238           {
2239             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2240             if (q == (PixelPacket *) NULL)
2241               break;
2242             for (x=0; x < (ssize_t) columns; x++)
2243             {
2244               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2245                 QuantumRange*(*p)));
2246               p++;
2247               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2248                 QuantumRange*(*p)));
2249               p++;
2250               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2251                 QuantumRange*(*p)));
2252               p++;
2253               q++;
2254             }
2255             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2256               break;
2257           }
2258           break;
2259         }
2260       for (y=0; y < (ssize_t) rows; y++)
2261       {
2262         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2263         if (q == (PixelPacket *) NULL)
2264           break;
2265         indexes=GetAuthenticIndexQueue(image);
2266         for (x=0; x < (ssize_t) columns; x++)
2267         {
2268           for (i=0; i < (ssize_t) length; i++)
2269           {
2270             switch (quantum_map[i])
2271             {
2272               case RedQuantum:
2273               case CyanQuantum:
2274               {
2275                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2276                   QuantumRange*(*p)));
2277                 break;
2278               }
2279               case GreenQuantum:
2280               case MagentaQuantum:
2281               {
2282                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2283                   QuantumRange*(*p)));
2284                 break;
2285               }
2286               case BlueQuantum:
2287               case YellowQuantum:
2288               {
2289                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2290                   QuantumRange*(*p)));
2291                 break;
2292               }
2293               case AlphaQuantum:
2294               {
2295                 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2296                   (MagickRealType) QuantumRange*(*p));
2297                 break;
2298               }
2299               case OpacityQuantum:
2300               {
2301                 SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
2302                   QuantumRange*(*p)));
2303                 break;
2304               }
2305               case BlackQuantum:
2306               {
2307                 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2308                 break;
2309               }
2310               case IndexQuantum:
2311               {
2312                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2313                   QuantumRange*(*p)));
2314                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2315                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2316                 break;
2317               }
2318               default:
2319                 break;
2320             }
2321             p++;
2322           }
2323           q++;
2324         }
2325         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2326           break;
2327       }
2328       break;
2329     }
2330     case FloatPixel:
2331     {
2332       register const float
2333         *p;
2334
2335       p=(const float *) pixels;
2336       if (LocaleCompare(map,"BGR") == 0)
2337         {
2338           for (y=0; y < (ssize_t) rows; y++)
2339           {
2340             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2341             if (q == (PixelPacket *) NULL)
2342               break;
2343             for (x=0; x < (ssize_t) columns; x++)
2344             {
2345               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2346                 QuantumRange*(*p)));
2347               p++;
2348               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2349                 QuantumRange*(*p)));
2350               p++;
2351               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2352                 QuantumRange*(*p)));
2353               p++;
2354               q++;
2355             }
2356             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2357               break;
2358           }
2359           break;
2360         }
2361       if (LocaleCompare(map,"BGRA") == 0)
2362         {
2363           for (y=0; y < (ssize_t) rows; y++)
2364           {
2365             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2366             if (q == (PixelPacket *) NULL)
2367               break;
2368             for (x=0; x < (ssize_t) columns; x++)
2369             {
2370               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2371                 QuantumRange*(*p)));
2372               p++;
2373               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2374                 QuantumRange*(*p)));
2375               p++;
2376               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2377                 QuantumRange*(*p)));
2378               p++;
2379               q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2380                 QuantumRange*(*p));
2381               p++;
2382               q++;
2383             }
2384             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2385               break;
2386           }
2387           break;
2388         }
2389       if (LocaleCompare(map,"BGRP") == 0)
2390         {
2391           for (y=0; y < (ssize_t) rows; y++)
2392           {
2393             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2394             if (q == (PixelPacket *) NULL)
2395               break;
2396             for (x=0; x < (ssize_t) columns; x++)
2397             {
2398               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2399                 QuantumRange*(*p)));
2400               p++;
2401               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2402                 QuantumRange*(*p)));
2403               p++;
2404               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2405                 QuantumRange*(*p)));
2406               p++;
2407               p++;
2408               q++;
2409             }
2410             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2411               break;
2412           }
2413           break;
2414         }
2415       if (LocaleCompare(map,"I") == 0)
2416         {
2417           for (y=0; y < (ssize_t) rows; y++)
2418           {
2419             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2420             if (q == (PixelPacket *) NULL)
2421               break;
2422             for (x=0; x < (ssize_t) columns; x++)
2423             {
2424               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2425                 QuantumRange*(*p)));
2426               SetGreenPixelComponent(q,GetRedPixelComponent(q));
2427               SetBluePixelComponent(q,GetRedPixelComponent(q));
2428               p++;
2429               q++;
2430             }
2431             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2432               break;
2433           }
2434           break;
2435         }
2436       if (LocaleCompare(map,"RGB") == 0)
2437         {
2438           for (y=0; y < (ssize_t) rows; y++)
2439           {
2440             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2441             if (q == (PixelPacket *) NULL)
2442               break;
2443             for (x=0; x < (ssize_t) columns; x++)
2444             {
2445               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2446                 QuantumRange*(*p)));
2447               p++;
2448               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2449                 QuantumRange*(*p)));
2450               p++;
2451               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2452                 QuantumRange*(*p)));
2453               p++;
2454               q++;
2455             }
2456             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2457               break;
2458           }
2459           break;
2460         }
2461       if (LocaleCompare(map,"RGBA") == 0)
2462         {
2463           for (y=0; y < (ssize_t) rows; y++)
2464           {
2465             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2466             if (q == (PixelPacket *) NULL)
2467               break;
2468             for (x=0; x < (ssize_t) columns; x++)
2469             {
2470               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2471                 QuantumRange*(*p)));
2472               p++;
2473               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2474                 QuantumRange*(*p)));
2475               p++;
2476               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2477                 QuantumRange*(*p)));
2478               p++;
2479               q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2480                 QuantumRange*(*p));
2481               p++;
2482               q++;
2483             }
2484             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2485               break;
2486           }
2487           break;
2488         }
2489       if (LocaleCompare(map,"RGBP") == 0)
2490         {
2491           for (y=0; y < (ssize_t) rows; y++)
2492           {
2493             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2494             if (q == (PixelPacket *) NULL)
2495               break;
2496             for (x=0; x < (ssize_t) columns; x++)
2497             {
2498               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2499                 QuantumRange*(*p)));
2500               p++;
2501               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2502                 QuantumRange*(*p)));
2503               p++;
2504               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2505                 QuantumRange*(*p)));
2506               p++;
2507               q++;
2508             }
2509             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2510               break;
2511           }
2512           break;
2513         }
2514       for (y=0; y < (ssize_t) rows; y++)
2515       {
2516         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2517         if (q == (PixelPacket *) NULL)
2518           break;
2519         indexes=GetAuthenticIndexQueue(image);
2520         for (x=0; x < (ssize_t) columns; x++)
2521         {
2522           for (i=0; i < (ssize_t) length; i++)
2523           {
2524             switch (quantum_map[i])
2525             {
2526               case RedQuantum:
2527               case CyanQuantum:
2528               {
2529                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2530                 QuantumRange*(*p)));
2531                 break;
2532               }
2533               case GreenQuantum:
2534               case MagentaQuantum:
2535               {
2536                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2537                 QuantumRange*(*p)));
2538                 break;
2539               }
2540               case BlueQuantum:
2541               case YellowQuantum:
2542               {
2543                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2544                 QuantumRange*(*p)));
2545                 break;
2546               }
2547               case AlphaQuantum:
2548               {
2549                 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2550                   (MagickRealType) QuantumRange*(*p));
2551                 break;
2552               }
2553               case OpacityQuantum:
2554               {
2555                 SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
2556                 QuantumRange*(*p)));
2557                 break;
2558               }
2559               case BlackQuantum:
2560               {
2561                 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2562                 break;
2563               }
2564               case IndexQuantum:
2565               {
2566                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2567                   QuantumRange*(*p)));
2568                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2569                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2570                 break;
2571               }
2572               default:
2573                 break;
2574             }
2575             p++;
2576           }
2577           q++;
2578         }
2579         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2580           break;
2581       }
2582       break;
2583     }
2584     case IntegerPixel:
2585     {
2586       register const unsigned int
2587         *p;
2588
2589       p=(const unsigned int *) pixels;
2590       if (LocaleCompare(map,"BGR") == 0)
2591         {
2592           for (y=0; y < (ssize_t) rows; y++)
2593           {
2594             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2595             if (q == (PixelPacket *) NULL)
2596               break;
2597             for (x=0; x < (ssize_t) columns; x++)
2598             {
2599               q->blue=ScaleLongToQuantum(*p++);
2600               q->green=ScaleLongToQuantum(*p++);
2601               q->red=ScaleLongToQuantum(*p++);
2602               q++;
2603             }
2604             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2605               break;
2606           }
2607           break;
2608         }
2609       if (LocaleCompare(map,"BGRA") == 0)
2610         {
2611           for (y=0; y < (ssize_t) rows; y++)
2612           {
2613             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2614             if (q == (PixelPacket *) NULL)
2615               break;
2616             for (x=0; x < (ssize_t) columns; x++)
2617             {
2618               q->blue=ScaleLongToQuantum(*p++);
2619               q->green=ScaleLongToQuantum(*p++);
2620               q->red=ScaleLongToQuantum(*p++);
2621               q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2622               q++;
2623             }
2624             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2625               break;
2626           }
2627           break;
2628         }
2629       if (LocaleCompare(map,"BGRP") == 0)
2630         {
2631           for (y=0; y < (ssize_t) rows; y++)
2632           {
2633             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2634             if (q == (PixelPacket *) NULL)
2635               break;
2636             for (x=0; x < (ssize_t) columns; x++)
2637             {
2638               q->blue=ScaleLongToQuantum(*p++);
2639               q->green=ScaleLongToQuantum(*p++);
2640               q->red=ScaleLongToQuantum(*p++);
2641               p++;
2642               q++;
2643             }
2644             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2645               break;
2646           }
2647           break;
2648         }
2649       if (LocaleCompare(map,"I") == 0)
2650         {
2651           for (y=0; y < (ssize_t) rows; y++)
2652           {
2653             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2654             if (q == (PixelPacket *) NULL)
2655               break;
2656             for (x=0; x < (ssize_t) columns; x++)
2657             {
2658               q->red=ScaleLongToQuantum(*p++);
2659               SetGreenPixelComponent(q,GetRedPixelComponent(q));
2660               SetBluePixelComponent(q,GetRedPixelComponent(q));
2661               q++;
2662             }
2663             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2664               break;
2665           }
2666           break;
2667         }
2668       if (LocaleCompare(map,"RGB") == 0)
2669         {
2670           for (y=0; y < (ssize_t) rows; y++)
2671           {
2672             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2673             if (q == (PixelPacket *) NULL)
2674               break;
2675             for (x=0; x < (ssize_t) columns; x++)
2676             {
2677               q->red=ScaleLongToQuantum(*p++);
2678               q->green=ScaleLongToQuantum(*p++);
2679               q->blue=ScaleLongToQuantum(*p++);
2680               q++;
2681             }
2682             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2683               break;
2684           }
2685           break;
2686         }
2687       if (LocaleCompare(map,"RGBA") == 0)
2688         {
2689           for (y=0; y < (ssize_t) rows; y++)
2690           {
2691             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2692             if (q == (PixelPacket *) NULL)
2693               break;
2694             for (x=0; x < (ssize_t) columns; x++)
2695             {
2696               q->red=ScaleLongToQuantum(*p++);
2697               q->green=ScaleLongToQuantum(*p++);
2698               q->blue=ScaleLongToQuantum(*p++);
2699               q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2700               q++;
2701             }
2702             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2703               break;
2704           }
2705           break;
2706         }
2707       if (LocaleCompare(map,"RGBP") == 0)
2708         {
2709           for (y=0; y < (ssize_t) rows; y++)
2710           {
2711             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2712             if (q == (PixelPacket *) NULL)
2713               break;
2714             for (x=0; x < (ssize_t) columns; x++)
2715             {
2716               q->red=ScaleLongToQuantum(*p++);
2717               q->green=ScaleLongToQuantum(*p++);
2718               q->blue=ScaleLongToQuantum(*p++);
2719               p++;
2720               q++;
2721             }
2722             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2723               break;
2724           }
2725           break;
2726         }
2727       for (y=0; y < (ssize_t) rows; y++)
2728       {
2729         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2730         if (q == (PixelPacket *) NULL)
2731           break;
2732         indexes=GetAuthenticIndexQueue(image);
2733         for (x=0; x < (ssize_t) columns; x++)
2734         {
2735           for (i=0; i < (ssize_t) length; i++)
2736           {
2737             switch (quantum_map[i])
2738             {
2739               case RedQuantum:
2740               case CyanQuantum:
2741               {
2742                 q->red=ScaleLongToQuantum(*p);
2743                 break;
2744               }
2745               case GreenQuantum:
2746               case MagentaQuantum:
2747               {
2748                 q->green=ScaleLongToQuantum(*p);
2749                 break;
2750               }
2751               case BlueQuantum:
2752               case YellowQuantum:
2753               {
2754                 q->blue=ScaleLongToQuantum(*p);
2755                 break;
2756               }
2757               case AlphaQuantum:
2758               {
2759                 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2760                 break;
2761               }
2762               case OpacityQuantum:
2763               {
2764                 q->opacity=ScaleLongToQuantum(*p);
2765                 break;
2766               }
2767               case BlackQuantum:
2768               {
2769                 indexes[x]=ScaleLongToQuantum(*p);
2770                 break;
2771               }
2772               case IndexQuantum:
2773               {
2774                 q->red=ScaleLongToQuantum(*p);
2775                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2776                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2777                 break;
2778               }
2779               default:
2780                 break;
2781             }
2782             p++;
2783           }
2784           q++;
2785         }
2786         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2787           break;
2788       }
2789       break;
2790     }
2791     case LongPixel:
2792     {
2793       register const unsigned int
2794         *p;
2795
2796       p=(const unsigned int *) pixels;
2797       if (LocaleCompare(map,"BGR") == 0)
2798         {
2799           for (y=0; y < (ssize_t) rows; y++)
2800           {
2801             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2802             if (q == (PixelPacket *) NULL)
2803               break;
2804             for (x=0; x < (ssize_t) columns; x++)
2805             {
2806               q->blue=ScaleLongToQuantum(*p++);
2807               q->green=ScaleLongToQuantum(*p++);
2808               q->red=ScaleLongToQuantum(*p++);
2809               q++;
2810             }
2811             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2812               break;
2813           }
2814           break;
2815         }
2816       if (LocaleCompare(map,"BGRA") == 0)
2817         {
2818           for (y=0; y < (ssize_t) rows; y++)
2819           {
2820             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2821             if (q == (PixelPacket *) NULL)
2822               break;
2823             for (x=0; x < (ssize_t) columns; x++)
2824             {
2825               q->blue=ScaleLongToQuantum(*p++);
2826               q->green=ScaleLongToQuantum(*p++);
2827               q->red=ScaleLongToQuantum(*p++);
2828               q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2829               q++;
2830             }
2831             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2832               break;
2833           }
2834           break;
2835         }
2836       if (LocaleCompare(map,"BGRP") == 0)
2837         {
2838           for (y=0; y < (ssize_t) rows; y++)
2839           {
2840             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2841             if (q == (PixelPacket *) NULL)
2842               break;
2843             for (x=0; x < (ssize_t) columns; x++)
2844             {
2845               q->blue=ScaleLongToQuantum(*p++);
2846               q->green=ScaleLongToQuantum(*p++);
2847               q->red=ScaleLongToQuantum(*p++);
2848               p++;
2849               q++;
2850             }
2851             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2852               break;
2853           }
2854           break;
2855         }
2856       if (LocaleCompare(map,"I") == 0)
2857         {
2858           for (y=0; y < (ssize_t) rows; y++)
2859           {
2860             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2861             if (q == (PixelPacket *) NULL)
2862               break;
2863             for (x=0; x < (ssize_t) columns; x++)
2864             {
2865               q->red=ScaleLongToQuantum(*p++);
2866               SetGreenPixelComponent(q,GetRedPixelComponent(q));
2867               SetBluePixelComponent(q,GetRedPixelComponent(q));
2868               q++;
2869             }
2870             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2871               break;
2872           }
2873           break;
2874         }
2875       if (LocaleCompare(map,"RGB") == 0)
2876         {
2877           for (y=0; y < (ssize_t) rows; y++)
2878           {
2879             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2880             if (q == (PixelPacket *) NULL)
2881               break;
2882             for (x=0; x < (ssize_t) columns; x++)
2883             {
2884               q->red=ScaleLongToQuantum(*p++);
2885               q->green=ScaleLongToQuantum(*p++);
2886               q->blue=ScaleLongToQuantum(*p++);
2887               q++;
2888             }
2889             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2890               break;
2891           }
2892           break;
2893         }
2894       if (LocaleCompare(map,"RGBA") == 0)
2895         {
2896           for (y=0; y < (ssize_t) rows; y++)
2897           {
2898             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2899             if (q == (PixelPacket *) NULL)
2900               break;
2901             for (x=0; x < (ssize_t) columns; x++)
2902             {
2903               q->red=ScaleLongToQuantum(*p++);
2904               q->green=ScaleLongToQuantum(*p++);
2905               q->blue=ScaleLongToQuantum(*p++);
2906               q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2907               q++;
2908             }
2909             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2910               break;
2911           }
2912           break;
2913         }
2914       if (LocaleCompare(map,"RGBP") == 0)
2915         {
2916           for (y=0; y < (ssize_t) rows; y++)
2917           {
2918             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2919             if (q == (PixelPacket *) NULL)
2920               break;
2921             for (x=0; x < (ssize_t) columns; x++)
2922             {
2923               q->red=ScaleLongToQuantum(*p++);
2924               q->green=ScaleLongToQuantum(*p++);
2925               q->blue=ScaleLongToQuantum(*p++);
2926               p++;
2927               q++;
2928             }
2929             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2930               break;
2931           }
2932           break;
2933         }
2934       for (y=0; y < (ssize_t) rows; y++)
2935       {
2936         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2937         if (q == (PixelPacket *) NULL)
2938           break;
2939         indexes=GetAuthenticIndexQueue(image);
2940         for (x=0; x < (ssize_t) columns; x++)
2941         {
2942           for (i=0; i < (ssize_t) length; i++)
2943           {
2944             switch (quantum_map[i])
2945             {
2946               case RedQuantum:
2947               case CyanQuantum:
2948               {
2949                 q->red=ScaleLongToQuantum(*p);
2950                 break;
2951               }
2952               case GreenQuantum:
2953               case MagentaQuantum:
2954               {
2955                 q->green=ScaleLongToQuantum(*p);
2956                 break;
2957               }
2958               case BlueQuantum:
2959               case YellowQuantum:
2960               {
2961                 q->blue=ScaleLongToQuantum(*p);
2962                 break;
2963               }
2964               case AlphaQuantum:
2965               {
2966                 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2967                 break;
2968               }
2969               case OpacityQuantum:
2970               {
2971                 q->opacity=ScaleLongToQuantum(*p);
2972                 break;
2973               }
2974               case BlackQuantum:
2975               {
2976                 indexes[x]=ScaleLongToQuantum(*p);
2977                 break;
2978               }
2979               case IndexQuantum:
2980               {
2981                 q->red=ScaleLongToQuantum(*p);
2982                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2983                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2984                 break;
2985               }
2986               default:
2987                 break;
2988             }
2989             p++;
2990           }
2991           q++;
2992         }
2993         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2994           break;
2995       }
2996       break;
2997     }
2998     case QuantumPixel:
2999     {
3000       register const Quantum
3001         *p;
3002
3003       p=(const Quantum *) pixels;
3004       if (LocaleCompare(map,"BGR") == 0)
3005         {
3006           for (y=0; y < (ssize_t) rows; y++)
3007           {
3008             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3009             if (q == (PixelPacket *) NULL)
3010               break;
3011             for (x=0; x < (ssize_t) columns; x++)
3012             {
3013               q->blue=(*p++);
3014               q->green=(*p++);
3015               q->red=(*p++);
3016               q++;
3017             }
3018             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3019               break;
3020           }
3021           break;
3022         }
3023       if (LocaleCompare(map,"BGRA") == 0)
3024         {
3025           for (y=0; y < (ssize_t) rows; y++)
3026           {
3027             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3028             if (q == (PixelPacket *) NULL)
3029               break;
3030             for (x=0; x < (ssize_t) columns; x++)
3031             {
3032               q->blue=(*p++);
3033               q->green=(*p++);
3034               q->red=(*p++);
3035               q->opacity=(Quantum) QuantumRange-(*p++);
3036               q++;
3037             }
3038             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3039               break;
3040           }
3041           break;
3042         }
3043       if (LocaleCompare(map,"BGRP") == 0)
3044         {
3045           for (y=0; y < (ssize_t) rows; y++)
3046           {
3047             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3048             if (q == (PixelPacket *) NULL)
3049               break;
3050             for (x=0; x < (ssize_t) columns; x++)
3051             {
3052               q->blue=(*p++);
3053               q->green=(*p++);
3054               q->red=(*p++);
3055               p++;
3056               q++;
3057             }
3058             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3059               break;
3060           }
3061           break;
3062         }
3063       if (LocaleCompare(map,"I") == 0)
3064         {
3065           for (y=0; y < (ssize_t) rows; y++)
3066           {
3067             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3068             if (q == (PixelPacket *) NULL)
3069               break;
3070             for (x=0; x < (ssize_t) columns; x++)
3071             {
3072               q->red=(*p++);
3073               SetGreenPixelComponent(q,GetRedPixelComponent(q));
3074               SetBluePixelComponent(q,GetRedPixelComponent(q));
3075               q++;
3076             }
3077             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3078               break;
3079           }
3080           break;
3081         }
3082       if (LocaleCompare(map,"RGB") == 0)
3083         {
3084           for (y=0; y < (ssize_t) rows; y++)
3085           {
3086             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3087             if (q == (PixelPacket *) NULL)
3088               break;
3089             for (x=0; x < (ssize_t) columns; x++)
3090             {
3091               q->red=(*p++);
3092               q->green=(*p++);
3093               q->blue=(*p++);
3094               q++;
3095             }
3096             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3097               break;
3098           }
3099           break;
3100         }
3101       if (LocaleCompare(map,"RGBA") == 0)
3102         {
3103           for (y=0; y < (ssize_t) rows; y++)
3104           {
3105             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3106             if (q == (PixelPacket *) NULL)
3107               break;
3108             for (x=0; x < (ssize_t) columns; x++)
3109             {
3110               q->red=(*p++);
3111               q->green=(*p++);
3112               q->blue=(*p++);
3113               q->opacity=(Quantum) QuantumRange-(*p++);
3114               q++;
3115             }
3116             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3117               break;
3118           }
3119           break;
3120         }
3121       if (LocaleCompare(map,"RGBP") == 0)
3122         {
3123           for (y=0; y < (ssize_t) rows; y++)
3124           {
3125             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3126             if (q == (PixelPacket *) NULL)
3127               break;
3128             for (x=0; x < (ssize_t) columns; x++)
3129             {
3130               q->red=(*p++);
3131               q->green=(*p++);
3132               q->blue=(*p++);
3133               p++;
3134               q++;
3135             }
3136             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3137               break;
3138           }
3139           break;
3140         }
3141       for (y=0; y < (ssize_t) rows; y++)
3142       {
3143         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3144         if (q == (PixelPacket *) NULL)
3145           break;
3146         indexes=GetAuthenticIndexQueue(image);
3147         for (x=0; x < (ssize_t) columns; x++)
3148         {
3149           for (i=0; i < (ssize_t) length; i++)
3150           {
3151             switch (quantum_map[i])
3152             {
3153               case RedQuantum:
3154               case CyanQuantum:
3155               {
3156                 q->red=(*p);
3157                 break;
3158               }
3159               case GreenQuantum:
3160               case MagentaQuantum:
3161               {
3162                 q->green=(*p);
3163                 break;
3164               }
3165               case BlueQuantum:
3166               case YellowQuantum:
3167               {
3168                 q->blue=(*p);
3169                 break;
3170               }
3171               case AlphaQuantum:
3172               {
3173                 q->opacity=(Quantum) QuantumRange-(*p);
3174                 break;
3175               }
3176               case OpacityQuantum:
3177               {
3178                 q->opacity=(*p);
3179                 break;
3180               }
3181               case BlackQuantum:
3182               {
3183                 indexes[x]=(*p);
3184                 break;
3185               }
3186               case IndexQuantum:
3187               {
3188                 q->red=(*p);
3189                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
3190                 SetBluePixelComponent(q,GetRedPixelComponent(q));
3191                 break;
3192               }
3193               default:
3194                 break;
3195             }
3196             p++;
3197           }
3198           q++;
3199         }
3200         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3201           break;
3202       }
3203       break;
3204     }
3205     case ShortPixel:
3206     {
3207       register const unsigned short
3208         *p;
3209
3210       p=(const unsigned short *) pixels;
3211       if (LocaleCompare(map,"BGR") == 0)
3212         {
3213           for (y=0; y < (ssize_t) rows; y++)
3214           {
3215             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3216             if (q == (PixelPacket *) NULL)
3217               break;
3218             for (x=0; x < (ssize_t) columns; x++)
3219             {
3220               q->blue=ScaleShortToQuantum(*p++);
3221               q->green=ScaleShortToQuantum(*p++);
3222               q->red=ScaleShortToQuantum(*p++);
3223               q++;
3224             }
3225             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3226               break;
3227           }
3228           break;
3229         }
3230       if (LocaleCompare(map,"BGRA") == 0)
3231         {
3232           for (y=0; y < (ssize_t) rows; y++)
3233           {
3234             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3235             if (q == (PixelPacket *) NULL)
3236               break;
3237             for (x=0; x < (ssize_t) columns; x++)
3238             {
3239               q->blue=ScaleShortToQuantum(*p++);
3240               q->green=ScaleShortToQuantum(*p++);
3241               q->red=ScaleShortToQuantum(*p++);
3242               q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3243               q++;
3244             }
3245             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3246               break;
3247           }
3248           break;
3249         }
3250       if (LocaleCompare(map,"BGRP") == 0)
3251         {
3252           for (y=0; y < (ssize_t) rows; y++)
3253           {
3254             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3255             if (q == (PixelPacket *) NULL)
3256               break;
3257             for (x=0; x < (ssize_t) columns; x++)
3258             {
3259               q->blue=ScaleShortToQuantum(*p++);
3260               q->green=ScaleShortToQuantum(*p++);
3261               q->red=ScaleShortToQuantum(*p++);
3262               p++;
3263               q++;
3264             }
3265             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3266               break;
3267           }
3268           break;
3269         }
3270       if (LocaleCompare(map,"I") == 0)
3271         {
3272           for (y=0; y < (ssize_t) rows; y++)
3273           {
3274             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3275             if (q == (PixelPacket *) NULL)
3276               break;
3277             for (x=0; x < (ssize_t) columns; x++)
3278             {
3279               q->red=ScaleShortToQuantum(*p++);
3280               SetGreenPixelComponent(q,GetRedPixelComponent(q));
3281               SetBluePixelComponent(q,GetRedPixelComponent(q));
3282               q++;
3283             }
3284             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3285               break;
3286           }
3287           break;
3288         }
3289       if (LocaleCompare(map,"RGB") == 0)
3290         {
3291           for (y=0; y < (ssize_t) rows; y++)
3292           {
3293             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3294             if (q == (PixelPacket *) NULL)
3295               break;
3296             for (x=0; x < (ssize_t) columns; x++)
3297             {
3298               q->red=ScaleShortToQuantum(*p++);
3299               q->green=ScaleShortToQuantum(*p++);
3300               q->blue=ScaleShortToQuantum(*p++);
3301               q++;
3302             }
3303             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3304               break;
3305           }
3306           break;
3307         }
3308       if (LocaleCompare(map,"RGBA") == 0)
3309         {
3310           for (y=0; y < (ssize_t) rows; y++)
3311           {
3312             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3313             if (q == (PixelPacket *) NULL)
3314               break;
3315             for (x=0; x < (ssize_t) columns; x++)
3316             {
3317               q->red=ScaleShortToQuantum(*p++);
3318               q->green=ScaleShortToQuantum(*p++);
3319               q->blue=ScaleShortToQuantum(*p++);
3320               q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3321               q++;
3322             }
3323             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3324               break;
3325           }
3326           break;
3327         }
3328       if (LocaleCompare(map,"RGBP") == 0)
3329         {
3330           for (y=0; y < (ssize_t) rows; y++)
3331           {
3332             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3333             if (q == (PixelPacket *) NULL)
3334               break;
3335             for (x=0; x < (ssize_t) columns; x++)
3336             {
3337               q->red=ScaleShortToQuantum(*p++);
3338               q->green=ScaleShortToQuantum(*p++);
3339               q->blue=ScaleShortToQuantum(*p++);
3340               p++;
3341               q++;
3342             }
3343             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3344               break;
3345           }
3346           break;
3347         }
3348       for (y=0; y < (ssize_t) rows; y++)
3349       {
3350         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3351         if (q == (PixelPacket *) NULL)
3352           break;
3353         indexes=GetAuthenticIndexQueue(image);
3354         for (x=0; x < (ssize_t) columns; x++)
3355         {
3356           for (i=0; i < (ssize_t) length; i++)
3357           {
3358             switch (quantum_map[i])
3359             {
3360               case RedQuantum:
3361               case CyanQuantum:
3362               {
3363                 q->red=ScaleShortToQuantum(*p);
3364                 break;
3365               }
3366               case GreenQuantum:
3367               case MagentaQuantum:
3368               {
3369                 q->green=ScaleShortToQuantum(*p);
3370                 break;
3371               }
3372               case BlueQuantum:
3373               case YellowQuantum:
3374               {
3375                 q->blue=ScaleShortToQuantum(*p);
3376                 break;
3377               }
3378               case AlphaQuantum:
3379               {
3380                 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
3381                 break;
3382               }
3383               case OpacityQuantum:
3384               {
3385                 q->opacity=ScaleShortToQuantum(*p);
3386                 break;
3387               }
3388               case BlackQuantum:
3389               {
3390                 indexes[x]=ScaleShortToQuantum(*p);
3391                 break;
3392               }
3393               case IndexQuantum:
3394               {
3395                 q->red=ScaleShortToQuantum(*p);
3396                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
3397                 SetBluePixelComponent(q,GetRedPixelComponent(q));
3398                 break;
3399               }
3400               default:
3401                 break;
3402             }
3403             p++;
3404           }
3405           q++;
3406         }
3407         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3408           break;
3409       }
3410       break;
3411     }
3412     default:
3413     {
3414       quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3415       (void) ThrowMagickException(&image->exception,GetMagickModule(),
3416         OptionError,"UnrecognizedPixelMap","`%s'",map);
3417       break;
3418     }
3419   }
3420   quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3421   return(MagickTrue);
3422 }
3423 \f
3424 /*
3425 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3426 %                                                                             %
3427 %                                                                             %
3428 %                                                                             %
3429 %   I n t e r p o l a t e M a g i c k P i x e l P a c k e t                   %
3430 %                                                                             %
3431 %                                                                             %
3432 %                                                                             %
3433 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3434 %
3435 %  InterpolateMagickPixelPacket() applies bi-linear or tri-linear interpolation
3436 %  between a floating point coordinate and the pixels surrounding that
3437 %  coordinate.  No pixel area resampling, or scaling of the result is
3438 %  performed.
3439 %
3440 %  The format of the InterpolateMagickPixelPacket method is:
3441 %
3442 %      MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
3443 %        const CacheView *image_view,const InterpolatePixelMethod method,
3444 %        const double x,const double y,MagickPixelPacket *pixel,
3445 %        ExceptionInfo *exception)
3446 %
3447 %  A description of each parameter follows:
3448 %
3449 %    o image: the image.
3450 %
3451 %    o image_view: the image view.
3452 %
3453 %    o method: the pixel color interpolation method.
3454 %
3455 %    o x,y: A double representing the current (x,y) position of the pixel.
3456 %
3457 %    o pixel: return the interpolated pixel here.
3458 %
3459 %    o exception: return any errors or warnings in this structure.
3460 %
3461 */
3462
3463 static inline void AlphaBlendMagickPixelPacket(const Image *image,
3464   const PixelPacket *color,const IndexPacket *index,MagickPixelPacket *pixel,
3465   MagickRealType *alpha)
3466 {
3467   if (image->matte == MagickFalse)
3468     {
3469       *alpha=1.0;
3470       pixel->red=(MagickRealType) color->red;
3471       pixel->green=(MagickRealType) color->green;
3472       pixel->blue=(MagickRealType) color->blue;
3473       pixel->opacity=(MagickRealType) color->opacity;
3474       pixel->index=0.0;
3475       if (((image->colorspace == CMYKColorspace) ||
3476            (image->storage_class == PseudoClass)) &&
3477           (index != (const IndexPacket *) NULL))
3478         pixel->index=(MagickRealType) *index;
3479       return;
3480     }
3481   *alpha=QuantumScale*GetAlphaPixelComponent(color);
3482   pixel->red=(MagickRealType) (*alpha*color->red);
3483   pixel->green=(MagickRealType) (*alpha*color->green);
3484   pixel->blue=(MagickRealType) (*alpha*color->blue);
3485   pixel->opacity=(MagickRealType) (*alpha*color->opacity);
3486   pixel->index=0.0;
3487   if (((image->colorspace == CMYKColorspace) ||
3488        (image->storage_class == PseudoClass)) &&
3489       (index != (const IndexPacket *) NULL))
3490     pixel->index=(MagickRealType) (*alpha*(*index));
3491 }
3492
3493 static void BicubicInterpolate(const MagickPixelPacket *pixels,const double dx,
3494   MagickPixelPacket *pixel)
3495 {
3496   MagickRealType
3497     dx2,
3498     p,
3499     q,
3500     r,
3501     s;
3502
3503   dx2=dx*dx;
3504   p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
3505   q=(pixels[0].red-pixels[1].red)-p;
3506   r=pixels[2].red-pixels[0].red;
3507   s=pixels[1].red;
3508   pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3509   p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
3510   q=(pixels[0].green-pixels[1].green)-p;
3511   r=pixels[2].green-pixels[0].green;
3512   s=pixels[1].green;
3513   pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3514   p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
3515   q=(pixels[0].blue-pixels[1].blue)-p;
3516   r=pixels[2].blue-pixels[0].blue;
3517   s=pixels[1].blue;
3518   pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3519   p=(pixels[3].opacity-pixels[2].opacity)-(pixels[0].opacity-pixels[1].opacity);
3520   q=(pixels[0].opacity-pixels[1].opacity)-p;
3521   r=pixels[2].opacity-pixels[0].opacity;
3522   s=pixels[1].opacity;
3523   pixel->opacity=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3524   if (pixel->colorspace == CMYKColorspace)
3525     {
3526       p=(pixels[3].index-pixels[2].index)-(pixels[0].index-pixels[1].index);
3527       q=(pixels[0].index-pixels[1].index)-p;
3528       r=pixels[2].index-pixels[0].index;
3529       s=pixels[1].index;
3530       pixel->index=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3531     }
3532 }
3533
3534 static inline double MagickMax(const MagickRealType x,const MagickRealType y)
3535 {
3536   if (x > y)
3537     return(x);
3538   return(y);
3539 }
3540
3541 static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
3542 {
3543   MagickRealType
3544     alpha,
3545     gamma;
3546
3547   alpha=MagickMax(x+2.0,0.0);
3548   gamma=1.0*alpha*alpha*alpha;
3549   alpha=MagickMax(x+1.0,0.0);
3550   gamma-=4.0*alpha*alpha*alpha;
3551   alpha=MagickMax(x+0.0,0.0);
3552   gamma+=6.0*alpha*alpha*alpha;
3553   alpha=MagickMax(x-1.0,0.0);
3554   gamma-=4.0*alpha*alpha*alpha;
3555   return(gamma/6.0);
3556 }
3557
3558 static inline double MeshInterpolate(const PointInfo *delta,const double p,
3559   const double x,const double y)
3560 {
3561   return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3562 }
3563
3564 static inline ssize_t NearestNeighbor(const MagickRealType x)
3565 {
3566   if (x >= 0.0)
3567     return((ssize_t) (x+0.5));
3568   return((ssize_t) (x-0.5));
3569 }
3570
3571 MagickExport MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
3572   const CacheView *image_view,const InterpolatePixelMethod method,
3573   const double x,const double y,MagickPixelPacket *pixel,
3574   ExceptionInfo *exception)
3575 {
3576   MagickBooleanType
3577     status;
3578
3579   MagickPixelPacket
3580     pixels[16];
3581
3582   MagickRealType
3583     alpha[16],
3584     gamma;
3585
3586   register const IndexPacket
3587     *indexes;
3588
3589   register const PixelPacket
3590     *p;
3591
3592   register ssize_t
3593     i;
3594
3595   ssize_t
3596     x_offset,
3597     y_offset;
3598
3599   assert(image != (Image *) NULL);
3600   assert(image->signature == MagickSignature);
3601   assert(image_view != (CacheView *) NULL);
3602   status=MagickTrue;
3603   x_offset=(ssize_t) floor(x);
3604   y_offset=(ssize_t) floor(y);
3605   switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
3606   {
3607     case AverageInterpolatePixel:
3608     {
3609       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3610         exception);
3611       if (p == (const PixelPacket *) NULL)
3612         {
3613           status=MagickFalse;
3614           break;
3615         }
3616       indexes=GetCacheViewVirtualIndexQueue(image_view);
3617       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3618       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3619       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3620       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3621       AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3622       AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3623       AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3624       AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3625       AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3626       AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3627       AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3628       AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3629       AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3630       AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3631       AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3632       AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3633       pixel->red=0.0;
3634       pixel->green=0.0;
3635       pixel->blue=0.0;
3636       pixel->opacity=0.0;
3637       pixel->index=0.0;
3638       for (i=0; i < 16L; i++)
3639       {
3640         gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
3641         pixel->red+=gamma*0.0625*pixels[i].red;
3642         pixel->green+=gamma*0.0625*pixels[i].green;
3643         pixel->blue+=gamma*0.0625*pixels[i].blue;
3644         pixel->opacity+=0.0625*pixels[i].opacity;
3645         if (image->colorspace == CMYKColorspace)
3646           pixel->index+=gamma*0.0625*pixels[i].index;
3647       }
3648       break;
3649     }
3650     case BicubicInterpolatePixel:
3651     {
3652       MagickPixelPacket
3653         u[4];
3654
3655       PointInfo
3656         delta;
3657
3658       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3659         exception);
3660       if (p == (const PixelPacket *) NULL)
3661         {
3662           status=MagickFalse;
3663           break;
3664         }
3665       indexes=GetCacheViewVirtualIndexQueue(image_view);
3666       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3667       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3668       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3669       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3670       AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3671       AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3672       AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3673       AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3674       AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3675       AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3676       AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3677       AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3678       AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3679       AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3680       AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3681       AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3682       delta.x=x-x_offset;
3683       delta.y=y-y_offset;
3684       for (i=0; i < 4L; i++)
3685         BicubicInterpolate(pixels+4*i,delta.x,u+i);
3686       BicubicInterpolate(u,delta.y,pixel);
3687       break;
3688     }
3689     case BilinearInterpolatePixel:
3690     default:
3691     {
3692       PointInfo
3693         delta,
3694         epsilon;
3695
3696       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3697       if (p == (const PixelPacket *) NULL)
3698         {
3699           status=MagickFalse;
3700           break;
3701         }
3702       indexes=GetCacheViewVirtualIndexQueue(image_view);
3703       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3704       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3705       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3706       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3707       delta.x=x-x_offset;
3708       delta.y=y-y_offset;
3709       epsilon.x=1.0-delta.x;
3710       epsilon.y=1.0-delta.y;
3711       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
3712         (epsilon.x*alpha[2]+delta.x*alpha[3])));
3713       gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3714       pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
3715         pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
3716       pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
3717         pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
3718         pixels[3].green));
3719       pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
3720         pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
3721         pixels[3].blue));
3722       pixel->opacity=(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
3723         pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x*
3724         pixels[3].opacity));
3725       if (image->colorspace == CMYKColorspace)
3726         pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
3727           pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x*
3728           pixels[3].index));
3729       break;
3730     }
3731     case FilterInterpolatePixel:
3732     {
3733       CacheView
3734         *filter_view;
3735
3736       Image
3737         *excerpt_image,
3738         *filter_image;
3739
3740       RectangleInfo
3741         geometry;
3742
3743       geometry.width=4L;
3744       geometry.height=4L;
3745       geometry.x=x_offset-1;
3746       geometry.y=y_offset-1;
3747       excerpt_image=ExcerptImage(image,&geometry,exception);
3748       if (excerpt_image == (Image *) NULL)
3749         {
3750           status=MagickFalse;
3751           break;
3752         }
3753       filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
3754         exception);
3755       excerpt_image=DestroyImage(excerpt_image);
3756       if (filter_image == (Image *) NULL)
3757         break;
3758       filter_view=AcquireCacheView(filter_image);
3759       p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
3760       if (p != (const PixelPacket *) NULL)
3761         {
3762           indexes=GetVirtualIndexQueue(filter_image);
3763           SetMagickPixelPacket(image,p,indexes,pixel);
3764         }
3765       filter_view=DestroyCacheView(filter_view);
3766       filter_image=DestroyImage(filter_image);
3767       break;
3768     }
3769     case IntegerInterpolatePixel:
3770     {
3771       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
3772       if (p == (const PixelPacket *) NULL)
3773         {
3774           status=MagickFalse;
3775           break;
3776         }
3777       indexes=GetCacheViewVirtualIndexQueue(image_view);
3778       SetMagickPixelPacket(image,p,indexes,pixel);
3779       break;
3780     }
3781     case MeshInterpolatePixel:
3782     {
3783       PointInfo
3784         delta,
3785         luminance;
3786
3787       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
3788         exception);
3789       if (p == (const PixelPacket *) NULL)
3790         {
3791           status=MagickFalse;
3792           break;
3793         }
3794       indexes=GetCacheViewVirtualIndexQueue(image_view);
3795       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3796       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3797       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3798       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3799       delta.x=x-x_offset;
3800       delta.y=y-y_offset;
3801       luminance.x=MagickPixelLuminance(pixels+0)-MagickPixelLuminance(pixels+3);
3802       luminance.y=MagickPixelLuminance(pixels+1)-MagickPixelLuminance(pixels+2);
3803       if (fabs(luminance.x) < fabs(luminance.y))
3804         {
3805           /*
3806             Diagonal 0-3 NW-SE.
3807           */
3808           if (delta.x <= delta.y)
3809             {
3810               /*
3811                 Bottom-left triangle  (pixel:2, diagonal: 0-3).
3812               */
3813               delta.y=1.0-delta.y;
3814               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
3815               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3816               pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
3817                 pixels[3].red,pixels[0].red);
3818               pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
3819                 pixels[3].green,pixels[0].green);
3820               pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
3821                 pixels[3].blue,pixels[0].blue);
3822               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
3823                 pixels[3].opacity,pixels[0].opacity);
3824               if (image->colorspace == CMYKColorspace)
3825                 pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
3826                   pixels[3].index,pixels[0].index);
3827             }
3828           else
3829             {
3830               /*
3831                 Top-right triangle (pixel:1, diagonal: 0-3).
3832               */
3833               delta.x=1.0-delta.x;
3834               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
3835               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3836               pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
3837                 pixels[0].red,pixels[3].red);
3838               pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
3839                 pixels[0].green,pixels[3].green);
3840               pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
3841                 pixels[0].blue,pixels[3].blue);
3842               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
3843                 pixels[0].opacity,pixels[3].opacity);
3844               if (image->colorspace == CMYKColorspace)
3845                 pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
3846                   pixels[0].index,pixels[3].index);
3847             }
3848         }
3849       else
3850         {
3851           /*
3852             Diagonal 1-2 NE-SW.
3853           */
3854           if (delta.x <= (1.0-delta.y))
3855             {
3856               /*
3857                 Top-left triangle (pixel 0, diagonal: 1-2).
3858               */
3859               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
3860               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3861               pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
3862                 pixels[1].red,pixels[2].red);
3863               pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
3864                 pixels[1].green,pixels[2].green);
3865               pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
3866                 pixels[1].blue,pixels[2].blue);
3867               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
3868                 pixels[1].opacity,pixels[2].opacity);
3869               if (image->colorspace == CMYKColorspace)
3870                 pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
3871                   pixels[1].index,pixels[2].index);
3872             }
3873           else
3874             {
3875               /*
3876                 Bottom-right triangle (pixel: 3, diagonal: 1-2).
3877               */
3878               delta.x=1.0-delta.x;
3879               delta.y=1.0-delta.y;
3880               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
3881               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3882               pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
3883                 pixels[2].red,pixels[1].red);
3884               pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
3885                 pixels[2].green,pixels[1].green);
3886               pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
3887                 pixels[2].blue,pixels[1].blue);
3888               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
3889                 pixels[2].opacity,pixels[1].opacity);
3890               if (image->colorspace == CMYKColorspace)
3891                 pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
3892                   pixels[2].index,pixels[1].index);
3893             }
3894         }
3895       break;
3896     }
3897     case NearestNeighborInterpolatePixel:
3898     {
3899       p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
3900         NearestNeighbor(y),1,1,exception);
3901       if (p == (const PixelPacket *) NULL)
3902         {
3903           status=MagickFalse;
3904           break;
3905         }
3906       indexes=GetCacheViewVirtualIndexQueue(image_view);
3907       SetMagickPixelPacket(image,p,indexes,pixel);
3908       break;
3909     }
3910     case SplineInterpolatePixel:
3911     {
3912       MagickRealType
3913         dx,
3914         dy;
3915
3916       PointInfo
3917         delta;
3918
3919       ssize_t
3920         j,
3921         n;
3922
3923       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3924         exception);
3925       if (p == (const PixelPacket *) NULL)
3926         {
3927           status=MagickFalse;
3928           break;
3929         }
3930       indexes=GetCacheViewVirtualIndexQueue(image_view);
3931       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3932       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3933       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3934       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3935       AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3936       AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3937       AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3938       AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3939       AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3940       AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3941       AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3942       AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3943       AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3944       AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3945       AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3946       AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3947       pixel->red=0.0;
3948       pixel->green=0.0;
3949       pixel->blue=0.0;
3950       pixel->opacity=0.0;
3951       pixel->index=0.0;
3952       delta.x=x-x_offset;
3953       delta.y=y-y_offset;
3954       n=0;
3955       for (i=(-1); i < 3L; i++)
3956       {
3957         dy=CubicWeightingFunction((MagickRealType) i-delta.y);
3958         for (j=(-1); j < 3L; j++)
3959         {
3960           dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
3961           gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
3962           pixel->red+=gamma*dx*dy*pixels[n].red;
3963           pixel->green+=gamma*dx*dy*pixels[n].green;
3964           pixel->blue+=gamma*dx*dy*pixels[n].blue;
3965           pixel->opacity+=dx*dy*pixels[n].opacity;
3966           if (image->colorspace == CMYKColorspace)
3967             pixel->index+=gamma*dx*dy*pixels[n].index;
3968           n++;
3969         }
3970       }
3971       break;
3972     }
3973   }
3974   return(status);
3975 }