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 SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1847 SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1848 SetRedPixelComponent(q,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 SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1866 SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1867 SetRedPixelComponent(q,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 SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1886 SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1887 SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1888 SetOpacityPixelComponent(q,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 SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1906 SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1907 SetRedPixelComponent(q,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 SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1926 SetGreenPixelComponent(q,GetRedPixelComponent(q));
1927 SetBluePixelComponent(q,GetRedPixelComponent(q));
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 SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1945 SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1946 SetBluePixelComponent(q,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 SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1964 SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1965 SetBluePixelComponent(q,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 SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
1984 SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
1985 SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
1986 SetOpacityPixelComponent(q,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 SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
2004 SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
2005 SetBluePixelComponent(q,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 SetRedPixelComponent(q,ScaleCharToQuantum(*p));
2033 case MagentaQuantum:
2035 SetGreenPixelComponent(q,ScaleCharToQuantum(*p));
2041 SetBluePixelComponent(q,ScaleCharToQuantum(*p));
2046 q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
2049 case OpacityQuantum:
2051 SetOpacityPixelComponent(q,ScaleCharToQuantum(*p));
2056 SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(*p));
2061 SetRedPixelComponent(q,ScaleCharToQuantum(*p));
2062 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2063 SetBluePixelComponent(q,GetRedPixelComponent(q));
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 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2094 QuantumRange*(*p)));
2096 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2097 QuantumRange*(*p)));
2099 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2100 QuantumRange*(*p)));
2104 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2109 if (LocaleCompare(map,"BGRA") == 0)
2111 for (y=0; y < (ssize_t) rows; y++)
2113 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2114 if (q == (PixelPacket *) NULL)
2116 for (x=0; x < (ssize_t) columns; x++)
2118 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2119 QuantumRange*(*p)));
2121 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2122 QuantumRange*(*p)));
2124 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2125 QuantumRange*(*p)));
2127 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2132 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2137 if (LocaleCompare(map,"BGRP") == 0)
2139 for (y=0; y < (ssize_t) rows; y++)
2141 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2142 if (q == (PixelPacket *) NULL)
2144 for (x=0; x < (ssize_t) columns; x++)
2146 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2147 QuantumRange*(*p)));
2149 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2150 QuantumRange*(*p)));
2152 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2153 QuantumRange*(*p)));
2158 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2163 if (LocaleCompare(map,"I") == 0)
2165 for (y=0; y < (ssize_t) rows; y++)
2167 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2168 if (q == (PixelPacket *) NULL)
2170 for (x=0; x < (ssize_t) columns; x++)
2172 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2173 QuantumRange*(*p)));
2174 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2175 SetBluePixelComponent(q,GetRedPixelComponent(q));
2179 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2184 if (LocaleCompare(map,"RGB") == 0)
2186 for (y=0; y < (ssize_t) rows; y++)
2188 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2189 if (q == (PixelPacket *) NULL)
2191 for (x=0; x < (ssize_t) columns; x++)
2193 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2194 QuantumRange*(*p)));
2196 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2198 SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2202 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2207 if (LocaleCompare(map,"RGBA") == 0)
2209 for (y=0; y < (ssize_t) rows; y++)
2211 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2212 if (q == (PixelPacket *) NULL)
2214 for (x=0; x < (ssize_t) columns; x++)
2216 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2217 QuantumRange*(*p)));
2219 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2220 QuantumRange*(*p)));
2222 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2223 QuantumRange*(*p)));
2225 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2230 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2235 if (LocaleCompare(map,"RGBP") == 0)
2237 for (y=0; y < (ssize_t) rows; y++)
2239 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2240 if (q == (PixelPacket *) NULL)
2242 for (x=0; x < (ssize_t) columns; x++)
2244 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2245 QuantumRange*(*p)));
2247 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2248 QuantumRange*(*p)));
2250 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2251 QuantumRange*(*p)));
2255 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2260 for (y=0; y < (ssize_t) rows; y++)
2262 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2263 if (q == (PixelPacket *) NULL)
2265 indexes=GetAuthenticIndexQueue(image);
2266 for (x=0; x < (ssize_t) columns; x++)
2268 for (i=0; i < (ssize_t) length; i++)
2270 switch (quantum_map[i])
2275 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2276 QuantumRange*(*p)));
2280 case MagentaQuantum:
2282 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2283 QuantumRange*(*p)));
2289 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2290 QuantumRange*(*p)));
2295 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2296 (MagickRealType) QuantumRange*(*p));
2299 case OpacityQuantum:
2301 SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
2302 QuantumRange*(*p)));
2307 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2312 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2313 QuantumRange*(*p)));
2314 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2315 SetBluePixelComponent(q,GetRedPixelComponent(q));
2325 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2332 register const float
2335 p=(const float *) pixels;
2336 if (LocaleCompare(map,"BGR") == 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 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2346 QuantumRange*(*p)));
2348 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2349 QuantumRange*(*p)));
2351 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2352 QuantumRange*(*p)));
2356 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2361 if (LocaleCompare(map,"BGRA") == 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 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2371 QuantumRange*(*p)));
2373 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2374 QuantumRange*(*p)));
2376 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2377 QuantumRange*(*p)));
2379 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2384 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2389 if (LocaleCompare(map,"BGRP") == 0)
2391 for (y=0; y < (ssize_t) rows; y++)
2393 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2394 if (q == (PixelPacket *) NULL)
2396 for (x=0; x < (ssize_t) columns; x++)
2398 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2399 QuantumRange*(*p)));
2401 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2402 QuantumRange*(*p)));
2404 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2405 QuantumRange*(*p)));
2410 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2415 if (LocaleCompare(map,"I") == 0)
2417 for (y=0; y < (ssize_t) rows; y++)
2419 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2420 if (q == (PixelPacket *) NULL)
2422 for (x=0; x < (ssize_t) columns; x++)
2424 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2425 QuantumRange*(*p)));
2426 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2427 SetBluePixelComponent(q,GetRedPixelComponent(q));
2431 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2436 if (LocaleCompare(map,"RGB") == 0)
2438 for (y=0; y < (ssize_t) rows; y++)
2440 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2441 if (q == (PixelPacket *) NULL)
2443 for (x=0; x < (ssize_t) columns; x++)
2445 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2446 QuantumRange*(*p)));
2448 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2449 QuantumRange*(*p)));
2451 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2452 QuantumRange*(*p)));
2456 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2461 if (LocaleCompare(map,"RGBA") == 0)
2463 for (y=0; y < (ssize_t) rows; y++)
2465 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2466 if (q == (PixelPacket *) NULL)
2468 for (x=0; x < (ssize_t) columns; x++)
2470 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2471 QuantumRange*(*p)));
2473 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2474 QuantumRange*(*p)));
2476 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2477 QuantumRange*(*p)));
2479 q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
2484 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2489 if (LocaleCompare(map,"RGBP") == 0)
2491 for (y=0; y < (ssize_t) rows; y++)
2493 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2494 if (q == (PixelPacket *) NULL)
2496 for (x=0; x < (ssize_t) columns; x++)
2498 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2499 QuantumRange*(*p)));
2501 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2502 QuantumRange*(*p)));
2504 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2505 QuantumRange*(*p)));
2509 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2514 for (y=0; y < (ssize_t) rows; y++)
2516 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2517 if (q == (PixelPacket *) NULL)
2519 indexes=GetAuthenticIndexQueue(image);
2520 for (x=0; x < (ssize_t) columns; x++)
2522 for (i=0; i < (ssize_t) length; i++)
2524 switch (quantum_map[i])
2529 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2530 QuantumRange*(*p)));
2534 case MagentaQuantum:
2536 SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
2537 QuantumRange*(*p)));
2543 SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
2544 QuantumRange*(*p)));
2549 q->opacity=(Quantum) QuantumRange-ClampToQuantum(
2550 (MagickRealType) QuantumRange*(*p));
2553 case OpacityQuantum:
2555 SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
2556 QuantumRange*(*p)));
2561 indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
2566 SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
2567 QuantumRange*(*p)));
2568 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2569 SetBluePixelComponent(q,GetRedPixelComponent(q));
2579 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2586 register const unsigned int
2589 p=(const unsigned int *) pixels;
2590 if (LocaleCompare(map,"BGR") == 0)
2592 for (y=0; y < (ssize_t) rows; y++)
2594 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2595 if (q == (PixelPacket *) NULL)
2597 for (x=0; x < (ssize_t) columns; x++)
2599 q->blue=ScaleLongToQuantum(*p++);
2600 q->green=ScaleLongToQuantum(*p++);
2601 q->red=ScaleLongToQuantum(*p++);
2604 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2609 if (LocaleCompare(map,"BGRA") == 0)
2611 for (y=0; y < (ssize_t) rows; y++)
2613 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2614 if (q == (PixelPacket *) NULL)
2616 for (x=0; x < (ssize_t) columns; x++)
2618 q->blue=ScaleLongToQuantum(*p++);
2619 q->green=ScaleLongToQuantum(*p++);
2620 q->red=ScaleLongToQuantum(*p++);
2621 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2624 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2629 if (LocaleCompare(map,"BGRP") == 0)
2631 for (y=0; y < (ssize_t) rows; y++)
2633 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2634 if (q == (PixelPacket *) NULL)
2636 for (x=0; x < (ssize_t) columns; x++)
2638 q->blue=ScaleLongToQuantum(*p++);
2639 q->green=ScaleLongToQuantum(*p++);
2640 q->red=ScaleLongToQuantum(*p++);
2644 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2649 if (LocaleCompare(map,"I") == 0)
2651 for (y=0; y < (ssize_t) rows; y++)
2653 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2654 if (q == (PixelPacket *) NULL)
2656 for (x=0; x < (ssize_t) columns; x++)
2658 q->red=ScaleLongToQuantum(*p++);
2659 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2660 SetBluePixelComponent(q,GetRedPixelComponent(q));
2663 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2668 if (LocaleCompare(map,"RGB") == 0)
2670 for (y=0; y < (ssize_t) rows; y++)
2672 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2673 if (q == (PixelPacket *) NULL)
2675 for (x=0; x < (ssize_t) columns; x++)
2677 q->red=ScaleLongToQuantum(*p++);
2678 q->green=ScaleLongToQuantum(*p++);
2679 q->blue=ScaleLongToQuantum(*p++);
2682 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2687 if (LocaleCompare(map,"RGBA") == 0)
2689 for (y=0; y < (ssize_t) rows; y++)
2691 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2692 if (q == (PixelPacket *) NULL)
2694 for (x=0; x < (ssize_t) columns; x++)
2696 q->red=ScaleLongToQuantum(*p++);
2697 q->green=ScaleLongToQuantum(*p++);
2698 q->blue=ScaleLongToQuantum(*p++);
2699 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2702 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2707 if (LocaleCompare(map,"RGBP") == 0)
2709 for (y=0; y < (ssize_t) rows; y++)
2711 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2712 if (q == (PixelPacket *) NULL)
2714 for (x=0; x < (ssize_t) columns; x++)
2716 q->red=ScaleLongToQuantum(*p++);
2717 q->green=ScaleLongToQuantum(*p++);
2718 q->blue=ScaleLongToQuantum(*p++);
2722 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2727 for (y=0; y < (ssize_t) rows; y++)
2729 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2730 if (q == (PixelPacket *) NULL)
2732 indexes=GetAuthenticIndexQueue(image);
2733 for (x=0; x < (ssize_t) columns; x++)
2735 for (i=0; i < (ssize_t) length; i++)
2737 switch (quantum_map[i])
2742 q->red=ScaleLongToQuantum(*p);
2746 case MagentaQuantum:
2748 q->green=ScaleLongToQuantum(*p);
2754 q->blue=ScaleLongToQuantum(*p);
2759 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2762 case OpacityQuantum:
2764 q->opacity=ScaleLongToQuantum(*p);
2769 indexes[x]=ScaleLongToQuantum(*p);
2774 q->red=ScaleLongToQuantum(*p);
2775 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2776 SetBluePixelComponent(q,GetRedPixelComponent(q));
2786 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2793 register const unsigned int
2796 p=(const unsigned int *) pixels;
2797 if (LocaleCompare(map,"BGR") == 0)
2799 for (y=0; y < (ssize_t) rows; y++)
2801 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2802 if (q == (PixelPacket *) NULL)
2804 for (x=0; x < (ssize_t) columns; x++)
2806 q->blue=ScaleLongToQuantum(*p++);
2807 q->green=ScaleLongToQuantum(*p++);
2808 q->red=ScaleLongToQuantum(*p++);
2811 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2816 if (LocaleCompare(map,"BGRA") == 0)
2818 for (y=0; y < (ssize_t) rows; y++)
2820 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2821 if (q == (PixelPacket *) NULL)
2823 for (x=0; x < (ssize_t) columns; x++)
2825 q->blue=ScaleLongToQuantum(*p++);
2826 q->green=ScaleLongToQuantum(*p++);
2827 q->red=ScaleLongToQuantum(*p++);
2828 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2831 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2836 if (LocaleCompare(map,"BGRP") == 0)
2838 for (y=0; y < (ssize_t) rows; y++)
2840 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2841 if (q == (PixelPacket *) NULL)
2843 for (x=0; x < (ssize_t) columns; x++)
2845 q->blue=ScaleLongToQuantum(*p++);
2846 q->green=ScaleLongToQuantum(*p++);
2847 q->red=ScaleLongToQuantum(*p++);
2851 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2856 if (LocaleCompare(map,"I") == 0)
2858 for (y=0; y < (ssize_t) rows; y++)
2860 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2861 if (q == (PixelPacket *) NULL)
2863 for (x=0; x < (ssize_t) columns; x++)
2865 q->red=ScaleLongToQuantum(*p++);
2866 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2867 SetBluePixelComponent(q,GetRedPixelComponent(q));
2870 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2875 if (LocaleCompare(map,"RGB") == 0)
2877 for (y=0; y < (ssize_t) rows; y++)
2879 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2880 if (q == (PixelPacket *) NULL)
2882 for (x=0; x < (ssize_t) columns; x++)
2884 q->red=ScaleLongToQuantum(*p++);
2885 q->green=ScaleLongToQuantum(*p++);
2886 q->blue=ScaleLongToQuantum(*p++);
2889 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2894 if (LocaleCompare(map,"RGBA") == 0)
2896 for (y=0; y < (ssize_t) rows; y++)
2898 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2899 if (q == (PixelPacket *) NULL)
2901 for (x=0; x < (ssize_t) columns; x++)
2903 q->red=ScaleLongToQuantum(*p++);
2904 q->green=ScaleLongToQuantum(*p++);
2905 q->blue=ScaleLongToQuantum(*p++);
2906 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p++);
2909 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2914 if (LocaleCompare(map,"RGBP") == 0)
2916 for (y=0; y < (ssize_t) rows; y++)
2918 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2919 if (q == (PixelPacket *) NULL)
2921 for (x=0; x < (ssize_t) columns; x++)
2923 q->red=ScaleLongToQuantum(*p++);
2924 q->green=ScaleLongToQuantum(*p++);
2925 q->blue=ScaleLongToQuantum(*p++);
2929 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2934 for (y=0; y < (ssize_t) rows; y++)
2936 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2937 if (q == (PixelPacket *) NULL)
2939 indexes=GetAuthenticIndexQueue(image);
2940 for (x=0; x < (ssize_t) columns; x++)
2942 for (i=0; i < (ssize_t) length; i++)
2944 switch (quantum_map[i])
2949 q->red=ScaleLongToQuantum(*p);
2953 case MagentaQuantum:
2955 q->green=ScaleLongToQuantum(*p);
2961 q->blue=ScaleLongToQuantum(*p);
2966 q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
2969 case OpacityQuantum:
2971 q->opacity=ScaleLongToQuantum(*p);
2976 indexes[x]=ScaleLongToQuantum(*p);
2981 q->red=ScaleLongToQuantum(*p);
2982 SetGreenPixelComponent(q,GetRedPixelComponent(q));
2983 SetBluePixelComponent(q,GetRedPixelComponent(q));
2993 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3000 register const Quantum
3003 p=(const Quantum *) pixels;
3004 if (LocaleCompare(map,"BGR") == 0)
3006 for (y=0; y < (ssize_t) rows; y++)
3008 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3009 if (q == (PixelPacket *) NULL)
3011 for (x=0; x < (ssize_t) columns; x++)
3018 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3023 if (LocaleCompare(map,"BGRA") == 0)
3025 for (y=0; y < (ssize_t) rows; y++)
3027 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3028 if (q == (PixelPacket *) NULL)
3030 for (x=0; x < (ssize_t) columns; x++)
3035 q->opacity=(Quantum) QuantumRange-(*p++);
3038 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3043 if (LocaleCompare(map,"BGRP") == 0)
3045 for (y=0; y < (ssize_t) rows; y++)
3047 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3048 if (q == (PixelPacket *) NULL)
3050 for (x=0; x < (ssize_t) columns; x++)
3058 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3063 if (LocaleCompare(map,"I") == 0)
3065 for (y=0; y < (ssize_t) rows; y++)
3067 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3068 if (q == (PixelPacket *) NULL)
3070 for (x=0; x < (ssize_t) columns; x++)
3073 SetGreenPixelComponent(q,GetRedPixelComponent(q));
3074 SetBluePixelComponent(q,GetRedPixelComponent(q));
3077 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3082 if (LocaleCompare(map,"RGB") == 0)
3084 for (y=0; y < (ssize_t) rows; y++)
3086 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3087 if (q == (PixelPacket *) NULL)
3089 for (x=0; x < (ssize_t) columns; x++)
3096 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3101 if (LocaleCompare(map,"RGBA") == 0)
3103 for (y=0; y < (ssize_t) rows; y++)
3105 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3106 if (q == (PixelPacket *) NULL)
3108 for (x=0; x < (ssize_t) columns; x++)
3113 q->opacity=(Quantum) QuantumRange-(*p++);
3116 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3121 if (LocaleCompare(map,"RGBP") == 0)
3123 for (y=0; y < (ssize_t) rows; y++)
3125 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3126 if (q == (PixelPacket *) NULL)
3128 for (x=0; x < (ssize_t) columns; x++)
3136 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3141 for (y=0; y < (ssize_t) rows; y++)
3143 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3144 if (q == (PixelPacket *) NULL)
3146 indexes=GetAuthenticIndexQueue(image);
3147 for (x=0; x < (ssize_t) columns; x++)
3149 for (i=0; i < (ssize_t) length; i++)
3151 switch (quantum_map[i])
3160 case MagentaQuantum:
3173 q->opacity=(Quantum) QuantumRange-(*p);
3176 case OpacityQuantum:
3189 SetGreenPixelComponent(q,GetRedPixelComponent(q));
3190 SetBluePixelComponent(q,GetRedPixelComponent(q));
3200 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3207 register const unsigned short
3210 p=(const unsigned short *) pixels;
3211 if (LocaleCompare(map,"BGR") == 0)
3213 for (y=0; y < (ssize_t) rows; y++)
3215 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3216 if (q == (PixelPacket *) NULL)
3218 for (x=0; x < (ssize_t) columns; x++)
3220 q->blue=ScaleShortToQuantum(*p++);
3221 q->green=ScaleShortToQuantum(*p++);
3222 q->red=ScaleShortToQuantum(*p++);
3225 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3230 if (LocaleCompare(map,"BGRA") == 0)
3232 for (y=0; y < (ssize_t) rows; y++)
3234 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3235 if (q == (PixelPacket *) NULL)
3237 for (x=0; x < (ssize_t) columns; x++)
3239 q->blue=ScaleShortToQuantum(*p++);
3240 q->green=ScaleShortToQuantum(*p++);
3241 q->red=ScaleShortToQuantum(*p++);
3242 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3245 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3250 if (LocaleCompare(map,"BGRP") == 0)
3252 for (y=0; y < (ssize_t) rows; y++)
3254 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3255 if (q == (PixelPacket *) NULL)
3257 for (x=0; x < (ssize_t) columns; x++)
3259 q->blue=ScaleShortToQuantum(*p++);
3260 q->green=ScaleShortToQuantum(*p++);
3261 q->red=ScaleShortToQuantum(*p++);
3265 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3270 if (LocaleCompare(map,"I") == 0)
3272 for (y=0; y < (ssize_t) rows; y++)
3274 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3275 if (q == (PixelPacket *) NULL)
3277 for (x=0; x < (ssize_t) columns; x++)
3279 q->red=ScaleShortToQuantum(*p++);
3280 SetGreenPixelComponent(q,GetRedPixelComponent(q));
3281 SetBluePixelComponent(q,GetRedPixelComponent(q));
3284 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3289 if (LocaleCompare(map,"RGB") == 0)
3291 for (y=0; y < (ssize_t) rows; y++)
3293 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3294 if (q == (PixelPacket *) NULL)
3296 for (x=0; x < (ssize_t) columns; x++)
3298 q->red=ScaleShortToQuantum(*p++);
3299 q->green=ScaleShortToQuantum(*p++);
3300 q->blue=ScaleShortToQuantum(*p++);
3303 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3308 if (LocaleCompare(map,"RGBA") == 0)
3310 for (y=0; y < (ssize_t) rows; y++)
3312 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3313 if (q == (PixelPacket *) NULL)
3315 for (x=0; x < (ssize_t) columns; x++)
3317 q->red=ScaleShortToQuantum(*p++);
3318 q->green=ScaleShortToQuantum(*p++);
3319 q->blue=ScaleShortToQuantum(*p++);
3320 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p++);
3323 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3328 if (LocaleCompare(map,"RGBP") == 0)
3330 for (y=0; y < (ssize_t) rows; y++)
3332 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3333 if (q == (PixelPacket *) NULL)
3335 for (x=0; x < (ssize_t) columns; x++)
3337 q->red=ScaleShortToQuantum(*p++);
3338 q->green=ScaleShortToQuantum(*p++);
3339 q->blue=ScaleShortToQuantum(*p++);
3343 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3348 for (y=0; y < (ssize_t) rows; y++)
3350 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3351 if (q == (PixelPacket *) NULL)
3353 indexes=GetAuthenticIndexQueue(image);
3354 for (x=0; x < (ssize_t) columns; x++)
3356 for (i=0; i < (ssize_t) length; i++)
3358 switch (quantum_map[i])
3363 q->red=ScaleShortToQuantum(*p);
3367 case MagentaQuantum:
3369 q->green=ScaleShortToQuantum(*p);
3375 q->blue=ScaleShortToQuantum(*p);
3380 q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
3383 case OpacityQuantum:
3385 q->opacity=ScaleShortToQuantum(*p);
3390 indexes[x]=ScaleShortToQuantum(*p);
3395 q->red=ScaleShortToQuantum(*p);
3396 SetGreenPixelComponent(q,GetRedPixelComponent(q));
3397 SetBluePixelComponent(q,GetRedPixelComponent(q));
3407 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3414 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3415 (void) ThrowMagickException(&image->exception,GetMagickModule(),
3416 OptionError,"UnrecognizedPixelMap","`%s'",map);
3420 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3425 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3429 % I n t e r p o l a t e M a g i c k P i x e l P a c k e t %
3433 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3435 % InterpolateMagickPixelPacket() applies bi-linear or tri-linear interpolation
3436 % between a floating point coordinate and the pixels surrounding that
3437 % coordinate. No pixel area resampling, or scaling of the result is
3440 % The format of the InterpolateMagickPixelPacket method is:
3442 % MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
3443 % const CacheView *image_view,const InterpolatePixelMethod method,
3444 % const double x,const double y,MagickPixelPacket *pixel,
3445 % ExceptionInfo *exception)
3447 % A description of each parameter follows:
3449 % o image: the image.
3451 % o image_view: the image view.
3453 % o method: the pixel color interpolation method.
3455 % o x,y: A double representing the current (x,y) position of the pixel.
3457 % o pixel: return the interpolated pixel here.
3459 % o exception: return any errors or warnings in this structure.
3463 static inline void AlphaBlendMagickPixelPacket(const Image *image,
3464 const PixelPacket *color,const IndexPacket *indexes,MagickPixelPacket *pixel,
3465 MagickRealType *alpha)
3467 if (image->matte == MagickFalse)
3470 pixel->red=(MagickRealType) GetRedPixelComponent(color);
3471 pixel->green=(MagickRealType) GetGreenPixelComponent(color);
3472 pixel->blue=(MagickRealType) GetBluePixelComponent(color);
3473 pixel->opacity=(MagickRealType) GetOpacityPixelComponent(color);
3475 if (((image->colorspace == CMYKColorspace) ||
3476 (image->storage_class == PseudoClass)) &&
3477 (indexes != (const IndexPacket *) NULL))
3478 pixel->index=(MagickRealType) GetIndexPixelComponent(indexes);
3481 *alpha=QuantumScale*GetAlphaPixelComponent(color);
3482 pixel->red=(*alpha*GetRedPixelComponent(color));
3483 pixel->green=(*alpha*GetGreenPixelComponent(color));
3484 pixel->blue=(*alpha*GetBluePixelComponent(color));
3485 pixel->opacity=(MagickRealType) GetOpacityPixelComponent(color);
3487 if (((image->colorspace == CMYKColorspace) ||
3488 (image->storage_class == PseudoClass)) &&
3489 (indexes != (const IndexPacket *) NULL))
3490 pixel->index=(*alpha*GetIndexPixelComponent(indexes));
3493 static void BicubicInterpolate(const MagickPixelPacket *pixels,const double dx,
3494 MagickPixelPacket *pixel)
3504 p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
3505 q=(pixels[0].red-pixels[1].red)-p;
3506 r=pixels[2].red-pixels[0].red;
3508 pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3509 p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
3510 q=(pixels[0].green-pixels[1].green)-p;
3511 r=pixels[2].green-pixels[0].green;
3513 pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3514 p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
3515 q=(pixels[0].blue-pixels[1].blue)-p;
3516 r=pixels[2].blue-pixels[0].blue;
3518 pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3519 p=(pixels[3].opacity-pixels[2].opacity)-(pixels[0].opacity-pixels[1].opacity);
3520 q=(pixels[0].opacity-pixels[1].opacity)-p;
3521 r=pixels[2].opacity-pixels[0].opacity;
3522 s=pixels[1].opacity;
3523 pixel->opacity=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3524 if (pixel->colorspace == CMYKColorspace)
3526 p=(pixels[3].index-pixels[2].index)-(pixels[0].index-pixels[1].index);
3527 q=(pixels[0].index-pixels[1].index)-p;
3528 r=pixels[2].index-pixels[0].index;
3530 pixel->index=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
3534 static inline double MagickMax(const MagickRealType x,const MagickRealType y)
3541 static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
3547 alpha=MagickMax(x+2.0,0.0);
3548 gamma=1.0*alpha*alpha*alpha;
3549 alpha=MagickMax(x+1.0,0.0);
3550 gamma-=4.0*alpha*alpha*alpha;
3551 alpha=MagickMax(x+0.0,0.0);
3552 gamma+=6.0*alpha*alpha*alpha;
3553 alpha=MagickMax(x-1.0,0.0);
3554 gamma-=4.0*alpha*alpha*alpha;
3558 static inline double MeshInterpolate(const PointInfo *delta,const double p,
3559 const double x,const double y)
3561 return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3564 static inline ssize_t NearestNeighbor(const MagickRealType x)
3567 return((ssize_t) (x+0.5));
3568 return((ssize_t) (x-0.5));
3571 MagickExport MagickBooleanType InterpolateMagickPixelPacket(const Image *image,
3572 const CacheView *image_view,const InterpolatePixelMethod method,
3573 const double x,const double y,MagickPixelPacket *pixel,
3574 ExceptionInfo *exception)
3586 register const IndexPacket
3589 register const PixelPacket
3599 assert(image != (Image *) NULL);
3600 assert(image->signature == MagickSignature);
3601 assert(image_view != (CacheView *) NULL);
3603 x_offset=(ssize_t) floor(x);
3604 y_offset=(ssize_t) floor(y);
3605 switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
3607 case AverageInterpolatePixel:
3609 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3611 if (p == (const PixelPacket *) NULL)
3616 indexes=GetCacheViewVirtualIndexQueue(image_view);
3617 AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3618 AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3619 AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3620 AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3621 AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3622 AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3623 AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3624 AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3625 AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3626 AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3627 AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3628 AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3629 AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3630 AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3631 AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3632 AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3638 for (i=0; i < 16L; i++)
3640 gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
3641 pixel->red+=gamma*0.0625*pixels[i].red;
3642 pixel->green+=gamma*0.0625*pixels[i].green;
3643 pixel->blue+=gamma*0.0625*pixels[i].blue;
3644 pixel->opacity+=0.0625*pixels[i].opacity;
3645 if (image->colorspace == CMYKColorspace)
3646 pixel->index+=gamma*0.0625*pixels[i].index;
3650 case BicubicInterpolatePixel:
3658 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3660 if (p == (const PixelPacket *) NULL)
3665 indexes=GetCacheViewVirtualIndexQueue(image_view);
3666 AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3667 AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3668 AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3669 AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3670 AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3671 AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3672 AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3673 AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3674 AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3675 AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3676 AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3677 AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3678 AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3679 AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3680 AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3681 AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3684 for (i=0; i < 4L; i++)
3685 BicubicInterpolate(pixels+4*i,delta.x,u+i);
3686 BicubicInterpolate(u,delta.y,pixel);
3689 case BilinearInterpolatePixel:
3696 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3697 if (p == (const PixelPacket *) NULL)
3702 indexes=GetCacheViewVirtualIndexQueue(image_view);
3703 AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3704 AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3705 AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3706 AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3709 epsilon.x=1.0-delta.x;
3710 epsilon.y=1.0-delta.y;
3711 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
3712 (epsilon.x*alpha[2]+delta.x*alpha[3])));
3713 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3714 pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
3715 pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
3716 pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
3717 pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
3719 pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
3720 pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
3722 pixel->opacity=(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
3723 pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x*
3724 pixels[3].opacity));
3725 if (image->colorspace == CMYKColorspace)
3726 pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
3727 pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x*
3731 case FilterInterpolatePixel:
3745 geometry.x=x_offset-1;
3746 geometry.y=y_offset-1;
3747 excerpt_image=ExcerptImage(image,&geometry,exception);
3748 if (excerpt_image == (Image *) NULL)
3753 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
3755 excerpt_image=DestroyImage(excerpt_image);
3756 if (filter_image == (Image *) NULL)
3758 filter_view=AcquireCacheView(filter_image);
3759 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
3760 if (p != (const PixelPacket *) NULL)
3762 indexes=GetVirtualIndexQueue(filter_image);
3763 SetMagickPixelPacket(image,p,indexes,pixel);
3765 filter_view=DestroyCacheView(filter_view);
3766 filter_image=DestroyImage(filter_image);
3769 case IntegerInterpolatePixel:
3771 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
3772 if (p == (const PixelPacket *) NULL)
3777 indexes=GetCacheViewVirtualIndexQueue(image_view);
3778 SetMagickPixelPacket(image,p,indexes,pixel);
3781 case MeshInterpolatePixel:
3787 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
3789 if (p == (const PixelPacket *) NULL)
3794 indexes=GetCacheViewVirtualIndexQueue(image_view);
3795 AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3796 AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3797 AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3798 AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3801 luminance.x=MagickPixelLuminance(pixels+0)-MagickPixelLuminance(pixels+3);
3802 luminance.y=MagickPixelLuminance(pixels+1)-MagickPixelLuminance(pixels+2);
3803 if (fabs(luminance.x) < fabs(luminance.y))
3808 if (delta.x <= delta.y)
3811 Bottom-left triangle (pixel:2, diagonal: 0-3).
3813 delta.y=1.0-delta.y;
3814 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
3815 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3816 pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
3817 pixels[3].red,pixels[0].red);
3818 pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
3819 pixels[3].green,pixels[0].green);
3820 pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
3821 pixels[3].blue,pixels[0].blue);
3822 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
3823 pixels[3].opacity,pixels[0].opacity);
3824 if (image->colorspace == CMYKColorspace)
3825 pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
3826 pixels[3].index,pixels[0].index);
3831 Top-right triangle (pixel:1, diagonal: 0-3).
3833 delta.x=1.0-delta.x;
3834 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
3835 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3836 pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
3837 pixels[0].red,pixels[3].red);
3838 pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
3839 pixels[0].green,pixels[3].green);
3840 pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
3841 pixels[0].blue,pixels[3].blue);
3842 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
3843 pixels[0].opacity,pixels[3].opacity);
3844 if (image->colorspace == CMYKColorspace)
3845 pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
3846 pixels[0].index,pixels[3].index);
3854 if (delta.x <= (1.0-delta.y))
3857 Top-left triangle (pixel 0, diagonal: 1-2).
3859 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
3860 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3861 pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
3862 pixels[1].red,pixels[2].red);
3863 pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
3864 pixels[1].green,pixels[2].green);
3865 pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
3866 pixels[1].blue,pixels[2].blue);
3867 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
3868 pixels[1].opacity,pixels[2].opacity);
3869 if (image->colorspace == CMYKColorspace)
3870 pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
3871 pixels[1].index,pixels[2].index);
3876 Bottom-right triangle (pixel: 3, diagonal: 1-2).
3878 delta.x=1.0-delta.x;
3879 delta.y=1.0-delta.y;
3880 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
3881 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3882 pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
3883 pixels[2].red,pixels[1].red);
3884 pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
3885 pixels[2].green,pixels[1].green);
3886 pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
3887 pixels[2].blue,pixels[1].blue);
3888 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
3889 pixels[2].opacity,pixels[1].opacity);
3890 if (image->colorspace == CMYKColorspace)
3891 pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
3892 pixels[2].index,pixels[1].index);
3897 case NearestNeighborInterpolatePixel:
3899 p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
3900 NearestNeighbor(y),1,1,exception);
3901 if (p == (const PixelPacket *) NULL)
3906 indexes=GetCacheViewVirtualIndexQueue(image_view);
3907 SetMagickPixelPacket(image,p,indexes,pixel);
3910 case SplineInterpolatePixel:
3923 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3925 if (p == (const PixelPacket *) NULL)
3930 indexes=GetCacheViewVirtualIndexQueue(image_view);
3931 AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0);
3932 AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1);
3933 AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2);
3934 AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3);
3935 AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4);
3936 AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5);
3937 AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6);
3938 AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7);
3939 AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8);
3940 AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9);
3941 AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10);
3942 AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11);
3943 AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12);
3944 AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13);
3945 AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14);
3946 AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15);
3955 for (i=(-1); i < 3L; i++)
3957 dy=CubicWeightingFunction((MagickRealType) i-delta.y);
3958 for (j=(-1); j < 3L; j++)
3960 dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
3961 gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
3962 pixel->red+=gamma*dx*dy*pixels[n].red;
3963 pixel->green+=gamma*dx*dy*pixels[n].green;
3964 pixel->blue+=gamma*dx*dy*pixels[n].blue;
3965 pixel->opacity+=dx*dy*pixels[n].opacity;
3966 if (image->colorspace == CMYKColorspace)
3967 pixel->index+=gamma*dx*dy*pixels[n].index;