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 *) AcquireQuantumMemory(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 PixelInterpolateMethod 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 PixelInterpolateMethod 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+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 C h a n n e l s %
4052 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4054 % InterpolatePixelChannels() 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 InterpolatePixelChannels method is:
4060 % MagickBooleanType InterpolatePixelChannels(const Image *source,
4061 % const CacheView *source_view,const Image *destination,
4062 % const PixelInterpolateMethod method,const double x,const double y,
4063 % Quantum *pixel,ExceptionInfo *exception)
4065 % A description of each parameter follows:
4067 % o source: the source.
4069 % o source_view: the source view.
4071 % o destination: the destination image.
4073 % o method: the pixel color interpolation method.
4075 % o x,y: A double representing the current (x,y) position of the pixel.
4077 % o pixel: return the interpolated pixel here.
4079 % o exception: return any errors or warnings in this structure.
4082 MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
4083 const CacheView *source_view,const Image *destination,
4084 const PixelInterpolateMethod method,const double x,const double y,
4085 Quantum *pixel,ExceptionInfo *exception)
4102 register const Quantum
4112 assert(source != (Image *) NULL);
4113 assert(source != (Image *) NULL);
4114 assert(source->signature == MagickSignature);
4115 assert(source_view != (CacheView *) NULL);
4117 x_offset=(ssize_t) floor(x);
4118 y_offset=(ssize_t) floor(y);
4119 switch (method == UndefinedInterpolatePixel ? source->interpolate : method)
4121 case AverageInterpolatePixel:
4123 p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4125 if (p == (const Quantum *) NULL)
4130 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4138 traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4139 channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4140 destination_traits=GetPixelChannelMapTraits(destination,channel);
4141 if ((traits == UndefinedPixelTrait) ||
4142 (destination_traits == UndefinedPixelTrait))
4144 for (j=0; j < 16; j++)
4145 pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4146 if ((traits & BlendPixelTrait) == 0)
4148 for (j=0; j < 16; j++)
4149 pixel[channel]+=0.0625*pixels[j];
4153 for (j=0; j < 16; j++)
4155 alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4156 GetPixelChannels(source));
4157 pixels[j]*=alpha[j];
4158 gamma=1.0/(fabs((double) alpha[j]) <= MagickEpsilon ? 1.0 : alpha[j]);
4159 sum+=gamma*0.0625*pixels[j];
4161 pixel[channel]=ClampToQuantum(sum);
4165 case BicubicInterpolatePixel:
4174 p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4176 if (p == (const Quantum *) NULL)
4181 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4186 traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4187 channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4188 destination_traits=GetPixelChannelMapTraits(destination,channel);
4189 if ((traits == UndefinedPixelTrait) ||
4190 (destination_traits == UndefinedPixelTrait))
4192 if ((traits & BlendPixelTrait) == 0)
4193 for (j=0; j < 16; j++)
4196 pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4199 for (j=0; j < 16; j++)
4201 alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4202 GetPixelChannels(source));
4203 pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
4207 for (j=0; j < 4; j++)
4209 u[0]=(pixels[4*j+3]-pixels[4*j+2])-(pixels[4*j+0]-pixels[4*j+1]);
4210 u[1]=(pixels[4*j+0]-pixels[4*j+1])-u[0];
4211 u[2]=pixels[4*j+2]-pixels[4*j+0];
4213 v[j]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
4216 u[0]=(v[3]-v[2])-(v[0]-v[1]);
4217 u[1]=(v[0]-v[1])-u[0];
4220 pixel[channel]=ClampToQuantum((delta.y*delta.y*delta.y*u[0])+(delta.y*
4221 delta.y*u[1])+(delta.y*u[2])+u[3]);
4225 case BilinearInterpolatePixel:
4228 p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
4229 if (p == (const Quantum *) NULL)
4234 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4240 traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4241 channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4242 destination_traits=GetPixelChannelMapTraits(destination,channel);
4243 if ((traits == UndefinedPixelTrait) ||
4244 (destination_traits == UndefinedPixelTrait))
4248 epsilon.x=1.0-delta.x;
4249 epsilon.y=1.0-delta.y;
4250 pixels[0]=(MagickRealType) p[i];
4251 pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
4252 pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
4253 pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
4254 if ((traits & BlendPixelTrait) == 0)
4256 gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4257 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4258 pixel[channel]=ClampToQuantum(gamma*(epsilon.y*(epsilon.x*pixels[0]+
4259 delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+delta.x*
4263 alpha[0]=QuantumScale*GetPixelAlpha(source,p);
4264 alpha[1]=QuantumScale*GetPixelAlpha(source,p+GetPixelChannels(source));
4265 alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
4266 GetPixelChannels(source));
4267 alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
4268 GetPixelChannels(source));
4269 pixels[0]*=alpha[0];
4270 pixels[1]*=alpha[1];
4271 pixels[2]*=alpha[2];
4272 pixels[3]*=alpha[3];
4273 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4274 (epsilon.x*alpha[2]+delta.x*alpha[3])));
4275 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4276 pixel[channel]=ClampToQuantum(gamma*(epsilon.y*(epsilon.x*pixels[0]+
4277 delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+delta.x*pixels[3])));
4281 case FilterInterpolatePixel:
4283 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4295 traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4296 channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4297 destination_traits=GetPixelChannelMapTraits(destination,channel);
4298 if ((traits == UndefinedPixelTrait) ||
4299 (destination_traits == UndefinedPixelTrait))
4303 geometry.x=x_offset-1;
4304 geometry.y=y_offset-1;
4305 excerpt_source=ExcerptImage(source,&geometry,exception);
4306 if (excerpt_source == (Image *) NULL)
4311 filter_source=ResizeImage(excerpt_source,1,1,source->filter,
4312 source->blur,exception);
4313 excerpt_source=DestroyImage(excerpt_source);
4314 if (filter_source == (Image *) NULL)
4316 filter_view=AcquireCacheView(filter_source);
4317 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4318 if (p == (const Quantum *) NULL)
4321 pixel[channel]=p[i];
4322 filter_view=DestroyCacheView(filter_view);
4323 filter_source=DestroyImage(filter_source);
4327 case IntegerInterpolatePixel:
4329 p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
4330 if (p == (const Quantum *) NULL)
4335 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4337 traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4338 channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4339 destination_traits=GetPixelChannelMapTraits(destination,channel);
4340 if ((traits == UndefinedPixelTrait) ||
4341 (destination_traits == UndefinedPixelTrait))
4343 pixel[channel]=p[i];
4347 case NearestNeighborInterpolatePixel:
4349 p=GetCacheViewVirtualPixels(source_view,NearestNeighbor(x),
4350 NearestNeighbor(y),1,1,exception);
4351 if (p == (const Quantum *) NULL)
4356 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4358 traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4359 channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4360 destination_traits=GetPixelChannelMapTraits(destination,channel);
4361 if ((traits == UndefinedPixelTrait) ||
4362 (destination_traits == UndefinedPixelTrait))
4364 pixel[channel]=p[i];
4368 case MeshInterpolatePixel:
4370 p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
4371 if (p == (const Quantum *) NULL)
4376 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4382 traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4383 channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4384 destination_traits=GetPixelChannelMapTraits(destination,channel);
4385 if ((traits == UndefinedPixelTrait) ||
4386 (destination_traits == UndefinedPixelTrait))
4388 pixels[0]=(MagickRealType) p[i];
4389 pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
4390 pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
4391 pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
4392 if ((traits & BlendPixelTrait) == 0)
4401 alpha[0]=QuantumScale*GetPixelAlpha(source,p);
4402 alpha[1]=QuantumScale*GetPixelAlpha(source,p+
4403 GetPixelChannels(source));
4404 alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
4405 GetPixelChannels(source));
4406 alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
4407 GetPixelChannels(source));
4411 luminance.x=GetPixelLuminance(source,p)-(double)
4412 GetPixelLuminance(source,p+3*GetPixelChannels(source));
4413 luminance.y=GetPixelLuminance(source,p+GetPixelChannels(source))-
4414 (double) GetPixelLuminance(source,p+2*GetPixelChannels(source));
4415 if (fabs(luminance.x) < fabs(luminance.y))
4420 if (delta.x <= delta.y)
4423 Bottom-left triangle (pixel: 2, diagonal: 0-3).
4425 delta.y=1.0-delta.y;
4426 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4427 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4428 pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4429 pixels[2],pixels[3],pixels[0]));
4434 Top-right triangle (pixel: 1, diagonal: 0-3).
4436 delta.x=1.0-delta.x;
4437 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4438 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4439 pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4440 pixels[1],pixels[0],pixels[3]));
4448 if (delta.x <= (1.0-delta.y))
4451 Top-left triangle (pixel: 0, diagonal: 1-2).
4453 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4454 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4455 pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4456 pixels[0],pixels[1],pixels[2]));
4461 Bottom-right triangle (pixel: 3, diagonal: 1-2).
4463 delta.x=1.0-delta.x;
4464 delta.y=1.0-delta.y;
4465 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4466 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4467 pixel[channel]=ClampToQuantum(gamma*MeshInterpolate(&delta,
4468 pixels[3],pixels[2],pixels[1]));
4474 case SplineInterpolatePixel:
4476 p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4478 if (p == (const Quantum *) NULL)
4483 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4502 traits=GetPixelChannelMapTraits(source,(PixelChannel) i);
4503 channel=GetPixelChannelMapChannel(source,(PixelChannel) i);
4504 destination_traits=GetPixelChannelMapTraits(destination,channel);
4505 if ((traits == UndefinedPixelTrait) ||
4506 (destination_traits == UndefinedPixelTrait))
4508 if ((traits & BlendPixelTrait) == 0)
4509 for (j=0; j < 16; j++)
4512 pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4515 for (j=0; j < 16; j++)
4517 alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4518 GetPixelChannels(source));
4519 pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
4525 for (j=(-1); j < 3L; j++)
4527 dy=CubicWeightingFunction((MagickRealType) j-delta.y);
4528 for (k=(-1); k < 3L; k++)
4530 dx=CubicWeightingFunction(delta.x-(MagickRealType) k);
4531 gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 :
4533 sum+=gamma*dx*dy*pixels[n];
4537 pixel[channel]=ClampToQuantum(sum);
4546 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4550 % I n t e r p o l a t e P i x e l I n f o %
4554 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4556 % InterpolatePixelInfo() applies a pixel interpolation method between a
4557 % floating point coordinate and the pixels surrounding that coordinate. No
4558 % pixel area resampling, or scaling of the result is performed.
4560 % The format of the InterpolatePixelInfo method is:
4562 % MagickBooleanType InterpolatePixelInfo(const Image *image,
4563 % const CacheView *image_view,const PixelInterpolateMethod method,
4564 % const double x,const double y,PixelInfo *pixel,
4565 % ExceptionInfo *exception)
4567 % A description of each parameter follows:
4569 % o image: the image.
4571 % o image_view: the image view.
4573 % o method: the pixel color interpolation method.
4575 % o x,y: A double representing the current (x,y) position of the pixel.
4577 % o pixel: return the interpolated pixel here.
4579 % o exception: return any errors or warnings in this structure.
4583 static inline void AlphaBlendPixelInfo(const Image *image,
4584 const Quantum *pixel,PixelInfo *pixel_info,MagickRealType *alpha)
4586 if (image->matte == MagickFalse)
4589 pixel_info->red=(MagickRealType) GetPixelRed(image,pixel);
4590 pixel_info->green=(MagickRealType) GetPixelGreen(image,pixel);
4591 pixel_info->blue=(MagickRealType) GetPixelBlue(image,pixel);
4592 pixel_info->black=0.0;
4593 if (image->colorspace == CMYKColorspace)
4594 pixel_info->black=(MagickRealType) GetPixelBlack(image,pixel);
4595 pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
4598 *alpha=QuantumScale*GetPixelAlpha(image,pixel);
4599 pixel_info->red=(*alpha*GetPixelRed(image,pixel));
4600 pixel_info->green=(*alpha*GetPixelGreen(image,pixel));
4601 pixel_info->blue=(*alpha*GetPixelBlue(image,pixel));
4602 pixel_info->black=0.0;
4603 if (image->colorspace == CMYKColorspace)
4604 pixel_info->black=(*alpha*GetPixelBlack(image,pixel));
4605 pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
4608 static void BicubicInterpolate(const PixelInfo *pixels,const double dx,
4619 p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
4620 q=(pixels[0].red-pixels[1].red)-p;
4621 r=pixels[2].red-pixels[0].red;
4623 pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4624 p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
4625 q=(pixels[0].green-pixels[1].green)-p;
4626 r=pixels[2].green-pixels[0].green;
4628 pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4629 p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue);
4630 q=(pixels[0].blue-pixels[1].blue)-p;
4631 r=pixels[2].blue-pixels[0].blue;
4633 pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4634 p=(pixels[3].alpha-pixels[2].alpha)-(pixels[0].alpha-pixels[1].alpha);
4635 q=(pixels[0].alpha-pixels[1].alpha)-p;
4636 r=pixels[2].alpha-pixels[0].alpha;
4638 pixel->alpha=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4639 if (pixel->colorspace == CMYKColorspace)
4641 p=(pixels[3].black-pixels[2].black)-(pixels[0].black-pixels[1].black);
4642 q=(pixels[0].black-pixels[1].black)-p;
4643 r=pixels[2].black-pixels[0].black;
4645 pixel->black=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
4649 MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
4650 const CacheView *image_view,const PixelInterpolateMethod method,
4651 const double x,const double y,PixelInfo *pixel,ExceptionInfo *exception)
4663 register const Quantum
4673 assert(image != (Image *) NULL);
4674 assert(image->signature == MagickSignature);
4675 assert(image_view != (CacheView *) NULL);
4677 x_offset=(ssize_t) floor(x);
4678 y_offset=(ssize_t) floor(y);
4679 switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
4681 case AverageInterpolatePixel:
4683 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4685 if (p == (const Quantum *) NULL)
4690 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4691 AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4692 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4693 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4694 AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4695 AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4696 AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4697 AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4698 AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4699 AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4700 AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4702 AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4704 AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4706 AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4708 AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4710 AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4717 for (i=0; i < 16L; i++)
4719 gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
4720 pixel->red+=gamma*0.0625*pixels[i].red;
4721 pixel->green+=gamma*0.0625*pixels[i].green;
4722 pixel->blue+=gamma*0.0625*pixels[i].blue;
4723 if (image->colorspace == CMYKColorspace)
4724 pixel->black+=gamma*0.0625*pixels[i].black;
4725 pixel->alpha+=0.0625*pixels[i].alpha;
4729 case BicubicInterpolatePixel:
4737 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4739 if (p == (const Quantum *) NULL)
4744 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4745 AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4746 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4747 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4748 AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
4749 AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
4750 AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
4751 AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
4752 AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
4753 AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
4754 AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
4756 AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
4758 AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
4760 AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
4762 AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
4764 AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
4768 for (i=0; i < 4L; i++)
4769 BicubicInterpolate(pixels+4*i,delta.x,u+i);
4770 BicubicInterpolate(u,delta.y,pixel);
4773 case BilinearInterpolatePixel:
4780 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4781 if (p == (const Quantum *) NULL)
4786 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4787 AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4788 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4789 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4792 epsilon.x=1.0-delta.x;
4793 epsilon.y=1.0-delta.y;
4794 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4795 (epsilon.x*alpha[2]+delta.x*alpha[3])));
4796 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4797 pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
4798 pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
4799 pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
4800 pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
4802 pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
4803 pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
4805 if (image->colorspace == CMYKColorspace)
4806 pixel->black=gamma*(epsilon.y*(epsilon.x*pixels[0].black+delta.x*
4807 pixels[1].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
4809 gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4810 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4811 pixel->alpha=(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
4812 pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
4816 case FilterInterpolatePixel:
4830 geometry.x=x_offset-1;
4831 geometry.y=y_offset-1;
4832 excerpt_image=ExcerptImage(image,&geometry,exception);
4833 if (excerpt_image == (Image *) NULL)
4838 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
4840 excerpt_image=DestroyImage(excerpt_image);
4841 if (filter_image == (Image *) NULL)
4843 filter_view=AcquireCacheView(filter_image);
4844 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4845 if (p != (const Quantum *) NULL)
4846 SetPixelInfo(image,p,pixel);
4847 filter_view=DestroyCacheView(filter_view);
4848 filter_image=DestroyImage(filter_image);
4851 case IntegerInterpolatePixel:
4853 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4854 if (p == (const Quantum *) NULL)
4859 SetPixelInfo(image,p,pixel);
4862 case MeshInterpolatePixel:
4868 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4869 if (p == (const Quantum *) NULL)
4876 luminance.x=GetPixelLuminance(image,p)-(double)
4877 GetPixelLuminance(image,p+3*GetPixelChannels(image));
4878 luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
4879 GetPixelLuminance(image,p+2*GetPixelChannels(image));
4880 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
4881 AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
4882 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
4883 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
4884 if (fabs(luminance.x) < fabs(luminance.y))
4889 if (delta.x <= delta.y)
4892 Bottom-left triangle (pixel: 2, diagonal: 0-3).
4894 delta.y=1.0-delta.y;
4895 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4896 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4897 pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
4898 pixels[3].red,pixels[0].red);
4899 pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
4900 pixels[3].green,pixels[0].green);
4901 pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
4902 pixels[3].blue,pixels[0].blue);
4903 if (image->colorspace == CMYKColorspace)
4904 pixel->black=gamma*MeshInterpolate(&delta,pixels[2].black,
4905 pixels[3].black,pixels[0].black);
4906 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4907 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[2].alpha,
4908 pixels[3].alpha,pixels[0].alpha);
4913 Top-right triangle (pixel:1 , diagonal: 0-3).
4915 delta.x=1.0-delta.x;
4916 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4917 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4918 pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
4919 pixels[0].red,pixels[3].red);
4920 pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
4921 pixels[0].green,pixels[3].green);
4922 pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
4923 pixels[0].blue,pixels[3].blue);
4924 if (image->colorspace == CMYKColorspace)
4925 pixel->black=gamma*MeshInterpolate(&delta,pixels[1].black,
4926 pixels[0].black,pixels[3].black);
4927 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4928 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[1].alpha,
4929 pixels[0].alpha,pixels[3].alpha);
4937 if (delta.x <= (1.0-delta.y))
4940 Top-left triangle (pixel: 0, diagonal: 1-2).
4942 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4943 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4944 pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
4945 pixels[1].red,pixels[2].red);
4946 pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
4947 pixels[1].green,pixels[2].green);
4948 pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
4949 pixels[1].blue,pixels[2].blue);
4950 if (image->colorspace == CMYKColorspace)
4951 pixel->black=gamma*MeshInterpolate(&delta,pixels[0].black,
4952 pixels[1].black,pixels[2].black);
4953 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4954 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[0].alpha,
4955 pixels[1].alpha,pixels[2].alpha);
4960 Bottom-right triangle (pixel: 3, diagonal: 1-2).
4962 delta.x=1.0-delta.x;
4963 delta.y=1.0-delta.y;
4964 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4965 gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
4966 pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
4967 pixels[2].red,pixels[1].red);
4968 pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
4969 pixels[2].green,pixels[1].green);
4970 pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
4971 pixels[2].blue,pixels[1].blue);
4972 if (image->colorspace == CMYKColorspace)
4973 pixel->black=gamma*MeshInterpolate(&delta,pixels[3].black,
4974 pixels[2].black,pixels[1].black);
4975 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4976 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[3].alpha,
4977 pixels[2].alpha,pixels[1].alpha);
4982 case NearestNeighborInterpolatePixel:
4984 p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
4985 NearestNeighbor(y),1,1,exception);
4986 if (p == (const Quantum *) NULL)
4991 SetPixelInfo(image,p,pixel);
4994 case SplineInterpolatePixel:
5007 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
5009 if (p == (const Quantum *) NULL)
5014 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
5015 AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
5016 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
5017 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
5018 AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
5019 AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
5020 AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
5021 AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
5022 AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
5023 AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
5024 AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
5026 AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
5028 AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
5030 AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
5032 AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
5034 AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
5044 for (i=(-1); i < 3L; i++)
5046 dy=CubicWeightingFunction((MagickRealType) i-delta.y);
5047 for (j=(-1); j < 3L; j++)
5049 dx=CubicWeightingFunction(delta.x-(MagickRealType) j);
5050 gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]);
5051 pixel->red+=gamma*dx*dy*pixels[n].red;
5052 pixel->green+=gamma*dx*dy*pixels[n].green;
5053 pixel->blue+=gamma*dx*dy*pixels[n].blue;
5054 if (image->colorspace == CMYKColorspace)
5055 pixel->black+=gamma*dx*dy*pixels[n].black;
5056 pixel->alpha+=dx*dy*pixels[n].alpha;
5067 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5071 + I s F u z z y E q u i v a l e n c e P i x e l %
5075 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5077 % IsFuzzyEquivalencePixel() returns MagickTrue if the distance between two
5078 % pixels is less than the specified distance in a linear three (or four)u
5079 % dimensional color space.
5081 % The format of the IsFuzzyEquivalencePixel method is:
5083 % void IsFuzzyEquivalencePixel(const Image *image,const Quantum *p,
5086 % A description of each parameter follows:
5088 % o image: the image.
5095 MagickExport MagickBooleanType IsFuzzyEquivalencePixel(const Image *image,
5096 const Quantum *p,const Quantum *q)
5102 register MagickRealType
5106 fuzz=MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2)*
5107 MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2);
5110 if (image->matte != MagickFalse)
5113 Transparencies are involved - set alpha distance
5115 pixel=(MagickRealType) ((image->matte != MagickFalse ?
5116 GetPixelAlpha(image,p) : OpaqueAlpha)-(image->matte != MagickFalse ?
5117 GetPixelAlpha(image,q) : OpaqueAlpha));
5118 distance=pixel*pixel;
5119 if (distance > fuzz)
5120 return(MagickFalse);
5122 Generate a alpha scaling factor to generate a 4D cone on colorspace
5123 Note that if one color is transparent, distance has no color component.
5125 scale=QuantumScale*GetPixelAlpha(image,p);
5126 scale*=QuantumScale*GetPixelAlpha(image,q);
5127 if (scale <= MagickEpsilon)
5131 RGB or CMY color cube
5133 distance*=3.0; /* rescale appropriately */
5135 pixel=GetPixelRed(image,p)-(MagickRealType) GetPixelRed(image,q);
5136 if ((image->colorspace == HSLColorspace) ||
5137 (image->colorspace == HSBColorspace) ||
5138 (image->colorspace == HWBColorspace))
5141 Compute an arc distance for hue. It should be a vector angle of
5142 'S'/'W' length with 'L'/'B' forming appropriate cones.
5144 if (fabs((double) pixel) > (QuantumRange/2))
5145 pixel-=QuantumRange;
5148 distance+=scale*pixel*pixel;
5149 if (distance > fuzz)
5150 return(MagickFalse);
5151 pixel=GetPixelGreen(image,p)-(MagickRealType) GetPixelGreen(image,q);
5152 distance+=scale*pixel*pixel;
5153 if (distance > fuzz)
5154 return(MagickFalse);
5155 pixel=GetPixelBlue(image,p)-(MagickRealType) GetPixelBlue(image,q);
5156 distance+=scale*pixel*pixel;
5157 if (distance > fuzz)
5158 return(MagickFalse);
5163 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5167 + 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 %
5171 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5173 % IsFuzzyEquivalencePixelInfo() returns true if the distance between two
5174 % colors is less than the specified distance in a linear three (or four)
5175 % dimensional color space.
5177 % This implements the equivalent of...
5178 % fuzz < sqrt( color_distance^2 * u.a*v.a + alpha_distance^2 )
5180 % Which produces a multi-dimensional cone for that colorspace along the
5181 % transparency vector.
5183 % For example for an RGB
5184 % color_distance^2 = ( (u.r-v.r)^2 + (u.g-v.g)^2 + (u.b-v.b)^2 ) / 3
5186 % See http://www.imagemagick.org/Usage/bugs/fuzz_distance/
5188 % Hue colorspace distances need more work. Hue is not a distance, it is an
5191 % A check that q is in the same color space as p should be made and the
5192 % appropriate mapping made. -- Anthony Thyssen 8 December 2010
5194 % The format of the IsFuzzyEquivalencePixelInfo method is:
5196 % MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
5197 % const PixelInfo *q)
5199 % A description of each parameter follows:
5206 MagickExport MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
5213 register MagickRealType
5217 if ((p->fuzz == 0.0) && (q->fuzz == 0.0))
5218 return(IsPixelInfoEquivalent(p,q));
5220 fuzz=MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2)*
5221 MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
5222 else if (q->fuzz == 0.0)
5223 fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*
5224 MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2);
5226 fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*
5227 MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
5230 if ((p->matte != MagickFalse) || (q->matte != MagickFalse))
5233 Transparencies are involved - set alpha distance.
5235 pixel=(p->matte != MagickFalse ? p->alpha : OpaqueAlpha)-
5236 (q->matte != MagickFalse ? q->alpha : OpaqueAlpha);
5237 distance=pixel*pixel;
5238 if (distance > fuzz)
5239 return(MagickFalse);
5241 Generate a alpha scaling factor to generate a 4D cone on colorspace.
5242 Note that if one color is transparent, distance has no color component.
5244 if (p->matte != MagickFalse)
5245 scale=(QuantumScale*p->alpha);
5246 if (q->matte != MagickFalse)
5247 scale*=(QuantumScale*q->alpha);
5248 if (scale <= MagickEpsilon )
5252 CMYK create a CMY cube with a multi-dimensional cone toward black.
5254 if (p->colorspace == CMYKColorspace)
5256 pixel=p->black-q->black;
5257 distance+=pixel*pixel*scale;
5258 if (distance > fuzz)
5259 return(MagickFalse);
5260 scale*=(MagickRealType) (QuantumScale*(QuantumRange-p->black));
5261 scale*=(MagickRealType) (QuantumScale*(QuantumRange-q->black));
5264 RGB or CMY color cube.
5266 distance*=3.0; /* rescale appropriately */
5268 pixel=p->red-q->red;
5269 if ((p->colorspace == HSLColorspace) || (p->colorspace == HSBColorspace) ||
5270 (p->colorspace == HWBColorspace))
5272 /* This calculates a arc distance for hue
5273 Really if should be a vector angle of 'S'/'W' length
5274 with 'L'/'B' forming appropriate cones.
5275 In other words this is a hack - Anthony
5277 if (fabs((double) pixel) > (QuantumRange/2))
5278 pixel-=QuantumRange;
5281 distance+=pixel*pixel*scale;
5282 if (distance > fuzz)
5283 return(MagickFalse);
5284 pixel=p->green-q->green;
5285 distance+=pixel*pixel*scale;
5286 if (distance > fuzz)
5287 return(MagickFalse);
5288 pixel=p->blue-q->blue;
5289 distance+=pixel*pixel*scale;
5290 if (distance > fuzz)
5291 return(MagickFalse);
5296 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5300 + 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 %
5304 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5306 % IsFuzzyEquivalencePixelPacket() returns MagickTrue if the distance between
5307 % two pixels is less than the specified distance in a linear three (or four)
5308 % dimensional color space.
5310 % The format of the IsFuzzyEquivalencePixelPacket method is:
5312 % void IsFuzzyEquivalencePixelPacket(const Image *image,
5313 % const PixelPacket *p,const PixelPacket *q)
5315 % A description of each parameter follows:
5317 % o image: the image.
5324 MagickExport MagickBooleanType IsFuzzyEquivalencePixelPacket(const Image *image,
5325 const PixelPacket *p,const PixelPacket *q)
5331 register MagickRealType
5335 if ((image->fuzz == 0.0) && (image->matte == MagickFalse))
5336 return(IsPixelPacketEquivalent(p,q));
5337 fuzz=MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2)*
5338 MagickMax(image->fuzz,(MagickRealType) MagickSQ1_2);
5341 if (image->matte != MagickFalse)
5344 Transparencies are involved - set alpha distance
5346 pixel=(MagickRealType) ((image->matte != MagickFalse ? p->alpha :
5347 OpaqueAlpha)-(image->matte != MagickFalse ? q->alpha : OpaqueAlpha));
5348 distance=pixel*pixel;
5349 if (distance > fuzz)
5350 return(MagickFalse);
5352 Generate a alpha scaling factor to generate a 4D cone on colorspace
5353 Note that if one color is transparent, distance has no color component.
5355 scale=QuantumScale*p->alpha;
5356 scale*=QuantumScale*q->alpha;
5357 if (scale <= MagickEpsilon)
5361 RGB or CMY color cube
5363 distance*=3.0; /* rescale appropriately */
5365 pixel=p->red-(MagickRealType) q->red;
5366 if ((image->colorspace == HSLColorspace) ||
5367 (image->colorspace == HSBColorspace) ||
5368 (image->colorspace == HWBColorspace))
5371 Compute an arc distance for hue. It should be a vector angle of
5372 'S'/'W' length with 'L'/'B' forming appropriate cones.
5374 if (fabs((double) pixel) > (QuantumRange/2))
5375 pixel-=QuantumRange;
5378 distance+=scale*pixel*pixel;
5379 if (distance > fuzz)
5380 return(MagickFalse);
5381 pixel=(MagickRealType) p->green-q->green;
5382 distance+=scale*pixel*pixel;
5383 if (distance > fuzz)
5384 return(MagickFalse);
5385 pixel=(MagickRealType) p->blue-q->blue;
5386 distance+=scale*pixel*pixel;
5387 if (distance > fuzz)
5388 return(MagickFalse);
5393 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5397 % S e t P i x e l C h a n n e l M a p %
5401 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5403 % SetPixelChannelMap() sets the pixel channel map from the specified channel
5406 % The format of the SetPixelChannelMap method is:
5408 % void SetPixelChannelMap(Image *image,const ChannelType channel_mask)
5410 % A description of each parameter follows:
5412 % o image: the image.
5414 % o mask: the channel mask.
5417 MagickExport void SetPixelChannelMap(Image *image,
5418 const ChannelType channel_mask)
5420 #define GetChannelBit(mask,bit) (((size_t) (mask) >> (size_t) (bit)) & 0x01)
5425 image->sync=channel_mask == DefaultChannels ? MagickTrue : MagickFalse;
5426 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
5427 SetPixelChannelMapTraits(image,(PixelChannel) i,
5428 GetChannelBit(channel_mask,i) != 0 ? UpdatePixelTrait : CopyPixelTrait);
5429 for ( ; i < MaxPixelChannels; i++)
5430 SetPixelChannelMapTraits(image,(PixelChannel) i,UndefinedPixelTrait);
5431 if (image->storage_class == PseudoClass)
5432 SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
5436 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5440 % S e t P i x e l C h a n n e l M a s k %
5444 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5446 % SetPixelChannelMask() sets the pixel channel mask from the specified
5449 % The format of the SetPixelChannelMask method is:
5451 % ChannelType SetPixelChannelMask(Image *image,
5452 % const ChannelType channel_mask)
5454 % A description of each parameter follows:
5456 % o image: the image.
5458 % o channel_mask: the channel mask.
5461 MagickExport ChannelType SetPixelChannelMask(Image *image,
5462 const ChannelType channel_mask)
5467 mask=image->channel_mask;
5468 image->channel_mask=channel_mask;
5469 SetPixelChannelMap(image,channel_mask);