static MagickPixelPacket **DestroyPixelThreadSet(MagickPixelPacket **pixels)
{
- register long
+ register ssize_t
i;
assert(pixels != (MagickPixelPacket **) NULL);
- for (i=0; i < (long) GetOpenMPMaximumThreads(); i++)
+ for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
if (pixels[i] != (MagickPixelPacket *) NULL)
pixels[i]=(MagickPixelPacket *) RelinquishMagickMemory(pixels[i]);
pixels=(MagickPixelPacket **) RelinquishAlignedMemory(pixels);
static MagickPixelPacket **AcquirePixelThreadSet(const Image *image)
{
- register long
+ register ssize_t
i,
j;
MagickPixelPacket
**pixels;
- unsigned long
+ size_t
number_threads;
number_threads=GetOpenMPMaximumThreads();
if (pixels == (MagickPixelPacket **) NULL)
return((MagickPixelPacket **) NULL);
(void) ResetMagickMemory(pixels,0,number_threads*sizeof(*pixels));
- for (i=0; i < (long) number_threads; i++)
+ for (i=0; i < (ssize_t) number_threads; i++)
{
pixels[i]=(MagickPixelPacket *) AcquireQuantumMemory(image->columns,
sizeof(**pixels));
if (pixels[i] == (MagickPixelPacket *) NULL)
return(DestroyPixelThreadSet(pixels));
- for (j=0; j < (long) image->columns; j++)
+ for (j=0; j < (ssize_t) image->columns; j++)
GetMagickPixelPacket(image,&pixels[i][j]);
}
return(pixels);
{
case UndefinedEvaluateOperator:
break;
+ case AbsEvaluateOperator:
+ {
+ result=(MagickRealType) fabs((double) (pixel+value));
+ break;
+ }
case AddEvaluateOperator:
{
result=(MagickRealType) (pixel+value);
and could return a negative result (which is clipped).
*/
result=pixel+value;
- result-=(QuantumRange+1)*floor(result/(QuantumRange+1));
+ result-=(QuantumRange+1.0)*floor((double) result/(QuantumRange+1.0));
break;
}
case AndEvaluateOperator:
{
- result=(MagickRealType) ((unsigned long) pixel & (unsigned long)
+ result=(MagickRealType) ((size_t) pixel & (size_t)
(value+0.5));
break;
}
}
case LeftShiftEvaluateOperator:
{
- result=(MagickRealType) ((unsigned long) pixel << (unsigned long)
+ result=(MagickRealType) ((size_t) pixel << (size_t)
(value+0.5));
break;
}
}
case OrEvaluateOperator:
{
- result=(MagickRealType) ((unsigned long) pixel | (unsigned long)
+ result=(MagickRealType) ((size_t) pixel | (size_t)
(value+0.5));
break;
}
}
case RightShiftEvaluateOperator:
{
- result=(MagickRealType) ((unsigned long) pixel >> (unsigned long)
+ result=(MagickRealType) ((size_t) pixel >> (size_t)
(value+0.5));
break;
}
}
case XorEvaluateOperator:
{
- result=(MagickRealType) ((unsigned long) pixel ^ (unsigned long)
+ result=(MagickRealType) ((size_t) pixel ^ (size_t)
(value+0.5));
break;
}
Image
*evaluate_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
MagickPixelPacket
**restrict evaluate_pixels,
zero;
RandomInfo
**restrict random_info;
- unsigned long
+ size_t
number_images;
+ ssize_t
+ y;
+
/*
Ensure the image are the same size.
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic) shared(progress,status)
#endif
- for (y=0; y < (long) evaluate_image->rows; y++)
+ for (y=0; y < (ssize_t) evaluate_image->rows; y++)
{
CacheView
*image_view;
const Image
*next;
+ int
+ id;
+
MagickPixelPacket
pixel;
register IndexPacket
*restrict evaluate_indexes;
- register long
+ register ssize_t
i,
- id,
x;
register MagickPixelPacket
pixel=zero;
id=GetOpenMPThreadId();
evaluate_pixel=evaluate_pixels[id];
- for (x=0; x < (long) evaluate_image->columns; x++)
+ for (x=0; x < (ssize_t) evaluate_image->columns; x++)
evaluate_pixel[x]=zero;
next=images;
- for (i=0; i < (long) number_images; i++)
+ for (i=0; i < (ssize_t) number_images; i++)
{
register const IndexPacket
*indexes;
break;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
- for (x=0; x < (long) next->columns; x++)
+ for (x=0; x < (ssize_t) next->columns; x++)
{
evaluate_pixel[x].red=ApplyEvaluateOperator(random_info[id],p->red,
i == 0 ? AddEvaluateOperator : op,evaluate_pixel[x].red);
next=GetNextImageInList(next);
}
if (op == MeanEvaluateOperator)
- for (x=0; x < (long) evaluate_image->columns; x++)
+ for (x=0; x < (ssize_t) evaluate_image->columns; x++)
{
evaluate_pixel[x].red/=number_images;
evaluate_pixel[x].green/=number_images;
evaluate_pixel[x].opacity/=number_images;
evaluate_pixel[x].index/=number_images;
}
- for (x=0; x < (long) evaluate_image->columns; x++)
+ for (x=0; x < (ssize_t) evaluate_image->columns; x++)
{
q->red=ClampToQuantum(evaluate_pixel[x].red);
q->green=ClampToQuantum(evaluate_pixel[x].green);
CacheView
*image_view;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
RandomInfo
**restrict random_info;
+ ssize_t
+ y;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
+ int
+ id;
+
register IndexPacket
*restrict indexes;
- register long
- id,
+ register ssize_t
x;
register PixelPacket
}
indexes=GetCacheViewAuthenticIndexQueue(image_view);
id=GetOpenMPThreadId();
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if ((channel & RedChannel) != 0)
q->red=ClampToQuantum(ApplyEvaluateOperator(random_info[id],q->red,op,
% The format of the FunctionImageChannel method is:
%
% MagickBooleanType FunctionImage(Image *image,
-% const MagickFunction function,const long number_parameters,
+% const MagickFunction function,const ssize_t number_parameters,
% const double *parameters,ExceptionInfo *exception)
% MagickBooleanType FunctionImageChannel(Image *image,
% const ChannelType channel,const MagickFunction function,
-% const long number_parameters,const double *argument,
+% const ssize_t number_parameters,const double *argument,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
*/
static Quantum ApplyFunction(Quantum pixel,const MagickFunction function,
- const unsigned long number_parameters,const double *parameters,
+ const size_t number_parameters,const double *parameters,
ExceptionInfo *exception)
{
MagickRealType
result;
- register long
+ register ssize_t
i;
(void) exception;
* For example: c0*x^3 + c1*x^2 + c2*x + c3
*/
result=0.0;
- for (i=0; i < (long) number_parameters; i++)
+ for (i=0; i < (ssize_t) number_parameters; i++)
result = result*QuantumScale*pixel + parameters[i];
result *= QuantumRange;
break;
}
MagickExport MagickBooleanType FunctionImage(Image *image,
- const MagickFunction function,const unsigned long number_parameters,
+ const MagickFunction function,const size_t number_parameters,
const double *parameters,ExceptionInfo *exception)
{
MagickBooleanType
MagickExport MagickBooleanType FunctionImageChannel(Image *image,
const ChannelType channel,const MagickFunction function,
- const unsigned long number_parameters,const double *parameters,
+ const size_t number_parameters,const double *parameters,
ExceptionInfo *exception)
{
#define FunctionImageTag "Function/Image "
CacheView
*image_view;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
+ ssize_t
+ y;
+
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register IndexPacket
*restrict indexes;
- register long
+ register ssize_t
x;
register PixelPacket
continue;
}
indexes=GetCacheViewAuthenticIndexQueue(image_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if ((channel & RedChannel) != 0)
q->red=ApplyFunction(q->red,function,number_parameters,parameters,
% The format of the GetImageChannelExtrema method is:
%
% MagickBooleanType GetImageChannelExtrema(const Image *image,
-% const ChannelType channel,unsigned long *minima,unsigned long *maxima,
+% const ChannelType channel,size_t *minima,size_t *maxima,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
*/
MagickExport MagickBooleanType GetImageExtrema(const Image *image,
- unsigned long *minima,unsigned long *maxima,ExceptionInfo *exception)
+ size_t *minima,size_t *maxima,ExceptionInfo *exception)
{
return(GetImageChannelExtrema(image,AllChannels,minima,maxima,exception));
}
MagickExport MagickBooleanType GetImageChannelExtrema(const Image *image,
- const ChannelType channel,unsigned long *minima,unsigned long *maxima,
+ const ChannelType channel,size_t *minima,size_t *maxima,
ExceptionInfo *exception)
{
double
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
status=GetImageChannelRange(image,channel,&min,&max,exception);
- *minima=(unsigned long) ceil(min-0.5);
- *maxima=(unsigned long) floor(max+0.5);
+ *minima=(size_t) ceil(min-0.5);
+ *maxima=(size_t) floor(max+0.5);
return(status);
}
\f
const ChannelType channel,double *mean,double *standard_deviation,
ExceptionInfo *exception)
{
- double
- area;
+ ChannelStatistics
+ *channel_statistics;
- long
- y;
+ size_t
+ channels;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- *mean=0.0;
- *standard_deviation=0.0;
- area=0.0;
- for (y=0; y < (long) image->rows; y++)
- {
- register const IndexPacket
- *restrict indexes;
-
- register const PixelPacket
- *restrict p;
-
- register long
- x;
-
- p=GetVirtualPixels(image,0,y,image->columns,1,exception);
- if (p == (const PixelPacket *) NULL)
- break;
- indexes=GetVirtualIndexQueue(image);
- for (x=0; x < (long) image->columns; x++)
+ channel_statistics=GetImageChannelStatistics(image,exception);
+ if (channel_statistics == (ChannelStatistics *) NULL)
+ return(MagickFalse);
+ channels=0;
+ channel_statistics[AllChannels].mean=0.0;
+ channel_statistics[AllChannels].standard_deviation=0.0;
+ if ((channel & RedChannel) != 0)
{
- if ((channel & RedChannel) != 0)
- {
- *mean+=GetRedPixelComponent(p);
- *standard_deviation+=(double) p->red*GetRedPixelComponent(p);
- area++;
- }
- if ((channel & GreenChannel) != 0)
- {
- *mean+=GetGreenPixelComponent(p);
- *standard_deviation+=(double) p->green*GetGreenPixelComponent(p);
- area++;
- }
- if ((channel & BlueChannel) != 0)
- {
- *mean+=GetBluePixelComponent(p);
- *standard_deviation+=(double) p->blue*GetBluePixelComponent(p);
- area++;
- }
- if ((channel & OpacityChannel) != 0)
- {
- *mean+=GetOpacityPixelComponent(p);
- *standard_deviation+=(double) p->opacity*GetOpacityPixelComponent(p);
- area++;
- }
- if (((channel & IndexChannel) != 0) &&
- (image->colorspace == CMYKColorspace))
- {
- *mean+=indexes[x];
- *standard_deviation+=(double) indexes[x]*indexes[x];
- area++;
- }
- p++;
+ channel_statistics[AllChannels].mean+=
+ channel_statistics[RedChannel].mean;
+ channel_statistics[AllChannels].standard_deviation+=
+ channel_statistics[RedChannel].variance-
+ channel_statistics[RedChannel].mean*
+ channel_statistics[RedChannel].mean;
+ channels++;
}
- }
- if (y < (long) image->rows)
- return(MagickFalse);
- if (area != 0)
+ if ((channel & GreenChannel) != 0)
+ {
+ channel_statistics[AllChannels].mean+=
+ channel_statistics[GreenChannel].mean;
+ channel_statistics[AllChannels].standard_deviation+=
+ channel_statistics[GreenChannel].variance-
+ channel_statistics[GreenChannel].mean*
+ channel_statistics[GreenChannel].mean;
+ channels++;
+ }
+ if ((channel & BlueChannel) != 0)
{
- *mean/=area;
- *standard_deviation/=area;
+ channel_statistics[AllChannels].mean+=
+ channel_statistics[BlueChannel].mean;
+ channel_statistics[AllChannels].standard_deviation+=
+ channel_statistics[BlueChannel].variance-
+ channel_statistics[BlueChannel].mean*
+ channel_statistics[BlueChannel].mean;
+ channels++;
}
- *standard_deviation=sqrt(*standard_deviation-(*mean*(*mean)));
- return(y == (long) image->rows ? MagickTrue : MagickFalse);
+ if (((channel & OpacityChannel) != 0) &&
+ (image->matte != MagickFalse))
+ {
+ channel_statistics[AllChannels].mean+=
+ channel_statistics[OpacityChannel].mean;
+ channel_statistics[AllChannels].standard_deviation+=
+ channel_statistics[OpacityChannel].variance-
+ channel_statistics[OpacityChannel].mean*
+ channel_statistics[OpacityChannel].mean;
+ channels++;
+ }
+ if (((channel & IndexChannel) != 0) &&
+ (image->colorspace == CMYKColorspace))
+ {
+ channel_statistics[AllChannels].mean+=
+ channel_statistics[BlackChannel].mean;
+ channel_statistics[AllChannels].standard_deviation+=
+ channel_statistics[BlackChannel].variance-
+ channel_statistics[BlackChannel].mean*
+ channel_statistics[BlackChannel].mean;
+ channels++;
+ }
+ channel_statistics[AllChannels].mean/=channels;
+ channel_statistics[AllChannels].standard_deviation=
+ sqrt(channel_statistics[AllChannels].standard_deviation/channels);
+ *mean=channel_statistics[AllChannels].mean;
+ *standard_deviation=channel_statistics[AllChannels].standard_deviation;
+ channel_statistics=(ChannelStatistics *) RelinquishMagickMemory(
+ channel_statistics);
+ return(MagickTrue);
}
\f
/*
sum_cubes,
sum_fourth_power;
- long
+ ssize_t
y;
assert(image != (Image *) NULL);
sum_squares=0.0;
sum_cubes=0.0;
sum_fourth_power=0.0;
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const IndexPacket
*restrict indexes;
register const PixelPacket
*restrict p;
- register long
+ register ssize_t
x;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetVirtualIndexQueue(image);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if ((channel & RedChannel) != 0)
{
p++;
}
}
- if (y < (long) image->rows)
+ if (y < (ssize_t) image->rows)
return(MagickFalse);
if (area != 0.0)
{
*skewness=sum_cubes-3.0*mean*sum_squares+2.0*mean*mean*mean;
*skewness/=standard_deviation*standard_deviation*standard_deviation;
}
- return(y == (long) image->rows ? MagickTrue : MagickFalse);
+ return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
}
\f
/*
const ChannelType channel,double *minima,double *maxima,
ExceptionInfo *exception)
{
- long
+ ssize_t
y;
MagickPixelPacket
*maxima=(-1.0E-37);
*minima=1.0E+37;
GetMagickPixelPacket(image,&pixel);
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const IndexPacket
*restrict indexes;
register const PixelPacket
*restrict p;
- register long
+ register ssize_t
x;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetVirtualIndexQueue(image);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
SetMagickPixelPacket(image,p,indexes+x,&pixel);
if ((channel & RedChannel) != 0)
p++;
}
}
- return(y == (long) image->rows ? MagickTrue : MagickFalse);
+ return(y == (ssize_t) image->rows ? MagickTrue : MagickFalse);
}
\f
/*
*channel_statistics;
double
- area,
- sum_squares,
- sum_cubes;
+ area;
- long
+ ssize_t
y;
MagickStatusType
QuantumAny
range;
- register long
+ register ssize_t
i;
size_t
length;
- unsigned long
+ size_t
channels,
depth;
channel_statistics[i].depth=1;
channel_statistics[i].maxima=(-1.0E-37);
channel_statistics[i].minima=1.0E+37;
- channel_statistics[i].mean=0.0;
- channel_statistics[i].standard_deviation=0.0;
- channel_statistics[i].kurtosis=0.0;
- channel_statistics[i].skewness=0.0;
}
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register const IndexPacket
*restrict indexes;
register const PixelPacket
*restrict p;
- register long
+ register ssize_t
x;
p=GetVirtualPixels(image,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetVirtualIndexQueue(image);
- for (x=0; x < (long) image->columns; )
+ for (x=0; x < (ssize_t) image->columns; )
{
if (channel_statistics[RedChannel].depth != MAGICKCORE_QUANTUM_DEPTH)
{
channel_statistics[RedChannel].minima=(double) GetRedPixelComponent(p);
if ((double) p->red > channel_statistics[RedChannel].maxima)
channel_statistics[RedChannel].maxima=(double) GetRedPixelComponent(p);
- channel_statistics[RedChannel].mean+=GetRedPixelComponent(p);
- channel_statistics[RedChannel].standard_deviation+=(double) p->red*
+ channel_statistics[RedChannel].sum+=GetRedPixelComponent(p);
+ channel_statistics[RedChannel].sum_squared+=(double) p->red*
GetRedPixelComponent(p);
- channel_statistics[RedChannel].kurtosis+=(double) p->red*p->red*
- p->red*GetRedPixelComponent(p);
- channel_statistics[RedChannel].skewness+=(double) p->red*p->red*
+ channel_statistics[RedChannel].sum_cubed+=(double) p->red*p->red*
GetRedPixelComponent(p);
+ channel_statistics[RedChannel].sum_fourth_power+=(double) p->red*p->red*
+ p->red*GetRedPixelComponent(p);
if ((double) p->green < channel_statistics[GreenChannel].minima)
channel_statistics[GreenChannel].minima=(double)
GetGreenPixelComponent(p);
if ((double) p->green > channel_statistics[GreenChannel].maxima)
channel_statistics[GreenChannel].maxima=(double)
GetGreenPixelComponent(p);
- channel_statistics[GreenChannel].mean+=GetGreenPixelComponent(p);
- channel_statistics[GreenChannel].standard_deviation+=(double) p->green*
+ channel_statistics[GreenChannel].sum+=GetGreenPixelComponent(p);
+ channel_statistics[GreenChannel].sum_squared+=(double) p->green*
GetGreenPixelComponent(p);
- channel_statistics[GreenChannel].kurtosis+=(double) p->green*p->green*
- p->green*GetGreenPixelComponent(p);
- channel_statistics[GreenChannel].skewness+=(double) p->green*p->green*
+ channel_statistics[GreenChannel].sum_cubed+=(double) p->green*p->green*
GetGreenPixelComponent(p);
+ channel_statistics[GreenChannel].sum_fourth_power+=(double) p->green*
+ p->green*p->green*GetGreenPixelComponent(p);
if ((double) p->blue < channel_statistics[BlueChannel].minima)
channel_statistics[BlueChannel].minima=(double)
GetBluePixelComponent(p);
if ((double) p->blue > channel_statistics[BlueChannel].maxima)
channel_statistics[BlueChannel].maxima=(double)
GetBluePixelComponent(p);
- channel_statistics[BlueChannel].mean+=GetBluePixelComponent(p);
- channel_statistics[BlueChannel].standard_deviation+=(double) p->blue*
+ channel_statistics[BlueChannel].sum+=GetBluePixelComponent(p);
+ channel_statistics[BlueChannel].sum_squared+=(double) p->blue*
GetBluePixelComponent(p);
- channel_statistics[BlueChannel].kurtosis+=(double) p->blue*p->blue*
- p->blue*GetBluePixelComponent(p);
- channel_statistics[BlueChannel].skewness+=(double) p->blue*p->blue*
+ channel_statistics[BlueChannel].sum_cubed+=(double) p->blue*p->blue*
GetBluePixelComponent(p);
+ channel_statistics[BlueChannel].sum_fourth_power+=(double) p->blue*
+ p->blue*p->blue*GetBluePixelComponent(p);
if (image->matte != MagickFalse)
{
if ((double) p->opacity < channel_statistics[OpacityChannel].minima)
if ((double) p->opacity > channel_statistics[OpacityChannel].maxima)
channel_statistics[OpacityChannel].maxima=(double)
GetOpacityPixelComponent(p);
- channel_statistics[OpacityChannel].mean+=GetOpacityPixelComponent(p);
- channel_statistics[OpacityChannel].standard_deviation+=(double)
+ channel_statistics[OpacityChannel].sum+=GetOpacityPixelComponent(p);
+ channel_statistics[OpacityChannel].sum_squared+=(double)
p->opacity*GetOpacityPixelComponent(p);
- channel_statistics[OpacityChannel].kurtosis+=(double) p->opacity*
- p->opacity*p->opacity*GetOpacityPixelComponent(p);
- channel_statistics[OpacityChannel].skewness+=(double) p->opacity*
+ channel_statistics[OpacityChannel].sum_cubed+=(double) p->opacity*
p->opacity*GetOpacityPixelComponent(p);
+ channel_statistics[OpacityChannel].sum_fourth_power+=(double)
+ p->opacity*p->opacity*p->opacity*GetOpacityPixelComponent(p);
}
if (image->colorspace == CMYKColorspace)
{
channel_statistics[BlackChannel].minima=(double) indexes[x];
if ((double) indexes[x] > channel_statistics[BlackChannel].maxima)
channel_statistics[BlackChannel].maxima=(double) indexes[x];
- channel_statistics[BlackChannel].mean+=indexes[x];
- channel_statistics[BlackChannel].standard_deviation+=(double)
+ channel_statistics[BlackChannel].sum+=indexes[x];
+ channel_statistics[BlackChannel].sum_squared+=(double)
indexes[x]*indexes[x];
- channel_statistics[BlackChannel].kurtosis+=(double) indexes[x]*
- indexes[x]*indexes[x]*indexes[x];
- channel_statistics[BlackChannel].skewness+=(double) indexes[x]*
+ channel_statistics[BlackChannel].sum_cubed+=(double) indexes[x]*
indexes[x]*indexes[x];
+ channel_statistics[BlackChannel].sum_fourth_power+=(double)
+ indexes[x]*indexes[x]*indexes[x]*indexes[x];
}
x++;
p++;
area=(double) image->columns*image->rows;
for (i=0; i < AllChannels; i++)
{
- channel_statistics[i].mean/=area;
- channel_statistics[i].standard_deviation/=area;
- channel_statistics[i].kurtosis/=area;
- channel_statistics[i].skewness/=area;
+ channel_statistics[i].sum/=area;
+ channel_statistics[i].sum_squared/=area;
+ channel_statistics[i].sum_cubed/=area;
+ channel_statistics[i].sum_fourth_power/=area;
+ channel_statistics[i].mean=channel_statistics[i].sum;
+ channel_statistics[i].variance=channel_statistics[i].sum_squared;
+ channel_statistics[i].standard_deviation=sqrt(
+ channel_statistics[i].variance-(channel_statistics[i].mean*
+ channel_statistics[i].mean));
}
for (i=0; i < AllChannels; i++)
{
- channel_statistics[AllChannels].depth=(unsigned long) MagickMax((double)
+ channel_statistics[AllChannels].depth=(size_t) MagickMax((double)
channel_statistics[AllChannels].depth,(double)
channel_statistics[i].depth);
channel_statistics[AllChannels].minima=MagickMin(
channel_statistics[AllChannels].minima,channel_statistics[i].minima);
channel_statistics[AllChannels].maxima=MagickMax(
channel_statistics[AllChannels].maxima,channel_statistics[i].maxima);
+ channel_statistics[AllChannels].sum+=channel_statistics[i].sum;
+ channel_statistics[AllChannels].sum_squared+=
+ channel_statistics[i].sum_squared;
+ channel_statistics[AllChannels].sum_cubed+=channel_statistics[i].sum_cubed;
+ channel_statistics[AllChannels].sum_fourth_power+=
+ channel_statistics[i].sum_fourth_power;
channel_statistics[AllChannels].mean+=channel_statistics[i].mean;
+ channel_statistics[AllChannels].variance+=channel_statistics[i].variance-
+ channel_statistics[i].mean*channel_statistics[i].mean;
channel_statistics[AllChannels].standard_deviation+=
- channel_statistics[i].standard_deviation;
- channel_statistics[AllChannels].kurtosis+=channel_statistics[i].kurtosis;
- channel_statistics[AllChannels].skewness+=channel_statistics[i].skewness;
+ channel_statistics[i].variance-channel_statistics[i].mean*
+ channel_statistics[i].mean;
}
- channels=4;
+ channels=3;
+ if (image->matte != MagickFalse)
+ channels++;
if (image->colorspace == CMYKColorspace)
channels++;
+ channel_statistics[AllChannels].sum/=channels;
+ channel_statistics[AllChannels].sum_squared/=channels;
+ channel_statistics[AllChannels].sum_cubed/=channels;
+ channel_statistics[AllChannels].sum_fourth_power/=channels;
channel_statistics[AllChannels].mean/=channels;
- channel_statistics[AllChannels].standard_deviation/=channels;
+ channel_statistics[AllChannels].variance/=channels;
+ channel_statistics[AllChannels].standard_deviation=
+ sqrt(channel_statistics[AllChannels].standard_deviation/channels);
channel_statistics[AllChannels].kurtosis/=channels;
channel_statistics[AllChannels].skewness/=channels;
for (i=0; i <= AllChannels; i++)
{
- sum_squares=0.0;
- sum_squares=channel_statistics[i].standard_deviation;
- sum_cubes=0.0;
- sum_cubes=channel_statistics[i].skewness;
- channel_statistics[i].standard_deviation=sqrt(
- channel_statistics[i].standard_deviation-
- (channel_statistics[i].mean*channel_statistics[i].mean));
if (channel_statistics[i].standard_deviation == 0.0)
- {
- channel_statistics[i].kurtosis=0.0;
- channel_statistics[i].skewness=0.0;
- }
- else
- {
- channel_statistics[i].skewness=(channel_statistics[i].skewness-
- 3.0*channel_statistics[i].mean*sum_squares+
- 2.0*channel_statistics[i].mean*channel_statistics[i].mean*
- channel_statistics[i].mean)/
- (channel_statistics[i].standard_deviation*
- channel_statistics[i].standard_deviation*
- channel_statistics[i].standard_deviation);
- channel_statistics[i].kurtosis=(channel_statistics[i].kurtosis-
- 4.0*channel_statistics[i].mean*sum_cubes+
- 6.0*channel_statistics[i].mean*channel_statistics[i].mean*sum_squares-
- 3.0*channel_statistics[i].mean*channel_statistics[i].mean*
- 1.0*channel_statistics[i].mean*channel_statistics[i].mean)/
- (channel_statistics[i].standard_deviation*
- channel_statistics[i].standard_deviation*
- channel_statistics[i].standard_deviation*
- channel_statistics[i].standard_deviation)-3.0;
- }
+ continue;
+ channel_statistics[i].skewness=(channel_statistics[i].sum_cubed-
+ 3.0*channel_statistics[i].mean*channel_statistics[i].sum_squared+
+ 2.0*channel_statistics[i].mean*channel_statistics[i].mean*
+ channel_statistics[i].mean)/(channel_statistics[i].standard_deviation*
+ channel_statistics[i].standard_deviation*
+ channel_statistics[i].standard_deviation);
+ channel_statistics[i].kurtosis=(channel_statistics[i].sum_fourth_power-
+ 4.0*channel_statistics[i].mean*channel_statistics[i].sum_cubed+
+ 6.0*channel_statistics[i].mean*channel_statistics[i].mean*
+ channel_statistics[i].sum_squared-3.0*channel_statistics[i].mean*
+ channel_statistics[i].mean*1.0*channel_statistics[i].mean*
+ channel_statistics[i].mean)/(channel_statistics[i].standard_deviation*
+ channel_statistics[i].standard_deviation*
+ channel_statistics[i].standard_deviation*
+ channel_statistics[i].standard_deviation)-3.0;
}
return(channel_statistics);
}
projects / imagemagick / blobdiff