41 #include "magick/studio.h"
42 #include "magick/property.h"
43 #include "magick/blob.h"
44 #include "magick/blob-private.h"
45 #include "magick/color-private.h"
46 #include "magick/draw.h"
47 #include "magick/exception.h"
48 #include "magick/exception-private.h"
49 #include "magick/cache.h"
50 #include "magick/colorspace-private.h"
51 #include "magick/constitute.h"
52 #include "magick/delegate.h"
53 #include "magick/geometry.h"
54 #include "magick/list.h"
55 #include "magick/magick.h"
56 #include "magick/memory_.h"
57 #include "magick/memory-private.h"
58 #include "magick/monitor.h"
59 #include "magick/option.h"
60 #include "magick/pixel.h"
61 #include "magick/pixel-private.h"
62 #include "magick/quantum.h"
63 #include "magick/resource_.h"
64 #include "magick/semaphore.h"
65 #include "magick/statistic.h"
66 #include "magick/stream.h"
67 #include "magick/string_.h"
68 #include "magick/transform.h"
69 #include "magick/utility.h"
100 sizeof(*clone_pixel)));
102 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
103 *clone_pixel=(*pixel);
138 MagickExport
void ConformMagickPixelPacket(
Image *image,
142 assert(image != (
Image *) NULL);
143 assert(image->signature == MagickCoreSignature);
146 *destination=(*source);
147 if (image->colorspace == CMYKColorspace)
149 if (IssRGBCompatibleColorspace(destination->colorspace) != MagickFalse)
150 ConvertRGBToCMYK(destination);
153 if (destination->colorspace == CMYKColorspace)
155 if (IssRGBCompatibleColorspace(image->colorspace) != MagickFalse)
156 ConvertCMYKToRGB(destination);
158 if ((IsGrayColorspace(image->colorspace) != MagickFalse) &&
159 (IsMagickGray(destination) == MagickFalse))
160 (void) TransformImageColorspace(image,sRGBColorspace);
161 if ((destination->matte != MagickFalse) && (image->matte == MagickFalse))
162 (void) SetImageOpacity(image,OpaqueOpacity);
188 static inline double DecodeGamma(
const double x)
200 static const double coefficient[] =
202 1.7917488588043277509,
203 0.82045614371976854984,
204 0.027694100686325412819,
205 -0.00094244335181762134018,
206 0.000064355540911469709545,
207 -5.7224404636060757485e-06,
208 5.8767669437311184313e-07,
209 -6.6139920053589721168e-08,
210 7.9323242696227458163e-09
213 static const double powers_of_two[] =
216 2.6390158215457883983,
217 6.9644045063689921093,
218 1.8379173679952558018e+01,
219 4.8502930128332728543e+01
226 term[1]=4.0*frexp(x,&exponent)-3.0;
227 term[2]=2.0*term[1]*term[1]-term[0];
228 term[3]=2.0*term[1]*term[2]-term[1];
229 term[4]=2.0*term[1]*term[3]-term[2];
230 term[5]=2.0*term[1]*term[4]-term[3];
231 term[6]=2.0*term[1]*term[5]-term[4];
232 term[7]=2.0*term[1]*term[6]-term[5];
233 term[8]=2.0*term[1]*term[7]-term[6];
234 p=coefficient[0]*term[0]+coefficient[1]*term[1]+coefficient[2]*term[2]+
235 coefficient[3]*term[3]+coefficient[4]*term[4]+coefficient[5]*term[5]+
236 coefficient[6]*term[6]+coefficient[7]*term[7]+coefficient[8]*term[8];
237 quotient=div(exponent-1,5);
238 if (quotient.rem < 0)
243 return(x*ldexp(powers_of_two[quotient.rem]*p,7*quotient.quot));
246 MagickExport MagickRealType DecodePixelGamma(
const MagickRealType pixel)
248 if (pixel <= (0.0404482362771076*QuantumRange))
249 return(pixel/12.92f);
250 return((MagickRealType) (QuantumRange*DecodeGamma((
double) (QuantumScale*
251 pixel+0.055)/1.055)));
277 static inline double EncodeGamma(
const double x)
289 static const double coefficient[] =
291 1.1758200232996901923,
292 0.16665763094889061230,
293 -0.0083154894939042125035,
294 0.00075187976780420279038,
295 -0.000083240178519391795367,
296 0.000010229209410070008679,
297 -1.3400466409860246e-06,
298 1.8333422241635376682e-07,
299 -2.5878596761348859722e-08
302 static const double powers_of_two[] =
305 1.3348398541700343678,
306 1.7817974362806785482,
307 2.3784142300054420538,
308 3.1748021039363991669,
309 4.2378523774371812394,
310 5.6568542494923805819,
311 7.5509945014535482244,
312 1.0079368399158985525e1,
313 1.3454342644059433809e1,
314 1.7959392772949968275e1,
315 2.3972913230026907883e1
322 term[1]=4.0*frexp(x,&exponent)-3.0;
323 term[2]=2.0*term[1]*term[1]-term[0];
324 term[3]=2.0*term[1]*term[2]-term[1];
325 term[4]=2.0*term[1]*term[3]-term[2];
326 term[5]=2.0*term[1]*term[4]-term[3];
327 term[6]=2.0*term[1]*term[5]-term[4];
328 term[7]=2.0*term[1]*term[6]-term[5];
329 term[8]=2.0*term[1]*term[7]-term[6];
330 p=coefficient[0]*term[0]+coefficient[1]*term[1]+coefficient[2]*term[2]+
331 coefficient[3]*term[3]+coefficient[4]*term[4]+coefficient[5]*term[5]+
332 coefficient[6]*term[6]+coefficient[7]*term[7]+coefficient[8]*term[8];
333 quotient=div(exponent-1,12);
334 if (quotient.rem < 0)
339 return(ldexp(powers_of_two[quotient.rem]*p,5*quotient.quot));
342 MagickExport MagickRealType EncodePixelGamma(
const MagickRealType pixel)
344 if (pixel <= (0.0031306684425005883*QuantumRange))
345 return(12.92f*pixel);
346 return((MagickRealType) QuantumRange*(1.055*EncodeGamma((
double) QuantumScale*
406 const char *magick_restrict map,
const QuantumType *quantum_map,
void *pixels,
410 *magick_restrict indexes;
427 q=(
unsigned char *) pixels;
428 if (LocaleCompare(map,
"BGR") == 0)
430 for (y=0; y < (ssize_t) roi->height; y++)
432 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
435 for (x=0; x < (ssize_t) roi->width; x++)
437 *q++=ScaleQuantumToChar(GetPixelBlue(p));
438 *q++=ScaleQuantumToChar(GetPixelGreen(p));
439 *q++=ScaleQuantumToChar(GetPixelRed(p));
443 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
445 if (LocaleCompare(map,
"BGRA") == 0)
447 for (y=0; y < (ssize_t) roi->height; y++)
449 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
452 for (x=0; x < (ssize_t) roi->width; x++)
454 *q++=ScaleQuantumToChar(GetPixelBlue(p));
455 *q++=ScaleQuantumToChar(GetPixelGreen(p));
456 *q++=ScaleQuantumToChar(GetPixelRed(p));
457 *q++=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
461 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
463 if (LocaleCompare(map,
"BGRP") == 0)
465 for (y=0; y < (ssize_t) roi->height; y++)
467 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
470 for (x=0; x < (ssize_t) roi->width; x++)
472 *q++=ScaleQuantumToChar(GetPixelBlue(p));
473 *q++=ScaleQuantumToChar(GetPixelGreen(p));
474 *q++=ScaleQuantumToChar(GetPixelRed(p));
475 *q++=ScaleQuantumToChar((Quantum) 0);
479 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
481 if (LocaleCompare(map,
"I") == 0)
483 for (y=0; y < (ssize_t) roi->height; y++)
485 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
488 for (x=0; x < (ssize_t) roi->width; x++)
490 *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
494 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
496 if (LocaleCompare(map,
"RGB") == 0)
498 for (y=0; y < (ssize_t) roi->height; y++)
500 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
503 for (x=0; x < (ssize_t) roi->width; x++)
505 *q++=ScaleQuantumToChar(GetPixelRed(p));
506 *q++=ScaleQuantumToChar(GetPixelGreen(p));
507 *q++=ScaleQuantumToChar(GetPixelBlue(p));
511 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
513 if (LocaleCompare(map,
"RGBA") == 0)
515 for (y=0; y < (ssize_t) roi->height; y++)
517 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
520 for (x=0; x < (ssize_t) roi->width; x++)
522 *q++=ScaleQuantumToChar(GetPixelRed(p));
523 *q++=ScaleQuantumToChar(GetPixelGreen(p));
524 *q++=ScaleQuantumToChar(GetPixelBlue(p));
525 *q++=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
529 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
531 if (LocaleCompare(map,
"RGBP") == 0)
533 for (y=0; y < (ssize_t) roi->height; y++)
535 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
538 for (x=0; x < (ssize_t) roi->width; x++)
540 *q++=ScaleQuantumToChar(GetPixelRed(p));
541 *q++=ScaleQuantumToChar(GetPixelGreen(p));
542 *q++=ScaleQuantumToChar(GetPixelBlue(p));
543 *q++=ScaleQuantumToChar((Quantum) 0);
547 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
550 for (y=0; y < (ssize_t) roi->height; y++)
552 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
555 indexes=GetVirtualIndexQueue(image);
556 for (x=0; x < (ssize_t) roi->width; x++)
561 for (i=0; i < (ssize_t) length; i++)
564 switch (quantum_map[i])
569 *q=ScaleQuantumToChar(GetPixelRed(p));
575 *q=ScaleQuantumToChar(GetPixelGreen(p));
581 *q=ScaleQuantumToChar(GetPixelBlue(p));
586 *q=ScaleQuantumToChar((Quantum) GetPixelAlpha(p));
591 *q=ScaleQuantumToChar(GetPixelOpacity(p));
596 if (image->colorspace == CMYKColorspace)
597 *q=ScaleQuantumToChar(GetPixelIndex(indexes+x));
602 *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
613 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
616 static MagickBooleanType ExportDoublePixel(
Image *image,
618 const QuantumType *quantum_map,
void *pixels,
ExceptionInfo *exception)
621 *magick_restrict indexes;
639 if (LocaleCompare(map,
"BGR") == 0)
641 for (y=0; y < (ssize_t) roi->height; y++)
643 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
646 for (x=0; x < (ssize_t) roi->width; x++)
648 *q++=(double) (QuantumScale*GetPixelBlue(p));
649 *q++=(double) (QuantumScale*GetPixelGreen(p));
650 *q++=(double) (QuantumScale*GetPixelRed(p));
654 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
656 if (LocaleCompare(map,
"BGRA") == 0)
658 for (y=0; y < (ssize_t) roi->height; y++)
660 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
663 for (x=0; x < (ssize_t) roi->width; x++)
665 *q++=(double) (QuantumScale*GetPixelBlue(p));
666 *q++=(double) (QuantumScale*GetPixelGreen(p));
667 *q++=(double) (QuantumScale*GetPixelRed(p));
668 *q++=(double) (QuantumScale*((Quantum) (QuantumRange-
669 GetPixelOpacity(p))));
673 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
675 if (LocaleCompare(map,
"BGRP") == 0)
677 for (y=0; y < (ssize_t) roi->height; y++)
679 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
682 for (x=0; x < (ssize_t) roi->width; x++)
684 *q++=(double) (QuantumScale*GetPixelBlue(p));
685 *q++=(double) (QuantumScale*GetPixelGreen(p));
686 *q++=(double) (QuantumScale*GetPixelRed(p));
691 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
693 if (LocaleCompare(map,
"I") == 0)
695 for (y=0; y < (ssize_t) roi->height; y++)
697 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
700 for (x=0; x < (ssize_t) roi->width; x++)
702 *q++=(double) (QuantumScale*GetPixelIntensity(image,p));
706 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
708 if (LocaleCompare(map,
"RGB") == 0)
710 for (y=0; y < (ssize_t) roi->height; y++)
712 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
715 for (x=0; x < (ssize_t) roi->width; x++)
717 *q++=(double) (QuantumScale*GetPixelRed(p));
718 *q++=(double) (QuantumScale*GetPixelGreen(p));
719 *q++=(double) (QuantumScale*GetPixelBlue(p));
723 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
725 if (LocaleCompare(map,
"RGBA") == 0)
727 for (y=0; y < (ssize_t) roi->height; y++)
729 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
732 for (x=0; x < (ssize_t) roi->width; x++)
734 *q++=(double) (QuantumScale*GetPixelRed(p));
735 *q++=(double) (QuantumScale*GetPixelGreen(p));
736 *q++=(double) (QuantumScale*GetPixelBlue(p));
737 *q++=(double) (QuantumScale*((Quantum) (QuantumRange-
738 GetPixelOpacity(p))));
742 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
744 if (LocaleCompare(map,
"RGBP") == 0)
746 for (y=0; y < (ssize_t) roi->height; y++)
748 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
751 for (x=0; x < (ssize_t) roi->width; x++)
753 *q++=(double) (QuantumScale*GetPixelRed(p));
754 *q++=(double) (QuantumScale*GetPixelGreen(p));
755 *q++=(double) (QuantumScale*GetPixelBlue(p));
760 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
763 for (y=0; y < (ssize_t) roi->height; y++)
765 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
768 indexes=GetVirtualIndexQueue(image);
769 for (x=0; x < (ssize_t) roi->width; x++)
774 for (i=0; i < (ssize_t) length; i++)
777 switch (quantum_map[i])
782 *q=(double) (QuantumScale*GetPixelRed(p));
788 *q=(double) (QuantumScale*GetPixelGreen(p));
794 *q=(double) (QuantumScale*GetPixelBlue(p));
799 *q=(double) (QuantumScale*((Quantum) (QuantumRange-
800 GetPixelOpacity(p))));
805 *q=(double) (QuantumScale*GetPixelOpacity(p));
810 if (image->colorspace == CMYKColorspace)
811 *q=(double) (QuantumScale*GetPixelIndex(indexes+x));
816 *q=(double) (QuantumScale*GetPixelIntensity(image,p));
827 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
831 const char *magick_restrict map,
const QuantumType *quantum_map,
void *pixels,
835 *magick_restrict indexes;
853 if (LocaleCompare(map,
"BGR") == 0)
855 for (y=0; y < (ssize_t) roi->height; y++)
857 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
860 for (x=0; x < (ssize_t) roi->width; x++)
862 *q++=(float) (QuantumScale*GetPixelBlue(p));
863 *q++=(float) (QuantumScale*GetPixelGreen(p));
864 *q++=(float) (QuantumScale*GetPixelRed(p));
868 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
870 if (LocaleCompare(map,
"BGRA") == 0)
872 for (y=0; y < (ssize_t) roi->height; y++)
874 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
877 for (x=0; x < (ssize_t) roi->width; x++)
879 *q++=(float) (QuantumScale*GetPixelBlue(p));
880 *q++=(float) (QuantumScale*GetPixelGreen(p));
881 *q++=(float) (QuantumScale*GetPixelRed(p));
882 *q++=(float) (QuantumScale*GetPixelAlpha(p));
886 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
888 if (LocaleCompare(map,
"BGRP") == 0)
890 for (y=0; y < (ssize_t) roi->height; y++)
892 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
895 for (x=0; x < (ssize_t) roi->width; x++)
897 *q++=(float) (QuantumScale*GetPixelBlue(p));
898 *q++=(float) (QuantumScale*GetPixelGreen(p));
899 *q++=(float) (QuantumScale*GetPixelRed(p));
904 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
906 if (LocaleCompare(map,
"I") == 0)
908 for (y=0; y < (ssize_t) roi->height; y++)
910 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
913 for (x=0; x < (ssize_t) roi->width; x++)
915 *q++=(float) (QuantumScale*GetPixelIntensity(image,p));
919 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
921 if (LocaleCompare(map,
"RGB") == 0)
923 for (y=0; y < (ssize_t) roi->height; y++)
925 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
928 for (x=0; x < (ssize_t) roi->width; x++)
930 *q++=(float) (QuantumScale*GetPixelRed(p));
931 *q++=(float) (QuantumScale*GetPixelGreen(p));
932 *q++=(float) (QuantumScale*GetPixelBlue(p));
936 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
938 if (LocaleCompare(map,
"RGBA") == 0)
940 for (y=0; y < (ssize_t) roi->height; y++)
942 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
945 for (x=0; x < (ssize_t) roi->width; x++)
947 *q++=(float) (QuantumScale*GetPixelRed(p));
948 *q++=(float) (QuantumScale*GetPixelGreen(p));
949 *q++=(float) (QuantumScale*GetPixelBlue(p));
950 *q++=(float) (QuantumScale*GetPixelAlpha(p));
954 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
956 if (LocaleCompare(map,
"RGBP") == 0)
958 for (y=0; y < (ssize_t) roi->height; y++)
960 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
963 for (x=0; x < (ssize_t) roi->width; x++)
965 *q++=(float) (QuantumScale*GetPixelRed(p));
966 *q++=(float) (QuantumScale*GetPixelGreen(p));
967 *q++=(float) (QuantumScale*GetPixelBlue(p));
972 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
975 for (y=0; y < (ssize_t) roi->height; y++)
977 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
980 indexes=GetVirtualIndexQueue(image);
981 for (x=0; x < (ssize_t) roi->width; x++)
986 for (i=0; i < (ssize_t) length; i++)
989 switch (quantum_map[i])
994 *q=(float) (QuantumScale*GetPixelRed(p));
1000 *q=(float) (QuantumScale*GetPixelGreen(p));
1006 *q=(float) (QuantumScale*GetPixelBlue(p));
1011 *q=(float) (QuantumScale*((Quantum) (GetPixelAlpha(p))));
1014 case OpacityQuantum:
1016 *q=(float) (QuantumScale*GetPixelOpacity(p));
1021 if (image->colorspace == CMYKColorspace)
1022 *q=(float) (QuantumScale*GetPixelIndex(indexes+x));
1027 *q=(float) (QuantumScale*GetPixelIntensity(image,p));
1038 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1041 static MagickBooleanType ExportIntegerPixel(
Image *image,
1043 const QuantumType *quantum_map,
void *pixels,
ExceptionInfo *exception)
1046 *magick_restrict indexes;
1063 q=(
unsigned int *) pixels;
1064 if (LocaleCompare(map,
"BGR") == 0)
1066 for (y=0; y < (ssize_t) roi->height; y++)
1068 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1071 for (x=0; x < (ssize_t) roi->width; x++)
1073 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1074 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1075 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1079 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1081 if (LocaleCompare(map,
"BGRA") == 0)
1083 for (y=0; y < (ssize_t) roi->height; y++)
1085 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1088 for (x=0; x < (ssize_t) roi->width; x++)
1090 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1091 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1092 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1093 *q++=(
unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
1094 GetPixelOpacity(p)));
1098 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1100 if (LocaleCompare(map,
"BGRP") == 0)
1102 for (y=0; y < (ssize_t) roi->height; y++)
1104 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1107 for (x=0; x < (ssize_t) roi->width; x++)
1109 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1110 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1111 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1116 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1118 if (LocaleCompare(map,
"I") == 0)
1120 for (y=0; y < (ssize_t) roi->height; y++)
1122 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1125 for (x=0; x < (ssize_t) roi->width; x++)
1127 *q++=(
unsigned int) ScaleQuantumToLong(ClampToQuantum(
1128 GetPixelIntensity(image,p)));
1132 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1134 if (LocaleCompare(map,
"RGB") == 0)
1136 for (y=0; y < (ssize_t) roi->height; y++)
1138 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1141 for (x=0; x < (ssize_t) roi->width; x++)
1143 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1144 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1145 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1149 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1151 if (LocaleCompare(map,
"RGBA") == 0)
1153 for (y=0; y < (ssize_t) roi->height; y++)
1155 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1158 for (x=0; x < (ssize_t) roi->width; x++)
1160 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1161 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1162 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1163 *q++=(
unsigned int) ScaleQuantumToLong((Quantum) GetPixelAlpha(p));
1167 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1169 if (LocaleCompare(map,
"RGBP") == 0)
1171 for (y=0; y < (ssize_t) roi->height; y++)
1173 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1176 for (x=0; x < (ssize_t) roi->width; x++)
1178 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1179 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1180 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1185 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1188 for (y=0; y < (ssize_t) roi->height; y++)
1190 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1193 indexes=GetVirtualIndexQueue(image);
1194 for (x=0; x < (ssize_t) roi->width; x++)
1199 for (i=0; i < (ssize_t) length; i++)
1202 switch (quantum_map[i])
1207 *q=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1211 case MagentaQuantum:
1213 *q=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1219 *q=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1224 *q=(
unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
1225 GetPixelOpacity(p)));
1228 case OpacityQuantum:
1230 *q=(
unsigned int) ScaleQuantumToLong(GetPixelOpacity(p));
1235 if (image->colorspace == CMYKColorspace)
1236 *q=(
unsigned int) ScaleQuantumToLong(GetPixelIndex(indexes+x));
1241 *q=(
unsigned int) ScaleQuantumToLong(ClampToQuantum(
1242 GetPixelIntensity(image,p)));
1253 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1257 const char *magick_restrict map,
const QuantumType *quantum_map,
void *pixels,
1261 *magick_restrict indexes;
1278 q=(
unsigned int *) pixels;
1279 if (LocaleCompare(map,
"BGR") == 0)
1281 for (y=0; y < (ssize_t) roi->height; y++)
1283 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1286 for (x=0; x < (ssize_t) roi->width; x++)
1288 *q++=ScaleQuantumToLong(GetPixelBlue(p));
1289 *q++=ScaleQuantumToLong(GetPixelGreen(p));
1290 *q++=ScaleQuantumToLong(GetPixelRed(p));
1294 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1296 if (LocaleCompare(map,
"BGRA") == 0)
1298 for (y=0; y < (ssize_t) roi->height; y++)
1300 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1303 for (x=0; x < (ssize_t) roi->width; x++)
1305 *q++=ScaleQuantumToLong(GetPixelBlue(p));
1306 *q++=ScaleQuantumToLong(GetPixelGreen(p));
1307 *q++=ScaleQuantumToLong(GetPixelRed(p));
1308 *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p)));
1312 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1314 if (LocaleCompare(map,
"BGRP") == 0)
1316 for (y=0; y < (ssize_t) roi->height; y++)
1318 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1321 for (x=0; x < (ssize_t) roi->width; x++)
1323 *q++=ScaleQuantumToLong(GetPixelBlue(p));
1324 *q++=ScaleQuantumToLong(GetPixelGreen(p));
1325 *q++=ScaleQuantumToLong(GetPixelRed(p));
1330 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1332 if (LocaleCompare(map,
"I") == 0)
1334 for (y=0; y < (ssize_t) roi->height; y++)
1336 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1339 for (x=0; x < (ssize_t) roi->width; x++)
1341 *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
1345 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1347 if (LocaleCompare(map,
"RGB") == 0)
1349 for (y=0; y < (ssize_t) roi->height; y++)
1351 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1354 for (x=0; x < (ssize_t) roi->width; x++)
1356 *q++=ScaleQuantumToLong(GetPixelRed(p));
1357 *q++=ScaleQuantumToLong(GetPixelGreen(p));
1358 *q++=ScaleQuantumToLong(GetPixelBlue(p));
1362 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1364 if (LocaleCompare(map,
"RGBA") == 0)
1366 for (y=0; y < (ssize_t) roi->height; y++)
1368 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1371 for (x=0; x < (ssize_t) roi->width; x++)
1373 *q++=ScaleQuantumToLong(GetPixelRed(p));
1374 *q++=ScaleQuantumToLong(GetPixelGreen(p));
1375 *q++=ScaleQuantumToLong(GetPixelBlue(p));
1376 *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p)));
1380 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1382 if (LocaleCompare(map,
"RGBP") == 0)
1384 for (y=0; y < (ssize_t) roi->height; y++)
1386 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1389 for (x=0; x < (ssize_t) roi->width; x++)
1391 *q++=ScaleQuantumToLong(GetPixelRed(p));
1392 *q++=ScaleQuantumToLong(GetPixelGreen(p));
1393 *q++=ScaleQuantumToLong(GetPixelBlue(p));
1398 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1401 for (y=0; y < (ssize_t) roi->height; y++)
1403 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1406 indexes=GetVirtualIndexQueue(image);
1407 for (x=0; x < (ssize_t) roi->width; x++)
1412 for (i=0; i < (ssize_t) length; i++)
1415 switch (quantum_map[i])
1420 *q=ScaleQuantumToLong(GetPixelRed(p));
1424 case MagentaQuantum:
1426 *q=ScaleQuantumToLong(GetPixelGreen(p));
1432 *q=ScaleQuantumToLong(GetPixelBlue(p));
1437 *q=ScaleQuantumToLong((Quantum) GetPixelAlpha(p));
1440 case OpacityQuantum:
1442 *q=ScaleQuantumToLong(GetPixelOpacity(p));
1447 if (image->colorspace == CMYKColorspace)
1448 *q=ScaleQuantumToLong(GetPixelIndex(indexes+x));
1453 *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
1464 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1467 static MagickBooleanType ExportQuantumPixel(
Image *image,
1469 const QuantumType *quantum_map,
void *pixels,
ExceptionInfo *exception)
1472 *magick_restrict indexes;
1489 q=(Quantum *) pixels;
1490 if (LocaleCompare(map,
"BGR") == 0)
1492 for (y=0; y < (ssize_t) roi->height; y++)
1494 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1497 for (x=0; x < (ssize_t) roi->width; x++)
1499 *q++=GetPixelBlue(p);
1500 *q++=GetPixelGreen(p);
1501 *q++=GetPixelRed(p);
1505 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1507 if (LocaleCompare(map,
"BGRA") == 0)
1509 for (y=0; y < (ssize_t) roi->height; y++)
1511 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1514 for (x=0; x < (ssize_t) roi->width; x++)
1516 *q++=GetPixelBlue(p);
1517 *q++=GetPixelGreen(p);
1518 *q++=GetPixelRed(p);
1519 *q++=(Quantum) GetPixelAlpha(p);
1523 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1525 if (LocaleCompare(map,
"BGRP") == 0)
1527 for (y=0; y < (ssize_t) roi->height; y++)
1529 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1532 for (x=0; x < (ssize_t) roi->width; x++)
1534 *q++=GetPixelBlue(p);
1535 *q++=GetPixelGreen(p);
1536 *q++=GetPixelRed(p);
1541 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1543 if (LocaleCompare(map,
"I") == 0)
1545 for (y=0; y < (ssize_t) roi->height; y++)
1547 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1550 for (x=0; x < (ssize_t) roi->width; x++)
1552 *q++=ClampToQuantum(GetPixelIntensity(image,p));
1556 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1558 if (LocaleCompare(map,
"RGB") == 0)
1560 for (y=0; y < (ssize_t) roi->height; y++)
1562 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1565 for (x=0; x < (ssize_t) roi->width; x++)
1567 *q++=GetPixelRed(p);
1568 *q++=GetPixelGreen(p);
1569 *q++=GetPixelBlue(p);
1573 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1575 if (LocaleCompare(map,
"RGBA") == 0)
1577 for (y=0; y < (ssize_t) roi->height; y++)
1579 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1582 for (x=0; x < (ssize_t) roi->width; x++)
1584 *q++=GetPixelRed(p);
1585 *q++=GetPixelGreen(p);
1586 *q++=GetPixelBlue(p);
1587 *q++=(Quantum) GetPixelAlpha(p);
1591 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1593 if (LocaleCompare(map,
"RGBP") == 0)
1595 for (y=0; y < (ssize_t) roi->height; y++)
1597 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1600 for (x=0; x < (ssize_t) roi->width; x++)
1602 *q++=GetPixelRed(p);
1603 *q++=GetPixelGreen(p);
1604 *q++=GetPixelBlue(p);
1609 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1612 for (y=0; y < (ssize_t) roi->height; y++)
1614 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1617 indexes=GetVirtualIndexQueue(image);
1618 for (x=0; x < (ssize_t) roi->width; x++)
1623 for (i=0; i < (ssize_t) length; i++)
1626 switch (quantum_map[i])
1635 case MagentaQuantum:
1637 *q=GetPixelGreen(p);
1648 *q=(Quantum) (GetPixelAlpha(p));
1651 case OpacityQuantum:
1653 *q=GetPixelOpacity(p);
1658 if (image->colorspace == CMYKColorspace)
1659 *q=GetPixelIndex(indexes+x);
1664 *q=(ClampToQuantum(GetPixelIntensity(image,p)));
1678 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1682 const char *magick_restrict map,
const QuantumType *quantum_map,
void *pixels,
1686 *magick_restrict indexes;
1703 q=(
unsigned short *) pixels;
1704 if (LocaleCompare(map,
"BGR") == 0)
1706 for (y=0; y < (ssize_t) roi->height; y++)
1708 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1711 for (x=0; x < (ssize_t) roi->width; x++)
1713 *q++=ScaleQuantumToShort(GetPixelBlue(p));
1714 *q++=ScaleQuantumToShort(GetPixelGreen(p));
1715 *q++=ScaleQuantumToShort(GetPixelRed(p));
1719 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1721 if (LocaleCompare(map,
"BGRA") == 0)
1723 for (y=0; y < (ssize_t) roi->height; y++)
1725 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1728 for (x=0; x < (ssize_t) roi->width; x++)
1730 *q++=ScaleQuantumToShort(GetPixelBlue(p));
1731 *q++=ScaleQuantumToShort(GetPixelGreen(p));
1732 *q++=ScaleQuantumToShort(GetPixelRed(p));
1733 *q++=ScaleQuantumToShort((Quantum) GetPixelAlpha(p));
1737 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1739 if (LocaleCompare(map,
"BGRP") == 0)
1741 for (y=0; y < (ssize_t) roi->height; y++)
1743 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1746 for (x=0; x < (ssize_t) roi->width; x++)
1748 *q++=ScaleQuantumToShort(GetPixelBlue(p));
1749 *q++=ScaleQuantumToShort(GetPixelGreen(p));
1750 *q++=ScaleQuantumToShort(GetPixelRed(p));
1755 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1757 if (LocaleCompare(map,
"I") == 0)
1759 for (y=0; y < (ssize_t) roi->height; y++)
1761 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1764 for (x=0; x < (ssize_t) roi->width; x++)
1766 *q++=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
1770 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1772 if (LocaleCompare(map,
"RGB") == 0)
1774 for (y=0; y < (ssize_t) roi->height; y++)
1776 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1779 for (x=0; x < (ssize_t) roi->width; x++)
1781 *q++=ScaleQuantumToShort(GetPixelRed(p));
1782 *q++=ScaleQuantumToShort(GetPixelGreen(p));
1783 *q++=ScaleQuantumToShort(GetPixelBlue(p));
1787 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1789 if (LocaleCompare(map,
"RGBA") == 0)
1791 for (y=0; y < (ssize_t) roi->height; y++)
1793 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1796 for (x=0; x < (ssize_t) roi->width; x++)
1798 *q++=ScaleQuantumToShort(GetPixelRed(p));
1799 *q++=ScaleQuantumToShort(GetPixelGreen(p));
1800 *q++=ScaleQuantumToShort(GetPixelBlue(p));
1801 *q++=ScaleQuantumToShort((Quantum) GetPixelAlpha(p));
1805 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1807 if (LocaleCompare(map,
"RGBP") == 0)
1809 for (y=0; y < (ssize_t) roi->height; y++)
1811 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1814 for (x=0; x < (ssize_t) roi->width; x++)
1816 *q++=ScaleQuantumToShort(GetPixelRed(p));
1817 *q++=ScaleQuantumToShort(GetPixelGreen(p));
1818 *q++=ScaleQuantumToShort(GetPixelBlue(p));
1823 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1826 for (y=0; y < (ssize_t) roi->height; y++)
1828 p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
1831 indexes=GetVirtualIndexQueue(image);
1832 for (x=0; x < (ssize_t) roi->width; x++)
1837 for (i=0; i < (ssize_t) length; i++)
1840 switch (quantum_map[i])
1845 *q=ScaleQuantumToShort(GetPixelRed(p));
1849 case MagentaQuantum:
1851 *q=ScaleQuantumToShort(GetPixelGreen(p));
1857 *q=ScaleQuantumToShort(GetPixelBlue(p));
1862 *q=ScaleQuantumToShort((Quantum) (GetPixelAlpha(p)));
1865 case OpacityQuantum:
1867 *q=ScaleQuantumToShort(GetPixelOpacity(p));
1872 if (image->colorspace == CMYKColorspace)
1873 *q=ScaleQuantumToShort(GetPixelIndex(indexes+x));
1878 *q=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
1889 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
1892 MagickExport MagickBooleanType ExportImagePixels(
const Image *image,
1893 const ssize_t x,
const ssize_t y,
const size_t width,
const size_t height,
1894 const char *map,
const StorageType type,
void *pixels,
ExceptionInfo *exception)
1911 assert(image != (
Image *) NULL);
1912 assert(image->signature == MagickCoreSignature);
1913 if (IsEventLogging() != MagickFalse)
1914 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1916 quantum_map=(QuantumType *) AcquireQuantumMemory(length,
sizeof(*quantum_map));
1917 if (quantum_map == (QuantumType *) NULL)
1919 (void) ThrowMagickException(exception,GetMagickModule(),
1920 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1921 return(MagickFalse);
1923 for (i=0; i < (ssize_t) length; i++)
1930 quantum_map[i]=AlphaQuantum;
1936 quantum_map[i]=BlueQuantum;
1942 quantum_map[i]=CyanQuantum;
1943 if (image->colorspace == CMYKColorspace)
1945 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1946 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1947 "ColorSeparatedImageRequired",
"`%s'",map);
1948 return(MagickFalse);
1953 quantum_map[i]=GreenQuantum;
1959 quantum_map[i]=IndexQuantum;
1965 quantum_map[i]=BlackQuantum;
1966 if (image->colorspace == CMYKColorspace)
1968 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1969 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1970 "ColorSeparatedImageRequired",
"`%s'",map);
1971 return(MagickFalse);
1976 quantum_map[i]=MagentaQuantum;
1977 if (image->colorspace == CMYKColorspace)
1979 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1980 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1981 "ColorSeparatedImageRequired",
"`%s'",map);
1982 return(MagickFalse);
1987 quantum_map[i]=OpacityQuantum;
1993 quantum_map[i]=UndefinedQuantum;
1999 quantum_map[i]=RedQuantum;
2005 quantum_map[i]=YellowQuantum;
2006 if (image->colorspace == CMYKColorspace)
2008 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2009 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
2010 "ColorSeparatedImageRequired",
"`%s'",map);
2011 return(MagickFalse);
2015 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2016 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2017 "UnrecognizedPixelMap",
"`%s'",map);
2018 return(MagickFalse);
2030 status=ExportCharPixel((
Image *) image,&roi,map,quantum_map,pixels,
2036 status=ExportDoublePixel((
Image *) image,&roi,map,quantum_map,pixels,
2042 status=ExportFloatPixel((
Image *) image,&roi,map,quantum_map,pixels,
2048 status=ExportIntegerPixel((
Image *) image,&roi,map,quantum_map,pixels,
2054 status=ExportLongPixel((
Image *) image,&roi,map,quantum_map,pixels,
2060 status=ExportQuantumPixel((
Image *) image,&roi,map,quantum_map,pixels,
2066 status=ExportShortPixel((
Image *) image,&roi,map,quantum_map,pixels,
2072 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2073 "UnrecognizedPixelMap",
"`%s'",map);
2077 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2118 MagickExport MagickRealType GetMagickPixelIntensity(
const Image *image,
2130 switch (image->intensity)
2132 case AveragePixelIntensityMethod:
2134 intensity=(red+green+blue)/3.0;
2137 case BrightnessPixelIntensityMethod:
2139 intensity=MagickMax(MagickMax(red,green),blue);
2142 case LightnessPixelIntensityMethod:
2144 intensity=(MagickMin(MagickMin(red,green),blue)+
2145 MagickMax(MagickMax(red,green),blue))/2.0;
2148 case MSPixelIntensityMethod:
2150 intensity=(MagickRealType) (((
double) red*red+green*green+blue*blue)/
2151 (3.0*QuantumRange));
2154 case Rec601LumaPixelIntensityMethod:
2156 if (pixel->colorspace == RGBColorspace)
2158 red=EncodePixelGamma(red);
2159 green=EncodePixelGamma(green);
2160 blue=EncodePixelGamma(blue);
2162 intensity=0.298839*red+0.586811*green+0.114350*blue;
2165 case Rec601LuminancePixelIntensityMethod:
2167 if (pixel->colorspace == sRGBColorspace)
2169 red=DecodePixelGamma(red);
2170 green=DecodePixelGamma(green);
2171 blue=DecodePixelGamma(blue);
2173 intensity=0.298839*red+0.586811*green+0.114350*blue;
2176 case Rec709LumaPixelIntensityMethod:
2179 if (pixel->colorspace == RGBColorspace)
2181 red=EncodePixelGamma(red);
2182 green=EncodePixelGamma(green);
2183 blue=EncodePixelGamma(blue);
2185 intensity=0.212656*red+0.715158*green+0.072186*blue;
2188 case Rec709LuminancePixelIntensityMethod:
2190 if (pixel->colorspace == sRGBColorspace)
2192 red=DecodePixelGamma(red);
2193 green=DecodePixelGamma(green);
2194 blue=DecodePixelGamma(blue);
2196 intensity=0.212656*red+0.715158*green+0.072186*blue;
2199 case RMSPixelIntensityMethod:
2201 intensity=(MagickRealType) (sqrt((
double) red*red+green*green+blue*blue)/
2233 MagickExport
void GetMagickPixelPacket(
const Image *image,
2236 pixel->storage_class=DirectClass;
2237 pixel->colorspace=sRGBColorspace;
2238 pixel->matte=MagickFalse;
2240 pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
2244 pixel->opacity=(MagickRealType) OpaqueOpacity;
2246 if (image == (
const Image *) NULL)
2248 pixel->storage_class=image->storage_class;
2249 pixel->colorspace=image->colorspace;
2250 pixel->matte=image->matte;
2251 pixel->depth=image->depth;
2252 pixel->fuzz=image->fuzz;
2292 MagickExport MagickRealType GetPixelIntensity(
const Image *image,
2301 red=(MagickRealType) pixel->red;
2302 green=(MagickRealType) pixel->green;
2303 blue=(MagickRealType) pixel->blue;
2304 switch (image->intensity)
2306 case AveragePixelIntensityMethod:
2308 intensity=(red+green+blue)/3.0;
2311 case BrightnessPixelIntensityMethod:
2313 intensity=MagickMax(MagickMax(red,green),blue);
2316 case LightnessPixelIntensityMethod:
2318 intensity=(MagickMin(MagickMin(red,green),blue)+
2319 MagickMax(MagickMax(red,green),blue))/2.0;
2322 case MSPixelIntensityMethod:
2324 intensity=(MagickRealType) (((
double) red*red+green*green+blue*blue)/
2325 (3.0*QuantumRange));
2328 case Rec601LumaPixelIntensityMethod:
2330 if ((image->colorspace == RGBColorspace) ||
2331 (image->colorspace == LinearGRAYColorspace))
2333 red=EncodePixelGamma(red);
2334 green=EncodePixelGamma(green);
2335 blue=EncodePixelGamma(blue);
2337 intensity=0.298839*red+0.586811*green+0.114350*blue;
2340 case Rec601LuminancePixelIntensityMethod:
2342 if ((image->colorspace == sRGBColorspace) ||
2343 (image->colorspace == GRAYColorspace))
2345 red=DecodePixelGamma(red);
2346 green=DecodePixelGamma(green);
2347 blue=DecodePixelGamma(blue);
2349 intensity=0.298839*red+0.586811*green+0.114350*blue;
2352 case Rec709LumaPixelIntensityMethod:
2355 if ((image->colorspace == RGBColorspace) ||
2356 (image->colorspace == LinearGRAYColorspace))
2358 red=EncodePixelGamma(red);
2359 green=EncodePixelGamma(green);
2360 blue=EncodePixelGamma(blue);
2362 intensity=0.212656*red+0.715158*green+0.072186*blue;
2365 case Rec709LuminancePixelIntensityMethod:
2367 if ((image->colorspace == sRGBColorspace) ||
2368 (image->colorspace == GRAYColorspace))
2370 red=DecodePixelGamma(red);
2371 green=DecodePixelGamma(green);
2372 blue=DecodePixelGamma(blue);
2374 intensity=0.212656*red+0.715158*green+0.072186*blue;
2377 case RMSPixelIntensityMethod:
2379 intensity=(MagickRealType) (sqrt((
double) red*red+green*green+blue*blue)/
2441 const char *magick_restrict map,
const QuantumType *quantum_map,
2448 *magick_restrict indexes;
2462 p=(
const unsigned char *) pixels;
2463 if (LocaleCompare(map,
"BGR") == 0)
2465 for (y=0; y < (ssize_t) roi->height; y++)
2467 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2470 for (x=0; x < (ssize_t) roi->width; x++)
2472 SetPixelBlue(q,ScaleCharToQuantum(*p++));
2473 SetPixelGreen(q,ScaleCharToQuantum(*p++));
2474 SetPixelRed(q,ScaleCharToQuantum(*p++));
2477 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2480 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2482 if (LocaleCompare(map,
"BGRA") == 0)
2484 for (y=0; y < (ssize_t) roi->height; y++)
2486 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2489 for (x=0; x < (ssize_t) roi->width; x++)
2491 SetPixelBlue(q,ScaleCharToQuantum(*p++));
2492 SetPixelGreen(q,ScaleCharToQuantum(*p++));
2493 SetPixelRed(q,ScaleCharToQuantum(*p++));
2494 SetPixelAlpha(q,ScaleCharToQuantum(*p++));
2497 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2500 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2502 if (LocaleCompare(map,
"BGRO") == 0)
2504 for (y=0; y < (ssize_t) roi->height; y++)
2506 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2509 for (x=0; x < (ssize_t) roi->width; x++)
2511 SetPixelBlue(q,ScaleCharToQuantum(*p++));
2512 SetPixelGreen(q,ScaleCharToQuantum(*p++));
2513 SetPixelRed(q,ScaleCharToQuantum(*p++));
2514 SetPixelOpacity(q,ScaleCharToQuantum(*p++));
2517 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2520 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2522 if (LocaleCompare(map,
"BGRP") == 0)
2524 for (y=0; y < (ssize_t) roi->height; y++)
2526 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2529 for (x=0; x < (ssize_t) roi->width; x++)
2531 SetPixelBlue(q,ScaleCharToQuantum(*p++));
2532 SetPixelGreen(q,ScaleCharToQuantum(*p++));
2533 SetPixelRed(q,ScaleCharToQuantum(*p++));
2537 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2540 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2542 if (LocaleCompare(map,
"I") == 0)
2544 for (y=0; y < (ssize_t) roi->height; y++)
2546 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2549 for (x=0; x < (ssize_t) roi->width; x++)
2551 SetPixelRed(q,ScaleCharToQuantum(*p++));
2552 SetPixelGreen(q,GetPixelRed(q));
2553 SetPixelBlue(q,GetPixelRed(q));
2556 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2559 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2561 if (LocaleCompare(map,
"RGB") == 0)
2563 for (y=0; y < (ssize_t) roi->height; y++)
2565 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2568 for (x=0; x < (ssize_t) roi->width; x++)
2570 SetPixelRed(q,ScaleCharToQuantum(*p++));
2571 SetPixelGreen(q,ScaleCharToQuantum(*p++));
2572 SetPixelBlue(q,ScaleCharToQuantum(*p++));
2575 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2578 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2580 if (LocaleCompare(map,
"RGBA") == 0)
2582 for (y=0; y < (ssize_t) roi->height; y++)
2584 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2587 for (x=0; x < (ssize_t) roi->width; x++)
2589 SetPixelRed(q,ScaleCharToQuantum(*p++));
2590 SetPixelGreen(q,ScaleCharToQuantum(*p++));
2591 SetPixelBlue(q,ScaleCharToQuantum(*p++));
2592 SetPixelAlpha(q,ScaleCharToQuantum(*p++));
2595 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2598 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2600 if (LocaleCompare(map,
"RGBO") == 0)
2602 for (y=0; y < (ssize_t) roi->height; y++)
2604 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2607 for (x=0; x < (ssize_t) roi->width; x++)
2609 SetPixelRed(q,ScaleCharToQuantum(*p++));
2610 SetPixelGreen(q,ScaleCharToQuantum(*p++));
2611 SetPixelBlue(q,ScaleCharToQuantum(*p++));
2612 SetPixelOpacity(q,ScaleCharToQuantum(*p++));
2615 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2618 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2620 if (LocaleCompare(map,
"RGBP") == 0)
2622 for (y=0; y < (ssize_t) roi->height; y++)
2624 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2627 for (x=0; x < (ssize_t) roi->width; x++)
2629 SetPixelRed(q,ScaleCharToQuantum(*p++));
2630 SetPixelGreen(q,ScaleCharToQuantum(*p++));
2631 SetPixelBlue(q,ScaleCharToQuantum(*p++));
2635 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2638 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2641 for (y=0; y < (ssize_t) roi->height; y++)
2643 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2646 indexes=GetAuthenticIndexQueue(image);
2647 for (x=0; x < (ssize_t) roi->width; x++)
2652 for (i=0; i < (ssize_t) length; i++)
2654 switch (quantum_map[i])
2659 SetPixelRed(q,ScaleCharToQuantum(*p));
2663 case MagentaQuantum:
2665 SetPixelGreen(q,ScaleCharToQuantum(*p));
2671 SetPixelBlue(q,ScaleCharToQuantum(*p));
2676 SetPixelAlpha(q,ScaleCharToQuantum(*p));
2679 case OpacityQuantum:
2681 SetPixelOpacity(q,ScaleCharToQuantum(*p));
2686 SetPixelIndex(indexes+x,ScaleCharToQuantum(*p));
2691 SetPixelRed(q,ScaleCharToQuantum(*p));
2692 SetPixelGreen(q,GetPixelRed(q));
2693 SetPixelBlue(q,GetPixelRed(q));
2703 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2706 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2709 static MagickBooleanType ImportDoublePixel(
Image *image,
2711 const QuantumType *quantum_map,
const void *pixels,
ExceptionInfo *exception)
2717 *magick_restrict indexes;
2731 p=(
const double *) pixels;
2732 if (LocaleCompare(map,
"BGR") == 0)
2734 for (y=0; y < (ssize_t) roi->height; y++)
2736 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2739 for (x=0; x < (ssize_t) roi->width; x++)
2741 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2743 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2745 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2749 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2752 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2754 if (LocaleCompare(map,
"BGRA") == 0)
2756 for (y=0; y < (ssize_t) roi->height; y++)
2758 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2761 for (x=0; x < (ssize_t) roi->width; x++)
2763 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2765 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2767 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2769 q->opacity=QuantumRange-ClampToQuantum((MagickRealType)
2774 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2777 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2779 if (LocaleCompare(map,
"BGRP") == 0)
2781 for (y=0; y < (ssize_t) roi->height; y++)
2783 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2786 for (x=0; x < (ssize_t) roi->width; x++)
2788 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2790 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2792 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2797 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2800 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2802 if (LocaleCompare(map,
"I") == 0)
2804 for (y=0; y < (ssize_t) roi->height; y++)
2806 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2809 for (x=0; x < (ssize_t) roi->width; x++)
2811 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2812 SetPixelGreen(q,GetPixelRed(q));
2813 SetPixelBlue(q,GetPixelRed(q));
2817 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2820 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2822 if (LocaleCompare(map,
"RGB") == 0)
2824 for (y=0; y < (ssize_t) roi->height; y++)
2826 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2829 for (x=0; x < (ssize_t) roi->width; x++)
2831 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2833 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2835 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2839 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2842 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2844 if (LocaleCompare(map,
"RGBA") == 0)
2846 for (y=0; y < (ssize_t) roi->height; y++)
2848 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2851 for (x=0; x < (ssize_t) roi->width; x++)
2853 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2855 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2857 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2859 SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2863 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2866 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2868 if (LocaleCompare(map,
"RGBP") == 0)
2870 for (y=0; y < (ssize_t) roi->height; y++)
2872 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2875 for (x=0; x < (ssize_t) roi->width; x++)
2877 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2879 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2881 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2885 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2888 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2891 for (y=0; y < (ssize_t) roi->height; y++)
2893 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2896 indexes=GetAuthenticIndexQueue(image);
2897 for (x=0; x < (ssize_t) roi->width; x++)
2902 for (i=0; i < (ssize_t) length; i++)
2904 switch (quantum_map[i])
2909 SetPixelRed(q,ClampToQuantum((MagickRealType)
2910 QuantumRange*(*p)));
2914 case MagentaQuantum:
2916 SetPixelGreen(q,ClampToQuantum((MagickRealType)
2917 QuantumRange*(*p)));
2923 SetPixelBlue(q,ClampToQuantum((MagickRealType)
2924 QuantumRange*(*p)));
2929 SetPixelAlpha(q,ClampToQuantum((MagickRealType)
2930 QuantumRange*(*p)));
2933 case OpacityQuantum:
2935 SetPixelOpacity(q,ClampToQuantum((MagickRealType)
2936 QuantumRange*(*p)));
2941 SetPixelIndex(indexes+x,ClampToQuantum((MagickRealType)
2942 QuantumRange*(*p)));
2947 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2948 SetPixelGreen(q,GetPixelRed(q));
2949 SetPixelBlue(q,GetPixelRed(q));
2959 if (SyncAuthenticPixels(image,exception) == MagickFalse)
2962 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
2966 const char *magick_restrict map,
const QuantumType *quantum_map,
2973 *magick_restrict indexes;
2987 p=(
const float *) pixels;
2988 if (LocaleCompare(map,
"BGR") == 0)
2990 for (y=0; y < (ssize_t) roi->height; y++)
2992 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
2995 for (x=0; x < (ssize_t) roi->width; x++)
2997 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
2999 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3001 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3005 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3008 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3010 if (LocaleCompare(map,
"BGRA") == 0)
3012 for (y=0; y < (ssize_t) roi->height; y++)
3014 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3017 for (x=0; x < (ssize_t) roi->width; x++)
3019 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3021 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3023 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3025 SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3029 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3032 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3034 if (LocaleCompare(map,
"BGRP") == 0)
3036 for (y=0; y < (ssize_t) roi->height; y++)
3038 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3041 for (x=0; x < (ssize_t) roi->width; x++)
3043 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3045 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3047 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3052 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3055 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3057 if (LocaleCompare(map,
"I") == 0)
3059 for (y=0; y < (ssize_t) roi->height; y++)
3061 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3064 for (x=0; x < (ssize_t) roi->width; x++)
3066 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3067 SetPixelGreen(q,GetPixelRed(q));
3068 SetPixelBlue(q,GetPixelRed(q));
3072 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3075 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3077 if (LocaleCompare(map,
"RGB") == 0)
3079 for (y=0; y < (ssize_t) roi->height; y++)
3081 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3084 for (x=0; x < (ssize_t) roi->width; x++)
3086 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3088 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3090 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3094 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3097 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3099 if (LocaleCompare(map,
"RGBA") == 0)
3101 for (y=0; y < (ssize_t) roi->height; y++)
3103 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3106 for (x=0; x < (ssize_t) roi->width; x++)
3108 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3110 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3112 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3114 SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3118 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3121 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3123 if (LocaleCompare(map,
"RGBP") == 0)
3125 for (y=0; y < (ssize_t) roi->height; y++)
3127 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3130 for (x=0; x < (ssize_t) roi->width; x++)
3132 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3134 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3136 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3140 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3143 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3146 for (y=0; y < (ssize_t) roi->height; y++)
3148 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3151 indexes=GetAuthenticIndexQueue(image);
3152 for (x=0; x < (ssize_t) roi->width; x++)
3157 for (i=0; i < (ssize_t) length; i++)
3159 switch (quantum_map[i])
3164 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3168 case MagentaQuantum:
3170 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3176 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3181 SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3184 case OpacityQuantum:
3186 SetPixelOpacity(q,ClampToQuantum((MagickRealType)
3187 QuantumRange*(*p)));
3192 SetPixelIndex(indexes+x,ClampToQuantum((MagickRealType)
3193 QuantumRange*(*p)));
3198 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
3199 SetPixelGreen(q,GetPixelRed(q));
3200 SetPixelBlue(q,GetPixelRed(q));
3210 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3213 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3216 static MagickBooleanType ImportIntegerPixel(
Image *image,
3218 const QuantumType *quantum_map,
const void *pixels,
ExceptionInfo *exception)
3224 *magick_restrict indexes;
3238 p=(
const unsigned int *) pixels;
3239 if (LocaleCompare(map,
"BGR") == 0)
3241 for (y=0; y < (ssize_t) roi->height; y++)
3243 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3246 for (x=0; x < (ssize_t) roi->width; x++)
3248 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3249 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3250 SetPixelRed(q,ScaleLongToQuantum(*p++));
3253 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3256 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3258 if (LocaleCompare(map,
"BGRA") == 0)
3260 for (y=0; y < (ssize_t) roi->height; y++)
3262 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3265 for (x=0; x < (ssize_t) roi->width; x++)
3267 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3268 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3269 SetPixelRed(q,ScaleLongToQuantum(*p++));
3270 SetPixelAlpha(q,ScaleLongToQuantum(*p++));
3273 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3276 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3278 if (LocaleCompare(map,
"BGRP") == 0)
3280 for (y=0; y < (ssize_t) roi->height; y++)
3282 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3285 for (x=0; x < (ssize_t) roi->width; x++)
3287 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3288 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3289 SetPixelRed(q,ScaleLongToQuantum(*p++));
3293 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3296 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3298 if (LocaleCompare(map,
"I") == 0)
3300 for (y=0; y < (ssize_t) roi->height; y++)
3302 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3305 for (x=0; x < (ssize_t) roi->width; x++)
3307 SetPixelRed(q,ScaleLongToQuantum(*p++));
3308 SetPixelGreen(q,GetPixelRed(q));
3309 SetPixelBlue(q,GetPixelRed(q));
3312 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3315 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3317 if (LocaleCompare(map,
"RGB") == 0)
3319 for (y=0; y < (ssize_t) roi->height; y++)
3321 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3324 for (x=0; x < (ssize_t) roi->width; x++)
3326 SetPixelRed(q,ScaleLongToQuantum(*p++));
3327 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3328 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3331 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3334 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3336 if (LocaleCompare(map,
"RGBA") == 0)
3338 for (y=0; y < (ssize_t) roi->height; y++)
3340 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3343 for (x=0; x < (ssize_t) roi->width; x++)
3345 SetPixelRed(q,ScaleLongToQuantum(*p++));
3346 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3347 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3348 SetPixelAlpha(q,ScaleLongToQuantum(*p++));
3351 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3354 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3356 if (LocaleCompare(map,
"RGBP") == 0)
3358 for (y=0; y < (ssize_t) roi->height; y++)
3360 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3363 for (x=0; x < (ssize_t) roi->width; x++)
3365 SetPixelRed(q,ScaleLongToQuantum(*p++));
3366 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3367 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3371 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3374 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3377 for (y=0; y < (ssize_t) roi->height; y++)
3379 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3382 indexes=GetAuthenticIndexQueue(image);
3383 for (x=0; x < (ssize_t) roi->width; x++)
3388 for (i=0; i < (ssize_t) length; i++)
3390 switch (quantum_map[i])
3395 SetPixelRed(q,ScaleLongToQuantum(*p));
3399 case MagentaQuantum:
3401 SetPixelGreen(q,ScaleLongToQuantum(*p));
3407 SetPixelBlue(q,ScaleLongToQuantum(*p));
3412 SetPixelAlpha(q,ScaleLongToQuantum(*p));
3415 case OpacityQuantum:
3417 SetPixelOpacity(q,ScaleLongToQuantum(*p));
3422 SetPixelIndex(indexes+x,ScaleLongToQuantum(*p));
3427 SetPixelRed(q,ScaleLongToQuantum(*p));
3428 SetPixelGreen(q,GetPixelRed(q));
3429 SetPixelBlue(q,GetPixelRed(q));
3439 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3442 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3446 const char *magick_restrict map,
const QuantumType *quantum_map,
3453 *magick_restrict indexes;
3467 p=(
const unsigned int *) pixels;
3468 if (LocaleCompare(map,
"BGR") == 0)
3470 for (y=0; y < (ssize_t) roi->height; y++)
3472 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3475 for (x=0; x < (ssize_t) roi->width; x++)
3477 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3478 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3479 SetPixelRed(q,ScaleLongToQuantum(*p++));
3482 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3485 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3487 if (LocaleCompare(map,
"BGRA") == 0)
3489 for (y=0; y < (ssize_t) roi->height; y++)
3491 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3494 for (x=0; x < (ssize_t) roi->width; x++)
3496 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3497 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3498 SetPixelRed(q,ScaleLongToQuantum(*p++));
3499 SetPixelAlpha(q,ScaleLongToQuantum(*p++));
3502 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3505 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3507 if (LocaleCompare(map,
"BGRP") == 0)
3509 for (y=0; y < (ssize_t) roi->height; y++)
3511 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3514 for (x=0; x < (ssize_t) roi->width; x++)
3516 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3517 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3518 SetPixelRed(q,ScaleLongToQuantum(*p++));
3522 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3525 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3527 if (LocaleCompare(map,
"I") == 0)
3529 for (y=0; y < (ssize_t) roi->height; y++)
3531 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3534 for (x=0; x < (ssize_t) roi->width; x++)
3536 SetPixelRed(q,ScaleLongToQuantum(*p++));
3537 SetPixelGreen(q,GetPixelRed(q));
3538 SetPixelBlue(q,GetPixelRed(q));
3541 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3544 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3546 if (LocaleCompare(map,
"RGB") == 0)
3548 for (y=0; y < (ssize_t) roi->height; y++)
3550 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3553 for (x=0; x < (ssize_t) roi->width; x++)
3555 SetPixelRed(q,ScaleLongToQuantum(*p++));
3556 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3557 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3560 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3563 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3565 if (LocaleCompare(map,
"RGBA") == 0)
3567 for (y=0; y < (ssize_t) roi->height; y++)
3569 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3572 for (x=0; x < (ssize_t) roi->width; x++)
3574 SetPixelRed(q,ScaleLongToQuantum(*p++));
3575 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3576 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3577 SetPixelAlpha(q,ScaleLongToQuantum(*p++));
3580 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3583 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3585 if (LocaleCompare(map,
"RGBP") == 0)
3587 for (y=0; y < (ssize_t) roi->height; y++)
3589 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3592 for (x=0; x < (ssize_t) roi->width; x++)
3594 SetPixelRed(q,ScaleLongToQuantum(*p++));
3595 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3596 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3600 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3603 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3606 for (y=0; y < (ssize_t) roi->height; y++)
3608 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3611 indexes=GetAuthenticIndexQueue(image);
3612 for (x=0; x < (ssize_t) roi->width; x++)
3617 for (i=0; i < (ssize_t) length; i++)
3619 switch (quantum_map[i])
3624 SetPixelRed(q,ScaleLongToQuantum(*p));
3628 case MagentaQuantum:
3630 SetPixelGreen(q,ScaleLongToQuantum(*p));
3636 SetPixelBlue(q,ScaleLongToQuantum(*p));
3641 SetPixelAlpha(q,ScaleLongToQuantum(*p));
3644 case OpacityQuantum:
3646 SetPixelOpacity(q,ScaleLongToQuantum(*p));
3651 SetPixelIndex(indexes+x,ScaleLongToQuantum(*p));
3656 SetPixelRed(q,ScaleLongToQuantum(*p));
3657 SetPixelGreen(q,GetPixelRed(q));
3658 SetPixelBlue(q,GetPixelRed(q));
3668 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3671 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3674 static MagickBooleanType ImportQuantumPixel(
Image *image,
3676 const QuantumType *quantum_map,
const void *pixels,
ExceptionInfo *exception)
3682 *magick_restrict indexes;
3696 p=(
const Quantum *) pixels;
3697 if (LocaleCompare(map,
"BGR") == 0)
3699 for (y=0; y < (ssize_t) roi->height; y++)
3701 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3704 for (x=0; x < (ssize_t) roi->width; x++)
3706 SetPixelBlue(q,*p++);
3707 SetPixelGreen(q,*p++);
3708 SetPixelRed(q,*p++);
3711 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3714 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3716 if (LocaleCompare(map,
"BGRA") == 0)
3718 for (y=0; y < (ssize_t) roi->height; y++)
3720 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3723 for (x=0; x < (ssize_t) roi->width; x++)
3725 SetPixelBlue(q,*p++);
3726 SetPixelGreen(q,*p++);
3727 SetPixelRed(q,*p++);
3728 SetPixelAlpha(q,*p++);
3731 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3734 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3736 if (LocaleCompare(map,
"BGRP") == 0)
3738 for (y=0; y < (ssize_t) roi->height; y++)
3740 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3743 for (x=0; x < (ssize_t) roi->width; x++)
3745 SetPixelBlue(q,*p++);
3746 SetPixelGreen(q,*p++);
3747 SetPixelRed(q,*p++);
3751 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3754 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3756 if (LocaleCompare(map,
"I") == 0)
3758 for (y=0; y < (ssize_t) roi->height; y++)
3760 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3763 for (x=0; x < (ssize_t) roi->width; x++)
3765 SetPixelRed(q,*p++);
3766 SetPixelGreen(q,GetPixelRed(q));
3767 SetPixelBlue(q,GetPixelRed(q));
3770 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3773 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3775 if (LocaleCompare(map,
"RGB") == 0)
3777 for (y=0; y < (ssize_t) roi->height; y++)
3779 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3782 for (x=0; x < (ssize_t) roi->width; x++)
3784 SetPixelRed(q,*p++);
3785 SetPixelGreen(q,*p++);
3786 SetPixelBlue(q,*p++);
3789 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3792 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3794 if (LocaleCompare(map,
"RGBA") == 0)
3796 for (y=0; y < (ssize_t) roi->height; y++)
3798 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3801 for (x=0; x < (ssize_t) roi->width; x++)
3803 SetPixelRed(q,*p++);
3804 SetPixelGreen(q,*p++);
3805 SetPixelBlue(q,*p++);
3806 SetPixelAlpha(q,*p++);
3809 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3812 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3814 if (LocaleCompare(map,
"RGBP") == 0)
3816 for (y=0; y < (ssize_t) roi->height; y++)
3818 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3821 for (x=0; x < (ssize_t) roi->width; x++)
3823 SetPixelRed(q,*p++);
3824 SetPixelGreen(q,*p++);
3825 SetPixelBlue(q,*p++);
3829 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3832 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3835 for (y=0; y < (ssize_t) roi->height; y++)
3837 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3840 indexes=GetAuthenticIndexQueue(image);
3841 for (x=0; x < (ssize_t) roi->width; x++)
3846 for (i=0; i < (ssize_t) length; i++)
3848 switch (quantum_map[i])
3857 case MagentaQuantum:
3859 SetPixelGreen(q,*p);
3870 SetPixelAlpha(q,*p);
3873 case OpacityQuantum:
3875 SetPixelOpacity(q,*p);
3880 SetPixelIndex(indexes+x,*p);
3886 SetPixelGreen(q,GetPixelRed(q));
3887 SetPixelBlue(q,GetPixelRed(q));
3897 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3900 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3904 const char *magick_restrict map,
const QuantumType *quantum_map,
3907 const unsigned short
3911 *magick_restrict indexes;
3925 p=(
const unsigned short *) pixels;
3926 if (LocaleCompare(map,
"BGR") == 0)
3928 for (y=0; y < (ssize_t) roi->height; y++)
3930 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3933 for (x=0; x < (ssize_t) roi->width; x++)
3935 SetPixelBlue(q,ScaleShortToQuantum(*p++));
3936 SetPixelGreen(q,ScaleShortToQuantum(*p++));
3937 SetPixelRed(q,ScaleShortToQuantum(*p++));
3940 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3943 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3945 if (LocaleCompare(map,
"BGRA") == 0)
3947 for (y=0; y < (ssize_t) roi->height; y++)
3949 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3952 for (x=0; x < (ssize_t) roi->width; x++)
3954 SetPixelBlue(q,ScaleShortToQuantum(*p++));
3955 SetPixelGreen(q,ScaleShortToQuantum(*p++));
3956 SetPixelRed(q,ScaleShortToQuantum(*p++));
3957 SetPixelAlpha(q,ScaleShortToQuantum(*p++));
3960 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3963 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3965 if (LocaleCompare(map,
"BGRP") == 0)
3967 for (y=0; y < (ssize_t) roi->height; y++)
3969 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3972 for (x=0; x < (ssize_t) roi->width; x++)
3974 SetPixelBlue(q,ScaleShortToQuantum(*p++));
3975 SetPixelGreen(q,ScaleShortToQuantum(*p++));
3976 SetPixelRed(q,ScaleShortToQuantum(*p++));
3980 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3983 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3985 if (LocaleCompare(map,
"I") == 0)
3987 for (y=0; y < (ssize_t) roi->height; y++)
3989 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3992 for (x=0; x < (ssize_t) roi->width; x++)
3994 SetPixelRed(q,ScaleShortToQuantum(*p++));
3995 SetPixelGreen(q,GetPixelRed(q));
3996 SetPixelBlue(q,GetPixelRed(q));
3999 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4002 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4004 if (LocaleCompare(map,
"RGB") == 0)
4006 for (y=0; y < (ssize_t) roi->height; y++)
4008 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4011 for (x=0; x < (ssize_t) roi->width; x++)
4013 SetPixelRed(q,ScaleShortToQuantum(*p++));
4014 SetPixelGreen(q,ScaleShortToQuantum(*p++));
4015 SetPixelBlue(q,ScaleShortToQuantum(*p++));
4018 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4021 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4023 if (LocaleCompare(map,
"RGBA") == 0)
4025 for (y=0; y < (ssize_t) roi->height; y++)
4027 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4030 for (x=0; x < (ssize_t) roi->width; x++)
4032 SetPixelRed(q,ScaleShortToQuantum(*p++));
4033 SetPixelGreen(q,ScaleShortToQuantum(*p++));
4034 SetPixelBlue(q,ScaleShortToQuantum(*p++));
4035 SetPixelAlpha(q,ScaleShortToQuantum(*p++));
4038 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4041 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4043 if (LocaleCompare(map,
"RGBP") == 0)
4045 for (y=0; y < (ssize_t) roi->height; y++)
4047 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4050 for (x=0; x < (ssize_t) roi->width; x++)
4052 SetPixelRed(q,ScaleShortToQuantum(*p++));
4053 SetPixelGreen(q,ScaleShortToQuantum(*p++));
4054 SetPixelBlue(q,ScaleShortToQuantum(*p++));
4058 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4061 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4064 for (y=0; y < (ssize_t) roi->height; y++)
4066 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4069 indexes=GetAuthenticIndexQueue(image);
4070 for (x=0; x < (ssize_t) roi->width; x++)
4075 for (i=0; i < (ssize_t) length; i++)
4077 switch (quantum_map[i])
4082 SetPixelRed(q,ScaleShortToQuantum(*p));
4086 case MagentaQuantum:
4088 SetPixelGreen(q,ScaleShortToQuantum(*p));
4094 SetPixelBlue(q,ScaleShortToQuantum(*p));
4099 SetPixelAlpha(q,ScaleShortToQuantum(*p));
4102 case OpacityQuantum:
4104 SetPixelOpacity(q,ScaleShortToQuantum(*p));
4109 SetPixelIndex(indexes+x,ScaleShortToQuantum(*p));
4114 SetPixelRed(q,ScaleShortToQuantum(*p));
4115 SetPixelGreen(q,GetPixelRed(q));
4116 SetPixelBlue(q,GetPixelRed(q));
4126 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4129 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4132 MagickExport MagickBooleanType ImportImagePixels(
Image *image,
const ssize_t x,
4133 const ssize_t y,
const size_t width,
const size_t height,
const char *map,
4134 const StorageType type,
const void *pixels)
4157 assert(image != (
Image *) NULL);
4158 assert(image->signature == MagickCoreSignature);
4159 if (IsEventLogging() != MagickFalse)
4160 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4161 exception=(&image->exception);
4163 quantum_map=(QuantumType *) AcquireQuantumMemory(length,
sizeof(*quantum_map));
4164 if (quantum_map == (QuantumType *) NULL)
4165 ThrowBinaryException(ResourceLimitError,
"MemoryAllocationFailed",
4167 for (i=0; i < (ssize_t) length; i++)
4174 quantum_map[i]=AlphaQuantum;
4175 image->matte=MagickTrue;
4181 quantum_map[i]=BlueQuantum;
4187 quantum_map[i]=CyanQuantum;
4188 (void) SetImageColorspace(image,CMYKColorspace);
4194 quantum_map[i]=GreenQuantum;
4200 quantum_map[i]=BlackQuantum;
4201 (void) SetImageColorspace(image,CMYKColorspace);
4207 quantum_map[i]=IndexQuantum;
4208 (void) SetImageColorspace(image,GRAYColorspace);
4214 quantum_map[i]=MagentaQuantum;
4215 (void) SetImageColorspace(image,CMYKColorspace);
4221 quantum_map[i]=OpacityQuantum;
4222 image->matte=MagickTrue;
4228 quantum_map[i]=UndefinedQuantum;
4234 quantum_map[i]=RedQuantum;
4240 quantum_map[i]=YellowQuantum;
4241 (void) SetImageColorspace(image,CMYKColorspace);
4246 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
4247 (void) ThrowMagickException(&image->exception,GetMagickModule(),
4248 OptionError,
"UnrecognizedPixelMap",
"`%s'",map);
4249 return(MagickFalse);
4253 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
4254 return(MagickFalse);
4266 status=ImportCharPixel(image,&roi,map,quantum_map,pixels,exception);
4271 status=ImportDoublePixel(image,&roi,map,quantum_map,pixels,exception);
4276 status=ImportFloatPixel(image,&roi,map,quantum_map,pixels,exception);
4281 status=ImportIntegerPixel(image,&roi,map,quantum_map,pixels,exception);
4286 status=ImportLongPixel(image,&roi,map,quantum_map,pixels,exception);
4291 status=ImportQuantumPixel(image,&roi,map,quantum_map,pixels,exception);
4296 status=ImportShortPixel(image,&roi,map,quantum_map,pixels,exception);
4301 (void) ThrowMagickException(&image->exception,GetMagickModule(),
4302 OptionError,
"UnrecognizedStorageType",
"`%d'",type);
4306 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
4349 static inline void AlphaBlendMagickPixelPacket(
const Image *image,
4351 MagickRealType *alpha)
4357 if (image->matte == MagickFalse)
4360 pixel->red=(MagickRealType) GetPixelRed(color);
4361 pixel->green=(MagickRealType) GetPixelGreen(color);
4362 pixel->blue=(MagickRealType) GetPixelBlue(color);
4363 pixel->opacity=(MagickRealType) GetPixelOpacity(color);
4365 if (((image->colorspace == CMYKColorspace) ||
4366 (image->storage_class == PseudoClass)) &&
4367 (indexes != (
const IndexPacket *) NULL))
4368 pixel->index=(MagickRealType) GetPixelIndex(indexes);
4371 *alpha=QuantumScale*GetPixelAlpha(color);
4372 pixel->red=(*alpha*GetPixelRed(color));
4373 pixel->green=(*alpha*GetPixelGreen(color));
4374 pixel->blue=(*alpha*GetPixelBlue(color));
4375 pixel->opacity=(MagickRealType) GetPixelOpacity(color);
4377 if (((image->colorspace == CMYKColorspace) ||
4378 (image->storage_class == PseudoClass)) &&
4379 (indexes != (
const IndexPacket *) NULL))
4380 pixel->index=(*alpha*GetPixelIndex(indexes));
4383 static inline void CatromWeights(
const MagickRealType x,
4384 MagickRealType (*weights)[4])
4399 alpha=(MagickRealType) 1.0-x;
4400 beta=(MagickRealType) (-0.5)*x*alpha;
4401 (*weights)[0]=alpha*beta;
4402 (*weights)[3]=x*beta;
4407 gamma=(*weights)[3]-(*weights)[0];
4408 (*weights)[1]=alpha-(*weights)[0]+gamma;
4409 (*weights)[2]=x-(*weights)[3]-gamma;
4412 static inline void SplineWeights(
const MagickRealType x,
4413 MagickRealType (*weights)[4])
4426 alpha=(MagickRealType) 1.0-x;
4427 (*weights)[3]=(MagickRealType) (1.0/6.0)*x*x*x;
4428 (*weights)[0]=(MagickRealType) (1.0/6.0)*alpha*alpha*alpha;
4429 beta=(*weights)[3]-(*weights)[0];
4430 (*weights)[1]=alpha-(*weights)[0]+beta;
4431 (*weights)[2]=x-(*weights)[3]-beta;
4434 static inline double MeshInterpolate(
const PointInfo *delta,
const double p,
4435 const double x,
const double y)
4437 return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
4440 MagickExport MagickBooleanType InterpolateMagickPixelPacket(
4442 const InterpolatePixelMethod method,
const double x,
const double y,
4470 InterpolatePixelMethod
4473 assert(image != (
Image *) NULL);
4474 assert(image->signature == MagickCoreSignature);
4475 assert(image_view != (
CacheView *) NULL);
4477 x_offset=CastDoubleToLong(floor(x));
4478 y_offset=CastDoubleToLong(floor(y));
4479 interpolate = method;
4480 if (interpolate == UndefinedInterpolatePixel)
4481 interpolate=image->interpolate;
4482 GetMagickPixelPacket(image,pixel);
4483 switch (interpolate)
4485 case AverageInterpolatePixel:
4486 case Average9InterpolatePixel:
4487 case Average16InterpolatePixel:
4493 if (interpolate == Average9InterpolatePixel)
4496 x_offset=CastDoubleToLong(floor(x+0.5)-1.0);
4497 y_offset=CastDoubleToLong(floor(y+0.5)-1.0);
4500 if (interpolate == Average16InterpolatePixel)
4506 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(
size_t) count,
4507 (
size_t) count,exception);
4513 indexes=GetCacheViewVirtualIndexQueue(image_view);
4520 GetMagickPixelPacket(image,pixels);
4521 for (i=0; i < (ssize_t) count; i++)
4523 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels,alpha);
4524 gamma=PerceptibleReciprocal(alpha[0]);
4525 pixel->red+=gamma*pixels[0].red;
4526 pixel->green+=gamma*pixels[0].green;
4527 pixel->blue+=gamma*pixels[0].blue;
4528 pixel->index+=gamma*pixels[0].index;
4529 pixel->opacity+=pixels[0].opacity;
4533 pixel->green*=gamma;
4535 pixel->index*=gamma;
4536 pixel->opacity*=gamma;
4539 case BackgroundInterpolatePixel:
4544 index=(IndexPacket) 0;
4545 SetMagickPixelPacket(image,&image->background_color,&index,pixel);
4548 case BilinearInterpolatePixel:
4555 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4561 indexes=GetCacheViewVirtualIndexQueue(image_view);
4562 for (i=0; i < 4L; i++)
4564 GetMagickPixelPacket(image,pixels+i);
4565 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4569 epsilon.x=1.0-delta.x;
4570 epsilon.y=1.0-delta.y;
4571 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4572 (epsilon.x*alpha[2]+delta.x*alpha[3])));
4573 gamma=PerceptibleReciprocal(gamma);
4574 pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
4575 pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
4576 pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
4577 pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
4579 pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
4580 pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
4582 if (image->colorspace == CMYKColorspace)
4583 pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
4584 pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x*
4586 gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4587 gamma=PerceptibleReciprocal(gamma);
4588 pixel->opacity=gamma*(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
4589 pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x*
4590 pixels[3].opacity));
4593 case BlendInterpolatePixel:
4595 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4601 indexes=GetCacheViewVirtualIndexQueue(image_view);
4602 for (i=0; i < 4L; i++)
4604 GetMagickPixelPacket(image,pixels+i);
4605 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4608 for (i=0; i <= 1L; i++)
4610 if ((y-y_offset) >= 0.75)
4612 alpha[i]=alpha[i+2];
4613 pixels[i]=pixels[i+2];
4616 if ((y-y_offset) > 0.25)
4619 alpha[i]+=alpha[i+2];
4620 pixels[i].red+=pixels[i+2].red;
4621 pixels[i].green+=pixels[i+2].green;
4622 pixels[i].blue+=pixels[i+2].blue;
4623 pixels[i].opacity+=pixels[i+2].opacity;
4624 pixels[i].index+=pixels[i+2].index;
4627 if ((x-x_offset) >= 0.75)
4630 pixels[0]=pixels[1];
4633 if ((x-x_offset) > 0.25)
4637 pixels[0].red+=pixels[1].red;
4638 pixels[0].green+=pixels[1].green;
4639 pixels[0].blue+=pixels[1].blue;
4640 pixels[0].opacity+=pixels[1].opacity;
4641 pixels[0].index+=pixels[1].index;
4644 alpha[0]=PerceptibleReciprocal(alpha[0]);
4645 pixel->red=alpha[0]*pixels[0].red;
4646 pixel->green=alpha[0]*pixels[0].green;
4647 pixel->blue=alpha[0]*pixels[0].blue;
4648 pixel->index=alpha[0]*pixels[0].index;
4649 pixel->opacity=gamma*pixels[0].opacity;
4652 case CatromInterpolatePixel:
4653 case BicubicInterpolatePixel:
4659 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4666 indexes=GetCacheViewVirtualIndexQueue(image_view);
4667 for (i=0; i < 16L; i++)
4669 GetMagickPixelPacket(image,pixels+i);
4670 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4672 CatromWeights((MagickRealType) (x-x_offset),&cx);
4673 CatromWeights((MagickRealType) (y-y_offset),&cy);
4674 pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
4675 pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
4676 pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
4677 pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
4678 pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
4679 pixels[14].red+cx[3]*pixels[15].red));
4680 pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]*
4681 pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+
4682 cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+
4683 cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]*
4684 pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+
4685 cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
4686 pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*pixels[1].blue+cx[2]*
4687 pixels[2].blue+cx[3]*pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]*
4688 pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*pixels[7].blue)+cy[2]*(cx[0]*
4689 pixels[8].blue+cx[1]*pixels[9].blue+cx[2]*pixels[10].blue+cx[3]*
4690 pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*pixels[13].blue+
4691 cx[2]*pixels[14].blue+cx[3]*pixels[15].blue));
4692 pixel->opacity=(cy[0]*(cx[0]*pixels[0].opacity+cx[1]*pixels[1].opacity+
4693 cx[2]*pixels[2].opacity+cx[3]*pixels[3].opacity)+cy[1]*(cx[0]*
4694 pixels[4].opacity+cx[1]*pixels[5].opacity+cx[2]*pixels[6].opacity+
4695 cx[3]*pixels[7].opacity)+cy[2]*(cx[0]*pixels[8].opacity+cx[1]*
4696 pixels[9].opacity+cx[2]*pixels[10].opacity+cx[3]*pixels[11].opacity)+
4697 cy[3]*(cx[0]*pixels[12].opacity+cx[1]*pixels[13].opacity+cx[2]*
4698 pixels[14].opacity+cx[3]*pixels[15].opacity));
4701 case FilterInterpolatePixel:
4720 geometry.x=x_offset-1;
4721 geometry.y=y_offset-1;
4722 excerpt_image=ExcerptImage(image,&geometry,exception);
4723 if (excerpt_image == (
Image *) NULL)
4728 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
4730 excerpt_image=DestroyImage(excerpt_image);
4731 if (filter_image == (
Image *) NULL)
4733 filter_view=AcquireVirtualCacheView(filter_image,exception);
4734 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4737 indexes=GetVirtualIndexQueue(filter_image);
4738 SetMagickPixelPacket(image,p,indexes,pixel);
4740 filter_view=DestroyCacheView(filter_view);
4741 filter_image=DestroyImage(filter_image);
4744 case IntegerInterpolatePixel:
4746 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4752 indexes=GetCacheViewVirtualIndexQueue(image_view);
4753 SetMagickPixelPacket(image,p,indexes,pixel);
4756 case MeshInterpolatePixel:
4762 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
4769 indexes=GetCacheViewVirtualIndexQueue(image_view);
4770 for (i=0; i < 4L; i++)
4772 GetMagickPixelPacket(image,pixels+i);
4773 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4777 luma.x=fabs((
double) (MagickPixelLuma(pixels+0)-
4778 MagickPixelLuma(pixels+3)));
4779 luma.y=fabs((
double) (MagickPixelLuma(pixels+1)-
4780 MagickPixelLuma(pixels+2)));
4781 if (luma.x < luma.y)
4786 if (delta.x <= delta.y)
4791 delta.y=1.0-delta.y;
4792 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4793 gamma=PerceptibleReciprocal(gamma);
4794 pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
4795 pixels[3].red,pixels[0].red);
4796 pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
4797 pixels[3].green,pixels[0].green);
4798 pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
4799 pixels[3].blue,pixels[0].blue);
4800 if (image->colorspace == CMYKColorspace)
4801 pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
4802 pixels[3].index,pixels[0].index);
4803 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4804 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
4805 pixels[3].opacity,pixels[0].opacity);
4812 delta.x=1.0-delta.x;
4813 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4814 gamma=PerceptibleReciprocal(gamma);
4815 pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
4816 pixels[0].red,pixels[3].red);
4817 pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
4818 pixels[0].green,pixels[3].green);
4819 pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
4820 pixels[0].blue,pixels[3].blue);
4821 if (image->colorspace == CMYKColorspace)
4822 pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
4823 pixels[0].index,pixels[3].index);
4824 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4825 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
4826 pixels[0].opacity,pixels[3].opacity);
4834 if (delta.x <= (1.0-delta.y))
4839 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4840 gamma=PerceptibleReciprocal(gamma);
4841 pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
4842 pixels[1].red,pixels[2].red);
4843 pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
4844 pixels[1].green,pixels[2].green);
4845 pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
4846 pixels[1].blue,pixels[2].blue);
4847 if (image->colorspace == CMYKColorspace)
4848 pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
4849 pixels[1].index,pixels[2].index);
4850 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4851 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
4852 pixels[1].opacity,pixels[2].opacity);
4859 delta.x=1.0-delta.x;
4860 delta.y=1.0-delta.y;
4861 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4862 gamma=PerceptibleReciprocal(gamma);
4863 pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
4864 pixels[2].red,pixels[1].red);
4865 pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
4866 pixels[2].green,pixels[1].green);
4867 pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
4868 pixels[2].blue,pixels[1].blue);
4869 if (image->colorspace == CMYKColorspace)
4870 pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
4871 pixels[2].index,pixels[1].index);
4872 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4873 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
4874 pixels[2].opacity,pixels[1].opacity);
4879 case NearestNeighborInterpolatePixel:
4881 p=GetCacheViewVirtualPixels(image_view,CastDoubleToLong(floor(x+0.5)),
4882 CastDoubleToLong(floor(y+0.5)),1,1,exception);
4888 indexes=GetCacheViewVirtualIndexQueue(image_view);
4889 SetMagickPixelPacket(image,p,indexes,pixel);
4892 case SplineInterpolatePixel:
4898 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4905 indexes=GetCacheViewVirtualIndexQueue(image_view);
4906 for (i=0; i < 16L; i++)
4908 GetMagickPixelPacket(image,pixels+i);
4909 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4911 SplineWeights((MagickRealType) (x-x_offset),&cx);
4912 SplineWeights((MagickRealType) (y-y_offset),&cy);
4913 pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
4914 pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
4915 pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
4916 pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
4917 pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
4918 pixels[14].red+cx[3]*pixels[15].red));
4919 pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]*
4920 pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+
4921 cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+
4922 cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]*
4923 pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+
4924 cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
4925 pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*pixels[1].blue+cx[2]*
4926 pixels[2].blue+cx[3]*pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]*
4927 pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*pixels[7].blue)+cy[2]*(cx[0]*
4928 pixels[8].blue+cx[1]*pixels[9].blue+cx[2]*pixels[10].blue+cx[3]*
4929 pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*pixels[13].blue+
4930 cx[2]*pixels[14].blue+cx[3]*pixels[15].blue));
4931 pixel->opacity=(cy[0]*(cx[0]*pixels[0].opacity+cx[1]*pixels[1].opacity+
4932 cx[2]*pixels[2].opacity+cx[3]*pixels[3].opacity)+cy[1]*(cx[0]*
4933 pixels[4].opacity+cx[1]*pixels[5].opacity+cx[2]*pixels[6].opacity+cx[3]*
4934 pixels[7].opacity)+cy[2]*(cx[0]*pixels[8].opacity+cx[1]*
4935 pixels[9].opacity+cx[2]*pixels[10].opacity+cx[3]*pixels[11].opacity)+
4936 cy[3]*(cx[0]*pixels[12].opacity+cx[1]*pixels[13].opacity+cx[2]*
4937 pixels[14].opacity+cx[3]*pixels[15].opacity));