% October 1998 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% 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 %
#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/statistic.h"
#include "magick/stream.h"
#include "magick/string_.h"
+#include "magick/transform.h"
#include "magick/utility.h"
\f
/*
%
% 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, long, float,
+% 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
% The format of the ExportImagePixels method is:
%
% MagickBooleanType ExportImagePixels(const Image *image,
-% const long x_offset,const long y_offset,const unsigned long columns,
-% const unsigned long rows,const char *map,const StorageType type,
+% 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:
%
*/
MagickExport MagickBooleanType ExportImagePixels(const Image *image,
- const long x_offset,const long y_offset,const unsigned long columns,
- const unsigned long rows,const char *map,const StorageType type,void *pixels,
+ 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)
{
- long
- y;
-
QuantumType
*quantum_map;
- register long
+ register ssize_t
i,
x;
size_t
length;
+ ssize_t
+ y;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(MagickFalse);
}
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (map[i])
{
q=(unsigned char *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetRedSample(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
*q++=ScaleQuantumToChar((Quantum) 0);
p++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToChar(PixelIntensityToQuantum(p));
p++;
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
- *q++=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToChar(GetRedSample(p));
- *q++=ScaleQuantumToChar(GetGreenSample(p));
- *q++=ScaleQuantumToChar(GetBlueSample(p));
+ *q++=ScaleQuantumToChar(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToChar(GetBluePixelComponent(p));
*q++=ScaleQuantumToChar((Quantum) 0);
p++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToChar(GetRedSample(p));
+ *q=ScaleQuantumToChar(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToChar(GetGreenSample(p));
+ *q=ScaleQuantumToChar(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToChar(GetBlueSample(p));
+ *q=ScaleQuantumToChar(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToChar((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToChar((Quantum) (GetAlphaPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToChar(GetOpacitySample(p));
+ *q=ScaleQuantumToChar(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToChar(indexes[x]);
+ *q=ScaleQuantumToChar(GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
q=(double *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(double) (QuantumScale*GetBlueSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetRedSample(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(double) (QuantumScale*GetBlueSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetRedSample(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
*q++=(double) (QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p))));
+ GetOpacityPixelComponent(p))));
p++;
}
}
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(double) (QuantumScale*GetBlueSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetRedSample(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
*q++=0.0;
p++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
*q++=(double) (QuantumScale*PixelIntensityToQuantum(p));
p++;
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(double) (QuantumScale*GetRedSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetBlueSample(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(double) (QuantumScale*GetRedSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetBlueSample(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
*q++=(double) (QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p))));
+ GetOpacityPixelComponent(p))));
p++;
}
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(double) (QuantumScale*GetRedSample(p));
- *q++=(double) (QuantumScale*GetGreenSample(p));
- *q++=(double) (QuantumScale*GetBlueSample(p));
+ *q++=(double) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(double) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(double) (QuantumScale*GetBluePixelComponent(p));
*q++=0.0;
p++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=(double) (QuantumScale*GetRedSample(p));
+ *q=(double) (QuantumScale*GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(double) (QuantumScale*GetGreenSample(p));
+ *q=(double) (QuantumScale*GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(double) (QuantumScale*GetBlueSample(p));
+ *q=(double) (QuantumScale*GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
*q=(double) (QuantumScale*((Quantum) (QuantumRange-
- GetOpacitySample(p))));
+ GetOpacityPixelComponent(p))));
break;
}
case OpacityQuantum:
{
- *q=(double) (QuantumScale*GetOpacitySample(p));
+ *q=(double) (QuantumScale*GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=(double) (QuantumScale*indexes[x]);
+ *q=(double) (QuantumScale*GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
q=(float *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(float) (QuantumScale*GetBlueSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetRedSample(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(float) (QuantumScale*GetBlueSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetRedSample(p));
- *q++=(float) (QuantumScale*(Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(float) (QuantumScale*(Quantum) (GetAlphaPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(float) (QuantumScale*GetBlueSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetRedSample(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
*q++=0.0;
p++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
*q++=(float) (QuantumScale*PixelIntensityToQuantum(p));
p++;
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(float) (QuantumScale*GetRedSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetBlueSample(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(float) (QuantumScale*GetRedSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetBlueSample(p));
- *q++=(float) (QuantumScale*((Quantum) (QuantumRange-GetOpacitySample(p))));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
+ *q++=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p))));
p++;
}
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(float) (QuantumScale*GetRedSample(p));
- *q++=(float) (QuantumScale*GetGreenSample(p));
- *q++=(float) (QuantumScale*GetBlueSample(p));
+ *q++=(float) (QuantumScale*GetRedPixelComponent(p));
+ *q++=(float) (QuantumScale*GetGreenPixelComponent(p));
+ *q++=(float) (QuantumScale*GetBluePixelComponent(p));
*q++=0.0;
p++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=(float) (QuantumScale*GetRedSample(p));
+ *q=(float) (QuantumScale*GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(float) (QuantumScale*GetGreenSample(p));
+ *q=(float) (QuantumScale*GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(float) (QuantumScale*GetBlueSample(p));
+ *q=(float) (QuantumScale*GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=(float) (QuantumScale*((Quantum) (QuantumRange-GetOpacitySample(p))));
+ *q=(float) (QuantumScale*((Quantum) (GetAlphaPixelComponent(p))));
break;
}
case OpacityQuantum:
{
- *q=(float) (QuantumScale*GetOpacitySample(p));
+ *q=(float) (QuantumScale*GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=(float) (QuantumScale*indexes[x]);
+ *q=(float) (QuantumScale*GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
q=(unsigned int *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
- GetOpacitySample(p)));
+ GetOpacityPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=0U;
p++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
*q++=(unsigned int)
ScaleQuantumToLong(PixelIntensityToQuantum(p));
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=(unsigned int) ScaleQuantumToLong((Quantum)
- (QuantumRange-GetOpacitySample(p)));
+ (GetAlphaPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
- *q++=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *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 < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetRedSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetGreenSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetBlueSample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
*q=(unsigned int) ScaleQuantumToLong((Quantum) (QuantumRange-
- GetOpacitySample(p)));
+ GetOpacityPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=(unsigned int) ScaleQuantumToLong(GetOpacitySample(p));
+ *q=(unsigned int) ScaleQuantumToLong(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=(unsigned int) ScaleQuantumToLong(indexes[x]);
+ *q=(unsigned int) ScaleQuantumToLong(GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
}
case LongPixel:
{
- register unsigned long
+ register size_t
*q;
- q=(unsigned long *) pixels;
+ q=(size_t *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetRedSample(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
*q++=0;
p++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToLong(PixelIntensityToQuantum(p));
p++;
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
- *q++=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToLong(GetRedSample(p));
- *q++=ScaleQuantumToLong(GetGreenSample(p));
- *q++=ScaleQuantumToLong(GetBlueSample(p));
+ *q++=ScaleQuantumToLong(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToLong(GetBluePixelComponent(p));
*q++=0;
p++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToLong(GetRedSample(p));
+ *q=ScaleQuantumToLong(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToLong(GetGreenSample(p));
+ *q=ScaleQuantumToLong(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToLong(GetBlueSample(p));
+ *q=ScaleQuantumToLong(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToLong((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToLong((Quantum) (GetAlphaPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToLong(GetOpacitySample(p));
+ *q=ScaleQuantumToLong(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToLong(indexes[x]);
+ *q=ScaleQuantumToLong(GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
q=(Quantum *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
p++;
}
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
- *q++=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=(Quantum) (GetAlphaPixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=GetBlueSample(p);
- *q++=GetGreenSample(p);
- *q++=GetRedSample(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetRedPixelComponent(p);
*q++=(Quantum) 0;
p++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
*q++=PixelIntensityToQuantum(p);
p++;
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
p++;
}
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
- *q++=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
+ *q++=(Quantum) (GetAlphaPixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=GetRedSample(p);
- *q++=GetGreenSample(p);
- *q++=GetBlueSample(p);
+ *q++=GetRedPixelComponent(p);
+ *q++=GetGreenPixelComponent(p);
+ *q++=GetBluePixelComponent(p);
*q++=(Quantum) 0;
p++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=(Quantum) 0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=GetRedSample(p);
+ *q=GetRedPixelComponent(p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=GetGreenSample(p);
+ *q=GetGreenPixelComponent(p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=GetBlueSample(p);
+ *q=GetBluePixelComponent(p);
break;
}
case AlphaQuantum:
{
- *q=(Quantum) (QuantumRange-GetOpacitySample(p));
+ *q=(Quantum) (GetAlphaPixelComponent(p));
break;
}
case OpacityQuantum:
{
- *q=GetOpacitySample(p);
+ *q=GetOpacityPixelComponent(p);
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=indexes[x];
+ *q=GetIndexPixelComponent(indexes+x);
break;
}
case IndexQuantum:
q=(unsigned short *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetRedSample(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
*q++=0;
p++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
*q++=ScaleQuantumToShort(PixelIntensityToQuantum(p));
p++;
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
p++;
}
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
- *q++=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
+ *q++=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
p++;
}
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- *q++=ScaleQuantumToShort(GetRedSample(p));
- *q++=ScaleQuantumToShort(GetGreenSample(p));
- *q++=ScaleQuantumToShort(GetBlueSample(p));
+ *q++=ScaleQuantumToShort(GetRedPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetGreenPixelComponent(p));
+ *q++=ScaleQuantumToShort(GetBluePixelComponent(p));
*q++=0;
p++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
case RedQuantum:
case CyanQuantum:
{
- *q=ScaleQuantumToShort(GetRedSample(p));
+ *q=ScaleQuantumToShort(GetRedPixelComponent(p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- *q=ScaleQuantumToShort(GetGreenSample(p));
+ *q=ScaleQuantumToShort(GetGreenPixelComponent(p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- *q=ScaleQuantumToShort(GetBlueSample(p));
+ *q=ScaleQuantumToShort(GetBluePixelComponent(p));
break;
}
case AlphaQuantum:
{
- *q=ScaleQuantumToShort((Quantum) (QuantumRange-GetOpacitySample(p)));
+ *q=ScaleQuantumToShort((Quantum) (GetAlphaPixelComponent(p)));
break;
}
case OpacityQuantum:
{
- *q=ScaleQuantumToShort(GetOpacitySample(p));
+ *q=ScaleQuantumToShort(GetOpacityPixelComponent(p));
break;
}
case BlackQuantum:
{
if (image->colorspace == CMYKColorspace)
- *q=ScaleQuantumToShort(indexes[x]);
+ *q=ScaleQuantumToShort(GetIndexPixelComponent(indexes+x));
break;
}
case IndexQuantum:
% 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, long, float, or double in the order specified by map.
+% 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:
%
% The format of the ImportImagePixels method is:
%
-% MagickBooleanType ImportImagePixels(Image *image,const long x_offset,
-% const long y_offset,const unsigned long columns,
-% const unsigned long rows,const char *map,const StorageType type,
+% 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:
%
*/
MagickExport MagickBooleanType ImportImagePixels(Image *image,
- const long x_offset,const long y_offset,const unsigned long columns,
- const unsigned long rows,const char *map,const StorageType type,
+ 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;
- long
- y;
-
PixelPacket
*q;
register IndexPacket
*indexes;
- register long
+ register ssize_t
i,
x;
size_t
length;
+ ssize_t
+ y;
+
/*
Allocate image structure.
*/
if (quantum_map == (QuantumType *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (map[i])
{
p=(const unsigned char *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->red=ScaleCharToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ 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++);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRO") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->red=ScaleCharToQuantum(*p++);
- q->opacity=ScaleCharToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->red=ScaleCharToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
p++;
q++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->blue=ScaleCharToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ 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++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBO") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->blue=ScaleCharToQuantum(*p++);
- q->opacity=ScaleCharToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleCharToQuantum(*p++);
- q->green=ScaleCharToQuantum(*p++);
- q->blue=ScaleCharToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p++));
p++;
q++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- q->red=ScaleCharToQuantum(*p);
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ScaleCharToQuantum(*p);
+ SetGreenPixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ScaleCharToQuantum(*p);
+ SetBluePixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ScaleCharToQuantum(*p);
+ SetAlphaPixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=ScaleCharToQuantum(*p);
+ SetOpacityPixelComponent(q,ScaleCharToQuantum(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=ScaleCharToQuantum(*p);
+ SetIndexPixelComponent(indexes+x,ScaleCharToQuantum(*p));
break;
}
case IndexQuantum:
{
- q->red=ScaleCharToQuantum(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleCharToQuantum(*p));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
p=(const double *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->opacity=(Quantum) QuantumRange-RoundToQuantum((MagickRealType)
+ q->opacity=(Quantum) QuantumRange-ClampToQuantum((MagickRealType)
QuantumRange*(*p));
p++;
q++;
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
p++;
q++;
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p++;
q++;
}
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType) QuantumRange*(*p)));
p++;
q++;
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->opacity=(Quantum) QuantumRange-RoundToQuantum((MagickRealType)
- QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-RoundToQuantum(
- (MagickRealType) QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case OpacityQuantum:
{
- q->opacity=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case BlackQuantum:
{
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(
+ (MagickRealType) QuantumRange*(*p)));
break;
}
case IndexQuantum:
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
p=(const float *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->opacity=(Quantum) QuantumRange-RoundToQuantum((MagickRealType)
- QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
p++;
q++;
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
p++;
q++;
}
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->opacity=(Quantum) QuantumRange-RoundToQuantum((MagickRealType)
- QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
p++;
q++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetGreenPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetBluePixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-RoundToQuantum(
- (MagickRealType) QuantumRange*(*p));
+ SetAlphaPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case OpacityQuantum:
{
- q->opacity=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetOpacityPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
break;
}
case BlackQuantum:
{
- indexes[x]=RoundToQuantum((MagickRealType) QuantumRange*(*p));
+ SetIndexPixelComponent(indexes+x,ClampToQuantum(
+ (MagickRealType) QuantumRange*(*p)));
break;
}
case IndexQuantum:
{
- q->red=RoundToQuantum((MagickRealType) QuantumRange*(*p));
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ClampToQuantum((MagickRealType)
+ QuantumRange*(*p)));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
p=(const unsigned int *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ 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++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
p++;
q++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ 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++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
p++;
q++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- q->red=ScaleLongToQuantum(*p);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ScaleLongToQuantum(*p);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ScaleLongToQuantum(*p);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=ScaleLongToQuantum(*p);
+ SetOpacityPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=ScaleLongToQuantum(*p);
+ SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p));
break;
}
case IndexQuantum:
{
- q->red=ScaleLongToQuantum(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
}
case LongPixel:
{
- register const unsigned long
+ register const unsigned int
*p;
- p=(const unsigned long *) pixels;
+ p=(const unsigned int *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ 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++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->red=ScaleLongToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
p++;
q++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ 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++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleLongToQuantum(*p++);
- q->green=ScaleLongToQuantum(*p++);
- q->blue=ScaleLongToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p++));
p++;
q++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- q->red=ScaleLongToQuantum(*p);
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ScaleLongToQuantum(*p);
+ SetGreenPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ScaleLongToQuantum(*p);
+ SetBluePixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ScaleLongToQuantum(*p);
+ SetAlphaPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=ScaleLongToQuantum(*p);
+ SetOpacityPixelComponent(q,ScaleLongToQuantum(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=ScaleLongToQuantum(*p);
+ SetIndexPixelComponent(indexes+x,ScaleLongToQuantum(*p));
break;
}
case IndexQuantum:
{
- q->red=ScaleLongToQuantum(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleLongToQuantum(*p));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
p=(const Quantum *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=(*p++);
- q->green=(*p++);
- q->red=(*p++);
+ SetBluePixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetRedPixelComponent(q,*p++);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=(*p++);
- q->green=(*p++);
- q->red=(*p++);
- q->opacity=(Quantum) QuantumRange-(*p++);
+ SetBluePixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetRedPixelComponent(q,*p++);
+ SetAlphaPixelComponent(q,*p++);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=(*p++);
- q->green=(*p++);
- q->red=(*p++);
+ SetBluePixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetRedPixelComponent(q,*p++);
p++;
q++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,*p++);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=(*p++);
- q->green=(*p++);
- q->blue=(*p++);
+ SetRedPixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetBluePixelComponent(q,*p++);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=(*p++);
- q->green=(*p++);
- q->blue=(*p++);
- q->opacity=(Quantum) QuantumRange-(*p++);
+ SetRedPixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetBluePixelComponent(q,*p++);
+ SetAlphaPixelComponent(q,*p++);
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=(*p++);
- q->green=(*p++);
- q->blue=(*p++);
+ SetRedPixelComponent(q,*p++);
+ SetGreenPixelComponent(q,*p++);
+ SetBluePixelComponent(q,*p++);
p++;
q++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- q->red=(*p);
+ SetRedPixelComponent(q,*p);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=(*p);
+ SetGreenPixelComponent(q,*p);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=(*p);
+ SetBluePixelComponent(q,*p);
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-(*p);
+ SetAlphaPixelComponent(q,*p);
break;
}
case OpacityQuantum:
{
- q->opacity=(*p);
+ SetOpacityPixelComponent(q,*p);
break;
}
case BlackQuantum:
{
- indexes[x]=(*p);
+ SetIndexPixelComponent(indexes+x,*p);
break;
}
case IndexQuantum:
{
- q->red=(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,*p);
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
p=(const unsigned short *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->red=ScaleShortToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ 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++);
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"BGRP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->blue=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->red=ScaleShortToQuantum(*p++);
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
p++;
q++;
}
}
if (LocaleCompare(map,"I") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleShortToQuantum(*p++);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGB") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->blue=ScaleShortToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBA") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ 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++);
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(*p++));
q++;
}
if (SyncAuthenticPixels(image,exception) == MagickFalse)
}
if (LocaleCompare(map,"RGBP") == 0)
{
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- q->red=ScaleShortToQuantum(*p++);
- q->green=ScaleShortToQuantum(*p++);
- q->blue=ScaleShortToQuantum(*p++);
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p++));
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p++));
p++;
q++;
}
}
break;
}
- for (y=0; y < (long) rows; y++)
+ 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 < (long) columns; x++)
+ for (x=0; x < (ssize_t) columns; x++)
{
- for (i=0; i < (long) length; i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- q->red=ScaleShortToQuantum(*p);
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- q->green=ScaleShortToQuantum(*p);
+ SetGreenPixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case BlueQuantum:
case YellowQuantum:
{
- q->blue=ScaleShortToQuantum(*p);
+ SetBluePixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case AlphaQuantum:
{
- q->opacity=(Quantum) QuantumRange-ScaleShortToQuantum(*p);
+ SetAlphaPixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case OpacityQuantum:
{
- q->opacity=ScaleShortToQuantum(*p);
+ SetOpacityPixelComponent(q,ScaleShortToQuantum(*p));
break;
}
case BlackQuantum:
{
- indexes[x]=ScaleShortToQuantum(*p);
+ SetIndexPixelComponent(indexes+x,ScaleShortToQuantum(*p));
break;
}
case IndexQuantum:
{
- q->red=ScaleShortToQuantum(*p);
- q->green=q->red;
- q->blue=q->red;
+ SetRedPixelComponent(q,ScaleShortToQuantum(*p));
+ SetGreenPixelComponent(q,GetRedPixelComponent(q));
+ SetBluePixelComponent(q,GetRedPixelComponent(q));
break;
}
default:
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
return(MagickTrue);
}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% 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);
+}
projects / imagemagick / blobdiff