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(GetIndexPixelComponent(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*GetIndexPixelComponent(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*GetIndexPixelComponent(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(GetIndexPixelComponent(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(GetIndexPixelComponent(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=GetIndexPixelComponent(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(GetIndexPixelComponent(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               SetAlphaPixelComponent(q,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               SetAlphaPixelComponent(q,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                 SetAlphaPixelComponent(q,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               SetAlphaPixelComponent(q,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                 SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
2296                   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                 SetIndexPixelComponent(indexes+x,ClampToQuantum(
2308                   (MagickRealType) QuantumRange*(*p)));
2309                 break;
2310               }
2311               case IndexQuantum:
2312               {
2313                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2314                   QuantumRange*(*p)));
2315                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2316                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2317                 break;
2318               }
2319               default:
2320                 break;
2321             }
2322             p++;
2323           }
2324           q++;
2325         }
2326         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2327           break;
2328       }
2329       break;
2330     }
2331     case FloatPixel:
2332     {
2333       register const float
2334         *p;
2335
2336       p=(const float *) pixels;
2337       if (LocaleCompare(map,"BGR") == 0)
2338         {
2339           for (y=0; y < (ssize_t) rows; y++)
2340           {
2341             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2342             if (q == (PixelPacket *) NULL)
2343               break;
2344             for (x=0; x < (ssize_t) columns; x++)
2345             {
2346               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2347                 QuantumRange*(*p)));
2348               p++;
2349               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2350                 QuantumRange*(*p)));
2351               p++;
2352               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2353                 QuantumRange*(*p)));
2354               p++;
2355               q++;
2356             }
2357             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2358               break;
2359           }
2360           break;
2361         }
2362       if (LocaleCompare(map,"BGRA") == 0)
2363         {
2364           for (y=0; y < (ssize_t) rows; y++)
2365           {
2366             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2367             if (q == (PixelPacket *) NULL)
2368               break;
2369             for (x=0; x < (ssize_t) columns; x++)
2370             {
2371               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2372                 QuantumRange*(*p)));
2373               p++;
2374               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2375                 QuantumRange*(*p)));
2376               p++;
2377               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2378                 QuantumRange*(*p)));
2379               p++;
2380               SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
2381                 QuantumRange*(*p)));
2382               p++;
2383               q++;
2384             }
2385             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2386               break;
2387           }
2388           break;
2389         }
2390       if (LocaleCompare(map,"BGRP") == 0)
2391         {
2392           for (y=0; y < (ssize_t) rows; y++)
2393           {
2394             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2395             if (q == (PixelPacket *) NULL)
2396               break;
2397             for (x=0; x < (ssize_t) columns; x++)
2398             {
2399               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2400                 QuantumRange*(*p)));
2401               p++;
2402               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2403                 QuantumRange*(*p)));
2404               p++;
2405               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2406                 QuantumRange*(*p)));
2407               p++;
2408               p++;
2409               q++;
2410             }
2411             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2412               break;
2413           }
2414           break;
2415         }
2416       if (LocaleCompare(map,"I") == 0)
2417         {
2418           for (y=0; y < (ssize_t) rows; y++)
2419           {
2420             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2421             if (q == (PixelPacket *) NULL)
2422               break;
2423             for (x=0; x < (ssize_t) columns; x++)
2424             {
2425               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2426                 QuantumRange*(*p)));
2427               SetGreenPixelComponent(q,GetRedPixelComponent(q));
2428               SetBluePixelComponent(q,GetRedPixelComponent(q));
2429               p++;
2430               q++;
2431             }
2432             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2433               break;
2434           }
2435           break;
2436         }
2437       if (LocaleCompare(map,"RGB") == 0)
2438         {
2439           for (y=0; y < (ssize_t) rows; y++)
2440           {
2441             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2442             if (q == (PixelPacket *) NULL)
2443               break;
2444             for (x=0; x < (ssize_t) columns; x++)
2445             {
2446               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2447                 QuantumRange*(*p)));
2448               p++;
2449               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2450                 QuantumRange*(*p)));
2451               p++;
2452               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2453                 QuantumRange*(*p)));
2454               p++;
2455               q++;
2456             }
2457             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2458               break;
2459           }
2460           break;
2461         }
2462       if (LocaleCompare(map,"RGBA") == 0)
2463         {
2464           for (y=0; y < (ssize_t) rows; y++)
2465           {
2466             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2467             if (q == (PixelPacket *) NULL)
2468               break;
2469             for (x=0; x < (ssize_t) columns; x++)
2470             {
2471               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2472                 QuantumRange*(*p)));
2473               p++;
2474               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2475                 QuantumRange*(*p)));
2476               p++;
2477               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2478                 QuantumRange*(*p)));
2479               p++;
2480               SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
2481                 QuantumRange*(*p)));
2482               p++;
2483               q++;
2484             }
2485             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2486               break;
2487           }
2488           break;
2489         }
2490       if (LocaleCompare(map,"RGBP") == 0)
2491         {
2492           for (y=0; y < (ssize_t) rows; y++)
2493           {
2494             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2495             if (q == (PixelPacket *) NULL)
2496               break;
2497             for (x=0; x < (ssize_t) columns; x++)
2498             {
2499               SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2500                 QuantumRange*(*p)));
2501               p++;
2502               SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2503                 QuantumRange*(*p)));
2504               p++;
2505               SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2506                 QuantumRange*(*p)));
2507               p++;
2508               q++;
2509             }
2510             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2511               break;
2512           }
2513           break;
2514         }
2515       for (y=0; y < (ssize_t) rows; y++)
2516       {
2517         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2518         if (q == (PixelPacket *) NULL)
2519           break;
2520         indexes=GetAuthenticIndexQueue(image);
2521         for (x=0; x < (ssize_t) columns; x++)
2522         {
2523           for (i=0; i < (ssize_t) length; i++)
2524           {
2525             switch (quantum_map[i])
2526             {
2527               case RedQuantum:
2528               case CyanQuantum:
2529               {
2530                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2531                 QuantumRange*(*p)));
2532                 break;
2533               }
2534               case GreenQuantum:
2535               case MagentaQuantum:
2536               {
2537                 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2538                 QuantumRange*(*p)));
2539                 break;
2540               }
2541               case BlueQuantum:
2542               case YellowQuantum:
2543               {
2544                 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2545                 QuantumRange*(*p)));
2546                 break;
2547               }
2548               case AlphaQuantum:
2549               {
2550                 SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
2551                   QuantumRange*(*p)));
2552                 break;
2553               }
2554               case OpacityQuantum:
2555               {
2556                 SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
2557                   QuantumRange*(*p)));
2558                 break;
2559               }
2560               case BlackQuantum:
2561               {
2562                 SetIndexPixelComponent(indexes+x,ClampToQuantum(
2563                   (MagickRealType) QuantumRange*(*p)));
2564                 break;
2565               }
2566               case IndexQuantum:
2567               {
2568                 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2569                   QuantumRange*(*p)));
2570                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2571                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2572                 break;
2573               }
2574               default:
2575                 break;
2576             }
2577             p++;
2578           }
2579           q++;
2580         }
2581         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2582           break;
2583       }
2584       break;
2585     }
2586     case IntegerPixel:
2587     {
2588       register const unsigned int
2589         *p;
2590
2591       p=(const unsigned int *) pixels;
2592       if (LocaleCompare(map,"BGR") == 0)
2593         {
2594           for (y=0; y < (ssize_t) rows; y++)
2595           {
2596             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2597             if (q == (PixelPacket *) NULL)
2598               break;
2599             for (x=0; x < (ssize_t) columns; x++)
2600             {
2601               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2602               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2603               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2604               q++;
2605             }
2606             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2607               break;
2608           }
2609           break;
2610         }
2611       if (LocaleCompare(map,"BGRA") == 0)
2612         {
2613           for (y=0; y < (ssize_t) rows; y++)
2614           {
2615             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2616             if (q == (PixelPacket *) NULL)
2617               break;
2618             for (x=0; x < (ssize_t) columns; x++)
2619             {
2620               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2621               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2622               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2623               SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
2624               q++;
2625             }
2626             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2627               break;
2628           }
2629           break;
2630         }
2631       if (LocaleCompare(map,"BGRP") == 0)
2632         {
2633           for (y=0; y < (ssize_t) rows; y++)
2634           {
2635             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2636             if (q == (PixelPacket *) NULL)
2637               break;
2638             for (x=0; x < (ssize_t) columns; x++)
2639             {
2640               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2641               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2642               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2643               p++;
2644               q++;
2645             }
2646             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2647               break;
2648           }
2649           break;
2650         }
2651       if (LocaleCompare(map,"I") == 0)
2652         {
2653           for (y=0; y < (ssize_t) rows; y++)
2654           {
2655             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2656             if (q == (PixelPacket *) NULL)
2657               break;
2658             for (x=0; x < (ssize_t) columns; x++)
2659             {
2660               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2661               SetGreenPixelComponent(q,GetRedPixelComponent(q));
2662               SetBluePixelComponent(q,GetRedPixelComponent(q));
2663               q++;
2664             }
2665             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2666               break;
2667           }
2668           break;
2669         }
2670       if (LocaleCompare(map,"RGB") == 0)
2671         {
2672           for (y=0; y < (ssize_t) rows; y++)
2673           {
2674             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2675             if (q == (PixelPacket *) NULL)
2676               break;
2677             for (x=0; x < (ssize_t) columns; x++)
2678             {
2679               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2680               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2681               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2682               q++;
2683             }
2684             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2685               break;
2686           }
2687           break;
2688         }
2689       if (LocaleCompare(map,"RGBA") == 0)
2690         {
2691           for (y=0; y < (ssize_t) rows; y++)
2692           {
2693             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2694             if (q == (PixelPacket *) NULL)
2695               break;
2696             for (x=0; x < (ssize_t) columns; x++)
2697             {
2698               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2699               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2700               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2701               SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
2702               q++;
2703             }
2704             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2705               break;
2706           }
2707           break;
2708         }
2709       if (LocaleCompare(map,"RGBP") == 0)
2710         {
2711           for (y=0; y < (ssize_t) rows; y++)
2712           {
2713             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2714             if (q == (PixelPacket *) NULL)
2715               break;
2716             for (x=0; x < (ssize_t) columns; x++)
2717             {
2718               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2719               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2720               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2721               p++;
2722               q++;
2723             }
2724             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2725               break;
2726           }
2727           break;
2728         }
2729       for (y=0; y < (ssize_t) rows; y++)
2730       {
2731         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2732         if (q == (PixelPacket *) NULL)
2733           break;
2734         indexes=GetAuthenticIndexQueue(image);
2735         for (x=0; x < (ssize_t) columns; x++)
2736         {
2737           for (i=0; i < (ssize_t) length; i++)
2738           {
2739             switch (quantum_map[i])
2740             {
2741               case RedQuantum:
2742               case CyanQuantum:
2743               {
2744                 SetRedPixelComponent(q,ScaleLongToQuantum(*p));
2745                 break;
2746               }
2747               case GreenQuantum:
2748               case MagentaQuantum:
2749               {
2750                 SetGreenPixelComponent(q,ScaleLongToQuantum(*p));
2751                 break;
2752               }
2753               case BlueQuantum:
2754               case YellowQuantum:
2755               {
2756                 SetBluePixelComponent(q,ScaleLongToQuantum(*p));
2757                 break;
2758               }
2759               case AlphaQuantum:
2760               {
2761                 SetAlphaPixelComponent(q,ScaleLongToQuantum(*p));
2762                 break;
2763               }
2764               case OpacityQuantum:
2765               {
2766                 SetOpacityPixelComponent(q,ScaleLongToQuantum(*p));
2767                 break;
2768               }
2769               case BlackQuantum:
2770               {
2771                 SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p));
2772                 break;
2773               }
2774               case IndexQuantum:
2775               {
2776                 SetRedPixelComponent(q,ScaleLongToQuantum(*p));
2777                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2778                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2779                 break;
2780               }
2781               default:
2782                 break;
2783             }
2784             p++;
2785           }
2786           q++;
2787         }
2788         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2789           break;
2790       }
2791       break;
2792     }
2793     case LongPixel:
2794     {
2795       register const unsigned int
2796         *p;
2797
2798       p=(const unsigned int *) pixels;
2799       if (LocaleCompare(map,"BGR") == 0)
2800         {
2801           for (y=0; y < (ssize_t) rows; y++)
2802           {
2803             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2804             if (q == (PixelPacket *) NULL)
2805               break;
2806             for (x=0; x < (ssize_t) columns; x++)
2807             {
2808               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2809               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2810               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2811               q++;
2812             }
2813             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2814               break;
2815           }
2816           break;
2817         }
2818       if (LocaleCompare(map,"BGRA") == 0)
2819         {
2820           for (y=0; y < (ssize_t) rows; y++)
2821           {
2822             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2823             if (q == (PixelPacket *) NULL)
2824               break;
2825             for (x=0; x < (ssize_t) columns; x++)
2826             {
2827               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2828               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2829               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2830               SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
2831               q++;
2832             }
2833             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2834               break;
2835           }
2836           break;
2837         }
2838       if (LocaleCompare(map,"BGRP") == 0)
2839         {
2840           for (y=0; y < (ssize_t) rows; y++)
2841           {
2842             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2843             if (q == (PixelPacket *) NULL)
2844               break;
2845             for (x=0; x < (ssize_t) columns; x++)
2846             {
2847               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2848               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2849               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2850               p++;
2851               q++;
2852             }
2853             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2854               break;
2855           }
2856           break;
2857         }
2858       if (LocaleCompare(map,"I") == 0)
2859         {
2860           for (y=0; y < (ssize_t) rows; y++)
2861           {
2862             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2863             if (q == (PixelPacket *) NULL)
2864               break;
2865             for (x=0; x < (ssize_t) columns; x++)
2866             {
2867               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2868               SetGreenPixelComponent(q,GetRedPixelComponent(q));
2869               SetBluePixelComponent(q,GetRedPixelComponent(q));
2870               q++;
2871             }
2872             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2873               break;
2874           }
2875           break;
2876         }
2877       if (LocaleCompare(map,"RGB") == 0)
2878         {
2879           for (y=0; y < (ssize_t) rows; y++)
2880           {
2881             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2882             if (q == (PixelPacket *) NULL)
2883               break;
2884             for (x=0; x < (ssize_t) columns; x++)
2885             {
2886               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2887               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2888               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2889               q++;
2890             }
2891             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2892               break;
2893           }
2894           break;
2895         }
2896       if (LocaleCompare(map,"RGBA") == 0)
2897         {
2898           for (y=0; y < (ssize_t) rows; y++)
2899           {
2900             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2901             if (q == (PixelPacket *) NULL)
2902               break;
2903             for (x=0; x < (ssize_t) columns; x++)
2904             {
2905               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2906               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2907               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2908               SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
2909               q++;
2910             }
2911             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2912               break;
2913           }
2914           break;
2915         }
2916       if (LocaleCompare(map,"RGBP") == 0)
2917         {
2918           for (y=0; y < (ssize_t) rows; y++)
2919           {
2920             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2921             if (q == (PixelPacket *) NULL)
2922               break;
2923             for (x=0; x < (ssize_t) columns; x++)
2924             {
2925               SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
2926               SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
2927               SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
2928               p++;
2929               q++;
2930             }
2931             if (SyncAuthenticPixels(image,exception) == MagickFalse)
2932               break;
2933           }
2934           break;
2935         }
2936       for (y=0; y < (ssize_t) rows; y++)
2937       {
2938         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2939         if (q == (PixelPacket *) NULL)
2940           break;
2941         indexes=GetAuthenticIndexQueue(image);
2942         for (x=0; x < (ssize_t) columns; x++)
2943         {
2944           for (i=0; i < (ssize_t) length; i++)
2945           {
2946             switch (quantum_map[i])
2947             {
2948               case RedQuantum:
2949               case CyanQuantum:
2950               {
2951                 SetRedPixelComponent(q,ScaleLongToQuantum(*p));
2952                 break;
2953               }
2954               case GreenQuantum:
2955               case MagentaQuantum:
2956               {
2957                 SetGreenPixelComponent(q,ScaleLongToQuantum(*p));
2958                 break;
2959               }
2960               case BlueQuantum:
2961               case YellowQuantum:
2962               {
2963                 SetBluePixelComponent(q,ScaleLongToQuantum(*p));
2964                 break;
2965               }
2966               case AlphaQuantum:
2967               {
2968                 SetAlphaPixelComponent(q,ScaleLongToQuantum(*p));
2969                 break;
2970               }
2971               case OpacityQuantum:
2972               {
2973                 SetOpacityPixelComponent(q,ScaleLongToQuantum(*p));
2974                 break;
2975               }
2976               case BlackQuantum:
2977               {
2978                 SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p));
2979                 break;
2980               }
2981               case IndexQuantum:
2982               {
2983                 SetRedPixelComponent(q,ScaleLongToQuantum(*p));
2984                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2985                 SetBluePixelComponent(q,GetRedPixelComponent(q));
2986                 break;
2987               }
2988               default:
2989                 break;
2990             }
2991             p++;
2992           }
2993           q++;
2994         }
2995         if (SyncAuthenticPixels(image,exception) == MagickFalse)
2996           break;
2997       }
2998       break;
2999     }
3000     case QuantumPixel:
3001     {
3002       register const Quantum
3003         *p;
3004
3005       p=(const Quantum *) pixels;
3006       if (LocaleCompare(map,"BGR") == 0)
3007         {
3008           for (y=0; y < (ssize_t) rows; y++)
3009           {
3010             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3011             if (q == (PixelPacket *) NULL)
3012               break;
3013             for (x=0; x < (ssize_t) columns; x++)
3014             {
3015               SetBluePixelComponent(q,*p++);
3016               SetGreenPixelComponent(q,*p++);
3017               SetRedPixelComponent(q,*p++);
3018               q++;
3019             }
3020             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3021               break;
3022           }
3023           break;
3024         }
3025       if (LocaleCompare(map,"BGRA") == 0)
3026         {
3027           for (y=0; y < (ssize_t) rows; y++)
3028           {
3029             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3030             if (q == (PixelPacket *) NULL)
3031               break;
3032             for (x=0; x < (ssize_t) columns; x++)
3033             {
3034               SetBluePixelComponent(q,*p++);
3035               SetGreenPixelComponent(q,*p++);
3036               SetRedPixelComponent(q,*p++);
3037               SetAlphaPixelComponent(q,*p++);
3038               q++;
3039             }
3040             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3041               break;
3042           }
3043           break;
3044         }
3045       if (LocaleCompare(map,"BGRP") == 0)
3046         {
3047           for (y=0; y < (ssize_t) rows; y++)
3048           {
3049             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3050             if (q == (PixelPacket *) NULL)
3051               break;
3052             for (x=0; x < (ssize_t) columns; x++)
3053             {
3054               SetBluePixelComponent(q,*p++);
3055               SetGreenPixelComponent(q,*p++);
3056               SetRedPixelComponent(q,*p++);
3057               p++;
3058               q++;
3059             }
3060             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3061               break;
3062           }
3063           break;
3064         }
3065       if (LocaleCompare(map,"I") == 0)
3066         {
3067           for (y=0; y < (ssize_t) rows; y++)
3068           {
3069             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3070             if (q == (PixelPacket *) NULL)
3071               break;
3072             for (x=0; x < (ssize_t) columns; x++)
3073             {
3074               SetRedPixelComponent(q,*p++);
3075               SetGreenPixelComponent(q,GetRedPixelComponent(q));
3076               SetBluePixelComponent(q,GetRedPixelComponent(q));
3077               q++;
3078             }
3079             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3080               break;
3081           }
3082           break;
3083         }
3084       if (LocaleCompare(map,"RGB") == 0)
3085         {
3086           for (y=0; y < (ssize_t) rows; y++)
3087           {
3088             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3089             if (q == (PixelPacket *) NULL)
3090               break;
3091             for (x=0; x < (ssize_t) columns; x++)
3092             {
3093               SetRedPixelComponent(q,*p++);
3094               SetGreenPixelComponent(q,*p++);
3095               SetBluePixelComponent(q,*p++);
3096               q++;
3097             }
3098             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3099               break;
3100           }
3101           break;
3102         }
3103       if (LocaleCompare(map,"RGBA") == 0)
3104         {
3105           for (y=0; y < (ssize_t) rows; y++)
3106           {
3107             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3108             if (q == (PixelPacket *) NULL)
3109               break;
3110             for (x=0; x < (ssize_t) columns; x++)
3111             {
3112               SetRedPixelComponent(q,*p++);
3113               SetGreenPixelComponent(q,*p++);
3114               SetBluePixelComponent(q,*p++);
3115               SetAlphaPixelComponent(q,*p++);
3116               q++;
3117             }
3118             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3119               break;
3120           }
3121           break;
3122         }
3123       if (LocaleCompare(map,"RGBP") == 0)
3124         {
3125           for (y=0; y < (ssize_t) rows; y++)
3126           {
3127             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3128             if (q == (PixelPacket *) NULL)
3129               break;
3130             for (x=0; x < (ssize_t) columns; x++)
3131             {
3132               SetRedPixelComponent(q,*p++);
3133               SetGreenPixelComponent(q,*p++);
3134               SetBluePixelComponent(q,*p++);
3135               p++;
3136               q++;
3137             }
3138             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3139               break;
3140           }
3141           break;
3142         }
3143       for (y=0; y < (ssize_t) rows; y++)
3144       {
3145         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3146         if (q == (PixelPacket *) NULL)
3147           break;
3148         indexes=GetAuthenticIndexQueue(image);
3149         for (x=0; x < (ssize_t) columns; x++)
3150         {
3151           for (i=0; i < (ssize_t) length; i++)
3152           {
3153             switch (quantum_map[i])
3154             {
3155               case RedQuantum:
3156               case CyanQuantum:
3157               {
3158                 SetRedPixelComponent(q,*p);
3159                 break;
3160               }
3161               case GreenQuantum:
3162               case MagentaQuantum:
3163               {
3164                 SetGreenPixelComponent(q,*p);
3165                 break;
3166               }
3167               case BlueQuantum:
3168               case YellowQuantum:
3169               {
3170                 SetBluePixelComponent(q,*p);
3171                 break;
3172               }
3173               case AlphaQuantum:
3174               {
3175                 SetAlphaPixelComponent(q,*p);
3176                 break;
3177               }
3178               case OpacityQuantum:
3179               {
3180                 SetOpacityPixelComponent(q,*p);
3181                 break;
3182               }
3183               case BlackQuantum:
3184               {
3185                 SetIndexPixelComponent(indexes+x,*p);
3186                 break;
3187               }
3188               case IndexQuantum:
3189               {
3190                 SetRedPixelComponent(q,*p);
3191                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
3192                 SetBluePixelComponent(q,GetRedPixelComponent(q));
3193                 break;
3194               }
3195               default:
3196                 break;
3197             }
3198             p++;
3199           }
3200           q++;
3201         }
3202         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3203           break;
3204       }
3205       break;
3206     }
3207     case ShortPixel:
3208     {
3209       register const unsigned short
3210         *p;
3211
3212       p=(const unsigned short *) pixels;
3213       if (LocaleCompare(map,"BGR") == 0)
3214         {
3215           for (y=0; y < (ssize_t) rows; y++)
3216           {
3217             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3218             if (q == (PixelPacket *) NULL)
3219               break;
3220             for (x=0; x < (ssize_t) columns; x++)
3221             {
3222               SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
3223               SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
3224               SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
3225               q++;
3226             }
3227             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3228               break;
3229           }
3230           break;
3231         }
3232       if (LocaleCompare(map,"BGRA") == 0)
3233         {
3234           for (y=0; y < (ssize_t) rows; y++)
3235           {
3236             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3237             if (q == (PixelPacket *) NULL)
3238               break;
3239             for (x=0; x < (ssize_t) columns; x++)
3240             {
3241               SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
3242               SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
3243               SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
3244               SetAlphaPixelComponent(q,ScaleShortToQuantum(*p++));
3245               q++;
3246             }
3247             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3248               break;
3249           }
3250           break;
3251         }
3252       if (LocaleCompare(map,"BGRP") == 0)
3253         {
3254           for (y=0; y < (ssize_t) rows; y++)
3255           {
3256             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3257             if (q == (PixelPacket *) NULL)
3258               break;
3259             for (x=0; x < (ssize_t) columns; x++)
3260             {
3261               SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
3262               SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
3263               SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
3264               p++;
3265               q++;
3266             }
3267             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3268               break;
3269           }
3270           break;
3271         }
3272       if (LocaleCompare(map,"I") == 0)
3273         {
3274           for (y=0; y < (ssize_t) rows; y++)
3275           {
3276             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3277             if (q == (PixelPacket *) NULL)
3278               break;
3279             for (x=0; x < (ssize_t) columns; x++)
3280             {
3281               SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
3282               SetGreenPixelComponent(q,GetRedPixelComponent(q));
3283               SetBluePixelComponent(q,GetRedPixelComponent(q));
3284               q++;
3285             }
3286             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3287               break;
3288           }
3289           break;
3290         }
3291       if (LocaleCompare(map,"RGB") == 0)
3292         {
3293           for (y=0; y < (ssize_t) rows; y++)
3294           {
3295             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3296             if (q == (PixelPacket *) NULL)
3297               break;
3298             for (x=0; x < (ssize_t) columns; x++)
3299             {
3300               SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
3301               SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
3302               SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
3303               q++;
3304             }
3305             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3306               break;
3307           }
3308           break;
3309         }
3310       if (LocaleCompare(map,"RGBA") == 0)
3311         {
3312           for (y=0; y < (ssize_t) rows; y++)
3313           {
3314             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3315             if (q == (PixelPacket *) NULL)
3316               break;
3317             for (x=0; x < (ssize_t) columns; x++)
3318             {
3319               SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
3320               SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
3321               SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
3322               SetAlphaPixelComponent(q,ScaleShortToQuantum(*p++));
3323               q++;
3324             }
3325             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3326               break;
3327           }
3328           break;
3329         }
3330       if (LocaleCompare(map,"RGBP") == 0)
3331         {
3332           for (y=0; y < (ssize_t) rows; y++)
3333           {
3334             q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3335             if (q == (PixelPacket *) NULL)
3336               break;
3337             for (x=0; x < (ssize_t) columns; x++)
3338             {
3339               SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
3340               SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
3341               SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
3342               p++;
3343               q++;
3344             }
3345             if (SyncAuthenticPixels(image,exception) == MagickFalse)
3346               break;
3347           }
3348           break;
3349         }
3350       for (y=0; y < (ssize_t) rows; y++)
3351       {
3352         q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3353         if (q == (PixelPacket *) NULL)
3354           break;
3355         indexes=GetAuthenticIndexQueue(image);
3356         for (x=0; x < (ssize_t) columns; x++)
3357         {
3358           for (i=0; i < (ssize_t) length; i++)
3359           {
3360             switch (quantum_map[i])
3361             {
3362               case RedQuantum:
3363               case CyanQuantum:
3364               {
3365                 SetRedPixelComponent(q,ScaleShortToQuantum(*p));
3366                 break;
3367               }
3368               case GreenQuantum:
3369               case MagentaQuantum:
3370               {
3371                 SetGreenPixelComponent(q,ScaleShortToQuantum(*p));
3372                 break;
3373               }
3374               case BlueQuantum:
3375               case YellowQuantum:
3376               {
3377                 SetBluePixelComponent(q,ScaleShortToQuantum(*p));
3378                 break;
3379               }
3380               case AlphaQuantum:
3381               {
3382                 SetAlphaPixelComponent(q,ScaleShortToQuantum(*p));
3383                 break;
3384               }
3385               case OpacityQuantum:
3386               {
3387                 SetOpacityPixelComponent(q,ScaleShortToQuantum(*p));
3388                 break;
3389               }
3390               case BlackQuantum:
3391               {
3392                 SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(*p));
3393                 break;
3394               }
3395               case IndexQuantum:
3396               {
3397                 SetRedPixelComponent(q,ScaleShortToQuantum(*p));
3398                 SetGreenPixelComponent(q,GetRedPixelComponent(q));
3399                 SetBluePixelComponent(q,GetRedPixelComponent(q));
3400                 break;
3401               }
3402               default:
3403                 break;
3404             }
3405             p++;
3406           }
3407           q++;
3408         }
3409         if (SyncAuthenticPixels(image,exception) == MagickFalse)
3410           break;
3411       }
3412       break;
3413     }
3414     default:
3415     {
3416       quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3417       (void) ThrowMagickException(&image->exception,GetMagickModule(),
3418         OptionError,"UnrecognizedPixelMap","`%s'",map);
3419       break;
3420     }
3421   }
3422   quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3423   return(MagickTrue);
3424 }
3425 \f
3426 /*
3427 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3428 %                                                                             %
3429 %                                                                             %
3430 %                                                                             %
3431 %   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                   %
3432 %                                                                             %
3433 %                                                                             %
3434 %                                                                             %
3435 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3436 %
3437 %  InterpolateMagickPixelPacket() applies bi-linear or tri-linear interpolation
3438 %  between a floating point coordinate and the pixels surrounding that
3439 %  coordinate.  No pixel area resampling, or scaling of the result is
3440 %  performed.
3441 %
3442 %  The format of the InterpolateMagickPixelPacket method is:
3443 %
3444 %      MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
3445 %        const CacheView *image_view,const InterpolatePixelMethod method,
3446 %        const double x,const double y,MagickPixelPacket *pixel,
3447 %        ExceptionInfo *exception)
3448 %
3449 %  A description of each parameter follows:
3450 %
3451 %    o image: the image.
3452 %
3453 %    o image_view: the image view.
3454 %
3455 %    o method: the pixel color interpolation method.
3456 %
3457 %    o x,y: A double representing the current (x,y) position of the pixel.
3458 %
3459 %    o pixel: return the interpolated pixel here.
3460 %
3461 %    o exception: return any errors or warnings in this structure.
3462 %
3463 */
3464
3465 static inline void AlphaBlendMagickPixelPacket(const Image *image,
3466   const PixelPacket *color,const IndexPacket *indexes,MagickPixelPacket *pixel,
3467   MagickRealType *alpha)
3468 {
3469   if (image->matte == MagickFalse)
3470     {
3471       *alpha=1.0;
3472       pixel->red=(MagickRealType) GetRedPixelComponent(color);
3473       pixel->green=(MagickRealType) GetGreenPixelComponent(color);
3474       pixel->blue=(MagickRealType) GetBluePixelComponent(color);
3475       pixel->opacity=(MagickRealType) GetOpacityPixelComponent(color);
3476       pixel->index=0.0;
3477       if (((image->colorspace == CMYKColorspace) ||
3478            (image->storage_class == PseudoClass)) &&
3479           (indexes != (const IndexPacket *) NULL))
3480         pixel->index=(MagickRealType) GetIndexPixelComponent(indexes);
3481       return;
3482     }
3483   *alpha=QuantumScale*GetAlphaPixelComponent(color);
3484   pixel->red=(*alpha*GetRedPixelComponent(color));
3485   pixel->green=(*alpha*GetGreenPixelComponent(color));
3486   pixel->blue=(*alpha*GetBluePixelComponent(color));
3487   pixel->opacity=(MagickRealType) GetOpacityPixelComponent(color);
3488   pixel->index=0.0;
3489   if (((image->colorspace == CMYKColorspace) ||
3490        (image->storage_class == PseudoClass)) &&
3491       (indexes != (const IndexPacket *) NULL))
3492     pixel->index=(*alpha*GetIndexPixelComponent(indexes));
3493 }
3494
3495 static void BicubicInterpolate(const MagickPixelPacket *pixels,const double dx,
3496   MagickPixelPacket *pixel)
3497 {
3498   MagickRealType
3499     dx2,
3500     p,
3501     q,
3502     r,
3503     s;
3504
3505   dx2=dx*dx;
3506   p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
3507   q=(pixels[0].red-pixels[1].red)-p;
3508   r=pixels[2].red-pixels[0].red;
3509   s=pixels[1].red;
3510   pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3511   p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
3512   q=(pixels[0].green-pixels[1].green)-p;
3513   r=pixels[2].green-pixels[0].green;
3514   s=pixels[1].green;
3515   pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3516   p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
3517   q=(pixels[0].blue-pixels[1].blue)-p;
3518   r=pixels[2].blue-pixels[0].blue;
3519   s=pixels[1].blue;
3520   pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3521   p=(pixels[3].opacity-pixels[2].opacity)-(pixels[0].opacity-pixels[1].opacity);
3522   q=(pixels[0].opacity-pixels[1].opacity)-p;
3523   r=pixels[2].opacity-pixels[0].opacity;
3524   s=pixels[1].opacity;
3525   pixel->opacity=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3526   if (pixel->colorspace == CMYKColorspace)
3527     {
3528       p=(pixels[3].index-pixels[2].index)-(pixels[0].index-pixels[1].index);
3529       q=(pixels[0].index-pixels[1].index)-p;
3530       r=pixels[2].index-pixels[0].index;
3531       s=pixels[1].index;
3532       pixel->index=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3533     }
3534 }
3535
3536 static inline double MagickMax(const MagickRealType x,const MagickRealType y)
3537 {
3538   if (x > y)
3539     return(x);
3540   return(y);
3541 }
3542
3543 static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
3544 {
3545   MagickRealType
3546     alpha,
3547     gamma;
3548
3549   alpha=MagickMax(x+2.0,0.0);
3550   gamma=1.0*alpha*alpha*alpha;
3551   alpha=MagickMax(x+1.0,0.0);
3552   gamma-=4.0*alpha*alpha*alpha;
3553   alpha=MagickMax(x+0.0,0.0);
3554   gamma+=6.0*alpha*alpha*alpha;
3555   alpha=MagickMax(x-1.0,0.0);
3556   gamma-=4.0*alpha*alpha*alpha;
3557   return(gamma/6.0);
3558 }
3559
3560 static inline double MeshInterpolate(const PointInfo *delta,const double p,
3561   const double x,const double y)
3562 {
3563   return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3564 }
3565
3566 static inline ssize_t NearestNeighbor(const MagickRealType x)
3567 {
3568   if (x >= 0.0)
3569     return((ssize_t) (x+0.5));
3570   return((ssize_t) (x-0.5));
3571 }
3572
3573 MagickExport MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
3574   const CacheView *image_view,const InterpolatePixelMethod method,
3575   const double x,const double y,MagickPixelPacket *pixel,
3576   ExceptionInfo *exception)
3577 {
3578   MagickBooleanType
3579     status;
3580
3581   MagickPixelPacket
3582     pixels[16];
3583
3584   MagickRealType
3585     alpha[16],
3586     gamma;
3587
3588   register const IndexPacket
3589     *indexes;
3590
3591   register const PixelPacket
3592     *p;
3593
3594   register ssize_t
3595     i;
3596
3597   ssize_t
3598     x_offset,
3599     y_offset;
3600
3601   assert(image != (Image *) NULL);
3602   assert(image->signature == MagickSignature);
3603   assert(image_view != (CacheView *) NULL);
3604   status=MagickTrue;
3605   x_offset=(ssize_t) floor(x);
3606   y_offset=(ssize_t) floor(y);
3607   switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
3608   {
3609     case AverageInterpolatePixel:
3610     {
3611       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3612         exception);
3613       if (p == (const PixelPacket *) NULL)
3614         {
3615           status=MagickFalse;
3616           break;
3617         }
3618       indexes=GetCacheViewVirtualIndexQueue(image_view);
3619       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3620       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3621       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3622       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3623       AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3624       AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3625       AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3626       AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3627       AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3628       AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3629       AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3630       AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3631       AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3632       AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3633       AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3634       AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3635       pixel->red=0.0;
3636       pixel->green=0.0;
3637       pixel->blue=0.0;
3638       pixel->opacity=0.0;
3639       pixel->index=0.0;
3640       for (i=0; i < 16L; i++)
3641       {
3642         gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
3643         pixel->red+=gamma*0.0625*pixels[i].red;
3644         pixel->green+=gamma*0.0625*pixels[i].green;
3645         pixel->blue+=gamma*0.0625*pixels[i].blue;
3646         pixel->opacity+=0.0625*pixels[i].opacity;
3647         if (image->colorspace == CMYKColorspace)
3648           pixel->index+=gamma*0.0625*pixels[i].index;
3649       }
3650       break;
3651     }
3652     case BicubicInterpolatePixel:
3653     {
3654       MagickPixelPacket
3655         u[4];
3656
3657       PointInfo
3658         delta;
3659
3660       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3661         exception);
3662       if (p == (const PixelPacket *) NULL)
3663         {
3664           status=MagickFalse;
3665           break;
3666         }
3667       indexes=GetCacheViewVirtualIndexQueue(image_view);
3668       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3669       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3670       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3671       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3672       AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3673       AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3674       AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3675       AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3676       AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3677       AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3678       AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3679       AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3680       AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3681       AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3682       AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3683       AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3684       delta.x=x-x_offset;
3685       delta.y=y-y_offset;
3686       for (i=0; i < 4L; i++)
3687         BicubicInterpolate(pixels+4*i,delta.x,u+i);
3688       BicubicInterpolate(u,delta.y,pixel);
3689       break;
3690     }
3691     case BilinearInterpolatePixel:
3692     default:
3693     {
3694       PointInfo
3695         delta,
3696         epsilon;
3697
3698       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3699       if (p == (const PixelPacket *) NULL)
3700         {
3701           status=MagickFalse;
3702           break;
3703         }
3704       indexes=GetCacheViewVirtualIndexQueue(image_view);
3705       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3706       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3707       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3708       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3709       delta.x=x-x_offset;
3710       delta.y=y-y_offset;
3711       epsilon.x=1.0-delta.x;
3712       epsilon.y=1.0-delta.y;
3713       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
3714         (epsilon.x*alpha[2]+delta.x*alpha[3])));
3715       gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3716       pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
3717         pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
3718       pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
3719         pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
3720         pixels[3].green));
3721       pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
3722         pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
3723         pixels[3].blue));
3724       pixel->opacity=(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
3725         pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x*
3726         pixels[3].opacity));
3727       if (image->colorspace == CMYKColorspace)
3728         pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
3729           pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x*
3730           pixels[3].index));
3731       break;
3732     }
3733     case FilterInterpolatePixel:
3734     {
3735       CacheView
3736         *filter_view;
3737
3738       Image
3739         *excerpt_image,
3740         *filter_image;
3741
3742       RectangleInfo
3743         geometry;
3744
3745       geometry.width=4L;
3746       geometry.height=4L;
3747       geometry.x=x_offset-1;
3748       geometry.y=y_offset-1;
3749       excerpt_image=ExcerptImage(image,&geometry,exception);
3750       if (excerpt_image == (Image *) NULL)
3751         {
3752           status=MagickFalse;
3753           break;
3754         }
3755       filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
3756         exception);
3757       excerpt_image=DestroyImage(excerpt_image);
3758       if (filter_image == (Image *) NULL)
3759         break;
3760       filter_view=AcquireCacheView(filter_image);
3761       p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
3762       if (p != (const PixelPacket *) NULL)
3763         {
3764           indexes=GetVirtualIndexQueue(filter_image);
3765           SetMagickPixelPacket(image,p,indexes,pixel);
3766         }
3767       filter_view=DestroyCacheView(filter_view);
3768       filter_image=DestroyImage(filter_image);
3769       break;
3770     }
3771     case IntegerInterpolatePixel:
3772     {
3773       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
3774       if (p == (const PixelPacket *) NULL)
3775         {
3776           status=MagickFalse;
3777           break;
3778         }
3779       indexes=GetCacheViewVirtualIndexQueue(image_view);
3780       SetMagickPixelPacket(image,p,indexes,pixel);
3781       break;
3782     }
3783     case MeshInterpolatePixel:
3784     {
3785       PointInfo
3786         delta,
3787         luminance;
3788
3789       p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
3790         exception);
3791       if (p == (const PixelPacket *) NULL)
3792         {
3793           status=MagickFalse;
3794           break;
3795         }
3796       indexes=GetCacheViewVirtualIndexQueue(image_view);
3797       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3798       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3799       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3800       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3801       delta.x=x-x_offset;
3802       delta.y=y-y_offset;
3803       luminance.x=MagickPixelLuminance(pixels+0)-MagickPixelLuminance(pixels+3);
3804       luminance.y=MagickPixelLuminance(pixels+1)-MagickPixelLuminance(pixels+2);
3805       if (fabs(luminance.x) < fabs(luminance.y))
3806         {
3807           /*
3808             Diagonal 0-3 NW-SE.
3809           */
3810           if (delta.x <= delta.y)
3811             {
3812               /*
3813                 Bottom-left triangle  (pixel:2, diagonal: 0-3).
3814               */
3815               delta.y=1.0-delta.y;
3816               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
3817               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3818               pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
3819                 pixels[3].red,pixels[0].red);
3820               pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
3821                 pixels[3].green,pixels[0].green);
3822               pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
3823                 pixels[3].blue,pixels[0].blue);
3824               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
3825                 pixels[3].opacity,pixels[0].opacity);
3826               if (image->colorspace == CMYKColorspace)
3827                 pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
3828                   pixels[3].index,pixels[0].index);
3829             }
3830           else
3831             {
3832               /*
3833                 Top-right triangle (pixel:1, diagonal: 0-3).
3834               */
3835               delta.x=1.0-delta.x;
3836               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
3837               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3838               pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
3839                 pixels[0].red,pixels[3].red);
3840               pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
3841                 pixels[0].green,pixels[3].green);
3842               pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
3843                 pixels[0].blue,pixels[3].blue);
3844               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
3845                 pixels[0].opacity,pixels[3].opacity);
3846               if (image->colorspace == CMYKColorspace)
3847                 pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
3848                   pixels[0].index,pixels[3].index);
3849             }
3850         }
3851       else
3852         {
3853           /*
3854             Diagonal 1-2 NE-SW.
3855           */
3856           if (delta.x <= (1.0-delta.y))
3857             {
3858               /*
3859                 Top-left triangle (pixel 0, diagonal: 1-2).
3860               */
3861               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
3862               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3863               pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
3864                 pixels[1].red,pixels[2].red);
3865               pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
3866                 pixels[1].green,pixels[2].green);
3867               pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
3868                 pixels[1].blue,pixels[2].blue);
3869               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
3870                 pixels[1].opacity,pixels[2].opacity);
3871               if (image->colorspace == CMYKColorspace)
3872                 pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
3873                   pixels[1].index,pixels[2].index);
3874             }
3875           else
3876             {
3877               /*
3878                 Bottom-right triangle (pixel: 3, diagonal: 1-2).
3879               */
3880               delta.x=1.0-delta.x;
3881               delta.y=1.0-delta.y;
3882               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
3883               gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3884               pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
3885                 pixels[2].red,pixels[1].red);
3886               pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
3887                 pixels[2].green,pixels[1].green);
3888               pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
3889                 pixels[2].blue,pixels[1].blue);
3890               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
3891                 pixels[2].opacity,pixels[1].opacity);
3892               if (image->colorspace == CMYKColorspace)
3893                 pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
3894                   pixels[2].index,pixels[1].index);
3895             }
3896         }
3897       break;
3898     }
3899     case NearestNeighborInterpolatePixel:
3900     {
3901       p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
3902         NearestNeighbor(y),1,1,exception);
3903       if (p == (const PixelPacket *) NULL)
3904         {
3905           status=MagickFalse;
3906           break;
3907         }
3908       indexes=GetCacheViewVirtualIndexQueue(image_view);
3909       SetMagickPixelPacket(image,p,indexes,pixel);
3910       break;
3911     }
3912     case SplineInterpolatePixel:
3913     {
3914       MagickRealType
3915         dx,
3916         dy;
3917
3918       PointInfo
3919         delta;
3920
3921       ssize_t
3922         j,
3923         n;
3924
3925       p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3926         exception);
3927       if (p == (const PixelPacket *) NULL)
3928         {
3929           status=MagickFalse;
3930           break;
3931         }
3932       indexes=GetCacheViewVirtualIndexQueue(image_view);
3933       AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3934       AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3935       AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3936       AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3937       AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3938       AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3939       AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3940       AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3941       AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3942       AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3943       AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3944       AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3945       AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3946       AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3947       AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3948       AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3949       pixel->red=0.0;
3950       pixel->green=0.0;
3951       pixel->blue=0.0;
3952       pixel->opacity=0.0;
3953       pixel->index=0.0;
3954       delta.x=x-x_offset;
3955       delta.y=y-y_offset;
3956       n=0;
3957       for (i=(-1); i < 3L; i++)
3958       {
3959         dy=CubicWeightingFunction((MagickRealType) i-delta.y);
3960         for (j=(-1); j < 3L; j++)
3961         {
3962           dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
3963           gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
3964           pixel->red+=gamma*dx*dy*pixels[n].red;
3965           pixel->green+=gamma*dx*dy*pixels[n].green;
3966           pixel->blue+=gamma*dx*dy*pixels[n].blue;
3967           pixel->opacity+=dx*dy*pixels[n].opacity;
3968           if (image->colorspace == CMYKColorspace)
3969             pixel->index+=gamma*dx*dy*pixels[n].index;
3970           n++;
3971         }
3972       }
3973       break;
3974     }
3975   }
3976   return(status);
3977 }