Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / ImageMagick / 1e604812fad85bb96f757a2393015ae3d061c39a / . / magick / pixel.c
blob: 748e0baf18d8e78f6d5e01e4ba9caf810da8af1c [file] [log] [blame]
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% 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++));
SetOpacityPixelComponent(q,QuantumRange-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++));
SetOpacityPixelComponent(q,QuantumRange-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:
{
SetOpacityPixelComponent(q,QuantumRange-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++;
SetOpacityPixelComponent(q,QuantumRange-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:
{
SetOpacityPixelComponent(q,QuantumRange-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++;
SetOpacityPixelComponent(q,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++;
SetOpacityPixelComponent(q,QuantumRange-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:
{
SetOpacityPixelComponent(q,QuantumRange-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++));
SetOpacityPixelComponent(q,QuantumRange-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++));
SetOpacityPixelComponent(q,QuantumRange-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:
{
SetOpacityPixelComponent(q,QuantumRange-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++));
SetOpacityPixelComponent(q,QuantumRange-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++));
SetOpacityPixelComponent(q,QuantumRange-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:
{
SetOpacityPixelComponent(q,QuantumRange-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++);
SetOpacityPixelComponent(q,QuantumRange-(*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++);
SetOpacityPixelComponent(q,QuantumRange-(*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:
{
SetOpacityPixelComponent(q,QuantumRange-(*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++));
SetOpacityPixelComponent(q,QuantumRange-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++));
SetOpacityPixelComponent(q,QuantumRange-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:
{
SetOpacityPixelComponent(q,QuantumRange-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);
}