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*(MagickRealType) QuantumRange))
249 return((MagickRealType) pixel/12.92);
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*(MagickRealType) QuantumRange))
346 return((MagickRealType) QuantumRange*(1.055*EncodeGamma(QuantumScale*
347 (MagickRealType) pixel)-0.055));
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*(
double) GetPixelBlue(p));
649 *q++=(double) (QuantumScale*(
double) GetPixelGreen(p));
650 *q++=(double) (QuantumScale*(
double) 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*(
double) GetPixelBlue(p));
666 *q++=(double) (QuantumScale*(
double) GetPixelGreen(p));
667 *q++=(double) (QuantumScale*(
double) GetPixelRed(p));
668 *q++=(double) (QuantumScale*((
double) QuantumRange-
669 (double) 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*(
double) GetPixelBlue(p));
685 *q++=(double) (QuantumScale*(
double) GetPixelGreen(p));
686 *q++=(double) (QuantumScale*(
double) 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*(
double) 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*(
double) GetPixelRed(p));
718 *q++=(double) (QuantumScale*(
double) GetPixelGreen(p));
719 *q++=(double) (QuantumScale*(
double) 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*(
double) GetPixelRed(p));
735 *q++=(double) (QuantumScale*(
double) GetPixelGreen(p));
736 *q++=(double) (QuantumScale*(
double) GetPixelBlue(p));
737 *q++=(double) (QuantumScale*((
double) QuantumRange-
738 (double) 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*(
double) GetPixelRed(p));
754 *q++=(double) (QuantumScale*(
double) GetPixelGreen(p));
755 *q++=(double) (QuantumScale*(
double) 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*(
double) GetPixelRed(p));
788 *q=(double) (QuantumScale*(
double) GetPixelGreen(p));
794 *q=(double) (QuantumScale*(
double) GetPixelBlue(p));
799 *q=(double) (QuantumScale*((
double) QuantumRange-
800 (double) GetPixelOpacity(p)));
805 *q=(double) (QuantumScale*(
double) GetPixelOpacity(p));
810 if (image->colorspace == CMYKColorspace)
811 *q=(double) (QuantumScale*(
double) GetPixelIndex(indexes+x));
816 *q=(double) (QuantumScale*(
double) 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*(
double) GetPixelBlue(p));
863 *q++=(float) (QuantumScale*(
double) GetPixelGreen(p));
864 *q++=(float) (QuantumScale*(
double) 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*(
double) GetPixelBlue(p));
880 *q++=(float) (QuantumScale*(
double) GetPixelGreen(p));
881 *q++=(float) (QuantumScale*(
double) GetPixelRed(p));
882 *q++=(float) (QuantumScale*(
double) 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*(
double) GetPixelBlue(p));
898 *q++=(float) (QuantumScale*(
double) GetPixelGreen(p));
899 *q++=(float) (QuantumScale*(
double) 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*(
double) 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*(
double) GetPixelRed(p));
931 *q++=(float) (QuantumScale*(
double) GetPixelGreen(p));
932 *q++=(float) (QuantumScale*(
double) 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*(
double) GetPixelRed(p));
948 *q++=(float) (QuantumScale*(
double) GetPixelGreen(p));
949 *q++=(float) (QuantumScale*(
double) GetPixelBlue(p));
950 *q++=(float) (QuantumScale*(
double) 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*(
double) GetPixelRed(p));
966 *q++=(float) (QuantumScale*(
double) GetPixelGreen(p));
967 *q++=(float) (QuantumScale*(
double) 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*(
double) GetPixelRed(p));
1000 *q=(float) (QuantumScale*(
double) GetPixelGreen(p));
1006 *q=(float) (QuantumScale*(
double) GetPixelBlue(p));
1011 *q=(float) (QuantumScale*(
double) GetPixelAlpha(p));
1014 case OpacityQuantum:
1016 *q=(float) (QuantumScale*(
double) GetPixelOpacity(p));
1021 if (image->colorspace == CMYKColorspace)
1022 *q=(float) (QuantumScale*(
double) GetPixelIndex(indexes+x));
1027 *q=(float) (QuantumScale*(
double) 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*(
double) 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*(
double) 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*
2998 (MagickRealType) (*p)));
3000 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*
3001 (MagickRealType) (*p)));
3003 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3004 (MagickRealType) (*p)));
3008 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3011 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3013 if (LocaleCompare(map,
"BGRA") == 0)
3015 for (y=0; y < (ssize_t) roi->height; y++)
3017 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3020 for (x=0; x < (ssize_t) roi->width; x++)
3022 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*
3023 (MagickRealType) (*p)));
3025 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*
3026 (MagickRealType) (*p)));
3028 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3029 (MagickRealType) (*p)));
3031 SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*
3032 (MagickRealType) (*p)));
3036 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3039 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3041 if (LocaleCompare(map,
"BGRP") == 0)
3043 for (y=0; y < (ssize_t) roi->height; y++)
3045 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3048 for (x=0; x < (ssize_t) roi->width; x++)
3050 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*
3051 (MagickRealType) (*p)));
3053 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*
3054 (MagickRealType) (*p)));
3056 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3057 (MagickRealType) (*p)));
3062 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3065 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3067 if (LocaleCompare(map,
"I") == 0)
3069 for (y=0; y < (ssize_t) roi->height; y++)
3071 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3074 for (x=0; x < (ssize_t) roi->width; x++)
3076 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3077 (MagickRealType) (*p)));
3078 SetPixelGreen(q,GetPixelRed(q));
3079 SetPixelBlue(q,GetPixelRed(q));
3083 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3086 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3088 if (LocaleCompare(map,
"RGB") == 0)
3090 for (y=0; y < (ssize_t) roi->height; y++)
3092 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3095 for (x=0; x < (ssize_t) roi->width; x++)
3097 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3098 (MagickRealType) (*p)));
3100 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*
3101 (MagickRealType) (*p)));
3103 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*
3104 (MagickRealType) (*p)));
3108 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3111 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3113 if (LocaleCompare(map,
"RGBA") == 0)
3115 for (y=0; y < (ssize_t) roi->height; y++)
3117 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3120 for (x=0; x < (ssize_t) roi->width; x++)
3122 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3123 (MagickRealType) (*p)));
3125 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*
3126 (MagickRealType) (*p)));
3128 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*
3129 (MagickRealType) (*p)));
3131 SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*
3132 (MagickRealType) (*p)));
3136 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3139 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3141 if (LocaleCompare(map,
"RGBP") == 0)
3143 for (y=0; y < (ssize_t) roi->height; y++)
3145 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3148 for (x=0; x < (ssize_t) roi->width; x++)
3150 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3151 (MagickRealType) (*p)));
3153 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*
3154 (MagickRealType) (*p)));
3156 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*
3157 (MagickRealType) (*p)));
3161 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3164 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3167 for (y=0; y < (ssize_t) roi->height; y++)
3169 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3172 indexes=GetAuthenticIndexQueue(image);
3173 for (x=0; x < (ssize_t) roi->width; x++)
3178 for (i=0; i < (ssize_t) length; i++)
3180 switch (quantum_map[i])
3185 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3186 (MagickRealType) (*p)));
3190 case MagentaQuantum:
3192 SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*
3193 (MagickRealType) (*p)));
3199 SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*
3200 (MagickRealType) (*p)));
3205 SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*
3206 (MagickRealType) (*p)));
3209 case OpacityQuantum:
3211 SetPixelOpacity(q,ClampToQuantum((MagickRealType)
3212 QuantumRange*(MagickRealType) (*p)));
3217 SetPixelIndex(indexes+x,ClampToQuantum((MagickRealType)
3218 QuantumRange*(MagickRealType) (*p)));
3223 SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*
3224 (MagickRealType) (*p)));
3225 SetPixelGreen(q,GetPixelRed(q));
3226 SetPixelBlue(q,GetPixelRed(q));
3236 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3239 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3242 static MagickBooleanType ImportIntegerPixel(
Image *image,
3244 const QuantumType *quantum_map,
const void *pixels,
ExceptionInfo *exception)
3250 *magick_restrict indexes;
3264 p=(
const unsigned int *) pixels;
3265 if (LocaleCompare(map,
"BGR") == 0)
3267 for (y=0; y < (ssize_t) roi->height; y++)
3269 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3272 for (x=0; x < (ssize_t) roi->width; x++)
3274 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3275 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3276 SetPixelRed(q,ScaleLongToQuantum(*p++));
3279 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3282 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3284 if (LocaleCompare(map,
"BGRA") == 0)
3286 for (y=0; y < (ssize_t) roi->height; y++)
3288 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3291 for (x=0; x < (ssize_t) roi->width; x++)
3293 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3294 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3295 SetPixelRed(q,ScaleLongToQuantum(*p++));
3296 SetPixelAlpha(q,ScaleLongToQuantum(*p++));
3299 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3302 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3304 if (LocaleCompare(map,
"BGRP") == 0)
3306 for (y=0; y < (ssize_t) roi->height; y++)
3308 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3311 for (x=0; x < (ssize_t) roi->width; x++)
3313 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3314 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3315 SetPixelRed(q,ScaleLongToQuantum(*p++));
3319 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3322 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3324 if (LocaleCompare(map,
"I") == 0)
3326 for (y=0; y < (ssize_t) roi->height; y++)
3328 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3331 for (x=0; x < (ssize_t) roi->width; x++)
3333 SetPixelRed(q,ScaleLongToQuantum(*p++));
3334 SetPixelGreen(q,GetPixelRed(q));
3335 SetPixelBlue(q,GetPixelRed(q));
3338 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3341 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3343 if (LocaleCompare(map,
"RGB") == 0)
3345 for (y=0; y < (ssize_t) roi->height; y++)
3347 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3350 for (x=0; x < (ssize_t) roi->width; x++)
3352 SetPixelRed(q,ScaleLongToQuantum(*p++));
3353 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3354 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3357 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3360 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3362 if (LocaleCompare(map,
"RGBA") == 0)
3364 for (y=0; y < (ssize_t) roi->height; y++)
3366 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3369 for (x=0; x < (ssize_t) roi->width; x++)
3371 SetPixelRed(q,ScaleLongToQuantum(*p++));
3372 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3373 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3374 SetPixelAlpha(q,ScaleLongToQuantum(*p++));
3377 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3380 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3382 if (LocaleCompare(map,
"RGBP") == 0)
3384 for (y=0; y < (ssize_t) roi->height; y++)
3386 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3389 for (x=0; x < (ssize_t) roi->width; x++)
3391 SetPixelRed(q,ScaleLongToQuantum(*p++));
3392 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3393 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3397 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3400 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3403 for (y=0; y < (ssize_t) roi->height; y++)
3405 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3408 indexes=GetAuthenticIndexQueue(image);
3409 for (x=0; x < (ssize_t) roi->width; x++)
3414 for (i=0; i < (ssize_t) length; i++)
3416 switch (quantum_map[i])
3421 SetPixelRed(q,ScaleLongToQuantum(*p));
3425 case MagentaQuantum:
3427 SetPixelGreen(q,ScaleLongToQuantum(*p));
3433 SetPixelBlue(q,ScaleLongToQuantum(*p));
3438 SetPixelAlpha(q,ScaleLongToQuantum(*p));
3441 case OpacityQuantum:
3443 SetPixelOpacity(q,ScaleLongToQuantum(*p));
3448 SetPixelIndex(indexes+x,ScaleLongToQuantum(*p));
3453 SetPixelRed(q,ScaleLongToQuantum(*p));
3454 SetPixelGreen(q,GetPixelRed(q));
3455 SetPixelBlue(q,GetPixelRed(q));
3465 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3468 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3472 const char *magick_restrict map,
const QuantumType *quantum_map,
3479 *magick_restrict indexes;
3493 p=(
const unsigned int *) pixels;
3494 if (LocaleCompare(map,
"BGR") == 0)
3496 for (y=0; y < (ssize_t) roi->height; y++)
3498 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3501 for (x=0; x < (ssize_t) roi->width; x++)
3503 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3504 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3505 SetPixelRed(q,ScaleLongToQuantum(*p++));
3508 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3511 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3513 if (LocaleCompare(map,
"BGRA") == 0)
3515 for (y=0; y < (ssize_t) roi->height; y++)
3517 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3520 for (x=0; x < (ssize_t) roi->width; x++)
3522 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3523 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3524 SetPixelRed(q,ScaleLongToQuantum(*p++));
3525 SetPixelAlpha(q,ScaleLongToQuantum(*p++));
3528 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3531 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3533 if (LocaleCompare(map,
"BGRP") == 0)
3535 for (y=0; y < (ssize_t) roi->height; y++)
3537 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3540 for (x=0; x < (ssize_t) roi->width; x++)
3542 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3543 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3544 SetPixelRed(q,ScaleLongToQuantum(*p++));
3548 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3551 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3553 if (LocaleCompare(map,
"I") == 0)
3555 for (y=0; y < (ssize_t) roi->height; y++)
3557 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3560 for (x=0; x < (ssize_t) roi->width; x++)
3562 SetPixelRed(q,ScaleLongToQuantum(*p++));
3563 SetPixelGreen(q,GetPixelRed(q));
3564 SetPixelBlue(q,GetPixelRed(q));
3567 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3570 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3572 if (LocaleCompare(map,
"RGB") == 0)
3574 for (y=0; y < (ssize_t) roi->height; y++)
3576 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3579 for (x=0; x < (ssize_t) roi->width; x++)
3581 SetPixelRed(q,ScaleLongToQuantum(*p++));
3582 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3583 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3586 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3589 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3591 if (LocaleCompare(map,
"RGBA") == 0)
3593 for (y=0; y < (ssize_t) roi->height; y++)
3595 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3598 for (x=0; x < (ssize_t) roi->width; x++)
3600 SetPixelRed(q,ScaleLongToQuantum(*p++));
3601 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3602 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3603 SetPixelAlpha(q,ScaleLongToQuantum(*p++));
3606 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3609 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3611 if (LocaleCompare(map,
"RGBP") == 0)
3613 for (y=0; y < (ssize_t) roi->height; y++)
3615 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3618 for (x=0; x < (ssize_t) roi->width; x++)
3620 SetPixelRed(q,ScaleLongToQuantum(*p++));
3621 SetPixelGreen(q,ScaleLongToQuantum(*p++));
3622 SetPixelBlue(q,ScaleLongToQuantum(*p++));
3626 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3629 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3632 for (y=0; y < (ssize_t) roi->height; y++)
3634 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3637 indexes=GetAuthenticIndexQueue(image);
3638 for (x=0; x < (ssize_t) roi->width; x++)
3643 for (i=0; i < (ssize_t) length; i++)
3645 switch (quantum_map[i])
3650 SetPixelRed(q,ScaleLongToQuantum(*p));
3654 case MagentaQuantum:
3656 SetPixelGreen(q,ScaleLongToQuantum(*p));
3662 SetPixelBlue(q,ScaleLongToQuantum(*p));
3667 SetPixelAlpha(q,ScaleLongToQuantum(*p));
3670 case OpacityQuantum:
3672 SetPixelOpacity(q,ScaleLongToQuantum(*p));
3677 SetPixelIndex(indexes+x,ScaleLongToQuantum(*p));
3682 SetPixelRed(q,ScaleLongToQuantum(*p));
3683 SetPixelGreen(q,GetPixelRed(q));
3684 SetPixelBlue(q,GetPixelRed(q));
3694 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3697 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3700 static MagickBooleanType ImportQuantumPixel(
Image *image,
3702 const QuantumType *quantum_map,
const void *pixels,
ExceptionInfo *exception)
3708 *magick_restrict indexes;
3722 p=(
const Quantum *) pixels;
3723 if (LocaleCompare(map,
"BGR") == 0)
3725 for (y=0; y < (ssize_t) roi->height; y++)
3727 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3730 for (x=0; x < (ssize_t) roi->width; x++)
3732 SetPixelBlue(q,*p++);
3733 SetPixelGreen(q,*p++);
3734 SetPixelRed(q,*p++);
3737 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3740 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3742 if (LocaleCompare(map,
"BGRA") == 0)
3744 for (y=0; y < (ssize_t) roi->height; y++)
3746 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3749 for (x=0; x < (ssize_t) roi->width; x++)
3751 SetPixelBlue(q,*p++);
3752 SetPixelGreen(q,*p++);
3753 SetPixelRed(q,*p++);
3754 SetPixelAlpha(q,*p++);
3757 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3760 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3762 if (LocaleCompare(map,
"BGRP") == 0)
3764 for (y=0; y < (ssize_t) roi->height; y++)
3766 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3769 for (x=0; x < (ssize_t) roi->width; x++)
3771 SetPixelBlue(q,*p++);
3772 SetPixelGreen(q,*p++);
3773 SetPixelRed(q,*p++);
3777 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3780 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3782 if (LocaleCompare(map,
"I") == 0)
3784 for (y=0; y < (ssize_t) roi->height; y++)
3786 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3789 for (x=0; x < (ssize_t) roi->width; x++)
3791 SetPixelRed(q,*p++);
3792 SetPixelGreen(q,GetPixelRed(q));
3793 SetPixelBlue(q,GetPixelRed(q));
3796 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3799 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3801 if (LocaleCompare(map,
"RGB") == 0)
3803 for (y=0; y < (ssize_t) roi->height; y++)
3805 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3808 for (x=0; x < (ssize_t) roi->width; x++)
3810 SetPixelRed(q,*p++);
3811 SetPixelGreen(q,*p++);
3812 SetPixelBlue(q,*p++);
3815 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3818 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3820 if (LocaleCompare(map,
"RGBA") == 0)
3822 for (y=0; y < (ssize_t) roi->height; y++)
3824 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3827 for (x=0; x < (ssize_t) roi->width; x++)
3829 SetPixelRed(q,*p++);
3830 SetPixelGreen(q,*p++);
3831 SetPixelBlue(q,*p++);
3832 SetPixelAlpha(q,*p++);
3835 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3838 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3840 if (LocaleCompare(map,
"RGBP") == 0)
3842 for (y=0; y < (ssize_t) roi->height; y++)
3844 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3847 for (x=0; x < (ssize_t) roi->width; x++)
3849 SetPixelRed(q,*p++);
3850 SetPixelGreen(q,*p++);
3851 SetPixelBlue(q,*p++);
3855 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3858 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3861 for (y=0; y < (ssize_t) roi->height; y++)
3863 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3866 indexes=GetAuthenticIndexQueue(image);
3867 for (x=0; x < (ssize_t) roi->width; x++)
3872 for (i=0; i < (ssize_t) length; i++)
3874 switch (quantum_map[i])
3883 case MagentaQuantum:
3885 SetPixelGreen(q,*p);
3896 SetPixelAlpha(q,*p);
3899 case OpacityQuantum:
3901 SetPixelOpacity(q,*p);
3906 SetPixelIndex(indexes+x,*p);
3912 SetPixelGreen(q,GetPixelRed(q));
3913 SetPixelBlue(q,GetPixelRed(q));
3923 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3926 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3930 const char *magick_restrict map,
const QuantumType *quantum_map,
3933 const unsigned short
3937 *magick_restrict indexes;
3951 p=(
const unsigned short *) pixels;
3952 if (LocaleCompare(map,
"BGR") == 0)
3954 for (y=0; y < (ssize_t) roi->height; y++)
3956 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3959 for (x=0; x < (ssize_t) roi->width; x++)
3961 SetPixelBlue(q,ScaleShortToQuantum(*p++));
3962 SetPixelGreen(q,ScaleShortToQuantum(*p++));
3963 SetPixelRed(q,ScaleShortToQuantum(*p++));
3966 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3969 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3971 if (LocaleCompare(map,
"BGRA") == 0)
3973 for (y=0; y < (ssize_t) roi->height; y++)
3975 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3978 for (x=0; x < (ssize_t) roi->width; x++)
3980 SetPixelBlue(q,ScaleShortToQuantum(*p++));
3981 SetPixelGreen(q,ScaleShortToQuantum(*p++));
3982 SetPixelRed(q,ScaleShortToQuantum(*p++));
3983 SetPixelAlpha(q,ScaleShortToQuantum(*p++));
3986 if (SyncAuthenticPixels(image,exception) == MagickFalse)
3989 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
3991 if (LocaleCompare(map,
"BGRP") == 0)
3993 for (y=0; y < (ssize_t) roi->height; y++)
3995 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
3998 for (x=0; x < (ssize_t) roi->width; x++)
4000 SetPixelBlue(q,ScaleShortToQuantum(*p++));
4001 SetPixelGreen(q,ScaleShortToQuantum(*p++));
4002 SetPixelRed(q,ScaleShortToQuantum(*p++));
4006 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4009 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4011 if (LocaleCompare(map,
"I") == 0)
4013 for (y=0; y < (ssize_t) roi->height; y++)
4015 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4018 for (x=0; x < (ssize_t) roi->width; x++)
4020 SetPixelRed(q,ScaleShortToQuantum(*p++));
4021 SetPixelGreen(q,GetPixelRed(q));
4022 SetPixelBlue(q,GetPixelRed(q));
4025 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4028 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4030 if (LocaleCompare(map,
"RGB") == 0)
4032 for (y=0; y < (ssize_t) roi->height; y++)
4034 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4037 for (x=0; x < (ssize_t) roi->width; x++)
4039 SetPixelRed(q,ScaleShortToQuantum(*p++));
4040 SetPixelGreen(q,ScaleShortToQuantum(*p++));
4041 SetPixelBlue(q,ScaleShortToQuantum(*p++));
4044 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4047 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4049 if (LocaleCompare(map,
"RGBA") == 0)
4051 for (y=0; y < (ssize_t) roi->height; y++)
4053 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4056 for (x=0; x < (ssize_t) roi->width; x++)
4058 SetPixelRed(q,ScaleShortToQuantum(*p++));
4059 SetPixelGreen(q,ScaleShortToQuantum(*p++));
4060 SetPixelBlue(q,ScaleShortToQuantum(*p++));
4061 SetPixelAlpha(q,ScaleShortToQuantum(*p++));
4064 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4067 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4069 if (LocaleCompare(map,
"RGBP") == 0)
4071 for (y=0; y < (ssize_t) roi->height; y++)
4073 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4076 for (x=0; x < (ssize_t) roi->width; x++)
4078 SetPixelRed(q,ScaleShortToQuantum(*p++));
4079 SetPixelGreen(q,ScaleShortToQuantum(*p++));
4080 SetPixelBlue(q,ScaleShortToQuantum(*p++));
4084 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4087 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4090 for (y=0; y < (ssize_t) roi->height; y++)
4092 q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
4095 indexes=GetAuthenticIndexQueue(image);
4096 for (x=0; x < (ssize_t) roi->width; x++)
4101 for (i=0; i < (ssize_t) length; i++)
4103 switch (quantum_map[i])
4108 SetPixelRed(q,ScaleShortToQuantum(*p));
4112 case MagentaQuantum:
4114 SetPixelGreen(q,ScaleShortToQuantum(*p));
4120 SetPixelBlue(q,ScaleShortToQuantum(*p));
4125 SetPixelAlpha(q,ScaleShortToQuantum(*p));
4128 case OpacityQuantum:
4130 SetPixelOpacity(q,ScaleShortToQuantum(*p));
4135 SetPixelIndex(indexes+x,ScaleShortToQuantum(*p));
4140 SetPixelRed(q,ScaleShortToQuantum(*p));
4141 SetPixelGreen(q,GetPixelRed(q));
4142 SetPixelBlue(q,GetPixelRed(q));
4152 if (SyncAuthenticPixels(image,exception) == MagickFalse)
4155 return(y < (ssize_t) roi->height ? MagickFalse : MagickTrue);
4158 MagickExport MagickBooleanType ImportImagePixels(
Image *image,
const ssize_t x,
4159 const ssize_t y,
const size_t width,
const size_t height,
const char *map,
4160 const StorageType type,
const void *pixels)
4183 assert(image != (
Image *) NULL);
4184 assert(image->signature == MagickCoreSignature);
4185 if (IsEventLogging() != MagickFalse)
4186 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4187 exception=(&image->exception);
4189 quantum_map=(QuantumType *) AcquireQuantumMemory(length,
sizeof(*quantum_map));
4190 if (quantum_map == (QuantumType *) NULL)
4191 ThrowBinaryException(ResourceLimitError,
"MemoryAllocationFailed",
4193 for (i=0; i < (ssize_t) length; i++)
4200 quantum_map[i]=AlphaQuantum;
4201 image->matte=MagickTrue;
4207 quantum_map[i]=BlueQuantum;
4213 quantum_map[i]=CyanQuantum;
4214 (void) SetImageColorspace(image,CMYKColorspace);
4220 quantum_map[i]=GreenQuantum;
4226 quantum_map[i]=BlackQuantum;
4227 (void) SetImageColorspace(image,CMYKColorspace);
4233 quantum_map[i]=IndexQuantum;
4234 (void) SetImageColorspace(image,GRAYColorspace);
4240 quantum_map[i]=MagentaQuantum;
4241 (void) SetImageColorspace(image,CMYKColorspace);
4247 quantum_map[i]=OpacityQuantum;
4248 image->matte=MagickTrue;
4254 quantum_map[i]=UndefinedQuantum;
4260 quantum_map[i]=RedQuantum;
4266 quantum_map[i]=YellowQuantum;
4267 (void) SetImageColorspace(image,CMYKColorspace);
4272 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
4273 (void) ThrowMagickException(&image->exception,GetMagickModule(),
4274 OptionError,
"UnrecognizedPixelMap",
"`%s'",map);
4275 return(MagickFalse);
4279 if (SetImageStorageClass(image,DirectClass) == MagickFalse)
4280 return(MagickFalse);
4292 status=ImportCharPixel(image,&roi,map,quantum_map,pixels,exception);
4297 status=ImportDoublePixel(image,&roi,map,quantum_map,pixels,exception);
4302 status=ImportFloatPixel(image,&roi,map,quantum_map,pixels,exception);
4307 status=ImportIntegerPixel(image,&roi,map,quantum_map,pixels,exception);
4312 status=ImportLongPixel(image,&roi,map,quantum_map,pixels,exception);
4317 status=ImportQuantumPixel(image,&roi,map,quantum_map,pixels,exception);
4322 status=ImportShortPixel(image,&roi,map,quantum_map,pixels,exception);
4327 (void) ThrowMagickException(&image->exception,GetMagickModule(),
4328 OptionError,
"UnrecognizedStorageType",
"`%d'",type);
4332 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
4375 static inline void AlphaBlendMagickPixelPacket(
const Image *image,
4377 MagickRealType *alpha)
4383 if (image->matte == MagickFalse)
4386 pixel->red=(MagickRealType) GetPixelRed(color);
4387 pixel->green=(MagickRealType) GetPixelGreen(color);
4388 pixel->blue=(MagickRealType) GetPixelBlue(color);
4389 pixel->opacity=(MagickRealType) GetPixelOpacity(color);
4391 if (((image->colorspace == CMYKColorspace) ||
4392 (image->storage_class == PseudoClass)) &&
4393 (indexes != (
const IndexPacket *) NULL))
4394 pixel->index=(MagickRealType) GetPixelIndex(indexes);
4397 *alpha=QuantumScale*(double) GetPixelAlpha(color);
4398 pixel->red=(*alpha*(double) GetPixelRed(color));
4399 pixel->green=(*alpha*(double) GetPixelGreen(color));
4400 pixel->blue=(*alpha*(double) GetPixelBlue(color));
4401 pixel->opacity=(MagickRealType) GetPixelOpacity(color);
4403 if (((image->colorspace == CMYKColorspace) ||
4404 (image->storage_class == PseudoClass)) &&
4405 (indexes != (
const IndexPacket *) NULL))
4406 pixel->index=(*alpha*(
double) GetPixelIndex(indexes));
4409 static inline void CatromWeights(
const MagickRealType x,
4410 MagickRealType (*weights)[4])
4425 alpha=(MagickRealType) 1.0-x;
4426 beta=(MagickRealType) (-0.5)*x*alpha;
4427 (*weights)[0]=alpha*beta;
4428 (*weights)[3]=x*beta;
4433 gamma=(*weights)[3]-(*weights)[0];
4434 (*weights)[1]=alpha-(*weights)[0]+gamma;
4435 (*weights)[2]=x-(*weights)[3]-gamma;
4438 static inline void SplineWeights(
const MagickRealType x,
4439 MagickRealType (*weights)[4])
4452 alpha=(MagickRealType) 1.0-x;
4453 (*weights)[3]=(MagickRealType) (1.0/6.0)*x*x*x;
4454 (*weights)[0]=(MagickRealType) (1.0/6.0)*alpha*alpha*alpha;
4455 beta=(*weights)[3]-(*weights)[0];
4456 (*weights)[1]=alpha-(*weights)[0]+beta;
4457 (*weights)[2]=x-(*weights)[3]-beta;
4460 static inline double MeshInterpolate(
const PointInfo *delta,
const double p,
4461 const double x,
const double y)
4463 return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
4466 MagickExport MagickBooleanType InterpolateMagickPixelPacket(
4468 const InterpolatePixelMethod method,
const double x,
const double y,
4496 InterpolatePixelMethod
4499 assert(image != (
Image *) NULL);
4500 assert(image->signature == MagickCoreSignature);
4501 assert(image_view != (
CacheView *) NULL);
4503 x_offset=CastDoubleToLong(floor(x));
4504 y_offset=CastDoubleToLong(floor(y));
4505 interpolate = method;
4506 if (interpolate == UndefinedInterpolatePixel)
4507 interpolate=image->interpolate;
4508 GetMagickPixelPacket(image,pixel);
4509 switch (interpolate)
4511 case AverageInterpolatePixel:
4512 case Average9InterpolatePixel:
4513 case Average16InterpolatePixel:
4519 if (interpolate == Average9InterpolatePixel)
4522 x_offset=CastDoubleToLong(floor(x+0.5)-1.0);
4523 y_offset=CastDoubleToLong(floor(y+0.5)-1.0);
4526 if (interpolate == Average16InterpolatePixel)
4532 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(
size_t) count,
4533 (
size_t) count,exception);
4539 indexes=GetCacheViewVirtualIndexQueue(image_view);
4546 GetMagickPixelPacket(image,pixels);
4547 for (i=0; i < (ssize_t) count; i++)
4549 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels,alpha);
4550 gamma=PerceptibleReciprocal(alpha[0]);
4551 pixel->red+=gamma*pixels[0].red;
4552 pixel->green+=gamma*pixels[0].green;
4553 pixel->blue+=gamma*pixels[0].blue;
4554 pixel->index+=gamma*pixels[0].index;
4555 pixel->opacity+=pixels[0].opacity;
4559 pixel->green*=gamma;
4561 pixel->index*=gamma;
4562 pixel->opacity*=gamma;
4565 case BackgroundInterpolatePixel:
4570 index=(IndexPacket) 0;
4571 SetMagickPixelPacket(image,&image->background_color,&index,pixel);
4574 case BilinearInterpolatePixel:
4581 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4587 indexes=GetCacheViewVirtualIndexQueue(image_view);
4588 for (i=0; i < 4L; i++)
4590 GetMagickPixelPacket(image,pixels+i);
4591 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4595 epsilon.x=1.0-delta.x;
4596 epsilon.y=1.0-delta.y;
4597 gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
4598 (epsilon.x*alpha[2]+delta.x*alpha[3])));
4599 gamma=PerceptibleReciprocal(gamma);
4600 pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
4601 pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
4602 pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
4603 pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
4605 pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
4606 pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x*
4608 if (image->colorspace == CMYKColorspace)
4609 pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
4610 pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x*
4612 gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
4613 gamma=PerceptibleReciprocal(gamma);
4614 pixel->opacity=gamma*(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
4615 pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x*
4616 pixels[3].opacity));
4619 case BlendInterpolatePixel:
4621 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
4627 indexes=GetCacheViewVirtualIndexQueue(image_view);
4628 for (i=0; i < 4L; i++)
4630 GetMagickPixelPacket(image,pixels+i);
4631 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4634 for (i=0; i <= 1L; i++)
4636 if ((y-y_offset) >= 0.75)
4638 alpha[i]=alpha[i+2];
4639 pixels[i]=pixels[i+2];
4642 if ((y-y_offset) > 0.25)
4645 alpha[i]+=alpha[i+2];
4646 pixels[i].red+=pixels[i+2].red;
4647 pixels[i].green+=pixels[i+2].green;
4648 pixels[i].blue+=pixels[i+2].blue;
4649 pixels[i].opacity+=pixels[i+2].opacity;
4650 pixels[i].index+=pixels[i+2].index;
4653 if ((x-x_offset) >= 0.75)
4656 pixels[0]=pixels[1];
4659 if ((x-x_offset) > 0.25)
4663 pixels[0].red+=pixels[1].red;
4664 pixels[0].green+=pixels[1].green;
4665 pixels[0].blue+=pixels[1].blue;
4666 pixels[0].opacity+=pixels[1].opacity;
4667 pixels[0].index+=pixels[1].index;
4670 alpha[0]=PerceptibleReciprocal(alpha[0]);
4671 pixel->red=alpha[0]*pixels[0].red;
4672 pixel->green=alpha[0]*pixels[0].green;
4673 pixel->blue=alpha[0]*pixels[0].blue;
4674 pixel->index=alpha[0]*pixels[0].index;
4675 pixel->opacity=gamma*pixels[0].opacity;
4678 case CatromInterpolatePixel:
4679 case BicubicInterpolatePixel:
4685 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4692 indexes=GetCacheViewVirtualIndexQueue(image_view);
4693 for (i=0; i < 16L; i++)
4695 GetMagickPixelPacket(image,pixels+i);
4696 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4698 CatromWeights((MagickRealType) (x-x_offset),&cx);
4699 CatromWeights((MagickRealType) (y-y_offset),&cy);
4700 pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
4701 pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
4702 pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
4703 pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
4704 pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
4705 pixels[14].red+cx[3]*pixels[15].red));
4706 pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]*
4707 pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+
4708 cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+
4709 cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]*
4710 pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+
4711 cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
4712 pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*pixels[1].blue+cx[2]*
4713 pixels[2].blue+cx[3]*pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]*
4714 pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*pixels[7].blue)+cy[2]*(cx[0]*
4715 pixels[8].blue+cx[1]*pixels[9].blue+cx[2]*pixels[10].blue+cx[3]*
4716 pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*pixels[13].blue+
4717 cx[2]*pixels[14].blue+cx[3]*pixels[15].blue));
4718 pixel->opacity=(cy[0]*(cx[0]*pixels[0].opacity+cx[1]*pixels[1].opacity+
4719 cx[2]*pixels[2].opacity+cx[3]*pixels[3].opacity)+cy[1]*(cx[0]*
4720 pixels[4].opacity+cx[1]*pixels[5].opacity+cx[2]*pixels[6].opacity+
4721 cx[3]*pixels[7].opacity)+cy[2]*(cx[0]*pixels[8].opacity+cx[1]*
4722 pixels[9].opacity+cx[2]*pixels[10].opacity+cx[3]*pixels[11].opacity)+
4723 cy[3]*(cx[0]*pixels[12].opacity+cx[1]*pixels[13].opacity+cx[2]*
4724 pixels[14].opacity+cx[3]*pixels[15].opacity));
4727 case FilterInterpolatePixel:
4746 geometry.x=x_offset-1;
4747 geometry.y=y_offset-1;
4748 excerpt_image=ExcerptImage(image,&geometry,exception);
4749 if (excerpt_image == (
Image *) NULL)
4754 filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
4756 excerpt_image=DestroyImage(excerpt_image);
4757 if (filter_image == (
Image *) NULL)
4759 filter_view=AcquireVirtualCacheView(filter_image,exception);
4760 p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
4763 indexes=GetVirtualIndexQueue(filter_image);
4764 SetMagickPixelPacket(image,p,indexes,pixel);
4766 filter_view=DestroyCacheView(filter_view);
4767 filter_image=DestroyImage(filter_image);
4770 case IntegerInterpolatePixel:
4772 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
4778 indexes=GetCacheViewVirtualIndexQueue(image_view);
4779 SetMagickPixelPacket(image,p,indexes,pixel);
4782 case MeshInterpolatePixel:
4788 p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
4795 indexes=GetCacheViewVirtualIndexQueue(image_view);
4796 for (i=0; i < 4L; i++)
4798 GetMagickPixelPacket(image,pixels+i);
4799 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4803 luma.x=fabs((
double) (MagickPixelLuma(pixels+0)-
4804 MagickPixelLuma(pixels+3)));
4805 luma.y=fabs((
double) (MagickPixelLuma(pixels+1)-
4806 MagickPixelLuma(pixels+2)));
4807 if (luma.x < luma.y)
4812 if (delta.x <= delta.y)
4817 delta.y=1.0-delta.y;
4818 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
4819 gamma=PerceptibleReciprocal(gamma);
4820 pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
4821 pixels[3].red,pixels[0].red);
4822 pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
4823 pixels[3].green,pixels[0].green);
4824 pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
4825 pixels[3].blue,pixels[0].blue);
4826 if (image->colorspace == CMYKColorspace)
4827 pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
4828 pixels[3].index,pixels[0].index);
4829 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4830 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
4831 pixels[3].opacity,pixels[0].opacity);
4838 delta.x=1.0-delta.x;
4839 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
4840 gamma=PerceptibleReciprocal(gamma);
4841 pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
4842 pixels[0].red,pixels[3].red);
4843 pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
4844 pixels[0].green,pixels[3].green);
4845 pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
4846 pixels[0].blue,pixels[3].blue);
4847 if (image->colorspace == CMYKColorspace)
4848 pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
4849 pixels[0].index,pixels[3].index);
4850 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4851 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
4852 pixels[0].opacity,pixels[3].opacity);
4860 if (delta.x <= (1.0-delta.y))
4865 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
4866 gamma=PerceptibleReciprocal(gamma);
4867 pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
4868 pixels[1].red,pixels[2].red);
4869 pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
4870 pixels[1].green,pixels[2].green);
4871 pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
4872 pixels[1].blue,pixels[2].blue);
4873 if (image->colorspace == CMYKColorspace)
4874 pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
4875 pixels[1].index,pixels[2].index);
4876 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4877 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
4878 pixels[1].opacity,pixels[2].opacity);
4885 delta.x=1.0-delta.x;
4886 delta.y=1.0-delta.y;
4887 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
4888 gamma=PerceptibleReciprocal(gamma);
4889 pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
4890 pixels[2].red,pixels[1].red);
4891 pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
4892 pixels[2].green,pixels[1].green);
4893 pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
4894 pixels[2].blue,pixels[1].blue);
4895 if (image->colorspace == CMYKColorspace)
4896 pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
4897 pixels[2].index,pixels[1].index);
4898 gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
4899 pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
4900 pixels[2].opacity,pixels[1].opacity);
4905 case NearestNeighborInterpolatePixel:
4907 p=GetCacheViewVirtualPixels(image_view,CastDoubleToLong(floor(x+0.5)),
4908 CastDoubleToLong(floor(y+0.5)),1,1,exception);
4914 indexes=GetCacheViewVirtualIndexQueue(image_view);
4915 SetMagickPixelPacket(image,p,indexes,pixel);
4918 case SplineInterpolatePixel:
4924 p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
4931 indexes=GetCacheViewVirtualIndexQueue(image_view);
4932 for (i=0; i < 16L; i++)
4934 GetMagickPixelPacket(image,pixels+i);
4935 AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
4937 SplineWeights((MagickRealType) (x-x_offset),&cx);
4938 SplineWeights((MagickRealType) (y-y_offset),&cy);
4939 pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
4940 pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
4941 pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
4942 pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
4943 pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
4944 pixels[14].red+cx[3]*pixels[15].red));
4945 pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]*
4946 pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+
4947 cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+
4948 cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]*
4949 pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+
4950 cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
4951 pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*pixels[1].blue+cx[2]*
4952 pixels[2].blue+cx[3]*pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]*
4953 pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*pixels[7].blue)+cy[2]*(cx[0]*
4954 pixels[8].blue+cx[1]*pixels[9].blue+cx[2]*pixels[10].blue+cx[3]*
4955 pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*pixels[13].blue+
4956 cx[2]*pixels[14].blue+cx[3]*pixels[15].blue));
4957 pixel->opacity=(cy[0]*(cx[0]*pixels[0].opacity+cx[1]*pixels[1].opacity+
4958 cx[2]*pixels[2].opacity+cx[3]*pixels[3].opacity)+cy[1]*(cx[0]*
4959 pixels[4].opacity+cx[1]*pixels[5].opacity+cx[2]*pixels[6].opacity+cx[3]*
4960 pixels[7].opacity)+cy[2]*(cx[0]*pixels[8].opacity+cx[1]*
4961 pixels[9].opacity+cx[2]*pixels[10].opacity+cx[3]*pixels[11].opacity)+
4962 cy[3]*(cx[0]*pixels[12].opacity+cx[1]*pixels[13].opacity+cx[2]*
4963 pixels[14].opacity+cx[3]*pixels[15].opacity));