/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % PPPP IIIII X X EEEEE L % % P P I X X E L % % PPPP I X EEE L % % P I X X E L % % P IIIII X X EEEEE LLLLL % % % % MagickCore Methods to Import/Export Pixels % % % % Software Design % % John Cristy % % October 1998 % % % % % % Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization % % dedicated to making software imaging solutions freely available. % % % % You may not use this file except in compliance with the License. You may % % obtain a copy of the License at % % % % http://www.imagemagick.org/script/license.php % % % % Unless required by applicable law or agreed to in writing, software % % distributed under the License is distributed on an "AS IS" BASIS, % % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % % See the License for the specific language governing permissions and % % limitations under the License. % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % */ /* Include declarations. */ #include "magick/studio.h" #include "magick/property.h" #include "magick/blob.h" #include "magick/blob-private.h" #include "magick/color-private.h" #include "magick/draw.h" #include "magick/exception.h" #include "magick/exception-private.h" #include "magick/cache.h" #include "magick/constitute.h" #include "magick/delegate.h" #include "magick/geometry.h" #include "magick/list.h" #include "magick/magick.h" #include "magick/memory_.h" #include "magick/memory-private.h" #include "magick/monitor.h" #include "magick/option.h" #include "magick/pixel.h" #include "magick/pixel-private.h" #include "magick/quantum.h" #include "magick/resource_.h" #include "magick/semaphore.h" #include "magick/statistic.h" #include "magick/stream.h" #include "magick/string_.h" #include "magick/transform.h" #include "magick/utility.h" /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % C l o n e M a g i c k P i x e l P a c k e t % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % CloneMagickPixelPacket() initializes the MagickPixelPacket structure. % % The format of the CloneMagickPixelPacket method is: % % MagickPixelPacket *CloneMagickPixelPacket(MagickPixelPacket *pixel) % % A description of each parameter follows: % % o pixel: Specifies a pointer to a PixelPacket structure. % */ MagickExport MagickPixelPacket *CloneMagickPixelPacket( const MagickPixelPacket *pixel) { MagickPixelPacket *clone_pixel; clone_pixel=(MagickPixelPacket *) MagickAssumeAligned(AcquireAlignedMemory(1, sizeof(*clone_pixel))); if (clone_pixel == (MagickPixelPacket *) NULL) ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); *clone_pixel=(*pixel); return(clone_pixel); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % D e c o d e P i x e l G a m m a % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % DecodePixelGamma() applies the expansive power-law nonlinearity to the pixel. % % The format of the DecodePixelGammaImage method is: % % MagickRealType DecodePixelGamma(const MagickRealType pixel) % % A description of each parameter follows: % % o pixel: the pixel. % */ MagickExport MagickRealType DecodePixelGamma(const MagickRealType pixel) { if (pixel <= (0.0404482362771076*QuantumRange)) return(pixel/12.92f); return((MagickRealType) (QuantumRange*pow((double) (QuantumScale*pixel+ 0.055)/1.055,2.4))); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % E n c o d e P i x e l G a m m a % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % EncodePixelGamma() cancels any nonlinearity in the pixel. % % The format of the EncodePixelGammaImage method is: % % MagickRealType EncodePixelGamma(const MagickRealType pixel) % % A description of each parameter follows: % % o pixel: the pixel. % */ MagickExport MagickRealType EncodePixelGamma(const MagickRealType pixel) { if (pixel <= (0.0031306684425005883*QuantumRange)) return(12.92f*pixel); return((MagickRealType) QuantumRange*(1.055*pow((double) QuantumScale*pixel, 1.0/2.4)-0.055)); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % E x p o r t I m a g e P i x e l s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ExportImagePixels() extracts pixel data from an image and returns it to you. % The method returns MagickTrue on success otherwise MagickFalse if an error is % encountered. The data is returned as char, short int, unsigned int, % unsigned long long, float, or double in the order specified by map. % % Suppose you want to extract the first scanline of a 640x480 image as % character data in red-green-blue order: % % ExportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels,exception); % % The format of the ExportImagePixels method is: % % MagickBooleanType ExportImagePixels(const Image *image,const ssize_t x, % const ssize_t y,const size_t width,const size_t height, % const char *map,const StorageType type,void *pixels, % ExceptionInfo *exception) % % A description of each parameter follows: % % o image: the image. % % o x,y,width,height: These values define the perimeter of a region of % pixels you want to extract. % % o map: This string reflects the expected ordering of the pixel array. % It can be any combination or order of R = red, G = green, B = blue, % A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan, % Y = yellow, M = magenta, K = black, I = intensity (for grayscale), % P = pad. % % o type: Define the data type of the pixels. Float and double types are % normalized to [0..1] otherwise [0..QuantumRange]. Choose from these % types: CharPixel (char *), DoublePixel (double *), FloatPixel (float *), % LongPixel (unsigned int *), QuantumPixel (Quantum *), or % ShortPixel (unsigned short *). % % o pixels: This array of values contain the pixel components as defined by % map and type. You must preallocate this array where the expected % length varies depending on the values of width, height, map, and type. % % o exception: return any errors or warnings in this structure. % */ static void ExportCharPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,void *pixels, ExceptionInfo *exception) { register const IndexPacket *restrict indexes; register const PixelPacket *restrict p; register ssize_t x; register unsigned char *q; size_t length; ssize_t y; q=(unsigned char *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToChar(GetPixelBlue(p)); *q++=ScaleQuantumToChar(GetPixelGreen(p)); *q++=ScaleQuantumToChar(GetPixelRed(p)); p++; } } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToChar(GetPixelBlue(p)); *q++=ScaleQuantumToChar(GetPixelGreen(p)); *q++=ScaleQuantumToChar(GetPixelRed(p)); *q++=ScaleQuantumToChar((Quantum) GetPixelAlpha(p)); p++; } } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToChar(GetPixelBlue(p)); *q++=ScaleQuantumToChar(GetPixelGreen(p)); *q++=ScaleQuantumToChar(GetPixelRed(p)); *q++=ScaleQuantumToChar((Quantum) 0); p++; } } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToChar(PixelIntensityToQuantum(image,p)); p++; } } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToChar(GetPixelRed(p)); *q++=ScaleQuantumToChar(GetPixelGreen(p)); *q++=ScaleQuantumToChar(GetPixelBlue(p)); p++; } } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToChar(GetPixelRed(p)); *q++=ScaleQuantumToChar(GetPixelGreen(p)); *q++=ScaleQuantumToChar(GetPixelBlue(p)); *q++=ScaleQuantumToChar((Quantum) GetPixelAlpha(p)); p++; } } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToChar(GetPixelRed(p)); *q++=ScaleQuantumToChar(GetPixelGreen(p)); *q++=ScaleQuantumToChar(GetPixelBlue(p)); *q++=ScaleQuantumToChar((Quantum) 0); p++; } } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=ScaleQuantumToChar(GetPixelRed(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=ScaleQuantumToChar(GetPixelGreen(p)); break; } case BlueQuantum: case YellowQuantum: { *q=ScaleQuantumToChar(GetPixelBlue(p)); break; } case AlphaQuantum: { *q=ScaleQuantumToChar((Quantum) GetPixelAlpha(p)); break; } case OpacityQuantum: { *q=ScaleQuantumToChar(GetPixelOpacity(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=ScaleQuantumToChar(GetPixelIndex(indexes+x)); break; } case IndexQuantum: { *q=ScaleQuantumToChar(PixelIntensityToQuantum(image,p)); break; } default: break; } q++; } p++; } } } static void ExportDoublePixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,void *pixels, ExceptionInfo *exception) { register const IndexPacket *restrict indexes; register const PixelPacket *restrict p; register double *q; register ssize_t x; size_t length; ssize_t y; q=(double *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(double) (QuantumScale*GetPixelBlue(p)); *q++=(double) (QuantumScale*GetPixelGreen(p)); *q++=(double) (QuantumScale*GetPixelRed(p)); p++; } } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(double) (QuantumScale*GetPixelBlue(p)); *q++=(double) (QuantumScale*GetPixelGreen(p)); *q++=(double) (QuantumScale*GetPixelRed(p)); *q++=(double) (QuantumScale*((Quantum) (QuantumRange- GetPixelOpacity(p)))); p++; } } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(double) (QuantumScale*GetPixelBlue(p)); *q++=(double) (QuantumScale*GetPixelGreen(p)); *q++=(double) (QuantumScale*GetPixelRed(p)); *q++=0.0; p++; } } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(double) (QuantumScale*PixelIntensityToQuantum(image,p)); p++; } } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(double) (QuantumScale*GetPixelRed(p)); *q++=(double) (QuantumScale*GetPixelGreen(p)); *q++=(double) (QuantumScale*GetPixelBlue(p)); p++; } } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(double) (QuantumScale*GetPixelRed(p)); *q++=(double) (QuantumScale*GetPixelGreen(p)); *q++=(double) (QuantumScale*GetPixelBlue(p)); *q++=(double) (QuantumScale*((Quantum) (QuantumRange- GetPixelOpacity(p)))); p++; } } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(double) (QuantumScale*GetPixelRed(p)); *q++=(double) (QuantumScale*GetPixelGreen(p)); *q++=(double) (QuantumScale*GetPixelBlue(p)); *q++=0.0; p++; } } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=(double) (QuantumScale*GetPixelRed(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=(double) (QuantumScale*GetPixelGreen(p)); break; } case BlueQuantum: case YellowQuantum: { *q=(double) (QuantumScale*GetPixelBlue(p)); break; } case AlphaQuantum: { *q=(double) (QuantumScale*((Quantum) (QuantumRange- GetPixelOpacity(p)))); break; } case OpacityQuantum: { *q=(double) (QuantumScale*GetPixelOpacity(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=(double) (QuantumScale*GetPixelIndex(indexes+x)); break; } case IndexQuantum: { *q=(double) (QuantumScale*PixelIntensityToQuantum(image,p)); break; } default: *q=0; } q++; } p++; } } } static void ExportFloatPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,void *pixels, ExceptionInfo *exception) { register const IndexPacket *restrict indexes; register const PixelPacket *restrict p; register float *q; register ssize_t x; size_t length; ssize_t y; q=(float *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(float) (QuantumScale*GetPixelBlue(p)); *q++=(float) (QuantumScale*GetPixelGreen(p)); *q++=(float) (QuantumScale*GetPixelRed(p)); p++; } } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(float) (QuantumScale*GetPixelBlue(p)); *q++=(float) (QuantumScale*GetPixelGreen(p)); *q++=(float) (QuantumScale*GetPixelRed(p)); *q++=(float) (QuantumScale*GetPixelAlpha(p)); p++; } } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(float) (QuantumScale*GetPixelBlue(p)); *q++=(float) (QuantumScale*GetPixelGreen(p)); *q++=(float) (QuantumScale*GetPixelRed(p)); *q++=0.0; p++; } } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(float) (QuantumScale*PixelIntensityToQuantum(image,p)); p++; } } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(float) (QuantumScale*GetPixelRed(p)); *q++=(float) (QuantumScale*GetPixelGreen(p)); *q++=(float) (QuantumScale*GetPixelBlue(p)); p++; } } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(float) (QuantumScale*GetPixelRed(p)); *q++=(float) (QuantumScale*GetPixelGreen(p)); *q++=(float) (QuantumScale*GetPixelBlue(p)); *q++=(float) (QuantumScale*GetPixelAlpha(p)); p++; } } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(float) (QuantumScale*GetPixelRed(p)); *q++=(float) (QuantumScale*GetPixelGreen(p)); *q++=(float) (QuantumScale*GetPixelBlue(p)); *q++=0.0; p++; } } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=(float) (QuantumScale*GetPixelRed(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=(float) (QuantumScale*GetPixelGreen(p)); break; } case BlueQuantum: case YellowQuantum: { *q=(float) (QuantumScale*GetPixelBlue(p)); break; } case AlphaQuantum: { *q=(float) (QuantumScale*((Quantum) (GetPixelAlpha(p)))); break; } case OpacityQuantum: { *q=(float) (QuantumScale*GetPixelOpacity(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=(float) (QuantumScale*GetPixelIndex(indexes+x)); break; } case IndexQuantum: { *q=(float) (QuantumScale*PixelIntensityToQuantum(image,p)); break; } default: *q=0; } q++; } p++; } } } static void ExportIntegerPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,void *pixels, ExceptionInfo *exception) { register const IndexPacket *restrict indexes; register const PixelPacket *restrict p; register ssize_t x; register unsigned int *q; size_t length; ssize_t y; q=(unsigned int *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(p)); p++; } } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(p)); *q++=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange- GetPixelOpacity(p))); p++; } } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(p)); *q++=0U; p++; } } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(unsigned int) ScaleQuantumToLong(PixelIntensityToQuantum(image,p)); p++; } } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(p)); p++; } } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(p)); *q++=(unsigned int) ScaleQuantumToLong((Quantum) GetPixelAlpha(p)); p++; } } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetPixelRed(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelGreen(p)); *q++=(unsigned int) ScaleQuantumToLong(GetPixelBlue(p)); *q++=0U; p++; } } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=(unsigned int) ScaleQuantumToLong(GetPixelRed(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=(unsigned int) ScaleQuantumToLong(GetPixelGreen(p)); break; } case BlueQuantum: case YellowQuantum: { *q=(unsigned int) ScaleQuantumToLong(GetPixelBlue(p)); break; } case AlphaQuantum: { *q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange- GetPixelOpacity(p))); break; } case OpacityQuantum: { *q=(unsigned int) ScaleQuantumToLong(GetPixelOpacity(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=(unsigned int) ScaleQuantumToLong(GetPixelIndex(indexes+x)); break; } case IndexQuantum: { *q=(unsigned int) ScaleQuantumToLong(PixelIntensityToQuantum(image,p)); break; } default: *q=0; } q++; } p++; } } } static void ExportLongPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,void *pixels, ExceptionInfo *exception) { register const IndexPacket *restrict indexes; register const PixelPacket *restrict p; register unsigned int *q; register ssize_t x; size_t length; ssize_t y; q=(unsigned int *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToLong(GetPixelBlue(p)); *q++=ScaleQuantumToLong(GetPixelGreen(p)); *q++=ScaleQuantumToLong(GetPixelRed(p)); p++; } } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToLong(GetPixelBlue(p)); *q++=ScaleQuantumToLong(GetPixelGreen(p)); *q++=ScaleQuantumToLong(GetPixelRed(p)); *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p))); p++; } } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToLong(GetPixelBlue(p)); *q++=ScaleQuantumToLong(GetPixelGreen(p)); *q++=ScaleQuantumToLong(GetPixelRed(p)); *q++=0; p++; } } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToLong(PixelIntensityToQuantum(image,p)); p++; } } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToLong(GetPixelRed(p)); *q++=ScaleQuantumToLong(GetPixelGreen(p)); *q++=ScaleQuantumToLong(GetPixelBlue(p)); p++; } } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToLong(GetPixelRed(p)); *q++=ScaleQuantumToLong(GetPixelGreen(p)); *q++=ScaleQuantumToLong(GetPixelBlue(p)); *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p))); p++; } } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToLong(GetPixelRed(p)); *q++=ScaleQuantumToLong(GetPixelGreen(p)); *q++=ScaleQuantumToLong(GetPixelBlue(p)); *q++=0; p++; } } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=ScaleQuantumToLong(GetPixelRed(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=ScaleQuantumToLong(GetPixelGreen(p)); break; } case BlueQuantum: case YellowQuantum: { *q=ScaleQuantumToLong(GetPixelBlue(p)); break; } case AlphaQuantum: { *q=ScaleQuantumToLong((Quantum) GetPixelAlpha(p)); break; } case OpacityQuantum: { *q=ScaleQuantumToLong(GetPixelOpacity(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=ScaleQuantumToLong(GetPixelIndex(indexes+x)); break; } case IndexQuantum: { *q=ScaleQuantumToLong(PixelIntensityToQuantum(image,p)); break; } default: break; } q++; } p++; } } } static void ExportQuantumPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,void *pixels, ExceptionInfo *exception) { register const IndexPacket *restrict indexes; register const PixelPacket *restrict p; register Quantum *q; register ssize_t x; size_t length; ssize_t y; q=(Quantum *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=GetPixelBlue(p); *q++=GetPixelGreen(p); *q++=GetPixelRed(p); p++; } } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=GetPixelBlue(p); *q++=GetPixelGreen(p); *q++=GetPixelRed(p); *q++=(Quantum) GetPixelAlpha(p); p++; } } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=GetPixelBlue(p); *q++=GetPixelGreen(p); *q++=GetPixelRed(p); *q++=(Quantum) 0; p++; } } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=PixelIntensityToQuantum(image,p); p++; } } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=GetPixelRed(p); *q++=GetPixelGreen(p); *q++=GetPixelBlue(p); p++; } } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=GetPixelRed(p); *q++=GetPixelGreen(p); *q++=GetPixelBlue(p); *q++=(Quantum) GetPixelAlpha(p); p++; } } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=GetPixelRed(p); *q++=GetPixelGreen(p); *q++=GetPixelBlue(p); *q++=(Quantum) 0; p++; } } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { *q=(Quantum) 0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=GetPixelRed(p); break; } case GreenQuantum: case MagentaQuantum: { *q=GetPixelGreen(p); break; } case BlueQuantum: case YellowQuantum: { *q=GetPixelBlue(p); break; } case AlphaQuantum: { *q=(Quantum) (GetPixelAlpha(p)); break; } case OpacityQuantum: { *q=GetPixelOpacity(p); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=GetPixelIndex(indexes+x); break; } case IndexQuantum: { *q=(PixelIntensityToQuantum(image,p)); break; } default: { *q=(Quantum) 0; break; } } q++; } p++; } } } static void ExportShortPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,void *pixels, ExceptionInfo *exception) { register const IndexPacket *restrict indexes; register const PixelPacket *restrict p; register ssize_t x; register unsigned short *q; size_t length; ssize_t y; q=(unsigned short *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToShort(GetPixelBlue(p)); *q++=ScaleQuantumToShort(GetPixelGreen(p)); *q++=ScaleQuantumToShort(GetPixelRed(p)); p++; } } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToShort(GetPixelBlue(p)); *q++=ScaleQuantumToShort(GetPixelGreen(p)); *q++=ScaleQuantumToShort(GetPixelRed(p)); *q++=ScaleQuantumToShort((Quantum) GetPixelAlpha(p)); p++; } } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToShort(GetPixelBlue(p)); *q++=ScaleQuantumToShort(GetPixelGreen(p)); *q++=ScaleQuantumToShort(GetPixelRed(p)); *q++=0; p++; } } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToShort(PixelIntensityToQuantum(image,p)); p++; } } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToShort(GetPixelRed(p)); *q++=ScaleQuantumToShort(GetPixelGreen(p)); *q++=ScaleQuantumToShort(GetPixelBlue(p)); p++; } } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToShort(GetPixelRed(p)); *q++=ScaleQuantumToShort(GetPixelGreen(p)); *q++=ScaleQuantumToShort(GetPixelBlue(p)); *q++=ScaleQuantumToShort((Quantum) GetPixelAlpha(p)); p++; } } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { *q++=ScaleQuantumToShort(GetPixelRed(p)); *q++=ScaleQuantumToShort(GetPixelGreen(p)); *q++=ScaleQuantumToShort(GetPixelBlue(p)); *q++=0; p++; } } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=ScaleQuantumToShort(GetPixelRed(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=ScaleQuantumToShort(GetPixelGreen(p)); break; } case BlueQuantum: case YellowQuantum: { *q=ScaleQuantumToShort(GetPixelBlue(p)); break; } case AlphaQuantum: { *q=ScaleQuantumToShort((Quantum) (GetPixelAlpha(p))); break; } case OpacityQuantum: { *q=ScaleQuantumToShort(GetPixelOpacity(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=ScaleQuantumToShort(GetPixelIndex(indexes+x)); break; } case IndexQuantum: { *q=ScaleQuantumToShort(PixelIntensityToQuantum(image,p)); break; } default: break; } q++; } p++; } } } MagickExport MagickBooleanType ExportImagePixels(const Image *image, const ssize_t x,const ssize_t y,const size_t width,const size_t height, const char *map,const StorageType type,void *pixels,ExceptionInfo *exception) { QuantumType *quantum_map; RectangleInfo roi; register ssize_t i; size_t length; assert(image != (Image *) NULL); assert(image->signature == MagickSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); length=strlen(map); quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map)); if (quantum_map == (QuantumType *) NULL) { (void) ThrowMagickException(exception,GetMagickModule(), ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename); return(MagickFalse); } for (i=0; i < (ssize_t) length; i++) { switch (map[i]) { case 'A': case 'a': { quantum_map[i]=AlphaQuantum; break; } case 'B': case 'b': { quantum_map[i]=BlueQuantum; break; } case 'C': case 'c': { quantum_map[i]=CyanQuantum; if (image->colorspace == CMYKColorspace) break; quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); (void) ThrowMagickException(exception,GetMagickModule(),ImageError, "ColorSeparatedImageRequired","`%s'",map); return(MagickFalse); } case 'g': case 'G': { quantum_map[i]=GreenQuantum; break; } case 'I': case 'i': { quantum_map[i]=IndexQuantum; break; } case 'K': case 'k': { quantum_map[i]=BlackQuantum; if (image->colorspace == CMYKColorspace) break; quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); (void) ThrowMagickException(exception,GetMagickModule(),ImageError, "ColorSeparatedImageRequired","`%s'",map); return(MagickFalse); } case 'M': case 'm': { quantum_map[i]=MagentaQuantum; if (image->colorspace == CMYKColorspace) break; quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); (void) ThrowMagickException(exception,GetMagickModule(),ImageError, "ColorSeparatedImageRequired","`%s'",map); return(MagickFalse); } case 'o': case 'O': { quantum_map[i]=OpacityQuantum; break; } case 'P': case 'p': { quantum_map[i]=UndefinedQuantum; break; } case 'R': case 'r': { quantum_map[i]=RedQuantum; break; } case 'Y': case 'y': { quantum_map[i]=YellowQuantum; if (image->colorspace == CMYKColorspace) break; quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); (void) ThrowMagickException(exception,GetMagickModule(),ImageError, "ColorSeparatedImageRequired","`%s'",map); return(MagickFalse); } default: { quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); (void) ThrowMagickException(exception,GetMagickModule(),OptionError, "UnrecognizedPixelMap","`%s'",map); return(MagickFalse); } } } roi.width=width; roi.height=height; roi.x=x; roi.y=y; switch (type) { case CharPixel: { ExportCharPixel((Image *) image,&roi,map,quantum_map,pixels,exception); break; } case DoublePixel: { ExportDoublePixel((Image *) image,&roi,map,quantum_map,pixels,exception); break; } case FloatPixel: { ExportFloatPixel((Image *) image,&roi,map,quantum_map,pixels,exception); break; } case IntegerPixel: { ExportIntegerPixel((Image *) image,&roi,map,quantum_map,pixels,exception); break; } case LongPixel: { ExportLongPixel((Image *) image,&roi,map,quantum_map,pixels,exception); break; } case QuantumPixel: { ExportQuantumPixel((Image *) image,&roi,map,quantum_map,pixels,exception); break; } case ShortPixel: { ExportShortPixel((Image *) image,&roi,map,quantum_map,pixels,exception); break; } default: { quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); (void) ThrowMagickException(exception,GetMagickModule(),OptionError, "UnrecognizedPixelMap","`%s'",map); break; } } quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); return(MagickTrue); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % G e t M a g i c k P i x e l P a c k e t % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % GetMagickPixelPacket() initializes the MagickPixelPacket structure. % % The format of the GetMagickPixelPacket method is: % % GetMagickPixelPacket(const Image *image,MagickPixelPacket *pixel) % % A description of each parameter follows: % % o image: the image. % % o pixel: Specifies a pointer to a PixelPacket structure. % */ MagickExport void GetMagickPixelPacket(const Image *image, MagickPixelPacket *pixel) { pixel->storage_class=DirectClass; pixel->colorspace=sRGBColorspace; pixel->matte=MagickFalse; pixel->fuzz=0.0; pixel->depth=MAGICKCORE_QUANTUM_DEPTH; pixel->red=0.0; pixel->green=0.0; pixel->blue=0.0; pixel->opacity=(MagickRealType) OpaqueOpacity; pixel->index=0.0; if (image == (const Image *) NULL) return; pixel->storage_class=image->storage_class; pixel->colorspace=image->colorspace; pixel->matte=image->matte; pixel->depth=image->depth; pixel->fuzz=image->fuzz; } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % I m p o r t I m a g e P i x e l s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ImportImagePixels() accepts pixel data and stores in the image at the % location you specify. The method returns MagickTrue on success otherwise % MagickFalse if an error is encountered. The pixel data can be either char, % short int, unsigned int, unsigned long long, float, or double in the order % specified by map. % % Suppose your want to upload the first scanline of a 640x480 image from % character data in red-green-blue order: % % ImportImagePixels(image,0,0,640,1,"RGB",CharPixel,pixels); % % The format of the ImportImagePixels method is: % % MagickBooleanType ImportImagePixels(Image *image,const ssize_t x, % const ssize_t y,const size_t width,const size_t height, % const char *map,const StorageType type,const void *pixels) % % A description of each parameter follows: % % o image: the image. % % o x,y,width,height: These values define the perimeter of a region of % pixels you want to define. % % o map: This string reflects the expected ordering of the pixel array. % It can be any combination or order of R = red, G = green, B = blue, % A = alpha (0 is transparent), O = opacity (0 is opaque), C = cyan, % Y = yellow, M = magenta, K = black, I = intensity (for grayscale), % P = pad. % % o type: Define the data type of the pixels. Float and double types are % normalized to [0..1] otherwise [0..QuantumRange]. Choose from these % types: CharPixel (char *), DoublePixel (double *), FloatPixel (float *), % LongPixel (unsigned int *), QuantumPixel (Quantum *), or ShortPixel % (unsigned short *). % % o pixels: This array of values contain the pixel components as defined by % map and type. You must preallocate this array where the expected % length varies depending on the values of width, height, map, and type. % */ static void ImportCharPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,const void *pixels, ExceptionInfo *exception) { register const unsigned char *restrict p; register IndexPacket *restrict indexes; register PixelPacket *restrict q; register ssize_t x; size_t length; ssize_t y; p=(const unsigned char *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,ScaleCharToQuantum(*p++)); SetPixelRed(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,ScaleCharToQuantum(*p++)); SetPixelRed(q,ScaleCharToQuantum(*p++)); SetPixelAlpha(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRO") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,ScaleCharToQuantum(*p++)); SetPixelRed(q,ScaleCharToQuantum(*p++)); SetPixelOpacity(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,ScaleCharToQuantum(*p++)); SetPixelRed(q,ScaleCharToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,ScaleCharToQuantum(*p++)); SetPixelBlue(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,ScaleCharToQuantum(*p++)); SetPixelBlue(q,ScaleCharToQuantum(*p++)); SetPixelAlpha(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBO") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,ScaleCharToQuantum(*p++)); SetPixelBlue(q,ScaleCharToQuantum(*p++)); SetPixelOpacity(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleCharToQuantum(*p++)); SetPixelGreen(q,ScaleCharToQuantum(*p++)); SetPixelBlue(q,ScaleCharToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetPixelRed(q,ScaleCharToQuantum(*p)); break; } case GreenQuantum: case MagentaQuantum: { SetPixelGreen(q,ScaleCharToQuantum(*p)); break; } case BlueQuantum: case YellowQuantum: { SetPixelBlue(q,ScaleCharToQuantum(*p)); break; } case AlphaQuantum: { SetPixelAlpha(q,ScaleCharToQuantum(*p)); break; } case OpacityQuantum: { SetPixelOpacity(q,ScaleCharToQuantum(*p)); break; } case BlackQuantum: { SetPixelIndex(indexes+x,ScaleCharToQuantum(*p)); break; } case IndexQuantum: { SetPixelRed(q,ScaleCharToQuantum(*p)); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } } static void ImportDoublePixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,const void *pixels, ExceptionInfo *exception) { register const double *restrict p; register IndexPacket *restrict indexes; register PixelPacket *restrict q; register ssize_t x; size_t length; ssize_t y; p=(const double *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q->opacity=QuantumRange-ClampToQuantum((MagickRealType) QuantumRange*(*p)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case GreenQuantum: case MagentaQuantum: { SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case BlueQuantum: case YellowQuantum: { SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case AlphaQuantum: { SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case OpacityQuantum: { SetPixelOpacity(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case BlackQuantum: { SetPixelIndex(indexes+x,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case IndexQuantum: { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } } static void ImportFloatPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,const void *pixels, ExceptionInfo *exception) { register const float *restrict p; register IndexPacket *restrict indexes; register PixelPacket *restrict q; register ssize_t x; size_t length; ssize_t y; p=(const float *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case GreenQuantum: case MagentaQuantum: { SetPixelGreen(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case BlueQuantum: case YellowQuantum: { SetPixelBlue(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case AlphaQuantum: { SetPixelAlpha(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case OpacityQuantum: { SetPixelOpacity(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case BlackQuantum: { SetPixelIndex(indexes+x,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case IndexQuantum: { SetPixelRed(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } } static void ImportIntegerPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,const void *pixels, ExceptionInfo *exception) { register const unsigned int *restrict p; register IndexPacket *restrict indexes; register PixelPacket *restrict q; register ssize_t x; size_t length; ssize_t y; p=(const unsigned int *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelRed(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelAlpha(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelRed(q,ScaleLongToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelBlue(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelBlue(q,ScaleLongToQuantum(*p++)); SetPixelAlpha(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelBlue(q,ScaleLongToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetPixelRed(q,ScaleLongToQuantum(*p)); break; } case GreenQuantum: case MagentaQuantum: { SetPixelGreen(q,ScaleLongToQuantum(*p)); break; } case BlueQuantum: case YellowQuantum: { SetPixelBlue(q,ScaleLongToQuantum(*p)); break; } case AlphaQuantum: { SetPixelAlpha(q,ScaleLongToQuantum(*p)); break; } case OpacityQuantum: { SetPixelOpacity(q,ScaleLongToQuantum(*p)); break; } case BlackQuantum: { SetPixelIndex(indexes+x,ScaleLongToQuantum(*p)); break; } case IndexQuantum: { SetPixelRed(q,ScaleLongToQuantum(*p)); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } } static void ImportLongPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,const void *pixels, ExceptionInfo *exception) { register const unsigned int *restrict p; register IndexPacket *restrict indexes; register PixelPacket *restrict q; register ssize_t x; size_t length; ssize_t y; p=(const unsigned int *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelRed(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelAlpha(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelRed(q,ScaleLongToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelBlue(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelBlue(q,ScaleLongToQuantum(*p++)); SetPixelAlpha(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleLongToQuantum(*p++)); SetPixelGreen(q,ScaleLongToQuantum(*p++)); SetPixelBlue(q,ScaleLongToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetPixelRed(q,ScaleLongToQuantum(*p)); break; } case GreenQuantum: case MagentaQuantum: { SetPixelGreen(q,ScaleLongToQuantum(*p)); break; } case BlueQuantum: case YellowQuantum: { SetPixelBlue(q,ScaleLongToQuantum(*p)); break; } case AlphaQuantum: { SetPixelAlpha(q,ScaleLongToQuantum(*p)); break; } case OpacityQuantum: { SetPixelOpacity(q,ScaleLongToQuantum(*p)); break; } case BlackQuantum: { SetPixelIndex(indexes+x,ScaleLongToQuantum(*p)); break; } case IndexQuantum: { SetPixelRed(q,ScaleLongToQuantum(*p)); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } } static void ImportQuantumPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,const void *pixels, ExceptionInfo *exception) { register const Quantum *restrict p; register IndexPacket *restrict indexes; register PixelPacket *restrict q; register ssize_t x; size_t length; ssize_t y; p=(const Quantum *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,*p++); SetPixelGreen(q,*p++); SetPixelRed(q,*p++); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,*p++); SetPixelGreen(q,*p++); SetPixelRed(q,*p++); SetPixelAlpha(q,*p++); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,*p++); SetPixelGreen(q,*p++); SetPixelRed(q,*p++); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,*p++); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,*p++); SetPixelGreen(q,*p++); SetPixelBlue(q,*p++); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,*p++); SetPixelGreen(q,*p++); SetPixelBlue(q,*p++); SetPixelAlpha(q,*p++); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,*p++); SetPixelGreen(q,*p++); SetPixelBlue(q,*p++); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetPixelRed(q,*p); break; } case GreenQuantum: case MagentaQuantum: { SetPixelGreen(q,*p); break; } case BlueQuantum: case YellowQuantum: { SetPixelBlue(q,*p); break; } case AlphaQuantum: { SetPixelAlpha(q,*p); break; } case OpacityQuantum: { SetPixelOpacity(q,*p); break; } case BlackQuantum: { SetPixelIndex(indexes+x,*p); break; } case IndexQuantum: { SetPixelRed(q,*p); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } } static void ImportShortPixel(Image *image,const RectangleInfo *roi, const char *restrict map,const QuantumType *quantum_map,const void *pixels, ExceptionInfo *exception) { register const unsigned short *restrict p; register IndexPacket *restrict indexes; register PixelPacket *restrict q; register ssize_t x; size_t length; ssize_t y; p=(const unsigned short *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleShortToQuantum(*p++)); SetPixelGreen(q,ScaleShortToQuantum(*p++)); SetPixelRed(q,ScaleShortToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleShortToQuantum(*p++)); SetPixelGreen(q,ScaleShortToQuantum(*p++)); SetPixelRed(q,ScaleShortToQuantum(*p++)); SetPixelAlpha(q,ScaleShortToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelBlue(q,ScaleShortToQuantum(*p++)); SetPixelGreen(q,ScaleShortToQuantum(*p++)); SetPixelRed(q,ScaleShortToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleShortToQuantum(*p++)); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleShortToQuantum(*p++)); SetPixelGreen(q,ScaleShortToQuantum(*p++)); SetPixelBlue(q,ScaleShortToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleShortToQuantum(*p++)); SetPixelGreen(q,ScaleShortToQuantum(*p++)); SetPixelBlue(q,ScaleShortToQuantum(*p++)); SetPixelAlpha(q,ScaleShortToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) roi->width; x++) { SetPixelRed(q,ScaleShortToQuantum(*p++)); SetPixelGreen(q,ScaleShortToQuantum(*p++)); SetPixelBlue(q,ScaleShortToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } return; } length=strlen(map); for (y=0; y < (ssize_t) roi->height; y++) { q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) roi->width; x++) { register ssize_t i; for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetPixelRed(q,ScaleShortToQuantum(*p)); break; } case GreenQuantum: case MagentaQuantum: { SetPixelGreen(q,ScaleShortToQuantum(*p)); break; } case BlueQuantum: case YellowQuantum: { SetPixelBlue(q,ScaleShortToQuantum(*p)); break; } case AlphaQuantum: { SetPixelAlpha(q,ScaleShortToQuantum(*p)); break; } case OpacityQuantum: { SetPixelOpacity(q,ScaleShortToQuantum(*p)); break; } case BlackQuantum: { SetPixelIndex(indexes+x,ScaleShortToQuantum(*p)); break; } case IndexQuantum: { SetPixelRed(q,ScaleShortToQuantum(*p)); SetPixelGreen(q,GetPixelRed(q)); SetPixelBlue(q,GetPixelRed(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } } MagickExport MagickBooleanType ImportImagePixels(Image *image,const ssize_t x, const ssize_t y,const size_t width,const size_t height,const char *map, const StorageType type,const void *pixels) { ExceptionInfo *exception; QuantumType *quantum_map; RectangleInfo roi; register ssize_t i; size_t length; /* Allocate image structure. */ assert(image != (Image *) NULL); assert(image->signature == MagickSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); length=strlen(map); quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map)); if (quantum_map == (QuantumType *) NULL) ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed", image->filename); for (i=0; i < (ssize_t) length; i++) { switch (map[i]) { case 'a': case 'A': { quantum_map[i]=AlphaQuantum; image->matte=MagickTrue; break; } case 'B': case 'b': { quantum_map[i]=BlueQuantum; break; } case 'C': case 'c': { quantum_map[i]=CyanQuantum; (void) SetImageColorspace(image,CMYKColorspace); break; } case 'g': case 'G': { quantum_map[i]=GreenQuantum; break; } case 'K': case 'k': { quantum_map[i]=BlackQuantum; (void) SetImageColorspace(image,CMYKColorspace); break; } case 'I': case 'i': { quantum_map[i]=IndexQuantum; (void) SetImageColorspace(image,GRAYColorspace); break; } case 'm': case 'M': { quantum_map[i]=MagentaQuantum; (void) SetImageColorspace(image,CMYKColorspace); break; } case 'O': case 'o': { quantum_map[i]=OpacityQuantum; image->matte=MagickTrue; break; } case 'P': case 'p': { quantum_map[i]=UndefinedQuantum; break; } case 'R': case 'r': { quantum_map[i]=RedQuantum; break; } case 'Y': case 'y': { quantum_map[i]=YellowQuantum; (void) SetImageColorspace(image,CMYKColorspace); break; } default: { quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); (void) ThrowMagickException(&image->exception,GetMagickModule(), OptionError,"UnrecognizedPixelMap","`%s'",map); return(MagickFalse); } } } if (SetImageStorageClass(image,DirectClass) == MagickFalse) return(MagickFalse); /* Transfer the pixels from the pixel datarray to the image. */ exception=(&image->exception); roi.width=width; roi.height=height; roi.x=x; roi.y=y; switch (type) { case CharPixel: { ImportCharPixel(image,&roi,map,quantum_map,pixels,exception); break; } case DoublePixel: { ImportDoublePixel(image,&roi,map,quantum_map,pixels,exception); break; } case FloatPixel: { ImportFloatPixel(image,&roi,map,quantum_map,pixels,exception); break; } case IntegerPixel: { ImportIntegerPixel(image,&roi,map,quantum_map,pixels,exception); break; } case LongPixel: { ImportLongPixel(image,&roi,map,quantum_map,pixels,exception); break; } case QuantumPixel: { ImportQuantumPixel(image,&roi,map,quantum_map,pixels,exception); break; } case ShortPixel: { ImportShortPixel(image,&roi,map,quantum_map,pixels,exception); break; } default: { quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); (void) ThrowMagickException(&image->exception,GetMagickModule(), OptionError,"UnrecognizedPixelMap","`%s'",map); break; } } quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map); return(MagickTrue); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % I n t e r p o l a t e M a g i c k P i x e l P a c k e t % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % InterpolateMagickPixelPacket() applies bi-linear or tri-linear interpolation % between a floating point coordinate and the pixels surrounding that % coordinate. No pixel area resampling, or scaling of the result is % performed. % % The format of the InterpolateMagickPixelPacket method is: % % MagickBooleanType InterpolateMagickPixelPacket(const Image *image, % const CacheView *image_view,const InterpolatePixelMethod method, % const double x,const double y,MagickPixelPacket *pixel, % ExceptionInfo *exception) % % A description of each parameter follows: % % o image: the image. % % o image_view: the image view. % % o method: the pixel color interpolation method. % % o x,y: A double representing the current (x,y) position of the pixel. % % o pixel: return the interpolated pixel here. % % o exception: return any errors or warnings in this structure. % */ /* Prepare pixels for weighted alpha blending. Save PixelPacket/IndexPacket 'color'/'index' into 'pixel'/'alpha' after multiplying colors by alpha. */ static inline void AlphaBlendMagickPixelPacket(const Image *image, const PixelPacket *color,const IndexPacket *indexes,MagickPixelPacket *pixel, MagickRealType *alpha) { if (image->matte == MagickFalse) { *alpha=1.0; pixel->red=(MagickRealType) GetPixelRed(color); pixel->green=(MagickRealType) GetPixelGreen(color); pixel->blue=(MagickRealType) GetPixelBlue(color); pixel->opacity=(MagickRealType) GetPixelOpacity(color); pixel->index=0.0; if (((image->colorspace == CMYKColorspace) || (image->storage_class == PseudoClass)) && (indexes != (const IndexPacket *) NULL)) pixel->index=(MagickRealType) GetPixelIndex(indexes); return; } *alpha=QuantumScale*GetPixelAlpha(color); pixel->red=(*alpha*GetPixelRed(color)); pixel->green=(*alpha*GetPixelGreen(color)); pixel->blue=(*alpha*GetPixelBlue(color)); pixel->opacity=(MagickRealType) GetPixelOpacity(color); pixel->index=0.0; if (((image->colorspace == CMYKColorspace) || (image->storage_class == PseudoClass)) && (indexes != (const IndexPacket *) NULL)) pixel->index=(*alpha*GetPixelIndex(indexes)); } static inline double MagickMax(const MagickRealType x,const MagickRealType y) { if (x > y) return(x); return(y); } static inline void CatromWeights(const MagickRealType x, MagickRealType (*weights)[4]) { /* Nicolas Robidoux' 10 flops (4* + 5- + 1+) refactoring of the computation of the standard four 1D Catmull-Rom weights. The sampling location is assumed between the second and third input pixel locations, and x is the position relative to the second input pixel location. Formulas originally derived for the VIPS (Virtual Image Processing System) library. */ MagickRealType alpha, beta, gamma; alpha=(MagickRealType) 1.0-x; beta=(MagickRealType) (-0.5)*x*alpha; (*weights)[0]=alpha*beta; (*weights)[3]=x*beta; /* The following computation of the inner weights from the outer ones works for all Keys cubics. */ gamma=(*weights)[3]-(*weights)[0]; (*weights)[1]=alpha-(*weights)[0]+gamma; (*weights)[2]=x-(*weights)[3]-gamma; } static inline void SplineWeights(const MagickRealType x, MagickRealType (*weights)[4]) { /* Nicolas Robidoux' 12 flops (6* + 5- + 1+) refactoring of the computation of the standard four 1D cubic B-spline smoothing weights. The sampling location is assumed between the second and third input pixel locations, and x is the position relative to the second input pixel location. */ MagickRealType alpha, beta; alpha=(MagickRealType) 1.0-x; (*weights)[3]=(MagickRealType) (1.0/6.0)*x*x*x; (*weights)[0]=(MagickRealType) (1.0/6.0)*alpha*alpha*alpha; beta=(*weights)[3]-(*weights)[0]; (*weights)[1]=alpha-(*weights)[0]+beta; (*weights)[2]=x-(*weights)[3]-beta; } static inline double MeshInterpolate(const PointInfo *delta,const double p, const double x,const double y) { return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p); } MagickExport MagickBooleanType InterpolateMagickPixelPacket(const Image *image, const CacheView *image_view,const InterpolatePixelMethod method, const double x,const double y,MagickPixelPacket *pixel, ExceptionInfo *exception) { double gamma; MagickBooleanType status; MagickPixelPacket pixels[16]; MagickRealType alpha[16]; register const IndexPacket *indexes; register const PixelPacket *p; register ssize_t i; ssize_t x_offset, y_offset; InterpolatePixelMethod interpolate; assert(image != (Image *) NULL); assert(image->signature == MagickSignature); assert(image_view != (CacheView *) NULL); status=MagickTrue; x_offset=(ssize_t) floor(x); y_offset=(ssize_t) floor(y); interpolate = method; if ( interpolate == UndefinedInterpolatePixel ) interpolate = image->interpolate; switch (interpolate) { case AverageInterpolatePixel: /* nearest 4 neighbours */ case Average9InterpolatePixel: /* nearest 9 neighbours */ case Average16InterpolatePixel: /* nearest 16 neighbours */ { ssize_t count; count=2; /* size of the area to average - default nearest 4 */ if (interpolate == Average9InterpolatePixel) { count=3; x_offset=(ssize_t) (floor(x+0.5)-1); y_offset=(ssize_t) (floor(y+0.5)-1); } else if (interpolate == Average16InterpolatePixel) { count=4; x_offset--; y_offset--; } p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(size_t) count, (size_t) count,exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); pixel->red=0.0; pixel->green=0.0; pixel->blue=0.0; pixel->opacity=0.0; pixel->index=0.0; count*=count; /* number of pixels - square of size */ for (i=0; i < (ssize_t) count; i++) { AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels,alpha); gamma=PerceptibleReciprocal(alpha[0]); pixel->red+=gamma*pixels[0].red; pixel->green+=gamma*pixels[0].green; pixel->blue+=gamma*pixels[0].blue; pixel->index+=gamma*pixels[0].index; pixel->opacity+=pixels[0].opacity; } gamma=1.0/count; /* average weighting of each pixel in area */ pixel->red*=gamma; pixel->green*=gamma; pixel->blue*=gamma; pixel->index*=gamma; pixel->opacity*=gamma; break; } case BackgroundInterpolatePixel: { IndexPacket index; index=0; /* CMYK index -- What should we do? -- This is a HACK */ SetMagickPixelPacket(image,&image->background_color,&index,pixel); break; } case BilinearInterpolatePixel: default: { PointInfo delta, epsilon; p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); for (i=0; i < 4L; i++) AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i); delta.x=x-x_offset; delta.y=y-y_offset; epsilon.x=1.0-delta.x; epsilon.y=1.0-delta.y; gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y* (epsilon.x*alpha[2]+delta.x*alpha[3]))); gamma=PerceptibleReciprocal(gamma); pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x* pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red)); pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x* pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x* pixels[3].green)); pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x* pixels[1].blue)+delta.y*(epsilon.x*pixels[2].blue+delta.x* pixels[3].blue)); if (image->colorspace == CMYKColorspace) pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x* pixels[1].index)+delta.y*(epsilon.x*pixels[2].index+delta.x* pixels[3].index)); gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x))); gamma=PerceptibleReciprocal(gamma); pixel->opacity=(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x* pixels[1].opacity)+delta.y*(epsilon.x*pixels[2].opacity+delta.x* pixels[3].opacity)); break; } case BlendInterpolatePixel: { p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); for (i=0; i < 4L; i++) AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i); gamma=1.0; /* number of pixels blended together */ for (i=0; i <= 1L; i++) { if ((y-y_offset) >= 0.75) { alpha[i]=alpha[i+2]; pixels[i]=pixels[i+2]; } else if ((y-y_offset) > 0.25) { gamma=2.0; /* each y pixels have been blended */ alpha[i]+=alpha[i+2]; /* add up alpha weights */ pixels[i].red+=pixels[i+2].red; pixels[i].green+=pixels[i+2].green; pixels[i].blue+=pixels[i+2].blue; pixels[i].opacity+=pixels[i+2].opacity; pixels[i].index+=pixels[i+2].index; } } if ((x-x_offset) >= 0.75 ) { alpha[0]=alpha[1]; pixels[0]=pixels[1]; } else if ((x-x_offset) > 0.25 ) { gamma*=2.0; /* double number of pixels blended */ alpha[0]+=alpha[1]; /* add up alpha weights */ pixels[0].red+=pixels[1].red; pixels[0].green+=pixels[1].green; pixels[0].blue+=pixels[1].blue; pixels[0].opacity+=pixels[1].opacity; pixels[0].index+=pixels[1].index; } gamma=1.0/gamma; /* 1/sum(pixels) */ alpha[0]=PerceptibleReciprocal(alpha[0]); /* 1/sum(alpha) */ pixel->red=alpha[0]*pixels[0].red; pixel->green=alpha[0]*pixels[0].green; /* divide by sum of alpha */ pixel->blue=alpha[0]*pixels[0].blue; pixel->index=alpha[0]*pixels[0].index; pixel->opacity=gamma*pixels[0].opacity; /* divide by number pixels */ break; } case CatromInterpolatePixel: case BicubicInterpolatePixel: /* deprecated method */ { MagickRealType cx[4], cy[4]; p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4, exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); for (i=0; i < 16L; i++) AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i); CatromWeights((MagickRealType) (x-x_offset),&cx); CatromWeights((MagickRealType) (y-y_offset),&cy); pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]* pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]* pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]* pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]* pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]* pixels[14].red+cx[3]*pixels[15].red)); pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]* pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+ cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+ cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]* pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+ cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green)); pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*pixels[1].blue+cx[2]* pixels[2].blue+cx[3]*pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]* pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*pixels[7].blue)+cy[2]*(cx[0]* pixels[8].blue+cx[1]*pixels[9].blue+cx[2]*pixels[10].blue+cx[3]* pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*pixels[13].blue+ cx[2]*pixels[14].blue+cx[3]*pixels[15].blue)); pixel->opacity=(cy[0]*(cx[0]*pixels[0].opacity+cx[1]*pixels[1].opacity+ cx[2]*pixels[2].opacity+cx[3]*pixels[3].opacity)+cy[1]*(cx[0]* pixels[4].opacity+cx[1]*pixels[5].opacity+cx[2]*pixels[6].opacity+ cx[3]*pixels[7].opacity)+cy[2]*(cx[0]*pixels[8].opacity+cx[1]* pixels[9].opacity+cx[2]*pixels[10].opacity+cx[3]*pixels[11].opacity)+ cy[3]*(cx[0]*pixels[12].opacity+cx[1]*pixels[13].opacity+cx[2]* pixels[14].opacity+cx[3]*pixels[15].opacity)); break; } case FilterInterpolatePixel: { CacheView *filter_view; Image *excerpt_image, *filter_image; RectangleInfo geometry; /* Use a normal resize filter: warning this is slow due to setup time a cache should be initialised on first call, and replaced if 'filter' changes. */ geometry.width=4L; geometry.height=4L; geometry.x=x_offset-1; geometry.y=y_offset-1; excerpt_image=ExcerptImage(image,&geometry,exception); if (excerpt_image == (Image *) NULL) { status=MagickFalse; break; } filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur, exception); excerpt_image=DestroyImage(excerpt_image); if (filter_image == (Image *) NULL) break; filter_view=AcquireVirtualCacheView(filter_image,exception); p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception); if (p != (const PixelPacket *) NULL) { indexes=GetVirtualIndexQueue(filter_image); SetMagickPixelPacket(image,p,indexes,pixel); } filter_view=DestroyCacheView(filter_view); filter_image=DestroyImage(filter_image); break; } case IntegerInterpolatePixel: { p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); SetMagickPixelPacket(image,p,indexes,pixel); break; } case MeshInterpolatePixel: { PointInfo delta, luminance; p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2, exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); for (i=0; i < 4L; i++) AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i); delta.x=x-x_offset; delta.y=y-y_offset; luminance.x=fabs(MagickPixelLuminance(pixels+0)- MagickPixelLuminance(pixels+3)); luminance.y=fabs(MagickPixelLuminance(pixels+1)- MagickPixelLuminance(pixels+2)); if (luminance.x < luminance.y) { /* Diagonal 0-3 NW-SE. */ if (delta.x <= delta.y) { /* Bottom-left triangle (pixel:2, diagonal: 0-3). */ delta.y=1.0-delta.y; gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]); gamma=PerceptibleReciprocal(gamma); pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red, pixels[3].red,pixels[0].red); pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green, pixels[3].green,pixels[0].green); pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue, pixels[3].blue,pixels[0].blue); if (image->colorspace == CMYKColorspace) pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index, pixels[3].index,pixels[0].index); gamma=MeshInterpolate(&delta,1.0,1.0,1.0); pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity, pixels[3].opacity,pixels[0].opacity); } else { /* Top-right triangle (pixel:1, diagonal: 0-3). */ delta.x=1.0-delta.x; gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]); gamma=PerceptibleReciprocal(gamma); pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red, pixels[0].red,pixels[3].red); pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green, pixels[0].green,pixels[3].green); pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue, pixels[0].blue,pixels[3].blue); if (image->colorspace == CMYKColorspace) pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index, pixels[0].index,pixels[3].index); gamma=MeshInterpolate(&delta,1.0,1.0,1.0); pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity, pixels[0].opacity,pixels[3].opacity); } } else { /* Diagonal 1-2 NE-SW. */ if (delta.x <= (1.0-delta.y)) { /* Top-left triangle (pixel: 0, diagonal: 1-2). */ gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]); gamma=PerceptibleReciprocal(gamma); pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red, pixels[1].red,pixels[2].red); pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green, pixels[1].green,pixels[2].green); pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue, pixels[1].blue,pixels[2].blue); if (image->colorspace == CMYKColorspace) pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index, pixels[1].index,pixels[2].index); gamma=MeshInterpolate(&delta,1.0,1.0,1.0); pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity, pixels[1].opacity,pixels[2].opacity); } else { /* Bottom-right triangle (pixel: 3, diagonal: 1-2). */ delta.x=1.0-delta.x; delta.y=1.0-delta.y; gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]); gamma=PerceptibleReciprocal(gamma); pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red, pixels[2].red,pixels[1].red); pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green, pixels[2].green,pixels[1].green); pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue, pixels[2].blue,pixels[1].blue); if (image->colorspace == CMYKColorspace) pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index, pixels[2].index,pixels[1].index); gamma=MeshInterpolate(&delta,1.0,1.0,1.0); pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity, pixels[2].opacity,pixels[1].opacity); } } break; } case NearestNeighborInterpolatePixel: { p=GetCacheViewVirtualPixels(image_view,(ssize_t) floor(x+0.5), (ssize_t) floor(y+0.5),1,1,exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); SetMagickPixelPacket(image,p,indexes,pixel); break; } case SplineInterpolatePixel: { MagickRealType cx[4], cy[4]; p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4, exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); for (i=0; i < 16L; i++) AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i); SplineWeights((MagickRealType) (x-x_offset),&cx); SplineWeights((MagickRealType) (y-y_offset),&cy); pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]* pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]* pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]* pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]* pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]* pixels[14].red+cx[3]*pixels[15].red)); pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]* pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+ cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+ cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]* pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+ cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green)); pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*pixels[1].blue+cx[2]* pixels[2].blue+cx[3]*pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]* pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*pixels[7].blue)+cy[2]*(cx[0]* pixels[8].blue+cx[1]*pixels[9].blue+cx[2]*pixels[10].blue+cx[3]* pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*pixels[13].blue+ cx[2]*pixels[14].blue+cx[3]*pixels[15].blue)); pixel->opacity=(cy[0]*(cx[0]*pixels[0].opacity+cx[1]*pixels[1].opacity+ cx[2]*pixels[2].opacity+cx[3]*pixels[3].opacity)+cy[1]*(cx[0]* pixels[4].opacity+cx[1]*pixels[5].opacity+cx[2]*pixels[6].opacity+cx[3]* pixels[7].opacity)+cy[2]*(cx[0]*pixels[8].opacity+cx[1]* pixels[9].opacity+cx[2]*pixels[10].opacity+cx[3]*pixels[11].opacity)+ cy[3]*(cx[0]*pixels[12].opacity+cx[1]*pixels[13].opacity+cx[2]* pixels[14].opacity+cx[3]*pixels[15].opacity)); break; } } return(status); }