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 "MagickCore/studio.h"
42 #include "MagickCore/property.h"
43 #include "MagickCore/blob.h"
44 #include "MagickCore/blob-private.h"
45 #include "MagickCore/color-private.h"
46 #include "MagickCore/draw.h"
47 #include "MagickCore/exception.h"
48 #include "MagickCore/exception-private.h"
49 #include "MagickCore/cache.h"
50 #include "MagickCore/constitute.h"
51 #include "MagickCore/delegate.h"
52 #include "MagickCore/geometry.h"
53 #include "MagickCore/image-private.h"
54 #include "MagickCore/list.h"
55 #include "MagickCore/magick.h"
56 #include "MagickCore/memory_.h"
57 #include "MagickCore/monitor.h"
58 #include "MagickCore/option.h"
59 #include "MagickCore/pixel.h"
60 #include "MagickCore/pixel-accessor.h"
61 #include "MagickCore/quantum.h"
62 #include "MagickCore/quantum-private.h"
63 #include "MagickCore/resource_.h"
64 #include "MagickCore/semaphore.h"
65 #include "MagickCore/statistic.h"
66 #include "MagickCore/stream.h"
67 #include "MagickCore/string_.h"
68 #include "MagickCore/transform.h"
69 #include "MagickCore/utility.h"
72 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
76 + A c q u i r e P i x e l C h a n n e l M a p %
80 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
82 % AcquirePixelChannelMap() acquires a pixel component map.
84 % The format of the AcquirePixelChannelMap() method is:
86 % PixelChannelMap *AcquirePixelChannelMap(void)
89 MagickExport PixelChannelMap *AcquirePixelChannelMap(void)
97 channel_map=(PixelChannelMap *) AcquireQuantumMemory(MaxPixelChannels,
98 sizeof(*channel_map));
99 if (channel_map == (PixelChannelMap *) NULL)
100 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
101 (void) ResetMagickMemory(channel_map,0,MaxPixelChannels*sizeof(*channel_map));
102 for (i=0; i < MaxPixelChannels; i++)
103 channel_map[i].channel=(PixelChannel) i;
108 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
112 + C l o n e P i x e l C h a n n e l M a p %
116 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
118 % ClonePixelChannelMap() clones a pixel component map.
120 % The format of the ClonePixelChannelMap() method is:
122 % PixelChannelMap *ClonePixelChannelMap(PixelChannelMap *channel_map)
124 % A description of each parameter follows:
126 % o channel_map: the pixel component map.
129 MagickExport PixelChannelMap *ClonePixelChannelMap(PixelChannelMap *channel_map)
134 assert(channel_map != (PixelChannelMap *) NULL);
135 clone_map=AcquirePixelChannelMap();
136 if (clone_map == (PixelChannelMap *) NULL)
137 return((PixelChannelMap *) NULL);
138 (void) CopyMagickMemory(clone_map,channel_map,MaxPixelChannels*
139 sizeof(*channel_map));
144 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
148 + C l o n e P i x e l I n f o %
152 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
154 % ClonePixelInfo() makes a duplicate of the given pixel info structure, or if
155 % pixel info is NULL, a new one.
157 % The format of the ClonePixelInfo method is:
159 % PixelInfo *ClonePixelInfo(const PixelInfo *pixel_info)
161 % A description of each parameter follows:
163 % o pixel_info: the pixel info.
166 MagickExport PixelInfo *ClonePixelInfo(const PixelInfo *pixel)
171 pixel_info=(PixelInfo *) AcquireAlignedMemory(1,sizeof(*pixel_info));
172 if (pixel_info == (PixelInfo *) NULL)
173 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
174 *pixel_info=(*pixel);
179 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
183 + D e s t r o y P i x e l C h a n n e l M a p %
187 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
189 % DestroyPixelChannelMap() deallocates memory associated with the pixel
192 % The format of the DestroyPixelChannelMap() method is:
194 % PixelChannelMap *DestroyPixelChannelMap(PixelChannelMap *channel_map)
196 % A description of each parameter follows:
198 % o channel_map: the pixel component map.
201 MagickExport PixelChannelMap *DestroyPixelChannelMap(
202 PixelChannelMap *channel_map)
204 assert(channel_map != (PixelChannelMap *) NULL);
205 channel_map=(PixelChannelMap *) RelinquishMagickMemory(channel_map);
206 return((PixelChannelMap *) RelinquishMagickMemory(channel_map));
210 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
214 % E x p o r t I m a g e P i x e l s %
218 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
220 % ExportImagePixels() extracts pixel data from an image and returns it to you.
221 % The method returns MagickTrue on success otherwise MagickFalse if an error is
222 % encountered. The data is returned as char, short int, int, ssize_t, float,
223 % or double in the order specified by map.
225 % Suppose you want to extract the first scanline of a 640x480 image as
226 % character data in red-green-blue order:
228 % ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
230 % The format of the ExportImagePixels method is:
232 % MagickBooleanType ExportImagePixels(const Image *image,
233 % const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
234 % const size_t rows,const char *map,const StorageType type,
235 % void *pixels,ExceptionInfo *exception)
237 % A description of each parameter follows:
239 % o image: the image.
241 % o x_offset,y_offset,columns,rows: These values define the perimeter
242 % of a region of pixels you want to extract.
244 % o map: This string reflects the expected ordering of the pixel array.
245 % It can be any combination or order of R = red, G = green, B = blue,
246 % A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
247 % Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
250 % o type: Define the data type of the pixels. Float and double types are
251 % normalized to [0..1] otherwise [0..QuantumRange]. Choose from these
252 % types: CharPixel, DoublePixel, FloatPixel, IntegerPixel, LongPixel,
253 % QuantumPixel, or ShortPixel.
255 % o pixels: This array of values contain the pixel components as defined by
256 % map and type. You must preallocate this array where the expected
257 % length varies depending on the values of width, height, map, and type.
259 % o exception: return any errors or warnings in this structure.
262 MagickExport MagickBooleanType ExportImagePixels(const Image *image,
263 const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
264 const size_t rows,const char *map,const StorageType type,void *pixels,
265 ExceptionInfo *exception)
274 register const Quantum
283 assert(image != (Image *) NULL);
284 assert(image->signature == MagickSignature);
285 if (image->debug != MagickFalse)
286 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
288 quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
289 if (quantum_map == (QuantumType *) NULL)
291 (void) ThrowMagickException(exception,GetMagickModule(),
292 ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
295 for (i=0; i < (ssize_t) length; i++)
302 quantum_map[i]=AlphaQuantum;
308 quantum_map[i]=BlueQuantum;
314 quantum_map[i]=CyanQuantum;
315 if (image->colorspace == CMYKColorspace)
317 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
318 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
319 "ColorSeparatedImageRequired","`%s'",map);
325 quantum_map[i]=GreenQuantum;
331 quantum_map[i]=IndexQuantum;
337 quantum_map[i]=BlackQuantum;
338 if (image->colorspace == CMYKColorspace)
340 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
341 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
342 "ColorSeparatedImageRequired","`%s'",map);
348 quantum_map[i]=MagentaQuantum;
349 if (image->colorspace == CMYKColorspace)
351 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
352 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
353 "ColorSeparatedImageRequired","`%s'",map);
359 quantum_map[i]=OpacityQuantum;
365 quantum_map[i]=UndefinedQuantum;
371 quantum_map[i]=RedQuantum;
377 quantum_map[i]=YellowQuantum;
378 if (image->colorspace == CMYKColorspace)
380 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
381 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
382 "ColorSeparatedImageRequired","`%s'",map);
387 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
388 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
389 "UnrecognizedPixelMap","`%s'",map);
398 register unsigned char
401 q=(unsigned char *) pixels;
402 if (LocaleCompare(map,"BGR") == 0)
404 for (y=0; y < (ssize_t) rows; y++)
406 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
407 if (p == (const Quantum *) NULL)
409 for (x=0; x < (ssize_t) columns; x++)
411 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
412 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
413 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
414 p+=GetPixelChannels(image);
419 if (LocaleCompare(map,"BGRA") == 0)
421 for (y=0; y < (ssize_t) rows; y++)
423 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
424 if (p == (const Quantum *) NULL)
426 for (x=0; x < (ssize_t) columns; x++)
428 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
429 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
430 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
431 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
432 p+=GetPixelChannels(image);
437 if (LocaleCompare(map,"BGRP") == 0)
439 for (y=0; y < (ssize_t) rows; y++)
441 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
442 if (p == (const Quantum *) NULL)
444 for (x=0; x < (ssize_t) columns; x++)
446 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
447 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
448 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
449 *q++=ScaleQuantumToChar((Quantum) 0);
450 p+=GetPixelChannels(image);
455 if (LocaleCompare(map,"I") == 0)
457 for (y=0; y < (ssize_t) rows; y++)
459 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
460 if (p == (const Quantum *) NULL)
462 for (x=0; x < (ssize_t) columns; x++)
464 *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
465 p+=GetPixelChannels(image);
470 if (LocaleCompare(map,"RGB") == 0)
472 for (y=0; y < (ssize_t) rows; y++)
474 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
475 if (p == (const Quantum *) NULL)
477 for (x=0; x < (ssize_t) columns; x++)
479 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
480 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
481 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
482 p+=GetPixelChannels(image);
487 if (LocaleCompare(map,"RGBA") == 0)
489 for (y=0; y < (ssize_t) rows; y++)
491 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
492 if (p == (const Quantum *) NULL)
494 for (x=0; x < (ssize_t) columns; x++)
496 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
497 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
498 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
499 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
500 p+=GetPixelChannels(image);
505 if (LocaleCompare(map,"RGBP") == 0)
507 for (y=0; y < (ssize_t) rows; y++)
509 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
510 if (p == (const Quantum *) NULL)
512 for (x=0; x < (ssize_t) columns; x++)
514 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
515 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
516 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
517 *q++=ScaleQuantumToChar((Quantum) 0);
518 p+=GetPixelChannels(image);
523 for (y=0; y < (ssize_t) rows; y++)
525 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
526 if (p == (const Quantum *) NULL)
528 for (x=0; x < (ssize_t) columns; x++)
530 for (i=0; i < (ssize_t) length; i++)
533 switch (quantum_map[i])
538 *q=ScaleQuantumToChar(GetPixelRed(image,p));
544 *q=ScaleQuantumToChar(GetPixelGreen(image,p));
550 *q=ScaleQuantumToChar(GetPixelBlue(image,p));
555 *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
560 *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
565 if (image->colorspace == CMYKColorspace)
566 *q=ScaleQuantumToChar(GetPixelBlack(image,p));
571 *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
579 p+=GetPixelChannels(image);
590 if (LocaleCompare(map,"BGR") == 0)
592 for (y=0; y < (ssize_t) rows; y++)
594 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
595 if (p == (const Quantum *) NULL)
597 for (x=0; x < (ssize_t) columns; x++)
599 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
600 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
601 *q++=(double) (QuantumScale*GetPixelRed(image,p));
602 p+=GetPixelChannels(image);
607 if (LocaleCompare(map,"BGRA") == 0)
609 for (y=0; y < (ssize_t) rows; y++)
611 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
612 if (p == (const Quantum *) NULL)
614 for (x=0; x < (ssize_t) columns; x++)
616 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
617 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
618 *q++=(double) (QuantumScale*GetPixelRed(image,p));
619 *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
620 p+=GetPixelChannels(image);
625 if (LocaleCompare(map,"BGRP") == 0)
627 for (y=0; y < (ssize_t) rows; y++)
629 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
630 if (p == (const Quantum *) NULL)
632 for (x=0; x < (ssize_t) columns; x++)
634 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
635 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
636 *q++=(double) (QuantumScale*GetPixelRed(image,p));
638 p+=GetPixelChannels(image);
643 if (LocaleCompare(map,"I") == 0)
645 for (y=0; y < (ssize_t) rows; y++)
647 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
648 if (p == (const Quantum *) NULL)
650 for (x=0; x < (ssize_t) columns; x++)
652 *q++=(double) (QuantumScale*GetPixelIntensity(image,p));
653 p+=GetPixelChannels(image);
658 if (LocaleCompare(map,"RGB") == 0)
660 for (y=0; y < (ssize_t) rows; y++)
662 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
663 if (p == (const Quantum *) NULL)
665 for (x=0; x < (ssize_t) columns; x++)
667 *q++=(double) (QuantumScale*GetPixelRed(image,p));
668 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
669 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
670 p+=GetPixelChannels(image);
675 if (LocaleCompare(map,"RGBA") == 0)
677 for (y=0; y < (ssize_t) rows; y++)
679 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
680 if (p == (const Quantum *) NULL)
682 for (x=0; x < (ssize_t) columns; x++)
684 *q++=(double) (QuantumScale*GetPixelRed(image,p));
685 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
686 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
687 *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
688 p+=GetPixelChannels(image);
693 if (LocaleCompare(map,"RGBP") == 0)
695 for (y=0; y < (ssize_t) rows; y++)
697 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
698 if (p == (const Quantum *) NULL)
700 for (x=0; x < (ssize_t) columns; x++)
702 *q++=(double) (QuantumScale*GetPixelRed(image,p));
703 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
704 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
706 p+=GetPixelChannels(image);
711 for (y=0; y < (ssize_t) rows; y++)
713 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
714 if (p == (const Quantum *) NULL)
716 for (x=0; x < (ssize_t) columns; x++)
718 for (i=0; i < (ssize_t) length; i++)
721 switch (quantum_map[i])
726 *q=(double) (QuantumScale*GetPixelRed(image,p));
732 *q=(double) (QuantumScale*GetPixelGreen(image,p));
738 *q=(double) (QuantumScale*GetPixelBlue(image,p));
743 *q=(double) (QuantumScale*GetPixelAlpha(image,p));
748 *q=(double) (QuantumScale*GetPixelAlpha(image,p));
753 if (image->colorspace == CMYKColorspace)
754 *q=(double) (QuantumScale*
755 GetPixelBlack(image,p));
760 *q=(double) (QuantumScale*GetPixelIntensity(image,p));
768 p+=GetPixelChannels(image);
779 if (LocaleCompare(map,"BGR") == 0)
781 for (y=0; y < (ssize_t) rows; y++)
783 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
784 if (p == (const Quantum *) NULL)
786 for (x=0; x < (ssize_t) columns; x++)
788 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
789 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
790 *q++=(float) (QuantumScale*GetPixelRed(image,p));
791 p+=GetPixelChannels(image);
796 if (LocaleCompare(map,"BGRA") == 0)
798 for (y=0; y < (ssize_t) rows; y++)
800 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
801 if (p == (const Quantum *) NULL)
803 for (x=0; x < (ssize_t) columns; x++)
805 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
806 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
807 *q++=(float) (QuantumScale*GetPixelRed(image,p));
808 *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
809 p+=GetPixelChannels(image);
814 if (LocaleCompare(map,"BGRP") == 0)
816 for (y=0; y < (ssize_t) rows; y++)
818 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
819 if (p == (const Quantum *) NULL)
821 for (x=0; x < (ssize_t) columns; x++)
823 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
824 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
825 *q++=(float) (QuantumScale*GetPixelRed(image,p));
827 p+=GetPixelChannels(image);
832 if (LocaleCompare(map,"I") == 0)
834 for (y=0; y < (ssize_t) rows; y++)
836 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
837 if (p == (const Quantum *) NULL)
839 for (x=0; x < (ssize_t) columns; x++)
841 *q++=(float) (QuantumScale*GetPixelIntensity(image,p));
842 p+=GetPixelChannels(image);
847 if (LocaleCompare(map,"RGB") == 0)
849 for (y=0; y < (ssize_t) rows; y++)
851 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
852 if (p == (const Quantum *) NULL)
854 for (x=0; x < (ssize_t) columns; x++)
856 *q++=(float) (QuantumScale*GetPixelRed(image,p));
857 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
858 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
859 p+=GetPixelChannels(image);
864 if (LocaleCompare(map,"RGBA") == 0)
866 for (y=0; y < (ssize_t) rows; y++)
868 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
869 if (p == (const Quantum *) NULL)
871 for (x=0; x < (ssize_t) columns; x++)
873 *q++=(float) (QuantumScale*GetPixelRed(image,p));
874 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
875 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
876 *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
877 p+=GetPixelChannels(image);
882 if (LocaleCompare(map,"RGBP") == 0)
884 for (y=0; y < (ssize_t) rows; y++)
886 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
887 if (p == (const Quantum *) NULL)
889 for (x=0; x < (ssize_t) columns; x++)
891 *q++=(float) (QuantumScale*GetPixelRed(image,p));
892 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
893 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
895 p+=GetPixelChannels(image);
900 for (y=0; y < (ssize_t) rows; y++)
902 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
903 if (p == (const Quantum *) NULL)
905 for (x=0; x < (ssize_t) columns; x++)
907 for (i=0; i < (ssize_t) length; i++)
910 switch (quantum_map[i])
915 *q=(float) (QuantumScale*GetPixelRed(image,p));
921 *q=(float) (QuantumScale*GetPixelGreen(image,p));
927 *q=(float) (QuantumScale*GetPixelBlue(image,p));
932 *q=(float) (QuantumScale*((Quantum) (GetPixelAlpha(image,p))));
937 *q=(float) (QuantumScale*GetPixelAlpha(image,p));
942 if (image->colorspace == CMYKColorspace)
943 *q=(float) (QuantumScale* GetPixelBlack(image,p));
948 *q=(float) (QuantumScale*GetPixelIntensity(image,p));
956 p+=GetPixelChannels(image);
963 register unsigned int
966 q=(unsigned int *) pixels;
967 if (LocaleCompare(map,"BGR") == 0)
969 for (y=0; y < (ssize_t) rows; y++)
971 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
972 if (p == (const Quantum *) NULL)
974 for (x=0; x < (ssize_t) columns; x++)
976 *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
977 *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
978 *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
979 p+=GetPixelChannels(image);
984 if (LocaleCompare(map,"BGRA") == 0)
986 for (y=0; y < (ssize_t) rows; y++)
988 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
989 if (p == (const Quantum *) NULL)
991 for (x=0; x < (ssize_t) columns; x++)
993 *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
994 *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
995 *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
996 *q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
997 p+=GetPixelChannels(image);
1002 if (LocaleCompare(map,"BGRP") == 0)
1004 for (y=0; y < (ssize_t) rows; y++)
1006 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1007 if (p == (const Quantum *) NULL)
1009 for (x=0; x < (ssize_t) columns; x++)
1011 *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1012 *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1013 *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1015 p+=GetPixelChannels(image);
1020 if (LocaleCompare(map,"I") == 0)
1022 for (y=0; y < (ssize_t) rows; y++)
1024 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1025 if (p == (const Quantum *) NULL)
1027 for (x=0; x < (ssize_t) columns; x++)
1029 *q++=(unsigned int) ScaleQuantumToLong(
1030 GetPixelIntensity(image,p));
1031 p+=GetPixelChannels(image);
1036 if (LocaleCompare(map,"RGB") == 0)
1038 for (y=0; y < (ssize_t) rows; y++)
1040 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1041 if (p == (const Quantum *) NULL)
1043 for (x=0; x < (ssize_t) columns; x++)
1045 *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1046 *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1047 *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1048 p+=GetPixelChannels(image);
1053 if (LocaleCompare(map,"RGBA") == 0)
1055 for (y=0; y < (ssize_t) rows; y++)
1057 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1058 if (p == (const Quantum *) NULL)
1060 for (x=0; x < (ssize_t) columns; x++)
1062 *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1063 *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1064 *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1065 *q++=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
1066 p+=GetPixelChannels(image);
1071 if (LocaleCompare(map,"RGBP") == 0)
1073 for (y=0; y < (ssize_t) rows; y++)
1075 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1076 if (p == (const Quantum *) NULL)
1078 for (x=0; x < (ssize_t) columns; x++)
1080 *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1081 *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1082 *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1084 p+=GetPixelChannels(image);
1089 for (y=0; y < (ssize_t) rows; y++)
1091 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1092 if (p == (const Quantum *) NULL)
1094 for (x=0; x < (ssize_t) columns; x++)
1096 for (i=0; i < (ssize_t) length; i++)
1099 switch (quantum_map[i])
1104 *q=(unsigned int) ScaleQuantumToLong(GetPixelRed(image,p));
1108 case MagentaQuantum:
1110 *q=(unsigned int) ScaleQuantumToLong(GetPixelGreen(image,p));
1116 *q=(unsigned int) ScaleQuantumToLong(GetPixelBlue(image,p));
1121 *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
1124 case OpacityQuantum:
1126 *q=(unsigned int) ScaleQuantumToLong(GetPixelAlpha(image,p));
1131 if (image->colorspace == CMYKColorspace)
1132 *q=(unsigned int) ScaleQuantumToLong(GetPixelBlack(image,p));
1137 *q=(unsigned int) ScaleQuantumToLong(
1138 GetPixelIntensity(image,p));
1146 p+=GetPixelChannels(image);
1156 q=(size_t *) pixels;
1157 if (LocaleCompare(map,"BGR") == 0)
1159 for (y=0; y < (ssize_t) rows; y++)
1161 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1162 if (p == (const Quantum *) NULL)
1164 for (x=0; x < (ssize_t) columns; x++)
1166 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1167 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1168 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1169 p+=GetPixelChannels(image);
1174 if (LocaleCompare(map,"BGRA") == 0)
1176 for (y=0; y < (ssize_t) rows; y++)
1178 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1179 if (p == (const Quantum *) NULL)
1181 for (x=0; x < (ssize_t) columns; x++)
1183 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1184 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1185 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1186 *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
1187 p+=GetPixelChannels(image);
1192 if (LocaleCompare(map,"BGRP") == 0)
1194 for (y=0; y < (ssize_t) rows; y++)
1196 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1197 if (p == (const Quantum *) NULL)
1199 for (x=0; x < (ssize_t) columns; x++)
1201 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1202 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1203 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1205 p+=GetPixelChannels(image);
1210 if (LocaleCompare(map,"I") == 0)
1212 for (y=0; y < (ssize_t) rows; y++)
1214 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1215 if (p == (const Quantum *) NULL)
1217 for (x=0; x < (ssize_t) columns; x++)
1219 *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
1220 p+=GetPixelChannels(image);
1225 if (LocaleCompare(map,"RGB") == 0)
1227 for (y=0; y < (ssize_t) rows; y++)
1229 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1230 if (p == (const Quantum *) NULL)
1232 for (x=0; x < (ssize_t) columns; x++)
1234 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1235 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1236 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1237 p+=GetPixelChannels(image);
1242 if (LocaleCompare(map,"RGBA") == 0)
1244 for (y=0; y < (ssize_t) rows; y++)
1246 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1247 if (p == (const Quantum *) NULL)
1249 for (x=0; x < (ssize_t) columns; x++)
1251 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1252 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1253 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1254 *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
1255 p+=GetPixelChannels(image);
1260 if (LocaleCompare(map,"RGBP") == 0)
1262 for (y=0; y < (ssize_t) rows; y++)
1264 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1265 if (p == (const Quantum *) NULL)
1267 for (x=0; x < (ssize_t) columns; x++)
1269 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1270 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1271 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1273 p+=GetPixelChannels(image);
1278 for (y=0; y < (ssize_t) rows; y++)
1280 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1281 if (p == (const Quantum *) NULL)
1283 for (x=0; x < (ssize_t) columns; x++)
1285 for (i=0; i < (ssize_t) length; i++)
1288 switch (quantum_map[i])
1293 *q=ScaleQuantumToLong(GetPixelRed(image,p));
1297 case MagentaQuantum:
1299 *q=ScaleQuantumToLong(GetPixelGreen(image,p));
1305 *q=ScaleQuantumToLong(GetPixelBlue(image,p));
1310 *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
1313 case OpacityQuantum:
1315 *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
1320 if (image->colorspace == CMYKColorspace)
1321 *q=ScaleQuantumToLong(GetPixelBlack(image,p));
1326 *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
1334 p+=GetPixelChannels(image);
1344 q=(Quantum *) pixels;
1345 if (LocaleCompare(map,"BGR") == 0)
1347 for (y=0; y < (ssize_t) rows; y++)
1349 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1350 if (p == (const Quantum *) NULL)
1352 for (x=0; x < (ssize_t) columns; x++)
1354 *q++=GetPixelBlue(image,p);
1355 *q++=GetPixelGreen(image,p);
1356 *q++=GetPixelRed(image,p);
1357 p+=GetPixelChannels(image);
1362 if (LocaleCompare(map,"BGRA") == 0)
1364 for (y=0; y < (ssize_t) rows; y++)
1366 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1367 if (p == (const Quantum *) NULL)
1369 for (x=0; x < (ssize_t) columns; x++)
1371 *q++=GetPixelBlue(image,p);
1372 *q++=GetPixelGreen(image,p);
1373 *q++=GetPixelRed(image,p);
1374 *q++=(Quantum) (GetPixelAlpha(image,p));
1375 p+=GetPixelChannels(image);
1380 if (LocaleCompare(map,"BGRP") == 0)
1382 for (y=0; y < (ssize_t) rows; y++)
1384 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1385 if (p == (const Quantum *) NULL)
1387 for (x=0; x < (ssize_t) columns; x++)
1389 *q++=GetPixelBlue(image,p);
1390 *q++=GetPixelGreen(image,p);
1391 *q++=GetPixelRed(image,p);
1393 p+=GetPixelChannels(image);
1398 if (LocaleCompare(map,"I") == 0)
1400 for (y=0; y < (ssize_t) rows; y++)
1402 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1403 if (p == (const Quantum *) NULL)
1405 for (x=0; x < (ssize_t) columns; x++)
1407 *q++=GetPixelIntensity(image,p);
1408 p+=GetPixelChannels(image);
1413 if (LocaleCompare(map,"RGB") == 0)
1415 for (y=0; y < (ssize_t) rows; y++)
1417 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1418 if (p == (const Quantum *) NULL)
1420 for (x=0; x < (ssize_t) columns; x++)
1422 *q++=GetPixelRed(image,p);
1423 *q++=GetPixelGreen(image,p);
1424 *q++=GetPixelBlue(image,p);
1425 p+=GetPixelChannels(image);
1430 if (LocaleCompare(map,"RGBA") == 0)
1432 for (y=0; y < (ssize_t) rows; y++)
1434 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1435 if (p == (const Quantum *) NULL)
1437 for (x=0; x < (ssize_t) columns; x++)
1439 *q++=GetPixelRed(image,p);
1440 *q++=GetPixelGreen(image,p);
1441 *q++=GetPixelBlue(image,p);
1442 *q++=(Quantum) (GetPixelAlpha(image,p));
1443 p+=GetPixelChannels(image);
1448 if (LocaleCompare(map,"RGBP") == 0)
1450 for (y=0; y < (ssize_t) rows; y++)
1452 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1453 if (p == (const Quantum *) NULL)
1455 for (x=0; x < (ssize_t) columns; x++)
1457 *q++=GetPixelRed(image,p);
1458 *q++=GetPixelGreen(image,p);
1459 *q++=GetPixelBlue(image,p);
1461 p+=GetPixelChannels(image);
1466 for (y=0; y < (ssize_t) rows; y++)
1468 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1469 if (p == (const Quantum *) NULL)
1471 for (x=0; x < (ssize_t) columns; x++)
1473 for (i=0; i < (ssize_t) length; i++)
1476 switch (quantum_map[i])
1481 *q=GetPixelRed(image,p);
1485 case MagentaQuantum:
1487 *q=GetPixelGreen(image,p);
1493 *q=GetPixelBlue(image,p);
1498 *q=(Quantum) (GetPixelAlpha(image,p));
1501 case OpacityQuantum:
1503 *q=GetPixelAlpha(image,p);
1508 if (image->colorspace == CMYKColorspace)
1509 *q=GetPixelBlack(image,p);
1514 *q=(GetPixelIntensity(image,p));
1522 p+=GetPixelChannels(image);
1529 register unsigned short
1532 q=(unsigned short *) pixels;
1533 if (LocaleCompare(map,"BGR") == 0)
1535 for (y=0; y < (ssize_t) rows; y++)
1537 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1538 if (p == (const Quantum *) NULL)
1540 for (x=0; x < (ssize_t) columns; x++)
1542 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1543 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1544 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1545 p+=GetPixelChannels(image);
1550 if (LocaleCompare(map,"BGRA") == 0)
1552 for (y=0; y < (ssize_t) rows; y++)
1554 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1555 if (p == (const Quantum *) NULL)
1557 for (x=0; x < (ssize_t) columns; x++)
1559 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1560 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1561 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1562 *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
1563 p+=GetPixelChannels(image);
1568 if (LocaleCompare(map,"BGRP") == 0)
1570 for (y=0; y < (ssize_t) rows; y++)
1572 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1573 if (p == (const Quantum *) NULL)
1575 for (x=0; x < (ssize_t) columns; x++)
1577 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1578 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1579 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1581 p+=GetPixelChannels(image);
1586 if (LocaleCompare(map,"I") == 0)
1588 for (y=0; y < (ssize_t) rows; y++)
1590 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1591 if (p == (const Quantum *) NULL)
1593 for (x=0; x < (ssize_t) columns; x++)
1595 *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
1596 p+=GetPixelChannels(image);
1601 if (LocaleCompare(map,"RGB") == 0)
1603 for (y=0; y < (ssize_t) rows; y++)
1605 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1606 if (p == (const Quantum *) NULL)
1608 for (x=0; x < (ssize_t) columns; x++)
1610 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1611 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1612 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1613 p+=GetPixelChannels(image);
1618 if (LocaleCompare(map,"RGBA") == 0)
1620 for (y=0; y < (ssize_t) rows; y++)
1622 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1623 if (p == (const Quantum *) NULL)
1625 for (x=0; x < (ssize_t) columns; x++)
1627 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1628 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1629 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1630 *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
1631 p+=GetPixelChannels(image);
1636 if (LocaleCompare(map,"RGBP") == 0)
1638 for (y=0; y < (ssize_t) rows; y++)
1640 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1641 if (p == (const Quantum *) NULL)
1643 for (x=0; x < (ssize_t) columns; x++)
1645 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1646 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1647 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1649 p+=GetPixelChannels(image);
1654 for (y=0; y < (ssize_t) rows; y++)
1656 p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception);
1657 if (p == (const Quantum *) NULL)
1659 for (x=0; x < (ssize_t) columns; x++)
1661 for (i=0; i < (ssize_t) length; i++)
1664 switch (quantum_map[i])
1669 *q=ScaleQuantumToShort(GetPixelRed(image,p));
1673 case MagentaQuantum:
1675 *q=ScaleQuantumToShort(GetPixelGreen(image,p));
1681 *q=ScaleQuantumToShort(GetPixelBlue(image,p));
1686 *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
1689 case OpacityQuantum:
1691 *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
1696 if (image->colorspace == CMYKColorspace)
1697 *q=ScaleQuantumToShort(GetPixelBlack(image,p));
1702 *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
1710 p+=GetPixelChannels(image);
1717 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1718 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1719 "UnrecognizedPixelMap","`%s'",map);
1723 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1728 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1732 % G e t M a g i c k P i x e l P a c k e t %
1736 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1738 % GetPixelInfo() initializes the PixelInfo structure.
1740 % The format of the GetPixelInfo method is:
1742 % GetPixelInfo(const Image *image,PixelInfo *pixel)
1744 % A description of each parameter follows:
1746 % o image: the image.
1748 % o pixel: Specifies a pointer to a PixelPacket structure.
1751 MagickExport void GetPixelInfo(const Image *image,
1754 pixel->storage_class=DirectClass;
1755 pixel->colorspace=RGBColorspace;
1756 pixel->matte=MagickFalse;
1758 pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
1763 pixel->alpha=(MagickRealType) OpaqueAlpha;
1765 if (image == (const Image *) NULL)
1767 pixel->storage_class=image->storage_class;
1768 pixel->colorspace=image->colorspace;
1769 pixel->matte=image->matte;
1770 pixel->depth=image->depth;
1771 pixel->fuzz=image->fuzz;
1775 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1779 % I m p o r t I m a g e P i x e l s %
1783 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1785 % ImportImagePixels() accepts pixel data and stores in the image at the
1786 % location you specify. The method returns MagickTrue on success otherwise
1787 % MagickFalse if an error is encountered. The pixel data can be either char,
1788 % short int, int, ssize_t, float, or double in the order specified by map.
1790 % Suppose your want to upload the first scanline of a 640x480 image from
1791 % character data in red-green-blue order:
1793 % ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
1795 % The format of the ImportImagePixels method is:
1797 % MagickBooleanType ImportImagePixels(Image *image,const ssize_t x_offset,
1798 % const ssize_t y_offset,const size_t columns,
1799 % const size_t rows,const char *map,const StorageType type,
1800 % const void *pixels,ExceptionInfo *exception)
1802 % A description of each parameter follows:
1804 % o image: the image.
1806 % o x_offset,y_offset,columns,rows: These values define the perimeter
1807 % of a region of pixels you want to define.
1809 % o map: This string reflects the expected ordering of the pixel array.
1810 % It can be any combination or order of R = red, G = green, B = blue,
1811 % A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
1812 % Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
1815 % o type: Define the data type of the pixels. Float and double types are
1816 % normalized to [0..1] otherwise [0..QuantumRange]. Choose from these
1817 % types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or
1820 % o pixels: This array of values contain the pixel components as defined by
1821 % map and type. You must preallocate this array where the expected
1822 % length varies depending on the values of width, height, map, and type.
1824 % o exception: return any errors or warnings in this structure.
1827 MagickExport MagickBooleanType ImportImagePixels(Image *image,
1828 const ssize_t x_offset,const ssize_t y_offset,const size_t columns,
1829 const size_t rows,const char *map,const StorageType type,
1830 const void *pixels,ExceptionInfo *exception)
1849 Allocate image structure.
1851 assert(image != (Image *) NULL);
1852 assert(image->signature == MagickSignature);
1853 if (image->debug != MagickFalse)
1854 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1856 quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1857 if (quantum_map == (QuantumType *) NULL)
1858 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
1860 for (i=0; i < (ssize_t) length; i++)
1867 quantum_map[i]=AlphaQuantum;
1868 image->matte=MagickTrue;
1874 quantum_map[i]=BlueQuantum;
1880 quantum_map[i]=CyanQuantum;
1881 (void) SetImageColorspace(image,CMYKColorspace,exception);
1887 quantum_map[i]=GreenQuantum;
1893 quantum_map[i]=BlackQuantum;
1894 (void) SetImageColorspace(image,CMYKColorspace,exception);
1900 quantum_map[i]=IndexQuantum;
1906 quantum_map[i]=MagentaQuantum;
1907 (void) SetImageColorspace(image,CMYKColorspace,exception);
1913 quantum_map[i]=OpacityQuantum;
1914 image->matte=MagickTrue;
1920 quantum_map[i]=UndefinedQuantum;
1926 quantum_map[i]=RedQuantum;
1932 quantum_map[i]=YellowQuantum;
1933 (void) SetImageColorspace(image,CMYKColorspace,exception);
1938 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1939 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1940 "UnrecognizedPixelMap","`%s'",map);
1941 return(MagickFalse);
1945 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
1946 return(MagickFalse);
1948 Transfer the pixels from the pixel datarray to the image.
1954 register const unsigned char
1957 p=(const unsigned char *) pixels;
1958 if (LocaleCompare(map,"BGR") == 0)
1960 for (y=0; y < (ssize_t) rows; y++)
1962 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1963 if (q == (Quantum *) NULL)
1965 for (x=0; x < (ssize_t) columns; x++)
1967 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
1968 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
1969 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
1970 q+=GetPixelChannels(image);
1972 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1977 if (LocaleCompare(map,"BGRA") == 0)
1979 for (y=0; y < (ssize_t) rows; y++)
1981 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
1982 if (q == (Quantum *) NULL)
1984 for (x=0; x < (ssize_t) columns; x++)
1986 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
1987 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
1988 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
1989 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
1990 q+=GetPixelChannels(image);
1992 if (SyncAuthenticPixels(image,exception) == MagickFalse)
1997 if (LocaleCompare(map,"BGRO") == 0)
1999 for (y=0; y < (ssize_t) rows; y++)
2001 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2002 if (q == (Quantum *) NULL)
2004 for (x=0; x < (ssize_t) columns; x++)
2006 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2007 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2008 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2009 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2010 q+=GetPixelChannels(image);
2012 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2017 if (LocaleCompare(map,"BGRP") == 0)
2019 for (y=0; y < (ssize_t) rows; y++)
2021 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2022 if (q == (Quantum *) NULL)
2024 for (x=0; x < (ssize_t) columns; x++)
2026 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2027 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2028 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2030 q+=GetPixelChannels(image);
2032 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2037 if (LocaleCompare(map,"I") == 0)
2039 for (y=0; y < (ssize_t) rows; y++)
2041 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2042 if (q == (Quantum *) NULL)
2044 for (x=0; x < (ssize_t) columns; x++)
2046 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2047 SetPixelGreen(image,GetPixelRed(image,q),q);
2048 SetPixelBlue(image,GetPixelRed(image,q),q);
2049 q+=GetPixelChannels(image);
2051 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2056 if (LocaleCompare(map,"RGB") == 0)
2058 for (y=0; y < (ssize_t) rows; y++)
2060 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2061 if (q == (Quantum *) NULL)
2063 for (x=0; x < (ssize_t) columns; x++)
2065 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2066 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2067 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2068 q+=GetPixelChannels(image);
2070 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2075 if (LocaleCompare(map,"RGBA") == 0)
2077 for (y=0; y < (ssize_t) rows; y++)
2079 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2080 if (q == (Quantum *) NULL)
2082 for (x=0; x < (ssize_t) columns; x++)
2084 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2085 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2086 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2087 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2088 q+=GetPixelChannels(image);
2090 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2095 if (LocaleCompare(map,"RGBO") == 0)
2097 for (y=0; y < (ssize_t) rows; y++)
2099 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2100 if (q == (Quantum *) NULL)
2102 for (x=0; x < (ssize_t) columns; x++)
2104 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2105 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2106 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2107 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2108 q+=GetPixelChannels(image);
2110 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2115 if (LocaleCompare(map,"RGBP") == 0)
2117 for (y=0; y < (ssize_t) rows; y++)
2119 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2120 if (q == (Quantum *) NULL)
2122 for (x=0; x < (ssize_t) columns; x++)
2124 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2125 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2126 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2128 q+=GetPixelChannels(image);
2130 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2135 for (y=0; y < (ssize_t) rows; y++)
2137 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2138 if (q == (Quantum *) NULL)
2140 for (x=0; x < (ssize_t) columns; x++)
2142 for (i=0; i < (ssize_t) length; i++)
2144 switch (quantum_map[i])
2149 SetPixelRed(image,ScaleCharToQuantum(*p),q);
2153 case MagentaQuantum:
2155 SetPixelGreen(image,ScaleCharToQuantum(*p),q);
2161 SetPixelBlue(image,ScaleCharToQuantum(*p),q);
2166 SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2169 case OpacityQuantum:
2171 SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2176 SetPixelBlack(image,ScaleCharToQuantum(*p),q);
2181 SetPixelRed(image,ScaleCharToQuantum(*p),q);
2182 SetPixelGreen(image,GetPixelRed(image,q),q);
2183 SetPixelBlue(image,GetPixelRed(image,q),q);
2191 q+=GetPixelChannels(image);
2193 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2200 register const double
2203 p=(const double *) pixels;
2204 if (LocaleCompare(map,"BGR") == 0)
2206 for (y=0; y < (ssize_t) rows; y++)
2208 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2209 if (q == (Quantum *) NULL)
2211 for (x=0; x < (ssize_t) columns; x++)
2213 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2216 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2219 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2222 q+=GetPixelChannels(image);
2224 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2229 if (LocaleCompare(map,"BGRA") == 0)
2231 for (y=0; y < (ssize_t) rows; y++)
2233 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2234 if (q == (Quantum *) NULL)
2236 for (x=0; x < (ssize_t) columns; x++)
2238 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2241 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2244 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2247 SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2250 q+=GetPixelChannels(image);
2252 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2257 if (LocaleCompare(map,"BGRP") == 0)
2259 for (y=0; y < (ssize_t) rows; y++)
2261 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2262 if (q == (Quantum *) NULL)
2264 for (x=0; x < (ssize_t) columns; x++)
2266 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2269 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2272 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2276 q+=GetPixelChannels(image);
2278 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2283 if (LocaleCompare(map,"I") == 0)
2285 for (y=0; y < (ssize_t) rows; y++)
2287 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2288 if (q == (Quantum *) NULL)
2290 for (x=0; x < (ssize_t) columns; x++)
2292 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2294 SetPixelGreen(image,GetPixelRed(image,q),q);
2295 SetPixelBlue(image,GetPixelRed(image,q),q);
2297 q+=GetPixelChannels(image);
2299 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2304 if (LocaleCompare(map,"RGB") == 0)
2306 for (y=0; y < (ssize_t) rows; y++)
2308 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2309 if (q == (Quantum *) NULL)
2311 for (x=0; x < (ssize_t) columns; x++)
2313 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2316 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2319 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2322 q+=GetPixelChannels(image);
2324 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2329 if (LocaleCompare(map,"RGBA") == 0)
2331 for (y=0; y < (ssize_t) rows; y++)
2333 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2334 if (q == (Quantum *) NULL)
2336 for (x=0; x < (ssize_t) columns; x++)
2338 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2341 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2344 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2347 SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2350 q+=GetPixelChannels(image);
2352 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2357 if (LocaleCompare(map,"RGBP") == 0)
2359 for (y=0; y < (ssize_t) rows; y++)
2361 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2362 if (q == (Quantum *) NULL)
2364 for (x=0; x < (ssize_t) columns; x++)
2366 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2369 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2372 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2375 q+=GetPixelChannels(image);
2377 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2382 for (y=0; y < (ssize_t) rows; y++)
2384 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2385 if (q == (Quantum *) NULL)
2387 for (x=0; x < (ssize_t) columns; x++)
2389 for (i=0; i < (ssize_t) length; i++)
2391 switch (quantum_map[i])
2396 SetPixelRed(image,ClampToQuantum((MagickRealType)
2397 QuantumRange*(*p)),q);
2401 case MagentaQuantum:
2403 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2404 QuantumRange*(*p)),q);
2410 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2411 QuantumRange*(*p)),q);
2416 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2417 QuantumRange*(*p)),q);
2420 case OpacityQuantum:
2422 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2423 QuantumRange*(*p)),q);
2428 SetPixelBlack(image,ClampToQuantum((MagickRealType)
2429 QuantumRange*(*p)),q);
2434 SetPixelRed(image,ClampToQuantum((MagickRealType)
2435 QuantumRange*(*p)),q);
2436 SetPixelGreen(image,GetPixelRed(image,q),q);
2437 SetPixelBlue(image,GetPixelRed(image,q),q);
2445 q+=GetPixelChannels(image);
2447 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2454 register const float
2457 p=(const float *) pixels;
2458 if (LocaleCompare(map,"BGR") == 0)
2460 for (y=0; y < (ssize_t) rows; y++)
2462 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2463 if (q == (Quantum *) NULL)
2465 for (x=0; x < (ssize_t) columns; x++)
2467 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2470 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2473 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2476 q+=GetPixelChannels(image);
2478 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2483 if (LocaleCompare(map,"BGRA") == 0)
2485 for (y=0; y < (ssize_t) rows; y++)
2487 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2488 if (q == (Quantum *) NULL)
2490 for (x=0; x < (ssize_t) columns; x++)
2492 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2495 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2498 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2501 SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2504 q+=GetPixelChannels(image);
2506 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2511 if (LocaleCompare(map,"BGRP") == 0)
2513 for (y=0; y < (ssize_t) rows; y++)
2515 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2516 if (q == (Quantum *) NULL)
2518 for (x=0; x < (ssize_t) columns; x++)
2520 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2523 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2526 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2530 q+=GetPixelChannels(image);
2532 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2537 if (LocaleCompare(map,"I") == 0)
2539 for (y=0; y < (ssize_t) rows; y++)
2541 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2542 if (q == (Quantum *) NULL)
2544 for (x=0; x < (ssize_t) columns; x++)
2546 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2548 SetPixelGreen(image,GetPixelRed(image,q),q);
2549 SetPixelBlue(image,GetPixelRed(image,q),q);
2551 q+=GetPixelChannels(image);
2553 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2558 if (LocaleCompare(map,"RGB") == 0)
2560 for (y=0; y < (ssize_t) rows; y++)
2562 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2563 if (q == (Quantum *) NULL)
2565 for (x=0; x < (ssize_t) columns; x++)
2567 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2570 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2573 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2576 q+=GetPixelChannels(image);
2578 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2583 if (LocaleCompare(map,"RGBA") == 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 == (Quantum *) NULL)
2590 for (x=0; x < (ssize_t) columns; x++)
2592 SetPixelRed(image,ClampToQuantum((MagickRealType)
2593 QuantumRange*(*p)),q);
2595 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2598 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2601 SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
2604 q+=GetPixelChannels(image);
2606 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2611 if (LocaleCompare(map,"RGBP") == 0)
2613 for (y=0; y < (ssize_t) rows; y++)
2615 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2616 if (q == (Quantum *) NULL)
2618 for (x=0; x < (ssize_t) columns; x++)
2620 SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
2623 SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
2626 SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
2629 q+=GetPixelChannels(image);
2631 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2636 for (y=0; y < (ssize_t) rows; y++)
2638 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2639 if (q == (Quantum *) NULL)
2641 for (x=0; x < (ssize_t) columns; x++)
2643 for (i=0; i < (ssize_t) length; i++)
2645 switch (quantum_map[i])
2650 SetPixelRed(image,ClampToQuantum((MagickRealType)
2651 QuantumRange*(*p)),q);
2655 case MagentaQuantum:
2657 SetPixelGreen(image,ClampToQuantum((MagickRealType)
2658 QuantumRange*(*p)),q);
2664 SetPixelBlue(image,ClampToQuantum((MagickRealType)
2665 QuantumRange*(*p)),q);
2670 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2671 QuantumRange*(*p)),q);
2674 case OpacityQuantum:
2676 SetPixelAlpha(image,ClampToQuantum((MagickRealType)
2677 QuantumRange*(*p)),q);
2682 SetPixelBlack(image,ClampToQuantum((MagickRealType)
2683 QuantumRange*(*p)),q);
2688 SetPixelRed(image,ClampToQuantum((MagickRealType)
2689 QuantumRange*(*p)),q);
2690 SetPixelGreen(image,GetPixelRed(image,q),q);
2691 SetPixelBlue(image,GetPixelRed(image,q),q);
2699 q+=GetPixelChannels(image);
2701 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2708 register const unsigned int
2711 p=(const unsigned int *) pixels;
2712 if (LocaleCompare(map,"BGR") == 0)
2714 for (y=0; y < (ssize_t) rows; y++)
2716 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2717 if (q == (Quantum *) NULL)
2719 for (x=0; x < (ssize_t) columns; x++)
2721 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2722 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2723 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2724 q+=GetPixelChannels(image);
2726 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2731 if (LocaleCompare(map,"BGRA") == 0)
2733 for (y=0; y < (ssize_t) rows; y++)
2735 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2736 if (q == (Quantum *) NULL)
2738 for (x=0; x < (ssize_t) columns; x++)
2740 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2741 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2742 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2743 SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2744 q+=GetPixelChannels(image);
2746 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2751 if (LocaleCompare(map,"BGRP") == 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 == (Quantum *) NULL)
2758 for (x=0; x < (ssize_t) columns; x++)
2760 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2761 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2762 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2764 q+=GetPixelChannels(image);
2766 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2771 if (LocaleCompare(map,"I") == 0)
2773 for (y=0; y < (ssize_t) rows; y++)
2775 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2776 if (q == (Quantum *) NULL)
2778 for (x=0; x < (ssize_t) columns; x++)
2780 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2781 SetPixelGreen(image,GetPixelRed(image,q),q);
2782 SetPixelBlue(image,GetPixelRed(image,q),q);
2783 q+=GetPixelChannels(image);
2785 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2790 if (LocaleCompare(map,"RGB") == 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 == (Quantum *) NULL)
2797 for (x=0; x < (ssize_t) columns; x++)
2799 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2800 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2801 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2802 q+=GetPixelChannels(image);
2804 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2809 if (LocaleCompare(map,"RGBA") == 0)
2811 for (y=0; y < (ssize_t) rows; y++)
2813 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2814 if (q == (Quantum *) NULL)
2816 for (x=0; x < (ssize_t) columns; x++)
2818 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2819 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2820 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2821 SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2822 q+=GetPixelChannels(image);
2824 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2829 if (LocaleCompare(map,"RGBP") == 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 == (Quantum *) NULL)
2836 for (x=0; x < (ssize_t) columns; x++)
2838 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2839 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2840 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2842 q+=GetPixelChannels(image);
2844 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2849 for (y=0; y < (ssize_t) rows; y++)
2851 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2852 if (q == (Quantum *) NULL)
2854 for (x=0; x < (ssize_t) columns; x++)
2856 for (i=0; i < (ssize_t) length; i++)
2858 switch (quantum_map[i])
2863 SetPixelRed(image,ScaleLongToQuantum(*p),q);
2867 case MagentaQuantum:
2869 SetPixelGreen(image,ScaleLongToQuantum(*p),q);
2875 SetPixelBlue(image,ScaleLongToQuantum(*p),q);
2880 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
2883 case OpacityQuantum:
2885 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
2890 SetPixelBlack(image,ScaleLongToQuantum(*p),q);
2895 SetPixelRed(image,ScaleLongToQuantum(*p),q);
2896 SetPixelGreen(image,GetPixelRed(image,q),q);
2897 SetPixelBlue(image,GetPixelRed(image,q),q);
2905 q+=GetPixelChannels(image);
2907 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2914 register const unsigned int
2917 p=(const unsigned int *) pixels;
2918 if (LocaleCompare(map,"BGR") == 0)
2920 for (y=0; y < (ssize_t) rows; y++)
2922 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2923 if (q == (Quantum *) NULL)
2925 for (x=0; x < (ssize_t) columns; x++)
2927 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2928 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2929 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2930 q+=GetPixelChannels(image);
2932 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2937 if (LocaleCompare(map,"BGRA") == 0)
2939 for (y=0; y < (ssize_t) rows; y++)
2941 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2942 if (q == (Quantum *) NULL)
2944 for (x=0; x < (ssize_t) columns; x++)
2946 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2947 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2948 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2949 SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2950 q+=GetPixelChannels(image);
2952 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2957 if (LocaleCompare(map,"BGRP") == 0)
2959 for (y=0; y < (ssize_t) rows; y++)
2961 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
2962 if (q == (Quantum *) NULL)
2964 for (x=0; x < (ssize_t) columns; x++)
2966 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2967 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2968 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2970 q+=GetPixelChannels(image);
2972 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2977 if (LocaleCompare(map,"I") == 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 == (Quantum *) NULL)
2984 for (x=0; x < (ssize_t) columns; x++)
2986 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2987 SetPixelGreen(image,GetPixelRed(image,q),q);
2988 SetPixelBlue(image,GetPixelRed(image,q),q);
2989 q+=GetPixelChannels(image);
2991 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2996 if (LocaleCompare(map,"RGB") == 0)
2998 for (y=0; y < (ssize_t) rows; y++)
3000 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3001 if (q == (Quantum *) NULL)
3003 for (x=0; x < (ssize_t) columns; x++)
3005 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3006 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3007 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3008 q+=GetPixelChannels(image);
3010 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3015 if (LocaleCompare(map,"RGBA") == 0)
3017 for (y=0; y < (ssize_t) rows; y++)
3019 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3020 if (q == (Quantum *) NULL)
3022 for (x=0; x < (ssize_t) columns; x++)
3024 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3025 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3026 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3027 SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
3028 q+=GetPixelChannels(image);
3030 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3035 if (LocaleCompare(map,"RGBP") == 0)
3037 for (y=0; y < (ssize_t) rows; y++)
3039 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3040 if (q == (Quantum *) NULL)
3042 for (x=0; x < (ssize_t) columns; x++)
3044 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
3045 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
3046 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
3048 q+=GetPixelChannels(image);
3050 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3055 for (y=0; y < (ssize_t) rows; y++)
3057 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3058 if (q == (Quantum *) NULL)
3060 for (x=0; x < (ssize_t) columns; x++)
3062 for (i=0; i < (ssize_t) length; i++)
3064 switch (quantum_map[i])
3069 SetPixelRed(image,ScaleLongToQuantum(*p),q);
3073 case MagentaQuantum:
3075 SetPixelGreen(image,ScaleLongToQuantum(*p),q);
3081 SetPixelBlue(image,ScaleLongToQuantum(*p),q);
3086 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3089 case OpacityQuantum:
3091 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3096 SetPixelBlack(image,ScaleLongToQuantum(*p),q);
3101 SetPixelRed(image,ScaleLongToQuantum(*p),q);
3102 SetPixelGreen(image,GetPixelRed(image,q),q);
3103 SetPixelBlue(image,GetPixelRed(image,q),q);
3111 q+=GetPixelChannels(image);
3113 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3120 register const Quantum
3123 p=(const Quantum *) pixels;
3124 if (LocaleCompare(map,"BGR") == 0)
3126 for (y=0; y < (ssize_t) rows; y++)
3128 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3129 if (q == (Quantum *) NULL)
3131 for (x=0; x < (ssize_t) columns; x++)
3133 SetPixelBlue(image,*p++,q);
3134 SetPixelGreen(image,*p++,q);
3135 SetPixelRed(image,*p++,q);
3136 q+=GetPixelChannels(image);
3138 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3143 if (LocaleCompare(map,"BGRA") == 0)
3145 for (y=0; y < (ssize_t) rows; y++)
3147 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3148 if (q == (Quantum *) NULL)
3150 for (x=0; x < (ssize_t) columns; x++)
3152 SetPixelBlue(image,*p++,q);
3153 SetPixelGreen(image,*p++,q);
3154 SetPixelRed(image,*p++,q);
3155 SetPixelAlpha(image,*p++,q);
3156 q+=GetPixelChannels(image);
3158 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3163 if (LocaleCompare(map,"BGRP") == 0)
3165 for (y=0; y < (ssize_t) rows; y++)
3167 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3168 if (q == (Quantum *) NULL)
3170 for (x=0; x < (ssize_t) columns; x++)
3172 SetPixelBlue(image,*p++,q);
3173 SetPixelGreen(image,*p++,q);
3174 SetPixelRed(image,*p++,q);
3176 q+=GetPixelChannels(image);
3178 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3183 if (LocaleCompare(map,"I") == 0)
3185 for (y=0; y < (ssize_t) rows; y++)
3187 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3188 if (q == (Quantum *) NULL)
3190 for (x=0; x < (ssize_t) columns; x++)
3192 SetPixelRed(image,*p++,q);
3193 SetPixelGreen(image,GetPixelRed(image,q),q);
3194 SetPixelBlue(image,GetPixelRed(image,q),q);
3195 q+=GetPixelChannels(image);
3197 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3202 if (LocaleCompare(map,"RGB") == 0)
3204 for (y=0; y < (ssize_t) rows; y++)
3206 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3207 if (q == (Quantum *) NULL)
3209 for (x=0; x < (ssize_t) columns; x++)
3211 SetPixelRed(image,*p++,q);
3212 SetPixelGreen(image,*p++,q);
3213 SetPixelBlue(image,*p++,q);
3214 q+=GetPixelChannels(image);
3216 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3221 if (LocaleCompare(map,"RGBA") == 0)
3223 for (y=0; y < (ssize_t) rows; y++)
3225 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3226 if (q == (Quantum *) NULL)
3228 for (x=0; x < (ssize_t) columns; x++)
3230 SetPixelRed(image,*p++,q);
3231 SetPixelGreen(image,*p++,q);
3232 SetPixelBlue(image,*p++,q);
3233 SetPixelAlpha(image,*p++,q);
3234 q+=GetPixelChannels(image);
3236 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3241 if (LocaleCompare(map,"RGBP") == 0)
3243 for (y=0; y < (ssize_t) rows; y++)
3245 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3246 if (q == (Quantum *) NULL)
3248 for (x=0; x < (ssize_t) columns; x++)
3250 SetPixelRed(image,*p++,q);
3251 SetPixelGreen(image,*p++,q);
3252 SetPixelBlue(image,*p++,q);
3254 q+=GetPixelChannels(image);
3256 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3261 for (y=0; y < (ssize_t) rows; y++)
3263 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3264 if (q == (Quantum *) NULL)
3266 for (x=0; x < (ssize_t) columns; x++)
3268 for (i=0; i < (ssize_t) length; i++)
3270 switch (quantum_map[i])
3275 SetPixelRed(image,*p,q);
3279 case MagentaQuantum:
3281 SetPixelGreen(image,*p,q);
3287 SetPixelBlue(image,*p,q);
3292 SetPixelAlpha(image,*p,q);
3295 case OpacityQuantum:
3297 SetPixelAlpha(image,*p,q);
3302 SetPixelBlack(image,*p,q);
3307 SetPixelRed(image,*p,q);
3308 SetPixelGreen(image,GetPixelRed(image,q),q);
3309 SetPixelBlue(image,GetPixelRed(image,q),q);
3317 q+=GetPixelChannels(image);
3319 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3326 register const unsigned short
3329 p=(const unsigned short *) pixels;
3330 if (LocaleCompare(map,"BGR") == 0)
3332 for (y=0; y < (ssize_t) rows; y++)
3334 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3335 if (q == (Quantum *) NULL)
3337 for (x=0; x < (ssize_t) columns; x++)
3339 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3340 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3341 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3342 q+=GetPixelChannels(image);
3344 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3349 if (LocaleCompare(map,"BGRA") == 0)
3351 for (y=0; y < (ssize_t) rows; y++)
3353 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3354 if (q == (Quantum *) NULL)
3356 for (x=0; x < (ssize_t) columns; x++)
3358 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3359 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3360 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3361 SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3362 q+=GetPixelChannels(image);
3364 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3369 if (LocaleCompare(map,"BGRP") == 0)
3371 for (y=0; y < (ssize_t) rows; y++)
3373 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3374 if (q == (Quantum *) NULL)
3376 for (x=0; x < (ssize_t) columns; x++)
3378 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3379 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3380 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3382 q+=GetPixelChannels(image);
3384 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3389 if (LocaleCompare(map,"I") == 0)
3391 for (y=0; y < (ssize_t) rows; y++)
3393 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3394 if (q == (Quantum *) NULL)
3396 for (x=0; x < (ssize_t) columns; x++)
3398 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3399 SetPixelGreen(image,GetPixelRed(image,q),q);
3400 SetPixelBlue(image,GetPixelRed(image,q),q);
3401 q+=GetPixelChannels(image);
3403 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3408 if (LocaleCompare(map,"RGB") == 0)
3410 for (y=0; y < (ssize_t) rows; y++)
3412 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3413 if (q == (Quantum *) NULL)
3415 for (x=0; x < (ssize_t) columns; x++)
3417 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3418 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3419 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3420 q+=GetPixelChannels(image);
3422 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3427 if (LocaleCompare(map,"RGBA") == 0)
3429 for (y=0; y < (ssize_t) rows; y++)
3431 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3432 if (q == (Quantum *) NULL)
3434 for (x=0; x < (ssize_t) columns; x++)
3436 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3437 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3438 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3439 SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3440 q+=GetPixelChannels(image);
3442 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3447 if (LocaleCompare(map,"RGBP") == 0)
3449 for (y=0; y < (ssize_t) rows; y++)
3451 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3452 if (q == (Quantum *) NULL)
3454 for (x=0; x < (ssize_t) columns; x++)
3456 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3457 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3458 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3460 q+=GetPixelChannels(image);
3462 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3467 for (y=0; y < (ssize_t) rows; y++)
3469 q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception);
3470 if (q == (Quantum *) NULL)
3472 for (x=0; x < (ssize_t) columns; x++)
3474 for (i=0; i < (ssize_t) length; i++)
3476 switch (quantum_map[i])
3481 SetPixelRed(image,ScaleShortToQuantum(*p),q);
3485 case MagentaQuantum:
3487 SetPixelGreen(image,ScaleShortToQuantum(*p),q);
3493 SetPixelBlue(image,ScaleShortToQuantum(*p),q);
3498 SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
3501 case OpacityQuantum:
3503 SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
3508 SetPixelBlack(image,ScaleShortToQuantum(*p),q);
3513 SetPixelRed(image,ScaleShortToQuantum(*p),q);
3514 SetPixelGreen(image,GetPixelRed(image,q),q);
3515 SetPixelBlue(image,GetPixelRed(image,q),q);
3523 q+=GetPixelChannels(image);
3525 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3532 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3533 (void) ThrowMagickException(&image->exception,GetMagickModule(),
3534 OptionError,"UnrecognizedPixelMap","`%s'",map);
3538 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3543 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3547 + I n i t i a l i z e P i x e l C h a n n e l M a p %
3551 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3553 % InitializePixelChannelMap() defines the standard pixel component map.
3555 % The format of the InitializePixelChannelMap() method is:
3557 % void InitializePixelChannelMap(Image *image)
3559 % A description of each parameter follows:
3561 % o image: the image.
3564 MagickExport void InitializePixelChannelMap(Image *image)
3572 for (i=0; i < (ssize_t) MaxPixelChannels; i++)
3574 SetPixelChannelMapChannel(image,(PixelChannel) i,(PixelChannel) i);
3575 SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
3577 image->sync=MagickTrue;
3578 image->number_channels=4;
3579 if (0 && image->colorspace == GRAYColorspace)
3580 image->number_channels=2;
3581 if (image->colorspace == CMYKColorspace)
3582 image->number_channels++;
3583 if (image->storage_class == PseudoClass)
3584 image->number_channels++;
3585 for (i=0; i < (ssize_t) image->number_channels; i++)
3586 SetPixelChannelMapTraits(image,(PixelChannel) i,(PixelTrait)
3588 alpha_channel=GetPixelChannelMapChannel(image,AlphaPixelChannel);
3589 if (image->matte == MagickFalse)
3590 SetPixelChannelMapTraits(image,AlphaPixelChannel,CopyPixelTrait);
3592 for (i=0; i < (ssize_t) image->number_channels; i++)
3593 if ((PixelChannel) i != alpha_channel)
3594 SetPixelChannelMapTraits(image,(PixelChannel) i,(PixelTrait)
3595 (UpdatePixelTrait | BlendPixelTrait));
3596 if (0 && image->colorspace == GRAYColorspace)
3598 image->number_channels=2;
3599 SetPixelChannelMapChannel(image,GreenPixelChannel,RedPixelChannel);
3600 SetPixelChannelMapChannel(image,BluePixelChannel,RedPixelChannel);
3602 if (image->storage_class == PseudoClass)
3604 SetPixelChannelMapChannel(image,IndexPixelChannel,IndexPixelChannel);
3605 SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
3607 image->number_channels+=image->number_meta_channels;
3608 for ( ; i < (ssize_t) image->number_channels; i++)
3609 SetPixelChannelMapTraits(image,(PixelChannel) i,CopyPixelTrait);
3610 (void) SetPixelChannelMask(image,image->channel_mask);
3614 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3618 % I n t e r p o l a t e P i x e l C h a n n e l %
3622 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3624 % InterpolatePixelChannel() applies a pixel interpolation method between a
3625 % floating point coordinate and the pixels surrounding that coordinate. No
3626 % pixel area resampling, or scaling of the result is performed.
3628 % The format of the InterpolatePixelChannel method is:
3630 % MagickBooleanType InterpolatePixelChannel(const Image *image,
3631 % const CacheView *image_view,const PixelChannel channel,
3632 % const InterpolatePixelMethod method,const double x,const double y,
3633 % double *pixel,ExceptionInfo *exception)
3635 % A description of each parameter follows:
3637 % o image: the image.
3639 % o image_view: the image view.
3641 % o channel: the pixel channel to interpolate.
3643 % o method: the pixel color interpolation method.
3645 % o x,y: A double representing the current (x,y) position of the pixel.
3647 % o pixel: return the interpolated pixel here.
3649 % o exception: return any errors or warnings in this structure.
3653 static inline double MagickMax(const MagickRealType x,const MagickRealType y)
3660 static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
3666 alpha=MagickMax(x+2.0,0.0);
3667 gamma=1.0*alpha*alpha*alpha;
3668 alpha=MagickMax(x+1.0,0.0);
3669 gamma-=4.0*alpha*alpha*alpha;
3670 alpha=MagickMax(x+0.0,0.0);
3671 gamma+=6.0*alpha*alpha*alpha;
3672 alpha=MagickMax(x-1.0,0.0);
3673 gamma-=4.0*alpha*alpha*alpha;
3677 static inline double MeshInterpolate(const PointInfo *delta,const double p,
3678 const double x,const double y)
3680 return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
3683 static inline ssize_t NearestNeighbor(const MagickRealType x)
3686 return((ssize_t) (x+0.5));
3687 return((ssize_t) (x-0.5));
3690 MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
3691 const CacheView *image_view,const PixelChannel channel,
3692 const InterpolatePixelMethod method,const double x,const double y,
3693 double *pixel,ExceptionInfo *exception)
3706 register const Quantum
3716 assert(image != (Image *) NULL);
3717 assert(image != (Image *) NULL);
3718 assert(image->signature == MagickSignature);
3719 assert(image_view != (CacheView *) NULL);
3722 traits=GetPixelChannelMapTraits(image,channel);
3723 x_offset=(ssize_t) floor(x);
3724 y_offset=(ssize_t) floor(y);
3725 switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
3727 case AverageInterpolatePixel:
3729 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3731 if (p == (const Quantum *) NULL)
3736 if ((traits & BlendPixelTrait) == 0)
3737 for (i=0; i < 16; i++)
3740 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3743 for (i=0; i < 16; i++)
3745 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3746 GetPixelChannels(image));
3747 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3749 for (i=0; i < 16; i++)
3751 gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
3752 *pixel+=gamma*0.0625*pixels[i];
3756 case BicubicInterpolatePixel:
3765 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
3767 if (p == (const Quantum *) NULL)
3772 if ((traits & BlendPixelTrait) == 0)
3773 for (i=0; i < 16; i++)
3776 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3779 for (i=0; i < 16; i++)
3781 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3782 GetPixelChannels(image));
3783 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3787 for (i=0; i < 4; i++)
3789 u[0]=(pixels[4*i+3]-pixels[4*i+2])-(pixels[4*i+0]-pixels[4*i+1]);
3790 u[1]=(pixels[4*i+0]-pixels[4*i+1])-u[0];
3791 u[2]=pixels[4*i+2]-pixels[4*i+0];
3793 v[i]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
3796 u[0]=(v[3]-v[2])-(v[0]-v[1]);
3797 u[1]=(v[0]-v[1])-u[0];
3800 *pixel=(delta.y*delta.y*delta.y*u[0])+(delta.y*delta.y*u[1])+(delta.y*
3804 case BilinearInterpolatePixel:
3811 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3812 if (p == (const Quantum *) NULL)
3817 if ((traits & BlendPixelTrait) == 0)
3818 for (i=0; i < 4; i++)
3821 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3824 for (i=0; i < 4; i++)
3826 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3827 GetPixelChannels(image));
3828 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3832 epsilon.x=1.0-delta.x;
3833 epsilon.y=1.0-delta.y;
3834 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
3835 (epsilon.x*alpha[2]+delta.x*alpha[3])));
3836 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3837 *pixel=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
3838 (epsilon.x*pixels[2]+delta.x*pixels[3]));
3841 case FilterInterpolatePixel:
3855 geometry.x=x_offset-1;
3856 geometry.y=y_offset-1;
3857 excerpt_image=ExcerptImage(image,&geometry,exception);
3858 if (excerpt_image == (Image *) NULL)
3863 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
3865 excerpt_image=DestroyImage(excerpt_image);
3866 if (filter_image == (Image *) NULL)
3868 filter_view=AcquireCacheView(filter_image);
3869 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
3870 if (p == (const Quantum *) NULL)
3873 *pixel=(double) p[channel];
3874 filter_view=DestroyCacheView(filter_view);
3875 filter_image=DestroyImage(filter_image);
3878 case IntegerInterpolatePixel:
3880 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
3881 if (p == (const Quantum *) NULL)
3886 *pixel=(double) p[channel];
3889 case NearestNeighborInterpolatePixel:
3891 p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
3892 NearestNeighbor(y),1,1,exception);
3893 if (p == (const Quantum *) NULL)
3898 *pixel=(double) p[channel];
3901 case MeshInterpolatePixel:
3907 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
3908 if (p == (const Quantum *) NULL)
3913 if ((traits & BlendPixelTrait) == 0)
3914 for (i=0; i < 4; i++)
3917 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
3920 for (i=0; i < 4; i++)
3922 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
3923 GetPixelChannels(image));
3924 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
3928 luminance.x=GetPixelLuminance(image,p)-(double)
3929 GetPixelLuminance(image,p+3*GetPixelChannels(image));
3930 luminance.y=GetPixelLuminance(image,p+1*GetPixelChannels(image))-(double)
3931 GetPixelLuminance(image,p+2*GetPixelChannels(image));
3932 if (fabs(luminance.x) < fabs(luminance.y))
3937 if (delta.x <= delta.y)
3940 Bottom-left triangle (pixel: 2, diagonal: 0-3).
3942 delta.y=1.0-delta.y;
3943 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
3944 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3945 *pixel=gamma*MeshInterpolate(&delta,pixels[2],pixels[3],
3951 Top-right triangle (pixel: 1, diagonal: 0-3).
3953 delta.x=1.0-delta.x;
3954 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
3955 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3956 *pixel=gamma*MeshInterpolate(&delta,pixels[1],pixels[0],
3965 if (delta.x <= (1.0-delta.y))
3968 Top-left triangle (pixel: 0, diagonal: 1-2).
3970 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
3971 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3972 *pixel=gamma*MeshInterpolate(&delta,pixels[0],pixels[1],
3978 Bottom-right triangle (pixel: 3, diagonal: 1-2).
3980 delta.x=1.0-delta.x;
3981 delta.y=1.0-delta.y;
3982 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
3983 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
3984 *pixel=gamma*MeshInterpolate(&delta,pixels[3],pixels[2],
3990 case SplineInterpolatePixel:
4003 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4005 if (p == (const Quantum *) NULL)
4010 if ((traits & BlendPixelTrait) == 0)
4011 for (i=0; i < 16; i++)
4014 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4017 for (i=0; i < 16; i++)
4019 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4020 GetPixelChannels(image));
4021 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4026 for (i=(-1); i < 3L; i++)
4028 dy=CubicWeightingFunction((MagickRealType) i-delta.y);
4029 for (j=(-1); j < 3L; j++)
4031 dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
4032 gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
4033 *pixel+=gamma*dx*dy*pixels[n];
4044 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4048 % I n t e r p o l a t e P i x e l I n f o %
4052 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4054 % InterpolatePixelInfo() applies a pixel interpolation method between a
4055 % floating point coordinate and the pixels surrounding that coordinate. No
4056 % pixel area resampling, or scaling of the result is performed.
4058 % The format of the InterpolatePixelInfo method is:
4060 % MagickBooleanType InterpolatePixelInfo(const Image *image,
4061 % const CacheView *image_view,const InterpolatePixelMethod method,
4062 % const double x,const double y,PixelInfo *pixel,
4063 % ExceptionInfo *exception)
4065 % A description of each parameter follows:
4067 % o image: the image.
4069 % o image_view: the image view.
4071 % o method: the pixel color interpolation method.
4073 % o x,y: A double representing the current (x,y) position of the pixel.
4075 % o pixel: return the interpolated pixel here.
4077 % o exception: return any errors or warnings in this structure.
4081 static inline void AlphaBlendPixelInfo(const Image *image,
4082 const Quantum *pixel,PixelInfo *pixel_info,MagickRealType *alpha)
4084 if (image->matte == MagickFalse)
4087 pixel_info->red=(MagickRealType) GetPixelRed(image,pixel);
4088 pixel_info->green=(MagickRealType) GetPixelGreen(image,pixel);
4089 pixel_info->blue=(MagickRealType) GetPixelBlue(image,pixel);
4090 pixel_info->black=0.0;
4091 if (image->colorspace == CMYKColorspace)
4092 pixel_info->black=(MagickRealType) GetPixelBlack(image,pixel);
4093 pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
4096 *alpha=QuantumScale*GetPixelAlpha(image,pixel);
4097 pixel_info->red=(*alpha*GetPixelRed(image,pixel));
4098 pixel_info->green=(*alpha*GetPixelGreen(image,pixel));
4099 pixel_info->blue=(*alpha*GetPixelBlue(image,pixel));
4100 pixel_info->black=0.0;
4101 if (image->colorspace == CMYKColorspace)
4102 pixel_info->black=(*alpha*GetPixelBlack(image,pixel));
4103 pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
4106 static void BicubicInterpolate(const PixelInfo *pixels,const double dx,
4117 p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
4118 q=(pixels[0].red-pixels[1].red)-p;
4119 r=pixels[2].red-pixels[0].red;
4121 pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4122 p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
4123 q=(pixels[0].green-pixels[1].green)-p;
4124 r=pixels[2].green-pixels[0].green;
4126 pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4127 p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
4128 q=(pixels[0].blue-pixels[1].blue)-p;
4129 r=pixels[2].blue-pixels[0].blue;
4131 pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4132 p=(pixels[3].alpha-pixels[2].alpha)-(pixels[0].alpha-pixels[1].alpha);
4133 q=(pixels[0].alpha-pixels[1].alpha)-p;
4134 r=pixels[2].alpha-pixels[0].alpha;
4136 pixel->alpha=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4137 if (pixel->colorspace == CMYKColorspace)
4139 p=(pixels[3].black-pixels[2].black)-(pixels[0].black-pixels[1].black);
4140 q=(pixels[0].black-pixels[1].black)-p;
4141 r=pixels[2].black-pixels[0].black;
4143 pixel->black=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4147 MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
4148 const CacheView *image_view,const InterpolatePixelMethod method,
4149 const double x,const double y,PixelInfo *pixel,ExceptionInfo *exception)
4161 register const Quantum
4171 assert(image != (Image *) NULL);
4172 assert(image->signature == MagickSignature);
4173 assert(image_view != (CacheView *) NULL);
4175 x_offset=(ssize_t) floor(x);
4176 y_offset=(ssize_t) floor(y);
4177 switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
4179 case AverageInterpolatePixel:
4181 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4183 if (p == (const Quantum *) NULL)
4188 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4189 AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
4190 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4191 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4192 AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4193 AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4194 AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4195 AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4196 AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4197 AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4198 AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4200 AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4202 AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4204 AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4206 AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4208 AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4215 for (i=0; i < 16L; i++)
4217 gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
4218 pixel->red+=gamma*0.0625*pixels[i].red;
4219 pixel->green+=gamma*0.0625*pixels[i].green;
4220 pixel->blue+=gamma*0.0625*pixels[i].blue;
4221 if (image->colorspace == CMYKColorspace)
4222 pixel->black+=gamma*0.0625*pixels[i].black;
4223 pixel->alpha+=0.0625*pixels[i].alpha;
4227 case BicubicInterpolatePixel:
4235 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4237 if (p == (const Quantum *) NULL)
4242 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4243 AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
4244 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4245 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4246 AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4247 AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4248 AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4249 AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4250 AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4251 AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4252 AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4254 AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4256 AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4258 AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4260 AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4262 AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4266 for (i=0; i < 4L; i++)
4267 BicubicInterpolate(pixels+4*i,delta.x,u+i);
4268 BicubicInterpolate(u,delta.y,pixel);
4271 case BilinearInterpolatePixel:
4278 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4279 if (p == (const Quantum *) NULL)
4284 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4285 AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
4286 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4287 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4290 epsilon.x=1.0-delta.x;
4291 epsilon.y=1.0-delta.y;
4292 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4293 (epsilon.x*alpha[2]+delta.x*alpha[3])));
4294 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4295 pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
4296 pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
4297 pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
4298 pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
4300 pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
4301 pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
4303 if (image->colorspace == CMYKColorspace)
4304 pixel->black=gamma*(epsilon.y*(epsilon.x*pixels[0].black+delta.x*
4305 pixels[1].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
4307 gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4308 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4309 pixel->alpha=(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
4310 pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
4314 case FilterInterpolatePixel:
4328 geometry.x=x_offset-1;
4329 geometry.y=y_offset-1;
4330 excerpt_image=ExcerptImage(image,&geometry,exception);
4331 if (excerpt_image == (Image *) NULL)
4336 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
4338 excerpt_image=DestroyImage(excerpt_image);
4339 if (filter_image == (Image *) NULL)
4341 filter_view=AcquireCacheView(filter_image);
4342 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4343 if (p != (const Quantum *) NULL)
4344 SetPixelInfo(image,p,pixel);
4345 filter_view=DestroyCacheView(filter_view);
4346 filter_image=DestroyImage(filter_image);
4349 case IntegerInterpolatePixel:
4351 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4352 if (p == (const Quantum *) NULL)
4357 SetPixelInfo(image,p,pixel);
4360 case MeshInterpolatePixel:
4366 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4367 if (p == (const Quantum *) NULL)
4374 luminance.x=GetPixelLuminance(image,p)-(double)
4375 GetPixelLuminance(image,p+3*GetPixelChannels(image));
4376 luminance.y=GetPixelLuminance(image,p+1*GetPixelChannels(image))-(double)
4377 GetPixelLuminance(image,p+2*GetPixelChannels(image));
4378 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4379 AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
4380 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4381 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4382 if (fabs(luminance.x) < fabs(luminance.y))
4387 if (delta.x <= delta.y)
4390 Bottom-left triangle (pixel: 2, diagonal: 0-3).
4392 delta.y=1.0-delta.y;
4393 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4394 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4395 pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
4396 pixels[3].red,pixels[0].red);
4397 pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
4398 pixels[3].green,pixels[0].green);
4399 pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
4400 pixels[3].blue,pixels[0].blue);
4401 if (image->colorspace == CMYKColorspace)
4402 pixel->black=gamma*MeshInterpolate(&delta,pixels[2].black,
4403 pixels[3].black,pixels[0].black);
4404 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4405 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[2].alpha,
4406 pixels[3].alpha,pixels[0].alpha);
4411 Top-right triangle (pixel:1 , diagonal: 0-3).
4413 delta.x=1.0-delta.x;
4414 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4415 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4416 pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
4417 pixels[0].red,pixels[3].red);
4418 pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
4419 pixels[0].green,pixels[3].green);
4420 pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
4421 pixels[0].blue,pixels[3].blue);
4422 if (image->colorspace == CMYKColorspace)
4423 pixel->black=gamma*MeshInterpolate(&delta,pixels[1].black,
4424 pixels[0].black,pixels[3].black);
4425 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4426 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[1].alpha,
4427 pixels[0].alpha,pixels[3].alpha);
4435 if (delta.x <= (1.0-delta.y))
4438 Top-left triangle (pixel: 0, diagonal: 1-2).
4440 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4441 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4442 pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
4443 pixels[1].red,pixels[2].red);
4444 pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
4445 pixels[1].green,pixels[2].green);
4446 pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
4447 pixels[1].blue,pixels[2].blue);
4448 if (image->colorspace == CMYKColorspace)
4449 pixel->black=gamma*MeshInterpolate(&delta,pixels[0].black,
4450 pixels[1].black,pixels[2].black);
4451 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4452 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[0].alpha,
4453 pixels[1].alpha,pixels[2].alpha);
4458 Bottom-right triangle (pixel: 3, diagonal: 1-2).
4460 delta.x=1.0-delta.x;
4461 delta.y=1.0-delta.y;
4462 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4463 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4464 pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
4465 pixels[2].red,pixels[1].red);
4466 pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
4467 pixels[2].green,pixels[1].green);
4468 pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
4469 pixels[2].blue,pixels[1].blue);
4470 if (image->colorspace == CMYKColorspace)
4471 pixel->black=gamma*MeshInterpolate(&delta,pixels[3].black,
4472 pixels[2].black,pixels[1].black);
4473 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4474 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[3].alpha,
4475 pixels[2].alpha,pixels[1].alpha);
4480 case NearestNeighborInterpolatePixel:
4482 p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
4483 NearestNeighbor(y),1,1,exception);
4484 if (p == (const Quantum *) NULL)
4489 SetPixelInfo(image,p,pixel);
4492 case SplineInterpolatePixel:
4505 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4507 if (p == (const Quantum *) NULL)
4512 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4513 AlphaBlendPixelInfo(image,p+1*GetPixelChannels(image),pixels+1,alpha+1);
4514 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4515 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4516 AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4517 AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4518 AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4519 AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4520 AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4521 AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4522 AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4524 AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4526 AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4528 AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4530 AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4532 AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4542 for (i=(-1); i < 3L; i++)
4544 dy=CubicWeightingFunction((MagickRealType) i-delta.y);
4545 for (j=(-1); j < 3L; j++)
4547 dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
4548 gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
4549 pixel->red+=gamma*dx*dy*pixels[n].red;
4550 pixel->green+=gamma*dx*dy*pixels[n].green;
4551 pixel->blue+=gamma*dx*dy*pixels[n].blue;
4552 if (image->colorspace == CMYKColorspace)
4553 pixel->black+=gamma*dx*dy*pixels[n].black;
4554 pixel->alpha+=dx*dy*pixels[n].alpha;
4565 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4569 + I s F u z z y E q u i v a l e n c e P i x e l %
4573 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4575 % IsFuzzyEquivalencePixel() returns MagickTrue if the distance between two
4576 % pixels is less than the specified distance in a linear three (or four)u
4577 % dimensional color space.
4579 % The format of the IsFuzzyEquivalencePixel method is:
4581 % void IsFuzzyEquivalencePixel(const Image *image,const Quantum *p,
4584 % A description of each parameter follows:
4586 % o image: the image.
4593 MagickExport MagickBooleanType IsFuzzyEquivalencePixel(const Image *image,
4594 const Quantum *p,const Quantum *q)
4600 register MagickRealType
4604 fuzz=MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2)*
4605 MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2);
4608 if (image->matte != MagickFalse)
4611 Transparencies are involved - set alpha distance
4613 pixel=(MagickRealType) ((image->matte != MagickFalse ?
4614 GetPixelAlpha(image,p) : OpaqueAlpha)-(image->matte != MagickFalse ?
4615 GetPixelAlpha(image,q) : OpaqueAlpha));
4616 distance=pixel*pixel;
4617 if (distance > fuzz)
4618 return(MagickFalse);
4620 Generate a alpha scaling factor to generate a 4D cone on colorspace
4621 Note that if one color is transparent, distance has no color component.
4623 scale=QuantumScale*GetPixelAlpha(image,p);
4624 scale*=QuantumScale*GetPixelAlpha(image,q);
4625 if (scale <= MagickEpsilon)
4629 RGB or CMY color cube
4631 distance*=3.0; /* rescale appropriately */
4633 pixel=GetPixelRed(image,p)-(MagickRealType) GetPixelRed(image,q);
4634 if ((image->colorspace == HSLColorspace) ||
4635 (image->colorspace == HSBColorspace) ||
4636 (image->colorspace == HWBColorspace))
4639 Compute an arc distance for hue. It should be a vector angle of
4640 'S'/'W' length with 'L'/'B' forming appropriate cones.
4642 if (fabs((double) pixel) > (QuantumRange/2))
4643 pixel-=QuantumRange;
4646 distance+=scale*pixel*pixel;
4647 if (distance > fuzz)
4648 return(MagickFalse);
4649 pixel=GetPixelGreen(image,p)-(MagickRealType) GetPixelGreen(image,q);
4650 distance+=scale*pixel*pixel;
4651 if (distance > fuzz)
4652 return(MagickFalse);
4653 pixel=GetPixelBlue(image,p)-(MagickRealType) GetPixelBlue(image,q);
4654 distance+=scale*pixel*pixel;
4655 if (distance > fuzz)
4656 return(MagickFalse);
4661 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4665 + I s F u z z y E q u i v a l e n c e P i x e l I n f o %
4669 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4671 % IsFuzzyEquivalencePixelInfo() returns true if the distance between two
4672 % colors is less than the specified distance in a linear three (or four)
4673 % dimensional color space.
4675 % This implements the equivalent of...
4676 % fuzz < sqrt( color_distance^2 * u.a*v.a + alpha_distance^2 )
4678 % Which produces a multi-dimensional cone for that colorspace along the
4679 % transparency vector.
4681 % For example for an RGB
4682 % color_distance^2 = ( (u.r-v.r)^2 + (u.g-v.g)^2 + (u.b-v.b)^2 ) / 3
4684 % See http://www.imagemagick.org/Usage/bugs/fuzz_distance/
4686 % Hue colorspace distances need more work. Hue is not a distance, it is an
4689 % A check that q is in the same color space as p should be made and the
4690 % appropriate mapping made. -- Anthony Thyssen 8 December 2010
4692 % The format of the IsFuzzyEquivalencePixelInfo method is:
4694 % MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
4695 % const PixelInfo *q)
4697 % A description of each parameter follows:
4704 MagickExport MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
4711 register MagickRealType
4715 if ((p->fuzz == 0.0) && (q->fuzz == 0.0))
4716 return(IsPixelInfoEquivalent(p,q));
4718 fuzz=MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2)*
4719 MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
4720 else if (q->fuzz == 0.0)
4721 fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*
4722 MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2);
4724 fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*
4725 MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
4728 if ((p->matte != MagickFalse) || (q->matte != MagickFalse))
4731 Transparencies are involved - set alpha distance.
4733 pixel=(p->matte != MagickFalse ? p->alpha : OpaqueAlpha)-
4734 (q->matte != MagickFalse ? q->alpha : OpaqueAlpha);
4735 distance=pixel*pixel;
4736 if (distance > fuzz)
4737 return(MagickFalse);
4739 Generate a alpha scaling factor to generate a 4D cone on colorspace.
4740 Note that if one color is transparent, distance has no color component.
4742 if (p->matte != MagickFalse)
4743 scale=(QuantumScale*p->alpha);
4744 if (q->matte != MagickFalse)
4745 scale*=(QuantumScale*q->alpha);
4746 if (scale <= MagickEpsilon )
4750 CMYK create a CMY cube with a multi-dimensional cone toward black.
4752 if (p->colorspace == CMYKColorspace)
4754 pixel=p->black-q->black;
4755 distance+=pixel*pixel*scale;
4756 if (distance > fuzz)
4757 return(MagickFalse);
4758 scale*=(MagickRealType) (QuantumScale*(QuantumRange-p->black));
4759 scale*=(MagickRealType) (QuantumScale*(QuantumRange-q->black));
4762 RGB or CMY color cube.
4764 distance*=3.0; /* rescale appropriately */
4766 pixel=p->red-q->red;
4767 if ((p->colorspace == HSLColorspace) || (p->colorspace == HSBColorspace) ||
4768 (p->colorspace == HWBColorspace))
4770 /* This calculates a arc distance for hue
4771 Really if should be a vector angle of 'S'/'W' length
4772 with 'L'/'B' forming appropriate cones.
4773 In other words this is a hack - Anthony
4775 if (fabs((double) pixel) > (QuantumRange/2))
4776 pixel-=QuantumRange;
4779 distance+=pixel*pixel*scale;
4780 if (distance > fuzz)
4781 return(MagickFalse);
4782 pixel=p->green-q->green;
4783 distance+=pixel*pixel*scale;
4784 if (distance > fuzz)
4785 return(MagickFalse);
4786 pixel=p->blue-q->blue;
4787 distance+=pixel*pixel*scale;
4788 if (distance > fuzz)
4789 return(MagickFalse);
4794 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4798 + I s F u z z y E q u i v a l e n c e P i x e l P a c k e t %
4802 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4804 % IsFuzzyEquivalencePixelPacket() returns MagickTrue if the distance between
4805 % two pixels is less than the specified distance in a linear three (or four)
4806 % dimensional color space.
4808 % The format of the IsFuzzyEquivalencePixelPacket method is:
4810 % void IsFuzzyEquivalencePixelPacket(const Image *image,
4811 % const PixelPacket *p,const PixelPacket *q)
4813 % A description of each parameter follows:
4815 % o image: the image.
4822 MagickExport MagickBooleanType IsFuzzyEquivalencePixelPacket(const Image *image,
4823 const PixelPacket *p,const PixelPacket *q)
4829 register MagickRealType
4833 if ((image->fuzz == 0.0) && (image->matte == MagickFalse))
4834 return(IsPixelPacketEquivalent(p,q));
4835 fuzz=MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2)*
4836 MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2);
4839 if (image->matte != MagickFalse)
4842 Transparencies are involved - set alpha distance
4844 pixel=(MagickRealType) ((image->matte != MagickFalse ? p->alpha :
4845 OpaqueAlpha)-(image->matte != MagickFalse ? q->alpha : OpaqueAlpha));
4846 distance=pixel*pixel;
4847 if (distance > fuzz)
4848 return(MagickFalse);
4850 Generate a alpha scaling factor to generate a 4D cone on colorspace
4851 Note that if one color is transparent, distance has no color component.
4853 scale=QuantumScale*p->alpha;
4854 scale*=QuantumScale*q->alpha;
4855 if (scale <= MagickEpsilon)
4859 RGB or CMY color cube
4861 distance*=3.0; /* rescale appropriately */
4863 pixel=p->red-(MagickRealType) q->red;
4864 if ((image->colorspace == HSLColorspace) ||
4865 (image->colorspace == HSBColorspace) ||
4866 (image->colorspace == HWBColorspace))
4869 Compute an arc distance for hue. It should be a vector angle of
4870 'S'/'W' length with 'L'/'B' forming appropriate cones.
4872 if (fabs((double) pixel) > (QuantumRange/2))
4873 pixel-=QuantumRange;
4876 distance+=scale*pixel*pixel;
4877 if (distance > fuzz)
4878 return(MagickFalse);
4879 pixel=(MagickRealType) p->green-q->green;
4880 distance+=scale*pixel*pixel;
4881 if (distance > fuzz)
4882 return(MagickFalse);
4883 pixel=(MagickRealType) p->blue-q->blue;
4884 distance+=scale*pixel*pixel;
4885 if (distance > fuzz)
4886 return(MagickFalse);
4891 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4895 % S e t P i x e l C h a n n e l M a p %
4899 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4901 % SetPixelChannelMap() sets the pixel channel map from the specified channel
4904 % The format of the SetPixelChannelMap method is:
4906 % void SetPixelChannelMap(Image *image,const ChannelType channel_mask)
4908 % A description of each parameter follows:
4910 % o image: the image.
4912 % o mask: the channel mask.
4915 MagickExport void SetPixelChannelMap(Image *image,
4916 const ChannelType channel_mask)
4918 #define GetChannelBit(mask,bit) (((size_t) (mask) >> (size_t) (bit)) & 0x01)
4923 image->sync=channel_mask == DefaultChannels ? MagickTrue : MagickFalse;
4924 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
4925 SetPixelChannelMapTraits(image,(PixelChannel) i,
4926 GetChannelBit(channel_mask,i) != 0 ? UpdatePixelTrait : CopyPixelTrait);
4927 for ( ; i < MaxPixelChannels; i++)
4928 SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
4929 if (image->storage_class == PseudoClass)
4930 SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
4934 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4938 % S e t P i x e l C h a n n e l M a s k %
4942 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4944 % SetPixelChannelMask() sets the pixel channel mask from the specified
4947 % The format of the SetPixelChannelMask method is:
4949 % ChannelType SetPixelChannelMask(Image *image,
4950 % const ChannelType channel_mask)
4952 % A description of each parameter follows:
4954 % o image: the image.
4956 % o channel_mask: the channel mask.
4959 MagickExport ChannelType SetPixelChannelMask(Image *image,
4960 const ChannelType channel_mask)
4965 mask=image->channel_mask;
4966 image->channel_mask=channel_mask;
4967 SetPixelChannelMap(image,channel_mask);