ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
- kernel_info=AcquireKernelInfo("1");
+ kernel_info=AcquireKernelInfo((const char *) NULL);
kernel_info->width=order_;
kernel_info->height=order_;
kernel_info->values=(double *) color_matrix_;
void Magick::Image::convolve ( const size_t order_,
const double *kernel_ )
{
+ KernelInfo
+ *kernel_info;
+
ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
+ kernel_info=AcquireKernelInfo((const char *) NULL);
+ kernel_info->width=order_;
+ kernel_info->height=order_;
+ kernel_info->values=(double *) kernel_;
MagickCore::Image* newImage =
- ConvolveImage ( image(), order_,
- kernel_, &exceptionInfo );
+ ConvolveImage ( image(), kernel_info, &exceptionInfo );
+ kernel_info->values=(double *) NULL;
+ kernel_info=DestroyKernelInfo(kernel_info);
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
// Filter image by replacing each pixel component with the median
// color in a circular neighborhood
- class MagickDLLDecl medianFilterImage : public std::unary_function<Image&,void>
+ class MagickDLLDecl medianConvolveImage : public std::unary_function<Image&,void>
{
public:
- medianFilterImage( const double radius_ = 0.0 );
+ medianConvolveImage( const double radius_ = 0.0 );
void operator()( Image &image_ ) const;
// Filter image by replacing each pixel component with the median
// color in a circular neighborhood
-Magick::medianFilterImage::medianFilterImage( const double radius_ )
+Magick::medianConvolveImage::medianConvolveImage( const double radius_ )
: _radius( radius_ )
{
}
-void Magick::medianFilterImage::operator()( Magick::Image &image_ ) const
+void Magick::medianConvolveImage::operator()( Magick::Image &image_ ) const
{
image_.medianFilter( _radius );
}
%
% The format of the ConvolveImage method is:
%
-% Image *ConvolveImage(const Image *image,const size_t order,
-% const double *kernel,ExceptionInfo *exception)
+% Image *ConvolveImage(const Image *image,const KernelInfo *kernel,
+% ExceptionInfo *exception)
+%
% A description of each parameter follows:
%
% o image: the image.
%
-% o order: the number of columns and rows in the filter kernel.
-%
-% o kernel: An array of double representing the convolution kernel.
+% o kernel: the filtering kernel.
%
% o exception: return any errors or warnings in this structure.
%
*/
-MagickExport Image *ConvolveImage(const Image *image,const size_t order,
- const double *kernel,ExceptionInfo *exception)
+MagickExport Image *ConvolveImage(const Image *image,
+ const KernelInfo *kernel_info,ExceptionInfo *exception)
{
#define ConvolveImageTag "Convolve/Image"
*convolve_view,
*image_view;
- double
- *normal_kernel;
-
Image
*convolve_image;
MagickOffsetType
progress;
- MagickRealType
- gamma;
-
- register ssize_t
- i;
-
- size_t
- width;
-
ssize_t
y;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- width=order;
- if ((width % 2) == 0)
+ if ((kernel_info->width % 2) == 0)
ThrowImageException(OptionError,"KernelWidthMustBeAnOddNumber");
convolve_image=CloneImage(image,image->columns,image->rows,MagickTrue,
exception);
v;
(void) LogMagickEvent(TransformEvent,GetMagickModule(),
- " ConvolveImage with %.20gx%.20g kernel:",(double) width,(double)
- width);
+ " ConvolveImage with %.20gx%.20g kernel:",(double) kernel_info->width,
+ (double) kernel_info->height);
message=AcquireString("");
- k=kernel;
- for (v=0; v < (ssize_t) width; v++)
+ k=kernel_info->values;
+ for (v=0; v < (ssize_t) kernel_info->width; v++)
{
*message='\0';
(void) FormatLocaleString(format,MaxTextExtent,"%.20g: ",(double) v);
(void) ConcatenateString(&message,format);
- for (u=0; u < (ssize_t) width; u++)
+ for (u=0; u < (ssize_t) kernel_info->height; u++)
{
(void) FormatLocaleString(format,MaxTextExtent,"%g ",*k++);
(void) ConcatenateString(&message,format);
}
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.
*/
if (status == MagickFalse)
continue;
- p=GetCacheViewVirtualPixels(image_view,-((ssize_t) width/2L),y-(ssize_t)
- (width/2L),image->columns+width,width,exception);
+ p=GetCacheViewVirtualPixels(image_view,-((ssize_t) kernel_info->width/2L),y-
+ (ssize_t) (kernel_info->height/2L),image->columns+kernel_info->width,
+ kernel_info->height,exception);
q=QueueCacheViewAuthenticPixels(convolve_view,0,y,convolve_image->columns,1,
exception);
if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
size_t
center;
- center=((image->columns+width)*width/2)*channels+i;
+ center=((image->columns+kernel_info->width)*kernel_info->height/2)*
+ channels+i;
SetPixelChannel(convolve_image,channel,p[center],q);
continue;
}
- k=normal_kernel;
+ k=kernel_info->values;
kernel_pixels=p;
pixel=image->bias;
if (((convolve_traits & BlendPixelTrait) == 0) ||
/*
No alpha blending.
*/
- for (v=0; v < (ssize_t) width; v++)
+ for (v=0; v < (ssize_t) kernel_info->width; v++)
{
- for (u=0; u < (ssize_t) width; u++)
+ for (u=0; u < (ssize_t) kernel_info->height; u++)
{
pixel+=(*k)*kernel_pixels[u*channels+i];
k++;
}
- kernel_pixels+=(image->columns+width)*channels;
+ kernel_pixels+=(image->columns+kernel_info->width)*channels;
}
SetPixelChannel(convolve_image,channel,ClampToQuantum(pixel),q);
continue;
Alpha blending.
*/
gamma=0.0;
- for (v=0; v < (ssize_t) width; v++)
+ for (v=0; v < (ssize_t) kernel_info->width; v++)
{
- for (u=0; u < (ssize_t) width; u++)
+ for (u=0; u < (ssize_t) kernel_info->height; u++)
{
alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,
kernel_pixels+u*channels));
gamma+=(*k)*alpha;
k++;
}
- kernel_pixels+=(image->columns+width)*channels;
+ kernel_pixels+=(image->columns+kernel_info->width)*channels;
}
gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
SetPixelChannel(convolve_image,channel,ClampToQuantum(gamma*pixel),q);
convolve_image->type=image->type;
convolve_view=DestroyCacheView(convolve_view);
image_view=DestroyCacheView(image_view);
- normal_kernel=(double *) RelinquishMagickMemory(normal_kernel);
if (status == MagickFalse)
convolve_image=DestroyImage(convolve_image);
return(convolve_image);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
width=GetOptimalKernelWidth1D(radius,0.5);
- kernel_info=(KernelInfo *) AcquireMagickMemory(sizeof(*kernel_info));
+ kernel_info=AcquireKernelInfo((const char *) NULL);
if (kernel_info == (KernelInfo *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
kernel_info->width=width;
kernel_info->height=width;
- kernel_info->signature=MagickSignature;
kernel_info->values=(double *) AcquireAlignedMemory(kernel_info->width,
kernel_info->width*sizeof(*kernel_info->values));
if (kernel_info->values == (double *) NULL)
}
}
kernel_info->values[i/2]=(double) (width*width-1.0);
- edge_image=FilterImage(image,kernel_info,exception);
+ edge_image=ConvolveImage(image,kernel_info,exception);
kernel_info=DestroyKernelInfo(kernel_info);
return(edge_image);
}
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
width=GetOptimalKernelWidth2D(radius,sigma);
- kernel_info=(KernelInfo *) AcquireMagickMemory(sizeof(*kernel_info));
+ kernel_info=AcquireKernelInfo((const char *) NULL);
if (kernel_info == (KernelInfo *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
- (void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
kernel_info->width=width;
kernel_info->height=width;
- kernel_info->signature=MagickSignature;
kernel_info->values=(double *) AcquireAlignedMemory(kernel_info->width,
kernel_info->width*sizeof(*kernel_info->values));
if (kernel_info->values == (double *) NULL)
}
k--;
}
- emboss_image=FilterImage(image,kernel_info,exception);
+ emboss_image=ConvolveImage(image,kernel_info,exception);
kernel_info=DestroyKernelInfo(kernel_info);
if (emboss_image != (Image *) NULL)
(void) EqualizeImage(emboss_image);
% %
% %
% %
-% F i l t e r I m a g e %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% FilterImage() applies a custom convolution kernel to the image.
-%
-% The format of the FilterImage method is:
-%
-% Image *FilterImage(const Image *image,const KernelInfo *kernel,
-% ExceptionInfo *exception)
-%
-% A description of each parameter follows:
-%
-% o image: the image.
-%
-% o kernel: the filtering kernel.
-%
-% o exception: return any errors or warnings in this structure.
-%
-*/
-MagickExport Image *FilterImage(const Image *image,
- const KernelInfo *kernel_info,ExceptionInfo *exception)
-{
-#define ConvolveImageTag "Convolve/Image"
-
- CacheView
- *convolve_view,
- *image_view;
-
- Image
- *convolve_image;
-
- MagickBooleanType
- status;
-
- MagickOffsetType
- progress;
-
- ssize_t
- y;
-
- /*
- Initialize convolve 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_info->width % 2) == 0)
- ThrowImageException(OptionError,"KernelWidthMustBeAnOddNumber");
- convolve_image=CloneImage(image,image->columns,image->rows,MagickTrue,
- exception);
- if (convolve_image == (Image *) NULL)
- return((Image *) NULL);
- if (SetImageStorageClass(convolve_image,DirectClass) == MagickFalse)
- {
- InheritException(exception,&convolve_image->exception);
- convolve_image=DestroyImage(convolve_image);
- return((Image *) NULL);
- }
- if (image->debug != MagickFalse)
- {
- char
- format[MaxTextExtent],
- *message;
-
- register const double
- *k;
-
- register ssize_t
- u;
-
- ssize_t
- v;
-
- (void) LogMagickEvent(TransformEvent,GetMagickModule(),
- " ConvolveImage with %.20gx%.20g kernel:",(double) kernel_info->width,
- (double) kernel_info->height);
- message=AcquireString("");
- k=kernel_info->values;
- for (v=0; v < (ssize_t) kernel_info->width; v++)
- {
- *message='\0';
- (void) FormatLocaleString(format,MaxTextExtent,"%.20g: ",(double) v);
- (void) ConcatenateString(&message,format);
- for (u=0; u < (ssize_t) kernel_info->height; u++)
- {
- (void) FormatLocaleString(format,MaxTextExtent,"%g ",*k++);
- (void) ConcatenateString(&message,format);
- }
- (void) LogMagickEvent(TransformEvent,GetMagickModule(),"%s",message);
- }
- message=DestroyString(message);
- }
- /*
- Convolve image.
- */
- status=MagickTrue;
- progress=0;
- image_view=AcquireCacheView(image);
- convolve_view=AcquireCacheView(convolve_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++)
- {
- register const Quantum
- *restrict p;
-
- register Quantum
- *restrict q;
-
- register ssize_t
- x;
-
- size_t
- channels,
- convolve_channels;
-
- if (status == MagickFalse)
- continue;
- p=GetCacheViewVirtualPixels(image_view,-((ssize_t) kernel_info->width/2L),y-
- (ssize_t) (kernel_info->height/2L),image->columns+kernel_info->width,
- kernel_info->height,exception);
- q=QueueCacheViewAuthenticPixels(convolve_view,0,y,convolve_image->columns,1,
- exception);
- if ((p == (const Quantum *) NULL) || (q == (Quantum *) NULL))
- {
- status=MagickFalse;
- continue;
- }
- channels=GetPixelChannels(image);
- convolve_channels=GetPixelChannels(convolve_image);
- for (x=0; x < (ssize_t) image->columns; x++)
- {
- register ssize_t
- i;
-
- for (i=0; i < (ssize_t) channels; i++)
- {
- MagickRealType
- alpha,
- gamma,
- pixel;
-
- PixelChannel
- channel;
-
- PixelTrait
- convolve_traits,
- traits;
-
- register const double
- *restrict k;
-
- register const Quantum
- *restrict kernel_pixels;
-
- register ssize_t
- u;
-
- ssize_t
- v;
-
- traits=GetPixelChannelMapTraits(image,i);
- if (traits == UndefinedPixelTrait)
- continue;
- channel=GetPixelChannelMapChannel(image,i);
- convolve_traits=GetPixelChannelMapTraits(convolve_image,channel);
- if (convolve_traits == UndefinedPixelTrait)
- continue;
- if ((convolve_traits & CopyPixelTrait) != 0)
- {
- size_t
- center;
-
- center=((image->columns+kernel_info->width)*kernel_info->height/2)*
- channels+i;
- SetPixelChannel(convolve_image,channel,p[center],q);
- continue;
- }
- k=kernel_info->values;
- kernel_pixels=p;
- pixel=image->bias;
- if (((convolve_traits & BlendPixelTrait) == 0) ||
- (GetPixelAlphaTraits(image) == UndefinedPixelTrait) ||
- (image->matte == MagickFalse))
- {
- /*
- No alpha blending.
- */
- for (v=0; v < (ssize_t) kernel_info->width; v++)
- {
- for (u=0; u < (ssize_t) kernel_info->height; u++)
- {
- pixel+=(*k)*kernel_pixels[u*channels+i];
- k++;
- }
- kernel_pixels+=(image->columns+kernel_info->width)*channels;
- }
- SetPixelChannel(convolve_image,channel,ClampToQuantum(pixel),q);
- continue;
- }
- /*
- Alpha blending.
- */
- gamma=0.0;
- for (v=0; v < (ssize_t) kernel_info->width; v++)
- {
- for (u=0; u < (ssize_t) kernel_info->height; u++)
- {
- alpha=(MagickRealType) (QuantumScale*GetPixelAlpha(image,
- kernel_pixels+u*channels));
- pixel+=(*k)*alpha*kernel_pixels[u*channels+i];
- gamma+=(*k)*alpha;
- k++;
- }
- kernel_pixels+=(image->columns+kernel_info->width)*channels;
- }
- gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
- SetPixelChannel(convolve_image,channel,ClampToQuantum(gamma*pixel),q);
- }
- p+=channels;
- q+=convolve_channels;
- }
- if (SyncCacheViewAuthenticPixels(convolve_view,exception) == MagickFalse)
- status=MagickFalse;
- if (image->progress_monitor != (MagickProgressMonitor) NULL)
- {
- MagickBooleanType
- proceed;
-
-#if defined(MAGICKCORE_OPENMP_SUPPORT)
- #pragma omp critical (MagickCore_ConvolveImage)
-#endif
- proceed=SetImageProgress(image,ConvolveImageTag,progress++,image->rows);
- if (proceed == MagickFalse)
- status=MagickFalse;
- }
- }
- convolve_image->type=image->type;
- convolve_view=DestroyCacheView(convolve_view);
- image_view=DestroyCacheView(image_view);
- if (status == MagickFalse)
- convolve_image=DestroyImage(convolve_image);
- return(convolve_image);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% G a u s s i a n B l u r I m a g e %
% %
% %
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
width=GetOptimalKernelWidth2D(radius,sigma);
- kernel_info=(KernelInfo *) AcquireMagickMemory(sizeof(*kernel_info));
+ kernel_info=AcquireKernelInfo((const char *) NULL);
if (kernel_info == (KernelInfo *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
(void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
i++;
}
}
- blur_image=FilterImage(image,kernel_info,exception);
+ blur_image=ConvolveImage(image,kernel_info,exception);
kernel_info=DestroyKernelInfo(kernel_info);
return(blur_image);
}
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
width=GetOptimalKernelWidth2D(radius,sigma);
- kernel_info=(KernelInfo *) AcquireMagickMemory(sizeof(*kernel_info));
+ kernel_info=AcquireKernelInfo((const char *) NULL);
if (kernel_info == (KernelInfo *) NULL)
ThrowImageException(ResourceLimitError,"MemoryAllocationFailed");
(void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
}
}
kernel_info->values[i/2]=(double) ((-2.0)*normalize);
- sharp_image=FilterImage(image,kernel_info,exception);
+ sharp_image=ConvolveImage(image,kernel_info,exception);
kernel_info=DestroyKernelInfo(kernel_info);
return(sharp_image);
}
*AdaptiveSharpenImage(const Image *,const double,const double,
ExceptionInfo *),
*BlurImage(const Image *,const double,const double,ExceptionInfo *),
- *ConvolveImage(const Image *,const size_t,const double *,ExceptionInfo *),
+ *ConvolveImage(const Image *,const KernelInfo *,ExceptionInfo *),
*DespeckleImage(const Image *,ExceptionInfo *),
*EdgeImage(const Image *,const double,ExceptionInfo *),
*EmbossImage(const Image *,const double,const double,ExceptionInfo *),
- *FilterImage(const Image *,const KernelInfo *,ExceptionInfo *),
*GaussianBlurImage(const Image *,const double,const double,ExceptionInfo *),
*MotionBlurImage(const Image *,const double,const double,const double,
ExceptionInfo *),
#define FileToImage PrependMagickMethod(FileToImage)
#define FileToStringInfo PrependMagickMethod(FileToStringInfo)
#define FileToString PrependMagickMethod(FileToString)
-#define FilterImage PrependMagickMethod(FilterImage)
-#define FilterImage PrependMagickMethod(FilterImage)
+#define ConvolveImage PrependMagickMethod(ConvolveImage)
+#define ConvolveImage PrependMagickMethod(ConvolveImage)
#define FinalizeSignature PrependMagickMethod(FinalizeSignature)
#define FlattenImages PrependMagickMethod(FlattenImages)
#define FlipImage PrependMagickMethod(FlipImage)
#define MapImage PrependMagickMethod(MapImage)
#define MapImages PrependMagickMethod(MapImages)
#define MatteFloodfillImage PrependMagickMethod(MatteFloodfillImage)
-#define MedianFilterImage PrependMagickMethod(MedianFilterImage)
+#define MedianConvolveImage PrependMagickMethod(MedianConvolveImage)
#define MergeImageLayers PrependMagickMethod(MergeImageLayers)
#define MimeComponentGenesis PrependMagickMethod(MimeComponentGenesis)
#define MimeComponentTerminus PrependMagickMethod(MimeComponentTerminus)
kernel->type = UserDefinedKernel;
kernel->next = (KernelInfo *) NULL;
kernel->signature = MagickSignature;
+ if (kernel_string == (const char *) NULL)
+ return(kernel);
/* find end of this specific kernel definition string */
end = strchr(kernel_string, ';');
size_t
kernel_number;
+ if (kernel_string == (const char *) NULL)
+ return(ParseKernelArray(kernel_string));
p = kernel_string;
kernel = NULL;
kernel_number = 0;
% The format of the MagickConvolveImage method is:
%
% MagickBooleanType MagickConvolveImage(MagickWand *wand,
-% const size_t order,const double *kernel)
+% const KernelInfo *kernel)
%
% A description of each parameter follows:
%
% o wand: the magick wand.
%
-% o order: the number of columns and rows in the filter kernel.
-%
% o kernel: An array of doubles representing the convolution kernel.
%
*/
WandExport MagickBooleanType MagickConvolveImage(MagickWand *wand,
- const size_t order,const double *kernel)
+ const KernelInfo *kernel)
{
Image
- *convolve_image;
+ *filter_image;
assert(wand != (MagickWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- if (kernel == (const double *) NULL)
+ if (kernel == (const KernelInfo *) NULL)
return(MagickFalse);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- convolve_image=ConvolveImage(wand->images,order,kernel,wand->exception);
- if (convolve_image == (Image *) NULL)
+ filter_image=ConvolveImage(wand->images,kernel,wand->exception);
+ if (filter_image == (Image *) NULL)
return(MagickFalse);
- ReplaceImageInList(&wand->images,convolve_image);
+ ReplaceImageInList(&wand->images,filter_image);
return(MagickTrue);
}
\f
% %
% %
% %
-% M a g i c k F i l t e r I m a g e %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% MagickFilterImage() applies a custom convolution kernel to the image.
-%
-% The format of the MagickFilterImage method is:
-%
-% MagickBooleanType MagickFilterImage(MagickWand *wand,
-% const KernelInfo *kernel)
-%
-% A description of each parameter follows:
-%
-% o wand: the magick wand.
-%
-% o kernel: An array of doubles representing the convolution kernel.
-%
-*/
-WandExport MagickBooleanType MagickFilterImage(MagickWand *wand,
- const KernelInfo *kernel)
-{
- Image
- *filter_image;
-
- assert(wand != (MagickWand *) NULL);
- assert(wand->signature == WandSignature);
- if (wand->debug != MagickFalse)
- (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- if (kernel == (const KernelInfo *) NULL)
- return(MagickFalse);
- if (wand->images == (Image *) NULL)
- ThrowWandException(WandError,"ContainsNoImages",wand->name);
- filter_image=FilterImage(wand->images,kernel,wand->exception);
- if (filter_image == (Image *) NULL)
- return(MagickFalse);
- ReplaceImageInList(&wand->images,filter_image);
- return(MagickTrue);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% M a g i c k F l i p I m a g e %
% %
% %
const StorageType,const void *),
MagickContrastImage(MagickWand *,const MagickBooleanType),
MagickContrastStretchImage(MagickWand *,const double,const double),
- MagickConvolveImage(MagickWand *,const size_t,const double *),
+ MagickConvolveImage(MagickWand *,const KernelInfo *),
MagickCropImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickCycleColormapImage(MagickWand *,const ssize_t),
const size_t,const size_t,const char *,const StorageType,void *),
MagickExtentImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
- MagickFilterImage(MagickWand *,const KernelInfo *),
MagickFlipImage(MagickWand *),
MagickFloodfillPaintImage(MagickWand *,const PixelWand *,const double,
const PixelWand *,const ssize_t,const ssize_t,const MagickBooleanType),
MagickLiquidRescaleImage(MagickWand *,const size_t,const size_t,const double,
const double),
MagickMagnifyImage(MagickWand *),
- MagickMedianFilterImage(MagickWand *,const double),
+ MagickMedianConvolveImage(MagickWand *,const double),
MagickMinifyImage(MagickWand *),
MagickModeImage(MagickWand *,const double),
MagickModulateImage(MagickWand *,const double,const double,const double),
KernelInfo
*kernel_info;
- register ssize_t
- j;
-
(void) SyncImageSettings(mogrify_info,*image);
kernel_info=AcquireKernelInfo(argv[i+1]);
if (kernel_info == (KernelInfo *) NULL)
break;
- mogrify_image=FilterImage(*image,kernel_info,exception);
+ mogrify_image=ConvolveImage(*image,kernel_info,exception);
kernel_info=DestroyKernelInfo(kernel_info);
break;
}
{"radius", RealReference}, {"sigma", RealReference},
{"channel", MagickChannelOptions} } },
{ "Convolve", { {"coefficients", ArrayReference},
- {"channel", MagickChannelOptions}, {"bias", StringReference} } },
+ {"channel", MagickChannelOptions}, {"bias", StringReference},
+ {"kernel", StringReference} } },
{ "Profile", { {"name", StringReference}, {"profile", StringReference},
{ "rendering-intent", MagickIntentOptions},
{ "black-point-compensation", MagickBooleanOptions} } },
{"black-point", StringReference}, {"white-point", StringReference},
{"channel", MagickChannelOptions}, {"invert", MagickBooleanOptions} } },
{ "Clamp", { {"channel", MagickChannelOptions} } },
- { "Filter", { {"kernel", StringReference},
- {"channel", MagickChannelOptions}, {"bias", StringReference} } },
{ "BrightnessContrast", { {"levels", StringReference},
{"brightness", RealReference},{"contrast", RealReference},
{"channel", MagickChannelOptions} } },
Magnify = 33
MagnifyImage = 34
MedianFilter = 35
- MedianFilterImage = 36
+ MedianConvolveImage = 36
Minify = 37
MinifyImage = 38
OilPaint = 39
LevelImageColors = 258
Clamp = 259
ClampImage = 260
- Filter = 261
- FilterImage = 262
BrightnessContrast = 263
BrightnessContrastImage = 264
Morphology = 265
}
case 67: /* Convolve */
{
- AV
- *av;
-
- double
+ KernelInfo
*kernel;
- size_t
- order;
-
- if (attribute_flag[0] == 0)
+ if ((attribute_flag[0] == 0) && (attribute_flag[3] == 0))
break;
+ if (attribute_flag[0] != 0)
+ {
+ AV
+ *av;
+
+ size_t
+ order;
+
+ kernel=AcquireKernelInfo((const char *) NULL);
+ if (kernel == (KernelInfo *) NULL)
+ break;
+ av=(AV *) argument_list[0].array_reference;
+ order=(size_t) sqrt(av_len(av)+1);
+ kernel->width=order;
+ kernel->height=order;
+ kernel->values=(double *) AcquireQuantumMemory(order,order*
+ sizeof(*kernel->values));
+ if (kernel->values == (double *) NULL)
+ {
+ kernel=DestroyKernelInfo(kernel);
+ ThrowPerlException(exception,ResourceLimitFatalError,
+ "MemoryAllocationFailed",PackageName);
+ goto PerlException;
+ }
+ for (j=0; (j < (ssize_t) (order*order)) && (j < (av_len(av)+1)); j++)
+ kernel->values[j]=(double) SvNV(*(av_fetch(av,j,0)));
+ for ( ; j < (ssize_t) (order*order); j++)
+ kernel->values[j]=0.0;
+ }
if (attribute_flag[1] != 0)
channel=(ChannelType) argument_list[1].integer_reference;
if (attribute_flag[2] != 0)
image->bias=SiPrefixToDouble(argument_list[2].string_reference,
QuantumRange);
- av=(AV *) argument_list[0].array_reference;
- order=(size_t) sqrt(av_len(av)+1);
- kernel=(double *) AcquireQuantumMemory(order,order*sizeof(*kernel));
- if (kernel == (double *) NULL)
+ if (attribute_flag[3] != 0)
{
- ThrowPerlException(exception,ResourceLimitFatalError,
- "MemoryAllocationFailed",PackageName);
- goto PerlException;
+ kernel=AcquireKernelInfo(argument_list[3].string_reference);
+ if (kernel == (KernelInfo *) NULL)
+ break;
}
- for (j=0; (j < (ssize_t) (order*order)) && (j < (av_len(av)+1)); j++)
- kernel[j]=(double) SvNV(*(av_fetch(av,j,0)));
- for ( ; j < (ssize_t) (order*order); j++)
- kernel[j]=0.0;
PushPixelChannelMap(image,channel);
- image=ConvolveImage(image,order,kernel,exception);
+ image=ConvolveImage(image,kernel,exception);
if (image != (Image *) NULL)
PopPixelChannelMap(image);
- kernel=(double *) RelinquishMagickMemory(kernel);
+ kernel=DestroyKernelInfo(kernel);
break;
}
case 68: /* Profile */
PopPixelChannelMap(image);
break;
}
- case 131: /* Filter */
- {
- KernelInfo
- *kernel;
-
- if (attribute_flag[0] == 0)
- break;
- kernel=AcquireKernelInfo(argument_list[0].string_reference);
- if (kernel == (KernelInfo *) NULL)
- break;
- if (attribute_flag[1] != 0)
- channel=(ChannelType) argument_list[1].integer_reference;
- if (attribute_flag[2] != 0)
- image->bias=SiPrefixToDouble(argument_list[2].string_reference,
- QuantumRange);
- PushPixelChannelMap(image,channel);
- image=FilterImage(image,kernel,exception);
- if (image != (Image *) NULL)
- PopPixelChannelMap(image);
- kernel=DestroyKernelInfo(kernel);
- break;
- }
case 132: /* BrightnessContrast */
{
double
color_matrix[j]=(double) SvNV(*(av_fetch(av,j,0)));
for ( ; j < (ssize_t) (order*order); j++)
color_matrix[j]=0.0;
- kernel_info=AcquireKernelInfo("1");
+ kernel_info=AcquireKernelInfo((const char *) NULL);
if (kernel_info == (KernelInfo *) NULL)
break;
kernel_info->width=order;
print "Convolve...\n";
$example=$model->Clone();
$example->Label('Convolve');
-$example->Convolve([1, 1, 1, 1, 4, 1, 1, 1, 1]);
+$example->Convolve([0.0.125, 0.0.125, 0.0.125, 0.0.125, 1, 0.0.125, 0.0.125, 0.0.125, 0.0.125]);
push(@$images,$example);
print "Crop...\n";
testFilterCompare('input.miff', q//, 'reference/filter/Contrast.miff', 'Contrast', q//, 0.06, 0.6);
++$test;
-testFilterCompare('input.miff', q//, 'reference/filter/Convolve.miff', 'Convolve', q/[1, 1, 1, 1, 4, 1, 1, 1, 1]/, 0.002, 0.02);
+testFilterCompare('input.miff', q//, 'reference/filter/Convolve.miff', 'Convolve', q/[0.125, 0.0.125, 0.0.125, 0.0.125, 1, 0.0.125, 0.0.125, 0.0.125, 0.0.125]/, 0.03, 0.3);
++$test;
testFilterCompare('input.miff', q//, 'reference/filter/Crop.miff', 'Crop', q/geometry=>'80x80+5+10'/, 0.002, 0.02);
# Motion Picture Experts Group file interchange format (version 2)
#
testRead( 'input.m2v',
- 'd3096f660b590223d1047d423f2911b3c5b5e66f4ac09a1a16825dcf389aecce' );
+ '11fabe4dc3114c91da9d4f905bc69a2ab30608b9a550c0d775f0be06f3b39cd0' );
#
# Motion Picture Experts Group file interchange format
#
++$test;
testRead( 'input.mpg',
- 'c8fa2aec1317786ed8b9d68f3353f812bf426699442c6d16768b46d95650ec1a' );
+ '113b91329ec4ad7d147e910e5fd8340d06db419ce6d0258de8993ec4673fc7bc' );
1;
Note that using the -quality option, not all combinations of
PNG filter type, zlib compression level, and zlib compression
- strategy are possible. This is addressed by using
- "-define PNG:compression-strategy", etc., which take precedence
- over -quality.
+ strategy are possible. This will be addressed soon in a
+ release that accomodates "-define PNG:compression-strategy",
+ etc.
*/
projects / imagemagick / commitdiff