#include "MagickCore/option.h"
#include "MagickCore/pixel.h"
#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/pixel-private.h"
#include "MagickCore/quantum.h"
#include "MagickCore/quantum-private.h"
#include "MagickCore/resource_.h"
PixelChannel \
channel; \
\
- switch (GetPixelChannelMapChannel(image,i)) \
+ switch (GetPixelChannelChannel(image,i)) \
{ \
case RedPixelChannel: \
{ \
default: \
name="undefined"; \
} \
- channel=GetPixelChannelMapChannel(image,i); \
+ channel=GetPixelChannelChannel(image,i); \
*traits='\0'; \
- if ((GetPixelChannelMapTraits(image,channel) & UpdatePixelTrait) != 0) \
+ if ((GetPixelChannelTraits(image,channel) & UpdatePixelTrait) != 0) \
(void) ConcatenateMagickString(traits,"update,",MaxTextExtent); \
- if ((GetPixelChannelMapTraits(image,channel) & BlendPixelTrait) != 0) \
+ if ((GetPixelChannelTraits(image,channel) & BlendPixelTrait) != 0) \
(void) ConcatenateMagickString(traits,"blend,",MaxTextExtent); \
- if ((GetPixelChannelMapTraits(image,channel) & CopyPixelTrait) != 0) \
+ if ((GetPixelChannelTraits(image,channel) & CopyPixelTrait) != 0) \
(void) ConcatenateMagickString(traits,"copy,",MaxTextExtent); \
if (*traits == '\0') \
(void) ConcatenateMagickString(traits,"undefined,",MaxTextExtent); \
%
*/
-static void ExportCharPixel(const Image *image,const RectangleInfo *roi,
+static void ExportCharPixel(Image *image,const RectangleInfo *roi,
const char *restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register unsigned char
*restrict q;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
}
}
-static void ExportDoublePixel(const Image *image,const RectangleInfo *roi,
+static void ExportDoublePixel(Image *image,const RectangleInfo *roi,
const char *restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
}
}
-static void ExportFloatPixel(const Image *image,const RectangleInfo *roi,
+static void ExportFloatPixel(Image *image,const RectangleInfo *roi,
const char *restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
}
}
-static void ExportLongPixel(const Image *image,const RectangleInfo *roi,
+static void ExportLongPixel(Image *image,const RectangleInfo *roi,
const char *restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register unsigned int
*restrict q;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
}
}
-static void ExportLongLongPixel(const Image *image,const RectangleInfo *roi,
+static void ExportLongLongPixel(Image *image,const RectangleInfo *roi,
const char *restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register MagickSizeType
*restrict q;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
}
}
-static void ExportQuantumPixel(const Image *image,const RectangleInfo *roi,
+static void ExportQuantumPixel(Image *image,const RectangleInfo *roi,
const char *restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=(Quantum) 0;
switch (quantum_map[i])
}
}
-static void ExportShortPixel(const Image *image,const RectangleInfo *roi,
+static void ExportShortPixel(Image *image,const RectangleInfo *roi,
const char *restrict map,const QuantumType *quantum_map,void *pixels,
ExceptionInfo *exception)
{
register ssize_t
x;
- ssize_t
- y;
-
register unsigned short
*restrict q;
+ size_t
+ length;
+
+ ssize_t
+ y;
+
q=(unsigned short *) pixels;
if (LocaleCompare(map,"BGR") == 0)
{
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
p=GetVirtualPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
*q=0;
switch (quantum_map[i])
}
}
-MagickExport MagickBooleanType ExportImagePixels(const Image *image,
+MagickExport MagickBooleanType ExportImagePixels(Image *image,
const ssize_t x,const ssize_t y,const size_t width,const size_t height,
const char *map,const StorageType type,void *pixels,ExceptionInfo *exception)
{
register ssize_t
i;
+ size_t
+ length;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- quantum_map=(QuantumType *) AcquireQuantumMemory(strlen(map),
- sizeof(*quantum_map));
+ length=strlen(map);
+ quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
if (quantum_map == (QuantumType *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
+ ResourceLimitError,"MemoryAllocationFailed","'%s'",image->filename);
return(MagickFalse);
}
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (map[i])
{
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",map);
+ "ColorSeparatedImageRequired","'%s'",map);
return(MagickFalse);
}
case 'g':
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",map);
+ "ColorSeparatedImageRequired","'%s'",map);
return(MagickFalse);
}
case 'M':
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",map);
+ "ColorSeparatedImageRequired","'%s'",map);
return(MagickFalse);
}
case 'o':
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",map);
+ "ColorSeparatedImageRequired","'%s'",map);
return(MagickFalse);
}
default:
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",map);
+ "UnrecognizedPixelMap","'%s'",map);
return(MagickFalse);
}
}
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",map);
+ "UnrecognizedPixelMap","'%s'",map);
break;
}
}
MagickExport void GetPixelInfo(const Image *image,PixelInfo *pixel)
{
pixel->storage_class=DirectClass;
- pixel->colorspace=RGBColorspace;
- pixel->matte=MagickFalse;
+ pixel->colorspace=sRGBColorspace;
+ pixel->alpha_trait=UndefinedPixelTrait;
pixel->fuzz=0.0;
pixel->depth=MAGICKCORE_QUANTUM_DEPTH;
pixel->red=0.0;
pixel->green=0.0;
pixel->blue=0.0;
pixel->black=0.0;
- pixel->alpha=(MagickRealType) OpaqueAlpha;
+ pixel->alpha=(double) OpaqueAlpha;
pixel->index=0.0;
if (image == (const Image *) NULL)
return;
pixel->storage_class=image->storage_class;
pixel->colorspace=image->colorspace;
- pixel->matte=image->matte;
+ pixel->alpha_trait=image->alpha_trait;
pixel->depth=image->depth;
pixel->fuzz=image->fuzz;
}
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
p++;
q+=GetPixelChannels(image);
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case AlphaQuantum:
{
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case OpacityQuantum:
{
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case BlackQuantum:
{
- SetPixelBlack(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case IndexQuantum:
{
- SetPixelGray(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
default:
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
p++;
q+=GetPixelChannels(image);
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelGray(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelAlpha(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- SetPixelRed(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelGreen(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
- SetPixelBlue(image,ClampToQuantum((MagickRealType) QuantumRange*
- (*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
p++;
q+=GetPixelChannels(image);
}
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
case RedQuantum:
case CyanQuantum:
{
- SetPixelRed(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelRed(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case GreenQuantum:
case MagentaQuantum:
{
- SetPixelGreen(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case BlueQuantum:
case YellowQuantum:
{
- SetPixelBlue(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case AlphaQuantum:
{
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case OpacityQuantum:
{
- SetPixelAlpha(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelAlpha(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case BlackQuantum:
{
- SetPixelBlack(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
case IndexQuantum:
{
- SetPixelGray(image,ClampToQuantum((MagickRealType)
- QuantumRange*(*p)),q);
+ SetPixelGray(image,ClampToQuantum(QuantumRange*(*p)),q);
break;
}
default:
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
register ssize_t
x;
+ size_t
+ length;
+
ssize_t
y;
}
return;
}
+ length=strlen(map);
for (y=0; y < (ssize_t) roi->height; y++)
{
q=GetAuthenticPixels(image,roi->x,roi->y+y,roi->width,1,exception);
register ssize_t
i;
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (quantum_map[i])
{
register ssize_t
i;
+ size_t
+ length;
+
/*
Allocate image structure.
*/
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- quantum_map=(QuantumType *) AcquireQuantumMemory(strlen(map),
- sizeof(*quantum_map));
+ length=strlen(map);
+ quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
if (quantum_map == (QuantumType *) NULL)
ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
image->filename);
- for (i=0; i < (ssize_t) strlen(map); i++)
+ for (i=0; i < (ssize_t) length; i++)
{
switch (map[i])
{
case 'A':
{
quantum_map[i]=AlphaQuantum;
- image->matte=MagickTrue;
+ image->alpha_trait=BlendPixelTrait;
break;
}
case 'B':
case 'i':
{
quantum_map[i]=IndexQuantum;
+ (void) SetImageColorspace(image,GRAYColorspace,exception);
break;
}
case 'm':
case 'o':
{
quantum_map[i]=OpacityQuantum;
- image->matte=MagickTrue;
+ image->alpha_trait=BlendPixelTrait;
break;
}
case 'P':
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",map);
+ "UnrecognizedPixelMap","'%s'",map);
return(MagickFalse);
}
}
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
- "UnrecognizedPixelMap","`%s'",map);
+ "UnrecognizedPixelMap","'%s'",map);
break;
}
}
(void) ResetMagickMemory(image->channel_map,0,MaxPixelChannels*
sizeof(*image->channel_map));
trait=UpdatePixelTrait;
- if (image->matte != MagickFalse)
+ if (image->alpha_trait == BlendPixelTrait)
trait=(PixelTrait) (trait | BlendPixelTrait);
n=0;
if (image->colorspace == GRAYColorspace)
{
- SetPixelChannelMap(image,BluePixelChannel,trait,n);
- SetPixelChannelMap(image,GreenPixelChannel,trait,n);
- SetPixelChannelMap(image,RedPixelChannel,trait,n++);
+ SetPixelChannelAttributes(image,BluePixelChannel,trait,n);
+ SetPixelChannelAttributes(image,GreenPixelChannel,trait,n);
+ SetPixelChannelAttributes(image,RedPixelChannel,trait,n++);
}
else
{
- SetPixelChannelMap(image,RedPixelChannel,trait,n++);
- SetPixelChannelMap(image,GreenPixelChannel,trait,n++);
- SetPixelChannelMap(image,BluePixelChannel,trait,n++);
+ SetPixelChannelAttributes(image,RedPixelChannel,trait,n++);
+ SetPixelChannelAttributes(image,GreenPixelChannel,trait,n++);
+ SetPixelChannelAttributes(image,BluePixelChannel,trait,n++);
}
if (image->colorspace == CMYKColorspace)
- SetPixelChannelMap(image,BlackPixelChannel,trait,n++);
- if (image->matte != MagickFalse)
- SetPixelChannelMap(image,AlphaPixelChannel,CopyPixelTrait,n++);
+ SetPixelChannelAttributes(image,BlackPixelChannel,trait,n++);
+ if (image->alpha_trait != UndefinedPixelTrait)
+ SetPixelChannelAttributes(image,AlphaPixelChannel,CopyPixelTrait,n++);
if (image->storage_class == PseudoClass)
- SetPixelChannelMap(image,IndexPixelChannel,CopyPixelTrait,n++);
+ SetPixelChannelAttributes(image,IndexPixelChannel,CopyPixelTrait,n++);
if (image->mask != MagickFalse)
- SetPixelChannelMap(image,MaskPixelChannel,CopyPixelTrait,n++);
+ SetPixelChannelAttributes(image,MaskPixelChannel,CopyPixelTrait,n++);
assert((n+image->number_meta_channels) < MaxPixelChannels);
for (i=0; i < (ssize_t) image->number_meta_channels; i++)
- SetPixelChannelMap(image,(PixelChannel) (MetaPixelChannel+i),CopyPixelTrait,
- n++);
+ SetPixelChannelAttributes(image,(PixelChannel) (MetaPixelChannel+i),
+ CopyPixelTrait,n++);
image->number_channels=(size_t) n;
if (image->debug != MagickFalse)
LogPixelChannels(image);
- (void) SetPixelChannelMask(image,image->channel_mask);
+ (void) SetImageChannelMask(image,image->channel_mask);
}
\f
/*
% floating point coordinate and the pixels surrounding that coordinate. No
% pixel area resampling, or scaling of the result is performed.
%
+% Interpolation is restricted to just the specified channel.
+%
% The format of the InterpolatePixelChannel method is:
%
% MagickBooleanType InterpolatePixelChannel(const Image *image,
%
*/
-static inline double MagickMax(const MagickRealType x,const MagickRealType y)
+static inline double MagickMax(const double x,const double y)
{
if (x > y)
return(x);
return(y);
}
-static inline MagickRealType CubicWeightingFunction(const MagickRealType x)
+static inline void CatromWeights(const double x,double (*weights)[4])
{
- MagickRealType
+ double
alpha,
+ beta,
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);
+ /*
+ Nicolas Robidoux' 10 flops (4* + 5- + 1+) refactoring of the computation
+ of the standard four 1D Catmull-Rom weights. The sampling location is
+ assumed between the second and third input pixel locations, and x is the
+ position relative to the second input pixel location. Formulas originally
+ derived for the VIPS (Virtual Image Processing System) library.
+ */
+ alpha=(double) 1.0-x;
+ beta=(double) (-0.5)*x*alpha;
+ (*weights)[0]=alpha*beta;
+ (*weights)[3]=x*beta;
+ /*
+ The following computation of the inner weights from the outer ones work
+ for all Keys cubics.
+ */
+ gamma=(*weights)[3]-(*weights)[0];
+ (*weights)[1]=alpha-(*weights)[0]+gamma;
+ (*weights)[2]=x-(*weights)[3]-gamma;
+}
+
+static inline void SplineWeights(const double x,double (*weights)[4])
+{
+ double
+ alpha,
+ beta;
+
+ /*
+ Nicolas Robidoux' 12 flops (6* + 5- + 1+) refactoring of the
+ computation of the standard four 1D cubic B-spline smoothing
+ weights. The sampling location is assumed between the second and
+ third input pixel locations, and x is the position relative to the
+ second input pixel location.
+ */
+ alpha=(double) 1.0-x;
+ (*weights)[3]=(double) (1.0/6.0)*x*x*x;
+ (*weights)[0]=(double) (1.0/6.0)*alpha*alpha*alpha;
+ beta=(*weights)[3]-(*weights)[0];
+ (*weights)[1]=alpha-(*weights)[0]+beta;
+ (*weights)[2]=x-(*weights)[3]-beta;
}
static inline double MeshInterpolate(const PointInfo *delta,const double p,
return(delta->x*x+delta->y*y+(1.0-delta->x-delta->y)*p);
}
-static inline ssize_t NearestNeighbor(const MagickRealType x)
+/*
+static inline ssize_t NearestNeighbor(const double x)
{
if (x >= 0.0)
return((ssize_t) (x+0.5));
return((ssize_t) (x-0.5));
}
+*/
MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
const CacheView *image_view,const PixelChannel channel,
MagickBooleanType
status;
- MagickRealType
+ double
alpha[16],
gamma,
pixels[16];
x_offset,
y_offset;
+ PixelInterpolateMethod
+ interpolate;
+
assert(image != (Image *) NULL);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
assert(image_view != (CacheView *) NULL);
status=MagickTrue;
*pixel=0.0;
- traits=GetPixelChannelMapTraits(image,channel);
+ traits=GetPixelChannelTraits(image,channel);
x_offset=(ssize_t) floor(x);
y_offset=(ssize_t) floor(y);
- switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
+ interpolate = method;
+ if ( interpolate == UndefinedInterpolatePixel )
+ interpolate = image->interpolate;
+ switch (interpolate)
{
- case AverageInterpolatePixel:
+ case AverageInterpolatePixel: /* nearest 4 neighbours */
+ case Average9InterpolatePixel: /* nearest 9 neighbours */
+ case Average16InterpolatePixel: /* nearest 16 neighbours */
{
- p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
+ size_t
+ count=2; /* size of the area to average - default nearest 4 */
+
+ if (interpolate == Average9InterpolatePixel)
+ {
+ count=3;
+ x_offset=(ssize_t) (floor(x+0.5)-1);
+ y_offset=(ssize_t) (floor(y+0.5)-1);
+ }
+ else if (interpolate == Average16InterpolatePixel)
+ {
+ count=4;
+ x_offset--;
+ y_offset--;
+ }
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,count,count,
exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
break;
}
+
+ count*=count; /* Number of pixels to Average */
if ((traits & BlendPixelTrait) == 0)
- for (i=0; i < 16; i++)
+ for (i=0; i < (ssize_t) count; i++)
{
alpha[i]=1.0;
- pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
}
else
- for (i=0; i < 16; i++)
+ for (i=0; i < (ssize_t) count; i++)
{
alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
GetPixelChannels(image));
pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
}
- for (i=0; i < 16; i++)
+ for (i=0; i < (ssize_t) count; i++)
{
- gamma=1.0/(fabs((double) alpha[i]) <= MagickEpsilon ? 1.0 : alpha[i]);
- *pixel+=gamma*0.0625*pixels[i];
+ gamma=MagickEpsilonReciprocal(alpha[i])/count;
+ *pixel+=gamma*pixels[i];
}
break;
}
- case BicubicInterpolatePixel:
+ case BilinearInterpolatePixel:
+ default:
{
- MagickRealType
- u[4],
- v[4];
-
PointInfo
- delta;
+ delta,
+ epsilon;
- p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
- exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
break;
}
if ((traits & BlendPixelTrait) == 0)
- for (i=0; i < 16; i++)
+ for (i=0; i < 4; i++)
{
alpha[i]=1.0;
- pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
}
else
- for (i=0; i < 16; i++)
+ for (i=0; i < 4; i++)
{
alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
GetPixelChannels(image));
}
delta.x=x-x_offset;
delta.y=y-y_offset;
- for (i=0; i < 4; i++)
- {
- u[0]=(pixels[4*i+3]-pixels[4*i+2])-(pixels[4*i+0]-pixels[4*i+1]);
- u[1]=(pixels[4*i+0]-pixels[4*i+1])-u[0];
- u[2]=pixels[4*i+2]-pixels[4*i+0];
- u[3]=pixels[4*i+1];
- v[i]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
- u[2])+u[3];
- }
- u[0]=(v[3]-v[2])-(v[0]-v[1]);
- u[1]=(v[0]-v[1])-u[0];
- u[2]=v[2]-v[0];
- u[3]=v[1];
- *pixel=(delta.y*delta.y*delta.y*u[0])+(delta.y*delta.y*u[1])+(delta.y*
- u[2])+u[3];
+ 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=MagickEpsilonReciprocal(gamma);
+ *pixel=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
+ (epsilon.x*pixels[2]+delta.x*pixels[3]));
break;
}
- case BilinearInterpolatePixel:
- default:
+ case BlendInterpolatePixel:
{
- PointInfo
- delta,
- epsilon;
-
p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
if (p == (const Quantum *) NULL)
{
GetPixelChannels(image));
pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
}
- 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=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
- (epsilon.x*pixels[2]+delta.x*pixels[3]));
+ gamma=1.0; /* number of pixels blended together (its variable) */
+ for (i=0; i <= 1L; i++) {
+ if ( y-y_offset >= 0.75 ) { /* take right pixels */
+ alpha[i] = alpha[i+2];
+ pixels[i] = pixels[i+2];
+ }
+ else if ( y-y_offset > 0.25 ) {
+ gamma = 2.0; /* blend both pixels in row */
+ alpha[i] += alpha[i+2]; /* add up alpha weights */
+ pixels[i] += pixels[i+2];
+ }
+ }
+ if ( x-x_offset >= 0.75 ) { /* take bottom row blend */
+ alpha[0] = alpha[1];
+ pixels[0] = pixels[1];
+ }
+ else if ( x-x_offset > 0.25 ) {
+ gamma *= 2.0; /* blend both rows */
+ alpha[0] += alpha[1]; /* add up alpha weights */
+ pixels[0] += pixels[1];
+ }
+ if (channel != AlphaPixelChannel)
+ gamma=MagickEpsilonReciprocal(alpha[0]); /* (color) 1/alpha_weights */
+ else
+ gamma=MagickEpsilonReciprocal(gamma); /* (alpha) 1/number_of_pixels */
+ *pixel=gamma*pixels[0];
+ break;
+ }
+ case CatromInterpolatePixel:
+ {
+ double
+ cx[4],
+ cy[4];
+
+ p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
+ exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ if ((traits & BlendPixelTrait) == 0)
+ for (i=0; i < 16; i++)
+ {
+ alpha[i]=1.0;
+ pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
+ }
+ else
+ for (i=0; i < 16; i++)
+ {
+ alpha[i]=QuantumScale*GetPixelAlpha(image,p+i*
+ GetPixelChannels(image));
+ pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
+ }
+ CatromWeights((double) (x-x_offset),&cx);
+ CatromWeights((double) (y-y_offset),&cy);
+ gamma=(channel == AlphaPixelChannel ? (double) 1.0 :
+ MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
+ alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
+ alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
+ alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
+ cx[2]*alpha[14]+cx[3]*alpha[15])));
+ *pixel=gamma*(cy[0]*(cx[0]*pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+
+ cx[3]*pixels[3])+cy[1]*(cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*
+ pixels[6]+cx[3]*pixels[7])+cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+
+ cx[2]*pixels[10]+cx[3]*pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*
+ pixels[13]+cx[2]*pixels[14]+cx[3]*pixels[15]));
break;
}
+#if 0
+ /* deprecated useless and very slow interpolator */
case FilterInterpolatePixel:
{
CacheView
status=MagickFalse;
break;
}
- filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
- exception);
+ filter_image=ResizeImage(excerpt_image,1,1,image->filter,exception);
excerpt_image=DestroyImage(excerpt_image);
if (filter_image == (Image *) NULL)
break;
- filter_view=AcquireCacheView(filter_image);
+ filter_view=AcquireVirtualCacheView(filter_image,exception);
p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
if (p == (const Quantum *) NULL)
status=MagickFalse;
filter_image=DestroyImage(filter_image);
break;
}
+#endif
case IntegerInterpolatePixel:
{
p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
*pixel=(double) GetPixelChannel(image,channel,p);
break;
}
- case NearestNeighborInterpolatePixel:
+ case NearestInterpolatePixel:
{
- p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
- NearestNeighbor(y),1,1,exception);
+ x_offset=(ssize_t) floor(x+0.5);
+ y_offset=(ssize_t) floor(y+0.5);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
for (i=0; i < 4; i++)
{
alpha[i]=1.0;
- pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
}
else
for (i=0; i < 4; i++)
*/
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);
+ gamma=MagickEpsilonReciprocal(gamma);
*pixel=gamma*MeshInterpolate(&delta,pixels[2],pixels[3],
pixels[0]);
}
*/
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);
+ gamma=MagickEpsilonReciprocal(gamma);
*pixel=gamma*MeshInterpolate(&delta,pixels[1],pixels[0],
pixels[3]);
}
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);
+ gamma=MagickEpsilonReciprocal(gamma);
*pixel=gamma*MeshInterpolate(&delta,pixels[0],pixels[1],
pixels[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);
+ gamma=MagickEpsilonReciprocal(gamma);
*pixel=gamma*MeshInterpolate(&delta,pixels[3],pixels[2],
pixels[1]);
}
}
case SplineInterpolatePixel:
{
- MagickRealType
- dx,
- dy;
-
- PointInfo
- delta;
-
- ssize_t
- j,
- n;
+ double
+ cx[4],
+ cy[4];
p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
exception);
for (i=0; i < 16; i++)
{
alpha[i]=1.0;
- pixels[i]=(MagickRealType) p[i*GetPixelChannels(image)+channel];
+ pixels[i]=(double) p[i*GetPixelChannels(image)+channel];
}
else
for (i=0; i < 16; i++)
GetPixelChannels(image));
pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
}
- 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+=gamma*dx*dy*pixels[n];
- n++;
- }
- }
+ SplineWeights((double) (x-x_offset),&cx);
+ SplineWeights((double) (y-y_offset),&cy);
+ gamma=(channel == AlphaPixelChannel ? (double) 1.0 :
+ MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
+ alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
+ alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
+ alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
+ cx[2]*alpha[14]+cx[3]*alpha[15])));
+ *pixel=gamma*(cy[0]*(cx[0]*pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+
+ cx[3]*pixels[3])+cy[1]*(cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*
+ pixels[6]+cx[3]*pixels[7])+cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+
+ cx[2]*pixels[10]+cx[3]*pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*
+ pixels[13]+cx[2]*pixels[14]+cx[3]*pixels[15]));
break;
}
}
% floating point coordinate and the pixels surrounding that coordinate. No
% pixel area resampling, or scaling of the result is performed.
%
+% Interpolation is restricted to just the current channel setting of the
+% destination image into which the color is to be stored
+%
% The format of the InterpolatePixelChannels method is:
%
% MagickBooleanType InterpolatePixelChannels(const Image *source,
%
% o source_view: the source view.
%
-% o destination: the destination image.
+% o destination: the destination image, for the interpolated color
%
% o method: the pixel color interpolation method.
%
MagickBooleanType
status;
- MagickRealType
+ double
alpha[16],
gamma,
pixels[16];
x_offset,
y_offset;
+ PixelInterpolateMethod
+ interpolate;
+
assert(source != (Image *) NULL);
assert(source != (Image *) NULL);
assert(source->signature == MagickSignature);
status=MagickTrue;
x_offset=(ssize_t) floor(x);
y_offset=(ssize_t) floor(y);
- switch (method == UndefinedInterpolatePixel ? source->interpolate : method)
+ interpolate = method;
+ if ( interpolate == UndefinedInterpolatePixel )
+ interpolate = source->interpolate;
+ switch (interpolate)
{
- case AverageInterpolatePixel:
+ case AverageInterpolatePixel: /* nearest 4 neighbours */
+ case Average9InterpolatePixel: /* nearest 9 neighbours */
+ case Average16InterpolatePixel: /* nearest 16 neighbours */
{
- p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
+ size_t
+ count=2; /* size of the area to average - default nearest 4 */
+
+ if (interpolate == Average9InterpolatePixel)
+ {
+ count=3;
+ x_offset=(ssize_t) (floor(x+0.5)-1);
+ y_offset=(ssize_t) (floor(y+0.5)-1);
+ }
+ else if (interpolate == Average16InterpolatePixel)
+ {
+ count=4;
+ x_offset--;
+ y_offset--;
+ }
+ p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,count,count,
exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
break;
}
+ count*=count; /* Number of pixels to Average */
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
{
double
register ssize_t
j;
- channel=GetPixelChannelMapChannel(source,i);
- traits=GetPixelChannelMapTraits(source,channel);
- destination_traits=GetPixelChannelMapTraits(destination,channel);
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
- for (j=0; j < 16; j++)
- pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
+ for (j=0; j < (ssize_t) count; j++)
+ pixels[j]=(double) p[j*GetPixelChannels(source)+i];
sum=0.0;
if ((traits & BlendPixelTrait) == 0)
{
- for (j=0; j < 16; j++)
- sum+=0.0625*pixels[j];
+ for (j=0; j < (ssize_t) count; j++)
+ sum+=pixels[j];
+ sum/=count;
SetPixelChannel(destination,channel,ClampToQuantum(sum),pixel);
continue;
}
- for (j=0; j < 16; j++)
+ for (j=0; j < (ssize_t) count; j++)
{
alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
GetPixelChannels(source));
pixels[j]*=alpha[j];
- gamma=1.0/(fabs((double) alpha[j]) <= MagickEpsilon ? 1.0 : alpha[j]);
- sum+=gamma*0.0625*pixels[j];
+ gamma=MagickEpsilonReciprocal(alpha[j]);
+ sum+=gamma*pixels[j];
}
+ sum/=count;
SetPixelChannel(destination,channel,ClampToQuantum(sum),pixel);
}
break;
}
- case BicubicInterpolatePixel:
- {
- MagickRealType
- u[4],
- v[4];
-
- PointInfo
- delta;
-
- p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
- exception);
- if (p == (const Quantum *) NULL)
- {
- status=MagickFalse;
- break;
- }
- for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
- {
- register ssize_t
- j;
-
- channel=GetPixelChannelMapChannel(source,i);
- traits=GetPixelChannelMapTraits(source,channel);
- destination_traits=GetPixelChannelMapTraits(destination,channel);
- if ((traits == UndefinedPixelTrait) ||
- (destination_traits == UndefinedPixelTrait))
- continue;
- if ((traits & BlendPixelTrait) == 0)
- for (j=0; j < 16; j++)
- {
- alpha[j]=1.0;
- pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
- }
- else
- for (j=0; j < 16; j++)
- {
- alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
- GetPixelChannels(source));
- pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
- }
- delta.x=x-x_offset;
- delta.y=y-y_offset;
- for (j=0; j < 4; j++)
- {
- u[0]=(pixels[4*j+3]-pixels[4*j+2])-(pixels[4*j+0]-pixels[4*j+1]);
- u[1]=(pixels[4*j+0]-pixels[4*j+1])-u[0];
- u[2]=pixels[4*j+2]-pixels[4*j+0];
- u[3]=pixels[4*j+1];
- v[j]=(delta.x*delta.x*delta.x*u[0])+(delta.x*delta.x*u[1])+(delta.x*
- u[2])+u[3];
- }
- u[0]=(v[3]-v[2])-(v[0]-v[1]);
- u[1]=(v[0]-v[1])-u[0];
- u[2]=v[2]-v[0];
- u[3]=v[1];
- SetPixelChannel(destination,channel,ClampToQuantum((delta.y*delta.y*
- delta.y*u[0])+(delta.y*delta.y*u[1])+(delta.y*u[2])+u[3]),pixel);
- }
- break;
- }
case BilinearInterpolatePixel:
default:
{
delta,
epsilon;
- channel=GetPixelChannelMapChannel(source,i);
- traits=GetPixelChannelMapTraits(source,channel);
- destination_traits=GetPixelChannelMapTraits(destination,channel);
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
delta.y=y-y_offset;
epsilon.x=1.0-delta.x;
epsilon.y=1.0-delta.y;
- pixels[0]=(MagickRealType) p[i];
- pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
- pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
- pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
+ pixels[0]=(double) p[i];
+ pixels[1]=(double) p[GetPixelChannels(source)+i];
+ pixels[2]=(double) p[2*GetPixelChannels(source)+i];
+ pixels[3]=(double) p[3*GetPixelChannels(source)+i];
if ((traits & BlendPixelTrait) == 0)
{
gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
- gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ gamma=MagickEpsilonReciprocal(gamma);
SetPixelChannel(destination,channel,ClampToQuantum(gamma*(epsilon.y*
(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*(epsilon.x*
pixels[2]+delta.x*pixels[3]))),pixel);
pixels[3]*=alpha[3];
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);
+ gamma=MagickEpsilonReciprocal(gamma);
SetPixelChannel(destination,channel,ClampToQuantum(gamma*(epsilon.y*
(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+
delta.x*pixels[3]))),pixel);
}
break;
}
+ case BlendInterpolatePixel:
+ {
+ p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,2,2,exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
+ {
+ register ssize_t
+ j;
+
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (destination_traits == UndefinedPixelTrait))
+ continue;
+ if ((traits & BlendPixelTrait) == 0)
+ for (j=0; j < 4; j++)
+ {
+ alpha[j]=1.0;
+ pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+channel];
+ }
+ else
+ for (j=0; j < 4; j++)
+ {
+ alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
+ GetPixelChannels(source));
+ pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+channel];
+ }
+ gamma=1.0; /* number of pixels blended together (its variable) */
+ for (j=0; j <= 1L; j++) {
+ if ( y-y_offset >= 0.75 ) { /* take right pixels */
+ alpha[j] = alpha[j+2];
+ pixels[j] = pixels[j+2];
+ }
+ else if ( y-y_offset > 0.25 ) {
+ gamma = 2.0; /* blend both pixels in row */
+ alpha[j] += alpha[j+2]; /* add up alpha weights */
+ pixels[j] += pixels[j+2];
+ }
+ }
+ if ( x-x_offset >= 0.75 ) { /* take bottom row blend */
+ alpha[0] = alpha[1];
+ pixels[0] = pixels[1];
+ }
+ else if ( x-x_offset > 0.25 ) {
+ gamma *= 2.0; /* blend both rows */
+ alpha[0] += alpha[1]; /* add up alpha weights */
+ pixels[0] += pixels[1];
+ }
+ if ((traits & BlendPixelTrait) == 0)
+ gamma=MagickEpsilonReciprocal(alpha[0]); /* (color) 1/alpha_weights */
+ else
+ gamma=MagickEpsilonReciprocal(gamma); /* (alpha) 1/number_of_pixels */
+ SetPixelChannel(destination,channel,ClampToQuantum(gamma*pixels[0]),
+ pixel);
+ }
+ break;
+ }
+ case CatromInterpolatePixel:
+ {
+ double
+ cx[4],
+ cy[4];
+
+ p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
+ exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
+ {
+ register ssize_t
+ j;
+
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
+ if ((traits == UndefinedPixelTrait) ||
+ (destination_traits == UndefinedPixelTrait))
+ continue;
+ if ((traits & BlendPixelTrait) == 0)
+ for (j=0; j < 16; j++)
+ {
+ alpha[j]=1.0;
+ pixels[j]=(double) p[j*GetPixelChannels(source)+i];
+ }
+ else
+ for (j=0; j < 16; j++)
+ {
+ alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
+ GetPixelChannels(source));
+ pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
+ }
+ CatromWeights((double) (x-x_offset),&cx);
+ CatromWeights((double) (y-y_offset),&cy);
+ gamma=((traits & BlendPixelTrait) ? (double) (1.0) :
+ MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
+ alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
+ alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
+ alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
+ cx[2]*alpha[14]+cx[3]*alpha[15])));
+ SetPixelChannel(destination,channel,ClampToQuantum(gamma*(cy[0]*(cx[0]*
+ pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+cx[3]*pixels[3])+cy[1]*
+ (cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*pixels[6]+cx[3]*pixels[7])+
+ cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+cx[2]*pixels[10]+cx[3]*
+ pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*pixels[13]+cx[2]*
+ pixels[14]+cx[3]*pixels[15]))),pixel);
+ }
+ break;
+ }
+#if 0
+ /* deprecated useless and very slow interpolator */
case FilterInterpolatePixel:
{
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
RectangleInfo
geometry;
- channel=GetPixelChannelMapChannel(source,i);
- traits=GetPixelChannelMapTraits(source,channel);
- destination_traits=GetPixelChannelMapTraits(destination,channel);
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
status=MagickFalse;
continue;
}
- filter_source=ResizeImage(excerpt_source,1,1,source->filter,
- source->blur,exception);
+ filter_source=ResizeImage(excerpt_source,1,1,source->filter,exception);
excerpt_source=DestroyImage(excerpt_source);
if (filter_source == (Image *) NULL)
continue;
- filter_view=AcquireCacheView(filter_source);
+ filter_view=AcquireVirtualCacheView(filter_source,exception);
p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
if (p == (const Quantum *) NULL)
status=MagickFalse;
}
break;
}
+#endif
case IntegerInterpolatePixel:
{
p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
}
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
{
- channel=GetPixelChannelMapChannel(source,i);
- traits=GetPixelChannelMapTraits(source,channel);
- destination_traits=GetPixelChannelMapTraits(destination,channel);
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
}
break;
}
- case NearestNeighborInterpolatePixel:
+ case NearestInterpolatePixel:
{
- p=GetCacheViewVirtualPixels(source_view,NearestNeighbor(x),
- NearestNeighbor(y),1,1,exception);
+ x_offset=(ssize_t) floor(x+0.5);
+ y_offset=(ssize_t) floor(y+0.5);
+ p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,1,1,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
}
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
{
- channel=GetPixelChannelMapChannel(source,i);
- traits=GetPixelChannelMapTraits(source,channel);
- destination_traits=GetPixelChannelMapTraits(destination,channel);
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
delta,
luminance;
- channel=GetPixelChannelMapChannel(source,i);
- traits=GetPixelChannelMapTraits(source,channel);
- destination_traits=GetPixelChannelMapTraits(destination,channel);
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
- pixels[0]=(MagickRealType) p[i];
- pixels[1]=(MagickRealType) p[GetPixelChannels(source)+i];
- pixels[2]=(MagickRealType) p[2*GetPixelChannels(source)+i];
- pixels[3]=(MagickRealType) p[3*GetPixelChannels(source)+i];
+ pixels[0]=(double) p[i];
+ pixels[1]=(double) p[GetPixelChannels(source)+i];
+ pixels[2]=(double) p[2*GetPixelChannels(source)+i];
+ pixels[3]=(double) p[3*GetPixelChannels(source)+i];
if ((traits & BlendPixelTrait) == 0)
{
alpha[0]=1.0;
}
delta.x=x-x_offset;
delta.y=y-y_offset;
- luminance.x=GetPixelLuminance(source,p)-(double)
- GetPixelLuminance(source,p+3*GetPixelChannels(source));
- luminance.y=GetPixelLuminance(source,p+GetPixelChannels(source))-
- (double) GetPixelLuminance(source,p+2*GetPixelChannels(source));
- if (fabs(luminance.x) < fabs(luminance.y))
+ luminance.x=fabs((double)(
+ GetPixelLuminance(source,p)
+ -GetPixelLuminance(source,p+3*GetPixelChannels(source))));
+ luminance.y=fabs((double)(
+ GetPixelLuminance(source,p+GetPixelChannels(source))
+ -GetPixelLuminance(source,p+2*GetPixelChannels(source))));
+ if (luminance.x < luminance.y)
{
/*
Diagonal 0-3 NW-SE.
*/
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);
+ gamma=MagickEpsilonReciprocal(gamma);
SetPixelChannel(destination,channel,ClampToQuantum(gamma*
MeshInterpolate(&delta,pixels[2],pixels[3],pixels[0])),pixel);
}
*/
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);
+ gamma=MagickEpsilonReciprocal(gamma);
SetPixelChannel(destination,channel,ClampToQuantum(gamma*
MeshInterpolate(&delta,pixels[1],pixels[0],pixels[3])),pixel);
}
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);
+ gamma=MagickEpsilonReciprocal(gamma);
SetPixelChannel(destination,channel,ClampToQuantum(gamma*
MeshInterpolate(&delta,pixels[0],pixels[1],pixels[2])),pixel);
}
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);
+ gamma=MagickEpsilonReciprocal(gamma);
SetPixelChannel(destination,channel,ClampToQuantum(gamma*
MeshInterpolate(&delta,pixels[3],pixels[2],pixels[1])),pixel);
}
}
case SplineInterpolatePixel:
{
+ double
+ cx[4],
+ cy[4];
+
p=GetCacheViewVirtualPixels(source_view,x_offset-1,y_offset-1,4,4,
exception);
if (p == (const Quantum *) NULL)
}
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
{
- double
- sum;
-
- MagickRealType
- dx,
- dy;
-
- PointInfo
- delta;
-
register ssize_t
j;
- ssize_t
- k,
- n;
-
- channel=GetPixelChannelMapChannel(source,i);
- traits=GetPixelChannelMapTraits(source,channel);
- destination_traits=GetPixelChannelMapTraits(destination,channel);
+ channel=GetPixelChannelChannel(source,i);
+ traits=GetPixelChannelTraits(source,channel);
+ destination_traits=GetPixelChannelTraits(destination,channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
for (j=0; j < 16; j++)
{
alpha[j]=1.0;
- pixels[j]=(MagickRealType) p[j*GetPixelChannels(source)+i];
+ pixels[j]=(double) p[j*GetPixelChannels(source)+i];
}
else
for (j=0; j < 16; j++)
GetPixelChannels(source));
pixels[j]=alpha[j]*p[j*GetPixelChannels(source)+i];
}
- delta.x=x-x_offset;
- delta.y=y-y_offset;
- sum=0.0;
- n=0;
- for (j=(-1); j < 3L; j++)
- {
- dy=CubicWeightingFunction((MagickRealType) j-delta.y);
- for (k=(-1); k < 3L; k++)
- {
- dx=CubicWeightingFunction(delta.x-(MagickRealType) k);
- gamma=1.0/(fabs((double) alpha[n]) <= MagickEpsilon ? 1.0 :
- alpha[n]);
- sum+=gamma*dx*dy*pixels[n];
- n++;
- }
- }
- SetPixelChannel(destination,channel,p[i],pixel);
+ SplineWeights((double) (x-x_offset),&cx);
+ SplineWeights((double) (y-y_offset),&cy);
+ gamma=((traits & BlendPixelTrait) ? (double) (1.0) :
+ MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
+ alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
+ alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
+ alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
+ cx[2]*alpha[14]+cx[3]*alpha[15])));
+ SetPixelChannel(destination,channel,ClampToQuantum(gamma*(cy[0]*(cx[0]*
+ pixels[0]+cx[1]*pixels[1]+cx[2]*pixels[2]+cx[3]*pixels[3])+cy[1]*
+ (cx[0]*pixels[4]+cx[1]*pixels[5]+cx[2]*pixels[6]+cx[3]*pixels[7])+
+ cy[2]*(cx[0]*pixels[8]+cx[1]*pixels[9]+cx[2]*pixels[10]+cx[3]*
+ pixels[11])+cy[3]*(cx[0]*pixels[12]+cx[1]*pixels[13]+cx[2]*
+ pixels[14]+cx[3]*pixels[15]))),pixel);
}
break;
}
% floating point coordinate and the pixels surrounding that coordinate. No
% pixel area resampling, or scaling of the result is performed.
%
+% Interpolation is restricted to just RGBKA channels.
+%
% The format of the InterpolatePixelInfo method is:
%
% MagickBooleanType InterpolatePixelInfo(const Image *image,
*/
static inline void AlphaBlendPixelInfo(const Image *image,
- const Quantum *pixel,PixelInfo *pixel_info,MagickRealType *alpha)
+ const Quantum *pixel,PixelInfo *pixel_info,double *alpha)
{
- if (image->matte == MagickFalse)
+ if (image->alpha_trait != BlendPixelTrait)
{
*alpha=1.0;
- pixel_info->red=(MagickRealType) GetPixelRed(image,pixel);
- pixel_info->green=(MagickRealType) GetPixelGreen(image,pixel);
- pixel_info->blue=(MagickRealType) GetPixelBlue(image,pixel);
+ pixel_info->red=(double) GetPixelRed(image,pixel);
+ pixel_info->green=(double) GetPixelGreen(image,pixel);
+ pixel_info->blue=(double) GetPixelBlue(image,pixel);
pixel_info->black=0.0;
if (image->colorspace == CMYKColorspace)
- pixel_info->black=(MagickRealType) GetPixelBlack(image,pixel);
- pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
+ pixel_info->black=(double) GetPixelBlack(image,pixel);
+ pixel_info->alpha=(double) GetPixelAlpha(image,pixel);
return;
}
*alpha=QuantumScale*GetPixelAlpha(image,pixel);
pixel_info->black=0.0;
if (image->colorspace == CMYKColorspace)
pixel_info->black=(*alpha*GetPixelBlack(image,pixel));
- pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
-}
-
-static void BicubicInterpolate(const PixelInfo *pixels,const double dx,
- PixelInfo *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].alpha-pixels[2].alpha)-(pixels[0].alpha-pixels[1].alpha);
- q=(pixels[0].alpha-pixels[1].alpha)-p;
- r=pixels[2].alpha-pixels[0].alpha;
- s=pixels[1].alpha;
- pixel->alpha=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
- if (pixel->colorspace == CMYKColorspace)
- {
- p=(pixels[3].black-pixels[2].black)-(pixels[0].black-pixels[1].black);
- q=(pixels[0].black-pixels[1].black)-p;
- r=pixels[2].black-pixels[0].black;
- s=pixels[1].black;
- pixel->black=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
- }
+ pixel_info->alpha=(double) GetPixelAlpha(image,pixel);
}
MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
MagickBooleanType
status;
- MagickRealType
+ double
alpha[16],
gamma;
x_offset,
y_offset;
+ PixelInterpolateMethod
+ interpolate;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
assert(image_view != (CacheView *) NULL);
status=MagickTrue;
x_offset=(ssize_t) floor(x);
y_offset=(ssize_t) floor(y);
- switch (method == UndefinedInterpolatePixel ? image->interpolate : method)
+ interpolate = method;
+ if ( interpolate == UndefinedInterpolatePixel )
+ interpolate = image->interpolate;
+ switch (interpolate)
{
- case AverageInterpolatePixel:
+ case AverageInterpolatePixel: /* nearest 4 neighbours */
+ case Average9InterpolatePixel: /* nearest 9 neighbours */
+ case Average16InterpolatePixel: /* nearest 16 neighbours */
{
- p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
+ size_t
+ count=2; /* size of the area to average - default nearest 4 */
+
+ if (interpolate == Average9InterpolatePixel)
+ {
+ count=3;
+ x_offset=(ssize_t) (floor(x+0.5)-1);
+ y_offset=(ssize_t) (floor(y+0.5)-1);
+ }
+ else if (interpolate == Average16InterpolatePixel)
+ {
+ count=4;
+ x_offset--;
+ y_offset--;
+ }
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,count,count,
exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
break;
}
- AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
- AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
- AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
- AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
- AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
- AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
- AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
- AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
- 10);
- AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
- 11);
- AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
- 12);
- AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
- 13);
- AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
- 14);
- AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
- 15);
pixel->red=0.0;
pixel->green=0.0;
pixel->blue=0.0;
pixel->black=0.0;
pixel->alpha=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;
- if (image->colorspace == CMYKColorspace)
- pixel->black+=gamma*0.0625*pixels[i].black;
- pixel->alpha+=0.0625*pixels[i].alpha;
- }
+ count*=count; /* number of pixels - square of size */
+ for (i=0; i < (ssize_t) count; i++)
+ {
+ AlphaBlendPixelInfo(image,p,pixels,alpha);
+ gamma=MagickEpsilonReciprocal(alpha[0]);
+ pixel->red += gamma*pixels[0].red;
+ pixel->green += gamma*pixels[0].green;
+ pixel->blue += gamma*pixels[0].blue;
+ pixel->black += gamma*pixels[0].black;
+ pixel->alpha += pixels[0].alpha;
+ p += GetPixelChannels(image);
+ }
+ gamma=1.0/count; /* average weighting of each pixel in area */
+ pixel->red *= gamma;
+ pixel->green *= gamma;
+ pixel->blue *= gamma;
+ pixel->black *= gamma;
+ pixel->alpha *= gamma;
break;
}
- case BicubicInterpolatePixel:
+ case BackgroundInterpolatePixel:
{
- PixelInfo
- u[4];
-
- PointInfo
- delta;
-
- p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
- exception);
- if (p == (const Quantum *) NULL)
- {
- status=MagickFalse;
- break;
- }
- AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
- AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
- AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
- AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
- AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
- AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
- AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
- AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
- 10);
- AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
- 11);
- AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
- 12);
- AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
- 13);
- AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
- 14);
- AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),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);
+ *pixel = image->background_color; /* Copy PixelInfo Structure */
break;
}
case BilinearInterpolatePixel:
status=MagickFalse;
break;
}
- AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
+ for (i=0; i < 4L; i++)
+ AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
delta.x=x-x_offset;
delta.y=y-y_offset;
epsilon.x=1.0-delta.x;
epsilon.y=1.0-delta.y;
gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
(epsilon.x*alpha[2]+delta.x*alpha[3])));
- gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ gamma=MagickEpsilonReciprocal(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].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
pixels[3].black));
gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
- gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ gamma=MagickEpsilonReciprocal(gamma);
pixel->alpha=(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
pixels[3].alpha));
break;
}
+ case BlendInterpolatePixel:
+ {
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ for (i=0; i < 4L; i++)
+ AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
+ gamma=1.0; /* number of pixels blended together (its variable) */
+ for (i=0; i <= 1L; i++) {
+ if ( y-y_offset >= 0.75 ) { /* take right pixels */
+ alpha[i] = alpha[i+2];
+ pixels[i] = pixels[i+2];
+ }
+ else if ( y-y_offset > 0.25 ) {
+ gamma = 2.0; /* blend both pixels in row */
+ alpha[i] += alpha[i+2]; /* add up alpha weights */
+ pixels[i].red += pixels[i+2].red;
+ pixels[i].green += pixels[i+2].green;
+ pixels[i].blue += pixels[i+2].blue;
+ pixels[i].black += pixels[i+2].black;
+ pixels[i].alpha += pixels[i+2].alpha;
+ }
+ }
+ if ( x-x_offset >= 0.75 ) {
+ alpha[0] = alpha[1];
+ pixels[0] = pixels[1];
+ }
+ else if ( x-x_offset > 0.25 ) {
+ gamma *= 2.0; /* blend both rows */
+ alpha[0] += alpha[1]; /* add up alpha weights */
+ pixels[0].red += pixels[1].red;
+ pixels[0].green += pixels[1].green;
+ pixels[0].blue += pixels[1].blue;
+ pixels[0].black += pixels[1].black;
+ pixels[0].alpha += pixels[1].alpha;
+ }
+ gamma = 1.0/gamma;
+ alpha[0]=MagickEpsilonReciprocal(alpha[0]);
+ pixel->red = alpha[0]*pixels[0].red;
+ pixel->green = alpha[0]*pixels[0].green; /* divide by sum of alpha */
+ pixel->blue = alpha[0]*pixels[0].blue;
+ pixel->black = alpha[0]*pixels[0].black;
+ pixel->alpha = gamma*pixels[0].alpha; /* divide by number of pixels */
+ break;
+ }
+ case CatromInterpolatePixel:
+ {
+ double
+ cx[4],
+ cy[4];
+
+ p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
+ exception);
+ if (p == (const Quantum *) NULL)
+ {
+ status=MagickFalse;
+ break;
+ }
+ for (i=0; i < 16L; i++)
+ AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
+ CatromWeights((double) (x-x_offset),&cx);
+ CatromWeights((double) (y-y_offset),&cy);
+ pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*
+ pixels[1].red+cx[2]*pixels[2].red+cx[3]*
+ pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
+ pixels[5].red+cx[2]*pixels[6].red+cx[3]*
+ pixels[7].red)+cy[2]*(cx[0]*pixels[8].red+cx[1]*
+ pixels[9].red+cx[2]*pixels[10].red+cx[3]*
+ pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*
+ pixels[13].red+cx[2]*pixels[14].red+cx[3]*pixels[15].red));
+ pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*
+ pixels[1].green+cx[2]*pixels[2].green+cx[3]*
+ pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+cx[1]*
+ pixels[5].green+cx[2]*pixels[6].green+cx[3]*
+ pixels[7].green)+cy[2]*(cx[0]*pixels[8].green+cx[1]*
+ pixels[9].green+cx[2]*pixels[10].green+cx[3]*
+ pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+cx[1]*
+ pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
+ pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*
+ pixels[1].blue+cx[2]*pixels[2].blue+cx[3]*
+ pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]*
+ pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*
+ pixels[7].blue)+cy[2]*(cx[0]*pixels[8].blue+cx[1]*
+ pixels[9].blue+cx[2]*pixels[10].blue+cx[3]*
+ pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*
+ pixels[13].blue+cx[2]*pixels[14].blue+cx[3]*pixels[15].blue));
+ if (image->colorspace == CMYKColorspace)
+ pixel->black=(cy[0]*(cx[0]*pixels[0].black+cx[1]*
+ pixels[1].black+cx[2]*pixels[2].black+cx[3]*
+ pixels[3].black)+cy[1]*(cx[0]*pixels[4].black+cx[1]*
+ pixels[5].black+cx[2]*pixels[6].black+cx[3]*
+ pixels[7].black)+cy[2]*(cx[0]*pixels[8].black+cx[1]*
+ pixels[9].black+cx[2]*pixels[10].black+cx[3]*
+ pixels[11].black)+cy[3]*(cx[0]*pixels[12].black+cx[1]*
+ pixels[13].black+cx[2]*pixels[14].black+cx[3]*pixels[15].black));
+ pixel->alpha=(cy[0]*(cx[0]*pixels[0].alpha+cx[1]*
+ pixels[1].alpha+cx[2]*pixels[2].alpha+cx[3]*
+ pixels[3].alpha)+cy[1]*(cx[0]*pixels[4].alpha+cx[1]*
+ pixels[5].alpha+cx[2]*pixels[6].alpha+cx[3]*
+ pixels[7].alpha)+cy[2]*(cx[0]*pixels[8].alpha+cx[1]*
+ pixels[9].alpha+cx[2]*pixels[10].alpha+cx[3]*
+ pixels[11].alpha)+cy[3]*(cx[0]*pixels[12].alpha+cx[1]*
+ pixels[13].alpha+cx[2]*pixels[14].alpha+cx[3]*pixels[15].alpha));
+ break;
+ }
+#if 0
+ /* deprecated useless and very slow interpolator */
case FilterInterpolatePixel:
{
CacheView
status=MagickFalse;
break;
}
- filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
- exception);
+ filter_image=ResizeImage(excerpt_image,1,1,image->filter,exception);
excerpt_image=DestroyImage(excerpt_image);
if (filter_image == (Image *) NULL)
break;
- filter_view=AcquireCacheView(filter_image);
+ filter_view=AcquireVirtualCacheView(filter_image,exception);
p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
if (p != (const Quantum *) NULL)
GetPixelInfoPixel(image,p,pixel);
filter_image=DestroyImage(filter_image);
break;
}
+#endif
case IntegerInterpolatePixel:
{
p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
*/
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);
+ gamma=MagickEpsilonReciprocal(gamma);
pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
pixels[3].red,pixels[0].red);
pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
*/
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);
+ gamma=MagickEpsilonReciprocal(gamma);
pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
pixels[0].red,pixels[3].red);
pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
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);
+ gamma=MagickEpsilonReciprocal(gamma);
pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
pixels[1].red,pixels[2].red);
pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
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);
+ gamma=MagickEpsilonReciprocal(gamma);
pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
pixels[2].red,pixels[1].red);
pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
}
break;
}
- case NearestNeighborInterpolatePixel:
+ case NearestInterpolatePixel:
{
- p=GetCacheViewVirtualPixels(image_view,NearestNeighbor(x),
- NearestNeighbor(y),1,1,exception);
+ x_offset=(ssize_t) floor(x+0.5);
+ y_offset=(ssize_t) floor(y+0.5);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
}
case SplineInterpolatePixel:
{
- MagickRealType
- dx,
- dy;
-
- PointInfo
- delta;
-
- ssize_t
- j,
- n;
+ double
+ cx[4],
+ cy[4];
p=GetCacheViewVirtualPixels(image_view,x_offset-1,y_offset-1,4,4,
exception);
status=MagickFalse;
break;
}
- AlphaBlendPixelInfo(image,p,pixels+0,alpha+0);
- AlphaBlendPixelInfo(image,p+GetPixelChannels(image),pixels+1,alpha+1);
- AlphaBlendPixelInfo(image,p+2*GetPixelChannels(image),pixels+2,alpha+2);
- AlphaBlendPixelInfo(image,p+3*GetPixelChannels(image),pixels+3,alpha+3);
- AlphaBlendPixelInfo(image,p+4*GetPixelChannels(image),pixels+4,alpha+4);
- AlphaBlendPixelInfo(image,p+5*GetPixelChannels(image),pixels+5,alpha+5);
- AlphaBlendPixelInfo(image,p+6*GetPixelChannels(image),pixels+6,alpha+6);
- AlphaBlendPixelInfo(image,p+7*GetPixelChannels(image),pixels+7,alpha+7);
- AlphaBlendPixelInfo(image,p+8*GetPixelChannels(image),pixels+8,alpha+8);
- AlphaBlendPixelInfo(image,p+9*GetPixelChannels(image),pixels+9,alpha+9);
- AlphaBlendPixelInfo(image,p+10*GetPixelChannels(image),pixels+10,alpha+
- 10);
- AlphaBlendPixelInfo(image,p+11*GetPixelChannels(image),pixels+11,alpha+
- 11);
- AlphaBlendPixelInfo(image,p+12*GetPixelChannels(image),pixels+12,alpha+
- 12);
- AlphaBlendPixelInfo(image,p+13*GetPixelChannels(image),pixels+13,alpha+
- 13);
- AlphaBlendPixelInfo(image,p+14*GetPixelChannels(image),pixels+14,alpha+
- 14);
- AlphaBlendPixelInfo(image,p+15*GetPixelChannels(image),pixels+15,alpha+
- 15);
- pixel->red=0.0;
- pixel->green=0.0;
- pixel->blue=0.0;
- pixel->black=0.0;
- pixel->alpha=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;
- if (image->colorspace == CMYKColorspace)
- pixel->black+=gamma*dx*dy*pixels[n].black;
- pixel->alpha+=dx*dy*pixels[n].alpha;
- n++;
- }
- }
+ for (i=0; i < 16L; i++)
+ AlphaBlendPixelInfo(image,p+i*GetPixelChannels(image),pixels+i,alpha+i);
+ SplineWeights((double) (x-x_offset),&cx);
+ SplineWeights((double) (y-y_offset),&cy);
+ pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*
+ pixels[1].red+cx[2]*pixels[2].red+cx[3]*
+ pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
+ pixels[5].red+cx[2]*pixels[6].red+cx[3]*
+ pixels[7].red)+cy[2]*(cx[0]*pixels[8].red+cx[1]*
+ pixels[9].red+cx[2]*pixels[10].red+cx[3]*
+ pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*
+ pixels[13].red+cx[2]*pixels[14].red+cx[3]*pixels[15].red));
+ pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*
+ pixels[1].green+cx[2]*pixels[2].green+cx[3]*
+ pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+cx[1]*
+ pixels[5].green+cx[2]*pixels[6].green+cx[3]*
+ pixels[7].green)+cy[2]*(cx[0]*pixels[8].green+cx[1]*
+ pixels[9].green+cx[2]*pixels[10].green+cx[3]*
+ pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+cx[1]*
+ pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
+ pixel->blue=(cy[0]*(cx[0]*pixels[0].blue+cx[1]*
+ pixels[1].blue+cx[2]*pixels[2].blue+cx[3]*
+ pixels[3].blue)+cy[1]*(cx[0]*pixels[4].blue+cx[1]*
+ pixels[5].blue+cx[2]*pixels[6].blue+cx[3]*
+ pixels[7].blue)+cy[2]*(cx[0]*pixels[8].blue+cx[1]*
+ pixels[9].blue+cx[2]*pixels[10].blue+cx[3]*
+ pixels[11].blue)+cy[3]*(cx[0]*pixels[12].blue+cx[1]*
+ pixels[13].blue+cx[2]*pixels[14].blue+cx[3]*pixels[15].blue));
+ if (image->colorspace == CMYKColorspace)
+ pixel->black=(cy[0]*(cx[0]*pixels[0].black+cx[1]*
+ pixels[1].black+cx[2]*pixels[2].black+cx[3]*
+ pixels[3].black)+cy[1]*(cx[0]*pixels[4].black+cx[1]*
+ pixels[5].black+cx[2]*pixels[6].black+cx[3]*
+ pixels[7].black)+cy[2]*(cx[0]*pixels[8].black+cx[1]*
+ pixels[9].black+cx[2]*pixels[10].black+cx[3]*
+ pixels[11].black)+cy[3]*(cx[0]*pixels[12].black+cx[1]*
+ pixels[13].black+cx[2]*pixels[14].black+cx[3]*pixels[15].black));
+ pixel->alpha=(cy[0]*(cx[0]*pixels[0].alpha+cx[1]*
+ pixels[1].alpha+cx[2]*pixels[2].alpha+cx[3]*
+ pixels[3].alpha)+cy[1]*(cx[0]*pixels[4].alpha+cx[1]*
+ pixels[5].alpha+cx[2]*pixels[6].alpha+cx[3]*
+ pixels[7].alpha)+cy[2]*(cx[0]*pixels[8].alpha+cx[1]*
+ pixels[9].alpha+cx[2]*pixels[10].alpha+cx[3]*
+ pixels[11].alpha)+cy[3]*(cx[0]*pixels[12].alpha+cx[1]*
+ pixels[13].alpha+cx[2]*pixels[14].alpha+cx[3]*pixels[15].alpha));
break;
}
}
MagickExport MagickBooleanType IsFuzzyEquivalencePixel(const Image *source,
const Quantum *p,const Image *destination,const Quantum *q)
{
- MagickRealType
+ double
fuzz,
pixel;
- register MagickRealType
+ register double
distance,
scale;
- fuzz=MagickMax(source->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(
- destination->fuzz,(MagickRealType) MagickSQ1_2);
+ fuzz=MagickMax(source->fuzz,(double) MagickSQ1_2)*MagickMax(
+ destination->fuzz,(double) MagickSQ1_2);
scale=1.0;
distance=0.0;
- if (source->matte != MagickFalse)
+ if (source->alpha_trait == BlendPixelTrait)
{
/*
Transparencies are involved - set alpha distance
*/
- pixel=GetPixelAlpha(source,p)-(MagickRealType)
+ pixel=GetPixelAlpha(source,p)-(double)
GetPixelAlpha(destination,q);
distance=pixel*pixel;
if (distance > fuzz)
*/
distance*=3.0; /* rescale appropriately */
fuzz*=3.0;
- pixel=GetPixelRed(source,p)-(MagickRealType) GetPixelRed(destination,q);
+ pixel=GetPixelRed(source,p)-(double) GetPixelRed(destination,q);
if ((source->colorspace == HSLColorspace) ||
(source->colorspace == HSBColorspace) ||
(source->colorspace == HWBColorspace))
distance+=scale*pixel*pixel;
if (distance > fuzz)
return(MagickFalse);
- pixel=GetPixelGreen(source,p)-(MagickRealType) GetPixelGreen(destination,q);
+ pixel=GetPixelGreen(source,p)-(double) GetPixelGreen(destination,q);
distance+=scale*pixel*pixel;
if (distance > fuzz)
return(MagickFalse);
- pixel=GetPixelBlue(source,p)-(MagickRealType) GetPixelBlue(destination,q);
+ pixel=GetPixelBlue(source,p)-(double) GetPixelBlue(destination,q);
distance+=scale*pixel*pixel;
if (distance > fuzz)
return(MagickFalse);
MagickExport MagickBooleanType IsFuzzyEquivalencePixelInfo(const PixelInfo *p,
const PixelInfo *q)
{
- MagickRealType
+ double
fuzz,
pixel;
- register MagickRealType
+ register double
scale,
distance;
if ((p->fuzz == 0.0) && (q->fuzz == 0.0))
return(IsPixelInfoEquivalent(p,q));
if (p->fuzz == 0.0)
- fuzz=MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(q->fuzz,
- (MagickRealType) MagickSQ1_2);
+ fuzz=MagickMax(q->fuzz,(double) MagickSQ1_2)*MagickMax(q->fuzz,
+ (double) MagickSQ1_2);
else if (q->fuzz == 0.0)
- fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(p->fuzz,
- (MagickRealType) MagickSQ1_2);
+ fuzz=MagickMax(p->fuzz,(double) MagickSQ1_2)*MagickMax(p->fuzz,
+ (double) MagickSQ1_2);
else
- fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(q->fuzz,
- (MagickRealType) MagickSQ1_2);
+ fuzz=MagickMax(p->fuzz,(double) MagickSQ1_2)*MagickMax(q->fuzz,
+ (double) MagickSQ1_2);
scale=1.0;
distance=0.0;
- if ((p->matte != MagickFalse) || (q->matte != MagickFalse))
+ if ((p->alpha_trait == BlendPixelTrait) || (q->alpha_trait == BlendPixelTrait))
{
/*
Transparencies are involved - set alpha distance.
*/
- pixel=(p->matte != MagickFalse ? p->alpha : OpaqueAlpha)-
- (q->matte != MagickFalse ? q->alpha : OpaqueAlpha);
+ pixel=(p->alpha_trait == BlendPixelTrait ? p->alpha : OpaqueAlpha)-
+ (q->alpha_trait == BlendPixelTrait ? q->alpha : OpaqueAlpha);
distance=pixel*pixel;
if (distance > fuzz)
return(MagickFalse);
Generate a alpha scaling factor to generate a 4D cone on colorspace.
If one color is transparent, distance has no color component.
*/
- if (p->matte != MagickFalse)
+ if (p->alpha_trait == BlendPixelTrait)
scale=(QuantumScale*p->alpha);
- if (q->matte != MagickFalse)
+ if (q->alpha_trait == BlendPixelTrait)
scale*=(QuantumScale*q->alpha);
if (scale <= MagickEpsilon )
return(MagickTrue);
distance+=pixel*pixel*scale;
if (distance > fuzz)
return(MagickFalse);
- scale*=(MagickRealType) (QuantumScale*(QuantumRange-p->black));
- scale*=(MagickRealType) (QuantumScale*(QuantumRange-q->black));
+ scale*=(double) (QuantumScale*(QuantumRange-p->black));
+ scale*=(double) (QuantumScale*(QuantumRange-q->black));
}
/*
RGB or CMY color cube.
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetPixelChannelMapMask() sets the pixel channel map from the specified
+% SetPixelChannelMask() sets the pixel channel map from the specified
% channel mask.
%
-% The format of the SetPixelChannelMapMask method is:
+% The format of the SetPixelChannelMask method is:
%
-% void SetPixelChannelMapMask(Image *image,const ChannelType channel_mask)
+% void SetPixelChannelMask(Image *image,const ChannelType channel_mask)
%
% A description of each parameter follows:
%
% o channel_mask: the channel mask.
%
*/
-MagickExport void SetPixelChannelMapMask(Image *image,
+MagickExport void SetPixelChannelMask(Image *image,
const ChannelType channel_mask)
{
#define GetChannelBit(mask,bit) (((size_t) (mask) >> (size_t) (bit)) & 0x01)
register ssize_t
i;
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(PixelEvent,GetMagickModule(),"%s[%08x]", \
+ image->filename,channel_mask); \
image->channel_mask=channel_mask;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel
channel;
- channel=GetPixelChannelMapChannel(image,i);
- SetPixelChannelMapTraits(image,channel,
+ channel=GetPixelChannelChannel(image,i);
+ SetPixelChannelTraits(image,channel,
GetChannelBit(channel_mask,channel) == 0 ? CopyPixelTrait :
- image->matte == MagickFalse || (channel == AlphaPixelChannel) ?
- UpdatePixelTrait : (PixelTrait) (UpdatePixelTrait | BlendPixelTrait));
+ image->alpha_trait != BlendPixelTrait || (channel == AlphaPixelChannel) ?
+ UpdatePixelTrait : (PixelTrait) (UpdatePixelTrait | image->alpha_trait));
}
if (image->storage_class == PseudoClass)
- SetPixelChannelMapTraits(image,IndexPixelChannel,CopyPixelTrait);
+ SetPixelChannelTraits(image,IndexPixelChannel,CopyPixelTrait);
if (image->mask != MagickFalse)
- SetPixelChannelMapTraits(image,MaskPixelChannel,CopyPixelTrait);
+ SetPixelChannelTraits(image,MaskPixelChannel,CopyPixelTrait);
if (image->debug != MagickFalse)
LogPixelChannels(image);
}
% %
% %
% %
-% S e t P i x e l C h a n n e l M a s k %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% SetPixelChannelMask() sets the pixel channel mask from the specified channel
-% mask.
-%
-% The format of the SetPixelChannelMask method is:
-%
-% ChannelType SetPixelChannelMask(Image *image,
-% const ChannelType channel_mask)
-%
-% A description of each parameter follows:
-%
-% o image: the image.
-%
-% o channel_mask: the channel mask.
-%
-*/
-MagickExport ChannelType SetPixelChannelMask(Image *image,
- const ChannelType channel_mask)
-{
- ChannelType
- mask;
-
- mask=image->channel_mask;
- image->channel_mask=channel_mask;
- SetPixelChannelMapMask(image,channel_mask);
- return(mask);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% S e t P i x e l M e t a C h a n n e l s %
% %
% %
projects / imagemagick / blobdiff