/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % 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-2011 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/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" /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % 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, int, ssize_t, 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_offset,const ssize_t y_offset,const size_t columns, % const size_t rows,const char *map,const StorageType type, % void *pixels,ExceptionInfo *exception) % % A description of each parameter follows: % % o image: the image. % % o x_offset,y_offset,columns,rows: 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, DoublePixel, FloatPixel, IntegerPixel, LongPixel, % QuantumPixel, or ShortPixel. % % 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. % */ MagickExport MagickBooleanType ExportImagePixels(const Image *image, const ssize_t x_offset,const ssize_t y_offset,const size_t columns, const size_t rows,const char *map,const StorageType type,void *pixels, ExceptionInfo *exception) { QuantumType *quantum_map; register ssize_t i, x; register const IndexPacket *indexes; register const PixelPacket *p; size_t length; ssize_t y; 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); } } } switch (type) { case CharPixel: { register unsigned char *q; q=(unsigned char *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToChar(GetBluePixelComponent(p)); *q++=ScaleQuantumToChar(GetGreenPixelComponent(p)); *q++=ScaleQuantumToChar(GetRedPixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToChar(GetBluePixelComponent(p)); *q++=ScaleQuantumToChar(GetGreenPixelComponent(p)); *q++=ScaleQuantumToChar(GetRedPixelComponent(p)); *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToChar(GetBluePixelComponent(p)); *q++=ScaleQuantumToChar(GetGreenPixelComponent(p)); *q++=ScaleQuantumToChar(GetRedPixelComponent(p)); *q++=ScaleQuantumToChar((Quantum) 0); p++; } } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToChar(PixelIntensityToQuantum(p)); p++; } } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToChar(GetRedPixelComponent(p)); *q++=ScaleQuantumToChar(GetGreenPixelComponent(p)); *q++=ScaleQuantumToChar(GetBluePixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToChar(GetRedPixelComponent(p)); *q++=ScaleQuantumToChar(GetGreenPixelComponent(p)); *q++=ScaleQuantumToChar(GetBluePixelComponent(p)); *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToChar(GetRedPixelComponent(p)); *q++=ScaleQuantumToChar(GetGreenPixelComponent(p)); *q++=ScaleQuantumToChar(GetBluePixelComponent(p)); *q++=ScaleQuantumToChar((Quantum) 0); p++; } } break; } for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=ScaleQuantumToChar(GetRedPixelComponent(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=ScaleQuantumToChar(GetGreenPixelComponent(p)); break; } case BlueQuantum: case YellowQuantum: { *q=ScaleQuantumToChar(GetBluePixelComponent(p)); break; } case AlphaQuantum: { *q=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p))); break; } case OpacityQuantum: { *q=ScaleQuantumToChar(GetOpacityPixelComponent(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x)); break; } case IndexQuantum: { *q=ScaleQuantumToChar(PixelIntensityToQuantum(p)); break; } default: break; } q++; } p++; } } break; } case DoublePixel: { register double *q; q=(double *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(double) (QuantumScale*GetBluePixelComponent(p)); *q++=(double) (QuantumScale*GetGreenPixelComponent(p)); *q++=(double) (QuantumScale*GetRedPixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(double) (QuantumScale*GetBluePixelComponent(p)); *q++=(double) (QuantumScale*GetGreenPixelComponent(p)); *q++=(double) (QuantumScale*GetRedPixelComponent(p)); *q++=(double) (QuantumScale*((Quantum) (QuantumRange- GetOpacityPixelComponent(p)))); p++; } } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(double) (QuantumScale*GetBluePixelComponent(p)); *q++=(double) (QuantumScale*GetGreenPixelComponent(p)); *q++=(double) (QuantumScale*GetRedPixelComponent(p)); *q++=0.0; p++; } } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(double) (QuantumScale*PixelIntensityToQuantum(p)); p++; } } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(double) (QuantumScale*GetRedPixelComponent(p)); *q++=(double) (QuantumScale*GetGreenPixelComponent(p)); *q++=(double) (QuantumScale*GetBluePixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(double) (QuantumScale*GetRedPixelComponent(p)); *q++=(double) (QuantumScale*GetGreenPixelComponent(p)); *q++=(double) (QuantumScale*GetBluePixelComponent(p)); *q++=(double) (QuantumScale*((Quantum) (QuantumRange- GetOpacityPixelComponent(p)))); p++; } } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(double) (QuantumScale*GetRedPixelComponent(p)); *q++=(double) (QuantumScale*GetGreenPixelComponent(p)); *q++=(double) (QuantumScale*GetBluePixelComponent(p)); *q++=0.0; p++; } } break; } for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=(double) (QuantumScale*GetRedPixelComponent(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=(double) (QuantumScale*GetGreenPixelComponent(p)); break; } case BlueQuantum: case YellowQuantum: { *q=(double) (QuantumScale*GetBluePixelComponent(p)); break; } case AlphaQuantum: { *q=(double) (QuantumScale*((Quantum) (QuantumRange- GetOpacityPixelComponent(p)))); break; } case OpacityQuantum: { *q=(double) (QuantumScale*GetOpacityPixelComponent(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=(double) (QuantumScale*GetIndexPixelComponent(indexes+x)); break; } case IndexQuantum: { *q=(double) (QuantumScale*PixelIntensityToQuantum(p)); break; } default: *q=0; } q++; } p++; } } break; } case FloatPixel: { register float *q; q=(float *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(float) (QuantumScale*GetBluePixelComponent(p)); *q++=(float) (QuantumScale*GetGreenPixelComponent(p)); *q++=(float) (QuantumScale*GetRedPixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(float) (QuantumScale*GetBluePixelComponent(p)); *q++=(float) (QuantumScale*GetGreenPixelComponent(p)); *q++=(float) (QuantumScale*GetRedPixelComponent(p)); *q++=(float) (QuantumScale*(Quantum) (GetAlphaPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(float) (QuantumScale*GetBluePixelComponent(p)); *q++=(float) (QuantumScale*GetGreenPixelComponent(p)); *q++=(float) (QuantumScale*GetRedPixelComponent(p)); *q++=0.0; p++; } } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(float) (QuantumScale*PixelIntensityToQuantum(p)); p++; } } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(float) (QuantumScale*GetRedPixelComponent(p)); *q++=(float) (QuantumScale*GetGreenPixelComponent(p)); *q++=(float) (QuantumScale*GetBluePixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(float) (QuantumScale*GetRedPixelComponent(p)); *q++=(float) (QuantumScale*GetGreenPixelComponent(p)); *q++=(float) (QuantumScale*GetBluePixelComponent(p)); *q++=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p)))); p++; } } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(float) (QuantumScale*GetRedPixelComponent(p)); *q++=(float) (QuantumScale*GetGreenPixelComponent(p)); *q++=(float) (QuantumScale*GetBluePixelComponent(p)); *q++=0.0; p++; } } break; } for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=(float) (QuantumScale*GetRedPixelComponent(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=(float) (QuantumScale*GetGreenPixelComponent(p)); break; } case BlueQuantum: case YellowQuantum: { *q=(float) (QuantumScale*GetBluePixelComponent(p)); break; } case AlphaQuantum: { *q=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p)))); break; } case OpacityQuantum: { *q=(float) (QuantumScale*GetOpacityPixelComponent(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=(float) (QuantumScale*GetIndexPixelComponent(indexes+x)); break; } case IndexQuantum: { *q=(float) (QuantumScale*PixelIntensityToQuantum(p)); break; } default: *q=0; } q++; } p++; } } break; } case IntegerPixel: { register unsigned int *q; q=(unsigned int *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange- GetOpacityPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=0U; p++; } } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(unsigned int) ScaleQuantumToLong(PixelIntensityToQuantum(p)); p++; } } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=0U; p++; } } break; } for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p)); break; } case BlueQuantum: case YellowQuantum: { *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p)); break; } case AlphaQuantum: { *q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange- GetOpacityPixelComponent(p))); break; } case OpacityQuantum: { *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=(unsigned int) ScaleQuantumToLong(GetIndexPixelComponent(indexes+x)); break; } case IndexQuantum: { *q=(unsigned int) ScaleQuantumToLong(PixelIntensityToQuantum(p)); break; } default: *q=0; } q++; } p++; } } break; } case LongPixel: { register size_t *q; q=(size_t *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=ScaleQuantumToLong(GetRedPixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=0; p++; } } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToLong(PixelIntensityToQuantum(p)); p++; } } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=ScaleQuantumToLong(GetBluePixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToLong(GetRedPixelComponent(p)); *q++=ScaleQuantumToLong(GetGreenPixelComponent(p)); *q++=ScaleQuantumToLong(GetBluePixelComponent(p)); *q++=0; p++; } } break; } for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=ScaleQuantumToLong(GetRedPixelComponent(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=ScaleQuantumToLong(GetGreenPixelComponent(p)); break; } case BlueQuantum: case YellowQuantum: { *q=ScaleQuantumToLong(GetBluePixelComponent(p)); break; } case AlphaQuantum: { *q=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p))); break; } case OpacityQuantum: { *q=ScaleQuantumToLong(GetOpacityPixelComponent(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=ScaleQuantumToLong(GetIndexPixelComponent(indexes+x)); break; } case IndexQuantum: { *q=ScaleQuantumToLong(PixelIntensityToQuantum(p)); break; } default: break; } q++; } p++; } } break; } case QuantumPixel: { register Quantum *q; q=(Quantum *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=GetBluePixelComponent(p); *q++=GetGreenPixelComponent(p); *q++=GetRedPixelComponent(p); p++; } } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=GetBluePixelComponent(p); *q++=GetGreenPixelComponent(p); *q++=GetRedPixelComponent(p); *q++=(Quantum) (GetAlphaPixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=GetBluePixelComponent(p); *q++=GetGreenPixelComponent(p); *q++=GetRedPixelComponent(p); *q++=(Quantum) 0; p++; } } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=PixelIntensityToQuantum(p); p++; } } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=GetRedPixelComponent(p); *q++=GetGreenPixelComponent(p); *q++=GetBluePixelComponent(p); p++; } } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=GetRedPixelComponent(p); *q++=GetGreenPixelComponent(p); *q++=GetBluePixelComponent(p); *q++=(Quantum) (GetAlphaPixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=GetRedPixelComponent(p); *q++=GetGreenPixelComponent(p); *q++=GetBluePixelComponent(p); *q++=(Quantum) 0; p++; } } break; } for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { *q=(Quantum) 0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=GetRedPixelComponent(p); break; } case GreenQuantum: case MagentaQuantum: { *q=GetGreenPixelComponent(p); break; } case BlueQuantum: case YellowQuantum: { *q=GetBluePixelComponent(p); break; } case AlphaQuantum: { *q=(Quantum) (GetAlphaPixelComponent(p)); break; } case OpacityQuantum: { *q=GetOpacityPixelComponent(p); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=GetIndexPixelComponent(indexes+x); break; } case IndexQuantum: { *q=(PixelIntensityToQuantum(p)); break; } default: *q=(Quantum) 0; } q++; } p++; } } break; } case ShortPixel: { register unsigned short *q; q=(unsigned short *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToShort(GetBluePixelComponent(p)); *q++=ScaleQuantumToShort(GetGreenPixelComponent(p)); *q++=ScaleQuantumToShort(GetRedPixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToShort(GetBluePixelComponent(p)); *q++=ScaleQuantumToShort(GetGreenPixelComponent(p)); *q++=ScaleQuantumToShort(GetRedPixelComponent(p)); *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToShort(GetBluePixelComponent(p)); *q++=ScaleQuantumToShort(GetGreenPixelComponent(p)); *q++=ScaleQuantumToShort(GetRedPixelComponent(p)); *q++=0; p++; } } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToShort(PixelIntensityToQuantum(p)); p++; } } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToShort(GetRedPixelComponent(p)); *q++=ScaleQuantumToShort(GetGreenPixelComponent(p)); *q++=ScaleQuantumToShort(GetBluePixelComponent(p)); p++; } } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToShort(GetRedPixelComponent(p)); *q++=ScaleQuantumToShort(GetGreenPixelComponent(p)); *q++=ScaleQuantumToShort(GetBluePixelComponent(p)); *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p))); p++; } } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { *q++=ScaleQuantumToShort(GetRedPixelComponent(p)); *q++=ScaleQuantumToShort(GetGreenPixelComponent(p)); *q++=ScaleQuantumToShort(GetBluePixelComponent(p)); *q++=0; p++; } } break; } for (y=0; y < (ssize_t) rows; y++) { p=GetVirtualPixels(image,x_offset,y_offset+y,columns,1,exception); if (p == (const PixelPacket *) NULL) break; indexes=GetVirtualIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { *q=0; switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { *q=ScaleQuantumToShort(GetRedPixelComponent(p)); break; } case GreenQuantum: case MagentaQuantum: { *q=ScaleQuantumToShort(GetGreenPixelComponent(p)); break; } case BlueQuantum: case YellowQuantum: { *q=ScaleQuantumToShort(GetBluePixelComponent(p)); break; } case AlphaQuantum: { *q=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p))); break; } case OpacityQuantum: { *q=ScaleQuantumToShort(GetOpacityPixelComponent(p)); break; } case BlackQuantum: { if (image->colorspace == CMYKColorspace) *q=ScaleQuantumToShort(GetIndexPixelComponent(indexes+x)); break; } case IndexQuantum: { *q=ScaleQuantumToShort(PixelIntensityToQuantum(p)); break; } default: break; } q++; } p++; } } 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=RGBColorspace; 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, int, ssize_t, 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_offset, % const ssize_t y_offset,const size_t columns, % const size_t rows,const char *map,const StorageType type, % const void *pixels) % % A description of each parameter follows: % % o image: the image. % % o x_offset,y_offset,columns,rows: 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, ShortPixel, IntegerPixel, LongPixel, FloatPixel, or % DoublePixel. % % 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. % */ MagickExport MagickBooleanType ImportImagePixels(Image *image, const ssize_t x_offset,const ssize_t y_offset,const size_t columns, const size_t rows,const char *map,const StorageType type, const void *pixels) { ExceptionInfo *exception; PixelPacket *q; QuantumType *quantum_map; register IndexPacket *indexes; register ssize_t i, x; size_t length; ssize_t y; /* 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; 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); switch (type) { case CharPixel: { register const unsigned char *p; p=(const unsigned char *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,ScaleCharToQuantum(*p++)); SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,ScaleCharToQuantum(*p++)); SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); SetAlphaPixelComponent(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRO") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,ScaleCharToQuantum(*p++)); SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); SetOpacityPixelComponent(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,ScaleCharToQuantum(*p++)); SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,ScaleCharToQuantum(*p++)); SetBluePixelComponent(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,ScaleCharToQuantum(*p++)); SetBluePixelComponent(q,ScaleCharToQuantum(*p++)); SetAlphaPixelComponent(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBO") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,ScaleCharToQuantum(*p++)); SetBluePixelComponent(q,ScaleCharToQuantum(*p++)); SetOpacityPixelComponent(q,ScaleCharToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleCharToQuantum(*p++)); SetGreenPixelComponent(q,ScaleCharToQuantum(*p++)); SetBluePixelComponent(q,ScaleCharToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetRedPixelComponent(q,ScaleCharToQuantum(*p)); break; } case GreenQuantum: case MagentaQuantum: { SetGreenPixelComponent(q,ScaleCharToQuantum(*p)); break; } case BlueQuantum: case YellowQuantum: { SetBluePixelComponent(q,ScaleCharToQuantum(*p)); break; } case AlphaQuantum: { SetAlphaPixelComponent(q,ScaleCharToQuantum(*p)); break; } case OpacityQuantum: { SetOpacityPixelComponent(q,ScaleCharToQuantum(*p)); break; } case BlackQuantum: { SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(*p)); break; } case IndexQuantum: { SetRedPixelComponent(q,ScaleCharToQuantum(*p)); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } case DoublePixel: { register const double *p; p=(const double *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType) QuantumRange*(*p)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case GreenQuantum: case MagentaQuantum: { SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case BlueQuantum: case YellowQuantum: { SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case AlphaQuantum: { SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case OpacityQuantum: { SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case BlackQuantum: { SetIndexPixelComponent(indexes+x,ClampToQuantum( (MagickRealType) QuantumRange*(*p))); break; } case IndexQuantum: { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } case FloatPixel: { register const float *p; p=(const float *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case GreenQuantum: case MagentaQuantum: { SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case BlueQuantum: case YellowQuantum: { SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case AlphaQuantum: { SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case OpacityQuantum: { SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); break; } case BlackQuantum: { SetIndexPixelComponent(indexes+x,ClampToQuantum( (MagickRealType) QuantumRange*(*p))); break; } case IndexQuantum: { SetRedPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p))); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } case IntegerPixel: { register const unsigned int *p; p=(const unsigned int *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetRedPixelComponent(q,ScaleLongToQuantum(*p)); break; } case GreenQuantum: case MagentaQuantum: { SetGreenPixelComponent(q,ScaleLongToQuantum(*p)); break; } case BlueQuantum: case YellowQuantum: { SetBluePixelComponent(q,ScaleLongToQuantum(*p)); break; } case AlphaQuantum: { SetAlphaPixelComponent(q,ScaleLongToQuantum(*p)); break; } case OpacityQuantum: { SetOpacityPixelComponent(q,ScaleLongToQuantum(*p)); break; } case BlackQuantum: { SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p)); break; } case IndexQuantum: { SetRedPixelComponent(q,ScaleLongToQuantum(*p)); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } case LongPixel: { register const unsigned int *p; p=(const unsigned int *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleLongToQuantum(*p++)); SetGreenPixelComponent(q,ScaleLongToQuantum(*p++)); SetBluePixelComponent(q,ScaleLongToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetRedPixelComponent(q,ScaleLongToQuantum(*p)); break; } case GreenQuantum: case MagentaQuantum: { SetGreenPixelComponent(q,ScaleLongToQuantum(*p)); break; } case BlueQuantum: case YellowQuantum: { SetBluePixelComponent(q,ScaleLongToQuantum(*p)); break; } case AlphaQuantum: { SetAlphaPixelComponent(q,ScaleLongToQuantum(*p)); break; } case OpacityQuantum: { SetOpacityPixelComponent(q,ScaleLongToQuantum(*p)); break; } case BlackQuantum: { SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p)); break; } case IndexQuantum: { SetRedPixelComponent(q,ScaleLongToQuantum(*p)); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } case QuantumPixel: { register const Quantum *p; p=(const Quantum *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,*p++); SetGreenPixelComponent(q,*p++); SetRedPixelComponent(q,*p++); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,*p++); SetGreenPixelComponent(q,*p++); SetRedPixelComponent(q,*p++); SetAlphaPixelComponent(q,*p++); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,*p++); SetGreenPixelComponent(q,*p++); SetRedPixelComponent(q,*p++); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,*p++); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,*p++); SetGreenPixelComponent(q,*p++); SetBluePixelComponent(q,*p++); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,*p++); SetGreenPixelComponent(q,*p++); SetBluePixelComponent(q,*p++); SetAlphaPixelComponent(q,*p++); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,*p++); SetGreenPixelComponent(q,*p++); SetBluePixelComponent(q,*p++); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetRedPixelComponent(q,*p); break; } case GreenQuantum: case MagentaQuantum: { SetGreenPixelComponent(q,*p); break; } case BlueQuantum: case YellowQuantum: { SetBluePixelComponent(q,*p); break; } case AlphaQuantum: { SetAlphaPixelComponent(q,*p); break; } case OpacityQuantum: { SetOpacityPixelComponent(q,*p); break; } case BlackQuantum: { SetIndexPixelComponent(indexes+x,*p); break; } case IndexQuantum: { SetRedPixelComponent(q,*p); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } case ShortPixel: { register const unsigned short *p; p=(const unsigned short *) pixels; if (LocaleCompare(map,"BGR") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleShortToQuantum(*p++)); SetGreenPixelComponent(q,ScaleShortToQuantum(*p++)); SetRedPixelComponent(q,ScaleShortToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleShortToQuantum(*p++)); SetGreenPixelComponent(q,ScaleShortToQuantum(*p++)); SetRedPixelComponent(q,ScaleShortToQuantum(*p++)); SetAlphaPixelComponent(q,ScaleShortToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"BGRP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetBluePixelComponent(q,ScaleShortToQuantum(*p++)); SetGreenPixelComponent(q,ScaleShortToQuantum(*p++)); SetRedPixelComponent(q,ScaleShortToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"I") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleShortToQuantum(*p++)); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGB") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleShortToQuantum(*p++)); SetGreenPixelComponent(q,ScaleShortToQuantum(*p++)); SetBluePixelComponent(q,ScaleShortToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBA") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleShortToQuantum(*p++)); SetGreenPixelComponent(q,ScaleShortToQuantum(*p++)); SetBluePixelComponent(q,ScaleShortToQuantum(*p++)); SetAlphaPixelComponent(q,ScaleShortToQuantum(*p++)); q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } if (LocaleCompare(map,"RGBP") == 0) { for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; for (x=0; x < (ssize_t) columns; x++) { SetRedPixelComponent(q,ScaleShortToQuantum(*p++)); SetGreenPixelComponent(q,ScaleShortToQuantum(*p++)); SetBluePixelComponent(q,ScaleShortToQuantum(*p++)); p++; q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } break; } for (y=0; y < (ssize_t) rows; y++) { q=GetAuthenticPixels(image,x_offset,y_offset+y,columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); for (x=0; x < (ssize_t) columns; x++) { for (i=0; i < (ssize_t) length; i++) { switch (quantum_map[i]) { case RedQuantum: case CyanQuantum: { SetRedPixelComponent(q,ScaleShortToQuantum(*p)); break; } case GreenQuantum: case MagentaQuantum: { SetGreenPixelComponent(q,ScaleShortToQuantum(*p)); break; } case BlueQuantum: case YellowQuantum: { SetBluePixelComponent(q,ScaleShortToQuantum(*p)); break; } case AlphaQuantum: { SetAlphaPixelComponent(q,ScaleShortToQuantum(*p)); break; } case OpacityQuantum: { SetOpacityPixelComponent(q,ScaleShortToQuantum(*p)); break; } case BlackQuantum: { SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(*p)); break; } case IndexQuantum: { SetRedPixelComponent(q,ScaleShortToQuantum(*p)); SetGreenPixelComponent(q,GetRedPixelComponent(q)); SetBluePixelComponent(q,GetRedPixelComponent(q)); break; } default: break; } p++; } q++; } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } 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. % */ 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) GetRedPixelComponent(color); pixel->green=(MagickRealType) GetGreenPixelComponent(color); pixel->blue=(MagickRealType) GetBluePixelComponent(color); pixel->opacity=(MagickRealType) GetOpacityPixelComponent(color); pixel->index=0.0; if (((image->colorspace == CMYKColorspace) || (image->storage_class == PseudoClass)) && (indexes != (const IndexPacket *) NULL)) pixel->index=(MagickRealType) GetIndexPixelComponent(indexes); return; } *alpha=QuantumScale*GetAlphaPixelComponent(color); pixel->red=(*alpha*GetRedPixelComponent(color)); pixel->green=(*alpha*GetGreenPixelComponent(color)); pixel->blue=(*alpha*GetBluePixelComponent(color)); pixel->opacity=(MagickRealType) GetOpacityPixelComponent(color); pixel->index=0.0; if (((image->colorspace == CMYKColorspace) || (image->storage_class == PseudoClass)) && (indexes != (const IndexPacket *) NULL)) pixel->index=(*alpha*GetIndexPixelComponent(indexes)); } static void BicubicInterpolate(const MagickPixelPacket *pixels,const double dx, MagickPixelPacket *pixel) { MagickRealType dx2, p, q, r, s; dx2=dx*dx; p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red); q=(pixels[0].red-pixels[1].red)-p; r=pixels[2].red-pixels[0].red; s=pixels[1].red; pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s; p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green); q=(pixels[0].green-pixels[1].green)-p; r=pixels[2].green-pixels[0].green; s=pixels[1].green; pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s; p=(pixels[3].blue-pixels[2].blue)-(pixels[0].blue-pixels[1].blue); q=(pixels[0].blue-pixels[1].blue)-p; r=pixels[2].blue-pixels[0].blue; s=pixels[1].blue; pixel->blue=(dx*dx2*p)+(dx2*q)+(dx*r)+s; p=(pixels[3].opacity-pixels[2].opacity)-(pixels[0].opacity-pixels[1].opacity); q=(pixels[0].opacity-pixels[1].opacity)-p; r=pixels[2].opacity-pixels[0].opacity; s=pixels[1].opacity; pixel->opacity=(dx*dx2*p)+(dx2*q)+(dx*r)+s; if (pixel->colorspace == CMYKColorspace) { p=(pixels[3].index-pixels[2].index)-(pixels[0].index-pixels[1].index); q=(pixels[0].index-pixels[1].index)-p; r=pixels[2].index-pixels[0].index; s=pixels[1].index; pixel->index=(dx*dx2*p)+(dx2*q)+(dx*r)+s; } } static inline double MagickMax(const MagickRealType x,const MagickRealType y) { if (x > y) return(x); return(y); } static inline MagickRealType CubicWeightingFunction(const MagickRealType x) { MagickRealType alpha, gamma; alpha=MagickMax(x+2.0,0.0); gamma=1.0*alpha*alpha*alpha; alpha=MagickMax(x+1.0,0.0); gamma-=4.0*alpha*alpha*alpha; alpha=MagickMax(x+0.0,0.0); gamma+=6.0*alpha*alpha*alpha; alpha=MagickMax(x-1.0,0.0); gamma-=4.0*alpha*alpha*alpha; return(gamma/6.0); } 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); } static inline ssize_t NearestNeighbor(const MagickRealType x) { if (x >= 0.0) return((ssize_t) (x+0.5)); return((ssize_t) (x-0.5)); } MagickExport MagickBooleanType InterpolateMagickPixelPacket(const Image *image, const CacheView *image_view,const InterpolatePixelMethod method, const double x,const double y,MagickPixelPacket *pixel, ExceptionInfo *exception) { MagickBooleanType status; MagickPixelPacket pixels[16]; MagickRealType alpha[16], gamma; register const IndexPacket *indexes; register const PixelPacket *p; register ssize_t i; ssize_t x_offset, y_offset; 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); switch (method == UndefinedInterpolatePixel ? image->interpolate : method) { case AverageInterpolatePixel: { 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); AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0); AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1); AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2); AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3); AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4); AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5); AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6); AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7); AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8); AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9); AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10); AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11); AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12); AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13); AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14); AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15); pixel->red=0.0; pixel->green=0.0; pixel->blue=0.0; pixel->opacity=0.0; pixel->index=0.0; for (i=0; i < 16L; i++) { gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]); pixel->red+=gamma*0.0625*pixels[i].red; pixel->green+=gamma*0.0625*pixels[i].green; pixel->blue+=gamma*0.0625*pixels[i].blue; pixel->opacity+=0.0625*pixels[i].opacity; if (image->colorspace == CMYKColorspace) pixel->index+=gamma*0.0625*pixels[i].index; } break; } case BicubicInterpolatePixel: { MagickPixelPacket u[4]; PointInfo delta; 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); AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0); AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1); AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2); AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3); AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4); AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5); AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6); AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7); AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8); AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9); AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10); AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11); AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12); AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13); AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14); AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15); delta.x=x-x_offset; delta.y=y-y_offset; for (i=0; i < 4L; i++) BicubicInterpolate(pixels+4*i,delta.x,u+i); BicubicInterpolate(u,delta.y,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); AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0); AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1); AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2); AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3); 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=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 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)); 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)); 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)); break; } case FilterInterpolatePixel: { CacheView *filter_view; Image *excerpt_image, *filter_image; RectangleInfo geometry; 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=AcquireCacheView(filter_image); 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); AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0); AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1); AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2); AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3); delta.x=x-x_offset; delta.y=y-y_offset; luminance.x=MagickPixelLuminance(pixels+0)-MagickPixelLuminance(pixels+3); luminance.y=MagickPixelLuminance(pixels+1)-MagickPixelLuminance(pixels+2); if (fabs(luminance.x) < fabs(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=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 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); pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity, pixels[3].opacity,pixels[0].opacity); if (image->colorspace == CMYKColorspace) pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index, pixels[3].index,pixels[0].index); } 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=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 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); pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity, pixels[0].opacity,pixels[3].opacity); if (image->colorspace == CMYKColorspace) pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index, pixels[0].index,pixels[3].index); } } 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=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 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); pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity, pixels[1].opacity,pixels[2].opacity); if (image->colorspace == CMYKColorspace) pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index, pixels[1].index,pixels[2].index); } 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=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : 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); pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity, pixels[2].opacity,pixels[1].opacity); if (image->colorspace == CMYKColorspace) pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index, pixels[2].index,pixels[1].index); } } break; } case NearestNeighborInterpolatePixel: { p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x), NearestNeighbor(y),1,1,exception); if (p == (const PixelPacket *) NULL) { status=MagickFalse; break; } indexes=GetCacheViewVirtualIndexQueue(image_view); SetMagickPixelPacket(image,p,indexes,pixel); break; } case SplineInterpolatePixel: { MagickRealType dx, dy; PointInfo delta; ssize_t j, n; 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); AlphaBlendMagickPixelPacket(image,p+0,indexes+0,pixels+0,alpha+0); AlphaBlendMagickPixelPacket(image,p+1,indexes+1,pixels+1,alpha+1); AlphaBlendMagickPixelPacket(image,p+2,indexes+2,pixels+2,alpha+2); AlphaBlendMagickPixelPacket(image,p+3,indexes+3,pixels+3,alpha+3); AlphaBlendMagickPixelPacket(image,p+4,indexes+4,pixels+4,alpha+4); AlphaBlendMagickPixelPacket(image,p+5,indexes+5,pixels+5,alpha+5); AlphaBlendMagickPixelPacket(image,p+6,indexes+6,pixels+6,alpha+6); AlphaBlendMagickPixelPacket(image,p+7,indexes+7,pixels+7,alpha+7); AlphaBlendMagickPixelPacket(image,p+8,indexes+8,pixels+8,alpha+8); AlphaBlendMagickPixelPacket(image,p+9,indexes+9,pixels+9,alpha+9); AlphaBlendMagickPixelPacket(image,p+10,indexes+10,pixels+10,alpha+10); AlphaBlendMagickPixelPacket(image,p+11,indexes+11,pixels+11,alpha+11); AlphaBlendMagickPixelPacket(image,p+12,indexes+12,pixels+12,alpha+12); AlphaBlendMagickPixelPacket(image,p+13,indexes+13,pixels+13,alpha+13); AlphaBlendMagickPixelPacket(image,p+14,indexes+14,pixels+14,alpha+14); AlphaBlendMagickPixelPacket(image,p+15,indexes+15,pixels+15,alpha+15); pixel->red=0.0; pixel->green=0.0; pixel->blue=0.0; pixel->opacity=0.0; pixel->index=0.0; delta.x=x-x_offset; delta.y=y-y_offset; n=0; for (i=(-1); i < 3L; i++) { dy=CubicWeightingFunction((MagickRealType) i-delta.y); for (j=(-1); j < 3L; j++) { dx=CubicWeightingFunction(delta.x-(MagickRealType) j); gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 : alpha[n]); pixel->red+=gamma*dx*dy*pixels[n].red; pixel->green+=gamma*dx*dy*pixels[n].green; pixel->blue+=gamma*dx*dy*pixels[n].blue; pixel->opacity+=dx*dy*pixels[n].opacity; if (image->colorspace == CMYKColorspace) pixel->index+=gamma*dx*dy*pixels[n].index; n++; } } break; } } return(status); }