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-2012 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/cache-private.h"
46 #include "MagickCore/color-private.h"
47 #include "MagickCore/draw.h"
48 #include "MagickCore/exception.h"
49 #include "MagickCore/exception-private.h"
50 #include "MagickCore/cache.h"
51 #include "MagickCore/constitute.h"
52 #include "MagickCore/delegate.h"
53 #include "MagickCore/geometry.h"
54 #include "MagickCore/image-private.h"
55 #include "MagickCore/list.h"
56 #include "MagickCore/magick.h"
57 #include "MagickCore/memory_.h"
58 #include "MagickCore/monitor.h"
59 #include "MagickCore/option.h"
60 #include "MagickCore/pixel.h"
61 #include "MagickCore/pixel-accessor.h"
62 #include "MagickCore/pixel-private.h"
63 #include "MagickCore/quantum.h"
64 #include "MagickCore/quantum-private.h"
65 #include "MagickCore/resource_.h"
66 #include "MagickCore/semaphore.h"
67 #include "MagickCore/statistic.h"
68 #include "MagickCore/stream.h"
69 #include "MagickCore/string_.h"
70 #include "MagickCore/transform.h"
71 #include "MagickCore/utility.h"
73 #define LogPixelChannels(image) \
78 (void) LogMagickEvent(PixelEvent,GetMagickModule(),"%s[%.20g]", \
79 image->filename,(double) image->number_channels); \
80 for (i=0; i < (ssize_t) image->number_channels; i++) \
83 traits[MaxTextExtent]; \
91 switch (GetPixelChannelMapChannel(image,i)) \
93 case RedPixelChannel: \
96 if (image->colorspace == CMYKColorspace) \
98 if (image->colorspace == GRAYColorspace) \
102 case GreenPixelChannel: \
105 if (image->colorspace == CMYKColorspace) \
109 case BluePixelChannel: \
112 if (image->colorspace == CMYKColorspace) \
116 case BlackPixelChannel: \
119 if (image->storage_class == PseudoClass) \
123 case IndexPixelChannel: \
128 case AlphaPixelChannel: \
133 case MaskPixelChannel: \
138 case MetaPixelChannel: \
146 channel=GetPixelChannelMapChannel(image,i); \
148 if ((GetPixelChannelMapTraits(image,channel) & UpdatePixelTrait) != 0) \
149 (void) ConcatenateMagickString(traits,"update,",MaxTextExtent); \
150 if ((GetPixelChannelMapTraits(image,channel) & BlendPixelTrait) != 0) \
151 (void) ConcatenateMagickString(traits,"blend,",MaxTextExtent); \
152 if ((GetPixelChannelMapTraits(image,channel) & CopyPixelTrait) != 0) \
153 (void) ConcatenateMagickString(traits,"copy,",MaxTextExtent); \
154 if (*traits == '\0') \
155 (void) ConcatenateMagickString(traits,"undefined,",MaxTextExtent); \
156 traits[strlen(traits)-1]='\0'; \
157 (void) LogMagickEvent(PixelEvent,GetMagickModule()," %.20g: %s (%s)", \
158 (double) i,name,traits); \
163 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
167 + A c q u i r e P i x e l C h a n n e l M a p %
171 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
173 % AcquirePixelChannelMap() acquires a pixel component map.
175 % The format of the AcquirePixelChannelMap() method is:
177 % PixelChannelMap *AcquirePixelChannelMap(void)
180 MagickExport PixelChannelMap *AcquirePixelChannelMap(void)
188 channel_map=(PixelChannelMap *) AcquireQuantumMemory(MaxPixelChannels,
189 sizeof(*channel_map));
190 if (channel_map == (PixelChannelMap *) NULL)
191 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
192 (void) ResetMagickMemory(channel_map,0,MaxPixelChannels*sizeof(*channel_map));
193 for (i=0; i < MaxPixelChannels; i++)
194 channel_map[i].channel=(PixelChannel) i;
199 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
203 + C l o n e P i x e l C h a n n e l M a p %
207 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
209 % ClonePixelChannelMap() clones a pixel component map.
211 % The format of the ClonePixelChannelMap() method is:
213 % PixelChannelMap *ClonePixelChannelMap(PixelChannelMap *channel_map)
215 % A description of each parameter follows:
217 % o channel_map: the pixel component map.
220 MagickExport PixelChannelMap *ClonePixelChannelMap(PixelChannelMap *channel_map)
225 assert(channel_map != (PixelChannelMap *) NULL);
226 clone_map=AcquirePixelChannelMap();
227 if (clone_map == (PixelChannelMap *) NULL)
228 return((PixelChannelMap *) NULL);
229 (void) CopyMagickMemory(clone_map,channel_map,MaxPixelChannels*
230 sizeof(*channel_map));
235 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
239 + C l o n e P i x e l I n f o %
243 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
245 % ClonePixelInfo() makes a duplicate of the given pixel info structure, or if
246 % pixel info is NULL, a new one.
248 % The format of the ClonePixelInfo method is:
250 % PixelInfo *ClonePixelInfo(const PixelInfo *pixel_info)
252 % A description of each parameter follows:
254 % o pixel_info: the pixel info.
257 MagickExport PixelInfo *ClonePixelInfo(const PixelInfo *pixel)
262 pixel_info=(PixelInfo *) AcquireQuantumMemory(1,sizeof(*pixel_info));
263 if (pixel_info == (PixelInfo *) NULL)
264 ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
265 *pixel_info=(*pixel);
270 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
274 + D e s t r o y P i x e l C h a n n e l M a p %
278 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
280 % DestroyPixelChannelMap() deallocates memory associated with the pixel
283 % The format of the DestroyPixelChannelMap() method is:
285 % PixelChannelMap *DestroyPixelChannelMap(PixelChannelMap *channel_map)
287 % A description of each parameter follows:
289 % o channel_map: the pixel component map.
292 MagickExport PixelChannelMap *DestroyPixelChannelMap(
293 PixelChannelMap *channel_map)
295 assert(channel_map != (PixelChannelMap *) NULL);
296 channel_map=(PixelChannelMap *) RelinquishMagickMemory(channel_map);
297 return((PixelChannelMap *) RelinquishMagickMemory(channel_map));
301 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
305 % E x p o r t I m a g e P i x e l s %
309 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
311 % ExportImagePixels() extracts pixel data from an image and returns it to you.
312 % The method returns MagickTrue on success otherwise MagickFalse if an error is
313 % encountered. The data is returned as char, short int, Quantum, unsigned int,
314 % unsigned long long, float, or double in the order specified by map.
316 % Suppose you want to extract the first scanline of a 640x480 image as
317 % character data in red-green-blue order:
319 % ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception);
321 % The format of the ExportImagePixels method is:
323 % MagickBooleanType ExportImagePixels(const Image *image,const ssize_t x,
324 % const ssize_t y,const size_t width,const size_t height,
325 % const char *map,const StorageType type,void *pixels,
326 % ExceptionInfo *exception)
328 % A description of each parameter follows:
330 % o image: the image.
332 % o x,y,width,height: These values define the perimeter
333 % of a region of pixels you want to extract.
335 % o map: This string reflects the expected ordering of the pixel array.
336 % It can be any combination or order of R = red, G = green, B = blue,
337 % A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
338 % Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
341 % o type: Define the data type of the pixels. Float and double types are
342 % normalized to [0..1] otherwise [0..QuantumRange]. Choose from these
343 % types: CharPixel (char *), DoublePixel (double *), FloatPixel (float *),
344 % LongPixel (unsigned int *), LongLongPixel (unsigned long long *),
345 % QuantumPixel (Quantum *), or ShortPixel (unsigned short *).
347 % o pixels: This array of values contain the pixel components as defined by
348 % map and type. You must preallocate this array where the expected
349 % length varies depending on the values of width, height, map, and type.
351 % o exception: return any errors or warnings in this structure.
355 static void ExportCharPixel(Image *image,const RectangleInfo *roi,
356 const char *restrict map,const QuantumType *quantum_map,void *pixels,
357 ExceptionInfo *exception)
359 register const Quantum
365 register unsigned char
374 q=(unsigned char *) pixels;
375 if (LocaleCompare(map,"BGR") == 0)
377 for (y=0; y < (ssize_t) roi->height; y++)
379 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
380 if (p == (const Quantum *) NULL)
382 for (x=0; x < (ssize_t) roi->width; x++)
384 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
385 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
386 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
387 p+=GetPixelChannels(image);
392 if (LocaleCompare(map,"BGRA") == 0)
394 for (y=0; y < (ssize_t) roi->height; y++)
396 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
397 if (p == (const Quantum *) NULL)
399 for (x=0; x < (ssize_t) roi->width; x++)
401 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
402 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
403 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
404 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
405 p+=GetPixelChannels(image);
410 if (LocaleCompare(map,"BGRP") == 0)
412 for (y=0; y < (ssize_t) roi->height; y++)
414 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
415 if (p == (const Quantum *) NULL)
417 for (x=0; x < (ssize_t) roi->width; x++)
419 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
420 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
421 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
422 *q++=ScaleQuantumToChar((Quantum) 0);
423 p+=GetPixelChannels(image);
428 if (LocaleCompare(map,"I") == 0)
430 for (y=0; y < (ssize_t) roi->height; y++)
432 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
433 if (p == (const Quantum *) NULL)
435 for (x=0; x < (ssize_t) roi->width; x++)
437 *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
438 p+=GetPixelChannels(image);
443 if (LocaleCompare(map,"RGB") == 0)
445 for (y=0; y < (ssize_t) roi->height; y++)
447 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
448 if (p == (const Quantum *) NULL)
450 for (x=0; x < (ssize_t) roi->width; x++)
452 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
453 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
454 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
455 p+=GetPixelChannels(image);
460 if (LocaleCompare(map,"RGBA") == 0)
462 for (y=0; y < (ssize_t) roi->height; y++)
464 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
465 if (p == (const Quantum *) NULL)
467 for (x=0; x < (ssize_t) roi->width; x++)
469 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
470 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
471 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
472 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
473 p+=GetPixelChannels(image);
478 if (LocaleCompare(map,"RGBP") == 0)
480 for (y=0; y < (ssize_t) roi->height; y++)
482 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
483 if (p == (const Quantum *) NULL)
485 for (x=0; x < (ssize_t) roi->width; x++)
487 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
488 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
489 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
490 *q++=ScaleQuantumToChar((Quantum) 0);
491 p+=GetPixelChannels(image);
497 for (y=0; y < (ssize_t) roi->height; y++)
499 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
500 if (p == (const Quantum *) NULL)
502 for (x=0; x < (ssize_t) roi->width; x++)
507 for (i=0; i < (ssize_t) length; i++)
510 switch (quantum_map[i])
515 *q=ScaleQuantumToChar(GetPixelRed(image,p));
521 *q=ScaleQuantumToChar(GetPixelGreen(image,p));
527 *q=ScaleQuantumToChar(GetPixelBlue(image,p));
532 *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
537 *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
542 if (image->colorspace == CMYKColorspace)
543 *q=ScaleQuantumToChar(GetPixelBlack(image,p));
548 *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
556 p+=GetPixelChannels(image);
561 static void ExportDoublePixel(Image *image,const RectangleInfo *roi,
562 const char *restrict map,const QuantumType *quantum_map,void *pixels,
563 ExceptionInfo *exception)
565 register const Quantum
581 if (LocaleCompare(map,"BGR") == 0)
583 for (y=0; y < (ssize_t) roi->height; y++)
585 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
586 if (p == (const Quantum *) NULL)
588 for (x=0; x < (ssize_t) roi->width; x++)
590 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
591 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
592 *q++=(double) (QuantumScale*GetPixelRed(image,p));
593 p+=GetPixelChannels(image);
598 if (LocaleCompare(map,"BGRA") == 0)
600 for (y=0; y < (ssize_t) roi->height; y++)
602 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
603 if (p == (const Quantum *) NULL)
605 for (x=0; x < (ssize_t) roi->width; x++)
607 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
608 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
609 *q++=(double) (QuantumScale*GetPixelRed(image,p));
610 *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
611 p+=GetPixelChannels(image);
616 if (LocaleCompare(map,"BGRP") == 0)
618 for (y=0; y < (ssize_t) roi->height; y++)
620 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
621 if (p == (const Quantum *) NULL)
623 for (x=0; x < (ssize_t) roi->width; x++)
625 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
626 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
627 *q++=(double) (QuantumScale*GetPixelRed(image,p));
629 p+=GetPixelChannels(image);
634 if (LocaleCompare(map,"I") == 0)
636 for (y=0; y < (ssize_t) roi->height; y++)
638 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
639 if (p == (const Quantum *) NULL)
641 for (x=0; x < (ssize_t) roi->width; x++)
643 *q++=(double) (QuantumScale*GetPixelIntensity(image,p));
644 p+=GetPixelChannels(image);
649 if (LocaleCompare(map,"RGB") == 0)
651 for (y=0; y < (ssize_t) roi->height; y++)
653 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
654 if (p == (const Quantum *) NULL)
656 for (x=0; x < (ssize_t) roi->width; x++)
658 *q++=(double) (QuantumScale*GetPixelRed(image,p));
659 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
660 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
661 p+=GetPixelChannels(image);
666 if (LocaleCompare(map,"RGBA") == 0)
668 for (y=0; y < (ssize_t) roi->height; y++)
670 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
671 if (p == (const Quantum *) NULL)
673 for (x=0; x < (ssize_t) roi->width; x++)
675 *q++=(double) (QuantumScale*GetPixelRed(image,p));
676 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
677 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
678 *q++=(double) (QuantumScale*GetPixelAlpha(image,p));
679 p+=GetPixelChannels(image);
684 if (LocaleCompare(map,"RGBP") == 0)
686 for (y=0; y < (ssize_t) roi->height; y++)
688 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
689 if (p == (const Quantum *) NULL)
691 for (x=0; x < (ssize_t) roi->width; x++)
693 *q++=(double) (QuantumScale*GetPixelRed(image,p));
694 *q++=(double) (QuantumScale*GetPixelGreen(image,p));
695 *q++=(double) (QuantumScale*GetPixelBlue(image,p));
697 p+=GetPixelChannels(image);
703 for (y=0; y < (ssize_t) roi->height; y++)
705 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
706 if (p == (const Quantum *) NULL)
708 for (x=0; x < (ssize_t) roi->width; x++)
713 for (i=0; i < (ssize_t) length; i++)
716 switch (quantum_map[i])
721 *q=(double) (QuantumScale*GetPixelRed(image,p));
727 *q=(double) (QuantumScale*GetPixelGreen(image,p));
733 *q=(double) (QuantumScale*GetPixelBlue(image,p));
738 *q=(double) (QuantumScale*GetPixelAlpha(image,p));
743 *q=(double) (QuantumScale*GetPixelAlpha(image,p));
748 if (image->colorspace == CMYKColorspace)
749 *q=(double) (QuantumScale*
750 GetPixelBlack(image,p));
755 *q=(double) (QuantumScale*GetPixelIntensity(image,p));
763 p+=GetPixelChannels(image);
768 static void ExportFloatPixel(Image *image,const RectangleInfo *roi,
769 const char *restrict map,const QuantumType *quantum_map,void *pixels,
770 ExceptionInfo *exception)
772 register const Quantum
788 if (LocaleCompare(map,"BGR") == 0)
790 for (y=0; y < (ssize_t) roi->height; y++)
792 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
793 if (p == (const Quantum *) NULL)
795 for (x=0; x < (ssize_t) roi->width; x++)
797 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
798 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
799 *q++=(float) (QuantumScale*GetPixelRed(image,p));
800 p+=GetPixelChannels(image);
805 if (LocaleCompare(map,"BGRA") == 0)
807 for (y=0; y < (ssize_t) roi->height; y++)
809 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
810 if (p == (const Quantum *) NULL)
812 for (x=0; x < (ssize_t) roi->width; x++)
814 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
815 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
816 *q++=(float) (QuantumScale*GetPixelRed(image,p));
817 *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
818 p+=GetPixelChannels(image);
823 if (LocaleCompare(map,"BGRP") == 0)
825 for (y=0; y < (ssize_t) roi->height; y++)
827 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
828 if (p == (const Quantum *) NULL)
830 for (x=0; x < (ssize_t) roi->width; x++)
832 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
833 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
834 *q++=(float) (QuantumScale*GetPixelRed(image,p));
836 p+=GetPixelChannels(image);
841 if (LocaleCompare(map,"I") == 0)
843 for (y=0; y < (ssize_t) roi->height; y++)
845 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
846 if (p == (const Quantum *) NULL)
848 for (x=0; x < (ssize_t) roi->width; x++)
850 *q++=(float) (QuantumScale*GetPixelIntensity(image,p));
851 p+=GetPixelChannels(image);
856 if (LocaleCompare(map,"RGB") == 0)
858 for (y=0; y < (ssize_t) roi->height; y++)
860 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
861 if (p == (const Quantum *) NULL)
863 for (x=0; x < (ssize_t) roi->width; x++)
865 *q++=(float) (QuantumScale*GetPixelRed(image,p));
866 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
867 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
868 p+=GetPixelChannels(image);
873 if (LocaleCompare(map,"RGBA") == 0)
875 for (y=0; y < (ssize_t) roi->height; y++)
877 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
878 if (p == (const Quantum *) NULL)
880 for (x=0; x < (ssize_t) roi->width; x++)
882 *q++=(float) (QuantumScale*GetPixelRed(image,p));
883 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
884 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
885 *q++=(float) (QuantumScale*GetPixelAlpha(image,p));
886 p+=GetPixelChannels(image);
891 if (LocaleCompare(map,"RGBP") == 0)
893 for (y=0; y < (ssize_t) roi->height; y++)
895 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
896 if (p == (const Quantum *) NULL)
898 for (x=0; x < (ssize_t) roi->width; x++)
900 *q++=(float) (QuantumScale*GetPixelRed(image,p));
901 *q++=(float) (QuantumScale*GetPixelGreen(image,p));
902 *q++=(float) (QuantumScale*GetPixelBlue(image,p));
904 p+=GetPixelChannels(image);
910 for (y=0; y < (ssize_t) roi->height; y++)
912 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
913 if (p == (const Quantum *) NULL)
915 for (x=0; x < (ssize_t) roi->width; x++)
920 for (i=0; i < (ssize_t) length; i++)
923 switch (quantum_map[i])
928 *q=(float) (QuantumScale*GetPixelRed(image,p));
934 *q=(float) (QuantumScale*GetPixelGreen(image,p));
940 *q=(float) (QuantumScale*GetPixelBlue(image,p));
945 *q=(float) (QuantumScale*((Quantum) (GetPixelAlpha(image,p))));
950 *q=(float) (QuantumScale*GetPixelAlpha(image,p));
955 if (image->colorspace == CMYKColorspace)
956 *q=(float) (QuantumScale* GetPixelBlack(image,p));
961 *q=(float) (QuantumScale*GetPixelIntensity(image,p));
969 p+=GetPixelChannels(image);
974 static void ExportLongPixel(Image *image,const RectangleInfo *roi,
975 const char *restrict map,const QuantumType *quantum_map,void *pixels,
976 ExceptionInfo *exception)
978 register const Quantum
984 register unsigned int
993 q=(unsigned int *) pixels;
994 if (LocaleCompare(map,"BGR") == 0)
996 for (y=0; y < (ssize_t) roi->height; y++)
998 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
999 if (p == (const Quantum *) NULL)
1001 for (x=0; x < (ssize_t) roi->width; x++)
1003 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1004 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1005 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1006 p+=GetPixelChannels(image);
1011 if (LocaleCompare(map,"BGRA") == 0)
1013 for (y=0; y < (ssize_t) roi->height; y++)
1015 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1016 if (p == (const Quantum *) NULL)
1018 for (x=0; x < (ssize_t) roi->width; x++)
1020 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1021 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1022 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1023 *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
1024 p+=GetPixelChannels(image);
1029 if (LocaleCompare(map,"BGRP") == 0)
1031 for (y=0; y < (ssize_t) roi->height; y++)
1033 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1034 if (p == (const Quantum *) NULL)
1036 for (x=0; x < (ssize_t) roi->width; x++)
1038 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1039 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1040 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1042 p+=GetPixelChannels(image);
1047 if (LocaleCompare(map,"I") == 0)
1049 for (y=0; y < (ssize_t) roi->height; y++)
1051 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1052 if (p == (const Quantum *) NULL)
1054 for (x=0; x < (ssize_t) roi->width; x++)
1056 *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
1057 p+=GetPixelChannels(image);
1062 if (LocaleCompare(map,"RGB") == 0)
1064 for (y=0; y < (ssize_t) roi->height; y++)
1066 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1067 if (p == (const Quantum *) NULL)
1069 for (x=0; x < (ssize_t) roi->width; x++)
1071 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1072 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1073 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1074 p+=GetPixelChannels(image);
1079 if (LocaleCompare(map,"RGBA") == 0)
1081 for (y=0; y < (ssize_t) roi->height; y++)
1083 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1084 if (p == (const Quantum *) NULL)
1086 for (x=0; x < (ssize_t) roi->width; x++)
1088 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1089 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1090 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1091 *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
1092 p+=GetPixelChannels(image);
1097 if (LocaleCompare(map,"RGBP") == 0)
1099 for (y=0; y < (ssize_t) roi->height; y++)
1101 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1102 if (p == (const Quantum *) NULL)
1104 for (x=0; x < (ssize_t) roi->width; x++)
1106 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
1107 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
1108 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
1110 p+=GetPixelChannels(image);
1116 for (y=0; y < (ssize_t) roi->height; y++)
1118 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1119 if (p == (const Quantum *) NULL)
1121 for (x=0; x < (ssize_t) roi->width; x++)
1126 for (i=0; i < (ssize_t) length; i++)
1129 switch (quantum_map[i])
1134 *q=ScaleQuantumToLong(GetPixelRed(image,p));
1138 case MagentaQuantum:
1140 *q=ScaleQuantumToLong(GetPixelGreen(image,p));
1146 *q=ScaleQuantumToLong(GetPixelBlue(image,p));
1151 *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
1154 case OpacityQuantum:
1156 *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
1161 if (image->colorspace == CMYKColorspace)
1162 *q=ScaleQuantumToLong(GetPixelBlack(image,p));
1167 *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
1175 p+=GetPixelChannels(image);
1180 static void ExportLongLongPixel(Image *image,const RectangleInfo *roi,
1181 const char *restrict map,const QuantumType *quantum_map,void *pixels,
1182 ExceptionInfo *exception)
1184 register const Quantum
1190 register MagickSizeType
1199 q=(MagickSizeType *) pixels;
1200 if (LocaleCompare(map,"BGR") == 0)
1202 for (y=0; y < (ssize_t) roi->height; y++)
1204 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1205 if (p == (const Quantum *) NULL)
1207 for (x=0; x < (ssize_t) roi->width; x++)
1209 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1210 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1211 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1212 p+=GetPixelChannels(image);
1217 if (LocaleCompare(map,"BGRA") == 0)
1219 for (y=0; y < (ssize_t) roi->height; y++)
1221 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1222 if (p == (const Quantum *) NULL)
1224 for (x=0; x < (ssize_t) roi->width; x++)
1226 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1227 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1228 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1229 *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
1230 p+=GetPixelChannels(image);
1235 if (LocaleCompare(map,"BGRP") == 0)
1237 for (y=0; y < (ssize_t) roi->height; y++)
1239 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1240 if (p == (const Quantum *) NULL)
1242 for (x=0; x < (ssize_t) roi->width; x++)
1244 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1245 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1246 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1248 p+=GetPixelChannels(image);
1253 if (LocaleCompare(map,"I") == 0)
1255 for (y=0; y < (ssize_t) roi->height; y++)
1257 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1258 if (p == (const Quantum *) NULL)
1260 for (x=0; x < (ssize_t) roi->width; x++)
1262 *q++=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
1263 p+=GetPixelChannels(image);
1268 if (LocaleCompare(map,"RGB") == 0)
1270 for (y=0; y < (ssize_t) roi->height; y++)
1272 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1273 if (p == (const Quantum *) NULL)
1275 for (x=0; x < (ssize_t) roi->width; x++)
1277 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1278 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1279 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1280 p+=GetPixelChannels(image);
1285 if (LocaleCompare(map,"RGBA") == 0)
1287 for (y=0; y < (ssize_t) roi->height; y++)
1289 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1290 if (p == (const Quantum *) NULL)
1292 for (x=0; x < (ssize_t) roi->width; x++)
1294 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1295 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1296 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1297 *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
1298 p+=GetPixelChannels(image);
1303 if (LocaleCompare(map,"RGBP") == 0)
1305 for (y=0; y < (ssize_t) roi->height; y++)
1307 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1308 if (p == (const Quantum *) NULL)
1310 for (x=0; x < (ssize_t) roi->width; x++)
1312 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
1313 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1314 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1316 p+=GetPixelChannels(image);
1322 for (y=0; y < (ssize_t) roi->height; y++)
1324 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1325 if (p == (const Quantum *) NULL)
1327 for (x=0; x < (ssize_t) roi->width; x++)
1332 for (i=0; i < (ssize_t) length; i++)
1335 switch (quantum_map[i])
1340 *q=ScaleQuantumToLongLong(GetPixelRed(image,p));
1344 case MagentaQuantum:
1346 *q=ScaleQuantumToLongLong(GetPixelGreen(image,p));
1352 *q=ScaleQuantumToLongLong(GetPixelBlue(image,p));
1357 *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
1360 case OpacityQuantum:
1362 *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
1367 if (image->colorspace == CMYKColorspace)
1368 *q=ScaleQuantumToLongLong(GetPixelBlack(image,p));
1373 *q=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
1381 p+=GetPixelChannels(image);
1386 static void ExportQuantumPixel(Image *image,const RectangleInfo *roi,
1387 const char *restrict map,const QuantumType *quantum_map,void *pixels,
1388 ExceptionInfo *exception)
1390 register const Quantum
1405 q=(Quantum *) pixels;
1406 if (LocaleCompare(map,"BGR") == 0)
1408 for (y=0; y < (ssize_t) roi->height; y++)
1410 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1411 if (p == (const Quantum *) NULL)
1413 for (x=0; x < (ssize_t) roi->width; x++)
1415 *q++=GetPixelBlue(image,p);
1416 *q++=GetPixelGreen(image,p);
1417 *q++=GetPixelRed(image,p);
1418 p+=GetPixelChannels(image);
1423 if (LocaleCompare(map,"BGRA") == 0)
1425 for (y=0; y < (ssize_t) roi->height; y++)
1427 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1428 if (p == (const Quantum *) NULL)
1430 for (x=0; x < (ssize_t) roi->width; x++)
1432 *q++=GetPixelBlue(image,p);
1433 *q++=GetPixelGreen(image,p);
1434 *q++=GetPixelRed(image,p);
1435 *q++=(Quantum) (GetPixelAlpha(image,p));
1436 p+=GetPixelChannels(image);
1441 if (LocaleCompare(map,"BGRP") == 0)
1443 for (y=0; y < (ssize_t) roi->height; y++)
1445 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1446 if (p == (const Quantum *) NULL)
1448 for (x=0; x < (ssize_t) roi->width; x++)
1450 *q++=GetPixelBlue(image,p);
1451 *q++=GetPixelGreen(image,p);
1452 *q++=GetPixelRed(image,p);
1454 p+=GetPixelChannels(image);
1459 if (LocaleCompare(map,"I") == 0)
1461 for (y=0; y < (ssize_t) roi->height; y++)
1463 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1464 if (p == (const Quantum *) NULL)
1466 for (x=0; x < (ssize_t) roi->width; x++)
1468 *q++=GetPixelIntensity(image,p);
1469 p+=GetPixelChannels(image);
1474 if (LocaleCompare(map,"RGB") == 0)
1476 for (y=0; y < (ssize_t) roi->height; y++)
1478 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1479 if (p == (const Quantum *) NULL)
1481 for (x=0; x < (ssize_t) roi->width; x++)
1483 *q++=GetPixelRed(image,p);
1484 *q++=GetPixelGreen(image,p);
1485 *q++=GetPixelBlue(image,p);
1486 p+=GetPixelChannels(image);
1491 if (LocaleCompare(map,"RGBA") == 0)
1493 for (y=0; y < (ssize_t) roi->height; y++)
1495 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1496 if (p == (const Quantum *) NULL)
1498 for (x=0; x < (ssize_t) roi->width; x++)
1500 *q++=GetPixelRed(image,p);
1501 *q++=GetPixelGreen(image,p);
1502 *q++=GetPixelBlue(image,p);
1503 *q++=(Quantum) (GetPixelAlpha(image,p));
1504 p+=GetPixelChannels(image);
1509 if (LocaleCompare(map,"RGBP") == 0)
1511 for (y=0; y < (ssize_t) roi->height; y++)
1513 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1514 if (p == (const Quantum *) NULL)
1516 for (x=0; x < (ssize_t) roi->width; x++)
1518 *q++=GetPixelRed(image,p);
1519 *q++=GetPixelGreen(image,p);
1520 *q++=GetPixelBlue(image,p);
1522 p+=GetPixelChannels(image);
1528 for (y=0; y < (ssize_t) roi->height; y++)
1530 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1531 if (p == (const Quantum *) NULL)
1533 for (x=0; x < (ssize_t) roi->width; x++)
1538 for (i=0; i < (ssize_t) length; i++)
1541 switch (quantum_map[i])
1546 *q=GetPixelRed(image,p);
1550 case MagentaQuantum:
1552 *q=GetPixelGreen(image,p);
1558 *q=GetPixelBlue(image,p);
1563 *q=GetPixelAlpha(image,p);
1566 case OpacityQuantum:
1568 *q=GetPixelAlpha(image,p);
1573 if (image->colorspace == CMYKColorspace)
1574 *q=GetPixelBlack(image,p);
1579 *q=(GetPixelIntensity(image,p));
1590 p+=GetPixelChannels(image);
1595 static void ExportShortPixel(Image *image,const RectangleInfo *roi,
1596 const char *restrict map,const QuantumType *quantum_map,void *pixels,
1597 ExceptionInfo *exception)
1599 register const Quantum
1605 register unsigned short
1614 q=(unsigned short *) pixels;
1615 if (LocaleCompare(map,"BGR") == 0)
1617 for (y=0; y < (ssize_t) roi->height; y++)
1619 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1620 if (p == (const Quantum *) NULL)
1622 for (x=0; x < (ssize_t) roi->width; x++)
1624 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1625 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1626 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1627 p+=GetPixelChannels(image);
1632 if (LocaleCompare(map,"BGRA") == 0)
1634 for (y=0; y < (ssize_t) roi->height; y++)
1636 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1637 if (p == (const Quantum *) NULL)
1639 for (x=0; x < (ssize_t) roi->width; x++)
1641 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1642 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1643 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1644 *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
1645 p+=GetPixelChannels(image);
1650 if (LocaleCompare(map,"BGRP") == 0)
1652 for (y=0; y < (ssize_t) roi->height; y++)
1654 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1655 if (p == (const Quantum *) NULL)
1657 for (x=0; x < (ssize_t) roi->width; x++)
1659 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1660 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1661 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1663 p+=GetPixelChannels(image);
1668 if (LocaleCompare(map,"I") == 0)
1670 for (y=0; y < (ssize_t) roi->height; y++)
1672 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1673 if (p == (const Quantum *) NULL)
1675 for (x=0; x < (ssize_t) roi->width; x++)
1677 *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
1678 p+=GetPixelChannels(image);
1683 if (LocaleCompare(map,"RGB") == 0)
1685 for (y=0; y < (ssize_t) roi->height; y++)
1687 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1688 if (p == (const Quantum *) NULL)
1690 for (x=0; x < (ssize_t) roi->width; x++)
1692 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1693 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1694 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1695 p+=GetPixelChannels(image);
1700 if (LocaleCompare(map,"RGBA") == 0)
1702 for (y=0; y < (ssize_t) roi->height; y++)
1704 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1705 if (p == (const Quantum *) NULL)
1707 for (x=0; x < (ssize_t) roi->width; x++)
1709 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1710 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1711 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1712 *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
1713 p+=GetPixelChannels(image);
1718 if (LocaleCompare(map,"RGBP") == 0)
1720 for (y=0; y < (ssize_t) roi->height; y++)
1722 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1723 if (p == (const Quantum *) NULL)
1725 for (x=0; x < (ssize_t) roi->width; x++)
1727 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
1728 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
1729 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
1731 p+=GetPixelChannels(image);
1737 for (y=0; y < (ssize_t) roi->height; y++)
1739 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1740 if (p == (const Quantum *) NULL)
1742 for (x=0; x < (ssize_t) roi->width; x++)
1747 for (i=0; i < (ssize_t) length; i++)
1750 switch (quantum_map[i])
1755 *q=ScaleQuantumToShort(GetPixelRed(image,p));
1759 case MagentaQuantum:
1761 *q=ScaleQuantumToShort(GetPixelGreen(image,p));
1767 *q=ScaleQuantumToShort(GetPixelBlue(image,p));
1772 *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
1775 case OpacityQuantum:
1777 *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
1782 if (image->colorspace == CMYKColorspace)
1783 *q=ScaleQuantumToShort(GetPixelBlack(image,p));
1788 *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
1796 p+=GetPixelChannels(image);
1801 MagickExport MagickBooleanType ExportImagePixels(Image *image,
1802 const ssize_t x,const ssize_t y,const size_t width,const size_t height,
1803 const char *map,const StorageType type,void *pixels,ExceptionInfo *exception)
1817 assert(image != (Image *) NULL);
1818 assert(image->signature == MagickSignature);
1819 if (image->debug != MagickFalse)
1820 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1822 quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1823 if (quantum_map == (QuantumType *) NULL)
1825 (void) ThrowMagickException(exception,GetMagickModule(),
1826 ResourceLimitError,"MemoryAllocationFailed","'%s'",image->filename);
1827 return(MagickFalse);
1829 for (i=0; i < (ssize_t) length; i++)
1836 quantum_map[i]=AlphaQuantum;
1842 quantum_map[i]=BlueQuantum;
1848 quantum_map[i]=CyanQuantum;
1849 if (image->colorspace == CMYKColorspace)
1851 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1852 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1853 "ColorSeparatedImageRequired","'%s'",map);
1854 return(MagickFalse);
1859 quantum_map[i]=GreenQuantum;
1865 quantum_map[i]=IndexQuantum;
1871 quantum_map[i]=BlackQuantum;
1872 if (image->colorspace == CMYKColorspace)
1874 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1875 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1876 "ColorSeparatedImageRequired","'%s'",map);
1877 return(MagickFalse);
1882 quantum_map[i]=MagentaQuantum;
1883 if (image->colorspace == CMYKColorspace)
1885 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1886 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1887 "ColorSeparatedImageRequired","'%s'",map);
1888 return(MagickFalse);
1893 quantum_map[i]=OpacityQuantum;
1899 quantum_map[i]=UndefinedQuantum;
1905 quantum_map[i]=RedQuantum;
1911 quantum_map[i]=YellowQuantum;
1912 if (image->colorspace == CMYKColorspace)
1914 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1915 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1916 "ColorSeparatedImageRequired","'%s'",map);
1917 return(MagickFalse);
1921 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1922 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1923 "UnrecognizedPixelMap","'%s'",map);
1924 return(MagickFalse);
1936 ExportCharPixel(image,&roi,map,quantum_map,pixels,exception);
1941 ExportDoublePixel(image,&roi,map,quantum_map,pixels,exception);
1946 ExportFloatPixel(image,&roi,map,quantum_map,pixels,exception);
1951 ExportLongPixel(image,&roi,map,quantum_map,pixels,exception);
1956 ExportLongLongPixel(image,&roi,map,quantum_map,pixels,exception);
1961 ExportQuantumPixel(image,&roi,map,quantum_map,pixels,exception);
1966 ExportShortPixel(image,&roi,map,quantum_map,pixels,exception);
1971 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1972 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1973 "UnrecognizedPixelMap","'%s'",map);
1977 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1982 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1986 % G e t P i x e l I n f o %
1990 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1992 % GetPixelInfo() initializes the PixelInfo structure.
1994 % The format of the GetPixelInfo method is:
1996 % GetPixelInfo(const Image *image,PixelInfo *pixel)
1998 % A description of each parameter follows:
2000 % o image: the image.
2002 % o pixel: Specifies a pointer to a PixelInfo structure.
2005 MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
2007 pixel->storage_class=DirectClass;
2008 pixel->colorspace=sRGBColorspace;
2009 pixel->matte=MagickFalse;
2011 pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
2016 pixel->alpha=(MagickRealType) OpaqueAlpha;
2018 if (image == (const Image *) NULL)
2020 pixel->storage_class=image->storage_class;
2021 pixel->colorspace=image->colorspace;
2022 pixel->matte=image->matte;
2023 pixel->depth=image->depth;
2024 pixel->fuzz=image->fuzz;
2028 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2032 % I m p o r t I m a g e P i x e l s %
2036 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2038 % ImportImagePixels() accepts pixel data and stores in the image at the
2039 % location you specify. The method returns MagickTrue on success otherwise
2040 % MagickFalse if an error is encountered. The pixel data can be either char,
2041 % Quantum, short int, unsigned int, unsigned long long, float, or double in
2042 % the order specified by map.
2044 % Suppose your want to upload the first scanline of a 640x480 image from
2045 % character data in red-green-blue order:
2047 % ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels);
2049 % The format of the ImportImagePixels method is:
2051 % MagickBooleanType ImportImagePixels(Image *image,const ssize_t x,
2052 % const ssize_t y,const size_t width,const size_t height,
2053 % const char *map,const StorageType type,const void *pixels,
2054 % ExceptionInfo *exception)
2056 % A description of each parameter follows:
2058 % o image: the image.
2060 % o x,y,width,height: These values define the perimeter
2061 % of a region of pixels you want to define.
2063 % o map: This string reflects the expected ordering of the pixel array.
2064 % It can be any combination or order of R = red, G = green, B = blue,
2065 % A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan,
2066 % Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
2069 % o type: Define the data type of the pixels. Float and double types are
2070 % normalized to [0..1] otherwise [0..QuantumRange]. Choose from these
2071 % types: CharPixel (char *), DoublePixel (double *), FloatPixel (float *),
2072 % LongPixel (unsigned int *), LongLongPixel (unsigned long long *),
2073 % QuantumPixel (Quantum *), or ShortPixel (unsigned short *).
2075 % o pixels: This array of values contain the pixel components as defined by
2076 % map and type. You must preallocate this array where the expected
2077 % length varies depending on the values of width, height, map, and type.
2079 % o exception: return any errors or warnings in this structure.
2083 static void ImportCharPixel(Image *image,const RectangleInfo *roi,
2084 const char *restrict map,const QuantumType *quantum_map,const void *pixels,
2085 ExceptionInfo *exception)
2087 register const unsigned char
2102 p=(const unsigned char *) pixels;
2103 if (LocaleCompare(map,"BGR") == 0)
2105 for (y=0; y < (ssize_t) roi->height; y++)
2107 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2108 if (q == (Quantum *) NULL)
2110 for (x=0; x < (ssize_t) roi->width; x++)
2112 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2113 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2114 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2115 q+=GetPixelChannels(image);
2117 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2122 if (LocaleCompare(map,"BGRA") == 0)
2124 for (y=0; y < (ssize_t) roi->height; y++)
2126 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2127 if (q == (Quantum *) NULL)
2129 for (x=0; x < (ssize_t) roi->width; x++)
2131 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2132 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2133 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2134 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2135 q+=GetPixelChannels(image);
2137 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2142 if (LocaleCompare(map,"BGRO") == 0)
2144 for (y=0; y < (ssize_t) roi->height; y++)
2146 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2147 if (q == (Quantum *) NULL)
2149 for (x=0; x < (ssize_t) roi->width; x++)
2151 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2152 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2153 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2154 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2155 q+=GetPixelChannels(image);
2157 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2162 if (LocaleCompare(map,"BGRP") == 0)
2164 for (y=0; y < (ssize_t) roi->height; y++)
2166 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2167 if (q == (Quantum *) NULL)
2169 for (x=0; x < (ssize_t) roi->width; x++)
2171 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2172 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2173 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2175 q+=GetPixelChannels(image);
2177 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2182 if (LocaleCompare(map,"I") == 0)
2184 for (y=0; y < (ssize_t) roi->height; y++)
2186 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2187 if (q == (Quantum *) NULL)
2189 for (x=0; x < (ssize_t) roi->width; x++)
2191 SetPixelGray(image,ScaleCharToQuantum(*p++),q);
2192 q+=GetPixelChannels(image);
2194 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2199 if (LocaleCompare(map,"RGB") == 0)
2201 for (y=0; y < (ssize_t) roi->height; y++)
2203 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2204 if (q == (Quantum *) NULL)
2206 for (x=0; x < (ssize_t) roi->width; x++)
2208 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2209 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2210 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2211 q+=GetPixelChannels(image);
2213 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2218 if (LocaleCompare(map,"RGBA") == 0)
2220 for (y=0; y < (ssize_t) roi->height; y++)
2222 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2223 if (q == (Quantum *) NULL)
2225 for (x=0; x < (ssize_t) roi->width; x++)
2227 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2228 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2229 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2230 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2231 q+=GetPixelChannels(image);
2233 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2238 if (LocaleCompare(map,"RGBO") == 0)
2240 for (y=0; y < (ssize_t) roi->height; y++)
2242 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2243 if (q == (Quantum *) NULL)
2245 for (x=0; x < (ssize_t) roi->width; x++)
2247 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2248 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2249 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2250 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
2251 q+=GetPixelChannels(image);
2253 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2258 if (LocaleCompare(map,"RGBP") == 0)
2260 for (y=0; y < (ssize_t) roi->height; y++)
2262 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2263 if (q == (Quantum *) NULL)
2265 for (x=0; x < (ssize_t) roi->width; x++)
2267 SetPixelRed(image,ScaleCharToQuantum(*p++),q);
2268 SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
2269 SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
2271 q+=GetPixelChannels(image);
2273 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2279 for (y=0; y < (ssize_t) roi->height; y++)
2281 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2282 if (q == (Quantum *) NULL)
2284 for (x=0; x < (ssize_t) roi->width; x++)
2289 for (i=0; i < (ssize_t) length; i++)
2291 switch (quantum_map[i])
2296 SetPixelRed(image,ScaleCharToQuantum(*p),q);
2300 case MagentaQuantum:
2302 SetPixelGreen(image,ScaleCharToQuantum(*p),q);
2308 SetPixelBlue(image,ScaleCharToQuantum(*p),q);
2313 SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2316 case OpacityQuantum:
2318 SetPixelAlpha(image,ScaleCharToQuantum(*p),q);
2323 SetPixelBlack(image,ScaleCharToQuantum(*p),q);
2328 SetPixelGray(image,ScaleCharToQuantum(*p),q);
2336 q+=GetPixelChannels(image);
2338 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2343 static void ImportDoublePixel(Image *image,const RectangleInfo *roi,
2344 const char *restrict map,const QuantumType *quantum_map,const void *pixels,
2345 ExceptionInfo *exception)
2347 register const double
2362 p=(const double *) pixels;
2363 if (LocaleCompare(map,"BGR") == 0)
2365 for (y=0; y < (ssize_t) roi->height; y++)
2367 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2368 if (q == (Quantum *) NULL)
2370 for (x=0; x < (ssize_t) roi->width; x++)
2372 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2374 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2376 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2378 q+=GetPixelChannels(image);
2380 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2385 if (LocaleCompare(map,"BGRA") == 0)
2387 for (y=0; y < (ssize_t) roi->height; y++)
2389 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2390 if (q == (Quantum *) NULL)
2392 for (x=0; x < (ssize_t) roi->width; x++)
2394 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2396 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2398 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2400 SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2402 q+=GetPixelChannels(image);
2404 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2409 if (LocaleCompare(map,"BGRP") == 0)
2411 for (y=0; y < (ssize_t) roi->height; y++)
2413 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2414 if (q == (Quantum *) NULL)
2416 for (x=0; x < (ssize_t) roi->width; x++)
2418 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2420 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2422 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2425 q+=GetPixelChannels(image);
2427 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2432 if (LocaleCompare(map,"I") == 0)
2434 for (y=0; y < (ssize_t) roi->height; y++)
2436 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2437 if (q == (Quantum *) NULL)
2439 for (x=0; x < (ssize_t) roi->width; x++)
2441 SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
2443 q+=GetPixelChannels(image);
2445 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2450 if (LocaleCompare(map,"RGB") == 0)
2452 for (y=0; y < (ssize_t) roi->height; y++)
2454 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2455 if (q == (Quantum *) NULL)
2457 for (x=0; x < (ssize_t) roi->width; x++)
2459 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2461 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2463 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2465 q+=GetPixelChannels(image);
2467 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2472 if (LocaleCompare(map,"RGBA") == 0)
2474 for (y=0; y < (ssize_t) roi->height; y++)
2476 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2477 if (q == (Quantum *) NULL)
2479 for (x=0; x < (ssize_t) roi->width; x++)
2481 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2483 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2485 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2487 SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2489 q+=GetPixelChannels(image);
2491 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2496 if (LocaleCompare(map,"RGBP") == 0)
2498 for (y=0; y < (ssize_t) roi->height; y++)
2500 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2501 if (q == (Quantum *) NULL)
2503 for (x=0; x < (ssize_t) roi->width; x++)
2505 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2507 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2509 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2511 q+=GetPixelChannels(image);
2513 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2519 for (y=0; y < (ssize_t) roi->height; y++)
2521 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2522 if (q == (Quantum *) NULL)
2524 for (x=0; x < (ssize_t) roi->width; x++)
2529 for (i=0; i < (ssize_t) length; i++)
2531 switch (quantum_map[i])
2536 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2540 case MagentaQuantum:
2542 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2548 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2553 SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2556 case OpacityQuantum:
2558 SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2563 SetPixelBlack(image,ClampToQuantum(QuantumRange*(*p)),q);
2568 SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
2576 q+=GetPixelChannels(image);
2578 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2583 static void ImportFloatPixel(Image *image,const RectangleInfo *roi,
2584 const char *restrict map,const QuantumType *quantum_map,const void *pixels,
2585 ExceptionInfo *exception)
2587 register const float
2602 p=(const float *) pixels;
2603 if (LocaleCompare(map,"BGR") == 0)
2605 for (y=0; y < (ssize_t) roi->height; y++)
2607 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2608 if (q == (Quantum *) NULL)
2610 for (x=0; x < (ssize_t) roi->width; x++)
2612 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2614 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2616 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2618 q+=GetPixelChannels(image);
2620 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2625 if (LocaleCompare(map,"BGRA") == 0)
2627 for (y=0; y < (ssize_t) roi->height; y++)
2629 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2630 if (q == (Quantum *) NULL)
2632 for (x=0; x < (ssize_t) roi->width; x++)
2634 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2636 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2638 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2640 SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2642 q+=GetPixelChannels(image);
2644 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2649 if (LocaleCompare(map,"BGRP") == 0)
2651 for (y=0; y < (ssize_t) roi->height; y++)
2653 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2654 if (q == (Quantum *) NULL)
2656 for (x=0; x < (ssize_t) roi->width; x++)
2658 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2660 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2662 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2665 q+=GetPixelChannels(image);
2667 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2672 if (LocaleCompare(map,"I") == 0)
2674 for (y=0; y < (ssize_t) roi->height; y++)
2676 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2677 if (q == (Quantum *) NULL)
2679 for (x=0; x < (ssize_t) roi->width; x++)
2681 SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
2683 q+=GetPixelChannels(image);
2685 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2690 if (LocaleCompare(map,"RGB") == 0)
2692 for (y=0; y < (ssize_t) roi->height; y++)
2694 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2695 if (q == (Quantum *) NULL)
2697 for (x=0; x < (ssize_t) roi->width; x++)
2699 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2701 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2703 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2705 q+=GetPixelChannels(image);
2707 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2712 if (LocaleCompare(map,"RGBA") == 0)
2714 for (y=0; y < (ssize_t) roi->height; y++)
2716 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2717 if (q == (Quantum *) NULL)
2719 for (x=0; x < (ssize_t) roi->width; x++)
2721 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2723 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2725 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2727 SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2729 q+=GetPixelChannels(image);
2731 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2736 if (LocaleCompare(map,"RGBP") == 0)
2738 for (y=0; y < (ssize_t) roi->height; y++)
2740 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2741 if (q == (Quantum *) NULL)
2743 for (x=0; x < (ssize_t) roi->width; x++)
2745 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2747 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2749 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2751 q+=GetPixelChannels(image);
2753 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2759 for (y=0; y < (ssize_t) roi->height; y++)
2761 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2762 if (q == (Quantum *) NULL)
2764 for (x=0; x < (ssize_t) roi->width; x++)
2769 for (i=0; i < (ssize_t) length; i++)
2771 switch (quantum_map[i])
2776 SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
2780 case MagentaQuantum:
2782 SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
2788 SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
2793 SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2796 case OpacityQuantum:
2798 SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
2803 SetPixelBlack(image,ClampToQuantum(QuantumRange*(*p)),q);
2808 SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
2816 q+=GetPixelChannels(image);
2818 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2823 static void ImportLongPixel(Image *image,const RectangleInfo *roi,
2824 const char *restrict map,const QuantumType *quantum_map,const void *pixels,
2825 ExceptionInfo *exception)
2827 register const unsigned int
2842 p=(const unsigned int *) pixels;
2843 if (LocaleCompare(map,"BGR") == 0)
2845 for (y=0; y < (ssize_t) roi->height; y++)
2847 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2848 if (q == (Quantum *) NULL)
2850 for (x=0; x < (ssize_t) roi->width; x++)
2852 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2853 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2854 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2855 q+=GetPixelChannels(image);
2857 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2862 if (LocaleCompare(map,"BGRA") == 0)
2864 for (y=0; y < (ssize_t) roi->height; y++)
2866 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2867 if (q == (Quantum *) NULL)
2869 for (x=0; x < (ssize_t) roi->width; x++)
2871 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2872 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2873 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2874 SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2875 q+=GetPixelChannels(image);
2877 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2882 if (LocaleCompare(map,"BGRP") == 0)
2884 for (y=0; y < (ssize_t) roi->height; y++)
2886 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2887 if (q == (Quantum *) NULL)
2889 for (x=0; x < (ssize_t) roi->width; x++)
2891 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2892 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2893 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2895 q+=GetPixelChannels(image);
2897 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2902 if (LocaleCompare(map,"I") == 0)
2904 for (y=0; y < (ssize_t) roi->height; y++)
2906 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2907 if (q == (Quantum *) NULL)
2909 for (x=0; x < (ssize_t) roi->width; x++)
2911 SetPixelGray(image,ScaleLongToQuantum(*p++),q);
2912 q+=GetPixelChannels(image);
2914 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2919 if (LocaleCompare(map,"RGB") == 0)
2921 for (y=0; y < (ssize_t) roi->height; y++)
2923 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2924 if (q == (Quantum *) NULL)
2926 for (x=0; x < (ssize_t) roi->width; x++)
2928 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2929 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2930 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2931 q+=GetPixelChannels(image);
2933 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2938 if (LocaleCompare(map,"RGBA") == 0)
2940 for (y=0; y < (ssize_t) roi->height; y++)
2942 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2943 if (q == (Quantum *) NULL)
2945 for (x=0; x < (ssize_t) roi->width; x++)
2947 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2948 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2949 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2950 SetPixelAlpha(image,ScaleLongToQuantum(*p++),q);
2951 q+=GetPixelChannels(image);
2953 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2958 if (LocaleCompare(map,"RGBP") == 0)
2960 for (y=0; y < (ssize_t) roi->height; y++)
2962 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2963 if (q == (Quantum *) NULL)
2965 for (x=0; x < (ssize_t) roi->width; x++)
2967 SetPixelRed(image,ScaleLongToQuantum(*p++),q);
2968 SetPixelGreen(image,ScaleLongToQuantum(*p++),q);
2969 SetPixelBlue(image,ScaleLongToQuantum(*p++),q);
2971 q+=GetPixelChannels(image);
2973 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2979 for (y=0; y < (ssize_t) roi->height; y++)
2981 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2982 if (q == (Quantum *) NULL)
2984 for (x=0; x < (ssize_t) roi->width; x++)
2989 for (i=0; i < (ssize_t) length; i++)
2991 switch (quantum_map[i])
2996 SetPixelRed(image,ScaleLongToQuantum(*p),q);
3000 case MagentaQuantum:
3002 SetPixelGreen(image,ScaleLongToQuantum(*p),q);
3008 SetPixelBlue(image,ScaleLongToQuantum(*p),q);
3013 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3016 case OpacityQuantum:
3018 SetPixelAlpha(image,ScaleLongToQuantum(*p),q);
3023 SetPixelBlack(image,ScaleLongToQuantum(*p),q);
3028 SetPixelGray(image,ScaleLongToQuantum(*p),q);
3036 q+=GetPixelChannels(image);
3038 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3043 static void ImportLongLongPixel(Image *image,const RectangleInfo *roi,
3044 const char *restrict map,const QuantumType *quantum_map,const void *pixels,
3045 ExceptionInfo *exception)
3047 register const MagickSizeType
3062 p=(const MagickSizeType *) pixels;
3063 if (LocaleCompare(map,"BGR") == 0)
3065 for (y=0; y < (ssize_t) roi->height; y++)
3067 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3068 if (q == (Quantum *) NULL)
3070 for (x=0; x < (ssize_t) roi->width; x++)
3072 SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3073 SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3074 SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3075 q+=GetPixelChannels(image);
3077 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3082 if (LocaleCompare(map,"BGRA") == 0)
3084 for (y=0; y < (ssize_t) roi->height; y++)
3086 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3087 if (q == (Quantum *) NULL)
3089 for (x=0; x < (ssize_t) roi->width; x++)
3091 SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3092 SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3093 SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3094 SetPixelAlpha(image,ScaleLongLongToQuantum(*p++),q);
3095 q+=GetPixelChannels(image);
3097 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3102 if (LocaleCompare(map,"BGRP") == 0)
3104 for (y=0; y < (ssize_t) roi->height; y++)
3106 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3107 if (q == (Quantum *) NULL)
3109 for (x=0; x < (ssize_t) roi->width; x++)
3111 SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3112 SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3113 SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3115 q+=GetPixelChannels(image);
3117 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3122 if (LocaleCompare(map,"I") == 0)
3124 for (y=0; y < (ssize_t) roi->height; y++)
3126 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3127 if (q == (Quantum *) NULL)
3129 for (x=0; x < (ssize_t) roi->width; x++)
3131 SetPixelGray(image,ScaleLongLongToQuantum(*p++),q);
3132 q+=GetPixelChannels(image);
3134 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3139 if (LocaleCompare(map,"RGB") == 0)
3141 for (y=0; y < (ssize_t) roi->height; y++)
3143 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3144 if (q == (Quantum *) NULL)
3146 for (x=0; x < (ssize_t) roi->width; x++)
3148 SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3149 SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3150 SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3151 q+=GetPixelChannels(image);
3153 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3158 if (LocaleCompare(map,"RGBA") == 0)
3160 for (y=0; y < (ssize_t) roi->height; y++)
3162 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3163 if (q == (Quantum *) NULL)
3165 for (x=0; x < (ssize_t) roi->width; x++)
3167 SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3168 SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3169 SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3170 SetPixelAlpha(image,ScaleLongLongToQuantum(*p++),q);
3171 q+=GetPixelChannels(image);
3173 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3178 if (LocaleCompare(map,"RGBP") == 0)
3180 for (y=0; y < (ssize_t) roi->height; y++)
3182 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3183 if (q == (Quantum *) NULL)
3185 for (x=0; x < (ssize_t) roi->width; x++)
3187 SetPixelRed(image,ScaleLongLongToQuantum(*p++),q);
3188 SetPixelGreen(image,ScaleLongLongToQuantum(*p++),q);
3189 SetPixelBlue(image,ScaleLongLongToQuantum(*p++),q);
3191 q+=GetPixelChannels(image);
3193 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3199 for (y=0; y < (ssize_t) roi->height; y++)
3201 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3202 if (q == (Quantum *) NULL)
3204 for (x=0; x < (ssize_t) roi->width; x++)
3209 for (i=0; i < (ssize_t) length; i++)
3211 switch (quantum_map[i])
3216 SetPixelRed(image,ScaleLongLongToQuantum(*p),q);
3220 case MagentaQuantum:
3222 SetPixelGreen(image,ScaleLongLongToQuantum(*p),q);
3228 SetPixelBlue(image,ScaleLongLongToQuantum(*p),q);
3233 SetPixelAlpha(image,ScaleLongLongToQuantum(*p),q);
3236 case OpacityQuantum:
3238 SetPixelAlpha(image,ScaleLongLongToQuantum(*p),q);
3243 SetPixelBlack(image,ScaleLongLongToQuantum(*p),q);
3248 SetPixelGray(image,ScaleLongLongToQuantum(*p),q);
3256 q+=GetPixelChannels(image);
3258 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3263 static void ImportQuantumPixel(Image *image,const RectangleInfo *roi,
3264 const char *restrict map,const QuantumType *quantum_map,const void *pixels,
3265 ExceptionInfo *exception)
3267 register const Quantum
3282 p=(const Quantum *) pixels;
3283 if (LocaleCompare(map,"BGR") == 0)
3285 for (y=0; y < (ssize_t) roi->height; y++)
3287 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3288 if (q == (Quantum *) NULL)
3290 for (x=0; x < (ssize_t) roi->width; x++)
3292 SetPixelBlue(image,*p++,q);
3293 SetPixelGreen(image,*p++,q);
3294 SetPixelRed(image,*p++,q);
3295 q+=GetPixelChannels(image);
3297 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3302 if (LocaleCompare(map,"BGRA") == 0)
3304 for (y=0; y < (ssize_t) roi->height; y++)
3306 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3307 if (q == (Quantum *) NULL)
3309 for (x=0; x < (ssize_t) roi->width; x++)
3311 SetPixelBlue(image,*p++,q);
3312 SetPixelGreen(image,*p++,q);
3313 SetPixelRed(image,*p++,q);
3314 SetPixelAlpha(image,*p++,q);
3315 q+=GetPixelChannels(image);
3317 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3322 if (LocaleCompare(map,"BGRP") == 0)
3324 for (y=0; y < (ssize_t) roi->height; y++)
3326 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3327 if (q == (Quantum *) NULL)
3329 for (x=0; x < (ssize_t) roi->width; x++)
3331 SetPixelBlue(image,*p++,q);
3332 SetPixelGreen(image,*p++,q);
3333 SetPixelRed(image,*p++,q);
3335 q+=GetPixelChannels(image);
3337 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3342 if (LocaleCompare(map,"I") == 0)
3344 for (y=0; y < (ssize_t) roi->height; y++)
3346 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3347 if (q == (Quantum *) NULL)
3349 for (x=0; x < (ssize_t) roi->width; x++)
3351 SetPixelGray(image,*p++,q);
3352 q+=GetPixelChannels(image);
3354 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3359 if (LocaleCompare(map,"RGB") == 0)
3361 for (y=0; y < (ssize_t) roi->height; y++)
3363 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3364 if (q == (Quantum *) NULL)
3366 for (x=0; x < (ssize_t) roi->width; x++)
3368 SetPixelRed(image,*p++,q);
3369 SetPixelGreen(image,*p++,q);
3370 SetPixelBlue(image,*p++,q);
3371 q+=GetPixelChannels(image);
3373 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3378 if (LocaleCompare(map,"RGBA") == 0)
3380 for (y=0; y < (ssize_t) roi->height; y++)
3382 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3383 if (q == (Quantum *) NULL)
3385 for (x=0; x < (ssize_t) roi->width; x++)
3387 SetPixelRed(image,*p++,q);
3388 SetPixelGreen(image,*p++,q);
3389 SetPixelBlue(image,*p++,q);
3390 SetPixelAlpha(image,*p++,q);
3391 q+=GetPixelChannels(image);
3393 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3398 if (LocaleCompare(map,"RGBP") == 0)
3400 for (y=0; y < (ssize_t) roi->height; y++)
3402 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3403 if (q == (Quantum *) NULL)
3405 for (x=0; x < (ssize_t) roi->width; x++)
3407 SetPixelRed(image,*p++,q);
3408 SetPixelGreen(image,*p++,q);
3409 SetPixelBlue(image,*p++,q);
3411 q+=GetPixelChannels(image);
3413 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3419 for (y=0; y < (ssize_t) roi->height; y++)
3421 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3422 if (q == (Quantum *) NULL)
3424 for (x=0; x < (ssize_t) roi->width; x++)
3429 for (i=0; i < (ssize_t) length; i++)
3431 switch (quantum_map[i])
3436 SetPixelRed(image,*p,q);
3440 case MagentaQuantum:
3442 SetPixelGreen(image,*p,q);
3448 SetPixelBlue(image,*p,q);
3453 SetPixelAlpha(image,*p,q);
3456 case OpacityQuantum:
3458 SetPixelAlpha(image,*p,q);
3463 SetPixelBlack(image,*p,q);
3468 SetPixelGray(image,*p,q);
3476 q+=GetPixelChannels(image);
3478 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3483 static void ImportShortPixel(Image *image,const RectangleInfo *roi,
3484 const char *restrict map,const QuantumType *quantum_map,const void *pixels,
3485 ExceptionInfo *exception)
3487 register const unsigned short
3502 p=(const unsigned short *) pixels;
3503 if (LocaleCompare(map,"BGR") == 0)
3505 for (y=0; y < (ssize_t) roi->height; y++)
3507 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3508 if (q == (Quantum *) NULL)
3510 for (x=0; x < (ssize_t) roi->width; x++)
3512 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3513 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3514 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3515 q+=GetPixelChannels(image);
3517 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3522 if (LocaleCompare(map,"BGRA") == 0)
3524 for (y=0; y < (ssize_t) roi->height; y++)
3526 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3527 if (q == (Quantum *) NULL)
3529 for (x=0; x < (ssize_t) roi->width; x++)
3531 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3532 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3533 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3534 SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3535 q+=GetPixelChannels(image);
3537 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3542 if (LocaleCompare(map,"BGRP") == 0)
3544 for (y=0; y < (ssize_t) roi->height; y++)
3546 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3547 if (q == (Quantum *) NULL)
3549 for (x=0; x < (ssize_t) roi->width; x++)
3551 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3552 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3553 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3555 q+=GetPixelChannels(image);
3557 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3562 if (LocaleCompare(map,"I") == 0)
3564 for (y=0; y < (ssize_t) roi->height; y++)
3566 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3567 if (q == (Quantum *) NULL)
3569 for (x=0; x < (ssize_t) roi->width; x++)
3571 SetPixelGray(image,ScaleShortToQuantum(*p++),q);
3572 q+=GetPixelChannels(image);
3574 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3579 if (LocaleCompare(map,"RGB") == 0)
3581 for (y=0; y < (ssize_t) roi->height; y++)
3583 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3584 if (q == (Quantum *) NULL)
3586 for (x=0; x < (ssize_t) roi->width; x++)
3588 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3589 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3590 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3591 q+=GetPixelChannels(image);
3593 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3598 if (LocaleCompare(map,"RGBA") == 0)
3600 for (y=0; y < (ssize_t) roi->height; y++)
3602 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3603 if (q == (Quantum *) NULL)
3605 for (x=0; x < (ssize_t) roi->width; x++)
3607 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3608 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3609 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3610 SetPixelAlpha(image,ScaleShortToQuantum(*p++),q);
3611 q+=GetPixelChannels(image);
3613 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3618 if (LocaleCompare(map,"RGBP") == 0)
3620 for (y=0; y < (ssize_t) roi->height; y++)
3622 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3623 if (q == (Quantum *) NULL)
3625 for (x=0; x < (ssize_t) roi->width; x++)
3627 SetPixelRed(image,ScaleShortToQuantum(*p++),q);
3628 SetPixelGreen(image,ScaleShortToQuantum(*p++),q);
3629 SetPixelBlue(image,ScaleShortToQuantum(*p++),q);
3631 q+=GetPixelChannels(image);
3633 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3639 for (y=0; y < (ssize_t) roi->height; y++)
3641 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3642 if (q == (Quantum *) NULL)
3644 for (x=0; x < (ssize_t) roi->width; x++)
3649 for (i=0; i < (ssize_t) length; i++)
3651 switch (quantum_map[i])
3656 SetPixelRed(image,ScaleShortToQuantum(*p),q);
3660 case MagentaQuantum:
3662 SetPixelGreen(image,ScaleShortToQuantum(*p),q);
3668 SetPixelBlue(image,ScaleShortToQuantum(*p),q);
3673 SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
3676 case OpacityQuantum:
3678 SetPixelAlpha(image,ScaleShortToQuantum(*p),q);
3683 SetPixelBlack(image,ScaleShortToQuantum(*p),q);
3688 SetPixelGray(image,ScaleShortToQuantum(*p),q);
3696 q+=GetPixelChannels(image);
3698 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3703 MagickExport MagickBooleanType ImportImagePixels(Image *image,const ssize_t x,
3704 const ssize_t y,const size_t width,const size_t height,const char *map,
3705 const StorageType type,const void *pixels,ExceptionInfo *exception)
3720 Allocate image structure.
3722 assert(image != (Image *) NULL);
3723 assert(image->signature == MagickSignature);
3724 if (image->debug != MagickFalse)
3725 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
3727 quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
3728 if (quantum_map == (QuantumType *) NULL)
3729 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
3731 for (i=0; i < (ssize_t) length; i++)
3738 quantum_map[i]=AlphaQuantum;
3739 image->matte=MagickTrue;
3745 quantum_map[i]=BlueQuantum;
3751 quantum_map[i]=CyanQuantum;
3752 (void) SetImageColorspace(image,CMYKColorspace,exception);
3758 quantum_map[i]=GreenQuantum;
3764 quantum_map[i]=BlackQuantum;
3765 (void) SetImageColorspace(image,CMYKColorspace,exception);
3771 quantum_map[i]=IndexQuantum;
3772 (void) SetImageColorspace(image,GRAYColorspace,exception);
3778 quantum_map[i]=MagentaQuantum;
3779 (void) SetImageColorspace(image,CMYKColorspace,exception);
3785 quantum_map[i]=OpacityQuantum;
3786 image->matte=MagickTrue;
3792 quantum_map[i]=UndefinedQuantum;
3798 quantum_map[i]=RedQuantum;
3804 quantum_map[i]=YellowQuantum;
3805 (void) SetImageColorspace(image,CMYKColorspace,exception);
3810 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3811 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
3812 "UnrecognizedPixelMap","'%s'",map);
3813 return(MagickFalse);
3817 if (SetImageStorageClass(image,DirectClass,exception) == MagickFalse)
3818 return(MagickFalse);
3820 Transfer the pixels from the pixel data to the image.
3830 ImportCharPixel(image,&roi,map,quantum_map,pixels,exception);
3835 ImportDoublePixel(image,&roi,map,quantum_map,pixels,exception);
3840 ImportFloatPixel(image,&roi,map,quantum_map,pixels,exception);
3845 ImportLongPixel(image,&roi,map,quantum_map,pixels,exception);
3850 ImportLongLongPixel(image,&roi,map,quantum_map,pixels,exception);
3855 ImportQuantumPixel(image,&roi,map,quantum_map,pixels,exception);
3860 ImportShortPixel(image,&roi,map,quantum_map,pixels,exception);
3865 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3866 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
3867 "UnrecognizedPixelMap","'%s'",map);
3871 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
3876 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3880 + 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 %
3884 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3886 % InitializePixelChannelMap() defines the standard pixel component map.
3888 % The format of the InitializePixelChannelMap() method is:
3890 % void InitializePixelChannelMap(Image *image)
3892 % A description of each parameter follows:
3894 % o image: the image.
3897 MagickExport void InitializePixelChannelMap(Image *image)
3908 assert(image != (Image *) NULL);
3909 assert(image->signature == MagickSignature);
3910 (void) ResetMagickMemory(image->channel_map,0,MaxPixelChannels*
3911 sizeof(*image->channel_map));
3912 trait=UpdatePixelTrait;
3913 if (image->matte != MagickFalse)
3914 trait=(PixelTrait) (trait | BlendPixelTrait);
3916 if (image->colorspace == GRAYColorspace)
3918 SetPixelChannelMap(image,BluePixelChannel,trait,n);
3919 SetPixelChannelMap(image,GreenPixelChannel,trait,n);
3920 SetPixelChannelMap(image,RedPixelChannel,trait,n++);
3924 SetPixelChannelMap(image,RedPixelChannel,trait,n++);
3925 SetPixelChannelMap(image,GreenPixelChannel,trait,n++);
3926 SetPixelChannelMap(image,BluePixelChannel,trait,n++);
3928 if (image->colorspace == CMYKColorspace)
3929 SetPixelChannelMap(image,BlackPixelChannel,trait,n++);
3930 if (image->matte != MagickFalse)
3931 SetPixelChannelMap(image,AlphaPixelChannel,CopyPixelTrait,n++);
3932 if (image->storage_class == PseudoClass)
3933 SetPixelChannelMap(image,IndexPixelChannel,CopyPixelTrait,n++);
3934 if (image->mask != MagickFalse)
3935 SetPixelChannelMap(image,MaskPixelChannel,CopyPixelTrait,n++);
3936 assert((n+image->number_meta_channels) < MaxPixelChannels);
3937 for (i=0; i < (ssize_t) image->number_meta_channels; i++)
3938 SetPixelChannelMap(image,(PixelChannel) (MetaPixelChannel+i),CopyPixelTrait,
3940 image->number_channels=(size_t) n;
3941 if (image->debug != MagickFalse)
3942 LogPixelChannels(image);
3943 (void) SetPixelChannelMask(image,image->channel_mask);
3947 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3951 % I n t e r p o l a t e P i x e l C h a n n e l %
3955 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3957 % InterpolatePixelChannel() applies a pixel interpolation method between a
3958 % floating point coordinate and the pixels surrounding that coordinate. No
3959 % pixel area resampling, or scaling of the result is performed.
3961 % Interpolation is restricted to just the specified channel.
3963 % The format of the InterpolatePixelChannel method is:
3965 % MagickBooleanType InterpolatePixelChannel(const Image *image,
3966 % const CacheView *image_view,const PixelChannel channel,
3967 % const PixelInterpolateMethod method,const double x,const double y,
3968 % double *pixel,ExceptionInfo *exception)
3970 % A description of each parameter follows:
3972 % o image: the image.
3974 % o image_view: the image view.
3976 % o channel: the pixel channel to interpolate.
3978 % o method: the pixel color interpolation method.
3980 % o x,y: A double representing the current (x,y) position of the pixel.
3982 % o pixel: return the interpolated pixel here.
3984 % o exception: return any errors or warnings in this structure.
3988 static inline double MagickMax(const MagickRealType x,const MagickRealType y)
3995 static inline void CatromWeights(const MagickRealType x,
3996 MagickRealType (*weights)[4])
3999 Nicolas Robidoux' 10 flops (4* + 5- + 1+) refactoring of the
4000 computation of the standard four 1D Catmull-Rom weights. The
4001 sampling location is assumed between the second and third input
4002 pixel locations, and x is the position relative to the second
4003 input pixel location. Formulas originally derived for the VIPS
4004 (Virtual Image Processing System) library.
4011 alpha=(MagickRealType) 1.0-x;
4012 beta=(MagickRealType) (-0.5)*x*alpha;
4013 (*weights)[0]=alpha*beta;
4014 (*weights)[3]=x*beta;
4016 The following computation of the inner weights from the outer ones
4017 works for all Keys cubics.
4019 gamma=(*weights)[3]-(*weights)[0];
4020 (*weights)[1]=alpha-(*weights)[0]+gamma;
4021 (*weights)[2]=x-(*weights)[3]-gamma;
4024 static inline void SplineWeights(const MagickRealType x,
4025 MagickRealType (*weights)[4])
4028 Nicolas Robidoux' 12 flops (6* + 5- + 1+) refactoring of the
4029 computation of the standard four 1D cubic B-spline smoothing
4030 weights. The sampling location is assumed between the second and
4031 third input pixel locations, and x is the position relative to the
4032 second input pixel location.
4038 alpha=(MagickRealType) 1.0-x;
4039 (*weights)[3]=(MagickRealType) (1.0/6.0)*x*x*x;
4040 (*weights)[0]=(MagickRealType) (1.0/6.0)*alpha*alpha*alpha;
4041 beta=(*weights)[3]-(*weights)[0];
4042 (*weights)[1]=alpha-(*weights)[0]+beta;
4043 (*weights)[2]=x-(*weights)[3]-beta;
4046 static inline double MeshInterpolate(const PointInfo *delta,const double p,
4047 const double x,const double y)
4049 return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
4053 static inline ssize_t NearestNeighbor(const MagickRealType x)
4056 return((ssize_t) (x+0.5));
4057 return((ssize_t) (x-0.5));
4061 MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
4062 const CacheView *image_view,const PixelChannel channel,
4063 const PixelInterpolateMethod method,const double x,const double y,
4064 double *pixel,ExceptionInfo *exception)
4077 register const Quantum
4087 PixelInterpolateMethod
4090 assert(image != (Image *) NULL);
4091 assert(image != (Image *) NULL);
4092 assert(image->signature == MagickSignature);
4093 assert(image_view != (CacheView *) NULL);
4096 traits=GetPixelChannelMapTraits(image,channel);
4097 x_offset=(ssize_t) floor(x);
4098 y_offset=(ssize_t) floor(y);
4099 interpolate = method;
4100 if ( interpolate == UndefinedInterpolatePixel )
4101 interpolate = image->interpolate;
4102 switch (interpolate)
4104 case AverageInterpolatePixel: /* nearest 4 neighbours */
4105 case Average9InterpolatePixel: /* nearest 9 neighbours */
4106 case Average16InterpolatePixel: /* nearest 16 neighbours */
4109 count=2; /* size of the area to average - default nearest 4 */
4111 if (interpolate == Average9InterpolatePixel)
4114 x_offset=(ssize_t) (floor(x+0.5)-1);
4115 y_offset=(ssize_t) (floor(y+0.5)-1);
4117 else if (interpolate == Average16InterpolatePixel)
4123 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,count,count,
4125 if (p == (const Quantum *) NULL)
4131 count*=count; /* Number of pixels to Average */
4132 if ((traits & BlendPixelTrait) == 0)
4133 for (i=0; i < (ssize_t) count; i++)
4136 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4139 for (i=0; i < (ssize_t) count; i++)
4141 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4142 GetPixelChannels(image));
4143 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4145 for (i=0; i < (ssize_t) count; i++)
4147 gamma=MagickEpsilonReciprocal(alpha[i])/count;
4148 *pixel+=gamma*pixels[i];
4152 case BilinearInterpolatePixel:
4159 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4160 if (p == (const Quantum *) NULL)
4165 if ((traits & BlendPixelTrait) == 0)
4166 for (i=0; i < 4; i++)
4169 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4172 for (i=0; i < 4; i++)
4174 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4175 GetPixelChannels(image));
4176 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4180 epsilon.x=1.0-delta.x;
4181 epsilon.y=1.0-delta.y;
4182 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4183 (epsilon.x*alpha[2]+delta.x*alpha[3])));
4184 gamma=MagickEpsilonReciprocal(gamma);
4185 *pixel=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
4186 (epsilon.x*pixels[2]+delta.x*pixels[3]));
4189 case CatromInterpolatePixel:
4195 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4197 if (p == (const Quantum *) NULL)
4202 if ((traits & BlendPixelTrait) == 0)
4203 for (i=0; i < 16; i++)
4206 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4209 for (i=0; i < 16; i++)
4211 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4212 GetPixelChannels(image));
4213 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4215 CatromWeights((MagickRealType) (x-x_offset),&cx);
4216 CatromWeights((MagickRealType) (y-y_offset),&cy);
4217 gamma=(channel == AlphaPixelChannel ? (MagickRealType) 1.0 :
4218 MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
4219 alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
4220 alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
4221 alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
4222 cx[2]*alpha[14]+cx[3]*alpha[15])));
4223 *pixel=gamma*(cy[0]*(cx[0]*pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+
4224 cx[3]*pixels[3])+cy[1]*(cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*
4225 pixels[6]+cx[3]*pixels[7])+cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+
4226 cx[2]*pixels[10]+cx[3]*pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*
4227 pixels[13]+cx[2]*pixels[14]+cx[3]*pixels[15]));
4231 /* deprecated useless and very slow interpolator */
4232 case FilterInterpolatePixel:
4246 geometry.x=x_offset-1;
4247 geometry.y=y_offset-1;
4248 excerpt_image=ExcerptImage(image,&geometry,exception);
4249 if (excerpt_image == (Image *) NULL)
4254 filter_image=ResizeImage(excerpt_image,1,1,image->filter,exception);
4255 excerpt_image=DestroyImage(excerpt_image);
4256 if (filter_image == (Image *) NULL)
4258 filter_view=AcquireVirtualCacheView(filter_image,exception);
4259 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4260 if (p == (const Quantum *) NULL)
4263 *pixel=(double) GetPixelChannel(image,channel,p);
4264 filter_view=DestroyCacheView(filter_view);
4265 filter_image=DestroyImage(filter_image);
4269 case IntegerInterpolatePixel:
4271 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4272 if (p == (const Quantum *) NULL)
4277 *pixel=(double) GetPixelChannel(image,channel,p);
4280 case NearestInterpolatePixel:
4282 x_offset=(ssize_t) floor(x+0.5);
4283 y_offset=(ssize_t) floor(y+0.5);
4284 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4285 if (p == (const Quantum *) NULL)
4290 *pixel=(double) GetPixelChannel(image,channel,p);
4293 case MeshInterpolatePixel:
4299 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4300 if (p == (const Quantum *) NULL)
4305 if ((traits & BlendPixelTrait) == 0)
4306 for (i=0; i < 4; i++)
4309 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4312 for (i=0; i < 4; i++)
4314 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4315 GetPixelChannels(image));
4316 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4320 luminance.x=GetPixelLuminance(image,p)-(double)
4321 GetPixelLuminance(image,p+3*GetPixelChannels(image));
4322 luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
4323 GetPixelLuminance(image,p+2*GetPixelChannels(image));
4324 if (fabs(luminance.x) < fabs(luminance.y))
4329 if (delta.x <= delta.y)
4332 Bottom-left triangle (pixel: 2, diagonal: 0-3).
4334 delta.y=1.0-delta.y;
4335 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4336 gamma=MagickEpsilonReciprocal(gamma);
4337 *pixel=gamma*MeshInterpolate(&delta,pixels[2],pixels[3],
4343 Top-right triangle (pixel: 1, diagonal: 0-3).
4345 delta.x=1.0-delta.x;
4346 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4347 gamma=MagickEpsilonReciprocal(gamma);
4348 *pixel=gamma*MeshInterpolate(&delta,pixels[1],pixels[0],
4357 if (delta.x <= (1.0-delta.y))
4360 Top-left triangle (pixel: 0, diagonal: 1-2).
4362 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4363 gamma=MagickEpsilonReciprocal(gamma);
4364 *pixel=gamma*MeshInterpolate(&delta,pixels[0],pixels[1],
4370 Bottom-right triangle (pixel: 3, diagonal: 1-2).
4372 delta.x=1.0-delta.x;
4373 delta.y=1.0-delta.y;
4374 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4375 gamma=MagickEpsilonReciprocal(gamma);
4376 *pixel=gamma*MeshInterpolate(&delta,pixels[3],pixels[2],
4382 case SplineInterpolatePixel:
4388 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4390 if (p == (const Quantum *) NULL)
4395 if ((traits & BlendPixelTrait) == 0)
4396 for (i=0; i < 16; i++)
4399 pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
4402 for (i=0; i < 16; i++)
4404 alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
4405 GetPixelChannels(image));
4406 pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
4408 SplineWeights((MagickRealType) (x-x_offset),&cx);
4409 SplineWeights((MagickRealType) (y-y_offset),&cy);
4410 gamma=(channel == AlphaPixelChannel ? (MagickRealType) 1.0 :
4411 MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
4412 alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
4413 alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
4414 alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
4415 cx[2]*alpha[14]+cx[3]*alpha[15])));
4416 *pixel=gamma*(cy[0]*(cx[0]*pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+
4417 cx[3]*pixels[3])+cy[1]*(cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*
4418 pixels[6]+cx[3]*pixels[7])+cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+
4419 cx[2]*pixels[10]+cx[3]*pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*
4420 pixels[13]+cx[2]*pixels[14]+cx[3]*pixels[15]));
4428 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4432 % I n t e r p o l a t e P i x e l C h a n n e l s %
4436 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4438 % InterpolatePixelChannels() applies a pixel interpolation method between a
4439 % floating point coordinate and the pixels surrounding that coordinate. No
4440 % pixel area resampling, or scaling of the result is performed.
4442 % Interpolation is restricted to just the current channel setting of the
4443 % destination image into which the color is to be stored
4445 % The format of the InterpolatePixelChannels method is:
4447 % MagickBooleanType InterpolatePixelChannels(const Image *source,
4448 % const CacheView *source_view,const Image *destination,
4449 % const PixelInterpolateMethod method,const double x,const double y,
4450 % Quantum *pixel,ExceptionInfo *exception)
4452 % A description of each parameter follows:
4454 % o source: the source.
4456 % o source_view: the source view.
4458 % o destination: the destination image, for the interpolated color
4460 % o method: the pixel color interpolation method.
4462 % o x,y: A double representing the current (x,y) position of the pixel.
4464 % o pixel: return the interpolated pixel here.
4466 % o exception: return any errors or warnings in this structure.
4469 MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
4470 const CacheView *source_view,const Image *destination,
4471 const PixelInterpolateMethod method,const double x,const double y,
4472 Quantum *pixel,ExceptionInfo *exception)
4489 register const Quantum
4499 PixelInterpolateMethod
4502 assert(source != (Image *) NULL);
4503 assert(source != (Image *) NULL);
4504 assert(source->signature == MagickSignature);
4505 assert(source_view != (CacheView *) NULL);
4507 x_offset=(ssize_t) floor(x);
4508 y_offset=(ssize_t) floor(y);
4509 interpolate = method;
4510 if ( interpolate == UndefinedInterpolatePixel )
4511 interpolate = source->interpolate;
4512 switch (interpolate)
4514 case AverageInterpolatePixel: /* nearest 4 neighbours */
4515 case Average9InterpolatePixel: /* nearest 9 neighbours */
4516 case Average16InterpolatePixel: /* nearest 16 neighbours */
4519 count=2; /* size of the area to average - default nearest 4 */
4521 if (interpolate == Average9InterpolatePixel)
4524 x_offset=(ssize_t) (floor(x+0.5)-1);
4525 y_offset=(ssize_t) (floor(y+0.5)-1);
4527 else if (interpolate == Average16InterpolatePixel)
4533 p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,count,count,
4535 if (p == (const Quantum *) NULL)
4540 count*=count; /* Number of pixels to Average */
4541 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4549 channel=GetPixelChannelMapChannel(source,i);
4550 traits=GetPixelChannelMapTraits(source,channel);
4551 destination_traits=GetPixelChannelMapTraits(destination,channel);
4552 if ((traits == UndefinedPixelTrait) ||
4553 (destination_traits == UndefinedPixelTrait))
4555 for (j=0; j < (ssize_t) count; j++)
4556 pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4558 if ((traits & BlendPixelTrait) == 0)
4560 for (j=0; j < (ssize_t) count; j++)
4563 SetPixelChannel(destination,channel,ClampToQuantum(sum),pixel);
4566 for (j=0; j < (ssize_t) count; j++)
4568 alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4569 GetPixelChannels(source));
4570 pixels[j]*=alpha[j];
4571 gamma=MagickEpsilonReciprocal(alpha[j]);
4572 sum+=gamma*pixels[j];
4575 SetPixelChannel(destination,channel,ClampToQuantum(sum),pixel);
4579 case BilinearInterpolatePixel:
4582 p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
4583 if (p == (const Quantum *) NULL)
4588 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4594 channel=GetPixelChannelMapChannel(source,i);
4595 traits=GetPixelChannelMapTraits(source,channel);
4596 destination_traits=GetPixelChannelMapTraits(destination,channel);
4597 if ((traits == UndefinedPixelTrait) ||
4598 (destination_traits == UndefinedPixelTrait))
4602 epsilon.x=1.0-delta.x;
4603 epsilon.y=1.0-delta.y;
4604 pixels[0]=(MagickRealType) p[i];
4605 pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
4606 pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
4607 pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
4608 if ((traits & BlendPixelTrait) == 0)
4610 gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4611 gamma=MagickEpsilonReciprocal(gamma);
4612 SetPixelChannel(destination,channel,ClampToQuantum(gamma*(epsilon.y*
4613 (epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*(epsilon.x*
4614 pixels[2]+delta.x*pixels[3]))),pixel);
4617 alpha[0]=QuantumScale*GetPixelAlpha(source,p);
4618 alpha[1]=QuantumScale*GetPixelAlpha(source,p+GetPixelChannels(source));
4619 alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
4620 GetPixelChannels(source));
4621 alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
4622 GetPixelChannels(source));
4623 pixels[0]*=alpha[0];
4624 pixels[1]*=alpha[1];
4625 pixels[2]*=alpha[2];
4626 pixels[3]*=alpha[3];
4627 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4628 (epsilon.x*alpha[2]+delta.x*alpha[3])));
4629 gamma=MagickEpsilonReciprocal(gamma);
4630 SetPixelChannel(destination,channel,ClampToQuantum(gamma*(epsilon.y*
4631 (epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+
4632 delta.x*pixels[3]))),pixel);
4636 case CatromInterpolatePixel:
4642 p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4644 if (p == (const Quantum *) NULL)
4649 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4654 channel=GetPixelChannelMapChannel(source,i);
4655 traits=GetPixelChannelMapTraits(source,channel);
4656 destination_traits=GetPixelChannelMapTraits(destination,channel);
4657 if ((traits == UndefinedPixelTrait) ||
4658 (destination_traits == UndefinedPixelTrait))
4660 if ((traits & BlendPixelTrait) == 0)
4661 for (j=0; j < 16; j++)
4664 pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4667 for (j=0; j < 16; j++)
4669 alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4670 GetPixelChannels(source));
4671 pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
4673 CatromWeights((MagickRealType) (x-x_offset),&cx);
4674 CatromWeights((MagickRealType) (y-y_offset),&cy);
4675 gamma=((traits & BlendPixelTrait) ? (MagickRealType) (1.0) :
4676 MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
4677 alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
4678 alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
4679 alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
4680 cx[2]*alpha[14]+cx[3]*alpha[15])));
4681 SetPixelChannel(destination,channel,ClampToQuantum(gamma*(cy[0]*(cx[0]*
4682 pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+cx[3]*pixels[3])+cy[1]*
4683 (cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*pixels[6]+cx[3]*pixels[7])+
4684 cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+cx[2]*pixels[10]+cx[3]*
4685 pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*pixels[13]+cx[2]*
4686 pixels[14]+cx[3]*pixels[15]))),pixel);
4691 /* deprecated useless and very slow interpolator */
4692 case FilterInterpolatePixel:
4694 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4706 channel=GetPixelChannelMapChannel(source,i);
4707 traits=GetPixelChannelMapTraits(source,channel);
4708 destination_traits=GetPixelChannelMapTraits(destination,channel);
4709 if ((traits == UndefinedPixelTrait) ||
4710 (destination_traits == UndefinedPixelTrait))
4714 geometry.x=x_offset-1;
4715 geometry.y=y_offset-1;
4716 excerpt_source=ExcerptImage(source,&geometry,exception);
4717 if (excerpt_source == (Image *) NULL)
4722 filter_source=ResizeImage(excerpt_source,1,1,source->filter,exception);
4723 excerpt_source=DestroyImage(excerpt_source);
4724 if (filter_source == (Image *) NULL)
4726 filter_view=AcquireVirtualCacheView(filter_source,exception);
4727 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4728 if (p == (const Quantum *) NULL)
4732 SetPixelChannel(destination,channel,p[i],pixel);
4734 filter_view=DestroyCacheView(filter_view);
4735 filter_source=DestroyImage(filter_source);
4740 case IntegerInterpolatePixel:
4742 p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
4743 if (p == (const Quantum *) NULL)
4748 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4750 channel=GetPixelChannelMapChannel(source,i);
4751 traits=GetPixelChannelMapTraits(source,channel);
4752 destination_traits=GetPixelChannelMapTraits(destination,channel);
4753 if ((traits == UndefinedPixelTrait) ||
4754 (destination_traits == UndefinedPixelTrait))
4756 SetPixelChannel(destination,channel,p[i],pixel);
4760 case NearestInterpolatePixel:
4762 x_offset=(ssize_t) floor(x+0.5);
4763 y_offset=(ssize_t) floor(y+0.5);
4764 p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
4765 if (p == (const Quantum *) NULL)
4770 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4772 channel=GetPixelChannelMapChannel(source,i);
4773 traits=GetPixelChannelMapTraits(source,channel);
4774 destination_traits=GetPixelChannelMapTraits(destination,channel);
4775 if ((traits == UndefinedPixelTrait) ||
4776 (destination_traits == UndefinedPixelTrait))
4778 SetPixelChannel(destination,channel,p[i],pixel);
4782 case MeshInterpolatePixel:
4784 p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
4785 if (p == (const Quantum *) NULL)
4790 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4796 channel=GetPixelChannelMapChannel(source,i);
4797 traits=GetPixelChannelMapTraits(source,channel);
4798 destination_traits=GetPixelChannelMapTraits(destination,channel);
4799 if ((traits == UndefinedPixelTrait) ||
4800 (destination_traits == UndefinedPixelTrait))
4802 pixels[0]=(MagickRealType) p[i];
4803 pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
4804 pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
4805 pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
4806 if ((traits & BlendPixelTrait) == 0)
4815 alpha[0]=QuantumScale*GetPixelAlpha(source,p);
4816 alpha[1]=QuantumScale*GetPixelAlpha(source,p+
4817 GetPixelChannels(source));
4818 alpha[2]=QuantumScale*GetPixelAlpha(source,p+2*
4819 GetPixelChannels(source));
4820 alpha[3]=QuantumScale*GetPixelAlpha(source,p+3*
4821 GetPixelChannels(source));
4825 luminance.x=fabs((double)(
4826 GetPixelLuminance(source,p)
4827 -GetPixelLuminance(source,p+3*GetPixelChannels(source))));
4828 luminance.y=fabs((double)(
4829 GetPixelLuminance(source,p+GetPixelChannels(source))
4830 -GetPixelLuminance(source,p+2*GetPixelChannels(source))));
4831 if (luminance.x < luminance.y)
4836 if (delta.x <= delta.y)
4839 Bottom-left triangle (pixel: 2, diagonal: 0-3).
4841 delta.y=1.0-delta.y;
4842 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4843 gamma=MagickEpsilonReciprocal(gamma);
4844 SetPixelChannel(destination,channel,ClampToQuantum(gamma*
4845 MeshInterpolate(&delta,pixels[2],pixels[3],pixels[0])),pixel);
4850 Top-right triangle (pixel: 1, diagonal: 0-3).
4852 delta.x=1.0-delta.x;
4853 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4854 gamma=MagickEpsilonReciprocal(gamma);
4855 SetPixelChannel(destination,channel,ClampToQuantum(gamma*
4856 MeshInterpolate(&delta,pixels[1],pixels[0],pixels[3])),pixel);
4864 if (delta.x <= (1.0-delta.y))
4867 Top-left triangle (pixel: 0, diagonal: 1-2).
4869 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4870 gamma=MagickEpsilonReciprocal(gamma);
4871 SetPixelChannel(destination,channel,ClampToQuantum(gamma*
4872 MeshInterpolate(&delta,pixels[0],pixels[1],pixels[2])),pixel);
4877 Bottom-right triangle (pixel: 3, diagonal: 1-2).
4879 delta.x=1.0-delta.x;
4880 delta.y=1.0-delta.y;
4881 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4882 gamma=MagickEpsilonReciprocal(gamma);
4883 SetPixelChannel(destination,channel,ClampToQuantum(gamma*
4884 MeshInterpolate(&delta,pixels[3],pixels[2],pixels[1])),pixel);
4890 case SplineInterpolatePixel:
4896 p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
4898 if (p == (const Quantum *) NULL)
4903 for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
4908 channel=GetPixelChannelMapChannel(source,i);
4909 traits=GetPixelChannelMapTraits(source,channel);
4910 destination_traits=GetPixelChannelMapTraits(destination,channel);
4911 if ((traits == UndefinedPixelTrait) ||
4912 (destination_traits == UndefinedPixelTrait))
4914 if ((traits & BlendPixelTrait) == 0)
4915 for (j=0; j < 16; j++)
4918 pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
4921 for (j=0; j < 16; j++)
4923 alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
4924 GetPixelChannels(source));
4925 pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
4927 SplineWeights((MagickRealType) (x-x_offset),&cx);
4928 SplineWeights((MagickRealType) (y-y_offset),&cy);
4929 gamma=((traits & BlendPixelTrait) ? (MagickRealType) (1.0) :
4930 MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
4931 alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
4932 alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
4933 alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
4934 cx[2]*alpha[14]+cx[3]*alpha[15])));
4935 SetPixelChannel(destination,channel,ClampToQuantum(gamma*(cy[0]*(cx[0]*
4936 pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+cx[3]*pixels[3])+cy[1]*
4937 (cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*pixels[6]+cx[3]*pixels[7])+
4938 cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+cx[2]*pixels[10]+cx[3]*
4939 pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*pixels[13]+cx[2]*
4940 pixels[14]+cx[3]*pixels[15]))),pixel);
4949 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4953 % I n t e r p o l a t e P i x e l I n f o %
4957 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4959 % InterpolatePixelInfo() applies a pixel interpolation method between a
4960 % floating point coordinate and the pixels surrounding that coordinate. No
4961 % pixel area resampling, or scaling of the result is performed.
4963 % Interpolation is restricted to just RGBKA channels.
4965 % The format of the InterpolatePixelInfo method is:
4967 % MagickBooleanType InterpolatePixelInfo(const Image *image,
4968 % const CacheView *image_view,const PixelInterpolateMethod method,
4969 % const double x,const double y,PixelInfo *pixel,
4970 % ExceptionInfo *exception)
4972 % A description of each parameter follows:
4974 % o image: the image.
4976 % o image_view: the image view.
4978 % o method: the pixel color interpolation method.
4980 % o x,y: A double representing the current (x,y) position of the pixel.
4982 % o pixel: return the interpolated pixel here.
4984 % o exception: return any errors or warnings in this structure.
4988 static inline void AlphaBlendPixelInfo(const Image *image,
4989 const Quantum *pixel,PixelInfo *pixel_info,MagickRealType *alpha)
4991 if (image->matte == MagickFalse)
4994 pixel_info->red=(MagickRealType) GetPixelRed(image,pixel);
4995 pixel_info->green=(MagickRealType) GetPixelGreen(image,pixel);
4996 pixel_info->blue=(MagickRealType) GetPixelBlue(image,pixel);
4997 pixel_info->black=0.0;
4998 if (image->colorspace == CMYKColorspace)
4999 pixel_info->black=(MagickRealType) GetPixelBlack(image,pixel);
5000 pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
5003 *alpha=QuantumScale*GetPixelAlpha(image,pixel);
5004 pixel_info->red=(*alpha*GetPixelRed(image,pixel));
5005 pixel_info->green=(*alpha*GetPixelGreen(image,pixel));
5006 pixel_info->blue=(*alpha*GetPixelBlue(image,pixel));
5007 pixel_info->black=0.0;
5008 if (image->colorspace == CMYKColorspace)
5009 pixel_info->black=(*alpha*GetPixelBlack(image,pixel));
5010 pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
5013 MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
5014 const CacheView *image_view,const PixelInterpolateMethod method,
5015 const double x,const double y,PixelInfo *pixel,ExceptionInfo *exception)
5027 register const Quantum
5037 PixelInterpolateMethod
5040 assert(image != (Image *) NULL);
5041 assert(image->signature == MagickSignature);
5042 assert(image_view != (CacheView *) NULL);
5044 x_offset=(ssize_t) floor(x);
5045 y_offset=(ssize_t) floor(y);
5046 interpolate = method;
5047 if ( interpolate == UndefinedInterpolatePixel )
5048 interpolate = image->interpolate;
5049 switch (interpolate)
5051 case AverageInterpolatePixel: /* nearest 4 neighbours */
5052 case Average9InterpolatePixel: /* nearest 9 neighbours */
5053 case Average16InterpolatePixel: /* nearest 16 neighbours */
5056 count=2; /* size of the area to average - default nearest 4 */
5058 if (interpolate == Average9InterpolatePixel)
5061 x_offset=(ssize_t) (floor(x+0.5)-1);
5062 y_offset=(ssize_t) (floor(y+0.5)-1);
5064 else if (interpolate == Average16InterpolatePixel)
5070 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,count,count,
5072 if (p == (const Quantum *) NULL)
5082 count*=count; /* number of pixels - square of size */
5083 for (i=0; i < (ssize_t) count; i++)
5085 AlphaBlendPixelInfo(image,p,pixels,alpha);
5086 gamma=MagickEpsilonReciprocal(alpha[0]);
5087 pixel->red += gamma*pixels[0].red;
5088 pixel->green += gamma*pixels[0].green;
5089 pixel->blue += gamma*pixels[0].blue;
5090 pixel->black += gamma*pixels[0].black;
5091 pixel->alpha += pixels[0].alpha;
5092 p += GetPixelChannels(image);
5094 gamma=1.0/count; /* average weighting of each pixel in area */
5095 pixel->red *= gamma;
5096 pixel->green *= gamma;
5097 pixel->blue *= gamma;
5098 pixel->black *= gamma;
5099 pixel->alpha *= gamma;
5102 case BackgroundInterpolatePixel:
5104 *pixel = image->background_color; /* Copy PixelInfo Structure */
5107 case BilinearInterpolatePixel:
5114 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
5115 if (p == (const Quantum *) NULL)
5120 for (i=0; i < 4L; i++)
5121 AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
5124 epsilon.x=1.0-delta.x;
5125 epsilon.y=1.0-delta.y;
5126 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
5127 (epsilon.x*alpha[2]+delta.x*alpha[3])));
5128 gamma=MagickEpsilonReciprocal(gamma);
5129 pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
5130 pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
5131 pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
5132 pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
5134 pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
5135 pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
5137 if (image->colorspace == CMYKColorspace)
5138 pixel->black=gamma*(epsilon.y*(epsilon.x*pixels[0].black+delta.x*
5139 pixels[1].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
5141 gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
5142 gamma=MagickEpsilonReciprocal(gamma);
5143 pixel->alpha=(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
5144 pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
5148 case BlendInterpolatePixel:
5150 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
5151 if (p == (const Quantum *) NULL)
5156 for (i=0; i < 4L; i++)
5157 AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
5158 gamma=1.0; /* number of pixels blended together */
5159 for (i=0; i <= 1L; i++) {
5160 if ( y-y_offset >= 0.75 ) {
5161 alpha[i] = alpha[i+2];
5162 pixels[i] = pixels[i+2];
5164 else if ( y-y_offset > 0.25 ) {
5165 gamma = 2.0; /* each y pixels have been blended */
5166 alpha[i] += alpha[i+2]; /* add up alpha weights */
5167 pixels[i].red += pixels[i+2].red;
5168 pixels[i].green += pixels[i+2].green;
5169 pixels[i].blue += pixels[i+2].blue;
5170 pixels[i].black += pixels[i+2].black;
5171 pixels[i].alpha += pixels[i+2].alpha;
5174 if ( x-x_offset >= 0.75 ) {
5175 alpha[0] = alpha[1];
5176 pixels[0] = pixels[1];
5178 else if ( x-x_offset > 0.25 ) {
5179 gamma *= 2.0; /* double number of pixels blended */
5180 alpha[0] += alpha[1]; /* add up alpha weights */
5181 pixels[0].red += pixels[1].red;
5182 pixels[0].green += pixels[1].green;
5183 pixels[0].blue += pixels[1].blue;
5184 pixels[0].black += pixels[1].black;
5185 pixels[0].alpha += pixels[1].alpha;
5188 alpha[0]=MagickEpsilonReciprocal(alpha[0]);
5189 pixel->red = alpha[0]*pixels[0].red;
5190 pixel->green = alpha[0]*pixels[0].green; /* divide by sum of alpha */
5191 pixel->blue = alpha[0]*pixels[0].blue;
5192 pixel->black = alpha[0]*pixels[0].black;
5193 pixel->alpha = gamma*pixels[0].alpha; /* divide by number of pixels */
5196 case CatromInterpolatePixel:
5202 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
5204 if (p == (const Quantum *) NULL)
5209 for (i=0; i < 16L; i++)
5210 AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
5211 CatromWeights((MagickRealType) (x-x_offset),&cx);
5212 CatromWeights((MagickRealType) (y-y_offset),&cy);
5213 pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*
5214 pixels[1].red+cx[2]*pixels[2].red+cx[3]*
5215 pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
5216 pixels[5].red+cx[2]*pixels[6].red+cx[3]*
5217 pixels[7].red)+cy[2]*(cx[0]*pixels[8].red+cx[1]*
5218 pixels[9].red+cx[2]*pixels[10].red+cx[3]*
5219 pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*
5220 pixels[13].red+cx[2]*pixels[14].red+cx[3]*pixels[15].red));
5221 pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*
5222 pixels[1].green+cx[2]*pixels[2].green+cx[3]*
5223 pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+cx[1]*
5224 pixels[5].green+cx[2]*pixels[6].green+cx[3]*
5225 pixels[7].green)+cy[2]*(cx[0]*pixels[8].green+cx[1]*
5226 pixels[9].green+cx[2]*pixels[10].green+cx[3]*
5227 pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+cx[1]*
5228 pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
5229 pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*
5230 pixels[1].blue+cx[2]*pixels[2].blue+cx[3]*
5231 pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]*
5232 pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*
5233 pixels[7].blue)+cy[2]*(cx[0]*pixels[8].blue+cx[1]*
5234 pixels[9].blue+cx[2]*pixels[10].blue+cx[3]*
5235 pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*
5236 pixels[13].blue+cx[2]*pixels[14].blue+cx[3]*pixels[15].blue));
5237 if (image->colorspace == CMYKColorspace)
5238 pixel->black=(cy[0]*(cx[0]*pixels[0].black+cx[1]*
5239 pixels[1].black+cx[2]*pixels[2].black+cx[3]*
5240 pixels[3].black)+cy[1]*(cx[0]*pixels[4].black+cx[1]*
5241 pixels[5].black+cx[2]*pixels[6].black+cx[3]*
5242 pixels[7].black)+cy[2]*(cx[0]*pixels[8].black+cx[1]*
5243 pixels[9].black+cx[2]*pixels[10].black+cx[3]*
5244 pixels[11].black)+cy[3]*(cx[0]*pixels[12].black+cx[1]*
5245 pixels[13].black+cx[2]*pixels[14].black+cx[3]*pixels[15].black));
5246 pixel->alpha=(cy[0]*(cx[0]*pixels[0].alpha+cx[1]*
5247 pixels[1].alpha+cx[2]*pixels[2].alpha+cx[3]*
5248 pixels[3].alpha)+cy[1]*(cx[0]*pixels[4].alpha+cx[1]*
5249 pixels[5].alpha+cx[2]*pixels[6].alpha+cx[3]*
5250 pixels[7].alpha)+cy[2]*(cx[0]*pixels[8].alpha+cx[1]*
5251 pixels[9].alpha+cx[2]*pixels[10].alpha+cx[3]*
5252 pixels[11].alpha)+cy[3]*(cx[0]*pixels[12].alpha+cx[1]*
5253 pixels[13].alpha+cx[2]*pixels[14].alpha+cx[3]*pixels[15].alpha));
5257 /* deprecated useless and very slow interpolator */
5258 case FilterInterpolatePixel:
5272 geometry.x=x_offset-1;
5273 geometry.y=y_offset-1;
5274 excerpt_image=ExcerptImage(image,&geometry,exception);
5275 if (excerpt_image == (Image *) NULL)
5280 filter_image=ResizeImage(excerpt_image,1,1,image->filter,exception);
5281 excerpt_image=DestroyImage(excerpt_image);
5282 if (filter_image == (Image *) NULL)
5284 filter_view=AcquireVirtualCacheView(filter_image,exception);
5285 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
5286 if (p != (const Quantum *) NULL)
5287 GetPixelInfoPixel(image,p,pixel);
5288 filter_view=DestroyCacheView(filter_view);
5289 filter_image=DestroyImage(filter_image);
5293 case IntegerInterpolatePixel:
5295 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
5296 if (p == (const Quantum *) NULL)
5301 GetPixelInfoPixel(image,p,pixel);
5304 case MeshInterpolatePixel:
5310 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
5311 if (p == (const Quantum *) NULL)
5318 luminance.x=GetPixelLuminance(image,p)-(double)
5319 GetPixelLuminance(image,p+3*GetPixelChannels(image));
5320 luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
5321 GetPixelLuminance(image,p+2*GetPixelChannels(image));
5322 AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
5323 AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
5324 AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
5325 AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
5326 if (fabs(luminance.x) < fabs(luminance.y))
5331 if (delta.x <= delta.y)
5334 Bottom-left triangle (pixel: 2, diagonal: 0-3).
5336 delta.y=1.0-delta.y;
5337 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
5338 gamma=MagickEpsilonReciprocal(gamma);
5339 pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
5340 pixels[3].red,pixels[0].red);
5341 pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
5342 pixels[3].green,pixels[0].green);
5343 pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
5344 pixels[3].blue,pixels[0].blue);
5345 if (image->colorspace == CMYKColorspace)
5346 pixel->black=gamma*MeshInterpolate(&delta,pixels[2].black,
5347 pixels[3].black,pixels[0].black);
5348 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
5349 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[2].alpha,
5350 pixels[3].alpha,pixels[0].alpha);
5355 Top-right triangle (pixel:1 , diagonal: 0-3).
5357 delta.x=1.0-delta.x;
5358 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
5359 gamma=MagickEpsilonReciprocal(gamma);
5360 pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
5361 pixels[0].red,pixels[3].red);
5362 pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
5363 pixels[0].green,pixels[3].green);
5364 pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
5365 pixels[0].blue,pixels[3].blue);
5366 if (image->colorspace == CMYKColorspace)
5367 pixel->black=gamma*MeshInterpolate(&delta,pixels[1].black,
5368 pixels[0].black,pixels[3].black);
5369 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
5370 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[1].alpha,
5371 pixels[0].alpha,pixels[3].alpha);
5379 if (delta.x <= (1.0-delta.y))
5382 Top-left triangle (pixel: 0, diagonal: 1-2).
5384 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
5385 gamma=MagickEpsilonReciprocal(gamma);
5386 pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
5387 pixels[1].red,pixels[2].red);
5388 pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
5389 pixels[1].green,pixels[2].green);
5390 pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
5391 pixels[1].blue,pixels[2].blue);
5392 if (image->colorspace == CMYKColorspace)
5393 pixel->black=gamma*MeshInterpolate(&delta,pixels[0].black,
5394 pixels[1].black,pixels[2].black);
5395 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
5396 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[0].alpha,
5397 pixels[1].alpha,pixels[2].alpha);
5402 Bottom-right triangle (pixel: 3, diagonal: 1-2).
5404 delta.x=1.0-delta.x;
5405 delta.y=1.0-delta.y;
5406 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
5407 gamma=MagickEpsilonReciprocal(gamma);
5408 pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
5409 pixels[2].red,pixels[1].red);
5410 pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
5411 pixels[2].green,pixels[1].green);
5412 pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
5413 pixels[2].blue,pixels[1].blue);
5414 if (image->colorspace == CMYKColorspace)
5415 pixel->black=gamma*MeshInterpolate(&delta,pixels[3].black,
5416 pixels[2].black,pixels[1].black);
5417 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
5418 pixel->alpha=gamma*MeshInterpolate(&delta,pixels[3].alpha,
5419 pixels[2].alpha,pixels[1].alpha);
5424 case NearestInterpolatePixel:
5426 x_offset=(ssize_t) floor(x+0.5);
5427 y_offset=(ssize_t) floor(y+0.5);
5428 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
5429 if (p == (const Quantum *) NULL)
5434 GetPixelInfoPixel(image,p,pixel);
5437 case SplineInterpolatePixel:
5443 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
5445 if (p == (const Quantum *) NULL)
5450 for (i=0; i < 16L; i++)
5451 AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
5452 SplineWeights((MagickRealType) (x-x_offset),&cx);
5453 SplineWeights((MagickRealType) (y-y_offset),&cy);
5454 pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*
5455 pixels[1].red+cx[2]*pixels[2].red+cx[3]*
5456 pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
5457 pixels[5].red+cx[2]*pixels[6].red+cx[3]*
5458 pixels[7].red)+cy[2]*(cx[0]*pixels[8].red+cx[1]*
5459 pixels[9].red+cx[2]*pixels[10].red+cx[3]*
5460 pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*
5461 pixels[13].red+cx[2]*pixels[14].red+cx[3]*pixels[15].red));
5462 pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*
5463 pixels[1].green+cx[2]*pixels[2].green+cx[3]*
5464 pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+cx[1]*
5465 pixels[5].green+cx[2]*pixels[6].green+cx[3]*
5466 pixels[7].green)+cy[2]*(cx[0]*pixels[8].green+cx[1]*
5467 pixels[9].green+cx[2]*pixels[10].green+cx[3]*
5468 pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+cx[1]*
5469 pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
5470 pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*
5471 pixels[1].blue+cx[2]*pixels[2].blue+cx[3]*
5472 pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]*
5473 pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*
5474 pixels[7].blue)+cy[2]*(cx[0]*pixels[8].blue+cx[1]*
5475 pixels[9].blue+cx[2]*pixels[10].blue+cx[3]*
5476 pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*
5477 pixels[13].blue+cx[2]*pixels[14].blue+cx[3]*pixels[15].blue));
5478 if (image->colorspace == CMYKColorspace)
5479 pixel->black=(cy[0]*(cx[0]*pixels[0].black+cx[1]*
5480 pixels[1].black+cx[2]*pixels[2].black+cx[3]*
5481 pixels[3].black)+cy[1]*(cx[0]*pixels[4].black+cx[1]*
5482 pixels[5].black+cx[2]*pixels[6].black+cx[3]*
5483 pixels[7].black)+cy[2]*(cx[0]*pixels[8].black+cx[1]*
5484 pixels[9].black+cx[2]*pixels[10].black+cx[3]*
5485 pixels[11].black)+cy[3]*(cx[0]*pixels[12].black+cx[1]*
5486 pixels[13].black+cx[2]*pixels[14].black+cx[3]*pixels[15].black));
5487 pixel->alpha=(cy[0]*(cx[0]*pixels[0].alpha+cx[1]*
5488 pixels[1].alpha+cx[2]*pixels[2].alpha+cx[3]*
5489 pixels[3].alpha)+cy[1]*(cx[0]*pixels[4].alpha+cx[1]*
5490 pixels[5].alpha+cx[2]*pixels[6].alpha+cx[3]*
5491 pixels[7].alpha)+cy[2]*(cx[0]*pixels[8].alpha+cx[1]*
5492 pixels[9].alpha+cx[2]*pixels[10].alpha+cx[3]*
5493 pixels[11].alpha)+cy[3]*(cx[0]*pixels[12].alpha+cx[1]*
5494 pixels[13].alpha+cx[2]*pixels[14].alpha+cx[3]*pixels[15].alpha));
5502 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5506 + I s F u z z y E q u i v a l e n c e P i x e l %
5510 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5512 % IsFuzzyEquivalencePixel() returns MagickTrue if the distance between two
5513 % pixels is less than the specified distance in a linear three (or four)u
5514 % dimensional color space.
5516 % The format of the IsFuzzyEquivalencePixel method is:
5518 % void IsFuzzyEquivalencePixel(const Image *source,const Quantum *p,
5519 % const Image *destination,const Quantum *q)
5521 % A description of each parameter follows:
5523 % o source: the source image.
5527 % o destination: the destination image.
5532 MagickExport MagickBooleanType IsFuzzyEquivalencePixel(const Image *source,
5533 const Quantum *p,const Image *destination,const Quantum *q)
5539 register MagickRealType
5543 fuzz=MagickMax(source->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(
5544 destination->fuzz,(MagickRealType) MagickSQ1_2);
5547 if (source->matte != MagickFalse)
5550 Transparencies are involved - set alpha distance
5552 pixel=GetPixelAlpha(source,p)-(MagickRealType)
5553 GetPixelAlpha(destination,q);
5554 distance=pixel*pixel;
5555 if (distance > fuzz)
5556 return(MagickFalse);
5558 Generate a alpha scaling factor to generate a 4D cone on colorspace
5559 Note that if one color is transparent, distance has no color component.
5561 scale=QuantumScale*GetPixelAlpha(source,p);
5562 scale*=QuantumScale*GetPixelAlpha(destination,q);
5563 if (scale <= MagickEpsilon)
5567 RGB or CMY color cube
5569 distance*=3.0; /* rescale appropriately */
5571 pixel=GetPixelRed(source,p)-(MagickRealType) GetPixelRed(destination,q);
5572 if ((source->colorspace == HSLColorspace) ||
5573 (source->colorspace == HSBColorspace) ||
5574 (source->colorspace == HWBColorspace))
5577 Compute an arc distance for hue. It should be a vector angle of
5578 'S'/'W' length with 'L'/'B' forming appropriate cones.
5580 if (fabs((double) pixel) > (QuantumRange/2))
5581 pixel-=QuantumRange;
5584 distance+=scale*pixel*pixel;
5585 if (distance > fuzz)
5586 return(MagickFalse);
5587 pixel=GetPixelGreen(source,p)-(MagickRealType) GetPixelGreen(destination,q);
5588 distance+=scale*pixel*pixel;
5589 if (distance > fuzz)
5590 return(MagickFalse);
5591 pixel=GetPixelBlue(source,p)-(MagickRealType) GetPixelBlue(destination,q);
5592 distance+=scale*pixel*pixel;
5593 if (distance > fuzz)
5594 return(MagickFalse);
5599 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5603 + 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 %
5607 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5609 % IsFuzzyEquivalencePixelInfo() returns true if the distance between two
5610 % colors is less than the specified distance in a linear three (or four)
5611 % dimensional color space.
5613 % This implements the equivalent of:
5614 % fuzz < sqrt(color_distance^2 * u.a*v.a + alpha_distance^2)
5616 % Which produces a multi-dimensional cone for that colorspace along the
5617 % transparency vector.
5619 % For example for an RGB:
5620 % color_distance^2 = ( (u.r-v.r)^2 + (u.g-v.g)^2 + (u.b-v.b)^2 ) / 3
5622 % See http://www.imagemagick.org/Usage/bugs/fuzz_distance/
5624 % Hue colorspace distances need more work. Hue is not a distance, it is an
5627 % A check that q is in the same color space as p should be made and the
5628 % appropriate mapping made. -- Anthony Thyssen 8 December 2010
5630 % The format of the IsFuzzyEquivalencePixelInfo method is:
5632 % MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
5633 % const PixelInfo *q)
5635 % A description of each parameter follows:
5642 MagickExport MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
5649 register MagickRealType
5653 if ((p->fuzz == 0.0) && (q->fuzz == 0.0))
5654 return(IsPixelInfoEquivalent(p,q));
5656 fuzz=MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(q->fuzz,
5657 (MagickRealType) MagickSQ1_2);
5658 else if (q->fuzz == 0.0)
5659 fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(p->fuzz,
5660 (MagickRealType) MagickSQ1_2);
5662 fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(q->fuzz,
5663 (MagickRealType) MagickSQ1_2);
5666 if ((p->matte != MagickFalse) || (q->matte != MagickFalse))
5669 Transparencies are involved - set alpha distance.
5671 pixel=(p->matte != MagickFalse ? p->alpha : OpaqueAlpha)-
5672 (q->matte != MagickFalse ? q->alpha : OpaqueAlpha);
5673 distance=pixel*pixel;
5674 if (distance > fuzz)
5675 return(MagickFalse);
5677 Generate a alpha scaling factor to generate a 4D cone on colorspace.
5678 If one color is transparent, distance has no color component.
5680 if (p->matte != MagickFalse)
5681 scale=(QuantumScale*p->alpha);
5682 if (q->matte != MagickFalse)
5683 scale*=(QuantumScale*q->alpha);
5684 if (scale <= MagickEpsilon )
5688 CMYK create a CMY cube with a multi-dimensional cone toward black.
5690 if (p->colorspace == CMYKColorspace)
5692 pixel=p->black-q->black;
5693 distance+=pixel*pixel*scale;
5694 if (distance > fuzz)
5695 return(MagickFalse);
5696 scale*=(MagickRealType) (QuantumScale*(QuantumRange-p->black));
5697 scale*=(MagickRealType) (QuantumScale*(QuantumRange-q->black));
5700 RGB or CMY color cube.
5702 distance*=3.0; /* rescale appropriately */
5704 pixel=p->red-q->red;
5705 if ((p->colorspace == HSLColorspace) || (p->colorspace == HSBColorspace) ||
5706 (p->colorspace == HWBColorspace))
5709 This calculates a arc distance for hue-- it should be a vector angle
5710 of 'S'/'W' length with 'L'/'B' forming appropriate cones. In other
5711 words this is a hack - Anthony.
5713 if (fabs((double) pixel) > (QuantumRange/2))
5714 pixel-=QuantumRange;
5717 distance+=pixel*pixel*scale;
5718 if (distance > fuzz)
5719 return(MagickFalse);
5720 pixel=p->green-q->green;
5721 distance+=pixel*pixel*scale;
5722 if (distance > fuzz)
5723 return(MagickFalse);
5724 pixel=p->blue-q->blue;
5725 distance+=pixel*pixel*scale;
5726 if (distance > fuzz)
5727 return(MagickFalse);
5732 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5736 % S e t P i x e l C h a n n e l M a p M a s k %
5740 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5742 % SetPixelChannelMapMask() sets the pixel channel map from the specified
5745 % The format of the SetPixelChannelMapMask method is:
5747 % void SetPixelChannelMapMask(Image *image,const ChannelType channel_mask)
5749 % A description of each parameter follows:
5751 % o image: the image.
5753 % o channel_mask: the channel mask.
5756 MagickExport void SetPixelChannelMapMask(Image *image,
5757 const ChannelType channel_mask)
5759 #define GetChannelBit(mask,bit) (((size_t) (mask) >> (size_t) (bit)) & 0x01)
5764 if (image->debug != MagickFalse)
5765 (void) LogMagickEvent(PixelEvent,GetMagickModule(),"%s[%08x]", \
5766 image->filename,channel_mask); \
5767 image->channel_mask=channel_mask;
5768 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
5773 channel=GetPixelChannelMapChannel(image,i);
5774 SetPixelChannelMapTraits(image,channel,
5775 GetChannelBit(channel_mask,channel) == 0 ? CopyPixelTrait :
5776 image->matte == MagickFalse || (channel == AlphaPixelChannel) ?
5777 UpdatePixelTrait : (PixelTrait) (UpdatePixelTrait | BlendPixelTrait));
5779 if (image->storage_class == PseudoClass)
5780 SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
5781 if (image->mask != MagickFalse)
5782 SetPixelChannelMapTraits(image,MaskPixelChannel,CopyPixelTrait);
5783 if (image->debug != MagickFalse)
5784 LogPixelChannels(image);
5788 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5792 % S e t P i x e l C h a n n e l M a s k %
5796 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5798 % SetPixelChannelMask() sets the pixel channel mask from the specified channel
5801 % The format of the SetPixelChannelMask method is:
5803 % ChannelType SetPixelChannelMask(Image *image,
5804 % const ChannelType channel_mask)
5806 % A description of each parameter follows:
5808 % o image: the image.
5810 % o channel_mask: the channel mask.
5813 MagickExport ChannelType SetPixelChannelMask(Image *image,
5814 const ChannelType channel_mask)
5819 mask=image->channel_mask;
5820 image->channel_mask=channel_mask;
5821 SetPixelChannelMapMask(image,channel_mask);
5826 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5830 % S e t P i x e l M e t a C h a n n e l s %
5834 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5836 % SetPixelMetaChannels() sets the image meta channels.
5838 % The format of the SetPixelMetaChannels method is:
5840 % MagickBooleanType SetPixelMetaChannels(Image *image,
5841 % const size_t number_meta_channels,ExceptionInfo *exception)
5843 % A description of each parameter follows:
5845 % o image: the image.
5847 % o number_meta_channels: the number of meta channels.
5849 % o exception: return any errors or warnings in this structure.
5852 MagickExport MagickBooleanType SetPixelMetaChannels(Image *image,
5853 const size_t number_meta_channels,ExceptionInfo *exception)
5855 image->number_meta_channels=number_meta_channels;
5856 return(SyncImagePixelCache(image,exception));