% October 1996 %
% %
% %
-% Copyright 1999-2009 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
Include declarations.
*/
#include "magick/studio.h"
-#include "magick/property.h"
+#include "magick/accelerate.h"
#include "magick/blob.h"
#include "magick/cache-view.h"
#include "magick/color.h"
#include "magick/monitor.h"
#include "magick/monitor-private.h"
#include "magick/montage.h"
+#include "magick/morphology.h"
#include "magick/paint.h"
#include "magick/pixel-private.h"
#include "magick/property.h"
#define AdaptiveBlurImageTag "Convolve/Image"
#define MagickSigma (fabs(sigma) <= MagickEpsilon ? 1.0 : sigma)
+ CacheView
+ *blur_view,
+ *edge_view,
+ *image_view;
+
double
- **kernel;
+ **kernel,
+ normalize;
Image
*blur_image,
*edge_image,
*gaussian_image;
- long
- j,
- progress,
- y;
-
MagickBooleanType
status;
- MagickPixelPacket
- zero;
+ MagickOffsetType
+ progress;
- MagickRealType
- alpha,
- bias,
- normalize;
+ MagickPixelPacket
+ bias;
- register long
- i,
- u,
- v;
+ register ssize_t
+ i;
- unsigned long
+ size_t
width;
- CacheView
- *blur_view,
- *edge_view,
- *image_view;
+ ssize_t
+ j,
+ k,
+ u,
+ v,
+ y;
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
(void) ResetMagickMemory(kernel,0,(size_t) width*sizeof(*kernel));
- for (i=0; i < (long) width; i+=2)
+ for (i=0; i < (ssize_t) width; i+=2)
{
kernel[i]=(double *) AcquireQuantumMemory((size_t) (width-i),(width-i)*
sizeof(**kernel));
if (kernel[i] == (double *) NULL)
break;
- j=0;
- for (v=(-((long) (width-i)/2)); v <= (long) ((width-i)/2); v++)
+ normalize=0.0;
+ j=(ssize_t) (width-i)/2;
+ k=0;
+ for (v=(-j); v <= j; v++)
{
- for (u=(-((long) (width-i)/2)); u <= (long) ((width-i)/2); u++)
+ for (u=(-j); u <= j; u++)
{
- alpha=exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma));
- kernel[i][j]=(double) (alpha/(2.0*MagickPI*MagickSigma*MagickSigma));
- j++;
+ kernel[i][k]=(double) (exp(-((double) u*u+v*v)/(2.0*MagickSigma*
+ MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
+ normalize+=kernel[i][k];
+ k++;
}
}
- normalize=0.0;
- for (j=0; j < (long) ((width-i)*(width-i)); j++)
- normalize+=kernel[i][j];
if (fabs(normalize) <= MagickEpsilon)
normalize=1.0;
normalize=1.0/normalize;
- for (j=0; j < (long) ((width-i)*(width-i)); j++)
- kernel[i][j]=(double) (normalize*kernel[i][j]);
+ for (k=0; k < (j*j); k++)
+ kernel[i][k]=normalize*kernel[i][k];
}
- if (i < (long) width)
+ if (i < (ssize_t) width)
{
for (i-=2; i >= 0; i-=2)
kernel[i]=(double *) RelinquishMagickMemory(kernel[i]);
*/
status=MagickTrue;
progress=0;
- bias=image->bias;
- GetMagickPixelPacket(image,&zero);
+ GetMagickPixelPacket(image,&bias);
+ SetMagickPixelPacketBias(image,&bias);
image_view=AcquireCacheView(image);
edge_view=AcquireCacheView(edge_image);
blur_view=AcquireCacheView(blur_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) blur_image->rows; y++)
+ for (y=0; y < (ssize_t) blur_image->rows; y++)
{
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p,
- *__restrict r;
+ *restrict p,
+ *restrict r;
register IndexPacket
- *__restrict blur_indexes;
-
- register long
- x;
+ *restrict blur_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
continue;
}
blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
- for (x=0; x < (long) blur_image->columns; x++)
+ for (x=0; x < (ssize_t) blur_image->columns; x++)
{
MagickPixelPacket
pixel;
gamma;
register const double
- *__restrict k;
+ *restrict k;
- register long
+ register ssize_t
i,
u,
v;
gamma=0.0;
- i=(long) (width*QuantumScale*PixelIntensity(r)+0.5);
+ i=(ssize_t) ceil((double) width*QuantumScale*PixelIntensity(r)-0.5);
if (i < 0)
i=0;
else
- if (i > (long) width)
- i=(long) width;
+ if (i > (ssize_t) width)
+ i=(ssize_t) width;
if ((i & 0x01) != 0)
i--;
- p=GetCacheViewVirtualPixels(image_view,x-((long) (width-i)/2L),y-(long)
- ((width-i)/2L),width-i,width-i,exception);
+ p=GetCacheViewVirtualPixels(image_view,x-((ssize_t) (width-i)/2L),y-
+ (ssize_t) ((width-i)/2L),width-i,width-i,exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetCacheViewVirtualIndexQueue(image_view);
- pixel=zero;
+ pixel=bias;
k=kernel[i];
- for (v=0; v < (long) (width-i); v++)
+ for (v=0; v < (ssize_t) (width-i); v++)
{
- for (u=0; u < (long) (width-i); u++)
+ for (u=0; u < (ssize_t) (width-i); u++)
{
alpha=1.0;
if (((channel & OpacityChannel) != 0) &&
(image->matte != MagickFalse))
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-p->opacity));
+ alpha=(MagickRealType) (QuantumScale*GetAlphaPixelComponent(p));
if ((channel & RedChannel) != 0)
- pixel.red+=(*k)*alpha*p->red;
+ pixel.red+=(*k)*alpha*GetRedPixelComponent(p);
if ((channel & GreenChannel) != 0)
- pixel.green+=(*k)*alpha*p->green;
+ pixel.green+=(*k)*alpha*GetGreenPixelComponent(p);
if ((channel & BlueChannel) != 0)
- pixel.blue+=(*k)*alpha*p->blue;
+ pixel.blue+=(*k)*alpha*GetBluePixelComponent(p);
if ((channel & OpacityChannel) != 0)
- pixel.opacity+=(*k)*p->opacity;
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(p);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- pixel.index+=(*k)*alpha*indexes[x+(width-i)*v+u];
+ pixel.index+=(*k)*alpha*GetIndexPixelComponent(indexes+x+(width-i)*
+ v+u);
gamma+=(*k)*alpha;
k++;
p++;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*pixel.red+bias);
+ SetRedPixelComponent(q,ClampToQuantum(gamma*pixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*pixel.green+bias);
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*pixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*pixel.blue+bias);
+ SetBluePixelComponent(q,ClampToQuantum(gamma*pixel.blue));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(pixel.opacity+bias);
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=RoundToQuantum(gamma*pixel.index+bias);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(gamma*
+ pixel.index));
q++;
r++;
}
edge_view=DestroyCacheView(edge_view);
image_view=DestroyCacheView(image_view);
edge_image=DestroyImage(edge_image);
- for (i=0; i < (long) width; i+=2)
+ for (i=0; i < (ssize_t) width; i+=2)
kernel[i]=(double *) RelinquishMagickMemory(kernel[i]);
kernel=(double **) RelinquishMagickMemory(kernel);
if (status == MagickFalse)
#define AdaptiveSharpenImageTag "Convolve/Image"
#define MagickSigma (fabs(sigma) <= MagickEpsilon ? 1.0 : sigma)
+ CacheView
+ *sharp_view,
+ *edge_view,
+ *image_view;
+
double
- **kernel;
+ **kernel,
+ normalize;
Image
*sharp_image,
*edge_image,
*gaussian_image;
- long
- j,
- progress,
- y;
-
MagickBooleanType
status;
- MagickPixelPacket
- zero;
+ MagickOffsetType
+ progress;
- MagickRealType
- alpha,
- bias,
- normalize;
+ MagickPixelPacket
+ bias;
- register long
- i,
- u,
- v;
+ register ssize_t
+ i;
- unsigned long
+ size_t
width;
- CacheView
- *sharp_view,
- *edge_view,
- *image_view;
+ ssize_t
+ j,
+ k,
+ u,
+ v,
+ y;
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
(void) ResetMagickMemory(kernel,0,(size_t) width*sizeof(*kernel));
- for (i=0; i < (long) width; i+=2)
+ for (i=0; i < (ssize_t) width; i+=2)
{
kernel[i]=(double *) AcquireQuantumMemory((size_t) (width-i),(width-i)*
sizeof(**kernel));
if (kernel[i] == (double *) NULL)
break;
- j=0;
- for (v=(-((long) (width-i)/2)); v <= (long) ((width-i)/2); v++)
+ normalize=0.0;
+ j=(ssize_t) (width-i)/2;
+ k=0;
+ for (v=(-j); v <= j; v++)
{
- for (u=(-((long) (width-i)/2)); u <= (long) ((width-i)/2); u++)
+ for (u=(-j); u <= j; u++)
{
- alpha=exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma));
- kernel[i][j]=(double) (-alpha/(2.0*MagickPI*MagickSigma*MagickSigma));
- j++;
+ kernel[i][k]=(double) (-exp(-((double) u*u+v*v)/(2.0*MagickSigma*
+ MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
+ normalize+=kernel[i][k];
+ k++;
}
}
- normalize=0.0;
- for (j=0; j < (long) ((width-i)*(width-i)); j++)
- normalize+=kernel[i][j];
if (fabs(normalize) <= MagickEpsilon)
normalize=1.0;
normalize=1.0/normalize;
- for (j=0; j < (long) ((width-i)*(width-i)); j++)
- kernel[i][j]=(double) (normalize*kernel[i][j]);
+ for (k=0; k < (j*j); k++)
+ kernel[i][k]=normalize*kernel[i][k];
}
- if (i < (long) width)
+ if (i < (ssize_t) width)
{
for (i-=2; i >= 0; i-=2)
kernel[i]=(double *) RelinquishMagickMemory(kernel[i]);
*/
status=MagickTrue;
progress=0;
- bias=image->bias;
- GetMagickPixelPacket(image,&zero);
+ GetMagickPixelPacket(image,&bias);
+ SetMagickPixelPacketBias(image,&bias);
image_view=AcquireCacheView(image);
edge_view=AcquireCacheView(edge_image);
sharp_view=AcquireCacheView(sharp_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) sharp_image->rows; y++)
+ for (y=0; y < (ssize_t) sharp_image->rows; y++)
{
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p,
- *__restrict r;
+ *restrict p,
+ *restrict r;
register IndexPacket
- *__restrict sharp_indexes;
-
- register long
- x;
+ *restrict sharp_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
continue;
}
sharp_indexes=GetCacheViewAuthenticIndexQueue(sharp_view);
- for (x=0; x < (long) sharp_image->columns; x++)
+ for (x=0; x < (ssize_t) sharp_image->columns; x++)
{
MagickPixelPacket
pixel;
gamma;
register const double
- *__restrict k;
+ *restrict k;
- register long
+ register ssize_t
i,
u,
v;
gamma=0.0;
- i=(long) (width*(QuantumRange-QuantumScale*PixelIntensity(r))+0.5);
+ i=(ssize_t) ceil((double) width*(QuantumRange-QuantumScale*
+ PixelIntensity(r))-0.5);
if (i < 0)
i=0;
else
- if (i > (long) width)
- i=(long) width;
+ if (i > (ssize_t) width)
+ i=(ssize_t) width;
if ((i & 0x01) != 0)
i--;
- p=GetCacheViewVirtualPixels(image_view,x-((long) (width-i)/2L),y-(long)
- ((width-i)/2L),width-i,width-i,exception);
+ p=GetCacheViewVirtualPixels(image_view,x-((ssize_t) (width-i)/2L),y-
+ (ssize_t) ((width-i)/2L),width-i,width-i,exception);
if (p == (const PixelPacket *) NULL)
break;
indexes=GetCacheViewVirtualIndexQueue(image_view);
k=kernel[i];
- pixel=zero;
- for (v=0; v < (long) (width-i); v++)
+ pixel=bias;
+ for (v=0; v < (ssize_t) (width-i); v++)
{
- for (u=0; u < (long) (width-i); u++)
+ for (u=0; u < (ssize_t) (width-i); u++)
{
alpha=1.0;
if (((channel & OpacityChannel) != 0) &&
(image->matte != MagickFalse))
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-p->opacity));
+ alpha=(MagickRealType) (QuantumScale*GetAlphaPixelComponent(p));
if ((channel & RedChannel) != 0)
- pixel.red+=(*k)*alpha*p->red;
+ pixel.red+=(*k)*alpha*GetRedPixelComponent(p);
if ((channel & GreenChannel) != 0)
- pixel.green+=(*k)*alpha*p->green;
+ pixel.green+=(*k)*alpha*GetGreenPixelComponent(p);
if ((channel & BlueChannel) != 0)
- pixel.blue+=(*k)*alpha*p->blue;
+ pixel.blue+=(*k)*alpha*GetBluePixelComponent(p);
if ((channel & OpacityChannel) != 0)
- pixel.opacity+=(*k)*p->opacity;
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(p);
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- pixel.index+=(*k)*alpha*indexes[x+(width-i)*v+u];
+ pixel.index+=(*k)*alpha*GetIndexPixelComponent(indexes+x+(width-i)*
+ v+u);
gamma+=(*k)*alpha;
k++;
p++;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*pixel.red+bias);
+ SetRedPixelComponent(q,ClampToQuantum(gamma*pixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*pixel.green+bias);
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*pixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*pixel.blue+bias);
+ SetBluePixelComponent(q,ClampToQuantum(gamma*pixel.blue));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(pixel.opacity+bias);
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- sharp_indexes[x]=RoundToQuantum(gamma*pixel.index+bias);
+ SetIndexPixelComponent(sharp_indexes+x,ClampToQuantum(gamma*
+ pixel.index));
q++;
r++;
}
edge_view=DestroyCacheView(edge_view);
image_view=DestroyCacheView(image_view);
edge_image=DestroyImage(edge_image);
- for (i=0; i < (long) width; i+=2)
+ for (i=0; i < (ssize_t) width; i+=2)
kernel[i]=(double *) RelinquishMagickMemory(kernel[i]);
kernel=(double **) RelinquishMagickMemory(kernel);
if (status == MagickFalse)
return(blur_image);
}
-static double *GetBlurKernel(unsigned long width,const MagickRealType sigma)
+static double *GetBlurKernel(const size_t width,const double sigma)
{
-#define KernelRank 3
-
double
- *kernel;
-
- long
- bias;
-
- MagickRealType
- alpha,
+ *kernel,
normalize;
- register long
+ register ssize_t
i;
+ ssize_t
+ j,
+ k;
+
/*
Generate a 1-D convolution kernel.
*/
kernel=(double *) AcquireQuantumMemory((size_t) width,sizeof(*kernel));
if (kernel == (double *) NULL)
return(0);
- (void) ResetMagickMemory(kernel,0,(size_t) width*sizeof(*kernel));
- bias=KernelRank*(long) width/2;
- for (i=(-bias); i <= bias; i++)
- {
- alpha=exp((-((double) (i*i))/(double) (2.0*KernelRank*KernelRank*
- MagickSigma*MagickSigma)));
- kernel[(i+bias)/KernelRank]+=(double) (alpha/(MagickSQ2PI*sigma));
- }
normalize=0.0;
- for (i=0; i < (long) width; i++)
+ j=(ssize_t) width/2;
+ i=0;
+ for (k=(-j); k <= j; k++)
+ {
+ kernel[i]=(double) (exp(-((double) k*k)/(2.0*MagickSigma*MagickSigma))/
+ (MagickSQ2PI*MagickSigma));
normalize+=kernel[i];
- for (i=0; i < (long) width; i++)
+ i++;
+ }
+ for (i=0; i < (ssize_t) width; i++)
kernel[i]/=normalize;
return(kernel);
}
{
#define BlurImageTag "Blur/Image"
+ CacheView
+ *blur_view,
+ *image_view;
+
double
*kernel;
Image
*blur_image;
- long
- progress,
- x,
- y;
-
MagickBooleanType
status;
- MagickPixelPacket
- zero;
+ MagickOffsetType
+ progress;
- MagickRealType
+ MagickPixelPacket
bias;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
width;
- CacheView
- *blur_view,
- *image_view;
+ ssize_t
+ x,
+ y;
/*
Initialize blur image attributes.
*k;
(void) LogMagickEvent(TransformEvent,GetMagickModule(),
- " BlurImage with %ld kernel:",width);
+ " BlurImage with %.20g kernel:",(double) width);
message=AcquireString("");
k=kernel;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
*message='\0';
- (void) FormatMagickString(format,MaxTextExtent,"%ld: ",i);
+ (void) FormatMagickString(format,MaxTextExtent,"%.20g: ",(double) i);
(void) ConcatenateString(&message,format);
(void) FormatMagickString(format,MaxTextExtent,"%g ",*k++);
(void) ConcatenateString(&message,format);
*/
status=MagickTrue;
progress=0;
- GetMagickPixelPacket(image,&zero);
- bias=image->bias;
+ GetMagickPixelPacket(image,&bias);
+ SetMagickPixelPacketBias(image,&bias);
image_view=AcquireCacheView(image);
blur_view=AcquireCacheView(blur_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) blur_image->rows; y++)
+ for (y=0; y < (ssize_t) blur_image->rows; y++)
{
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict blur_indexes;
-
- register long
- x;
+ *restrict blur_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
- p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y,image->columns+
- width,1,exception);
+ p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y,
+ image->columns+width,1,exception);
q=GetCacheViewAuthenticPixels(blur_view,0,y,blur_image->columns,1,
exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
- for (x=0; x < (long) blur_image->columns; x++)
+ for (x=0; x < (ssize_t) blur_image->columns; x++)
{
MagickPixelPacket
pixel;
register const double
- *__restrict k;
+ *restrict k;
register const PixelPacket
- *__restrict kernel_pixels;
+ *restrict kernel_pixels;
- register long
+ register ssize_t
i;
- pixel=zero;
+ pixel=bias;
k=kernel;
kernel_pixels=p;
if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
{
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- pixel.red+=(*k)*kernel_pixels->red;
- pixel.green+=(*k)*kernel_pixels->green;
- pixel.blue+=(*k)*kernel_pixels->blue;
+ pixel.red+=(*k)*GetRedPixelComponent(kernel_pixels);
+ pixel.green+=(*k)*GetGreenPixelComponent(kernel_pixels);
+ pixel.blue+=(*k)*GetBluePixelComponent(kernel_pixels);
k++;
kernel_pixels++;
}
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(pixel.red+bias);
+ SetRedPixelComponent(q,ClampToQuantum(pixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(pixel.green+bias);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(pixel.blue+bias);
+ SetBluePixelComponent(q,ClampToQuantum(pixel.blue));
if ((channel & OpacityChannel) != 0)
{
k=kernel;
kernel_pixels=p;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- pixel.opacity+=(*k)*kernel_pixels->opacity;
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(kernel_pixels);
k++;
kernel_pixels++;
}
- q->opacity=RoundToQuantum(pixel.opacity+bias);
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
{
register const IndexPacket
- *__restrict kernel_indexes;
+ *restrict kernel_indexes;
k=kernel;
kernel_indexes=indexes;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- pixel.index+=(*k)*(*kernel_indexes);
+ pixel.index+=(*k)*GetIndexPixelComponent(kernel_indexes);
k++;
kernel_indexes++;
}
- blur_indexes[x]=RoundToQuantum(pixel.index+bias);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(
+ pixel.index));
}
}
else
gamma;
gamma=0.0;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-
- kernel_pixels->opacity));
- pixel.red+=(*k)*alpha*kernel_pixels->red;
- pixel.green+=(*k)*alpha*kernel_pixels->green;
- pixel.blue+=(*k)*alpha*kernel_pixels->blue;
+ alpha=(MagickRealType) (QuantumScale*
+ GetAlphaPixelComponent(kernel_pixels));
+ pixel.red+=(*k)*alpha*GetRedPixelComponent(kernel_pixels);
+ pixel.green+=(*k)*alpha*GetGreenPixelComponent(kernel_pixels);
+ pixel.blue+=(*k)*alpha*GetBluePixelComponent(kernel_pixels);
gamma+=(*k)*alpha;
k++;
kernel_pixels++;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*pixel.red+bias);
+ SetRedPixelComponent(q,ClampToQuantum(gamma*pixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*pixel.green+bias);
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*pixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*pixel.blue+bias);
+ SetBluePixelComponent(q,ClampToQuantum(gamma*pixel.blue));
if ((channel & OpacityChannel) != 0)
{
k=kernel;
kernel_pixels=p;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- pixel.opacity+=(*k)*kernel_pixels->opacity;
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(kernel_pixels);
k++;
kernel_pixels++;
}
- q->opacity=RoundToQuantum(pixel.opacity+bias);
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
{
register const IndexPacket
- *__restrict kernel_indexes;
+ *restrict kernel_indexes;
k=kernel;
kernel_pixels=p;
kernel_indexes=indexes;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-
- kernel_pixels->opacity));
+ alpha=(MagickRealType) (QuantumScale*
+ GetAlphaPixelComponent(kernel_pixels));
pixel.index+=(*k)*alpha*(*kernel_indexes);
k++;
kernel_pixels++;
kernel_indexes++;
}
- blur_indexes[x]=RoundToQuantum(gamma*pixel.index+bias);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(gamma*
+ pixel.index));
}
}
+ indexes++;
p++;
q++;
}
image_view=AcquireCacheView(blur_image);
blur_view=AcquireCacheView(blur_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for shared(progress,status)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (x=0; x < (long) blur_image->columns; x++)
+ for (x=0; x < (ssize_t) blur_image->columns; x++)
{
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict blur_indexes;
-
- register long
- y;
+ *restrict blur_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ y;
if (status == MagickFalse)
continue;
- p=GetCacheViewVirtualPixels(image_view,x,-((long) width/2L),1,image->rows+
- width,exception);
+ p=GetCacheViewVirtualPixels(image_view,x,-((ssize_t) width/2L),1,
+ image->rows+width,exception);
q=GetCacheViewAuthenticPixels(blur_view,x,0,1,blur_image->rows,exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
{
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
- for (y=0; y < (long) blur_image->rows; y++)
+ for (y=0; y < (ssize_t) blur_image->rows; y++)
{
MagickPixelPacket
pixel;
register const double
- *__restrict k;
+ *restrict k;
register const PixelPacket
- *__restrict kernel_pixels;
+ *restrict kernel_pixels;
- register long
+ register ssize_t
i;
- pixel=zero;
+ pixel=bias;
k=kernel;
kernel_pixels=p;
if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
{
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- pixel.red+=(*k)*kernel_pixels->red;
- pixel.green+=(*k)*kernel_pixels->green;
- pixel.blue+=(*k)*kernel_pixels->blue;
+ pixel.red+=(*k)*GetRedPixelComponent(kernel_pixels);
+ pixel.green+=(*k)*GetGreenPixelComponent(kernel_pixels);
+ pixel.blue+=(*k)*GetBluePixelComponent(kernel_pixels);
k++;
kernel_pixels++;
}
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(pixel.red+bias);
+ SetRedPixelComponent(q,ClampToQuantum(pixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(pixel.green+bias);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(pixel.blue+bias);
+ SetBluePixelComponent(q,ClampToQuantum(pixel.blue));
if ((channel & OpacityChannel) != 0)
{
k=kernel;
kernel_pixels=p;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- pixel.opacity+=(*k)*kernel_pixels->opacity;
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(kernel_pixels);
k++;
kernel_pixels++;
}
- q->opacity=RoundToQuantum(pixel.opacity+bias);
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
{
register const IndexPacket
- *__restrict kernel_indexes;
+ *restrict kernel_indexes;
k=kernel;
kernel_indexes=indexes;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- pixel.index+=(*k)*(*kernel_indexes);
+ pixel.index+=(*k)*GetIndexPixelComponent(kernel_indexes);
k++;
kernel_indexes++;
}
- blur_indexes[y]=RoundToQuantum(pixel.index+bias);
+ SetIndexPixelComponent(blur_indexes+y,ClampToQuantum(
+ pixel.index));
}
}
else
gamma;
gamma=0.0;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-
- kernel_pixels->opacity));
- pixel.red+=(*k)*alpha*kernel_pixels->red;
- pixel.green+=(*k)*alpha*kernel_pixels->green;
- pixel.blue+=(*k)*alpha*kernel_pixels->blue;
+ alpha=(MagickRealType) (QuantumScale*
+ GetAlphaPixelComponent(kernel_pixels));
+ pixel.red+=(*k)*alpha*GetRedPixelComponent(kernel_pixels);
+ pixel.green+=(*k)*alpha*GetGreenPixelComponent(kernel_pixels);
+ pixel.blue+=(*k)*alpha*GetBluePixelComponent(kernel_pixels);
gamma+=(*k)*alpha;
k++;
kernel_pixels++;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*pixel.red+bias);
+ SetRedPixelComponent(q,ClampToQuantum(gamma*pixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*pixel.green+bias);
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*pixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*pixel.blue+bias);
+ SetBluePixelComponent(q,ClampToQuantum(gamma*pixel.blue));
if ((channel & OpacityChannel) != 0)
{
k=kernel;
kernel_pixels=p;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- pixel.opacity+=(*k)*kernel_pixels->opacity;
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(kernel_pixels);
k++;
kernel_pixels++;
}
- q->opacity=RoundToQuantum(pixel.opacity+bias);
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
{
register const IndexPacket
- *__restrict kernel_indexes;
+ *restrict kernel_indexes;
k=kernel;
kernel_pixels=p;
kernel_indexes=indexes;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-
- kernel_pixels->opacity));
+ alpha=(MagickRealType) (QuantumScale*
+ GetAlphaPixelComponent(kernel_pixels));
pixel.index+=(*k)*alpha*(*kernel_indexes);
k++;
kernel_pixels++;
kernel_indexes++;
}
- blur_indexes[y]=RoundToQuantum(gamma*pixel.index+bias);
+ SetIndexPixelComponent(blur_indexes+y,ClampToQuantum(gamma*
+ pixel.index));
}
}
+ indexes++;
p++;
q++;
}
% %
% %
% %
-% D e s p e c k l e I m a g e %
+% C o n v o l v e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DespeckleImage() reduces the speckle noise in an image while perserving the
-% edges of the original image.
+% ConvolveImage() applies a custom convolution kernel to the image.
%
-% The format of the DespeckleImage method is:
+% The format of the ConvolveImage method is:
%
-% Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
+% Image *ConvolveImage(const Image *image,const size_t order,
+% const double *kernel,ExceptionInfo *exception)
+% Image *ConvolveImageChannel(const Image *image,const ChannelType channel,
+% const size_t order,const double *kernel,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
+% o channel: the channel type.
+%
+% o order: the number of columns and rows in the filter kernel.
+%
+% o kernel: An array of double representing the convolution kernel.
+%
% o exception: return any errors or warnings in this structure.
%
*/
-static Quantum **DestroyPixelThreadSet(Quantum **pixels)
-{
- register long
- i;
-
- assert(pixels != (Quantum **) NULL);
- for (i=0; i < (long) GetOpenMPMaximumThreads(); i++)
- if (pixels[i] != (Quantum *) NULL)
- pixels[i]=(Quantum *) RelinquishMagickMemory(pixels[i]);
- pixels=(Quantum **) RelinquishAlignedMemory(pixels);
- return(pixels);
-}
-
-static Quantum **AcquirePixelThreadSet(const size_t count)
-{
- register long
- i;
-
- Quantum
- **pixels;
-
- unsigned long
- number_threads;
-
- number_threads=GetOpenMPMaximumThreads();
- pixels=(Quantum **) AcquireAlignedMemory(number_threads,sizeof(*pixels));
- if (pixels == (Quantum **) NULL)
- return((Quantum **) NULL);
- (void) ResetMagickMemory(pixels,0,number_threads*sizeof(*pixels));
- for (i=0; i < (long) number_threads; i++)
- {
- pixels[i]=(Quantum *) AcquireQuantumMemory(count,sizeof(**pixels));
- if (pixels[i] == (Quantum *) NULL)
- return(DestroyPixelThreadSet(pixels));
- }
- return(pixels);
-}
-
-static void Hull(const long x_offset,const long y_offset,
- const unsigned long columns,const unsigned long rows,Quantum *f,Quantum *g,
- const int polarity)
+MagickExport Image *ConvolveImage(const Image *image,const size_t order,
+ const double *kernel,ExceptionInfo *exception)
{
- long
- y;
-
- MagickRealType
- v;
-
- register long
- x;
-
- register Quantum
- *p,
- *q,
- *r,
- *s;
+ Image
+ *convolve_image;
- assert(f != (Quantum *) NULL);
- assert(g != (Quantum *) NULL);
- p=f+(columns+2);
- q=g+(columns+2);
- r=p+(y_offset*((long) columns+2)+x_offset);
- for (y=0; y < (long) rows; y++)
- {
- p++;
- q++;
- r++;
- if (polarity > 0)
- for (x=(long) columns; x != 0; x--)
- {
- v=(MagickRealType) (*p);
- if ((MagickRealType) *r >= (v+(MagickRealType) ScaleCharToQuantum(2)))
- v+=ScaleCharToQuantum(1);
- *q=(Quantum) v;
- p++;
- q++;
- r++;
- }
- else
- for (x=(long) columns; x != 0; x--)
- {
- v=(MagickRealType) (*p);
- if ((MagickRealType) *r <= (v-(MagickRealType) ScaleCharToQuantum(2)))
- v-=(long) ScaleCharToQuantum(1);
- *q=(Quantum) v;
- p++;
- q++;
- r++;
- }
- p++;
- q++;
- r++;
- }
- p=f+(columns+2);
- q=g+(columns+2);
- r=q+(y_offset*((long) columns+2)+x_offset);
- s=q-(y_offset*((long) columns+2)+x_offset);
- for (y=0; y < (long) rows; y++)
- {
- p++;
- q++;
- r++;
- s++;
- if (polarity > 0)
- for (x=(long) columns; x != 0; x--)
- {
- v=(MagickRealType) (*q);
- if (((MagickRealType) *s >=
- (v+(MagickRealType) ScaleCharToQuantum(2))) &&
- ((MagickRealType) *r > v))
- v+=ScaleCharToQuantum(1);
- *p=(Quantum) v;
- p++;
- q++;
- r++;
- s++;
- }
- else
- for (x=(long) columns; x != 0; x--)
- {
- v=(MagickRealType) (*q);
- if (((MagickRealType) *s <=
- (v-(MagickRealType) ScaleCharToQuantum(2))) &&
- ((MagickRealType) *r < v))
- v-=(MagickRealType) ScaleCharToQuantum(1);
- *p=(Quantum) v;
- p++;
- q++;
- r++;
- s++;
- }
- p++;
- q++;
- r++;
- s++;
- }
+ convolve_image=ConvolveImageChannel(image,DefaultChannels,order,kernel,
+ exception);
+ return(convolve_image);
}
-MagickExport Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
+MagickExport Image *ConvolveImageChannel(const Image *image,
+ const ChannelType channel,const size_t order,const double *kernel,
+ ExceptionInfo *exception)
{
-#define DespeckleImageTag "Despeckle/Image"
+#define ConvolveImageTag "Convolve/Image"
CacheView
- *despeckle_view,
+ *convolve_view,
*image_view;
- Image
- *despeckle_image;
+ double
+ *normal_kernel;
- long
- channel;
+ Image
+ *convolve_image;
MagickBooleanType
status;
- Quantum
- **buffers,
- **pixels;
+ MagickOffsetType
+ progress;
+
+ MagickPixelPacket
+ bias;
+
+ MagickRealType
+ gamma;
+
+ register ssize_t
+ i;
size_t
- length;
+ width;
- static const int
- X[4] = {0, 1, 1,-1},
- Y[4] = {1, 0, 1, 1};
+ ssize_t
+ y;
/*
- Allocate despeckled image.
+ Initialize convolve image attributes.
*/
- assert(image != (const Image *) NULL);
+ assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- despeckle_image=CloneImage(image,image->columns,image->rows,MagickTrue,
- exception);
- if (despeckle_image == (Image *) NULL)
+ width=order;
+ if ((width % 2) == 0)
+ ThrowImageException(OptionError,"KernelWidthMustBeAnOddNumber");
+ convolve_image=CloneImage(image,0,0,MagickTrue,exception);
+ if (convolve_image == (Image *) NULL)
return((Image *) NULL);
- if (SetImageStorageClass(despeckle_image,DirectClass) == MagickFalse)
+ if (SetImageStorageClass(convolve_image,DirectClass) == MagickFalse)
{
- InheritException(exception,&despeckle_image->exception);
- despeckle_image=DestroyImage(despeckle_image);
+ InheritException(exception,&convolve_image->exception);
+ convolve_image=DestroyImage(convolve_image);
return((Image *) NULL);
}
- /*
- Allocate image buffers.
- */
- length=(size_t) ((image->columns+2)*(image->rows+2));
- pixels=AcquirePixelThreadSet(length);
- buffers=AcquirePixelThreadSet(length);
- if ((pixels == (Quantum **) NULL) || (buffers == (Quantum **) NULL))
+ if (image->debug != MagickFalse)
{
- if (buffers != (Quantum **) NULL)
- buffers=DestroyPixelThreadSet(buffers);
- if (pixels != (Quantum **) NULL)
- pixels=DestroyPixelThreadSet(pixels);
- despeckle_image=DestroyImage(despeckle_image);
- ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- }
- /*
- Reduce speckle in the image.
+ char
+ format[MaxTextExtent],
+ *message;
+
+ register const double
+ *k;
+
+ ssize_t
+ u,
+ v;
+
+ (void) LogMagickEvent(TransformEvent,GetMagickModule(),
+ " ConvolveImage with %.20gx%.20g kernel:",(double) width,(double)
+ width);
+ message=AcquireString("");
+ k=kernel;
+ for (v=0; v < (ssize_t) width; v++)
+ {
+ *message='\0';
+ (void) FormatMagickString(format,MaxTextExtent,"%.20g: ",(double) v);
+ (void) ConcatenateString(&message,format);
+ for (u=0; u < (ssize_t) width; u++)
+ {
+ (void) FormatMagickString(format,MaxTextExtent,"%g ",*k++);
+ (void) ConcatenateString(&message,format);
+ }
+ (void) LogMagickEvent(TransformEvent,GetMagickModule(),"%s",message);
+ }
+ message=DestroyString(message);
+ }
+ /*
+ Normalize kernel.
+ */
+ normal_kernel=(double *) AcquireQuantumMemory(width*width,
+ sizeof(*normal_kernel));
+ if (normal_kernel == (double *) NULL)
+ {
+ convolve_image=DestroyImage(convolve_image);
+ ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ }
+ gamma=0.0;
+ for (i=0; i < (ssize_t) (width*width); i++)
+ gamma+=kernel[i];
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ for (i=0; i < (ssize_t) (width*width); i++)
+ normal_kernel[i]=gamma*kernel[i];
+ /*
+ Convolve image.
*/
status=MagickTrue;
+ progress=0;
+ GetMagickPixelPacket(image,&bias);
+ SetMagickPixelPacketBias(image,&bias);
image_view=AcquireCacheView(image);
- despeckle_view=AcquireCacheView(despeckle_image);
+ convolve_view=AcquireCacheView(convolve_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(status)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (channel=0; channel <= 3; channel++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
- long
- j,
- y;
+ MagickBooleanType
+ sync;
- register long
- i,
- id,
- x;
+ register const IndexPacket
+ *restrict indexes;
- register Quantum
- *buffer,
- *pixel;
+ register const PixelPacket
+ *restrict p;
+
+ register IndexPacket
+ *restrict convolve_indexes;
+
+ register PixelPacket
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
- id=GetOpenMPThreadId();
- pixel=pixels[id];
- (void) ResetMagickMemory(pixel,0,length*sizeof(*pixel));
- buffer=buffers[id];
- j=(long) image->columns+2;
- for (y=0; y < (long) image->rows; y++)
- {
- register const PixelPacket
- *__restrict p;
-
- p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
- if (p == (const PixelPacket *) NULL)
- break;
- j++;
- for (x=0; x < (long) image->columns; x++)
+ p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t)
+ (width/2L),image->columns+width,width,exception);
+ q=GetCacheViewAuthenticPixels(convolve_view,0,y,convolve_image->columns,1,
+ exception);
+ if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
{
- switch (channel)
- {
- case 0: pixel[j]=p->red; break;
- case 1: pixel[j]=p->green; break;
- case 2: pixel[j]=p->blue; break;
- case 3: pixel[j]=p->opacity; break;
- default: break;
- }
- p++;
- j++;
+ status=MagickFalse;
+ continue;
}
- j++;
- }
- (void) ResetMagickMemory(buffer,0,length*sizeof(*buffer));
- for (i=0; i < 4; i++)
- {
- Hull(X[i],Y[i],image->columns,image->rows,pixel,buffer,1);
- Hull(-X[i],-Y[i],image->columns,image->rows,pixel,buffer,1);
- Hull(-X[i],-Y[i],image->columns,image->rows,pixel,buffer,-1);
- Hull(X[i],Y[i],image->columns,image->rows,pixel,buffer,-1);
- }
- j=(long) image->columns+2;
- for (y=0; y < (long) image->rows; y++)
+ indexes=GetCacheViewVirtualIndexQueue(image_view);
+ convolve_indexes=GetCacheViewAuthenticIndexQueue(convolve_view);
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- MagickBooleanType
- sync;
+ MagickPixelPacket
+ pixel;
- register PixelPacket
- *__restrict q;
+ register const double
+ *restrict k;
- q=GetCacheViewAuthenticPixels(despeckle_view,0,y,despeckle_image->columns,
- 1,exception);
- if (q == (PixelPacket *) NULL)
- break;
- j++;
- for (x=0; x < (long) image->columns; x++)
- {
- switch (channel)
+ register const PixelPacket
+ *restrict kernel_pixels;
+
+ register ssize_t
+ u;
+
+ ssize_t
+ v;
+
+ pixel=bias;
+ k=normal_kernel;
+ kernel_pixels=p;
+ if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
{
- case 0: q->red=pixel[j]; break;
- case 1: q->green=pixel[j]; break;
- case 2: q->blue=pixel[j]; break;
- case 3: q->opacity=pixel[j]; break;
- default: break;
+ for (v=0; v < (ssize_t) width; v++)
+ {
+ for (u=0; u < (ssize_t) width; u++)
+ {
+ pixel.red+=(*k)*kernel_pixels[u].red;
+ pixel.green+=(*k)*kernel_pixels[u].green;
+ pixel.blue+=(*k)*kernel_pixels[u].blue;
+ k++;
+ }
+ kernel_pixels+=image->columns+width;
+ }
+ if ((channel & RedChannel) != 0)
+ SetRedPixelComponent(q,ClampToQuantum(pixel.red));
+ if ((channel & GreenChannel) != 0)
+ SetGreenPixelComponent(q,ClampToQuantum(pixel.green));
+ if ((channel & BlueChannel) != 0)
+ SetBluePixelComponent(q,ClampToQuantum(pixel.blue));
+ if ((channel & OpacityChannel) != 0)
+ {
+ k=normal_kernel;
+ kernel_pixels=p;
+ for (v=0; v < (ssize_t) width; v++)
+ {
+ for (u=0; u < (ssize_t) width; u++)
+ {
+ pixel.opacity+=(*k)*kernel_pixels[u].opacity;
+ k++;
+ }
+ kernel_pixels+=image->columns+width;
+ }
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
+ }
+ if (((channel & IndexChannel) != 0) &&
+ (image->colorspace == CMYKColorspace))
+ {
+ register const IndexPacket
+ *restrict kernel_indexes;
+
+ k=normal_kernel;
+ kernel_indexes=indexes;
+ for (v=0; v < (ssize_t) width; v++)
+ {
+ for (u=0; u < (ssize_t) width; u++)
+ {
+ pixel.index+=(*k)*GetIndexPixelComponent(kernel_indexes+u);
+ k++;
+ }
+ kernel_indexes+=image->columns+width;
+ }
+ SetIndexPixelComponent(convolve_indexes+x,ClampToQuantum(
+ pixel.index));
+ }
}
- q++;
- j++;
- }
- sync=SyncCacheViewAuthenticPixels(despeckle_view,exception);
- if (sync == MagickFalse)
+ else
{
- status=MagickFalse;
- break;
+ MagickRealType
+ alpha,
+ gamma;
+
+ gamma=0.0;
+ for (v=0; v < (ssize_t) width; v++)
+ {
+ for (u=0; u < (ssize_t) width; u++)
+ {
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-
+ kernel_pixels[u].opacity));
+ pixel.red+=(*k)*alpha*kernel_pixels[u].red;
+ pixel.green+=(*k)*alpha*kernel_pixels[u].green;
+ pixel.blue+=(*k)*alpha*kernel_pixels[u].blue;
+ gamma+=(*k)*alpha;
+ k++;
+ }
+ kernel_pixels+=image->columns+width;
+ }
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ if ((channel & RedChannel) != 0)
+ SetRedPixelComponent(q,ClampToQuantum(gamma*pixel.red));
+ if ((channel & GreenChannel) != 0)
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*pixel.green));
+ if ((channel & BlueChannel) != 0)
+ SetBluePixelComponent(q,ClampToQuantum(gamma*pixel.blue));
+ if ((channel & OpacityChannel) != 0)
+ {
+ k=normal_kernel;
+ kernel_pixels=p;
+ for (v=0; v < (ssize_t) width; v++)
+ {
+ for (u=0; u < (ssize_t) width; u++)
+ {
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(kernel_pixels+u);
+ k++;
+ }
+ kernel_pixels+=image->columns+width;
+ }
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
+ }
+ if (((channel & IndexChannel) != 0) &&
+ (image->colorspace == CMYKColorspace))
+ {
+ register const IndexPacket
+ *restrict kernel_indexes;
+
+ k=normal_kernel;
+ kernel_pixels=p;
+ kernel_indexes=indexes;
+ for (v=0; v < (ssize_t) width; v++)
+ {
+ for (u=0; u < (ssize_t) width; u++)
+ {
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-
+ kernel_pixels[u].opacity));
+ pixel.index+=(*k)*alpha*GetIndexPixelComponent(
+ kernel_indexes+u);
+ k++;
+ }
+ kernel_pixels+=image->columns+width;
+ kernel_indexes+=image->columns+width;
+ }
+ SetIndexPixelComponent(convolve_indexes+x,ClampToQuantum(gamma*
+ pixel.index));
+ }
}
- j++;
+ indexes++;
+ p++;
+ q++;
}
+ sync=SyncCacheViewAuthenticPixels(convolve_view,exception);
+ if (sync == MagickFalse)
+ status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
MagickBooleanType
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_DespeckleImage)
+ #pragma omp critical (MagickCore_ConvolveImageChannel)
#endif
- proceed=SetImageProgress(image,DespeckleImageTag,channel,3);
+ proceed=SetImageProgress(image,ConvolveImageTag,progress++,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
- despeckle_view=DestroyCacheView(despeckle_view);
+ convolve_image->type=image->type;
+ convolve_view=DestroyCacheView(convolve_view);
image_view=DestroyCacheView(image_view);
- buffers=DestroyPixelThreadSet(buffers);
- pixels=DestroyPixelThreadSet(pixels);
- despeckle_image->type=image->type;
+ normal_kernel=(double *) RelinquishMagickMemory(normal_kernel);
if (status == MagickFalse)
- despeckle_image=DestroyImage(despeckle_image);
- return(despeckle_image);
+ convolve_image=DestroyImage(convolve_image);
+ return(convolve_image);
}
\f
/*
% %
% %
% %
-% E d g e I m a g e %
+% D e s p e c k l e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% EdgeImage() finds edges in an image. Radius defines the radius of the
-% convolution filter. Use a radius of 0 and EdgeImage() selects a suitable
-% radius for you.
+% DespeckleImage() reduces the speckle noise in an image while perserving the
+% edges of the original image.
%
-% The format of the EdgeImage method is:
+% The format of the DespeckleImage method is:
%
-% Image *EdgeImage(const Image *image,const double radius,
-% ExceptionInfo *exception)
+% Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
-% o radius: the radius of the pixel neighborhood.
-%
% o exception: return any errors or warnings in this structure.
%
*/
-MagickExport Image *EdgeImage(const Image *image,const double radius,
- ExceptionInfo *exception)
+
+static void Hull(const ssize_t x_offset,const ssize_t y_offset,
+ const size_t columns,const size_t rows,Quantum *f,Quantum *g,
+ const int polarity)
{
- Image
- *edge_image;
+ MagickRealType
+ v;
- double
- *kernel;
+ register Quantum
+ *p,
+ *q,
+ *r,
+ *s;
- register long
- i;
+ register ssize_t
+ x;
- unsigned long
- width;
+ ssize_t
+ y;
- assert(image != (const Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
- width=GetOptimalKernelWidth1D(radius,0.5);
- kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
- if (kernel == (double *) NULL)
- ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- for (i=0; i < (long) (width*width); i++)
- kernel[i]=(-1.0);
- kernel[i/2]=(double) (width*width-1.0);
- edge_image=ConvolveImage(image,width,kernel,exception);
- kernel=(double *) RelinquishMagickMemory(kernel);
- return(edge_image);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% E m b o s s I m a g e %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% EmbossImage() returns a grayscale image with a three-dimensional effect.
-% We convolve the image with a Gaussian operator of the given radius and
-% standard deviation (sigma). For reasonable results, radius should be
-% larger than sigma. Use a radius of 0 and Emboss() selects a suitable
-% radius for you.
-%
-% The format of the EmbossImage method is:
-%
-% Image *EmbossImage(const Image *image,const double radius,
-% const double sigma,ExceptionInfo *exception)
-%
-% A description of each parameter follows:
-%
-% o image: the image.
-%
-% o radius: the radius of the pixel neighborhood.
-%
-% o sigma: the standard deviation of the Gaussian, in pixels.
-%
-% o exception: return any errors or warnings in this structure.
-%
-*/
-MagickExport Image *EmbossImage(const Image *image,const double radius,
- const double sigma,ExceptionInfo *exception)
+ assert(f != (Quantum *) NULL);
+ assert(g != (Quantum *) NULL);
+ p=f+(columns+2);
+ q=g+(columns+2);
+ r=p+(y_offset*((ssize_t) columns+2)+x_offset);
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p++;
+ q++;
+ r++;
+ if (polarity > 0)
+ for (x=(ssize_t) columns; x != 0; x--)
+ {
+ v=(MagickRealType) (*p);
+ if ((MagickRealType) *r >= (v+(MagickRealType) ScaleCharToQuantum(2)))
+ v+=ScaleCharToQuantum(1);
+ *q=(Quantum) v;
+ p++;
+ q++;
+ r++;
+ }
+ else
+ for (x=(ssize_t) columns; x != 0; x--)
+ {
+ v=(MagickRealType) (*p);
+ if ((MagickRealType) *r <= (v-(MagickRealType) ScaleCharToQuantum(2)))
+ v-=(ssize_t) ScaleCharToQuantum(1);
+ *q=(Quantum) v;
+ p++;
+ q++;
+ r++;
+ }
+ p++;
+ q++;
+ r++;
+ }
+ p=f+(columns+2);
+ q=g+(columns+2);
+ r=q+(y_offset*((ssize_t) columns+2)+x_offset);
+ s=q-(y_offset*((ssize_t) columns+2)+x_offset);
+ for (y=0; y < (ssize_t) rows; y++)
+ {
+ p++;
+ q++;
+ r++;
+ s++;
+ if (polarity > 0)
+ for (x=(ssize_t) columns; x != 0; x--)
+ {
+ v=(MagickRealType) (*q);
+ if (((MagickRealType) *s >=
+ (v+(MagickRealType) ScaleCharToQuantum(2))) &&
+ ((MagickRealType) *r > v))
+ v+=ScaleCharToQuantum(1);
+ *p=(Quantum) v;
+ p++;
+ q++;
+ r++;
+ s++;
+ }
+ else
+ for (x=(ssize_t) columns; x != 0; x--)
+ {
+ v=(MagickRealType) (*q);
+ if (((MagickRealType) *s <=
+ (v-(MagickRealType) ScaleCharToQuantum(2))) &&
+ ((MagickRealType) *r < v))
+ v-=(MagickRealType) ScaleCharToQuantum(1);
+ *p=(Quantum) v;
+ p++;
+ q++;
+ r++;
+ s++;
+ }
+ p++;
+ q++;
+ r++;
+ s++;
+ }
+}
+
+MagickExport Image *DespeckleImage(const Image *image,ExceptionInfo *exception)
{
- double
- *kernel;
+#define DespeckleImageTag "Despeckle/Image"
+
+ CacheView
+ *despeckle_view,
+ *image_view;
Image
- *emboss_image;
+ *despeckle_image;
- long
- j;
+ MagickBooleanType
+ status;
- MagickRealType
- alpha;
+ register ssize_t
+ i;
- register long
- i,
- u,
- v;
+ Quantum
+ *restrict buffers,
+ *restrict pixels;
- unsigned long
- width;
+ size_t
+ length,
+ number_channels;
- assert(image != (Image *) NULL);
+ static const ssize_t
+ X[4] = {0, 1, 1,-1},
+ Y[4] = {1, 0, 1, 1};
+
+ /*
+ Allocate despeckled image.
+ */
+ assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- width=GetOptimalKernelWidth2D(radius,sigma);
- kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
- if (kernel == (double *) NULL)
- ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- i=0;
- j=(long) width/2;
- for (v=(-((long) width/2)); v <= (long) (width/2); v++)
+ despeckle_image=CloneImage(image,image->columns,image->rows,MagickTrue,
+ exception);
+ if (despeckle_image == (Image *) NULL)
+ return((Image *) NULL);
+ if (SetImageStorageClass(despeckle_image,DirectClass) == MagickFalse)
+ {
+ InheritException(exception,&despeckle_image->exception);
+ despeckle_image=DestroyImage(despeckle_image);
+ return((Image *) NULL);
+ }
+ /*
+ Allocate image buffers.
+ */
+ length=(size_t) ((image->columns+2)*(image->rows+2));
+ pixels=(Quantum *) AcquireQuantumMemory(length,2*sizeof(*pixels));
+ buffers=(Quantum *) AcquireQuantumMemory(length,2*sizeof(*pixels));
+ if ((pixels == (Quantum *) NULL) || (buffers == (Quantum *) NULL))
+ {
+ if (buffers != (Quantum *) NULL)
+ buffers=(Quantum *) RelinquishMagickMemory(buffers);
+ if (pixels != (Quantum *) NULL)
+ pixels=(Quantum *) RelinquishMagickMemory(pixels);
+ despeckle_image=DestroyImage(despeckle_image);
+ ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ }
+ /*
+ Reduce speckle in the image.
+ */
+ status=MagickTrue;
+ number_channels=(size_t) (image->colorspace == CMYKColorspace ? 5 : 4);
+ image_view=AcquireCacheView(image);
+ despeckle_view=AcquireCacheView(despeckle_image);
+ for (i=0; i < (ssize_t) number_channels; i++)
{
- for (u=(-((long) width/2)); u <= (long) (width/2); u++)
+ register Quantum
+ *buffer,
+ *pixel;
+
+ register ssize_t
+ k,
+ x;
+
+ ssize_t
+ j,
+ y;
+
+ if (status == MagickFalse)
+ continue;
+ pixel=pixels;
+ (void) ResetMagickMemory(pixel,0,length*sizeof(*pixel));
+ buffer=buffers;
+ j=(ssize_t) image->columns+2;
+ for (y=0; y < (ssize_t) image->rows; y++)
{
- alpha=exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma));
- kernel[i]=(double) (((u < 0) || (v < 0) ? -8.0 : 8.0)*alpha/
- (2.0*MagickPI*MagickSigma*MagickSigma));
- if (u != j)
- kernel[i]=0.0;
- i++;
+ register const IndexPacket
+ *restrict indexes;
+
+ register const PixelPacket
+ *restrict p;
+
+ p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
+ if (p == (const PixelPacket *) NULL)
+ break;
+ indexes=GetCacheViewVirtualIndexQueue(image_view);
+ j++;
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ switch (i)
+ {
+ case 0: pixel[j]=GetRedPixelComponent(p); break;
+ case 1: pixel[j]=GetGreenPixelComponent(p); break;
+ case 2: pixel[j]=GetBluePixelComponent(p); break;
+ case 3: pixel[j]=GetOpacityPixelComponent(p); break;
+ case 4: pixel[j]=GetBlackPixelComponent(indexes+x); break;
+ default: break;
+ }
+ p++;
+ j++;
+ }
+ j++;
+ }
+ (void) ResetMagickMemory(buffer,0,length*sizeof(*buffer));
+ for (k=0; k < 4; k++)
+ {
+ Hull(X[k],Y[k],image->columns,image->rows,pixel,buffer,1);
+ Hull(-X[k],-Y[k],image->columns,image->rows,pixel,buffer,1);
+ Hull(-X[k],-Y[k],image->columns,image->rows,pixel,buffer,-1);
+ Hull(X[k],Y[k],image->columns,image->rows,pixel,buffer,-1);
+ }
+ j=(ssize_t) image->columns+2;
+ for (y=0; y < (ssize_t) image->rows; y++)
+ {
+ MagickBooleanType
+ sync;
+
+ register IndexPacket
+ *restrict indexes;
+
+ register PixelPacket
+ *restrict q;
+
+ q=GetCacheViewAuthenticPixels(despeckle_view,0,y,despeckle_image->columns,
+ 1,exception);
+ if (q == (PixelPacket *) NULL)
+ break;
+ indexes=GetCacheViewAuthenticIndexQueue(image_view);
+ j++;
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ switch (i)
+ {
+ case 0: SetRedPixelComponent(q,pixel[j]); break;
+ case 1: SetGreenPixelComponent(q,pixel[j]); break;
+ case 2: SetBluePixelComponent(q,pixel[j]); break;
+ case 3: SetOpacityPixelComponent(q,pixel[j]); break;
+ case 4: SetIndexPixelComponent(indexes+x,pixel[j]); break;
+ default: break;
+ }
+ q++;
+ j++;
+ }
+ sync=SyncCacheViewAuthenticPixels(despeckle_view,exception);
+ if (sync == MagickFalse)
+ {
+ status=MagickFalse;
+ break;
+ }
+ j++;
}
- j--;
+ if (image->progress_monitor != (MagickProgressMonitor) NULL)
+ {
+ MagickBooleanType
+ proceed;
+
+ proceed=SetImageProgress(image,DespeckleImageTag,(MagickOffsetType) i,
+ number_channels);
+ if (proceed == MagickFalse)
+ status=MagickFalse;
+ }
}
- emboss_image=ConvolveImage(image,width,kernel,exception);
- if (emboss_image != (Image *) NULL)
- (void) EqualizeImage(emboss_image);
- kernel=(double *) RelinquishMagickMemory(kernel);
- return(emboss_image);
+ despeckle_view=DestroyCacheView(despeckle_view);
+ image_view=DestroyCacheView(image_view);
+ buffers=(Quantum *) RelinquishMagickMemory(buffers);
+ pixels=(Quantum *) RelinquishMagickMemory(pixels);
+ despeckle_image->type=image->type;
+ if (status == MagickFalse)
+ despeckle_image=DestroyImage(despeckle_image);
+ return(despeckle_image);
}
\f
/*
% %
% %
% %
-% G a u s s i a n B l u r I m a g e %
+% E d g e I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GaussianBlurImage() blurs an image. We convolve the image with a
-% Gaussian operator of the given radius and standard deviation (sigma).
-% For reasonable results, the radius should be larger than sigma. Use a
-% radius of 0 and GaussianBlurImage() selects a suitable radius for you
+% EdgeImage() finds edges in an image. Radius defines the radius of the
+% convolution filter. Use a radius of 0 and EdgeImage() selects a suitable
+% radius for you.
%
-% The format of the GaussianBlurImage method is:
+% The format of the EdgeImage method is:
%
-% Image *GaussianBlurImage(const Image *image,onst double radius,
-% const double sigma,ExceptionInfo *exception)
-% Image *GaussianBlurImageChannel(const Image *image,
-% const ChannelType channel,const double radius,const double sigma,
+% Image *EdgeImage(const Image *image,const double radius,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
-% o channel: the channel type.
-%
-% o radius: the radius of the Gaussian, in pixels, not counting the center
-% pixel.
-%
-% o sigma: the standard deviation of the Gaussian, in pixels.
+% o radius: the radius of the pixel neighborhood.
%
% o exception: return any errors or warnings in this structure.
%
*/
-
-MagickExport Image *GaussianBlurImage(const Image *image,const double radius,
- const double sigma,ExceptionInfo *exception)
+MagickExport Image *EdgeImage(const Image *image,const double radius,
+ ExceptionInfo *exception)
{
Image
- *blur_image;
-
- blur_image=GaussianBlurImageChannel(image,DefaultChannels,radius,sigma,
- exception);
- return(blur_image);
-}
+ *edge_image;
-MagickExport Image *GaussianBlurImageChannel(const Image *image,
- const ChannelType channel,const double radius,const double sigma,
- ExceptionInfo *exception)
-{
double
*kernel;
- Image
- *blur_image;
+ register ssize_t
+ i;
- MagickRealType
- alpha;
+ size_t
+ width;
- register long
- i,
- u,
- v;
+ assert(image != (const Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ width=GetOptimalKernelWidth1D(radius,0.5);
+ kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
+ if (kernel == (double *) NULL)
+ ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ for (i=0; i < (ssize_t) (width*width); i++)
+ kernel[i]=(-1.0);
+ kernel[i/2]=(double) (width*width-1.0);
+ edge_image=ConvolveImage(image,width,kernel,exception);
+ kernel=(double *) RelinquishMagickMemory(kernel);
+ return(edge_image);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% E m b o s s I m a g e %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% EmbossImage() returns a grayscale image with a three-dimensional effect.
+% We convolve the image with a Gaussian operator of the given radius and
+% standard deviation (sigma). For reasonable results, radius should be
+% larger than sigma. Use a radius of 0 and Emboss() selects a suitable
+% radius for you.
+%
+% The format of the EmbossImage method is:
+%
+% Image *EmbossImage(const Image *image,const double radius,
+% const double sigma,ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o radius: the radius of the pixel neighborhood.
+%
+% o sigma: the standard deviation of the Gaussian, in pixels.
+%
+% o exception: return any errors or warnings in this structure.
+%
+*/
+MagickExport Image *EmbossImage(const Image *image,const double radius,
+ const double sigma,ExceptionInfo *exception)
+{
+ double
+ *kernel;
+
+ Image
+ *emboss_image;
+
+ register ssize_t
+ i;
- unsigned long
+ size_t
width;
- assert(image != (const Image *) NULL);
+ ssize_t
+ j,
+ k,
+ u,
+ v;
+
+ assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
if (kernel == (double *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ j=(ssize_t) width/2;
+ k=j;
i=0;
- for (v=(-((long) width/2)); v <= (long) (width/2); v++)
+ for (v=(-j); v <= j; v++)
{
- for (u=(-((long) width/2)); u <= (long) (width/2); u++)
+ for (u=(-j); u <= j; u++)
{
- alpha=exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma));
- kernel[i]=(double) (alpha/(2.0*MagickPI*MagickSigma*MagickSigma));
+ kernel[i]=(double) (((u < 0) || (v < 0) ? -8.0 : 8.0)*
+ exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma))/
+ (2.0*MagickPI*MagickSigma*MagickSigma));
+ if (u != k)
+ kernel[i]=0.0;
i++;
}
+ k--;
}
- blur_image=ConvolveImageChannel(image,channel,width,kernel,exception);
+ emboss_image=ConvolveImage(image,width,kernel,exception);
+ if (emboss_image != (Image *) NULL)
+ (void) EqualizeImage(emboss_image);
kernel=(double *) RelinquishMagickMemory(kernel);
- return(blur_image);
+ return(emboss_image);
}
\f
/*
% %
% %
% %
-% M e d i a n F i l t e r I m a g e %
+% F i l t e r I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MedianFilterImage() applies a digital filter that improves the quality
-% of a noisy image. Each pixel is replaced by the median in a set of
-% neighboring pixels as defined by radius.
+% FilterImage() applies a custom convolution kernel to the image.
%
-% The algorithm was contributed by Mike Edmonds and implements an insertion
-% sort for selecting median color-channel values. For more on this algorithm
-% see "Skip Lists: A probabilistic Alternative to Balanced Trees" by William
-% Pugh in the June 1990 of Communications of the ACM.
+% The format of the FilterImage method is:
%
-% The format of the MedianFilterImage method is:
-%
-% Image *MedianFilterImage(const Image *image,const double radius,
+% Image *FilterImage(const Image *image,const KernelInfo *kernel,
% ExceptionInfo *exception)
+% Image *FilterImageChannel(const Image *image,const ChannelType channel,
+% const KernelInfo *kernel,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
-% o radius: the radius of the pixel neighborhood.
+% o channel: the channel type.
+%
+% o kernel: the filtering kernel.
%
% o exception: return any errors or warnings in this structure.
%
*/
-#define MedianListChannels 5
-
-typedef struct _MedianListNode
+MagickExport Image *FilterImage(const Image *image,const KernelInfo *kernel,
+ ExceptionInfo *exception)
{
- unsigned long
- next[9],
- count,
- signature;
-} MedianListNode;
+ Image
+ *filter_image;
-typedef struct _MedianSkipList
+ filter_image=FilterImageChannel(image,DefaultChannels,kernel,exception);
+ return(filter_image);
+}
+
+MagickExport Image *FilterImageChannel(const Image *image,
+ const ChannelType channel,const KernelInfo *kernel,ExceptionInfo *exception)
{
- long
- level;
+#define FilterImageTag "Filter/Image"
- MedianListNode
- *nodes;
-} MedianSkipList;
+ CacheView
+ *filter_view,
+ *image_view;
-typedef struct _MedianPixelList
-{
- unsigned long
- center,
- seed,
- signature;
+ Image
+ *filter_image;
- MedianSkipList
- lists[MedianListChannels];
-} MedianPixelList;
+ MagickBooleanType
+ status;
-static MedianPixelList *DestroyMedianPixelList(MedianPixelList *pixel_list)
-{
- register long
- i;
+ MagickOffsetType
+ progress;
- if (pixel_list == (MedianPixelList *) NULL)
- return((MedianPixelList *) NULL);
- for (i=0; i < MedianListChannels; i++)
- if (pixel_list->lists[i].nodes != (MedianListNode *) NULL)
- pixel_list->lists[i].nodes=(MedianListNode *) RelinquishMagickMemory(
- pixel_list->lists[i].nodes);
- pixel_list=(MedianPixelList *) RelinquishAlignedMemory(pixel_list);
- return(pixel_list);
-}
+ MagickPixelPacket
+ bias;
-static MedianPixelList **DestroyMedianPixelListThreadSet(
- MedianPixelList **pixel_list)
-{
- register long
- i;
+ ssize_t
+ y;
- assert(pixel_list != (MedianPixelList **) NULL);
- for (i=0; i < (long) GetOpenMPMaximumThreads(); i++)
- if (pixel_list[i] != (MedianPixelList *) NULL)
- pixel_list[i]=DestroyMedianPixelList(pixel_list[i]);
- pixel_list=(MedianPixelList **) RelinquishAlignedMemory(pixel_list);
- return(pixel_list);
-}
+ /*
+ Initialize filter image attributes.
+ */
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ if ((kernel->width % 2) == 0)
+ ThrowImageException(OptionError,"KernelWidthMustBeAnOddNumber");
+ filter_image=CloneImage(image,0,0,MagickTrue,exception);
+ if (filter_image == (Image *) NULL)
+ return((Image *) NULL);
+ if (SetImageStorageClass(filter_image,DirectClass) == MagickFalse)
+ {
+ InheritException(exception,&filter_image->exception);
+ filter_image=DestroyImage(filter_image);
+ return((Image *) NULL);
+ }
+ if (image->debug != MagickFalse)
+ {
+ char
+ format[MaxTextExtent],
+ *message;
-static MedianPixelList *AcquireMedianPixelList(const unsigned long width)
-{
- MedianPixelList
- *pixel_list;
+ register const double
+ *k;
- register long
- i;
+ ssize_t
+ u,
+ v;
- pixel_list=(MedianPixelList *) AcquireAlignedMemory(1,sizeof(*pixel_list));
- if (pixel_list == (MedianPixelList *) NULL)
- return(pixel_list);
- (void) ResetMagickMemory((void *) pixel_list,0,sizeof(*pixel_list));
- pixel_list->center=width*width/2;
- for (i=0; i < MedianListChannels; i++)
+ (void) LogMagickEvent(TransformEvent,GetMagickModule(),
+ " FilterImage with %.20gx%.20g kernel:",(double) kernel->width,(double)
+ kernel->height);
+ message=AcquireString("");
+ k=kernel->values;
+ for (v=0; v < (ssize_t) kernel->height; v++)
+ {
+ *message='\0';
+ (void) FormatMagickString(format,MaxTextExtent,"%.20g: ",(double) v);
+ (void) ConcatenateString(&message,format);
+ for (u=0; u < (ssize_t) kernel->width; u++)
+ {
+ (void) FormatMagickString(format,MaxTextExtent,"%g ",*k++);
+ (void) ConcatenateString(&message,format);
+ }
+ (void) LogMagickEvent(TransformEvent,GetMagickModule(),"%s",message);
+ }
+ message=DestroyString(message);
+ }
+ status=AccelerateConvolveImage(image,kernel,filter_image,exception);
+ if (status == MagickTrue)
+ return(filter_image);
+ /*
+ Filter image.
+ */
+ status=MagickTrue;
+ progress=0;
+ GetMagickPixelPacket(image,&bias);
+ SetMagickPixelPacketBias(image,&bias);
+ image_view=AcquireCacheView(image);
+ filter_view=AcquireCacheView(filter_image);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
+#endif
+ for (y=0; y < (ssize_t) image->rows; y++)
{
- pixel_list->lists[i].nodes=(MedianListNode *) AcquireQuantumMemory(65537UL,
- sizeof(*pixel_list->lists[i].nodes));
- if (pixel_list->lists[i].nodes == (MedianListNode *) NULL)
- return(DestroyMedianPixelList(pixel_list));
- (void) ResetMagickMemory(pixel_list->lists[i].nodes,0,65537UL*
- sizeof(*pixel_list->lists[i].nodes));
- }
- pixel_list->signature=MagickSignature;
- return(pixel_list);
-}
-
-static MedianPixelList **AcquireMedianPixelListThreadSet(
- const unsigned long width)
-{
- register long
- i;
+ MagickBooleanType
+ sync;
- MedianPixelList
- **pixel_list;
+ register const IndexPacket
+ *restrict indexes;
- unsigned long
- number_threads;
+ register const PixelPacket
+ *restrict p;
- number_threads=GetOpenMPMaximumThreads();
- pixel_list=(MedianPixelList **) AcquireAlignedMemory(number_threads,
- sizeof(*pixel_list));
- if (pixel_list == (MedianPixelList **) NULL)
- return((MedianPixelList **) NULL);
- (void) ResetMagickMemory(pixel_list,0,number_threads*sizeof(*pixel_list));
- for (i=0; i < (long) number_threads; i++)
- {
- pixel_list[i]=AcquireMedianPixelList(width);
- if (pixel_list[i] == (MedianPixelList *) NULL)
- return(DestroyMedianPixelListThreadSet(pixel_list));
- }
- return(pixel_list);
-}
+ register IndexPacket
+ *restrict filter_indexes;
-static void AddNodeMedianPixelList(MedianPixelList *pixel_list,
- const long channel,const unsigned long color)
-{
- register long
- level;
+ register PixelPacket
+ *restrict q;
- register MedianSkipList
- *list;
+ register ssize_t
+ x;
- unsigned long
- search,
- update[9];
+ if (status == MagickFalse)
+ continue;
+ p=GetCacheViewVirtualPixels(image_view,-((ssize_t) kernel->width/2L),
+ y-(ssize_t) (kernel->height/2L),image->columns+kernel->width,
+ kernel->height,exception);
+ q=GetCacheViewAuthenticPixels(filter_view,0,y,filter_image->columns,1,
+ exception);
+ if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
+ {
+ status=MagickFalse;
+ continue;
+ }
+ indexes=GetCacheViewVirtualIndexQueue(image_view);
+ filter_indexes=GetCacheViewAuthenticIndexQueue(filter_view);
+ for (x=0; x < (ssize_t) image->columns; x++)
+ {
+ MagickPixelPacket
+ pixel;
- /*
- Initialize the node.
- */
- list=pixel_list->lists+channel;
- list->nodes[color].signature=pixel_list->signature;
- list->nodes[color].count=1;
- /*
- Determine where it belongs in the list.
- */
- search=65536UL;
- for (level=list->level; level >= 0; level--)
- {
- while (list->nodes[search].next[level] < color)
- search=list->nodes[search].next[level];
- update[level]=search;
- }
- /*
- Generate a pseudo-random level for this node.
- */
- for (level=0; ; level++)
- {
- pixel_list->seed=(pixel_list->seed*42893621L)+1L;
- if ((pixel_list->seed & 0x300) != 0x300)
- break;
- }
- if (level > 8)
- level=8;
- if (level > (list->level+2))
- level=list->level+2;
- /*
- If we're raising the list's level, link back to the root node.
- */
- while (level > list->level)
- {
- list->level++;
- update[list->level]=65536UL;
- }
- /*
- Link the node into the skip-list.
- */
- do
- {
- list->nodes[color].next[level]=list->nodes[update[level]].next[level];
- list->nodes[update[level]].next[level]=color;
- }
- while (level-- > 0);
-}
+ register const double
+ *restrict k;
-static MagickPixelPacket GetMedianPixelList(MedianPixelList *pixel_list)
-{
- MagickPixelPacket
- pixel;
+ register const PixelPacket
+ *restrict kernel_pixels;
- register long
- channel;
+ register ssize_t
+ u;
- register MedianSkipList
- *list;
+ ssize_t
+ v;
- unsigned long
- center,
- color,
- count;
-
- unsigned short
- channels[MedianListChannels];
-
- /*
- Find the median value for each of the color.
- */
- center=pixel_list->center;
- for (channel=0; channel < 5; channel++)
- {
- list=pixel_list->lists+channel;
- color=65536UL;
- count=0;
- do
- {
- color=list->nodes[color].next[0];
- count+=list->nodes[color].count;
- }
- while (count <= center);
- channels[channel]=(unsigned short) color;
- }
- GetMagickPixelPacket((const Image *) NULL,&pixel);
- pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
- pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
- pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
- pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
- pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
- return(pixel);
-}
-
-static inline void InsertMedianPixelList(const Image *image,
- const PixelPacket *pixel,const IndexPacket *indexes,
- MedianPixelList *pixel_list)
-{
- unsigned long
- signature;
-
- unsigned short
- index;
-
- index=ScaleQuantumToShort(pixel->red);
- signature=pixel_list->lists[0].nodes[index].signature;
- if (signature == pixel_list->signature)
- pixel_list->lists[0].nodes[index].count++;
- else
- AddNodeMedianPixelList(pixel_list,0,index);
- index=ScaleQuantumToShort(pixel->green);
- signature=pixel_list->lists[1].nodes[index].signature;
- if (signature == pixel_list->signature)
- pixel_list->lists[1].nodes[index].count++;
- else
- AddNodeMedianPixelList(pixel_list,1,index);
- index=ScaleQuantumToShort(pixel->blue);
- signature=pixel_list->lists[2].nodes[index].signature;
- if (signature == pixel_list->signature)
- pixel_list->lists[2].nodes[index].count++;
- else
- AddNodeMedianPixelList(pixel_list,2,index);
- index=ScaleQuantumToShort(pixel->opacity);
- signature=pixel_list->lists[3].nodes[index].signature;
- if (signature == pixel_list->signature)
- pixel_list->lists[3].nodes[index].count++;
- else
- AddNodeMedianPixelList(pixel_list,3,index);
- if (image->colorspace == CMYKColorspace)
- index=ScaleQuantumToShort(*indexes);
- signature=pixel_list->lists[4].nodes[index].signature;
- if (signature == pixel_list->signature)
- pixel_list->lists[4].nodes[index].count++;
- else
- AddNodeMedianPixelList(pixel_list,4,index);
-}
-
-static void ResetMedianPixelList(MedianPixelList *pixel_list)
-{
- int
- level;
-
- register long
- channel;
-
- register MedianListNode
- *root;
-
- register MedianSkipList
- *list;
-
- /*
- Reset the skip-list.
- */
- for (channel=0; channel < 5; channel++)
- {
- list=pixel_list->lists+channel;
- root=list->nodes+65536UL;
- list->level=0;
- for (level=0; level < 9; level++)
- root->next[level]=65536UL;
- }
- pixel_list->seed=pixel_list->signature++;
-}
-
-MagickExport Image *MedianFilterImage(const Image *image,const double radius,
- ExceptionInfo *exception)
-{
-#define MedianFilterImageTag "MedianFilter/Image"
-
- Image
- *median_image;
-
- long
- progress,
- y;
-
- MagickBooleanType
- status;
-
- MedianPixelList
- **pixel_list;
-
- unsigned long
- width;
-
- CacheView
- *image_view,
- *median_view;
-
- /*
- Initialize median image attributes.
- */
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
- width=GetOptimalKernelWidth2D(radius,0.5);
- if ((image->columns < width) || (image->rows < width))
- ThrowImageException(OptionError,"ImageSmallerThanKernelRadius");
- median_image=CloneImage(image,image->columns,image->rows,MagickTrue,
- exception);
- if (median_image == (Image *) NULL)
- return((Image *) NULL);
- if (SetImageStorageClass(median_image,DirectClass) == MagickFalse)
- {
- InheritException(exception,&median_image->exception);
- median_image=DestroyImage(median_image);
- return((Image *) NULL);
- }
- pixel_list=AcquireMedianPixelListThreadSet(width);
- if (pixel_list == (MedianPixelList **) NULL)
- {
- median_image=DestroyImage(median_image);
- ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- }
- /*
- Median filter each image row.
- */
- status=MagickTrue;
- progress=0;
- image_view=AcquireCacheView(image);
- median_view=AcquireCacheView(median_image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
-#endif
- for (y=0; y < (long) median_image->rows; y++)
- {
- register const IndexPacket
- *__restrict indexes;
-
- register const PixelPacket
- *__restrict p;
-
- register IndexPacket
- *__restrict median_indexes;
-
- register long
- id,
- x;
-
- register PixelPacket
- *__restrict q;
-
- if (status == MagickFalse)
- continue;
- p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y-(long) (width/
- 2L),image->columns+width,width,exception);
- q=QueueCacheViewAuthenticPixels(median_view,0,y,median_image->columns,1,
- exception);
- if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
- {
- status=MagickFalse;
- continue;
- }
- indexes=GetCacheViewVirtualIndexQueue(image_view);
- median_indexes=GetCacheViewAuthenticIndexQueue(median_view);
- id=GetOpenMPThreadId();
- for (x=0; x < (long) median_image->columns; x++)
- {
- MagickPixelPacket
- pixel;
-
- register const PixelPacket
- *__restrict r;
+ pixel=bias;
+ k=kernel->values;
+ kernel_pixels=p;
+ if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
+ {
+ for (v=0; v < (ssize_t) kernel->width; v++)
+ {
+ for (u=0; u < (ssize_t) kernel->height; u++)
+ {
+ pixel.red+=(*k)*kernel_pixels[u].red;
+ pixel.green+=(*k)*kernel_pixels[u].green;
+ pixel.blue+=(*k)*kernel_pixels[u].blue;
+ k++;
+ }
+ kernel_pixels+=image->columns+kernel->width;
+ }
+ if ((channel & RedChannel) != 0)
+ SetRedPixelComponent(q,ClampToQuantum(pixel.red));
+ if ((channel & GreenChannel) != 0)
+ SetGreenPixelComponent(q,ClampToQuantum(pixel.green));
+ if ((channel & BlueChannel) != 0)
+ SetBluePixelComponent(q,ClampToQuantum(pixel.blue));
+ if ((channel & OpacityChannel) != 0)
+ {
+ k=kernel->values;
+ kernel_pixels=p;
+ for (v=0; v < (ssize_t) kernel->width; v++)
+ {
+ for (u=0; u < (ssize_t) kernel->height; u++)
+ {
+ pixel.opacity+=(*k)*kernel_pixels[u].opacity;
+ k++;
+ }
+ kernel_pixels+=image->columns+kernel->width;
+ }
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
+ }
+ if (((channel & IndexChannel) != 0) &&
+ (image->colorspace == CMYKColorspace))
+ {
+ register const IndexPacket
+ *restrict kernel_indexes;
- register const IndexPacket
- *__restrict s;
+ k=kernel->values;
+ kernel_indexes=indexes;
+ for (v=0; v < (ssize_t) kernel->width; v++)
+ {
+ for (u=0; u < (ssize_t) kernel->height; u++)
+ {
+ pixel.index+=(*k)*GetIndexPixelComponent(kernel_indexes+u);
+ k++;
+ }
+ kernel_indexes+=image->columns+kernel->width;
+ }
+ SetIndexPixelComponent(filter_indexes+x,ClampToQuantum(
+ pixel.index));
+ }
+ }
+ else
+ {
+ MagickRealType
+ alpha,
+ gamma;
- register long
- u,
- v;
+ gamma=0.0;
+ for (v=0; v < (ssize_t) kernel->width; v++)
+ {
+ for (u=0; u < (ssize_t) kernel->height; u++)
+ {
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-
+ GetOpacityPixelComponent(kernel_pixels+u)));
+ pixel.red+=(*k)*alpha*GetRedPixelComponent(kernel_pixels+u);
+ pixel.green+=(*k)*alpha*GetGreenPixelComponent(kernel_pixels+u);
+ pixel.blue+=(*k)*alpha*GetBluePixelComponent(kernel_pixels+u);
+ gamma+=(*k)*alpha;
+ k++;
+ }
+ kernel_pixels+=image->columns+kernel->width;
+ }
+ gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
+ if ((channel & RedChannel) != 0)
+ SetRedPixelComponent(q,ClampToQuantum(gamma*pixel.red));
+ if ((channel & GreenChannel) != 0)
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*pixel.green));
+ if ((channel & BlueChannel) != 0)
+ SetBluePixelComponent(q,ClampToQuantum(gamma*pixel.blue));
+ if ((channel & OpacityChannel) != 0)
+ {
+ k=kernel->values;
+ kernel_pixels=p;
+ for (v=0; v < (ssize_t) kernel->width; v++)
+ {
+ for (u=0; u < (ssize_t) kernel->height; u++)
+ {
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(kernel_pixels+u);
+ k++;
+ }
+ kernel_pixels+=image->columns+kernel->width;
+ }
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
+ }
+ if (((channel & IndexChannel) != 0) &&
+ (image->colorspace == CMYKColorspace))
+ {
+ register const IndexPacket
+ *restrict kernel_indexes;
- r=p;
- s=indexes+x;
- ResetMedianPixelList(pixel_list[id]);
- for (v=0; v < (long) width; v++)
- {
- for (u=0; u < (long) width; u++)
- InsertMedianPixelList(image,r+u,s+u,pixel_list[id]);
- r+=image->columns+width;
- s+=image->columns+width;
- }
- pixel=GetMedianPixelList(pixel_list[id]);
- SetPixelPacket(median_image,&pixel,q,median_indexes+x);
+ k=kernel->values;
+ kernel_pixels=p;
+ kernel_indexes=indexes;
+ for (v=0; v < (ssize_t) kernel->width; v++)
+ {
+ for (u=0; u < (ssize_t) kernel->height; u++)
+ {
+ alpha=(MagickRealType) (QuantumScale*(QuantumRange-
+ kernel_pixels[u].opacity));
+ pixel.index+=(*k)*alpha*GetIndexPixelComponent(
+ kernel_indexes+u);
+ k++;
+ }
+ kernel_pixels+=image->columns+kernel->width;
+ kernel_indexes+=image->columns+kernel->width;
+ }
+ SetIndexPixelComponent(filter_indexes+x,ClampToQuantum(gamma*
+ pixel.index));
+ }
+ }
+ indexes++;
p++;
q++;
}
- if (SyncCacheViewAuthenticPixels(median_view,exception) == MagickFalse)
+ sync=SyncCacheViewAuthenticPixels(filter_view,exception);
+ if (sync == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_MedianFilterImage)
+ #pragma omp critical (MagickCore_FilterImageChannel)
#endif
- proceed=SetImageProgress(image,MedianFilterImageTag,progress++,
- image->rows);
+ proceed=SetImageProgress(image,FilterImageTag,progress++,image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
- median_view=DestroyCacheView(median_view);
+ filter_image->type=image->type;
+ filter_view=DestroyCacheView(filter_view);
image_view=DestroyCacheView(image_view);
- pixel_list=DestroyMedianPixelListThreadSet(pixel_list);
- return(median_image);
+ if (status == MagickFalse)
+ filter_image=DestroyImage(filter_image);
+ return(filter_image);
}
\f
/*
% %
% %
% %
-% M o t i o n B l u r I m a g e %
+% G a u s s i a n B l u r I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MotionBlurImage() simulates motion blur. We convolve the image with a
+% GaussianBlurImage() blurs an image. We convolve the image with a
% Gaussian operator of the given radius and standard deviation (sigma).
-% For reasonable results, radius should be larger than sigma. Use a
-% radius of 0 and MotionBlurImage() selects a suitable radius for you.
-% Angle gives the angle of the blurring motion.
-%
-% Andrew Protano contributed this effect.
+% For reasonable results, the radius should be larger than sigma. Use a
+% radius of 0 and GaussianBlurImage() selects a suitable radius for you
%
-% The format of the MotionBlurImage method is:
+% The format of the GaussianBlurImage method is:
%
-% Image *MotionBlurImage(const Image *image,const double radius,
-% const double sigma,const double angle,ExceptionInfo *exception)
-% Image *MotionBlurImageChannel(const Image *image,const ChannelType channel,
-% const double radius,const double sigma,const double angle,
-% ExceptionInfo *exception)
+% Image *GaussianBlurImage(const Image *image,onst double radius,
+% const double sigma,ExceptionInfo *exception)
+% Image *GaussianBlurImageChannel(const Image *image,
+% const ChannelType channel,const double radius,const double sigma,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o channel: the channel type.
%
% o radius: the radius of the Gaussian, in pixels, not counting the center
-% o radius: the radius of the Gaussian, in pixels, not counting
-% the center pixel.
+% pixel.
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o angle: Apply the effect along this angle.
-%
% o exception: return any errors or warnings in this structure.
%
*/
-static double *GetMotionBlurKernel(unsigned long width,
- const MagickRealType sigma)
+MagickExport Image *GaussianBlurImage(const Image *image,const double radius,
+ const double sigma,ExceptionInfo *exception)
{
-#define KernelRank 3
+ Image
+ *blur_image;
+ blur_image=GaussianBlurImageChannel(image,DefaultChannels,radius,sigma,
+ exception);
+ return(blur_image);
+}
+
+MagickExport Image *GaussianBlurImageChannel(const Image *image,
+ const ChannelType channel,const double radius,const double sigma,
+ ExceptionInfo *exception)
+{
double
*kernel;
- long
- bias;
+ Image
+ *blur_image;
- MagickRealType
- alpha,
+ register ssize_t
+ i;
+
+ size_t
+ width;
+
+ ssize_t
+ j,
+ u,
+ v;
+
+ assert(image != (const Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ width=GetOptimalKernelWidth2D(radius,sigma);
+ kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
+ if (kernel == (double *) NULL)
+ ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ j=(ssize_t) width/2;
+ i=0;
+ for (v=(-j); v <= j; v++)
+ {
+ for (u=(-j); u <= j; u++)
+ kernel[i++]=(double) (exp(-((double) u*u+v*v)/(2.0*MagickSigma*
+ MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
+ }
+ blur_image=ConvolveImageChannel(image,channel,width,kernel,exception);
+ kernel=(double *) RelinquishMagickMemory(kernel);
+ return(blur_image);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% M o t i o n B l u r I m a g e %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% MotionBlurImage() simulates motion blur. We convolve the image with a
+% Gaussian operator of the given radius and standard deviation (sigma).
+% For reasonable results, radius should be larger than sigma. Use a
+% radius of 0 and MotionBlurImage() selects a suitable radius for you.
+% Angle gives the angle of the blurring motion.
+%
+% Andrew Protano contributed this effect.
+%
+% The format of the MotionBlurImage method is:
+%
+% Image *MotionBlurImage(const Image *image,const double radius,
+% const double sigma,const double angle,ExceptionInfo *exception)
+% Image *MotionBlurImageChannel(const Image *image,const ChannelType channel,
+% const double radius,const double sigma,const double angle,
+% ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o channel: the channel type.
+%
+% o radius: the radius of the Gaussian, in pixels, not counting the center
+% o radius: the radius of the Gaussian, in pixels, not counting
+% the center pixel.
+%
+% o sigma: the standard deviation of the Gaussian, in pixels.
+%
+% o angle: Apply the effect along this angle.
+%
+% o exception: return any errors or warnings in this structure.
+%
+*/
+
+static double *GetMotionBlurKernel(const size_t width,const double sigma)
+{
+ double
+ *kernel,
normalize;
- register long
+ register ssize_t
i;
/*
- Generate a 1-D convolution kernel.
+ Generate a 1-D convolution kernel.
*/
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
kernel=(double *) AcquireQuantumMemory((size_t) width,sizeof(*kernel));
if (kernel == (double *) NULL)
return(kernel);
- (void) ResetMagickMemory(kernel,0,(size_t) width*sizeof(*kernel));
- bias=(long) (KernelRank*width);
- for (i=0; i < (long) bias; i++)
- {
- alpha=exp((-((double) (i*i))/(double) (2.0*KernelRank*KernelRank*
- MagickSigma*MagickSigma)));
- kernel[i/KernelRank]+=(double) alpha/(MagickSQ2PI*sigma);
- }
normalize=0.0;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
+ {
+ kernel[i]=(double) (exp((-((double) i*i)/(double) (2.0*MagickSigma*
+ MagickSigma)))/(MagickSQ2PI*MagickSigma));
normalize+=kernel[i];
- for (i=0; i < (long) width; i++)
+ }
+ for (i=0; i < (ssize_t) width; i++)
kernel[i]/=normalize;
return(kernel);
}
const ChannelType channel,const double radius,const double sigma,
const double angle,ExceptionInfo *exception)
{
- typedef struct _OffsetInfo
- {
- long
- x,
- y;
- } OffsetInfo;
+ CacheView
+ *blur_view,
+ *image_view;
double
*kernel;
Image
*blur_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
MagickPixelPacket
- zero;
+ bias;
OffsetInfo
*offset;
PointInfo
point;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
width;
- CacheView
- *blur_view,
- *image_view;
+ ssize_t
+ y;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
}
point.x=(double) width*sin(DegreesToRadians(angle));
point.y=(double) width*cos(DegreesToRadians(angle));
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
- offset[i].x=(long) ((i*point.y)/hypot(point.x,point.y)+0.5);
- offset[i].y=(long) ((i*point.x)/hypot(point.x,point.y)+0.5);
+ offset[i].x=(ssize_t) ceil((double) (i*point.y)/hypot(point.x,point.y)-0.5);
+ offset[i].y=(ssize_t) ceil((double) (i*point.x)/hypot(point.x,point.y)-0.5);
}
/*
Motion blur image.
*/
status=MagickTrue;
progress=0;
- GetMagickPixelPacket(image,&zero);
+ GetMagickPixelPacket(image,&bias);
image_view=AcquireCacheView(image);
blur_view=AcquireCacheView(blur_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
#endif
- for (y=0; y < (long) image->rows; y++)
+ for (y=0; y < (ssize_t) image->rows; y++)
{
register IndexPacket
- *__restrict blur_indexes;
-
- register long
- x;
+ *restrict blur_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
continue;
}
blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
MagickPixelPacket
qixel;
PixelPacket
pixel;
+ register const IndexPacket
+ *restrict indexes;
+
register double
- *__restrict k;
+ *restrict k;
- register long
+ register ssize_t
i;
- register const IndexPacket
- *__restrict indexes;
-
k=kernel;
- qixel=zero;
+ qixel=bias;
if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
{
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
(void) GetOneCacheViewVirtualPixel(image_view,x+offset[i].x,y+
offset[i].y,&pixel,exception);
k++;
}
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(qixel.red);
+ SetRedPixelComponent(q,ClampToQuantum(qixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(qixel.green);
+ SetGreenPixelComponent(q,ClampToQuantum(qixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(qixel.blue);
+ SetBluePixelComponent(q,ClampToQuantum(qixel.blue));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(qixel.opacity);
+ SetOpacityPixelComponent(q,ClampToQuantum(qixel.opacity));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=(IndexPacket) RoundToQuantum(qixel.index);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(qixel.index));
}
else
{
alpha=0.0;
gamma=0.0;
- for (i=0; i < (long) width; i++)
+ for (i=0; i < (ssize_t) width; i++)
{
(void) GetOneCacheViewVirtualPixel(image_view,x+offset[i].x,y+
offset[i].y,&pixel,exception);
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-pixel.opacity));
+ alpha=(MagickRealType) (QuantumScale*
+ GetAlphaPixelComponent(&pixel));
qixel.red+=(*k)*alpha*pixel.red;
qixel.green+=(*k)*alpha*pixel.green;
qixel.blue+=(*k)*alpha*pixel.blue;
if (image->colorspace == CMYKColorspace)
{
indexes=GetCacheViewVirtualIndexQueue(image_view);
- qixel.index+=(*k)*alpha*(*indexes);
+ qixel.index+=(*k)*alpha*GetIndexPixelComponent(indexes);
}
gamma+=(*k)*alpha;
k++;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*qixel.red);
+ SetRedPixelComponent(q,ClampToQuantum(gamma*qixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*qixel.green);
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*qixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*qixel.blue);
+ SetBluePixelComponent(q,ClampToQuantum(gamma*qixel.blue));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(qixel.opacity);
+ SetOpacityPixelComponent(q,ClampToQuantum(qixel.opacity));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=(IndexPacket) RoundToQuantum(gamma*qixel.index);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(gamma*
+ qixel.index));
}
q++;
}
ImageInfo
*preview_info;
- long
- y;
-
MagickBooleanType
proceed;
RectangleInfo
geometry;
- register long
+ register ssize_t
i,
x;
- unsigned long
+ size_t
colors;
+ ssize_t
+ y;
+
/*
Open output image file.
*/
}
case RollPreview:
{
- x=(long) ((i+1)*thumbnail->columns)/NumberTiles;
- y=(long) ((i+1)*thumbnail->rows)/NumberTiles;
+ x=(ssize_t) ((i+1)*thumbnail->columns)/NumberTiles;
+ y=(ssize_t) ((i+1)*thumbnail->rows)/NumberTiles;
preview_image=RollImage(thumbnail,x,y,exception);
- (void) FormatMagickString(label,MaxTextExtent,"roll %ldx%ld",x,y);
+ (void) FormatMagickString(label,MaxTextExtent,"roll %+.20gx%+.20g",
+ (double) x,(double) y);
break;
}
case HuePreview:
preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
if (preview_image == (Image *) NULL)
break;
- (void) FormatMagickString(factor,MaxTextExtent,"100,%g",2.0*percentage);
+ (void) FormatMagickString(factor,MaxTextExtent,"100,%g",
+ 2.0*percentage);
(void) ModulateImage(preview_image,factor);
(void) FormatMagickString(label,MaxTextExtent,"modulate %s",factor);
break;
if (preview_image != (Image *) NULL)
for (x=0; x < i; x++)
(void) ContrastImage(preview_image,MagickTrue);
- (void) FormatMagickString(label,MaxTextExtent,"contrast (%ld)",i+1);
+ (void) FormatMagickString(label,MaxTextExtent,"contrast (%.20g)",
+ (double) i+1);
break;
}
case DullPreview:
break;
for (x=0; x < i; x++)
(void) ContrastImage(preview_image,MagickFalse);
- (void) FormatMagickString(label,MaxTextExtent,"+contrast (%ld)",i+1);
+ (void) FormatMagickString(label,MaxTextExtent,"+contrast (%.20g)",
+ (double) i+1);
break;
}
case GrayscalePreview:
quantize_info.colorspace=GRAYColorspace;
(void) QuantizeImage(&quantize_info,preview_image);
(void) FormatMagickString(label,MaxTextExtent,
- "-colorspace gray -colors %ld",colors);
+ "-colorspace gray -colors %.20g",(double) colors);
break;
}
case QuantizePreview:
colors<<=1;
quantize_info.number_colors=colors;
(void) QuantizeImage(&quantize_info,preview_image);
- (void) FormatMagickString(label,MaxTextExtent,"colors %ld",colors);
+ (void) FormatMagickString(label,MaxTextExtent,"colors %.20g",(double)
+ colors);
break;
}
case DespecklePreview:
preview_image=DespeckleImage(thumbnail,exception);
if (preview_image == (Image *) NULL)
break;
- (void) FormatMagickString(label,MaxTextExtent,"despeckle (%ld)",i+1);
+ (void) FormatMagickString(label,MaxTextExtent,"despeckle (%.20g)",
+ (double) i+1);
break;
}
case ReduceNoisePreview:
{
- preview_image=ReduceNoiseImage(thumbnail,radius,exception);
+ preview_image=StatisticImage(thumbnail,NonpeakStatistic,(size_t) radius,
+ (size_t) radius,exception);
(void) FormatMagickString(label,MaxTextExtent,"noise %g",radius);
break;
}
break;
}
}
- preview_image=ReduceNoiseImage(thumbnail,(double) i,exception);
+ preview_image=StatisticImage(thumbnail,NonpeakStatistic,(size_t) i,
+ (size_t) i,exception);
(void) FormatMagickString(label,MaxTextExtent,"+noise %s",factor);
break;
}
case SharpenPreview:
{
preview_image=SharpenImage(thumbnail,radius,sigma,exception);
- (void) FormatMagickString(label,MaxTextExtent,"sharpen %gx%g",radius,
- sigma);
+ (void) FormatMagickString(label,MaxTextExtent,"sharpen %gx%g",
+ radius,sigma);
break;
}
case BlurPreview:
case SpreadPreview:
{
preview_image=SpreadImage(thumbnail,radius,exception);
- (void) FormatMagickString(label,MaxTextExtent,"spread %g",radius+0.5);
+ (void) FormatMagickString(label,MaxTextExtent,"spread %g",
+ radius+0.5);
break;
}
case SolarizePreview:
degrees+=10.0;
preview_image=ShadeImage(thumbnail,MagickTrue,degrees,degrees,
exception);
- (void) FormatMagickString(label,MaxTextExtent,"shade %gx%g",degrees,
- degrees);
+ (void) FormatMagickString(label,MaxTextExtent,"shade %gx%g",
+ degrees,degrees);
break;
}
case RaisePreview:
preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
if (preview_image == (Image *) NULL)
break;
- geometry.width=(unsigned long) (2*i+2);
- geometry.height=(unsigned long) (2*i+2);
+ geometry.width=(size_t) (2*i+2);
+ geometry.height=(size_t) (2*i+2);
geometry.x=i/2;
geometry.y=i/2;
(void) RaiseImage(preview_image,&geometry,MagickTrue);
- (void) FormatMagickString(label,MaxTextExtent,"raise %lux%lu%+ld%+ld",
- geometry.width,geometry.height,geometry.x,geometry.y);
+ (void) FormatMagickString(label,MaxTextExtent,
+ "raise %.20gx%.20g%+.20g%+.20g",(double) geometry.width,(double)
+ geometry.height,(double) geometry.x,(double) geometry.y);
break;
}
case SegmentPreview:
{
degrees+=5.0f;
preview_image=WaveImage(thumbnail,0.5*degrees,2.0*degrees,exception);
- (void) FormatMagickString(label,MaxTextExtent,"wave %gx%g",0.5*degrees,
- 2.0*degrees);
+ (void) FormatMagickString(label,MaxTextExtent,"wave %gx%g",
+ 0.5*degrees,2.0*degrees);
break;
}
case OilPaintPreview:
{
preview_image=CharcoalImage(thumbnail,(double) radius,(double) sigma,
exception);
- (void) FormatMagickString(label,MaxTextExtent,"charcoal %gx%g",radius,
- sigma);
+ (void) FormatMagickString(label,MaxTextExtent,"charcoal %gx%g",
+ radius,sigma);
break;
}
case JPEGPreview:
preview_image=CloneImage(thumbnail,0,0,MagickTrue,exception);
if (preview_image == (Image *) NULL)
break;
- preview_info->quality=(unsigned long) percentage;
- (void) FormatMagickString(factor,MaxTextExtent,"%lu",
+ preview_info->quality=(size_t) percentage;
+ (void) FormatMagickString(factor,MaxTextExtent,"%.20g",(double)
preview_info->quality);
file=AcquireUniqueFileResource(filename);
if (file != -1)
1024.0/1024.0);
else
if (GetBlobSize(preview_image) >= 1024)
- (void) FormatMagickString(label,MaxTextExtent,"quality %s\n%gkb ",
- factor,(double) ((MagickOffsetType) GetBlobSize(preview_image))/
- 1024.0);
+ (void) FormatMagickString(label,MaxTextExtent,
+ "quality %s\n%gkb ",factor,(double) ((MagickOffsetType)
+ GetBlobSize(preview_image))/1024.0);
else
- (void) FormatMagickString(label,MaxTextExtent,"quality %s\n%lub ",
- factor,(unsigned long) GetBlobSize(thumbnail));
+ (void) FormatMagickString(label,MaxTextExtent,"quality %s\n%.20gb ",
+ factor,(double) GetBlobSize(thumbnail));
break;
}
}
(void) DeleteImageProperty(preview_image,"label");
(void) SetImageProperty(preview_image,"label",label);
AppendImageToList(&images,preview_image);
- proceed=SetImageProgress(image,PreviewImageTag,i,NumberTiles);
+ proceed=SetImageProgress(image,PreviewImageTag,(MagickOffsetType) i,
+ NumberTiles);
if (proceed == MagickFalse)
break;
}
MagickExport Image *RadialBlurImageChannel(const Image *image,
const ChannelType channel,const double angle,ExceptionInfo *exception)
{
+ CacheView
+ *blur_view,
+ *image_view;
+
Image
*blur_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
MagickPixelPacket
- zero;
+ bias;
MagickRealType
blur_radius,
PointInfo
blur_center;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
n;
- CacheView
- *blur_view,
- *image_view;
+ ssize_t
+ y;
/*
Allocate blur image.
blur_center.x=(double) image->columns/2.0;
blur_center.y=(double) image->rows/2.0;
blur_radius=hypot(blur_center.x,blur_center.y);
- n=(unsigned long) fabs(4.0*DegreesToRadians(angle)*sqrt((double) blur_radius)+
- 2UL);
+ n=(size_t) fabs(4.0*DegreesToRadians(angle)*sqrt((double) blur_radius)+2UL);
theta=DegreesToRadians(angle)/(MagickRealType) (n-1);
cos_theta=(MagickRealType *) AcquireQuantumMemory((size_t) n,
sizeof(*cos_theta));
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
}
offset=theta*(MagickRealType) (n-1)/2.0;
- for (i=0; i < (long) n; i++)
+ for (i=0; i < (ssize_t) n; i++)
{
cos_theta[i]=cos((double) (theta*i-offset));
sin_theta[i]=sin((double) (theta*i-offset));
*/
status=MagickTrue;
progress=0;
- GetMagickPixelPacket(image,&zero);
+ GetMagickPixelPacket(image,&bias);
image_view=AcquireCacheView(image);
blur_view=AcquireCacheView(blur_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) blur_image->rows; y++)
+ for (y=0; y < (ssize_t) blur_image->rows; y++)
{
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register IndexPacket
- *__restrict blur_indexes;
-
- register long
- x;
+ *restrict blur_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
continue;
}
blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
- for (x=0; x < (long) blur_image->columns; x++)
+ for (x=0; x < (ssize_t) blur_image->columns; x++)
{
MagickPixelPacket
qixel;
PointInfo
center;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
step;
center.x=(double) x-blur_center.x;
step=1;
else
{
- step=(unsigned long) (blur_radius/radius);
+ step=(size_t) (blur_radius/radius);
if (step == 0)
step=1;
else
step=n-1;
}
normalize=0.0;
- qixel=zero;
+ qixel=bias;
if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
{
- for (i=0; i < (long) n; i+=step)
+ for (i=0; i < (ssize_t) n; i+=(ssize_t) step)
{
- (void) GetOneCacheViewVirtualPixel(image_view,(long) (blur_center.x+
- center.x*cos_theta[i]-center.y*sin_theta[i]+0.5),(long) (
- blur_center.y+center.x*sin_theta[i]+center.y*cos_theta[i]+0.5),
- &pixel,exception);
+ (void) GetOneCacheViewVirtualPixel(image_view,(ssize_t)
+ (blur_center.x+center.x*cos_theta[i]-center.y*sin_theta[i]+0.5),
+ (ssize_t) (blur_center.y+center.x*sin_theta[i]+center.y*
+ cos_theta[i]+0.5),&pixel,exception);
qixel.red+=pixel.red;
qixel.green+=pixel.green;
qixel.blue+=pixel.blue;
normalize=1.0/(fabs((double) normalize) <= MagickEpsilon ? 1.0 :
normalize);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(normalize*qixel.red);
+ SetRedPixelComponent(q,ClampToQuantum(normalize*qixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(normalize*qixel.green);
+ SetGreenPixelComponent(q,ClampToQuantum(normalize*qixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(normalize*qixel.blue);
+ SetBluePixelComponent(q,ClampToQuantum(normalize*qixel.blue));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(normalize*qixel.opacity);
+ SetOpacityPixelComponent(q,ClampToQuantum(normalize*qixel.opacity));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=(IndexPacket) RoundToQuantum(normalize*qixel.index);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(normalize*
+ qixel.index));
}
else
{
alpha=1.0;
gamma=0.0;
- for (i=0; i < (long) n; i+=step)
+ for (i=0; i < (ssize_t) n; i+=(ssize_t) step)
{
- (void) GetOneCacheViewVirtualPixel(image_view,(long) (blur_center.x+
- center.x*cos_theta[i]-center.y*sin_theta[i]+0.5),(long) (
- blur_center.y+center.x*sin_theta[i]+center.y*cos_theta[i]+0.5),
- &pixel,exception);
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-pixel.opacity));
+ (void) GetOneCacheViewVirtualPixel(image_view,(ssize_t)
+ (blur_center.x+center.x*cos_theta[i]-center.y*sin_theta[i]+0.5),
+ (ssize_t) (blur_center.y+center.x*sin_theta[i]+center.y*
+ cos_theta[i]+0.5),&pixel,exception);
+ alpha=(MagickRealType) (QuantumScale*
+ GetAlphaPixelComponent(&pixel));
qixel.red+=alpha*pixel.red;
qixel.green+=alpha*pixel.green;
qixel.blue+=alpha*pixel.blue;
normalize=1.0/(fabs((double) normalize) <= MagickEpsilon ? 1.0 :
normalize);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*qixel.red);
+ SetRedPixelComponent(q,ClampToQuantum(gamma*qixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*qixel.green);
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*qixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*qixel.blue);
+ SetBluePixelComponent(q,ClampToQuantum(gamma*qixel.blue));
if ((channel & OpacityChannel) != 0)
- q->opacity=RoundToQuantum(normalize*qixel.opacity);
+ SetOpacityPixelComponent(q,ClampToQuantum(normalize*qixel.opacity));
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
- blur_indexes[x]=(IndexPacket) RoundToQuantum(gamma*qixel.index);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(gamma*
+ qixel.index));
}
q++;
}
% %
% %
% %
-% R e d u c e N o i s e I m a g e %
+% S e l e c t i v e B l u r I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% ReduceNoiseImage() smooths the contours of an image while still preserving
-% edge information. The algorithm works by replacing each pixel with its
-% neighbor closest in value. A neighbor is defined by radius. Use a radius
-% of 0 and ReduceNoise() selects a suitable radius for you.
+% SelectiveBlurImage() selectively blur pixels within a contrast threshold.
+% It is similar to the unsharpen mask that sharpens everything with contrast
+% above a certain threshold.
%
-% The format of the ReduceNoiseImage method is:
+% The format of the SelectiveBlurImage method is:
%
-% Image *ReduceNoiseImage(const Image *image,const double radius,
-% ExceptionInfo *exception)
+% Image *SelectiveBlurImage(const Image *image,const double radius,
+% const double sigma,const double threshold,ExceptionInfo *exception)
+% Image *SelectiveBlurImageChannel(const Image *image,
+% const ChannelType channel,const double radius,const double sigma,
+% const double threshold,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o image: the image.
%
-% o radius: the radius of the pixel neighborhood.
+% o channel: the channel type.
+%
+% o radius: the radius of the Gaussian, in pixels, not counting the center
+% pixel.
+%
+% o sigma: the standard deviation of the Gaussian, in pixels.
+%
+% o threshold: only pixels within this contrast threshold are included
+% in the blur operation.
%
% o exception: return any errors or warnings in this structure.
%
*/
-static MagickPixelPacket GetNonpeakMedianPixelList(MedianPixelList *pixel_list)
+static inline MagickBooleanType SelectiveContrast(const PixelPacket *p,
+ const PixelPacket *q,const double threshold)
{
- MagickPixelPacket
- pixel;
-
- register long
- channel;
-
- register MedianSkipList
- *list;
-
- unsigned long
- center,
- color,
- count,
- previous,
- next;
+ if (fabs(PixelIntensity(p)-PixelIntensity(q)) < threshold)
+ return(MagickTrue);
+ return(MagickFalse);
+}
- unsigned short
- channels[5];
+MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
+ const double sigma,const double threshold,ExceptionInfo *exception)
+{
+ Image
+ *blur_image;
- /*
- Finds the median value for each of the color.
- */
- center=pixel_list->center;
- for (channel=0; channel < 5; channel++)
- {
- list=pixel_list->lists+channel;
- color=65536UL;
- next=list->nodes[color].next[0];
- count=0;
- do
- {
- previous=color;
- color=next;
- next=list->nodes[color].next[0];
- count+=list->nodes[color].count;
- }
- while (count <= center);
- if ((previous == 65536UL) && (next != 65536UL))
- color=next;
- else
- if ((previous != 65536UL) && (next == 65536UL))
- color=previous;
- channels[channel]=(unsigned short) color;
- }
- GetMagickPixelPacket((const Image *) NULL,&pixel);
- pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
- pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
- pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
- pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
- pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
- return(pixel);
+ blur_image=SelectiveBlurImageChannel(image,DefaultChannels,radius,sigma,
+ threshold,exception);
+ return(blur_image);
}
-MagickExport Image *ReduceNoiseImage(const Image *image,const double radius,
- ExceptionInfo *exception)
+MagickExport Image *SelectiveBlurImageChannel(const Image *image,
+ const ChannelType channel,const double radius,const double sigma,
+ const double threshold,ExceptionInfo *exception)
{
-#define ReduceNoiseImageTag "ReduceNoise/Image"
+#define SelectiveBlurImageTag "SelectiveBlur/Image"
- Image
- *noise_image;
+ CacheView
+ *blur_view,
+ *image_view;
- long
- progress,
- y;
+ double
+ *kernel;
+
+ Image
+ *blur_image;
MagickBooleanType
status;
- MedianPixelList
- **pixel_list;
+ MagickOffsetType
+ progress;
- unsigned long
+ MagickPixelPacket
+ bias;
+
+ register ssize_t
+ i;
+
+ size_t
width;
- CacheView
- *image_view,
- *noise_view;
+ ssize_t
+ j,
+ u,
+ v,
+ y;
/*
- Initialize noise image attributes.
+ Initialize blur image attributes.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- width=GetOptimalKernelWidth2D(radius,0.5);
- if ((image->columns < width) || (image->rows < width))
- ThrowImageException(OptionError,"ImageSmallerThanKernelRadius");
- noise_image=CloneImage(image,image->columns,image->rows,MagickTrue,
- exception);
- if (noise_image == (Image *) NULL)
- return((Image *) NULL);
- if (SetImageStorageClass(noise_image,DirectClass) == MagickFalse)
- {
- InheritException(exception,&noise_image->exception);
- noise_image=DestroyImage(noise_image);
- return((Image *) NULL);
- }
- pixel_list=AcquireMedianPixelListThreadSet(width);
- if (pixel_list == (MedianPixelList **) NULL)
- {
- noise_image=DestroyImage(noise_image);
- ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- }
- /*
- Reduce noise image.
- */
- status=MagickTrue;
- progress=0;
- image_view=AcquireCacheView(image);
- noise_view=AcquireCacheView(noise_image);
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
-#endif
- for (y=0; y < (long) noise_image->rows; y++)
- {
- register const IndexPacket
- *__restrict indexes;
-
- register const PixelPacket
- *__restrict p;
-
- register IndexPacket
- *__restrict noise_indexes;
-
- register long
- id,
- x;
-
- register PixelPacket
- *__restrict q;
-
- if (status == MagickFalse)
- continue;
- p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y-(long) (width/
- 2L),image->columns+width,width,exception);
- q=QueueCacheViewAuthenticPixels(noise_view,0,y,noise_image->columns,1,
- exception);
- if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
- {
- status=MagickFalse;
- continue;
- }
- indexes=GetCacheViewVirtualIndexQueue(image_view);
- noise_indexes=GetCacheViewAuthenticIndexQueue(noise_view);
- id=GetOpenMPThreadId();
- for (x=0; x < (long) noise_image->columns; x++)
- {
- MagickPixelPacket
- pixel;
-
- register const PixelPacket
- *__restrict r;
-
- register const IndexPacket
- *__restrict s;
-
- register long
- u,
- v;
-
- r=p;
- s=indexes+x;
- ResetMedianPixelList(pixel_list[id]);
- for (v=0; v < (long) width; v++)
- {
- for (u=0; u < (long) width; u++)
- InsertMedianPixelList(image,r+u,s+u,pixel_list[id]);
- r+=image->columns+width;
- s+=image->columns+width;
- }
- pixel=GetNonpeakMedianPixelList(pixel_list[id]);
- SetPixelPacket(noise_image,&pixel,q,noise_indexes+x);
- p++;
- q++;
- }
- if (SyncCacheViewAuthenticPixels(noise_view,exception) == MagickFalse)
- status=MagickFalse;
- if (image->progress_monitor != (MagickProgressMonitor) NULL)
- {
- MagickBooleanType
- proceed;
-
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_ReduceNoiseImage)
-#endif
- proceed=SetImageProgress(image,ReduceNoiseImageTag,progress++,
- image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- }
- noise_view=DestroyCacheView(noise_view);
- image_view=DestroyCacheView(image_view);
- pixel_list=DestroyMedianPixelListThreadSet(pixel_list);
- return(noise_image);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% S e l e c t i v e B l u r I m a g e %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% SelectiveBlurImage() selectively blur pixels within a contrast threshold.
-% It is similar to the unsharpen mask that sharpens everything with contrast
-% above a certain threshold.
-%
-% The format of the SelectiveBlurImage method is:
-%
-% Image *SelectiveBlurImage(const Image *image,const double radius,
-% const double sigma,const double threshold,ExceptionInfo *exception)
-% Image *SelectiveBlurImageChannel(const Image *image,
-% const ChannelType channel,const double radius,const double sigma,
-% const double threshold,ExceptionInfo *exception)
-%
-% A description of each parameter follows:
-%
-% o image: the image.
-%
-% o channel: the channel type.
-%
-% o radius: the radius of the Gaussian, in pixels, not counting the center
-% pixel.
-%
-% o sigma: the standard deviation of the Gaussian, in pixels.
-%
-% o threshold: only pixels within this contrast threshold are included
-% in the blur operation.
-%
-% o exception: return any errors or warnings in this structure.
-%
-*/
-
-static inline MagickBooleanType SelectiveContrast(const PixelPacket *p,
- const PixelPacket *q,const double threshold)
-{
- if (fabs(PixelIntensity(p)-PixelIntensity(q)) < threshold)
- return(MagickTrue);
- return(MagickFalse);
-}
-
-MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
- const double sigma,const double threshold,ExceptionInfo *exception)
-{
- Image
- *blur_image;
-
- blur_image=SelectiveBlurImageChannel(image,DefaultChannels,radius,sigma,
- threshold,exception);
- return(blur_image);
-}
-
-MagickExport Image *SelectiveBlurImageChannel(const Image *image,
- const ChannelType channel,const double radius,const double sigma,
- const double threshold,ExceptionInfo *exception)
-{
-#define SelectiveBlurImageTag "SelectiveBlur/Image"
-
- double
- alpha,
- *kernel;
-
- Image
- *blur_image;
-
- long
- progress,
- v,
- y;
-
- MagickBooleanType
- status;
-
- MagickPixelPacket
- zero;
-
- MagickRealType
- bias;
-
- register long
- i,
- u;
-
- unsigned long
- width;
-
- CacheView
- *blur_view,
- *image_view;
-
- /*
- Initialize blur image attributes.
- */
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
- width=GetOptimalKernelWidth1D(radius,sigma);
- kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
- if (kernel == (double *) NULL)
- ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- i=0;
- for (v=(-((long) width/2)); v <= (long) (width/2); v++)
- {
- for (u=(-((long) width/2)); u <= (long) (width/2); u++)
- {
- alpha=exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma));
- kernel[i]=(double) (alpha/(2.0*MagickPI*MagickSigma*MagickSigma));
- i++;
- }
- }
- if (image->debug != MagickFalse)
+ width=GetOptimalKernelWidth1D(radius,sigma);
+ kernel=(double *) AcquireQuantumMemory((size_t) width,width*sizeof(*kernel));
+ if (kernel == (double *) NULL)
+ ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ j=(ssize_t) width/2;
+ i=0;
+ for (v=(-j); v <= j; v++)
+ {
+ for (u=(-j); u <= j; u++)
+ kernel[i++]=(double) (exp(-((double) u*u+v*v)/(2.0*MagickSigma*
+ MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
+ }
+ if (image->debug != MagickFalse)
{
char
format[MaxTextExtent],
*message;
- long
- u,
- v;
-
register const double
*k;
+ ssize_t
+ u,
+ v;
+
(void) LogMagickEvent(TransformEvent,GetMagickModule(),
- " SelectiveBlurImage with %ldx%ld kernel:",width,width);
+ " SelectiveBlurImage with %.20gx%.20g kernel:",(double) width,(double)
+ width);
message=AcquireString("");
k=kernel;
- for (v=0; v < (long) width; v++)
+ for (v=0; v < (ssize_t) width; v++)
{
*message='\0';
- (void) FormatMagickString(format,MaxTextExtent,"%ld: ",v);
+ (void) FormatMagickString(format,MaxTextExtent,"%.20g: ",(double) v);
(void) ConcatenateString(&message,format);
- for (u=0; u < (long) width; u++)
+ for (u=0; u < (ssize_t) width; u++)
{
(void) FormatMagickString(format,MaxTextExtent,"%+f ",*k++);
(void) ConcatenateString(&message,format);
*/
status=MagickTrue;
progress=0;
- GetMagickPixelPacket(image,&zero);
- bias=image->bias;
+ GetMagickPixelPacket(image,&bias);
+ SetMagickPixelPacketBias(image,&bias);
image_view=AcquireCacheView(image);
blur_view=AcquireCacheView(blur_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #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++)
{
MagickBooleanType
sync;
gamma;
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict blur_indexes;
-
- register long
- x;
+ *restrict blur_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
- p=GetCacheViewVirtualPixels(image_view,-((long) width/2L),y-(long) (width/
- 2L),image->columns+width,width,exception);
+ p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t)
+ (width/2L),image->columns+width,width,exception);
q=GetCacheViewAuthenticPixels(blur_view,0,y,blur_image->columns,1,
exception);
if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
blur_indexes=GetCacheViewAuthenticIndexQueue(blur_view);
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- long
- j,
- v;
-
MagickPixelPacket
pixel;
register const double
- *__restrict k;
+ *restrict k;
- register long
+ register ssize_t
u;
- pixel=zero;
+ ssize_t
+ j,
+ v;
+
+ pixel=bias;
k=kernel;
gamma=0.0;
j=0;
if (((channel & OpacityChannel) == 0) || (image->matte == MagickFalse))
{
- for (v=0; v < (long) width; v++)
+ for (v=0; v < (ssize_t) width; v++)
{
- for (u=0; u < (long) width; u++)
+ for (u=0; u < (ssize_t) width; u++)
{
if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
{
- pixel.red+=(*k)*(p+u+j)->red;
- pixel.green+=(*k)*(p+u+j)->green;
- pixel.blue+=(*k)*(p+u+j)->blue;
+ pixel.red+=(*k)*GetRedPixelComponent(p+u+j);
+ pixel.green+=(*k)*GetGreenPixelComponent(p+u+j);
+ pixel.blue+=(*k)*GetBluePixelComponent(p+u+j);
gamma+=(*k);
k++;
}
}
- j+=image->columns+width;
+ j+=(ssize_t) (image->columns+width);
}
if (gamma != 0.0)
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*pixel.red+bias);
+ SetRedPixelComponent(q,ClampToQuantum(gamma*pixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*pixel.green+bias);
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*pixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*pixel.blue+bias);
+ SetBluePixelComponent(q,ClampToQuantum(gamma*pixel.blue));
}
if ((channel & OpacityChannel) != 0)
{
gamma=0.0;
j=0;
- for (v=0; v < (long) width; v++)
+ for (v=0; v < (ssize_t) width; v++)
{
- for (u=0; u < (long) width; u++)
+ for (u=0; u < (ssize_t) width; u++)
{
if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
{
k++;
}
}
- j+=image->columns+width;
+ j+=(ssize_t) (image->columns+width);
}
if (gamma != 0.0)
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 :
gamma);
- q->opacity=RoundToQuantum(gamma*pixel.opacity+bias);
+ SetOpacityPixelComponent(q,ClampToQuantum(gamma*
+ pixel.opacity));
}
}
if (((channel & IndexChannel) != 0) &&
{
gamma=0.0;
j=0;
- for (v=0; v < (long) width; v++)
+ for (v=0; v < (ssize_t) width; v++)
{
- for (u=0; u < (long) width; u++)
+ for (u=0; u < (ssize_t) width; u++)
{
if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
{
- pixel.index+=(*k)*indexes[x+u+j];
+ pixel.index+=(*k)*GetIndexPixelComponent(indexes+x+u+j);
gamma+=(*k);
k++;
}
}
- j+=image->columns+width;
+ j+=(ssize_t) (image->columns+width);
}
if (gamma != 0.0)
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 :
gamma);
- blur_indexes[x]=RoundToQuantum(gamma*pixel.index+bias);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(gamma*
+ pixel.index));
}
}
}
MagickRealType
alpha;
- for (v=0; v < (long) width; v++)
+ for (v=0; v < (ssize_t) width; v++)
{
- for (u=0; u < (long) width; u++)
+ for (u=0; u < (ssize_t) width; u++)
{
if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-
- (p+u+j)->opacity));
- pixel.red+=(*k)*alpha*(p+u+j)->red;
- pixel.green+=(*k)*alpha*(p+u+j)->green;
- pixel.blue+=(*k)*alpha*(p+u+j)->blue;
- pixel.opacity+=(*k)*(p+u+j)->opacity;
+ alpha=(MagickRealType) (QuantumScale*
+ GetAlphaPixelComponent(p+u+j));
+ pixel.red+=(*k)*alpha*GetRedPixelComponent(p+u+j);
+ pixel.green+=(*k)*alpha*GetGreenPixelComponent(p+u+j);
+ pixel.blue+=(*k)*alpha*GetBluePixelComponent(p+u+j);
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(p+u+j);
gamma+=(*k)*alpha;
k++;
}
}
- j+=image->columns+width;
+ j+=(ssize_t) (image->columns+width);
}
if (gamma != 0.0)
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
if ((channel & RedChannel) != 0)
- q->red=RoundToQuantum(gamma*pixel.red+bias);
+ SetRedPixelComponent(q,ClampToQuantum(gamma*pixel.red));
if ((channel & GreenChannel) != 0)
- q->green=RoundToQuantum(gamma*pixel.green+bias);
+ SetGreenPixelComponent(q,ClampToQuantum(gamma*pixel.green));
if ((channel & BlueChannel) != 0)
- q->blue=RoundToQuantum(gamma*pixel.blue+bias);
+ SetBluePixelComponent(q,ClampToQuantum(gamma*pixel.blue));
}
if ((channel & OpacityChannel) != 0)
{
gamma=0.0;
j=0;
- for (v=0; v < (long) width; v++)
+ for (v=0; v < (ssize_t) width; v++)
{
- for (u=0; u < (long) width; u++)
+ for (u=0; u < (ssize_t) width; u++)
{
if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
{
- pixel.opacity+=(*k)*(p+u+j)->opacity;
+ pixel.opacity+=(*k)*GetOpacityPixelComponent(p+u+j);
gamma+=(*k);
k++;
}
}
- j+=image->columns+width;
+ j+=(ssize_t) (image->columns+width);
}
if (gamma != 0.0)
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 :
gamma);
- q->opacity=RoundToQuantum(pixel.opacity+bias);
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
}
}
if (((channel & IndexChannel) != 0) &&
{
gamma=0.0;
j=0;
- for (v=0; v < (long) width; v++)
+ for (v=0; v < (ssize_t) width; v++)
{
- for (u=0; u < (long) width; u++)
+ for (u=0; u < (ssize_t) width; u++)
{
if (SelectiveContrast(p+u+j,q,threshold) != MagickFalse)
{
- alpha=(MagickRealType) (QuantumScale*(QuantumRange-
- (p+u+j)->opacity));
- pixel.index+=(*k)*alpha*indexes[x+u+j];
+ alpha=(MagickRealType) (QuantumScale*
+ GetAlphaPixelComponent(p+u+j));
+ pixel.index+=(*k)*alpha*GetIndexPixelComponent(indexes+x+
+ u+j);
gamma+=(*k);
k++;
}
}
- j+=image->columns+width;
+ j+=(ssize_t) (image->columns+width);
}
if (gamma != 0.0)
{
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 :
gamma);
- blur_indexes[x]=RoundToQuantum(gamma*pixel.index+bias);
+ SetIndexPixelComponent(blur_indexes+x,ClampToQuantum(gamma*
+ pixel.index));
}
}
}
{
#define ShadeImageTag "Shade/Image"
+ CacheView
+ *image_view,
+ *shade_view;
+
Image
*shade_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
PrimaryInfo
light;
- CacheView
- *image_view,
- *shade_view;
+ ssize_t
+ y;
/*
Initialize shaded image attributes.
image_view=AcquireCacheView(image);
shade_view=AcquireCacheView(shade_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #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++)
{
MagickRealType
distance,
normal;
register const PixelPacket
- *__restrict p,
- *__restrict s0,
- *__restrict s1,
- *__restrict s2;
-
- register long
- x;
+ *restrict p,
+ *restrict s0,
+ *restrict s1,
+ *restrict s2;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
s0=p+1;
s1=s0+image->columns+2;
s2=s1+image->columns+2;
- for (x=0; x < (long) image->columns; x++)
+ for (x=0; x < (ssize_t) image->columns; x++)
{
/*
Determine the surface normal and compute shading.
}
if (gray != MagickFalse)
{
- q->red=(Quantum) shade;
- q->green=(Quantum) shade;
- q->blue=(Quantum) shade;
+ SetRedPixelComponent(q,shade);
+ SetGreenPixelComponent(q,shade);
+ SetBluePixelComponent(q,shade);
}
else
{
- q->red=RoundToQuantum(QuantumScale*shade*s1->red);
- q->green=RoundToQuantum(QuantumScale*shade*s1->green);
- q->blue=RoundToQuantum(QuantumScale*shade*s1->blue);
+ SetRedPixelComponent(q,ClampToQuantum(QuantumScale*shade*
+ GetRedPixelComponent(s1)));
+ SetGreenPixelComponent(q,ClampToQuantum(QuantumScale*shade*
+ GetGreenPixelComponent(s1)));
+ SetBluePixelComponent(q,ClampToQuantum(QuantumScale*shade*
+ GetBluePixelComponent(s1)));
}
q->opacity=s1->opacity;
s0++;
%
*/
-MagickExport Image *SharpenImage(const Image *image,const double radius,
- const double sigma,ExceptionInfo *exception)
+MagickExport Image *SharpenImage(const Image *image,const double radius,
+ const double sigma,ExceptionInfo *exception)
+{
+ Image
+ *sharp_image;
+
+ sharp_image=SharpenImageChannel(image,DefaultChannels,radius,sigma,exception);
+ return(sharp_image);
+}
+
+MagickExport Image *SharpenImageChannel(const Image *image,
+ const ChannelType channel,const double radius,const double sigma,
+ ExceptionInfo *exception)
+{
+ double
+ *kernel,
+ normalize;
+
+ Image
+ *sharp_image;
+
+ register ssize_t
+ i;
+
+ size_t
+ width;
+
+ ssize_t
+ j,
+ u,
+ v;
+
+ assert(image != (const Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ width=GetOptimalKernelWidth2D(radius,sigma);
+ kernel=(double *) AcquireQuantumMemory((size_t) width*width,sizeof(*kernel));
+ if (kernel == (double *) NULL)
+ ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ normalize=0.0;
+ j=(ssize_t) width/2;
+ i=0;
+ for (v=(-j); v <= j; v++)
+ {
+ for (u=(-j); u <= j; u++)
+ {
+ kernel[i]=(double) (-exp(-((double) u*u+v*v)/(2.0*MagickSigma*
+ MagickSigma))/(2.0*MagickPI*MagickSigma*MagickSigma));
+ normalize+=kernel[i];
+ i++;
+ }
+ }
+ kernel[i/2]=(double) ((-2.0)*normalize);
+ sharp_image=ConvolveImageChannel(image,channel,width,kernel,exception);
+ kernel=(double *) RelinquishMagickMemory(kernel);
+ return(sharp_image);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% S p r e a d I m a g e %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% SpreadImage() is a special effects method that randomly displaces each
+% pixel in a block defined by the radius parameter.
+%
+% The format of the SpreadImage method is:
+%
+% Image *SpreadImage(const Image *image,const double radius,
+% ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o radius: Choose a random pixel in a neighborhood of this extent.
+%
+% o exception: return any errors or warnings in this structure.
+%
+*/
+MagickExport Image *SpreadImage(const Image *image,const double radius,
+ ExceptionInfo *exception)
+{
+#define SpreadImageTag "Spread/Image"
+
+ CacheView
+ *image_view,
+ *spread_view;
+
+ Image
+ *spread_image;
+
+ MagickBooleanType
+ status;
+
+ MagickOffsetType
+ progress;
+
+ MagickPixelPacket
+ bias;
+
+ RandomInfo
+ **restrict random_info;
+
+ size_t
+ width;
+
+ ssize_t
+ y;
+
+ /*
+ Initialize spread image attributes.
+ */
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ spread_image=CloneImage(image,image->columns,image->rows,MagickTrue,
+ exception);
+ if (spread_image == (Image *) NULL)
+ return((Image *) NULL);
+ if (SetImageStorageClass(spread_image,DirectClass) == MagickFalse)
+ {
+ InheritException(exception,&spread_image->exception);
+ spread_image=DestroyImage(spread_image);
+ return((Image *) NULL);
+ }
+ /*
+ Spread image.
+ */
+ status=MagickTrue;
+ progress=0;
+ GetMagickPixelPacket(spread_image,&bias);
+ width=GetOptimalKernelWidth1D(radius,0.5);
+ random_info=AcquireRandomInfoThreadSet();
+ image_view=AcquireCacheView(image);
+ spread_view=AcquireCacheView(spread_image);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status) omp_throttle(1)
+#endif
+ for (y=0; y < (ssize_t) spread_image->rows; y++)
+ {
+ const int
+ id = GetOpenMPThreadId();
+
+ MagickPixelPacket
+ pixel;
+
+ register IndexPacket
+ *restrict indexes;
+
+ register PixelPacket
+ *restrict q;
+
+ register ssize_t
+ x;
+
+ if (status == MagickFalse)
+ continue;
+ q=QueueCacheViewAuthenticPixels(spread_view,0,y,spread_image->columns,1,
+ exception);
+ if (q == (PixelPacket *) NULL)
+ {
+ status=MagickFalse;
+ continue;
+ }
+ indexes=GetCacheViewAuthenticIndexQueue(spread_view);
+ pixel=bias;
+ for (x=0; x < (ssize_t) spread_image->columns; x++)
+ {
+ (void) InterpolateMagickPixelPacket(image,image_view,
+ UndefinedInterpolatePixel,(double) x+width*(GetPseudoRandomValue(
+ random_info[id])-0.5),(double) y+width*(GetPseudoRandomValue(
+ random_info[id])-0.5),&pixel,exception);
+ SetPixelPacket(spread_image,&pixel,q,indexes+x);
+ q++;
+ }
+ if (SyncCacheViewAuthenticPixels(spread_view,exception) == MagickFalse)
+ status=MagickFalse;
+ if (image->progress_monitor != (MagickProgressMonitor) NULL)
+ {
+ MagickBooleanType
+ proceed;
+
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+ #pragma omp critical (MagickCore_SpreadImage)
+#endif
+ proceed=SetImageProgress(image,SpreadImageTag,progress++,image->rows);
+ if (proceed == MagickFalse)
+ status=MagickFalse;
+ }
+ }
+ spread_view=DestroyCacheView(spread_view);
+ image_view=DestroyCacheView(image_view);
+ random_info=DestroyRandomInfoThreadSet(random_info);
+ return(spread_image);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% S t a t i s t i c I m a g e %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% StatisticImage() makes each pixel the min / max / median / mode / etc. of
+% the neighborhood of the specified width and height.
+%
+% The format of the StatisticImage method is:
+%
+% Image *StatisticImage(const Image *image,const StatisticType type,
+% const size_t width,const size_t height,ExceptionInfo *exception)
+% Image *StatisticImageChannel(const Image *image,
+% const ChannelType channel,const StatisticType type,
+% const size_t width,const size_t height,ExceptionInfo *exception)
+%
+% A description of each parameter follows:
+%
+% o image: the image.
+%
+% o channel: the image channel.
+%
+% o type: the statistic type (median, mode, etc.).
+%
+% o width: the width of the pixel neighborhood.
+%
+% o height: the height of the pixel neighborhood.
+%
+% o exception: return any errors or warnings in this structure.
+%
+*/
+
+#define ListChannels 5
+
+typedef struct _ListNode
+{
+ size_t
+ next[9],
+ count,
+ signature;
+} ListNode;
+
+typedef struct _SkipList
+{
+ ssize_t
+ level;
+
+ ListNode
+ *nodes;
+} SkipList;
+
+typedef struct _PixelList
+{
+ size_t
+ length,
+ seed,
+ signature;
+
+ SkipList
+ lists[ListChannels];
+} PixelList;
+
+static PixelList *DestroyPixelList(PixelList *pixel_list)
+{
+ register ssize_t
+ i;
+
+ if (pixel_list == (PixelList *) NULL)
+ return((PixelList *) NULL);
+ for (i=0; i < ListChannels; i++)
+ if (pixel_list->lists[i].nodes != (ListNode *) NULL)
+ pixel_list->lists[i].nodes=(ListNode *) RelinquishMagickMemory(
+ pixel_list->lists[i].nodes);
+ pixel_list=(PixelList *) RelinquishMagickMemory(pixel_list);
+ return(pixel_list);
+}
+
+static PixelList **DestroyPixelListThreadSet(PixelList **pixel_list)
+{
+ register ssize_t
+ i;
+
+ assert(pixel_list != (PixelList **) NULL);
+ for (i=0; i < (ssize_t) GetOpenMPMaximumThreads(); i++)
+ if (pixel_list[i] != (PixelList *) NULL)
+ pixel_list[i]=DestroyPixelList(pixel_list[i]);
+ pixel_list=(PixelList **) RelinquishMagickMemory(pixel_list);
+ return(pixel_list);
+}
+
+static PixelList *AcquirePixelList(const size_t width,const size_t height)
+{
+ PixelList
+ *pixel_list;
+
+ register ssize_t
+ i;
+
+ pixel_list=(PixelList *) AcquireMagickMemory(sizeof(*pixel_list));
+ if (pixel_list == (PixelList *) NULL)
+ return(pixel_list);
+ (void) ResetMagickMemory((void *) pixel_list,0,sizeof(*pixel_list));
+ pixel_list->length=width*height;
+ for (i=0; i < ListChannels; i++)
+ {
+ pixel_list->lists[i].nodes=(ListNode *) AcquireQuantumMemory(65537UL,
+ sizeof(*pixel_list->lists[i].nodes));
+ if (pixel_list->lists[i].nodes == (ListNode *) NULL)
+ return(DestroyPixelList(pixel_list));
+ (void) ResetMagickMemory(pixel_list->lists[i].nodes,0,65537UL*
+ sizeof(*pixel_list->lists[i].nodes));
+ }
+ pixel_list->signature=MagickSignature;
+ return(pixel_list);
+}
+
+static PixelList **AcquirePixelListThreadSet(const size_t width,
+ const size_t height)
+{
+ PixelList
+ **pixel_list;
+
+ register ssize_t
+ i;
+
+ size_t
+ number_threads;
+
+ number_threads=GetOpenMPMaximumThreads();
+ pixel_list=(PixelList **) AcquireQuantumMemory(number_threads,
+ sizeof(*pixel_list));
+ if (pixel_list == (PixelList **) NULL)
+ return((PixelList **) NULL);
+ (void) ResetMagickMemory(pixel_list,0,number_threads*sizeof(*pixel_list));
+ for (i=0; i < (ssize_t) number_threads; i++)
+ {
+ pixel_list[i]=AcquirePixelList(width,height);
+ if (pixel_list[i] == (PixelList *) NULL)
+ return(DestroyPixelListThreadSet(pixel_list));
+ }
+ return(pixel_list);
+}
+
+static void AddNodePixelList(PixelList *pixel_list,const ssize_t channel,
+ const size_t color)
+{
+ register SkipList
+ *list;
+
+ register ssize_t
+ level;
+
+ size_t
+ search,
+ update[9];
+
+ /*
+ Initialize the node.
+ */
+ list=pixel_list->lists+channel;
+ list->nodes[color].signature=pixel_list->signature;
+ list->nodes[color].count=1;
+ /*
+ Determine where it belongs in the list.
+ */
+ search=65536UL;
+ for (level=list->level; level >= 0; level--)
+ {
+ while (list->nodes[search].next[level] < color)
+ search=list->nodes[search].next[level];
+ update[level]=search;
+ }
+ /*
+ Generate a pseudo-random level for this node.
+ */
+ for (level=0; ; level++)
+ {
+ pixel_list->seed=(pixel_list->seed*42893621L)+1L;
+ if ((pixel_list->seed & 0x300) != 0x300)
+ break;
+ }
+ if (level > 8)
+ level=8;
+ if (level > (list->level+2))
+ level=list->level+2;
+ /*
+ If we're raising the list's level, link back to the root node.
+ */
+ while (level > list->level)
+ {
+ list->level++;
+ update[list->level]=65536UL;
+ }
+ /*
+ Link the node into the skip-list.
+ */
+ do
+ {
+ list->nodes[color].next[level]=list->nodes[update[level]].next[level];
+ list->nodes[update[level]].next[level]=color;
+ } while (level-- > 0);
+}
+
+static MagickPixelPacket GetMaximumPixelList(PixelList *pixel_list)
+{
+ MagickPixelPacket
+ pixel;
+
+ register SkipList
+ *list;
+
+ register ssize_t
+ channel;
+
+ size_t
+ color,
+ maximum;
+
+ ssize_t
+ count;
+
+ unsigned short
+ channels[ListChannels];
+
+ /*
+ Find the maximum value for each of the color.
+ */
+ for (channel=0; channel < 5; channel++)
+ {
+ list=pixel_list->lists+channel;
+ color=65536L;
+ count=0;
+ maximum=list->nodes[color].next[0];
+ do
+ {
+ color=list->nodes[color].next[0];
+ if (color > maximum)
+ maximum=color;
+ count+=list->nodes[color].count;
+ } while (count < (ssize_t) pixel_list->length);
+ channels[channel]=(unsigned short) maximum;
+ }
+ GetMagickPixelPacket((const Image *) NULL,&pixel);
+ pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
+ pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
+ pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
+ pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
+ pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
+ return(pixel);
+}
+
+static MagickPixelPacket GetMeanPixelList(PixelList *pixel_list)
+{
+ MagickPixelPacket
+ pixel;
+
+ MagickRealType
+ sum;
+
+ register SkipList
+ *list;
+
+ register ssize_t
+ channel;
+
+ size_t
+ color;
+
+ ssize_t
+ count;
+
+ unsigned short
+ channels[ListChannels];
+
+ /*
+ Find the mean value for each of the color.
+ */
+ for (channel=0; channel < 5; channel++)
+ {
+ list=pixel_list->lists+channel;
+ color=65536L;
+ count=0;
+ sum=0.0;
+ do
+ {
+ color=list->nodes[color].next[0];
+ sum+=(MagickRealType) list->nodes[color].count*color;
+ count+=list->nodes[color].count;
+ } while (count < (ssize_t) pixel_list->length);
+ sum/=pixel_list->length;
+ channels[channel]=(unsigned short) sum;
+ }
+ GetMagickPixelPacket((const Image *) NULL,&pixel);
+ pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
+ pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
+ pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
+ pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
+ pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
+ return(pixel);
+}
+
+static MagickPixelPacket GetMedianPixelList(PixelList *pixel_list)
+{
+ MagickPixelPacket
+ pixel;
+
+ register SkipList
+ *list;
+
+ register ssize_t
+ channel;
+
+ size_t
+ color;
+
+ ssize_t
+ count;
+
+ unsigned short
+ channels[ListChannels];
+
+ /*
+ Find the median value for each of the color.
+ */
+ for (channel=0; channel < 5; channel++)
+ {
+ list=pixel_list->lists+channel;
+ color=65536L;
+ count=0;
+ do
+ {
+ color=list->nodes[color].next[0];
+ count+=list->nodes[color].count;
+ } while (count <= (ssize_t) (pixel_list->length >> 1));
+ channels[channel]=(unsigned short) color;
+ }
+ GetMagickPixelPacket((const Image *) NULL,&pixel);
+ pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
+ pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
+ pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
+ pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
+ pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
+ return(pixel);
+}
+
+static MagickPixelPacket GetMinimumPixelList(PixelList *pixel_list)
+{
+ MagickPixelPacket
+ pixel;
+
+ register SkipList
+ *list;
+
+ register ssize_t
+ channel;
+
+ size_t
+ color,
+ minimum;
+
+ ssize_t
+ count;
+
+ unsigned short
+ channels[ListChannels];
+
+ /*
+ Find the minimum value for each of the color.
+ */
+ for (channel=0; channel < 5; channel++)
+ {
+ list=pixel_list->lists+channel;
+ count=0;
+ color=65536UL;
+ minimum=list->nodes[color].next[0];
+ do
+ {
+ color=list->nodes[color].next[0];
+ if (color < minimum)
+ minimum=color;
+ count+=list->nodes[color].count;
+ } while (count < (ssize_t) pixel_list->length);
+ channels[channel]=(unsigned short) minimum;
+ }
+ GetMagickPixelPacket((const Image *) NULL,&pixel);
+ pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
+ pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
+ pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
+ pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
+ pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
+ return(pixel);
+}
+
+static MagickPixelPacket GetModePixelList(PixelList *pixel_list)
+{
+ MagickPixelPacket
+ pixel;
+
+ register SkipList
+ *list;
+
+ register ssize_t
+ channel;
+
+ size_t
+ color,
+ max_count,
+ mode;
+
+ ssize_t
+ count;
+
+ unsigned short
+ channels[5];
+
+ /*
+ Make each pixel the 'predominate color' of the specified neighborhood.
+ */
+ for (channel=0; channel < 5; channel++)
+ {
+ list=pixel_list->lists+channel;
+ color=65536L;
+ mode=color;
+ max_count=list->nodes[mode].count;
+ count=0;
+ do
+ {
+ color=list->nodes[color].next[0];
+ if (list->nodes[color].count > max_count)
+ {
+ mode=color;
+ max_count=list->nodes[mode].count;
+ }
+ count+=list->nodes[color].count;
+ } while (count < (ssize_t) pixel_list->length);
+ channels[channel]=(unsigned short) mode;
+ }
+ GetMagickPixelPacket((const Image *) NULL,&pixel);
+ pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
+ pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
+ pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
+ pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
+ pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
+ return(pixel);
+}
+
+static MagickPixelPacket GetNonpeakPixelList(PixelList *pixel_list)
+{
+ MagickPixelPacket
+ pixel;
+
+ register SkipList
+ *list;
+
+ register ssize_t
+ channel;
+
+ size_t
+ color,
+ next,
+ previous;
+
+ ssize_t
+ count;
+
+ unsigned short
+ channels[5];
+
+ /*
+ Finds the non peak value for each of the colors.
+ */
+ for (channel=0; channel < 5; channel++)
+ {
+ list=pixel_list->lists+channel;
+ color=65536L;
+ next=list->nodes[color].next[0];
+ count=0;
+ do
+ {
+ previous=color;
+ color=next;
+ next=list->nodes[color].next[0];
+ count+=list->nodes[color].count;
+ } while (count <= (ssize_t) (pixel_list->length >> 1));
+ if ((previous == 65536UL) && (next != 65536UL))
+ color=next;
+ else
+ if ((previous != 65536UL) && (next == 65536UL))
+ color=previous;
+ channels[channel]=(unsigned short) color;
+ }
+ GetMagickPixelPacket((const Image *) NULL,&pixel);
+ pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
+ pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
+ pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
+ pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
+ pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
+ return(pixel);
+}
+
+static MagickPixelPacket GetStandardDeviationPixelList(PixelList *pixel_list)
+{
+ MagickPixelPacket
+ pixel;
+
+ MagickRealType
+ sum,
+ sum_squared;
+
+ register SkipList
+ *list;
+
+ register ssize_t
+ channel;
+
+ size_t
+ color;
+
+ ssize_t
+ count;
+
+ unsigned short
+ channels[ListChannels];
+
+ /*
+ Find the standard-deviation value for each of the color.
+ */
+ for (channel=0; channel < 5; channel++)
+ {
+ list=pixel_list->lists+channel;
+ color=65536L;
+ count=0;
+ sum=0.0;
+ sum_squared=0.0;
+ do
+ {
+ register ssize_t
+ i;
+
+ color=list->nodes[color].next[0];
+ sum+=(MagickRealType) list->nodes[color].count*color;
+ for (i=0; i < (ssize_t) list->nodes[color].count; i++)
+ sum_squared+=((MagickRealType) color)*((MagickRealType) color);
+ count+=list->nodes[color].count;
+ } while (count < (ssize_t) pixel_list->length);
+ sum/=pixel_list->length;
+ sum_squared/=pixel_list->length;
+ channels[channel]=(unsigned short) sqrt(sum_squared-(sum*sum));
+ }
+ GetMagickPixelPacket((const Image *) NULL,&pixel);
+ pixel.red=(MagickRealType) ScaleShortToQuantum(channels[0]);
+ pixel.green=(MagickRealType) ScaleShortToQuantum(channels[1]);
+ pixel.blue=(MagickRealType) ScaleShortToQuantum(channels[2]);
+ pixel.opacity=(MagickRealType) ScaleShortToQuantum(channels[3]);
+ pixel.index=(MagickRealType) ScaleShortToQuantum(channels[4]);
+ return(pixel);
+}
+
+static inline void InsertPixelList(const Image *image,const PixelPacket *pixel,
+ const IndexPacket *indexes,PixelList *pixel_list)
{
- Image
- *sharp_image;
+ size_t
+ signature;
- sharp_image=SharpenImageChannel(image,DefaultChannels,radius,sigma,exception);
- return(sharp_image);
+ unsigned short
+ index;
+
+ index=ScaleQuantumToShort(GetRedPixelComponent(pixel));
+ signature=pixel_list->lists[0].nodes[index].signature;
+ if (signature == pixel_list->signature)
+ pixel_list->lists[0].nodes[index].count++;
+ else
+ AddNodePixelList(pixel_list,0,index);
+ index=ScaleQuantumToShort(GetGreenPixelComponent(pixel));
+ signature=pixel_list->lists[1].nodes[index].signature;
+ if (signature == pixel_list->signature)
+ pixel_list->lists[1].nodes[index].count++;
+ else
+ AddNodePixelList(pixel_list,1,index);
+ index=ScaleQuantumToShort(GetBluePixelComponent(pixel));
+ signature=pixel_list->lists[2].nodes[index].signature;
+ if (signature == pixel_list->signature)
+ pixel_list->lists[2].nodes[index].count++;
+ else
+ AddNodePixelList(pixel_list,2,index);
+ index=ScaleQuantumToShort(GetOpacityPixelComponent(pixel));
+ signature=pixel_list->lists[3].nodes[index].signature;
+ if (signature == pixel_list->signature)
+ pixel_list->lists[3].nodes[index].count++;
+ else
+ AddNodePixelList(pixel_list,3,index);
+ if (image->colorspace == CMYKColorspace)
+ index=ScaleQuantumToShort(GetIndexPixelComponent(indexes));
+ signature=pixel_list->lists[4].nodes[index].signature;
+ if (signature == pixel_list->signature)
+ pixel_list->lists[4].nodes[index].count++;
+ else
+ AddNodePixelList(pixel_list,4,index);
}
-MagickExport Image *SharpenImageChannel(const Image *image,
- const ChannelType channel,const double radius,const double sigma,
- ExceptionInfo *exception)
+static inline MagickRealType MagickAbsoluteValue(const MagickRealType x)
{
- double
- *kernel;
+ if (x < 0)
+ return(-x);
+ return(x);
+}
- Image
- *sharp_image;
+static void ResetPixelList(PixelList *pixel_list)
+{
+ int
+ level;
- MagickRealType
- alpha,
- normalize;
+ register ListNode
+ *root;
- register long
- i,
- u,
- v;
+ register SkipList
+ *list;
- unsigned long
- width;
+ register ssize_t
+ channel;
- assert(image != (const Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
- width=GetOptimalKernelWidth2D(radius,sigma);
- kernel=(double *) AcquireQuantumMemory((size_t) width*width,sizeof(*kernel));
- if (kernel == (double *) NULL)
- ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- i=0;
- normalize=0.0;
- for (v=(-((long) width/2)); v <= (long) (width/2); v++)
+ /*
+ Reset the skip-list.
+ */
+ for (channel=0; channel < 5; channel++)
{
- for (u=(-((long) width/2)); u <= (long) (width/2); u++)
- {
- alpha=exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma));
- kernel[i]=(double) (-alpha/(2.0*MagickPI*MagickSigma*MagickSigma));
- normalize+=kernel[i];
- i++;
- }
+ list=pixel_list->lists+channel;
+ root=list->nodes+65536UL;
+ list->level=0;
+ for (level=0; level < 9; level++)
+ root->next[level]=65536UL;
}
- kernel[i/2]=(double) ((-2.0)*normalize);
- sharp_image=ConvolveImageChannel(image,channel,width,kernel,exception);
- kernel=(double *) RelinquishMagickMemory(kernel);
- return(sharp_image);
+ pixel_list->seed=pixel_list->signature++;
}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
-% S p r e a d I m a g e %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% SpreadImage() is a special effects method that randomly displaces each
-% pixel in a block defined by the radius parameter.
-%
-% The format of the SpreadImage method is:
-%
-% Image *SpreadImage(const Image *image,const double radius,
-% ExceptionInfo *exception)
-%
-% A description of each parameter follows:
-%
-% o image: the image.
-%
-% o radius: Choose a random pixel in a neighborhood of this extent.
-%
-% o exception: return any errors or warnings in this structure.
-%
-*/
-MagickExport Image *SpreadImage(const Image *image,const double radius,
- ExceptionInfo *exception)
-{
-#define SpreadImageTag "Spread/Image"
+MagickExport Image *StatisticImage(const Image *image,const StatisticType type,
+ const size_t width,const size_t height,ExceptionInfo *exception)
+{
Image
- *spread_image;
+ *statistic_image;
- long
- progress,
- y;
+ statistic_image=StatisticImageChannel(image,DefaultChannels,type,width,
+ height,exception);
+ return(statistic_image);
+}
- MagickBooleanType
- status;
+MagickExport Image *StatisticImageChannel(const Image *image,
+ const ChannelType channel,const StatisticType type,const size_t width,
+ const size_t height,ExceptionInfo *exception)
+{
+#define StatisticWidth \
+ (width == 0 ? GetOptimalKernelWidth2D((double) width,0.5) : width)
+#define StatisticHeight \
+ (height == 0 ? GetOptimalKernelWidth2D((double) height,0.5) : height)
+#define StatisticImageTag "Statistic/Image"
- MagickPixelPacket
- zero;
+ CacheView
+ *image_view,
+ *statistic_view;
- RandomInfo
- **random_info;
+ Image
+ *statistic_image;
+
+ MagickBooleanType
+ status;
- ResampleFilter
- **resample_filter;
+ MagickOffsetType
+ progress;
- unsigned long
- width;
+ PixelList
+ **restrict pixel_list;
- CacheView
- *image_view;
+ ssize_t
+ y;
/*
- Initialize spread image attributes.
+ Initialize statistics image attributes.
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- spread_image=CloneImage(image,image->columns,image->rows,MagickTrue,
+ statistic_image=CloneImage(image,image->columns,image->rows,MagickTrue,
exception);
- if (spread_image == (Image *) NULL)
+ if (statistic_image == (Image *) NULL)
return((Image *) NULL);
- if (SetImageStorageClass(spread_image,DirectClass) == MagickFalse)
+ if (SetImageStorageClass(statistic_image,DirectClass) == MagickFalse)
{
- InheritException(exception,&spread_image->exception);
- spread_image=DestroyImage(spread_image);
+ InheritException(exception,&statistic_image->exception);
+ statistic_image=DestroyImage(statistic_image);
return((Image *) NULL);
}
+ pixel_list=AcquirePixelListThreadSet(StatisticWidth,StatisticHeight);
+ if (pixel_list == (PixelList **) NULL)
+ {
+ statistic_image=DestroyImage(statistic_image);
+ ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
+ }
/*
- Spread image.
+ Make each pixel the min / max / median / mode / etc. of the neighborhood.
*/
status=MagickTrue;
progress=0;
- GetMagickPixelPacket(spread_image,&zero);
- width=GetOptimalKernelWidth1D(radius,0.5);
- resample_filter=AcquireResampleFilterThreadSet(image,MagickTrue,exception);
- random_info=AcquireRandomInfoThreadSet();
- image_view=AcquireCacheView(spread_image);
+ image_view=AcquireCacheView(image);
+ statistic_view=AcquireCacheView(statistic_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #pragma omp parallel for schedule(dynamic,4) shared(progress,status)
#endif
- for (y=0; y < (long) spread_image->rows; y++)
+ for (y=0; y < (ssize_t) statistic_image->rows; y++)
{
- MagickPixelPacket
- pixel;
+ const int
+ id = GetOpenMPThreadId();
- register IndexPacket
- *__restrict indexes;
+ register const IndexPacket
+ *restrict indexes;
- register long
- id,
- x;
+ register const PixelPacket
+ *restrict p;
+
+ register IndexPacket
+ *restrict statistic_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
- q=QueueCacheViewAuthenticPixels(image_view,0,y,spread_image->columns,1,
- exception);
- if (q == (PixelPacket *) NULL)
+ p=GetCacheViewVirtualPixels(image_view,-((ssize_t) StatisticWidth/2L),y-
+ (ssize_t) (StatisticHeight/2L),image->columns+StatisticWidth,
+ StatisticHeight,exception);
+ q=QueueCacheViewAuthenticPixels(statistic_view,0,y,statistic_image->columns, 1,exception);
+ if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
{
status=MagickFalse;
continue;
}
- indexes=GetCacheViewAuthenticIndexQueue(image_view);
- pixel=zero;
- id=GetOpenMPThreadId();
- for (x=0; x < (long) spread_image->columns; x++)
+ indexes=GetCacheViewVirtualIndexQueue(image_view);
+ statistic_indexes=GetCacheViewAuthenticIndexQueue(statistic_view);
+ for (x=0; x < (ssize_t) statistic_image->columns; x++)
{
- (void) ResamplePixelColor(resample_filter[id],(double) x+width*
- (GetPseudoRandomValue(random_info[id])-0.5),(double) y+width*
- (GetPseudoRandomValue(random_info[id])-0.5),&pixel);
- SetPixelPacket(spread_image,&pixel,q,indexes+x);
+ MagickPixelPacket
+ pixel;
+
+ register const IndexPacket
+ *restrict s;
+
+ register const PixelPacket
+ *restrict r;
+
+ register ssize_t
+ u,
+ v;
+
+ r=p;
+ s=indexes+x;
+ ResetPixelList(pixel_list[id]);
+ for (v=0; v < (ssize_t) StatisticHeight; v++)
+ {
+ for (u=0; u < (ssize_t) StatisticWidth; u++)
+ InsertPixelList(image,r+u,s+u,pixel_list[id]);
+ r+=image->columns+StatisticWidth;
+ s+=image->columns+StatisticWidth;
+ }
+ GetMagickPixelPacket(image,&pixel);
+ SetMagickPixelPacket(image,p+StatisticWidth*StatisticHeight/2,indexes+
+ StatisticWidth*StatisticHeight/2+x,&pixel);
+ switch (type)
+ {
+ case GradientStatistic:
+ {
+ MagickPixelPacket
+ maximum,
+ minimum;
+
+ minimum=GetMinimumPixelList(pixel_list[id]);
+ maximum=GetMaximumPixelList(pixel_list[id]);
+ pixel.red=MagickAbsoluteValue(maximum.red-minimum.red);
+ pixel.green=MagickAbsoluteValue(maximum.green-minimum.green);
+ pixel.blue=MagickAbsoluteValue(maximum.blue-minimum.blue);
+ pixel.opacity=MagickAbsoluteValue(maximum.opacity-minimum.opacity);
+ if (image->colorspace == CMYKColorspace)
+ pixel.index=MagickAbsoluteValue(maximum.index-minimum.index);
+ break;
+ }
+ case MaximumStatistic:
+ {
+ pixel=GetMaximumPixelList(pixel_list[id]);
+ break;
+ }
+ case MeanStatistic:
+ {
+ pixel=GetMeanPixelList(pixel_list[id]);
+ break;
+ }
+ case MedianStatistic:
+ default:
+ {
+ pixel=GetMedianPixelList(pixel_list[id]);
+ break;
+ }
+ case MinimumStatistic:
+ {
+ pixel=GetMinimumPixelList(pixel_list[id]);
+ break;
+ }
+ case ModeStatistic:
+ {
+ pixel=GetModePixelList(pixel_list[id]);
+ break;
+ }
+ case NonpeakStatistic:
+ {
+ pixel=GetNonpeakPixelList(pixel_list[id]);
+ break;
+ }
+ case StandardDeviationStatistic:
+ {
+ pixel=GetStandardDeviationPixelList(pixel_list[id]);
+ break;
+ }
+ }
+ if ((channel & RedChannel) != 0)
+ SetRedPixelComponent(q,ClampToQuantum(pixel.red));
+ if ((channel & GreenChannel) != 0)
+ SetGreenPixelComponent(q,ClampToQuantum(pixel.green));
+ if ((channel & BlueChannel) != 0)
+ SetBluePixelComponent(q,ClampToQuantum(pixel.blue));
+ if (((channel & OpacityChannel) != 0) &&
+ (image->matte != MagickFalse))
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
+ if (((channel & IndexChannel) != 0) &&
+ (image->colorspace == CMYKColorspace))
+ SetIndexPixelComponent(statistic_indexes+x,ClampToQuantum(pixel.index));
+ p++;
q++;
}
- if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)
+ if (SyncCacheViewAuthenticPixels(statistic_view,exception) == MagickFalse)
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
proceed;
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_SpreadImage)
+ #pragma omp critical (MagickCore_StatisticImage)
#endif
- proceed=SetImageProgress(image,SpreadImageTag,progress++,image->rows);
+ proceed=SetImageProgress(image,StatisticImageTag,progress++,
+ image->rows);
if (proceed == MagickFalse)
status=MagickFalse;
}
}
+ statistic_view=DestroyCacheView(statistic_view);
image_view=DestroyCacheView(image_view);
- random_info=DestroyRandomInfoThreadSet(random_info);
- resample_filter=DestroyResampleFilterThreadSet(resample_filter);
- return(spread_image);
+ pixel_list=DestroyPixelListThreadSet(pixel_list);
+ return(statistic_image);
}
\f
/*
{
#define SharpenImageTag "Sharpen/Image"
+ CacheView
+ *image_view,
+ *unsharp_view;
+
Image
*unsharp_image;
- long
- progress,
- y;
-
MagickBooleanType
status;
+ MagickOffsetType
+ progress;
+
MagickPixelPacket
- zero;
+ bias;
MagickRealType
quantum_threshold;
- CacheView
- *image_view,
- *unsharp_view;
+ ssize_t
+ y;
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
*/
status=MagickTrue;
progress=0;
- GetMagickPixelPacket(image,&zero);
+ GetMagickPixelPacket(image,&bias);
image_view=AcquireCacheView(image);
unsharp_view=AcquireCacheView(unsharp_image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp parallel for schedule(static,1) shared(progress,status)
+ #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++)
{
MagickPixelPacket
pixel;
register const IndexPacket
- *__restrict indexes;
+ *restrict indexes;
register const PixelPacket
- *__restrict p;
+ *restrict p;
register IndexPacket
- *__restrict unsharp_indexes;
-
- register long
- x;
+ *restrict unsharp_indexes;
register PixelPacket
- *__restrict q;
+ *restrict q;
+
+ register ssize_t
+ x;
if (status == MagickFalse)
continue;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
unsharp_indexes=GetCacheViewAuthenticIndexQueue(unsharp_view);
- pixel=zero;
- for (x=0; x < (long) image->columns; x++)
+ pixel=bias;
+ for (x=0; x < (ssize_t) image->columns; x++)
{
if ((channel & RedChannel) != 0)
{
- pixel.red=p->red-(MagickRealType) q->red;
+ pixel.red=GetRedPixelComponent(p)-(MagickRealType)
+ GetRedPixelComponent(q);
if (fabs(2.0*pixel.red) < quantum_threshold)
- pixel.red=(MagickRealType) p->red;
+ pixel.red=(MagickRealType) GetRedPixelComponent(p);
else
- pixel.red=(MagickRealType) p->red+(pixel.red*amount);
- q->red=RoundToQuantum(pixel.red);
+ pixel.red=(MagickRealType) GetRedPixelComponent(p)+
+ (pixel.red*amount);
+ SetRedPixelComponent(q,ClampToQuantum(pixel.red));
}
if ((channel & GreenChannel) != 0)
{
- pixel.green=p->green-(MagickRealType) q->green;
+ pixel.green=GetGreenPixelComponent(p)-(MagickRealType) q->green;
if (fabs(2.0*pixel.green) < quantum_threshold)
- pixel.green=(MagickRealType) p->green;
+ pixel.green=(MagickRealType) GetGreenPixelComponent(p);
else
- pixel.green=(MagickRealType) p->green+(pixel.green*amount);
- q->green=RoundToQuantum(pixel.green);
+ pixel.green=(MagickRealType) GetGreenPixelComponent(p)+(pixel.green*amount);
+ SetGreenPixelComponent(q,ClampToQuantum(pixel.green));
}
if ((channel & BlueChannel) != 0)
{
- pixel.blue=p->blue-(MagickRealType) q->blue;
+ pixel.blue=GetBluePixelComponent(p)-(MagickRealType) q->blue;
if (fabs(2.0*pixel.blue) < quantum_threshold)
- pixel.blue=(MagickRealType) p->blue;
+ pixel.blue=(MagickRealType) GetBluePixelComponent(p);
else
- pixel.blue=(MagickRealType) p->blue+(pixel.blue*amount);
- q->blue=RoundToQuantum(pixel.blue);
+ pixel.blue=(MagickRealType) GetBluePixelComponent(p)+(pixel.blue*amount);
+ SetBluePixelComponent(q,ClampToQuantum(pixel.blue));
}
if ((channel & OpacityChannel) != 0)
{
- pixel.opacity=p->opacity-(MagickRealType) q->opacity;
+ pixel.opacity=GetOpacityPixelComponent(p)-(MagickRealType) q->opacity;
if (fabs(2.0*pixel.opacity) < quantum_threshold)
- pixel.opacity=(MagickRealType) p->opacity;
+ pixel.opacity=(MagickRealType) GetOpacityPixelComponent(p);
else
- pixel.opacity=p->opacity+(pixel.opacity*amount);
- q->opacity=RoundToQuantum(pixel.opacity);
+ pixel.opacity=GetOpacityPixelComponent(p)+(pixel.opacity*amount);
+ SetOpacityPixelComponent(q,ClampToQuantum(pixel.opacity));
}
if (((channel & IndexChannel) != 0) &&
(image->colorspace == CMYKColorspace))
{
- pixel.index=unsharp_indexes[x]-(MagickRealType) indexes[x];
+ pixel.index=GetIndexPixelComponent(indexes+x)-(MagickRealType)
+ GetIndexPixelComponent(unsharp_indexes+x);
if (fabs(2.0*pixel.index) < quantum_threshold)
- pixel.index=(MagickRealType) unsharp_indexes[x];
+ pixel.index=(MagickRealType) GetIndexPixelComponent(indexes+x);
else
- pixel.index=(MagickRealType) unsharp_indexes[x]+(pixel.index*
- amount);
- unsharp_indexes[x]=RoundToQuantum(pixel.index);
+ pixel.index=(MagickRealType) GetIndexPixelComponent(indexes+x)+
+ (pixel.index*amount);
+ SetIndexPixelComponent(unsharp_indexes+x,ClampToQuantum(pixel.index));
}
p++;
q++;
projects / imagemagick / blobdiff