2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6 % PPPP IIIII X X EEEEE L %
10 % P IIIII X X EEEEE LLLLL %
12 % MagickCore Methods to Import/Export Pixels %
19 % Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
20 % dedicated to making software imaging solutions freely available. %
22 % You may not use this file except in compliance with the License. You may %
23 % obtain a copy of the License at %
25 % http://www.imagemagick.org/script/license.php %
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. %
33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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"
70 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
74 % E x p o r t I m a g e P i x e l s %
78 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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.
85 % Suppose you want to extract the first scanline of a 640x480 image as
86 % character data in red-green-blue order:
88 % ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
90 % The format of the ExportImagePixels method is:
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)
97 % A description of each parameter follows:
101 % o x_offset,y_offset,columns,rows: These values define the perimeter
102 % of a region of pixels you want to extract.
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),
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.
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.
119 % o exception: return any errors or warnings in this structure.
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)
134 register const IndexPacket
137 register const PixelPacket
146 assert(image != (Image *) NULL);
147 assert(image->signature == MagickSignature);
148 if (image->debug != MagickFalse)
149 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
151 quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
152 if (quantum_map == (QuantumType *) NULL)
154 (void) ThrowMagickException(exception,GetMagickModule(),
155 ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
158 for (i=0; i < (ssize_t) length; i++)
165 quantum_map[i]=AlphaQuantum;
171 quantum_map[i]=BlueQuantum;
177 quantum_map[i]=CyanQuantum;
178 if (image->colorspace == CMYKColorspace)
180 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
181 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
182 "ColorSeparatedImageRequired","`%s'",map);
188 quantum_map[i]=GreenQuantum;
194 quantum_map[i]=IndexQuantum;
200 quantum_map[i]=BlackQuantum;
201 if (image->colorspace == CMYKColorspace)
203 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
204 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
205 "ColorSeparatedImageRequired","`%s'",map);
211 quantum_map[i]=MagentaQuantum;
212 if (image->colorspace == CMYKColorspace)
214 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
215 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
216 "ColorSeparatedImageRequired","`%s'",map);
222 quantum_map[i]=OpacityQuantum;
228 quantum_map[i]=UndefinedQuantum;
234 quantum_map[i]=RedQuantum;
240 quantum_map[i]=YellowQuantum;
241 if (image->colorspace == CMYKColorspace)
243 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
244 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
245 "ColorSeparatedImageRequired","`%s'",map);
250 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
251 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
252 "UnrecognizedPixelMap","`%s'",map);
261 register unsigned char
264 q=(unsigned char *) pixels;
265 if (LocaleCompare(map,"BGR") == 0)
267 for (y=0; y < (ssize_t) rows; y++)
269 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
270 if (p == (const PixelPacket *) NULL)
272 for (x=0; x < (ssize_t) columns; x++)
274 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
275 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
276 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
282 if (LocaleCompare(map,"BGRA") == 0)
284 for (y=0; y < (ssize_t) rows; y++)
286 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
287 if (p == (const PixelPacket *) NULL)
289 for (x=0; x < (ssize_t) columns; x++)
291 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
292 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
293 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
294 *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
300 if (LocaleCompare(map,"BGRP") == 0)
302 for (y=0; y < (ssize_t) rows; y++)
304 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
305 if (p == (const PixelPacket *) NULL)
307 for (x=0; x < (ssize_t) columns; x++)
309 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
310 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
311 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
312 *q++=ScaleQuantumToChar((Quantum) 0);
318 if (LocaleCompare(map,"I") == 0)
320 for (y=0; y < (ssize_t) rows; y++)
322 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
323 if (p == (const PixelPacket *) NULL)
325 for (x=0; x < (ssize_t) columns; x++)
327 *q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));
333 if (LocaleCompare(map,"RGB") == 0)
335 for (y=0; y < (ssize_t) rows; y++)
337 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
338 if (p == (const PixelPacket *) NULL)
340 for (x=0; x < (ssize_t) columns; x++)
342 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
343 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
344 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
350 if (LocaleCompare(map,"RGBA") == 0)
352 for (y=0; y < (ssize_t) rows; y++)
354 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
355 if (p == (const PixelPacket *) NULL)
357 for (x=0; x < (ssize_t) columns; x++)
359 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
360 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
361 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
362 *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
368 if (LocaleCompare(map,"RGBP") == 0)
370 for (y=0; y < (ssize_t) rows; y++)
372 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
373 if (p == (const PixelPacket *) NULL)
375 for (x=0; x < (ssize_t) columns; x++)
377 *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
378 *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
379 *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
380 *q++=ScaleQuantumToChar((Quantum) 0);
386 for (y=0; y < (ssize_t) rows; y++)
388 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
389 if (p == (const PixelPacket *) NULL)
391 indexes=GetVirtualIndexQueue(image);
392 for (x=0; x < (ssize_t) columns; x++)
394 for (i=0; i < (ssize_t) length; i++)
397 switch (quantum_map[i])
402 *q=ScaleQuantumToChar(GetRedPixelComponent(p));
408 *q=ScaleQuantumToChar(GetGreenPixelComponent(p));
414 *q=ScaleQuantumToChar(GetBluePixelComponent(p));
419 *q=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
424 *q=ScaleQuantumToChar(GetOpacityPixelComponent(p));
429 if (image->colorspace == CMYKColorspace)
430 *q=ScaleQuantumToChar(indexes[x]);
435 *q=ScaleQuantumToChar(PixelIntensityToQuantum(p));
454 if (LocaleCompare(map,"BGR") == 0)
456 for (y=0; y < (ssize_t) rows; y++)
458 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
459 if (p == (const PixelPacket *) NULL)
461 for (x=0; x < (ssize_t) columns; x++)
463 *q++=(double) (QuantumScale*GetBluePixelComponent(p));
464 *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
465 *q++=(double) (QuantumScale*GetRedPixelComponent(p));
471 if (LocaleCompare(map,"BGRA") == 0)
473 for (y=0; y < (ssize_t) rows; y++)
475 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
476 if (p == (const PixelPacket *) NULL)
478 for (x=0; x < (ssize_t) columns; x++)
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))));
490 if (LocaleCompare(map,"BGRP") == 0)
492 for (y=0; y < (ssize_t) rows; y++)
494 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
495 if (p == (const PixelPacket *) NULL)
497 for (x=0; x < (ssize_t) columns; x++)
499 *q++=(double) (QuantumScale*GetBluePixelComponent(p));
500 *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
501 *q++=(double) (QuantumScale*GetRedPixelComponent(p));
508 if (LocaleCompare(map,"I") == 0)
510 for (y=0; y < (ssize_t) rows; y++)
512 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
513 if (p == (const PixelPacket *) NULL)
515 for (x=0; x < (ssize_t) columns; x++)
517 *q++=(double) (QuantumScale*PixelIntensityToQuantum(p));
523 if (LocaleCompare(map,"RGB") == 0)
525 for (y=0; y < (ssize_t) rows; y++)
527 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
528 if (p == (const PixelPacket *) NULL)
530 for (x=0; x < (ssize_t) columns; x++)
532 *q++=(double) (QuantumScale*GetRedPixelComponent(p));
533 *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
534 *q++=(double) (QuantumScale*GetBluePixelComponent(p));
540 if (LocaleCompare(map,"RGBA") == 0)
542 for (y=0; y < (ssize_t) rows; y++)
544 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
545 if (p == (const PixelPacket *) NULL)
547 for (x=0; x < (ssize_t) columns; x++)
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))));
559 if (LocaleCompare(map,"RGBP") == 0)
561 for (y=0; y < (ssize_t) rows; y++)
563 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
564 if (p == (const PixelPacket *) NULL)
566 for (x=0; x < (ssize_t) columns; x++)
568 *q++=(double) (QuantumScale*GetRedPixelComponent(p));
569 *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
570 *q++=(double) (QuantumScale*GetBluePixelComponent(p));
577 for (y=0; y < (ssize_t) rows; y++)
579 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
580 if (p == (const PixelPacket *) NULL)
582 indexes=GetVirtualIndexQueue(image);
583 for (x=0; x < (ssize_t) columns; x++)
585 for (i=0; i < (ssize_t) length; i++)
588 switch (quantum_map[i])
593 *q=(double) (QuantumScale*GetRedPixelComponent(p));
599 *q=(double) (QuantumScale*GetGreenPixelComponent(p));
605 *q=(double) (QuantumScale*GetBluePixelComponent(p));
610 *q=(double) (QuantumScale*((Quantum) (QuantumRange-
611 GetOpacityPixelComponent(p))));
616 *q=(double) (QuantumScale*GetOpacityPixelComponent(p));
621 if (image->colorspace == CMYKColorspace)
622 *q=(double) (QuantumScale*indexes[x]);
627 *q=(double) (QuantumScale*PixelIntensityToQuantum(p));
646 if (LocaleCompare(map,"BGR") == 0)
648 for (y=0; y < (ssize_t) rows; y++)
650 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
651 if (p == (const PixelPacket *) NULL)
653 for (x=0; x < (ssize_t) columns; x++)
655 *q++=(float) (QuantumScale*GetBluePixelComponent(p));
656 *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
657 *q++=(float) (QuantumScale*GetRedPixelComponent(p));
663 if (LocaleCompare(map,"BGRA") == 0)
665 for (y=0; y < (ssize_t) rows; y++)
667 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
668 if (p == (const PixelPacket *) NULL)
670 for (x=0; x < (ssize_t) columns; x++)
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)));
681 if (LocaleCompare(map,"BGRP") == 0)
683 for (y=0; y < (ssize_t) rows; y++)
685 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
686 if (p == (const PixelPacket *) NULL)
688 for (x=0; x < (ssize_t) columns; x++)
690 *q++=(float) (QuantumScale*GetBluePixelComponent(p));
691 *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
692 *q++=(float) (QuantumScale*GetRedPixelComponent(p));
699 if (LocaleCompare(map,"I") == 0)
701 for (y=0; y < (ssize_t) rows; y++)
703 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
704 if (p == (const PixelPacket *) NULL)
706 for (x=0; x < (ssize_t) columns; x++)
708 *q++=(float) (QuantumScale*PixelIntensityToQuantum(p));
714 if (LocaleCompare(map,"RGB") == 0)
716 for (y=0; y < (ssize_t) rows; y++)
718 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
719 if (p == (const PixelPacket *) NULL)
721 for (x=0; x < (ssize_t) columns; x++)
723 *q++=(float) (QuantumScale*GetRedPixelComponent(p));
724 *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
725 *q++=(float) (QuantumScale*GetBluePixelComponent(p));
731 if (LocaleCompare(map,"RGBA") == 0)
733 for (y=0; y < (ssize_t) rows; y++)
735 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
736 if (p == (const PixelPacket *) NULL)
738 for (x=0; x < (ssize_t) columns; x++)
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))));
749 if (LocaleCompare(map,"RGBP") == 0)
751 for (y=0; y < (ssize_t) rows; y++)
753 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
754 if (p == (const PixelPacket *) NULL)
756 for (x=0; x < (ssize_t) columns; x++)
758 *q++=(float) (QuantumScale*GetRedPixelComponent(p));
759 *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
760 *q++=(float) (QuantumScale*GetBluePixelComponent(p));
767 for (y=0; y < (ssize_t) rows; y++)
769 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
770 if (p == (const PixelPacket *) NULL)
772 indexes=GetVirtualIndexQueue(image);
773 for (x=0; x < (ssize_t) columns; x++)
775 for (i=0; i < (ssize_t) length; i++)
778 switch (quantum_map[i])
783 *q=(float) (QuantumScale*GetRedPixelComponent(p));
789 *q=(float) (QuantumScale*GetGreenPixelComponent(p));
795 *q=(float) (QuantumScale*GetBluePixelComponent(p));
800 *q=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p))));
805 *q=(float) (QuantumScale*GetOpacityPixelComponent(p));
810 if (image->colorspace == CMYKColorspace)
811 *q=(float) (QuantumScale*indexes[x]);
816 *q=(float) (QuantumScale*PixelIntensityToQuantum(p));
831 register unsigned int
834 q=(unsigned int *) pixels;
835 if (LocaleCompare(map,"BGR") == 0)
837 for (y=0; y < (ssize_t) rows; y++)
839 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
840 if (p == (const PixelPacket *) NULL)
842 for (x=0; x < (ssize_t) columns; x++)
844 *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
845 *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
846 *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
852 if (LocaleCompare(map,"BGRA") == 0)
854 for (y=0; y < (ssize_t) rows; y++)
856 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
857 if (p == (const PixelPacket *) NULL)
859 for (x=0; x < (ssize_t) columns; x++)
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)));
871 if (LocaleCompare(map,"BGRP") == 0)
873 for (y=0; y < (ssize_t) rows; y++)
875 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
876 if (p == (const PixelPacket *) NULL)
878 for (x=0; x < (ssize_t) columns; x++)
880 *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
881 *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
882 *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
889 if (LocaleCompare(map,"I") == 0)
891 for (y=0; y < (ssize_t) rows; y++)
893 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
894 if (p == (const PixelPacket *) NULL)
896 for (x=0; x < (ssize_t) columns; x++)
899 ScaleQuantumToLong(PixelIntensityToQuantum(p));
905 if (LocaleCompare(map,"RGB") == 0)
907 for (y=0; y < (ssize_t) rows; y++)
909 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
910 if (p == (const PixelPacket *) NULL)
912 for (x=0; x < (ssize_t) columns; x++)
914 *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
915 *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
916 *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
922 if (LocaleCompare(map,"RGBA") == 0)
924 for (y=0; y < (ssize_t) rows; y++)
926 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
927 if (p == (const PixelPacket *) NULL)
929 for (x=0; x < (ssize_t) columns; x++)
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)));
941 if (LocaleCompare(map,"RGBP") == 0)
943 for (y=0; y < (ssize_t) rows; y++)
945 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
946 if (p == (const PixelPacket *) NULL)
948 for (x=0; x < (ssize_t) columns; x++)
950 *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
951 *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
952 *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
959 for (y=0; y < (ssize_t) rows; y++)
961 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
962 if (p == (const PixelPacket *) NULL)
964 indexes=GetVirtualIndexQueue(image);
965 for (x=0; x < (ssize_t) columns; x++)
967 for (i=0; i < (ssize_t) length; i++)
970 switch (quantum_map[i])
975 *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
981 *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
987 *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
992 *q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
993 GetOpacityPixelComponent(p)));
998 *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p));
1003 if (image->colorspace == CMYKColorspace)
1004 *q=(unsigned int) ScaleQuantumToLong(indexes[x]);
1010 ScaleQuantumToLong(PixelIntensityToQuantum(p));
1028 q=(size_t *) pixels;
1029 if (LocaleCompare(map,"BGR") == 0)
1031 for (y=0; y < (ssize_t) rows; y++)
1033 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1034 if (p == (const PixelPacket *) NULL)
1036 for (x=0; x < (ssize_t) columns; x++)
1038 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1039 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1040 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1046 if (LocaleCompare(map,"BGRA") == 0)
1048 for (y=0; y < (ssize_t) rows; y++)
1050 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1051 if (p == (const PixelPacket *) NULL)
1053 for (x=0; x < (ssize_t) columns; x++)
1055 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1056 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1057 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1058 *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1064 if (LocaleCompare(map,"BGRP") == 0)
1066 for (y=0; y < (ssize_t) rows; y++)
1068 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1069 if (p == (const PixelPacket *) NULL)
1071 for (x=0; x < (ssize_t) columns; x++)
1073 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1074 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1075 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1082 if (LocaleCompare(map,"I") == 0)
1084 for (y=0; y < (ssize_t) rows; y++)
1086 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1087 if (p == (const PixelPacket *) NULL)
1089 for (x=0; x < (ssize_t) columns; x++)
1091 *q++=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1097 if (LocaleCompare(map,"RGB") == 0)
1099 for (y=0; y < (ssize_t) rows; y++)
1101 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1102 if (p == (const PixelPacket *) NULL)
1104 for (x=0; x < (ssize_t) columns; x++)
1106 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1107 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1108 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1114 if (LocaleCompare(map,"RGBA") == 0)
1116 for (y=0; y < (ssize_t) rows; y++)
1118 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1119 if (p == (const PixelPacket *) NULL)
1121 for (x=0; x < (ssize_t) columns; x++)
1123 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1124 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1125 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1126 *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1132 if (LocaleCompare(map,"RGBP") == 0)
1134 for (y=0; y < (ssize_t) rows; y++)
1136 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1137 if (p == (const PixelPacket *) NULL)
1139 for (x=0; x < (ssize_t) columns; x++)
1141 *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
1142 *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
1143 *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
1150 for (y=0; y < (ssize_t) rows; y++)
1152 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1153 if (p == (const PixelPacket *) NULL)
1155 indexes=GetVirtualIndexQueue(image);
1156 for (x=0; x < (ssize_t) columns; x++)
1158 for (i=0; i < (ssize_t) length; i++)
1161 switch (quantum_map[i])
1166 *q=ScaleQuantumToLong(GetRedPixelComponent(p));
1170 case MagentaQuantum:
1172 *q=ScaleQuantumToLong(GetGreenPixelComponent(p));
1178 *q=ScaleQuantumToLong(GetBluePixelComponent(p));
1183 *q=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
1186 case OpacityQuantum:
1188 *q=ScaleQuantumToLong(GetOpacityPixelComponent(p));
1193 if (image->colorspace == CMYKColorspace)
1194 *q=ScaleQuantumToLong(indexes[x]);
1199 *q=ScaleQuantumToLong(PixelIntensityToQuantum(p));
1217 q=(Quantum *) pixels;
1218 if (LocaleCompare(map,"BGR") == 0)
1220 for (y=0; y < (ssize_t) rows; y++)
1222 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1223 if (p == (const PixelPacket *) NULL)
1225 for (x=0; x < (ssize_t) columns; x++)
1227 *q++=GetBluePixelComponent(p);
1228 *q++=GetGreenPixelComponent(p);
1229 *q++=GetRedPixelComponent(p);
1235 if (LocaleCompare(map,"BGRA") == 0)
1237 for (y=0; y < (ssize_t) rows; y++)
1239 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1240 if (p == (const PixelPacket *) NULL)
1242 for (x=0; x < (ssize_t) columns; x++)
1244 *q++=GetBluePixelComponent(p);
1245 *q++=GetGreenPixelComponent(p);
1246 *q++=GetRedPixelComponent(p);
1247 *q++=(Quantum) (GetAlphaPixelComponent(p));
1253 if (LocaleCompare(map,"BGRP") == 0)
1255 for (y=0; y < (ssize_t) rows; y++)
1257 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1258 if (p == (const PixelPacket *) NULL)
1260 for (x=0; x < (ssize_t) columns; x++)
1262 *q++=GetBluePixelComponent(p);
1263 *q++=GetGreenPixelComponent(p);
1264 *q++=GetRedPixelComponent(p);
1271 if (LocaleCompare(map,"I") == 0)
1273 for (y=0; y < (ssize_t) rows; y++)
1275 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1276 if (p == (const PixelPacket *) NULL)
1278 for (x=0; x < (ssize_t) columns; x++)
1280 *q++=PixelIntensityToQuantum(p);
1286 if (LocaleCompare(map,"RGB") == 0)
1288 for (y=0; y < (ssize_t) rows; y++)
1290 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1291 if (p == (const PixelPacket *) NULL)
1293 for (x=0; x < (ssize_t) columns; x++)
1295 *q++=GetRedPixelComponent(p);
1296 *q++=GetGreenPixelComponent(p);
1297 *q++=GetBluePixelComponent(p);
1303 if (LocaleCompare(map,"RGBA") == 0)
1305 for (y=0; y < (ssize_t) rows; y++)
1307 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1308 if (p == (const PixelPacket *) NULL)
1310 for (x=0; x < (ssize_t) columns; x++)
1312 *q++=GetRedPixelComponent(p);
1313 *q++=GetGreenPixelComponent(p);
1314 *q++=GetBluePixelComponent(p);
1315 *q++=(Quantum) (GetAlphaPixelComponent(p));
1321 if (LocaleCompare(map,"RGBP") == 0)
1323 for (y=0; y < (ssize_t) rows; y++)
1325 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1326 if (p == (const PixelPacket *) NULL)
1328 for (x=0; x < (ssize_t) columns; x++)
1330 *q++=GetRedPixelComponent(p);
1331 *q++=GetGreenPixelComponent(p);
1332 *q++=GetBluePixelComponent(p);
1339 for (y=0; y < (ssize_t) rows; y++)
1341 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1342 if (p == (const PixelPacket *) NULL)
1344 indexes=GetVirtualIndexQueue(image);
1345 for (x=0; x < (ssize_t) columns; x++)
1347 for (i=0; i < (ssize_t) length; i++)
1350 switch (quantum_map[i])
1355 *q=GetRedPixelComponent(p);
1359 case MagentaQuantum:
1361 *q=GetGreenPixelComponent(p);
1367 *q=GetBluePixelComponent(p);
1372 *q=(Quantum) (GetAlphaPixelComponent(p));
1375 case OpacityQuantum:
1377 *q=GetOpacityPixelComponent(p);
1382 if (image->colorspace == CMYKColorspace)
1388 *q=(PixelIntensityToQuantum(p));
1403 register unsigned short
1406 q=(unsigned short *) pixels;
1407 if (LocaleCompare(map,"BGR") == 0)
1409 for (y=0; y < (ssize_t) rows; y++)
1411 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1412 if (p == (const PixelPacket *) NULL)
1414 for (x=0; x < (ssize_t) columns; x++)
1416 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1417 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1418 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1424 if (LocaleCompare(map,"BGRA") == 0)
1426 for (y=0; y < (ssize_t) rows; y++)
1428 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1429 if (p == (const PixelPacket *) NULL)
1431 for (x=0; x < (ssize_t) columns; x++)
1433 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1434 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1435 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1436 *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1442 if (LocaleCompare(map,"BGRP") == 0)
1444 for (y=0; y < (ssize_t) rows; y++)
1446 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1447 if (p == (const PixelPacket *) NULL)
1449 for (x=0; x < (ssize_t) columns; x++)
1451 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1452 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1453 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1460 if (LocaleCompare(map,"I") == 0)
1462 for (y=0; y < (ssize_t) rows; y++)
1464 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1465 if (p == (const PixelPacket *) NULL)
1467 for (x=0; x < (ssize_t) columns; x++)
1469 *q++=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1475 if (LocaleCompare(map,"RGB") == 0)
1477 for (y=0; y < (ssize_t) rows; y++)
1479 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1480 if (p == (const PixelPacket *) NULL)
1482 for (x=0; x < (ssize_t) columns; x++)
1484 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1485 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1486 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1492 if (LocaleCompare(map,"RGBA") == 0)
1494 for (y=0; y < (ssize_t) rows; y++)
1496 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1497 if (p == (const PixelPacket *) NULL)
1499 for (x=0; x < (ssize_t) columns; x++)
1501 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1502 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1503 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1504 *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1510 if (LocaleCompare(map,"RGBP") == 0)
1512 for (y=0; y < (ssize_t) rows; y++)
1514 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1515 if (p == (const PixelPacket *) NULL)
1517 for (x=0; x < (ssize_t) columns; x++)
1519 *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
1520 *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
1521 *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
1528 for (y=0; y < (ssize_t) rows; y++)
1530 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1531 if (p == (const PixelPacket *) NULL)
1533 indexes=GetVirtualIndexQueue(image);
1534 for (x=0; x < (ssize_t) columns; x++)
1536 for (i=0; i < (ssize_t) length; i++)
1539 switch (quantum_map[i])
1544 *q=ScaleQuantumToShort(GetRedPixelComponent(p));
1548 case MagentaQuantum:
1550 *q=ScaleQuantumToShort(GetGreenPixelComponent(p));
1556 *q=ScaleQuantumToShort(GetBluePixelComponent(p));
1561 *q=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
1564 case OpacityQuantum:
1566 *q=ScaleQuantumToShort(GetOpacityPixelComponent(p));
1571 if (image->colorspace == CMYKColorspace)
1572 *q=ScaleQuantumToShort(indexes[x]);
1577 *q=ScaleQuantumToShort(PixelIntensityToQuantum(p));
1592 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1593 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1594 "UnrecognizedPixelMap","`%s'",map);
1598 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1603 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1607 % G e t M a g i c k P i x e l P a c k e t %
1611 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1613 % GetMagickPixelPacket() initializes the MagickPixelPacket structure.
1615 % The format of the GetMagickPixelPacket method is:
1617 % GetMagickPixelPacket(const Image *image,MagickPixelPacket *pixel)
1619 % A description of each parameter follows:
1621 % o image: the image.
1623 % o pixel: Specifies a pointer to a PixelPacket structure.
1626 MagickExport void GetMagickPixelPacket(const Image *image,
1627 MagickPixelPacket *pixel)
1629 pixel->storage_class=DirectClass;
1630 pixel->colorspace=RGBColorspace;
1631 pixel->matte=MagickFalse;
1633 pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
1637 pixel->opacity=(MagickRealType) OpaqueOpacity;
1639 if (image == (const Image *) NULL)
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;
1649 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1653 % I m p o r t I m a g e P i x e l s %
1657 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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.
1664 % Suppose your want to upload the first scanline of a 640x480 image from
1665 % character data in red-green-blue order:
1667 % ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
1669 % The format of the ImportImagePixels method is:
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)
1676 % A description of each parameter follows:
1678 % o image: the image.
1680 % o x_offset,y_offset,columns,rows: These values define the perimeter
1681 % of a region of pixels you want to define.
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),
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
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.
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,
1713 register IndexPacket
1727 Allocate image structure.
1729 assert(image != (Image *) NULL);
1730 assert(image->signature == MagickSignature);
1731 if (image->debug != MagickFalse)
1732 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1734 quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1735 if (quantum_map == (QuantumType *) NULL)
1736 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1738 for (i=0; i < (ssize_t) length; i++)
1745 quantum_map[i]=AlphaQuantum;
1746 image->matte=MagickTrue;
1752 quantum_map[i]=BlueQuantum;
1758 quantum_map[i]=CyanQuantum;
1759 (void) SetImageColorspace(image,CMYKColorspace);
1765 quantum_map[i]=GreenQuantum;
1771 quantum_map[i]=BlackQuantum;
1772 (void) SetImageColorspace(image,CMYKColorspace);
1778 quantum_map[i]=IndexQuantum;
1784 quantum_map[i]=MagentaQuantum;
1785 (void) SetImageColorspace(image,CMYKColorspace);
1791 quantum_map[i]=OpacityQuantum;
1792 image->matte=MagickTrue;
1798 quantum_map[i]=UndefinedQuantum;
1804 quantum_map[i]=RedQuantum;
1810 quantum_map[i]=YellowQuantum;
1811 (void) SetImageColorspace(image,CMYKColorspace);
1816 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1817 (void) ThrowMagickException(&image->exception,GetMagickModule(),
1818 OptionError,"UnrecognizedPixelMap","`%s'",map);
1819 return(MagickFalse);
1823 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
1824 return(MagickFalse);
1826 Transfer the pixels from the pixel datarray to the image.
1828 exception=(&image->exception);
1833 register const unsigned char
1836 p=(const unsigned char *) pixels;
1837 if (LocaleCompare(map,"BGR") == 0)
1839 for (y=0; y < (ssize_t) rows; y++)
1841 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1842 if (q == (PixelPacket *) NULL)
1844 for (x=0; x < (ssize_t) columns; x++)
1846 q->blue=ScaleCharToQuantum(*p++);
1847 q->green=ScaleCharToQuantum(*p++);
1848 q->red=ScaleCharToQuantum(*p++);
1851 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1856 if (LocaleCompare(map,"BGRA") == 0)
1858 for (y=0; y < (ssize_t) rows; y++)
1860 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1861 if (q == (PixelPacket *) NULL)
1863 for (x=0; x < (ssize_t) columns; x++)
1865 q->blue=ScaleCharToQuantum(*p++);
1866 q->green=ScaleCharToQuantum(*p++);
1867 q->red=ScaleCharToQuantum(*p++);
1868 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
1871 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1876 if (LocaleCompare(map,"BGRO") == 0)
1878 for (y=0; y < (ssize_t) rows; y++)
1880 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1881 if (q == (PixelPacket *) NULL)
1883 for (x=0; x < (ssize_t) columns; x++)
1885 q->blue=ScaleCharToQuantum(*p++);
1886 q->green=ScaleCharToQuantum(*p++);
1887 q->red=ScaleCharToQuantum(*p++);
1888 q->opacity=ScaleCharToQuantum(*p++);
1891 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1896 if (LocaleCompare(map,"BGRP") == 0)
1898 for (y=0; y < (ssize_t) rows; y++)
1900 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1901 if (q == (PixelPacket *) NULL)
1903 for (x=0; x < (ssize_t) columns; x++)
1905 q->blue=ScaleCharToQuantum(*p++);
1906 q->green=ScaleCharToQuantum(*p++);
1907 q->red=ScaleCharToQuantum(*p++);
1911 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1916 if (LocaleCompare(map,"I") == 0)
1918 for (y=0; y < (ssize_t) rows; y++)
1920 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1921 if (q == (PixelPacket *) NULL)
1923 for (x=0; x < (ssize_t) columns; x++)
1925 q->red=ScaleCharToQuantum(*p++);
1930 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1935 if (LocaleCompare(map,"RGB") == 0)
1937 for (y=0; y < (ssize_t) rows; y++)
1939 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1940 if (q == (PixelPacket *) NULL)
1942 for (x=0; x < (ssize_t) columns; x++)
1944 q->red=ScaleCharToQuantum(*p++);
1945 q->green=ScaleCharToQuantum(*p++);
1946 q->blue=ScaleCharToQuantum(*p++);
1949 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1954 if (LocaleCompare(map,"RGBA") == 0)
1956 for (y=0; y < (ssize_t) rows; y++)
1958 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1959 if (q == (PixelPacket *) NULL)
1961 for (x=0; x < (ssize_t) columns; x++)
1963 q->red=ScaleCharToQuantum(*p++);
1964 q->green=ScaleCharToQuantum(*p++);
1965 q->blue=ScaleCharToQuantum(*p++);
1966 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p++);
1969 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1974 if (LocaleCompare(map,"RGBO") == 0)
1976 for (y=0; y < (ssize_t) rows; y++)
1978 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1979 if (q == (PixelPacket *) NULL)
1981 for (x=0; x < (ssize_t) columns; x++)
1983 q->red=ScaleCharToQuantum(*p++);
1984 q->green=ScaleCharToQuantum(*p++);
1985 q->blue=ScaleCharToQuantum(*p++);
1986 q->opacity=ScaleCharToQuantum(*p++);
1989 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1994 if (LocaleCompare(map,"RGBP") == 0)
1996 for (y=0; y < (ssize_t) rows; y++)
1998 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1999 if (q == (PixelPacket *) NULL)
2001 for (x=0; x < (ssize_t) columns; x++)
2003 q->red=ScaleCharToQuantum(*p++);
2004 q->green=ScaleCharToQuantum(*p++);
2005 q->blue=ScaleCharToQuantum(*p++);
2009 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2014 for (y=0; y < (ssize_t) rows; y++)
2016 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2017 if (q == (PixelPacket *) NULL)
2019 indexes=GetAuthenticIndexQueue(image);
2020 for (x=0; x < (ssize_t) columns; x++)
2022 for (i=0; i < (ssize_t) length; i++)
2024 switch (quantum_map[i])
2029 q->red=ScaleCharToQuantum(*p);
2033 case MagentaQuantum:
2035 q->green=ScaleCharToQuantum(*p);
2041 q->blue=ScaleCharToQuantum(*p);
2046 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
2049 case OpacityQuantum:
2051 q->opacity=ScaleCharToQuantum(*p);
2056 indexes[x]=ScaleCharToQuantum(*p);
2061 q->red=ScaleCharToQuantum(*p);
2073 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2080 register const double
2083 p=(const double *) pixels;
2084 if (LocaleCompare(map,"BGR") == 0)
2086 for (y=0; y < (ssize_t) rows; y++)
2088 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2089 if (q == (PixelPacket *) NULL)
2091 for (x=0; x < (ssize_t) columns; x++)
2093 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2095 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2097 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2101 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2106 if (LocaleCompare(map,"BGRA") == 0)
2108 for (y=0; y < (ssize_t) rows; y++)
2110 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2111 if (q == (PixelPacket *) NULL)
2113 for (x=0; x < (ssize_t) columns; x++)
2115 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2117 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2119 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2121 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2126 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2131 if (LocaleCompare(map,"BGRP") == 0)
2133 for (y=0; y < (ssize_t) rows; y++)
2135 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2136 if (q == (PixelPacket *) NULL)
2138 for (x=0; x < (ssize_t) columns; x++)
2140 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2142 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2144 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2149 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2154 if (LocaleCompare(map,"I") == 0)
2156 for (y=0; y < (ssize_t) rows; y++)
2158 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2159 if (q == (PixelPacket *) NULL)
2161 for (x=0; x < (ssize_t) columns; x++)
2163 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2169 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2174 if (LocaleCompare(map,"RGB") == 0)
2176 for (y=0; y < (ssize_t) rows; y++)
2178 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2179 if (q == (PixelPacket *) NULL)
2181 for (x=0; x < (ssize_t) columns; x++)
2183 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2185 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2187 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2191 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2196 if (LocaleCompare(map,"RGBA") == 0)
2198 for (y=0; y < (ssize_t) rows; y++)
2200 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2201 if (q == (PixelPacket *) NULL)
2203 for (x=0; x < (ssize_t) columns; x++)
2205 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2207 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2209 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2211 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2216 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2221 if (LocaleCompare(map,"RGBP") == 0)
2223 for (y=0; y < (ssize_t) rows; y++)
2225 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2226 if (q == (PixelPacket *) NULL)
2228 for (x=0; x < (ssize_t) columns; x++)
2230 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2232 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2234 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2238 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2243 for (y=0; y < (ssize_t) rows; y++)
2245 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2246 if (q == (PixelPacket *) NULL)
2248 indexes=GetAuthenticIndexQueue(image);
2249 for (x=0; x < (ssize_t) columns; x++)
2251 for (i=0; i < (ssize_t) length; i++)
2253 switch (quantum_map[i])
2258 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2262 case MagentaQuantum:
2264 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2270 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2275 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2276 (MagickRealType) QuantumRange*(*p));
2279 case OpacityQuantum:
2281 q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2286 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2291 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2303 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2310 register const float
2313 p=(const float *) pixels;
2314 if (LocaleCompare(map,"BGR") == 0)
2316 for (y=0; y < (ssize_t) rows; y++)
2318 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2319 if (q == (PixelPacket *) NULL)
2321 for (x=0; x < (ssize_t) columns; x++)
2323 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2325 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2327 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2331 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2336 if (LocaleCompare(map,"BGRA") == 0)
2338 for (y=0; y < (ssize_t) rows; y++)
2340 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2341 if (q == (PixelPacket *) NULL)
2343 for (x=0; x < (ssize_t) columns; x++)
2345 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2347 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2349 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2351 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2356 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2361 if (LocaleCompare(map,"BGRP") == 0)
2363 for (y=0; y < (ssize_t) rows; y++)
2365 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2366 if (q == (PixelPacket *) NULL)
2368 for (x=0; x < (ssize_t) columns; x++)
2370 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2372 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2374 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2379 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2384 if (LocaleCompare(map,"I") == 0)
2386 for (y=0; y < (ssize_t) rows; y++)
2388 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2389 if (q == (PixelPacket *) NULL)
2391 for (x=0; x < (ssize_t) columns; x++)
2393 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2399 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2404 if (LocaleCompare(map,"RGB") == 0)
2406 for (y=0; y < (ssize_t) rows; y++)
2408 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2409 if (q == (PixelPacket *) NULL)
2411 for (x=0; x < (ssize_t) columns; x++)
2413 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2415 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2417 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2421 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2426 if (LocaleCompare(map,"RGBA") == 0)
2428 for (y=0; y < (ssize_t) rows; y++)
2430 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2431 if (q == (PixelPacket *) NULL)
2433 for (x=0; x < (ssize_t) columns; x++)
2435 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2437 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2439 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2441 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2446 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2451 if (LocaleCompare(map,"RGBP") == 0)
2453 for (y=0; y < (ssize_t) rows; y++)
2455 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2456 if (q == (PixelPacket *) NULL)
2458 for (x=0; x < (ssize_t) columns; x++)
2460 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2462 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2464 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2468 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2473 for (y=0; y < (ssize_t) rows; y++)
2475 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2476 if (q == (PixelPacket *) NULL)
2478 indexes=GetAuthenticIndexQueue(image);
2479 for (x=0; x < (ssize_t) columns; x++)
2481 for (i=0; i < (ssize_t) length; i++)
2483 switch (quantum_map[i])
2488 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2492 case MagentaQuantum:
2494 q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2500 q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2505 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2506 (MagickRealType) QuantumRange*(*p));
2509 case OpacityQuantum:
2511 q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2516 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2521 q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2533 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2540 register const unsigned int
2543 p=(const unsigned int *) pixels;
2544 if (LocaleCompare(map,"BGR") == 0)
2546 for (y=0; y < (ssize_t) rows; y++)
2548 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2549 if (q == (PixelPacket *) NULL)
2551 for (x=0; x < (ssize_t) columns; x++)
2553 q->blue=ScaleLongToQuantum(*p++);
2554 q->green=ScaleLongToQuantum(*p++);
2555 q->red=ScaleLongToQuantum(*p++);
2558 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2563 if (LocaleCompare(map,"BGRA") == 0)
2565 for (y=0; y < (ssize_t) rows; y++)
2567 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2568 if (q == (PixelPacket *) NULL)
2570 for (x=0; x < (ssize_t) columns; x++)
2572 q->blue=ScaleLongToQuantum(*p++);
2573 q->green=ScaleLongToQuantum(*p++);
2574 q->red=ScaleLongToQuantum(*p++);
2575 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2578 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2583 if (LocaleCompare(map,"BGRP") == 0)
2585 for (y=0; y < (ssize_t) rows; y++)
2587 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2588 if (q == (PixelPacket *) NULL)
2590 for (x=0; x < (ssize_t) columns; x++)
2592 q->blue=ScaleLongToQuantum(*p++);
2593 q->green=ScaleLongToQuantum(*p++);
2594 q->red=ScaleLongToQuantum(*p++);
2598 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2603 if (LocaleCompare(map,"I") == 0)
2605 for (y=0; y < (ssize_t) rows; y++)
2607 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2608 if (q == (PixelPacket *) NULL)
2610 for (x=0; x < (ssize_t) columns; x++)
2612 q->red=ScaleLongToQuantum(*p++);
2617 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2622 if (LocaleCompare(map,"RGB") == 0)
2624 for (y=0; y < (ssize_t) rows; y++)
2626 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2627 if (q == (PixelPacket *) NULL)
2629 for (x=0; x < (ssize_t) columns; x++)
2631 q->red=ScaleLongToQuantum(*p++);
2632 q->green=ScaleLongToQuantum(*p++);
2633 q->blue=ScaleLongToQuantum(*p++);
2636 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2641 if (LocaleCompare(map,"RGBA") == 0)
2643 for (y=0; y < (ssize_t) rows; y++)
2645 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2646 if (q == (PixelPacket *) NULL)
2648 for (x=0; x < (ssize_t) columns; x++)
2650 q->red=ScaleLongToQuantum(*p++);
2651 q->green=ScaleLongToQuantum(*p++);
2652 q->blue=ScaleLongToQuantum(*p++);
2653 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2656 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2661 if (LocaleCompare(map,"RGBP") == 0)
2663 for (y=0; y < (ssize_t) rows; y++)
2665 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2666 if (q == (PixelPacket *) NULL)
2668 for (x=0; x < (ssize_t) columns; x++)
2670 q->red=ScaleLongToQuantum(*p++);
2671 q->green=ScaleLongToQuantum(*p++);
2672 q->blue=ScaleLongToQuantum(*p++);
2676 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2681 for (y=0; y < (ssize_t) rows; y++)
2683 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2684 if (q == (PixelPacket *) NULL)
2686 indexes=GetAuthenticIndexQueue(image);
2687 for (x=0; x < (ssize_t) columns; x++)
2689 for (i=0; i < (ssize_t) length; i++)
2691 switch (quantum_map[i])
2696 q->red=ScaleLongToQuantum(*p);
2700 case MagentaQuantum:
2702 q->green=ScaleLongToQuantum(*p);
2708 q->blue=ScaleLongToQuantum(*p);
2713 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2716 case OpacityQuantum:
2718 q->opacity=ScaleLongToQuantum(*p);
2723 indexes[x]=ScaleLongToQuantum(*p);
2728 q->red=ScaleLongToQuantum(*p);
2740 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2747 register const unsigned int
2750 p=(const unsigned int *) pixels;
2751 if (LocaleCompare(map,"BGR") == 0)
2753 for (y=0; y < (ssize_t) rows; y++)
2755 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2756 if (q == (PixelPacket *) NULL)
2758 for (x=0; x < (ssize_t) columns; x++)
2760 q->blue=ScaleLongToQuantum(*p++);
2761 q->green=ScaleLongToQuantum(*p++);
2762 q->red=ScaleLongToQuantum(*p++);
2765 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2770 if (LocaleCompare(map,"BGRA") == 0)
2772 for (y=0; y < (ssize_t) rows; y++)
2774 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2775 if (q == (PixelPacket *) NULL)
2777 for (x=0; x < (ssize_t) columns; x++)
2779 q->blue=ScaleLongToQuantum(*p++);
2780 q->green=ScaleLongToQuantum(*p++);
2781 q->red=ScaleLongToQuantum(*p++);
2782 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2785 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2790 if (LocaleCompare(map,"BGRP") == 0)
2792 for (y=0; y < (ssize_t) rows; y++)
2794 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2795 if (q == (PixelPacket *) NULL)
2797 for (x=0; x < (ssize_t) columns; x++)
2799 q->blue=ScaleLongToQuantum(*p++);
2800 q->green=ScaleLongToQuantum(*p++);
2801 q->red=ScaleLongToQuantum(*p++);
2805 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2810 if (LocaleCompare(map,"I") == 0)
2812 for (y=0; y < (ssize_t) rows; y++)
2814 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2815 if (q == (PixelPacket *) NULL)
2817 for (x=0; x < (ssize_t) columns; x++)
2819 q->red=ScaleLongToQuantum(*p++);
2824 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2829 if (LocaleCompare(map,"RGB") == 0)
2831 for (y=0; y < (ssize_t) rows; y++)
2833 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2834 if (q == (PixelPacket *) NULL)
2836 for (x=0; x < (ssize_t) columns; x++)
2838 q->red=ScaleLongToQuantum(*p++);
2839 q->green=ScaleLongToQuantum(*p++);
2840 q->blue=ScaleLongToQuantum(*p++);
2843 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2848 if (LocaleCompare(map,"RGBA") == 0)
2850 for (y=0; y < (ssize_t) rows; y++)
2852 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2853 if (q == (PixelPacket *) NULL)
2855 for (x=0; x < (ssize_t) columns; x++)
2857 q->red=ScaleLongToQuantum(*p++);
2858 q->green=ScaleLongToQuantum(*p++);
2859 q->blue=ScaleLongToQuantum(*p++);
2860 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2863 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2868 if (LocaleCompare(map,"RGBP") == 0)
2870 for (y=0; y < (ssize_t) rows; y++)
2872 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2873 if (q == (PixelPacket *) NULL)
2875 for (x=0; x < (ssize_t) columns; x++)
2877 q->red=ScaleLongToQuantum(*p++);
2878 q->green=ScaleLongToQuantum(*p++);
2879 q->blue=ScaleLongToQuantum(*p++);
2883 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2888 for (y=0; y < (ssize_t) rows; y++)
2890 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2891 if (q == (PixelPacket *) NULL)
2893 indexes=GetAuthenticIndexQueue(image);
2894 for (x=0; x < (ssize_t) columns; x++)
2896 for (i=0; i < (ssize_t) length; i++)
2898 switch (quantum_map[i])
2903 q->red=ScaleLongToQuantum(*p);
2907 case MagentaQuantum:
2909 q->green=ScaleLongToQuantum(*p);
2915 q->blue=ScaleLongToQuantum(*p);
2920 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2923 case OpacityQuantum:
2925 q->opacity=ScaleLongToQuantum(*p);
2930 indexes[x]=ScaleLongToQuantum(*p);
2935 q->red=ScaleLongToQuantum(*p);
2947 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2954 register const Quantum
2957 p=(const Quantum *) pixels;
2958 if (LocaleCompare(map,"BGR") == 0)
2960 for (y=0; y < (ssize_t) rows; y++)
2962 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2963 if (q == (PixelPacket *) NULL)
2965 for (x=0; x < (ssize_t) columns; x++)
2972 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2977 if (LocaleCompare(map,"BGRA") == 0)
2979 for (y=0; y < (ssize_t) rows; y++)
2981 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2982 if (q == (PixelPacket *) NULL)
2984 for (x=0; x < (ssize_t) columns; x++)
2989 q->opacity=(Quantum) QuantumRange-(*p++);
2992 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2997 if (LocaleCompare(map,"BGRP") == 0)
2999 for (y=0; y < (ssize_t) rows; y++)
3001 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3002 if (q == (PixelPacket *) NULL)
3004 for (x=0; x < (ssize_t) columns; x++)
3012 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3017 if (LocaleCompare(map,"I") == 0)
3019 for (y=0; y < (ssize_t) rows; y++)
3021 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3022 if (q == (PixelPacket *) NULL)
3024 for (x=0; x < (ssize_t) columns; x++)
3031 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3036 if (LocaleCompare(map,"RGB") == 0)
3038 for (y=0; y < (ssize_t) rows; y++)
3040 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3041 if (q == (PixelPacket *) NULL)
3043 for (x=0; x < (ssize_t) columns; x++)
3050 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3055 if (LocaleCompare(map,"RGBA") == 0)
3057 for (y=0; y < (ssize_t) rows; y++)
3059 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3060 if (q == (PixelPacket *) NULL)
3062 for (x=0; x < (ssize_t) columns; x++)
3067 q->opacity=(Quantum) QuantumRange-(*p++);
3070 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3075 if (LocaleCompare(map,"RGBP") == 0)
3077 for (y=0; y < (ssize_t) rows; y++)
3079 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3080 if (q == (PixelPacket *) NULL)
3082 for (x=0; x < (ssize_t) columns; x++)
3090 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3095 for (y=0; y < (ssize_t) rows; y++)
3097 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3098 if (q == (PixelPacket *) NULL)
3100 indexes=GetAuthenticIndexQueue(image);
3101 for (x=0; x < (ssize_t) columns; x++)
3103 for (i=0; i < (ssize_t) length; i++)
3105 switch (quantum_map[i])
3114 case MagentaQuantum:
3127 q->opacity=(Quantum) QuantumRange-(*p);
3130 case OpacityQuantum:
3154 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3161 register const unsigned short
3164 p=(const unsigned short *) pixels;
3165 if (LocaleCompare(map,"BGR") == 0)
3167 for (y=0; y < (ssize_t) rows; y++)
3169 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3170 if (q == (PixelPacket *) NULL)
3172 for (x=0; x < (ssize_t) columns; x++)
3174 q->blue=ScaleShortToQuantum(*p++);
3175 q->green=ScaleShortToQuantum(*p++);
3176 q->red=ScaleShortToQuantum(*p++);
3179 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3184 if (LocaleCompare(map,"BGRA") == 0)
3186 for (y=0; y < (ssize_t) rows; y++)
3188 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3189 if (q == (PixelPacket *) NULL)
3191 for (x=0; x < (ssize_t) columns; x++)
3193 q->blue=ScaleShortToQuantum(*p++);
3194 q->green=ScaleShortToQuantum(*p++);
3195 q->red=ScaleShortToQuantum(*p++);
3196 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3199 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3204 if (LocaleCompare(map,"BGRP") == 0)
3206 for (y=0; y < (ssize_t) rows; y++)
3208 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3209 if (q == (PixelPacket *) NULL)
3211 for (x=0; x < (ssize_t) columns; x++)
3213 q->blue=ScaleShortToQuantum(*p++);
3214 q->green=ScaleShortToQuantum(*p++);
3215 q->red=ScaleShortToQuantum(*p++);
3219 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3224 if (LocaleCompare(map,"I") == 0)
3226 for (y=0; y < (ssize_t) rows; y++)
3228 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3229 if (q == (PixelPacket *) NULL)
3231 for (x=0; x < (ssize_t) columns; x++)
3233 q->red=ScaleShortToQuantum(*p++);
3238 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3243 if (LocaleCompare(map,"RGB") == 0)
3245 for (y=0; y < (ssize_t) rows; y++)
3247 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3248 if (q == (PixelPacket *) NULL)
3250 for (x=0; x < (ssize_t) columns; x++)
3252 q->red=ScaleShortToQuantum(*p++);
3253 q->green=ScaleShortToQuantum(*p++);
3254 q->blue=ScaleShortToQuantum(*p++);
3257 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3262 if (LocaleCompare(map,"RGBA") == 0)
3264 for (y=0; y < (ssize_t) rows; y++)
3266 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3267 if (q == (PixelPacket *) NULL)
3269 for (x=0; x < (ssize_t) columns; x++)
3271 q->red=ScaleShortToQuantum(*p++);
3272 q->green=ScaleShortToQuantum(*p++);
3273 q->blue=ScaleShortToQuantum(*p++);
3274 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3277 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3282 if (LocaleCompare(map,"RGBP") == 0)
3284 for (y=0; y < (ssize_t) rows; y++)
3286 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3287 if (q == (PixelPacket *) NULL)
3289 for (x=0; x < (ssize_t) columns; x++)
3291 q->red=ScaleShortToQuantum(*p++);
3292 q->green=ScaleShortToQuantum(*p++);
3293 q->blue=ScaleShortToQuantum(*p++);
3297 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3302 for (y=0; y < (ssize_t) rows; y++)
3304 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3305 if (q == (PixelPacket *) NULL)
3307 indexes=GetAuthenticIndexQueue(image);
3308 for (x=0; x < (ssize_t) columns; x++)
3310 for (i=0; i < (ssize_t) length; i++)
3312 switch (quantum_map[i])
3317 q->red=ScaleShortToQuantum(*p);
3321 case MagentaQuantum:
3323 q->green=ScaleShortToQuantum(*p);
3329 q->blue=ScaleShortToQuantum(*p);
3334 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
3337 case OpacityQuantum:
3339 q->opacity=ScaleShortToQuantum(*p);
3344 indexes[x]=ScaleShortToQuantum(*p);
3349 q->red=ScaleShortToQuantum(*p);
3361 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3368 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3369 (void) ThrowMagickException(&image->exception,GetMagickModule(),
3370 OptionError,"UnrecognizedPixelMap","`%s'",map);
3374 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3379 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3383 % 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 %
3387 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3389 % InterpolateMagickPixelPacket() applies bi-linear or tri-linear interpolation
3390 % between a floating point coordinate and the pixels surrounding that
3391 % coordinate. No pixel area resampling, or scaling of the result is
3394 % The format of the InterpolateMagickPixelPacket method is:
3396 % MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
3397 % const CacheView *image_view,const InterpolatePixelMethod method,
3398 % const double x,const double y,MagickPixelPacket *pixel,
3399 % ExceptionInfo *exception)
3401 % A description of each parameter follows:
3403 % o image: the image.
3405 % o image_view: the image view.
3407 % o method: the pixel color interpolation method.
3409 % o x,y: A double representing the current (x,y) position of the pixel.
3411 % o pixel: return the interpolated pixel here.
3413 % o exception: return any errors or warnings in this structure.
3417 static inline double MagickMax(const MagickRealType x,const MagickRealType y)
3424 static void BicubicInterpolate(const MagickPixelPacket *pixels,const double dx,
3425 MagickPixelPacket *pixel)
3435 p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
3436 q=(pixels[0].red-pixels[1].red)-p;
3437 r=pixels[2].red-pixels[0].red;
3439 pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3440 p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
3441 q=(pixels[0].green-pixels[1].green)-p;
3442 r=pixels[2].green-pixels[0].green;
3444 pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3445 p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
3446 q=(pixels[0].blue-pixels[1].blue)-p;
3447 r=pixels[2].blue-pixels[0].blue;
3449 pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3450 p=(pixels[3].opacity-pixels[2].opacity)-(pixels[0].opacity-pixels[1].opacity);
3451 q=(pixels[0].opacity-pixels[1].opacity)-p;
3452 r=pixels[2].opacity-pixels[0].opacity;
3453 s=pixels[1].opacity;
3454 pixel->opacity=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3455 if (pixel->colorspace == CMYKColorspace)
3457 p=(pixels[3].index-pixels[2].index)-(pixels[0].index-pixels[1].index);
3458 q=(pixels[0].index-pixels[1].index)-p;
3459 r=pixels[2].index-pixels[0].index;
3461 pixel->index=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3465 static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
3471 alpha=MagickMax(x+2.0,0.0);
3472 gamma=1.0*alpha*alpha*alpha;
3473 alpha=MagickMax(x+1.0,0.0);
3474 gamma-=4.0*alpha*alpha*alpha;
3475 alpha=MagickMax(x+0.0,0.0);
3476 gamma+=6.0*alpha*alpha*alpha;
3477 alpha=MagickMax(x-1.0,0.0);
3478 gamma-=4.0*alpha*alpha*alpha;
3482 static inline double MeshInterpolate(const PointInfo *delta,const double p,
3483 const double x,const double y)
3485 return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3488 static inline ssize_t NearestNeighbor(const MagickRealType x)
3491 return((ssize_t) (x+0.5));
3492 return((ssize_t) (x-0.5));
3495 MagickExport MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
3496 const CacheView *image_view,const InterpolatePixelMethod method,
3497 const double x,const double y,MagickPixelPacket *pixel,
3498 ExceptionInfo *exception)
3503 register const IndexPacket
3506 register const PixelPacket
3512 assert(image != (Image *) NULL);
3513 assert(image->signature == MagickSignature);
3514 assert(image_view != (CacheView *) NULL);
3516 switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
3518 case AverageInterpolatePixel:
3527 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,
3528 (ssize_t) floor(y)-1,4,4,exception);
3529 if (p == (const PixelPacket *) NULL)
3534 indexes=GetCacheViewVirtualIndexQueue(image_view);
3535 for (i=0; i < 16L; i++)
3537 GetMagickPixelPacket(image,pixels+i);
3538 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
3540 if (pixels[i].matte != MagickFalse)
3542 alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
3543 pixels[i].red*=alpha[i];
3544 pixels[i].green*=alpha[i];
3545 pixels[i].blue*=alpha[i];
3546 if (pixels[i].colorspace == CMYKColorspace)
3547 pixels[i].index*=alpha[i];
3550 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3551 pixel->red+=gamma*0.0625*pixels[i].red;
3552 pixel->green+=gamma*0.0625*pixels[i].green;
3553 pixel->blue+=gamma*0.0625*pixels[i].blue;
3554 pixel->opacity+=0.0625*pixels[i].opacity;
3555 if (pixel->colorspace == CMYKColorspace)
3556 pixel->index+=gamma*0.0625*pixels[i].index;
3561 case BicubicInterpolatePixel:
3573 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t)
3574 floor(y)-1,4,4,exception);
3575 if (p == (const PixelPacket *) NULL)
3580 indexes=GetCacheViewVirtualIndexQueue(image_view);
3581 for (i=0; i < 16L; i++)
3583 GetMagickPixelPacket(image,pixels+i);
3584 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
3586 if (pixels[i].matte != MagickFalse)
3588 alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
3589 pixels[i].red*=alpha[i];
3590 pixels[i].green*=alpha[i];
3591 pixels[i].blue*=alpha[i];
3592 if (pixels[i].colorspace == CMYKColorspace)
3593 pixels[i].index*=alpha[i];
3598 for (i=0; i < 4L; i++)
3599 BicubicInterpolate(pixels+4*i,delta.x,u+i);
3601 BicubicInterpolate(u,delta.y,pixel);
3604 case BilinearInterpolatePixel:
3618 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
3619 floor(y),2,2,exception);
3620 if (p == (const PixelPacket *) NULL)
3625 indexes=GetCacheViewVirtualIndexQueue(image_view);
3626 for (i=0; i < 4L; i++)
3628 GetMagickPixelPacket(image,pixels+i);
3629 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
3631 if (pixels[i].matte != MagickFalse)
3633 alpha[i]=QuantumScale*((MagickRealType) QuantumRange-p[i].opacity);
3634 pixels[i].red*=alpha[i];
3635 pixels[i].green*=alpha[i];
3636 pixels[i].blue*=alpha[i];
3638 if (indexes != (IndexPacket *) NULL)
3640 pixels[i].index=(MagickRealType) indexes[i];
3641 if (pixels[i].colorspace == CMYKColorspace)
3642 pixels[i].index*=alpha[i];
3648 epsilon.x=1.0-delta.x;
3649 epsilon.y=1.0-delta.y;
3650 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
3651 (epsilon.x*alpha[2]+delta.x*alpha[3])));
3652 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3653 pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
3654 pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
3655 pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
3656 pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
3658 pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
3659 pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
3661 pixel->opacity=(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
3662 pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x*
3663 pixels[3].opacity));
3664 if (pixel->colorspace == CMYKColorspace)
3665 pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
3666 pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x*
3670 case FilterInterpolatePixel:
3687 geometry.x=(ssize_t) floor(x)-1L;
3688 geometry.y=(ssize_t) floor(y)-1L;
3689 excerpt_image=ExcerptImage(image,&geometry,exception);
3690 if (excerpt_image == (Image *) NULL)
3695 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
3697 excerpt_image=DestroyImage(excerpt_image);
3698 if (filter_image == (Image *) NULL)
3700 filter_view=AcquireCacheView(filter_image);
3701 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
3702 if (p != (const PixelPacket *) NULL)
3704 indexes=GetVirtualIndexQueue(filter_image);
3705 GetMagickPixelPacket(image,pixels);
3706 SetMagickPixelPacket(image,p,indexes,pixel);
3708 filter_view=DestroyCacheView(filter_view);
3709 filter_image=DestroyImage(filter_image);
3712 case IntegerInterpolatePixel:
3717 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
3718 floor(y),1,1,exception);
3719 if (p == (const PixelPacket *) NULL)
3724 indexes=GetCacheViewVirtualIndexQueue(image_view);
3725 GetMagickPixelPacket(image,pixels);
3726 SetMagickPixelPacket(image,p,indexes,pixel);
3729 case MeshInterpolatePixel:
3742 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x),(ssize_t)
3743 floor(y),2,2,exception);
3744 if (p == (const PixelPacket *) NULL)
3749 indexes=GetCacheViewVirtualIndexQueue(image_view);
3750 for (i=0; i < 4L; i++)
3752 GetMagickPixelPacket(image,pixels+i);
3753 SetMagickPixelPacket(image,p,indexes+i,pixels+i);
3755 if (pixels[i].matte != MagickFalse)
3757 alpha[i]=QuantumScale*((MagickRealType) GetAlphaPixelComponent(p));
3758 pixels[i].red*=alpha[i];
3759 pixels[i].green*=alpha[i];
3760 pixels[i].blue*=alpha[i];
3761 if (pixels[i].colorspace == CMYKColorspace)
3762 pixels[i].index*=alpha[i];
3768 luminance.x=MagickPixelLuminance(pixels+0)-MagickPixelLuminance(pixels+3);
3769 luminance.y=MagickPixelLuminance(pixels+1)-MagickPixelLuminance(pixels+2);
3770 if (fabs(luminance.x) < fabs(luminance.y))
3775 if (delta.x <= delta.y)
3778 Bottom-left triangle (pixel:2, diagonal: 0-3).
3780 delta.y=1.0-delta.y;
3781 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
3782 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3783 pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
3784 pixels[3].red,pixels[0].red);
3785 pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
3786 pixels[3].green,pixels[0].green);
3787 pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
3788 pixels[3].blue,pixels[0].blue);
3789 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
3790 pixels[3].opacity,pixels[0].opacity);
3791 if (pixel->colorspace == CMYKColorspace)
3792 pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
3793 pixels[3].index,pixels[0].index);
3798 Top-right triangle (pixel:1, diagonal: 0-3).
3800 delta.x=1.0-delta.x;
3801 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
3802 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3803 pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
3804 pixels[0].red,pixels[3].red);
3805 pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
3806 pixels[0].green,pixels[3].green);
3807 pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
3808 pixels[0].blue,pixels[3].blue);
3809 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
3810 pixels[0].opacity,pixels[3].opacity);
3811 if (pixel->colorspace == CMYKColorspace)
3812 pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
3813 pixels[0].index,pixels[3].index);
3821 if (delta.x <= (1.0-delta.y))
3824 Top-left triangle (pixel 0, diagonal: 1-2).
3826 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
3827 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3828 pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
3829 pixels[1].red,pixels[2].red);
3830 pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
3831 pixels[1].green,pixels[2].green);
3832 pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
3833 pixels[1].blue,pixels[2].blue);
3834 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
3835 pixels[1].opacity,pixels[2].opacity);
3836 if (pixel->colorspace == CMYKColorspace)
3837 pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
3838 pixels[1].index,pixels[2].index);
3843 Bottom-right triangle (pixel: 3, diagonal: 1-2).
3845 delta.x=1.0-delta.x;
3846 delta.y=1.0-delta.y;
3847 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
3848 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3849 pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
3850 pixels[2].red,pixels[1].red);
3851 pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
3852 pixels[2].green,pixels[1].green);
3853 pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
3854 pixels[2].blue,pixels[1].blue);
3855 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
3856 pixels[2].opacity,pixels[1].opacity);
3857 if (pixel->colorspace == CMYKColorspace)
3858 pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
3859 pixels[2].index,pixels[1].index);
3864 case NearestNeighborInterpolatePixel:
3869 p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
3870 NearestNeighbor(y),1,1,exception);
3871 if (p == (const PixelPacket *) NULL)
3876 indexes=GetCacheViewVirtualIndexQueue(image_view);
3877 GetMagickPixelPacket(image,pixels);
3878 SetMagickPixelPacket(image,p,indexes,pixel);
3881 case SplineInterpolatePixel:
3899 p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x)-1,(ssize_t)
3900 floor(y)-1,4,4,exception);
3901 if (p == (const PixelPacket *) NULL)
3906 indexes=GetCacheViewVirtualIndexQueue(image_view);
3910 for (i=(-1); i < 3L; i++)
3912 dy=CubicWeightingFunction((MagickRealType) i-delta.y);
3913 for (j=(-1); j < 3L; j++)
3915 GetMagickPixelPacket(image,pixels+n);
3916 SetMagickPixelPacket(image,p,indexes+n,pixels+n);
3918 if (pixels[i].matte != MagickFalse)
3920 alpha[n]=QuantumScale*((MagickRealType)
3921 GetAlphaPixelComponent(p));
3922 pixels[n].red*=alpha[n];
3923 pixels[n].green*=alpha[n];
3924 pixels[n].blue*=alpha[n];
3925 if (pixels[i].colorspace == CMYKColorspace)
3926 pixels[n].index*=alpha[n];
3928 dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
3930 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3931 pixel->red+=gamma*dx*dy*pixels[n].red;
3932 pixel->green+=gamma*dx*dy*pixels[n].green;
3933 pixel->blue+=gamma*dx*dy*pixels[n].blue;
3934 if (pixel->matte != MagickFalse)
3935 pixel->opacity+=dx*dy*pixels[n].opacity;
3936 if (pixel->colorspace == CMYKColorspace)
3937 pixel->index+=gamma*dx*dy*pixels[n].index;