% MagickCore Methods to Import/Export Pixels %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% October 1998 %
% %
% %
-% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 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 "MagickCore/transform.h"
#include "MagickCore/utility.h"
\f
-#define LogPixelChannels(image) \
-{ \
- register ssize_t \
- i; \
- \
- (void) LogMagickEvent(PixelEvent,GetMagickModule(),"%s[%.20g]", \
- image->filename,(double) image->number_channels); \
- for (i=0; i < (ssize_t) image->number_channels; i++) \
- { \
- char \
- traits[MaxTextExtent]; \
- \
- const char \
- *name; \
- \
- PixelChannel \
- channel; \
- \
- switch (GetPixelChannelChannel(image,i)) \
- { \
- case RedPixelChannel: \
- { \
- name="red"; \
- if (image->colorspace == CMYKColorspace) \
- name="cyan"; \
- if (image->colorspace == GRAYColorspace) \
- name="gray"; \
- break; \
- } \
- case GreenPixelChannel: \
- { \
- name="green"; \
- if (image->colorspace == CMYKColorspace) \
- name="magenta"; \
- break; \
- } \
- case BluePixelChannel: \
- { \
- name="blue"; \
- if (image->colorspace == CMYKColorspace) \
- name="yellow"; \
- break; \
- } \
- case BlackPixelChannel: \
- { \
- name="black"; \
- if (image->storage_class == PseudoClass) \
- name="index"; \
- break; \
- } \
- case IndexPixelChannel: \
- { \
- name="index"; \
- break; \
- } \
- case AlphaPixelChannel: \
- { \
- name="alpha"; \
- break; \
- } \
- case MaskPixelChannel: \
- { \
- name="mask"; \
- break; \
- } \
- case MetaPixelChannel: \
- { \
- name="meta"; \
- break; \
- } \
- default: \
- name="undefined"; \
- } \
- channel=GetPixelChannelChannel(image,i); \
- *traits='\0'; \
- if ((GetPixelChannelTraits(image,channel) & UpdatePixelTrait) != 0) \
- (void) ConcatenateMagickString(traits,"update,",MaxTextExtent); \
- if ((GetPixelChannelTraits(image,channel) & BlendPixelTrait) != 0) \
- (void) ConcatenateMagickString(traits,"blend,",MaxTextExtent); \
- if ((GetPixelChannelTraits(image,channel) & CopyPixelTrait) != 0) \
- (void) ConcatenateMagickString(traits,"copy,",MaxTextExtent); \
- if (*traits == '\0') \
- (void) ConcatenateMagickString(traits,"undefined,",MaxTextExtent); \
- traits[strlen(traits)-1]='\0'; \
- (void) LogMagickEvent(PixelEvent,GetMagickModule()," %.20g: %s (%s)", \
- (double) i,name,traits); \
- } \
-}
-\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% %
+% D e c o d e P i x e l G a m m a %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% DecodePixelGamma() applies the expansive power-law nonlinearity to the pixel.
+%
+% The format of the DecodePixelGamma method is:
+%
+% double DecodePixelGamma(const MagickRealType pixel)
+%
+% A description of each parameter follows:
+%
+% o pixel: the pixel.
+%
+*/
+
+static inline double DecodeGamma(const double x)
+{
+ div_t
+ quotient;
+
+ double
+ p,
+ term[9];
+
+ int
+ exponent;
+
+ static const double coefficient[] = /* terms for x^(7/5), x=1.5 */
+ {
+ 1.7917488588043277509,
+ 0.82045614371976854984,
+ 0.027694100686325412819,
+ -0.00094244335181762134018,
+ 0.000064355540911469709545,
+ -5.7224404636060757485e-06,
+ 5.8767669437311184313e-07,
+ -6.6139920053589721168e-08,
+ 7.9323242696227458163e-09
+ };
+
+ static const double powers_of_two[] = /* (2^x)^(7/5) */
+ {
+ 1.0,
+ 2.6390158215457883983,
+ 6.9644045063689921093,
+ 1.8379173679952558018e+01,
+ 4.8502930128332728543e+01
+ };
+
+ /*
+ Compute x^2.4 == x*x^(7/5) == pow(x,2.4).
+ */
+ term[0]=1.0;
+ term[1]=4.0*frexp(x,&exponent)-3.0;
+ term[2]=2.0*term[1]*term[1]-term[0];
+ term[3]=2.0*term[1]*term[2]-term[1];
+ term[4]=2.0*term[1]*term[3]-term[2];
+ term[5]=2.0*term[1]*term[4]-term[3];
+ term[6]=2.0*term[1]*term[5]-term[4];
+ term[7]=2.0*term[1]*term[6]-term[5];
+ term[8]=2.0*term[1]*term[7]-term[6];
+ p=coefficient[0]*term[0]+coefficient[1]*term[1]+coefficient[2]*term[2]+
+ coefficient[3]*term[3]+coefficient[4]*term[4]+coefficient[5]*term[5]+
+ coefficient[6]*term[6]+coefficient[7]*term[7]+coefficient[8]*term[8];
+ quotient=div(exponent-1,5);
+ if (quotient.rem < 0)
+ {
+ quotient.quot-=1;
+ quotient.rem+=5;
+ }
+ return(x*ldexp(powers_of_two[quotient.rem]*p,7*quotient.quot));
+}
+
+MagickExport MagickRealType DecodePixelGamma(const MagickRealType pixel)
+{
+ if (pixel <= (0.0404482362771076*QuantumRange))
+ return(pixel/12.92f);
+ return((MagickRealType) (QuantumRange*DecodeGamma((double) (QuantumScale*
+ pixel+0.055)/1.055)));
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+ D e s t r o y P i x e l C h a n n e l M a p %
% %
% %
% %
% %
% %
++ E n c o d e P i x e l G a m m a %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% EncodePixelGamma() cancels any nonlinearity in the pixel.
+%
+% The format of the EncodePixelGamma method is:
+%
+% MagickRealType EncodePixelGamma(const double MagickRealType)
+%
+% A description of each parameter follows:
+%
+% o pixel: the pixel.
+%
+*/
+
+static inline double EncodeGamma(const double x)
+{
+ div_t
+ quotient;
+
+ double
+ p,
+ term[9];
+
+ int
+ exponent;
+
+ static const double coefficient[] = /* Chebychevi poly: x^(5/12), x=1.5 */
+ {
+ 1.1758200232996901923,
+ 0.16665763094889061230,
+ -0.0083154894939042125035,
+ 0.00075187976780420279038,
+ -0.000083240178519391795367,
+ 0.000010229209410070008679,
+ -1.3400466409860246e-06,
+ 1.8333422241635376682e-07,
+ -2.5878596761348859722e-08
+ };
+
+ static const double powers_of_two[] = /* (2^N)^(5/12) */
+ {
+ 1.0,
+ 1.3348398541700343678,
+ 1.7817974362806785482,
+ 2.3784142300054420538,
+ 3.1748021039363991669,
+ 4.2378523774371812394,
+ 5.6568542494923805819,
+ 7.5509945014535482244,
+ 1.0079368399158985525e1,
+ 1.3454342644059433809e1,
+ 1.7959392772949968275e1,
+ 2.3972913230026907883e1
+ };
+
+ /*
+ Compute x^(1/2.4) == x^(5/12) == pow(x,1.0/2.4).
+ */
+ term[0]=1.0;
+ term[1]=4.0*frexp(x,&exponent)-3.0;
+ term[2]=2.0*term[1]*term[1]-term[0];
+ term[3]=2.0*term[1]*term[2]-term[1];
+ term[4]=2.0*term[1]*term[3]-term[2];
+ term[5]=2.0*term[1]*term[4]-term[3];
+ term[6]=2.0*term[1]*term[5]-term[4];
+ term[7]=2.0*term[1]*term[6]-term[5];
+ term[8]=2.0*term[1]*term[7]-term[6];
+ p=coefficient[0]*term[0]+coefficient[1]*term[1]+coefficient[2]*term[2]+
+ coefficient[3]*term[3]+coefficient[4]*term[4]+coefficient[5]*term[5]+
+ coefficient[6]*term[6]+coefficient[7]*term[7]+coefficient[8]*term[8];
+ quotient=div(exponent-1,12);
+ if (quotient.rem < 0)
+ {
+ quotient.quot-=1;
+ quotient.rem+=12;
+ }
+ return(ldexp(powers_of_two[quotient.rem]*p,5*quotient.quot));
+}
+
+MagickExport MagickRealType EncodePixelGamma(const MagickRealType pixel)
+{
+ if (pixel <= (0.0031306684425005883*QuantumRange))
+ return(12.92f*pixel);
+ return((MagickRealType) QuantumRange*(1.055*EncodeGamma((double) QuantumScale*
+ pixel)-0.055));
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
% E x p o r t I m a g e P i x e l s %
% %
% %
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- *q++=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
p+=GetPixelChannels(image);
}
}
}
case IndexQuantum:
{
- *q=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
break;
}
default:
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- *q++=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
p+=GetPixelChannels(image);
}
}
}
case IndexQuantum:
{
- *q=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
break;
}
default:
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- *q++=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
+ *q++=ScaleQuantumToLongLong(ClampToQuantum(GetPixelIntensity(image,p)));
p+=GetPixelChannels(image);
}
}
}
case IndexQuantum:
{
- *q=ScaleQuantumToLongLong(GetPixelIntensity(image,p));
+ *q=ScaleQuantumToLongLong(ClampToQuantum(
+ GetPixelIntensity(image,p)));
break;
}
default:
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- *q++=GetPixelIntensity(image,p);
+ *q++=ClampToQuantum(GetPixelIntensity(image,p));
p+=GetPixelChannels(image);
}
}
}
case IndexQuantum:
{
- *q=(GetPixelIntensity(image,p));
+ *q=ClampToQuantum(GetPixelIntensity(image,p));
break;
}
default:
break;
for (x=0; x < (ssize_t) roi->width; x++)
{
- *q++=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ *q++=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
p+=GetPixelChannels(image);
}
}
}
case IndexQuantum:
{
- *q=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ *q=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,p)));
break;
}
default:
}
}
-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)
+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)
{
QuantumType
*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) length; 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;
}
}
%
% A description of each parameter follows:
%
-% o image: the image.
+% o image: the image. (optional - may be NULL)
%
% o pixel: Specifies a pointer to a PixelInfo structure.
%
% %
% %
% %
+% G e t P i x e l I n t e n s i t y %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% GetPixelIntensity() returns a single sample intensity value from the red,
+% green, and blue components of a pixel based on the selected method:
+%
+% Rec601Luma 0.298839R' + 0.586811G' + 0.114350B'
+% Rec601Luminance 0.298839R + 0.586811G + 0.114350B
+% Rec709Luma 0.212656R' + 0.715158G' + 0.072186B'
+% Rec709Luminance 0.212656R + 0.715158G + 0.072186B
+% Brightness max(R', G', B')
+% Lightness (min(R', G', B') + max(R', G', B')) / 2.0
+%
+% MS (R^2 + G^2 + B^2) / 3.0
+% RMS sqrt((R^2 + G^2 + B^2) / 3.0
+% Average (R + G + B') / 3.0
+%
+% The format of the GetPixelIntensity method is:
+%
+% MagickRealType GetPixelIntensity(const Image *image,
+% const Quantum *pixel)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o pixel: Specifies a pointer to a Quantum structure.
+%
+*/
+
+static inline MagickRealType MagickMax(const MagickRealType x,
+ const MagickRealType y)
+{
+ if (x > y)
+ return(x);
+ return(y);
+}
+
+static inline MagickRealType MagickMin(const MagickRealType x,
+ const MagickRealType y)
+{
+ if (x < y)
+ return(x);
+ return(y);
+}
+
+MagickExport MagickRealType GetPixelIntensity(const Image *restrict image,
+ const Quantum *restrict pixel)
+{
+ MagickRealType
+ blue,
+ green,
+ red,
+ intensity;
+
+ if (image->colorspace == GRAYColorspace)
+ return((MagickRealType) GetPixelGray(image,pixel));
+ red=(MagickRealType) GetPixelRed(image,pixel);
+ green=(MagickRealType) GetPixelGreen(image,pixel);
+ blue=(MagickRealType) GetPixelBlue(image,pixel);
+ switch (image->intensity)
+ {
+ case AveragePixelIntensityMethod:
+ {
+ intensity=(red+green+blue)/3.0;
+ break;
+ }
+ case BrightnessPixelIntensityMethod:
+ {
+ intensity=MagickMax(MagickMax(red,green),blue);
+ break;
+ }
+ case LightnessPixelIntensityMethod:
+ {
+ intensity=(MagickMin(MagickMin(red,green),blue)+
+ MagickMax(MagickMax(red,green),blue))/2.0;
+ break;
+ }
+ case MSPixelIntensityMethod:
+ {
+ intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
+ (3.0*QuantumRange));
+ break;
+ }
+ case Rec601LumaPixelIntensityMethod:
+ {
+ if (image->colorspace == RGBColorspace)
+ {
+ red=EncodePixelGamma(red);
+ green=EncodePixelGamma(green);
+ blue=EncodePixelGamma(blue);
+ }
+ intensity=0.298839*red+0.586811*green+0.114350*blue;
+ break;
+ }
+ case Rec601LuminancePixelIntensityMethod:
+ {
+ if (image->colorspace == sRGBColorspace)
+ {
+ red=DecodePixelGamma(red);
+ green=DecodePixelGamma(green);
+ blue=DecodePixelGamma(blue);
+ }
+ intensity=0.298839*red+0.586811*green+0.114350*blue;
+ break;
+ }
+ case Rec709LumaPixelIntensityMethod:
+ default:
+ {
+ if (image->colorspace == RGBColorspace)
+ {
+ red=EncodePixelGamma(red);
+ green=EncodePixelGamma(green);
+ blue=EncodePixelGamma(blue);
+ }
+ intensity=0.212656*red+0.715158*green+0.072186*blue;
+ break;
+ }
+ case Rec709LuminancePixelIntensityMethod:
+ {
+ if (image->colorspace == sRGBColorspace)
+ {
+ red=DecodePixelGamma(red);
+ green=DecodePixelGamma(green);
+ blue=DecodePixelGamma(blue);
+ }
+ intensity=0.212656*red+0.715158*green+0.072186*blue;
+ break;
+ }
+ case RMSPixelIntensityMethod:
+ {
+ intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
+ sqrt(3.0));
+ break;
+ }
+ }
+ return(intensity);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
% I m p o r t I m a g e P i x e l s %
% %
% %
{
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);
+ "UnrecognizedStorageType","`%d'",type);
break;
}
}
% o image: the image.
%
*/
+
+static void LogPixelChannels(const Image *image)
+{
+ register ssize_t
+ i;
+
+ (void) LogMagickEvent(PixelEvent,GetMagickModule(),"%s[%.20g]",
+ image->filename,(double) image->number_channels);
+ for (i=0; i < (ssize_t) image->number_channels; i++)
+ {
+ char
+ traits[MaxTextExtent];
+
+ const char
+ *name;
+
+ PixelChannel
+ channel;
+
+ switch (GetPixelChannelChannel(image,i))
+ {
+ case RedPixelChannel:
+ {
+ name="red";
+ if (image->colorspace == CMYKColorspace)
+ name="cyan";
+ if (image->colorspace == GRAYColorspace)
+ name="gray";
+ break;
+ }
+ case GreenPixelChannel:
+ {
+ name="green";
+ if (image->colorspace == CMYKColorspace)
+ name="magenta";
+ break;
+ }
+ case BluePixelChannel:
+ {
+ name="blue";
+ if (image->colorspace == CMYKColorspace)
+ name="yellow";
+ break;
+ }
+ case BlackPixelChannel:
+ {
+ name="black";
+ if (image->storage_class == PseudoClass)
+ name="index";
+ break;
+ }
+ case IndexPixelChannel:
+ {
+ name="index";
+ break;
+ }
+ case AlphaPixelChannel:
+ {
+ name="alpha";
+ break;
+ }
+ case ReadMaskPixelChannel:
+ {
+ name="read-mask";
+ break;
+ }
+ case WriteMaskPixelChannel:
+ {
+ name="write-mask";
+ break;
+ }
+ case MetaPixelChannel:
+ {
+ name="meta";
+ break;
+ }
+ default:
+ name="undefined";
+ }
+ channel=GetPixelChannelChannel(image,i);
+ *traits='\0';
+ if ((GetPixelChannelTraits(image,channel) & UpdatePixelTrait) != 0)
+ (void) ConcatenateMagickString(traits,"update,",MaxTextExtent);
+ if ((GetPixelChannelTraits(image,channel) & BlendPixelTrait) != 0)
+ (void) ConcatenateMagickString(traits,"blend,",MaxTextExtent);
+ if ((GetPixelChannelTraits(image,channel) & CopyPixelTrait) != 0)
+ (void) ConcatenateMagickString(traits,"copy,",MaxTextExtent);
+ if (*traits == '\0')
+ (void) ConcatenateMagickString(traits,"undefined,",MaxTextExtent);
+ traits[strlen(traits)-1]='\0';
+ (void) LogMagickEvent(PixelEvent,GetMagickModule()," %.20g: %s (%s)",
+ (double) i,name,traits);
+ }
+}
+
MagickExport void InitializePixelChannelMap(Image *image)
{
PixelTrait
SetPixelChannelAttributes(image,AlphaPixelChannel,CopyPixelTrait,n++);
if (image->storage_class == PseudoClass)
SetPixelChannelAttributes(image,IndexPixelChannel,CopyPixelTrait,n++);
- if (image->mask != MagickFalse)
- SetPixelChannelAttributes(image,MaskPixelChannel,CopyPixelTrait,n++);
+ if (image->read_mask != MagickFalse)
+ SetPixelChannelAttributes(image,ReadMaskPixelChannel,CopyPixelTrait,n++);
+ if (image->write_mask != MagickFalse)
+ SetPixelChannelAttributes(image,WriteMaskPixelChannel,CopyPixelTrait,n++);
assert((n+image->number_meta_channels) < MaxPixelChannels);
for (i=0; i < (ssize_t) image->number_meta_channels; i++)
SetPixelChannelAttributes(image,(PixelChannel) (MetaPixelChannel+i),
%
*/
-static inline double MagickMax(const double x,const double y)
-{
- if (x > y)
- return(x);
- return(y);
-}
-
static inline void CatromWeights(const double x,double (*weights)[4])
{
double
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.
+ 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;
const PixelInterpolateMethod method,const double x,const double y,
double *pixel,ExceptionInfo *exception)
{
- MagickBooleanType
- status;
-
double
alpha[16],
gamma,
pixels[16];
+ MagickBooleanType
+ status;
+
+ PixelInterpolateMethod
+ interpolate;
+
PixelTrait
traits;
x_offset,
y_offset;
- PixelInterpolateMethod
- interpolate;
-
assert(image != (Image *) NULL);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
interpolate = image->interpolate;
switch (interpolate)
{
- case AverageInterpolatePixel: /* nearest 4 neighbours */
- case Average9InterpolatePixel: /* nearest 9 neighbours */
- case Average16InterpolatePixel: /* nearest 16 neighbours */
+ case AverageInterpolatePixel: /* nearest 4 neighbours */
+ case Average9InterpolatePixel: /* nearest 9 neighbours */
+ case Average16InterpolatePixel: /* nearest 16 neighbours */
{
ssize_t
count;
x_offset--;
y_offset--;
}
- p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,count,count,
- exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(size_t) count,
+ (size_t) count,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
break;
}
- count*=count; /* Number of pixels to Average */
+ count*=count; /* Number of pixels to average */
if ((traits & BlendPixelTrait) == 0)
for (i=0; i < (ssize_t) count; i++)
{
GetPixelChannels(image));
pixels[i]=alpha[i]*p[i*GetPixelChannels(image)+channel];
}
- gamma=1.0; /* number of pixels blended together (its variable) */
+ gamma=1.0; /* number of pixels blended together (its variable) */
for (i=0; i <= 1L; i++) {
if ((y-y_offset) >= 0.75)
{
pixels[0]+=pixels[1];
}
if (channel != AlphaPixelChannel)
- gamma=PerceptibleReciprocal(alpha[0]); /* (color) 1/alpha_weights */
+ gamma=PerceptibleReciprocal(alpha[0]); /* (color) 1/alpha_weights */
else
- gamma=PerceptibleReciprocal(gamma); /* (alpha) 1/number_of_pixels */
+ gamma=PerceptibleReciprocal(gamma); /* (alpha) 1/number_of_pixels */
*pixel=gamma*pixels[0];
break;
}
pixels[13]+cx[2]*pixels[14]+cx[3]*pixels[15]));
break;
}
-#if 0
- /* deprecated useless and very slow interpolator */
- 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,exception);
- excerpt_image=DestroyImage(excerpt_image);
- if (filter_image == (Image *) NULL)
- break;
- filter_view=AcquireVirtualCacheView(filter_image,exception);
- p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
- if (p == (const Quantum *) NULL)
- status=MagickFalse;
- else
- *pixel=(double) GetPixelChannel(image,channel,p);
- filter_view=DestroyCacheView(filter_view);
- filter_image=DestroyImage(filter_image);
- break;
- }
-#endif
case IntegerInterpolatePixel:
{
p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
}
delta.x=x-x_offset;
delta.y=y-y_offset;
- luminance.x=GetPixelLuminance(image,p)-(double)
- GetPixelLuminance(image,p+3*GetPixelChannels(image));
- luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
- GetPixelLuminance(image,p+2*GetPixelChannels(image));
+ luminance.x=GetPixelLuma(image,p)-(double)
+ GetPixelLuma(image,p+3*GetPixelChannels(image));
+ luminance.y=GetPixelLuma(image,p+GetPixelChannels(image))-(double)
+ GetPixelLuma(image,p+2*GetPixelChannels(image));
if (fabs(luminance.x) < fabs(luminance.y))
{
/*
gamma,
pixels[16];
- PixelChannel
- channel;
-
- PixelTrait
- destination_traits,
- traits;
-
register const Quantum
*p;
interpolate = source->interpolate;
switch (interpolate)
{
- case AverageInterpolatePixel: /* nearest 4 neighbours */
- case Average9InterpolatePixel: /* nearest 9 neighbours */
- case Average16InterpolatePixel: /* nearest 16 neighbours */
+ case AverageInterpolatePixel: /* nearest 4 neighbours */
+ case Average9InterpolatePixel: /* nearest 9 neighbours */
+ case Average16InterpolatePixel: /* nearest 16 neighbours */
{
ssize_t
count;
x_offset--;
y_offset--;
}
- p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,count,count,
- exception);
+ p=GetCacheViewVirtualPixels(source_view,x_offset,y_offset,(size_t) count,
+ (size_t) count,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
break;
}
- count*=count; /* Number of pixels to Average */
+ count*=count; /* Number of pixels to average */
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
{
double
register ssize_t
j;
- channel=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
+ PixelChannel channel=GetPixelChannelChannel(source,i);
+ PixelTrait traits=GetPixelChannelTraits(source,channel);
+ PixelTrait destination_traits=GetPixelChannelTraits(destination,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
delta,
epsilon;
- channel=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
+ PixelChannel channel=GetPixelChannelChannel(source,i);
+ PixelTrait traits=GetPixelChannelTraits(source,channel);
+ PixelTrait destination_traits=GetPixelChannelTraits(destination,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
register ssize_t
j;
- channel=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
+ PixelChannel channel=GetPixelChannelChannel(source,i);
+ PixelTrait traits=GetPixelChannelTraits(source,channel);
+ PixelTrait destination_traits=GetPixelChannelTraits(destination,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
else
if ((y-y_offset) > 0.25)
{
- gamma=2.0; /* blend both pixels in row */
+ gamma=2.0; /* blend both pixels in row */
alpha[j]+=alpha[j+2]; /* add up alpha weights */
pixels[j]+=pixels[j+2];
}
pixels[0]+=pixels[1];
}
if ((traits & BlendPixelTrait) == 0)
- gamma=PerceptibleReciprocal(alpha[0]); /* (color) 1/alpha_weights */
+ gamma=PerceptibleReciprocal(alpha[0]); /* (color) 1/alpha_weights */
else
- gamma=PerceptibleReciprocal(gamma); /* (alpha) 1/number_of_pixels */
+ gamma=PerceptibleReciprocal(gamma); /* (alpha) 1/number_of_pixels */
SetPixelChannel(destination,channel,ClampToQuantum(gamma*pixels[0]),
pixel);
}
register ssize_t
j;
- channel=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
+ PixelChannel channel=GetPixelChannelChannel(source,i);
+ PixelTrait traits=GetPixelChannelTraits(source,channel);
+ PixelTrait destination_traits=GetPixelChannelTraits(destination,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
}
break;
}
-#if 0
- /* deprecated useless and very slow interpolator */
- case FilterInterpolatePixel:
- {
- for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
- {
- CacheView
- *filter_view;
-
- Image
- *excerpt_source,
- *filter_source;
-
- RectangleInfo
- geometry;
-
- channel=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
- if ((traits == UndefinedPixelTrait) ||
- (destination_traits == UndefinedPixelTrait))
- continue;
- geometry.width=4L;
- geometry.height=4L;
- geometry.x=x_offset-1;
- geometry.y=y_offset-1;
- excerpt_source=ExcerptImage(source,&geometry,exception);
- if (excerpt_source == (Image *) NULL)
- {
- status=MagickFalse;
- continue;
- }
- filter_source=ResizeImage(excerpt_source,1,1,source->filter,exception);
- excerpt_source=DestroyImage(excerpt_source);
- if (filter_source == (Image *) NULL)
- continue;
- filter_view=AcquireVirtualCacheView(filter_source,exception);
- p=GetCacheViewVirtualPixels(filter_view,0,0,1,1,exception);
- if (p == (const Quantum *) NULL)
- status=MagickFalse;
- else
- {
- SetPixelChannel(destination,channel,p[i],pixel);
- }
- filter_view=DestroyCacheView(filter_view);
- filter_source=DestroyImage(filter_source);
- }
- 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=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
+ PixelChannel channel=GetPixelChannelChannel(source,i);
+ PixelTrait traits=GetPixelChannelTraits(source,channel);
+ PixelTrait destination_traits=GetPixelChannelTraits(destination,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
}
for (i=0; i < (ssize_t) GetPixelChannels(source); i++)
{
- channel=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
+ PixelChannel channel=GetPixelChannelChannel(source,i);
+ PixelTrait traits=GetPixelChannelTraits(source,channel);
+ PixelTrait destination_traits=GetPixelChannelTraits(destination,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
delta,
luminance;
- channel=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
+ PixelChannel channel=GetPixelChannelChannel(source,i);
+ PixelTrait traits=GetPixelChannelTraits(source,channel);
+ PixelTrait destination_traits=GetPixelChannelTraits(destination,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
}
delta.x=x-x_offset;
delta.y=y-y_offset;
- 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*
+ luminance.x=fabs((double) (GetPixelLuma(source,p)-
+ GetPixelLuma(source,p+3*GetPixelChannels(source))));
+ luminance.y=fabs((double) (GetPixelLuma(source,p+
+ GetPixelChannels(source))-GetPixelLuma(source,p+2*
GetPixelChannels(source))));
if (luminance.x < luminance.y)
{
register ssize_t
j;
- channel=GetPixelChannelChannel(source,i);
- traits=GetPixelChannelTraits(source,channel);
- destination_traits=GetPixelChannelTraits(destination,channel);
+ PixelChannel channel=GetPixelChannelChannel(source,i);
+ PixelTrait traits=GetPixelChannelTraits(source,channel);
+ PixelTrait destination_traits=GetPixelChannelTraits(destination,
+ channel);
if ((traits == UndefinedPixelTrait) ||
(destination_traits == UndefinedPixelTrait))
continue;
interpolate = image->interpolate;
switch (interpolate)
{
- case AverageInterpolatePixel: /* nearest 4 neighbours */
- case Average9InterpolatePixel: /* nearest 9 neighbours */
- case Average16InterpolatePixel: /* nearest 16 neighbours */
+ case AverageInterpolatePixel: /* nearest 4 neighbours */
+ case Average9InterpolatePixel: /* nearest 9 neighbours */
+ case Average16InterpolatePixel: /* nearest 16 neighbours */
{
ssize_t
count;
x_offset--;
y_offset--;
}
- p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,count,count,
- exception);
+ p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,(size_t) count,
+ (size_t) count,exception);
if (p == (const Quantum *) NULL)
{
status=MagickFalse;
pixel->blue=0.0;
pixel->black=0.0;
pixel->alpha=0.0;
- count*=count; /* number of pixels - square of size */
+ count*=count; /* number of pixels - square of size */
for (i=0; i < (ssize_t) count; i++)
{
AlphaBlendPixelInfo(image,p,pixels,alpha);
if ((x-x_offset) > 0.25)
{
gamma*=2.0; /* blend both rows */
- alpha[0]+= alpha[1]; /* add up alpha weights */
+ 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;
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
- *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,exception);
- excerpt_image=DestroyImage(excerpt_image);
- if (filter_image == (Image *) NULL)
- break;
- 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_view=DestroyCacheView(filter_view);
- filter_image=DestroyImage(filter_image);
- break;
- }
-#endif
case IntegerInterpolatePixel:
{
p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,1,1,exception);
}
delta.x=x-x_offset;
delta.y=y-y_offset;
- luminance.x=GetPixelLuminance(image,p)-(double)
- GetPixelLuminance(image,p+3*GetPixelChannels(image));
- luminance.y=GetPixelLuminance(image,p+GetPixelChannels(image))-(double)
- GetPixelLuminance(image,p+2*GetPixelChannels(image));
+ luminance.x=GetPixelLuma(image,p)-(double)
+ GetPixelLuma(image,p+3*GetPixelChannels(image));
+ luminance.y=GetPixelLuma(image,p+GetPixelChannels(image))-(double)
+ GetPixelLuma(image,p+2*GetPixelChannels(image));
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);
distance,
scale;
- fuzz=MagickMax(source->fuzz,(double) MagickSQ1_2)*MagickMax(
- destination->fuzz,(double) MagickSQ1_2);
+ fuzz=(double) MagickMax(source->fuzz,(MagickRealType) MagickSQ1_2)*MagickMax(
+ destination->fuzz,(MagickRealType) MagickSQ1_2);
scale=1.0;
distance=0.0;
if (source->alpha_trait == BlendPixelTrait)
/*
Transparencies are involved - set alpha distance
*/
- pixel=GetPixelAlpha(source,p)-(double)
- GetPixelAlpha(destination,q);
+ pixel=GetPixelAlpha(source,p)-(double) GetPixelAlpha(destination,q);
distance=pixel*pixel;
if (distance > fuzz)
return(MagickFalse);
if ((p->fuzz == 0.0) && (q->fuzz == 0.0))
return(IsPixelInfoEquivalent(p,q));
if (p->fuzz == 0.0)
- fuzz=MagickMax(q->fuzz,(double) MagickSQ1_2)*MagickMax(q->fuzz,
- (double) MagickSQ1_2);
+ fuzz=MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2)*
+ MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
else if (q->fuzz == 0.0)
- fuzz=MagickMax(p->fuzz,(double) MagickSQ1_2)*MagickMax(p->fuzz,
- (double) MagickSQ1_2);
+ fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*
+ MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2);
else
- fuzz=MagickMax(p->fuzz,(double) MagickSQ1_2)*MagickMax(q->fuzz,
- (double) MagickSQ1_2);
+ fuzz=MagickMax(p->fuzz,(MagickRealType) MagickSQ1_2)*
+ MagickMax(q->fuzz,(MagickRealType) MagickSQ1_2);
scale=1.0;
distance=0.0;
- if ((p->alpha_trait == BlendPixelTrait) || (q->alpha_trait == BlendPixelTrait))
+ if ((p->alpha_trait == BlendPixelTrait) ||
+ (q->alpha_trait == BlendPixelTrait))
{
/*
Transparencies are involved - set alpha distance.
(p->colorspace == HWBColorspace))
{
/*
- This calculates a arc distance for hue-- it should be a vector angle
- of 'S'/'W' length with 'L'/'B' forming appropriate cones. In other
- words this is a hack - Anthony.
+ This calculates a arc distance for hue-- it should be a vector
+ angle of 'S'/'W' length with 'L'/'B' forming appropriate cones.
+ In other words this is a hack - Anthony.
*/
if (fabs((double) pixel) > (QuantumRange/2))
pixel-=QuantumRange;
% %
% %
% %
-% S e t P i x e l C h a n n e l M a p M a s k %
+% S e t P i x e l C h a n n e l M a s k %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% SetPixelChannelMask() sets the pixel channel map from the specified
-% channel mask.
+% SetPixelChannelMask() sets the pixel channel map from the specified channel
+% mask.
%
% The format of the SetPixelChannelMask method is:
%
image->channel_mask=channel_mask;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- PixelChannel
- channel;
-
- channel=GetPixelChannelChannel(image,i);
+ PixelChannel channel=GetPixelChannelChannel(image,i);
SetPixelChannelTraits(image,channel,
GetChannelBit(channel_mask,channel) == 0 ? CopyPixelTrait :
image->alpha_trait != BlendPixelTrait || (channel == AlphaPixelChannel) ?
}
if (image->storage_class == PseudoClass)
SetPixelChannelTraits(image,IndexPixelChannel,CopyPixelTrait);
- if (image->mask != MagickFalse)
- SetPixelChannelTraits(image,MaskPixelChannel,CopyPixelTrait);
+ if (image->read_mask != MagickFalse)
+ SetPixelChannelTraits(image,ReadMaskPixelChannel,CopyPixelTrait);
+ if (image->write_mask != MagickFalse)
+ SetPixelChannelTraits(image,WriteMaskPixelChannel,CopyPixelTrait);
if (image->debug != MagickFalse)
LogPixelChannels(image);
}
projects / imagemagick / blobdiff