Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / ImageMagick / ca48bce6fe97de73bb71690343d0927c3a5d4b35 / . / magick / pixel.c
blob: 133ceeda1b009938273c16aef5e5a274de20d267 [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-2010 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/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/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)
{
ssize_t
y;
QuantumType
*quantum_map;
register ssize_t
i,
x;
register const IndexPacket
*indexes;
register const PixelPacket
*p;
size_t
length;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
length=strlen(map);
quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
if (quantum_map == (QuantumType *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(MagickFalse);
}
for (i=0; i < (ssize_t) length; i++)
{
switch (map[i])
{
case 'A':
case 'a':
{
quantum_map[i]=AlphaQuantum;
break;
}
case 'B':
case 'b':
{
quantum_map[i]=BlueQuantum;
break;
}
case 'C':
case 'c':
{
quantum_map[i]=CyanQuantum;
if (image->colorspace == CMYKColorspace)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColorSeparatedImageRequired","`%s'",map);
return(MagickFalse);
}
case 'g':
case 'G':
{
quantum_map[i]=GreenQuantum;
break;
}
case 'I':
case 'i':
{
quantum_map[i]=IndexQuantum;
break;
}
case 'K':
case 'k':
{
quantum_map[i]=BlackQuantum;
if (image->colorspace == CMYKColorspace)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColorSeparatedImageRequired","`%s'",map);
return(MagickFalse);
}
case 'M':
case 'm':
{
quantum_map[i]=MagentaQuantum;
if (image->colorspace == CMYKColorspace)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColorSeparatedImageRequired","`%s'",map);
return(MagickFalse);
}
case 'o':
case 'O':
{
quantum_map[i]=OpacityQuantum;
break;
}
case 'P':
case 'p':
{
quantum_map[i]=UndefinedQuantum;
break;
}
case 'R':
case 'r':
{
quantum_map[i]=RedQuantum;
break;
}
case 'Y':
case 'y':
{
quantum_map[i]=YellowQuantum;
if (image->colorspace == CMYKColorspace)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColorSeparatedImageRequired","`%s'",map);
return(MagickFalse);
}
default:
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"UnrecognizedPixelMap","`%s'",map);
return(MagickFalse);
}
}
}
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(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*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*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(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(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=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(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;
ssize_t
y;
PixelPacket
*q;
QuantumType
*quantum_map;
register IndexPacket
*indexes;
register ssize_t
i,
x;
size_t
length;
/*
Allocate image structure.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
length=strlen(map);
quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
if (quantum_map == (QuantumType *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
for (i=0; i < (ssize_t) length; i++)
{
switch (map[i])
{
case 'a':
case 'A':
{
quantum_map[i]=AlphaQuantum;
image->matte=MagickTrue;
break;
}
case 'B':
case 'b':
{
quantum_map[i]=BlueQuantum;
break;
}
case 'C':
case 'c':
{
quantum_map[i]=CyanQuantum;
(void) SetImageColorspace(image,CMYKColorspace);
break;
}
case 'g':
case 'G':
{
quantum_map[i]=GreenQuantum;
break;
}
case 'K':
case 'k':
{
quantum_map[i]=BlackQuantum;
(void) SetImageColorspace(image,CMYKColorspace);
break;
}
case 'I':
case 'i':
{
quantum_map[i]=IndexQuantum;
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++)
{
q->blue=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->red=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++)
{
q->blue=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->red=ScaleCharToQuantum(*p++);
q->opacity=(Quantum) 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++)
{
q->blue=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->red=ScaleCharToQuantum(*p++);
q->opacity=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++)
{
q->blue=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->red=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++)
{
q->red=ScaleCharToQuantum(*p++);
q->green=q->red;
q->blue=q->red;
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++)
{
q->red=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->blue=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++)
{
q->red=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->blue=ScaleCharToQuantum(*p++);
q->opacity=(Quantum) 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++)
{
q->red=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->blue=ScaleCharToQuantum(*p++);
q->opacity=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++)
{
q->red=ScaleCharToQuantum(*p++);
q->green=ScaleCharToQuantum(*p++);
q->blue=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:
{
q->red=ScaleCharToQuantum(*p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
q->green=ScaleCharToQuantum(*p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
q->blue=ScaleCharToQuantum(*p);
break;
}
case AlphaQuantum:
{
q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
break;
}
case OpacityQuantum:
{
q->opacity=ScaleCharToQuantum(*p);
break;
}
case BlackQuantum:
{
indexes[x]=ScaleCharToQuantum(*p);
break;
}
case IndexQuantum:
{
q->red=ScaleCharToQuantum(*p);
q->green=q->red;
q->blue=q->red;
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++)
{
q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->red=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++)
{
q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->red=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++)
{
q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->red=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++)
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
q->green=q->red;
q->blue=q->red;
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++)
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->blue=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++)
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->blue=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,"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++)
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->blue=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:
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case AlphaQuantum:
{
q->opacity=(Quantum) QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*(*p));
break;
}
case OpacityQuantum:
{
q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case BlackQuantum:
{
indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case IndexQuantum:
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
q->green=q->red;
q->blue=q->red;
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++)
{
q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->red=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++)
{
q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->red=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++)
{
q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->red=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++)
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
q->green=q->red;
q->blue=q->red;
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++)
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->blue=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++)
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->blue=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,"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++)
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
p++;
q->blue=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:
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
q->green=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
q->blue=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case AlphaQuantum:
{
q->opacity=(Quantum) QuantumRange-ClampToQuantum(
(MagickRealType) QuantumRange*(*p));
break;
}
case OpacityQuantum:
{
q->opacity=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case BlackQuantum:
{
indexes[x]=ClampToQuantum((MagickRealType) QuantumRange*(*p));
break;
}
case IndexQuantum:
{
q->red=ClampToQuantum((MagickRealType) QuantumRange*(*p));
q->green=q->red;
q->blue=q->red;
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++)
{
q->blue=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->red=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++)
{
q->blue=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->red=ScaleLongToQuantum(*p++);
q->opacity=(Quantum) 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++)
{
q->blue=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->red=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++)
{
q->red=ScaleLongToQuantum(*p++);
q->green=q->red;
q->blue=q->red;
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++)
{
q->red=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->blue=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++)
{
q->red=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->blue=ScaleLongToQuantum(*p++);
q->opacity=(Quantum) 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++)
{
q->red=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->blue=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:
{
q->red=ScaleLongToQuantum(*p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
q->green=ScaleLongToQuantum(*p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
q->blue=ScaleLongToQuantum(*p);
break;
}
case AlphaQuantum:
{
q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
break;
}
case OpacityQuantum:
{
q->opacity=ScaleLongToQuantum(*p);
break;
}
case BlackQuantum:
{
indexes[x]=ScaleLongToQuantum(*p);
break;
}
case IndexQuantum:
{
q->red=ScaleLongToQuantum(*p);
q->green=q->red;
q->blue=q->red;
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++)
{
q->blue=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->red=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++)
{
q->blue=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->red=ScaleLongToQuantum(*p++);
q->opacity=(Quantum) 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++)
{
q->blue=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->red=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++)
{
q->red=ScaleLongToQuantum(*p++);
q->green=q->red;
q->blue=q->red;
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++)
{
q->red=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->blue=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++)
{
q->red=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->blue=ScaleLongToQuantum(*p++);
q->opacity=(Quantum) 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++)
{
q->red=ScaleLongToQuantum(*p++);
q->green=ScaleLongToQuantum(*p++);
q->blue=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:
{
q->red=ScaleLongToQuantum(*p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
q->green=ScaleLongToQuantum(*p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
q->blue=ScaleLongToQuantum(*p);
break;
}
case AlphaQuantum:
{
q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
break;
}
case OpacityQuantum:
{
q->opacity=ScaleLongToQuantum(*p);
break;
}
case BlackQuantum:
{
indexes[x]=ScaleLongToQuantum(*p);
break;
}
case IndexQuantum:
{
q->red=ScaleLongToQuantum(*p);
q->green=q->red;
q->blue=q->red;
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++)
{
q->blue=(*p++);
q->green=(*p++);
q->red=(*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++)
{
q->blue=(*p++);
q->green=(*p++);
q->red=(*p++);
q->opacity=(Quantum) 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++)
{
q->blue=(*p++);
q->green=(*p++);
q->red=(*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++)
{
q->red=(*p++);
q->green=q->red;
q->blue=q->red;
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++)
{
q->red=(*p++);
q->green=(*p++);
q->blue=(*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++)
{
q->red=(*p++);
q->green=(*p++);
q->blue=(*p++);
q->opacity=(Quantum) 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++)
{
q->red=(*p++);
q->green=(*p++);
q->blue=(*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:
{
q->red=(*p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
q->green=(*p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
q->blue=(*p);
break;
}
case AlphaQuantum:
{
q->opacity=(Quantum) QuantumRange-(*p);
break;
}
case OpacityQuantum:
{
q->opacity=(*p);
break;
}
case BlackQuantum:
{
indexes[x]=(*p);
break;
}
case IndexQuantum:
{
q->red=(*p);
q->green=q->red;
q->blue=q->red;
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++)
{
q->blue=ScaleShortToQuantum(*p++);
q->green=ScaleShortToQuantum(*p++);
q->red=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++)
{
q->blue=ScaleShortToQuantum(*p++);
q->green=ScaleShortToQuantum(*p++);
q->red=ScaleShortToQuantum(*p++);
q->opacity=(Quantum) 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++)
{
q->blue=ScaleShortToQuantum(*p++);
q->green=ScaleShortToQuantum(*p++);
q->red=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++)
{
q->red=ScaleShortToQuantum(*p++);
q->green=q->red;
q->blue=q->red;
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++)
{
q->red=ScaleShortToQuantum(*p++);
q->green=ScaleShortToQuantum(*p++);
q->blue=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++)
{
q->red=ScaleShortToQuantum(*p++);
q->green=ScaleShortToQuantum(*p++);
q->blue=ScaleShortToQuantum(*p++);
q->opacity=(Quantum) 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++)
{
q->red=ScaleShortToQuantum(*p++);
q->green=ScaleShortToQuantum(*p++);
q->blue=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:
{
q->red=ScaleShortToQuantum(*p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
q->green=ScaleShortToQuantum(*p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
q->blue=ScaleShortToQuantum(*p);
break;
}
case AlphaQuantum:
{
q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
break;
}
case OpacityQuantum:
{
q->opacity=ScaleShortToQuantum(*p);
break;
}
case BlackQuantum:
{
indexes[x]=ScaleShortToQuantum(*p);
break;
}
case IndexQuantum:
{
q->red=ScaleShortToQuantum(*p);
q->green=q->red;
q->blue=q->red;
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);
}