ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
MagickCore::Image* newImage =
- AdaptiveBlurImage( image(), radius_, sigma_, image()->bias, &exceptionInfo);
+ AdaptiveBlurImage( image(), radius_, sigma_, &exceptionInfo);
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
MagickCore::Image* newImage =
- BlurImage( image(), radius_, sigma_, image()->bias, &exceptionInfo);
+ BlurImage( image(), radius_, sigma_, &exceptionInfo);
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
GetExceptionInfo( &exceptionInfo );
ChannelType channel_mask = SetPixelChannelMask( image(), channel_ );
MagickCore::Image* newImage =
- BlurImage( image(), radius_, sigma_, image()->bias, &exceptionInfo);
+ BlurImage( image(), radius_, sigma_, &exceptionInfo);
(void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
throwException( exceptionInfo );
ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
MagickCore::Image* newImage =
- CharcoalImage( image(), radius_, sigma_, image()->bias, &exceptionInfo );
+ CharcoalImage( image(), radius_, sigma_, &exceptionInfo );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
kernel_info->width=order_;
kernel_info->height=order_;
kernel_info->values=(MagickRealType *) kernel_;
- kernel_info->bias=image()->bias;
MagickCore::Image* newImage =
ConvolveImage ( image(), kernel_info, &exceptionInfo );
kernel_info->values=(MagickRealType *) NULL;
ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
MagickCore::Image* newImage =
- MotionBlurImage( image(), radius_, sigma_, angle_, 0.0, &exceptionInfo);
+ MotionBlurImage( image(), radius_, sigma_, angle_, &exceptionInfo);
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
width,
height,
image()->filter,
- 1.0,
&exceptionInfo);
replaceImage( newImage );
throwException( exceptionInfo );
ExceptionInfo exceptionInfo;
GetExceptionInfo( &exceptionInfo );
MagickCore::Image* newImage = ShadowImage( image(), percent_opacity_, sigma_,
- image()->bias, x_, y_, &exceptionInfo );
+ x_, y_, &exceptionInfo );
replaceImage( newImage );
throwException( exceptionInfo );
(void) DestroyExceptionInfo( &exceptionInfo );
SharpenImage( image(),
radius_,
sigma_,
- image()->bias,
&exceptionInfo );
replaceImage( newImage );
throwException( exceptionInfo );
SharpenImage( image(),
radius_,
sigma_,
- image()->bias,
&exceptionInfo );
(void) SetPixelChannelMapMask( image(), channel_mask );
replaceImage( newImage );
width,
height,
image()->filter,
- image()->blur,
&exceptionInfo);
replaceImage( newImage );
throwException( exceptionInfo );
return(destination_image);
}
destination_channel=(PixelChannel) i;
- channel_mask|=ParseChannelOption(token);
+ channel_mask=(ChannelType) (channel_mask | ParseChannelOption(token));
if (LocaleCompare(token,"gray") == 0)
(void) SetImageColorspace(destination_image,GRAYColorspace,exception);
if ((LocaleCompare(token,"black") == 0) ||
{
case ExtractChannelOp:
{
- channel_mask|=(1 << destination_channel);
- destination_channel++;
+ channel_mask=(ChannelType) (channel_mask | (1 << destination_channel));
+ destination_channel=(PixelChannel) (destination_channel+1);
break;
}
default:
Blur Image by resampling.
*/
resample_filter=AcquireResampleFilter(image,exception);
- SetResampleFilter(resample_filter,CubicFilter,2.0);
+ SetResampleFilter(resample_filter,CubicFilter);
destination_view=AcquireCacheView(destination_image);
composite_view=AcquireCacheView(composite_image);
for (y=0; y < (ssize_t) composite_image->rows; y++)
flags=ParseRegionGeometry(next,read_info->extract,&geometry,
exception);
size_image=ResizeImage(next,geometry.width,geometry.height,
- next->filter,next->blur,exception);
+ next->filter,exception);
if (size_image != (Image *) NULL)
ReplaceImageInList(&next,size_image);
}
Scale composite image.
*/
resize_image=ResizeImage(composite_image,composite_info.width,
- composite_info.height,composite_image->filter,composite_image->blur,
- exception);
+ composite_info.height,composite_image->filter,exception);
composite_image=DestroyImage(composite_image);
if (resize_image == (Image *) NULL)
{
XCheckRefreshWindows(display,windows);
flags=ParseGeometry(radius,&geometry_info);
sharp_image=SharpenImage(*image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,exception);
+ exception);
if (sharp_image != (Image *) NULL)
{
*image=DestroyImage(*image);
XCheckRefreshWindows(display,windows);
flags=ParseGeometry(radius,&geometry_info);
blur_image=BlurImage(*image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,exception);
+ exception);
if (blur_image != (Image *) NULL)
{
*image=DestroyImage(*image);
geometry_info.xi=0.1*(*image)->columns;
if ((flags & PsiValue) == 0)
geometry_info.psi=0.1*(*image)->rows;
- vignette_image=VignetteImage(*image,geometry_info.rho,geometry_info.sigma,
- 0.0,(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
- ceil(geometry_info.psi-0.5),exception);
+ vignette_image=VignetteImage(*image,geometry_info.rho,0.0,(ssize_t)
+ ceil(geometry_info.xi-0.5),(ssize_t) ceil(geometry_info.psi-0.5),
+ exception);
if (vignette_image != (Image *) NULL)
{
*image=DestroyImage(*image);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
charcoal_image=CharcoalImage(*image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,exception);
+ exception);
if (charcoal_image != (Image *) NULL)
{
*image=DestroyImage(*image);
% The format of the AdaptiveBlurImage method is:
%
% Image *AdaptiveBlurImage(const Image *image,const double radius,
-% const double sigma,const double bias,ExceptionInfo *exception)
+% const double sigma,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Laplacian, in pixels.
%
-% o bias: the bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
}
MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
- const double sigma,const double bias,ExceptionInfo *exception)
+ const double sigma,ExceptionInfo *exception)
{
#define AdaptiveBlurImageTag "Convolve/Image"
#define MagickSigma (fabs(sigma) <= MagickEpsilon ? 1.0 : sigma)
}
k=kernel[j];
pixels=p;
- pixel=bias;
+ pixel=0.0;
gamma=0.0;
if ((blur_traits & BlendPixelTrait) == 0)
{
% The format of the AdaptiveSharpenImage method is:
%
% Image *AdaptiveSharpenImage(const Image *image,const double radius,
-% const double sigma,const double bias,ExceptionInfo *exception)
+% const double sigma,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Laplacian, in pixels.
%
-% o bias: the bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
- const double sigma,const double bias,ExceptionInfo *exception)
+ const double sigma,ExceptionInfo *exception)
{
#define AdaptiveSharpenImageTag "Convolve/Image"
#define MagickSigma (fabs(sigma) <= MagickEpsilon ? 1.0 : sigma)
}
k=kernel[j];
pixels=p;
- pixel=bias;
+ pixel=0.0;
gamma=0.0;
if ((sharp_traits & BlendPixelTrait) == 0)
{
% The format of the BlurImage method is:
%
% Image *BlurImage(const Image *image,const double radius,
-% const double sigma,const double bias,ExceptionInfo *exception)
+% const double sigma,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
}
MagickExport Image *BlurImage(const Image *image,const double radius,
- const double sigma,const double bias,ExceptionInfo *exception)
+ const double sigma,ExceptionInfo *exception)
{
#define BlurImageTag "Blur/Image"
}
}
kernel_info->values[i/2]=(double) (width*width-1.0);
- kernel_info->bias=image->bias; /* FUTURE: User bias on a edge image? */
edge_image=ConvolveImage(image,kernel_info,exception);
kernel_info=DestroyKernelInfo(kernel_info);
return(edge_image);
}
k--;
}
- kernel_info->bias=image->bias; /* FUTURE: user bias on an edge image */
emboss_image=ConvolveImage(image,kernel_info,exception);
kernel_info=DestroyKernelInfo(kernel_info);
if (emboss_image != (Image *) NULL)
% The format of the MotionBlurImage method is:
%
% Image *MotionBlurImage(const Image *image,const double radius,
-% const double sigma,const double angle,const double bias,
-% ExceptionInfo *exception)
+% const double sigma,const double angle,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o angle: Apply the effect along this angle.
%
-% o bias: the bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
}
MagickExport Image *MotionBlurImage(const Image *image,const double radius,
- const double sigma,const double angle,const double bias,
- ExceptionInfo *exception)
+ const double sigma,const double angle,ExceptionInfo *exception)
{
CacheView
*blur_view,
continue;
}
k=kernel;
- pixel=bias;
+ pixel=0.0;
if ((blur_traits & BlendPixelTrait) == 0)
{
for (j=0; j < (ssize_t) width; j++)
}
case SharpenPreview:
{
- /* FUTURE: user bias on sharpen! This is non-sensical! */
- preview_image=SharpenImage(thumbnail,radius,sigma,image->bias,
- exception);
+ preview_image=SharpenImage(thumbnail,radius,sigma,exception);
(void) FormatLocaleString(label,MaxTextExtent,"sharpen %gx%g",
radius,sigma);
break;
}
case BlurPreview:
{
- /* FUTURE: user bias on blur! This is non-sensical! */
- preview_image=BlurImage(thumbnail,radius,sigma,image->bias,exception);
+ preview_image=BlurImage(thumbnail,radius,sigma,exception);
(void) FormatLocaleString(label,MaxTextExtent,"blur %gx%g",radius,
sigma);
break;
}
case CharcoalDrawingPreview:
{
- /* FUTURE: user bias on charcoal! This is non-sensical! */
preview_image=CharcoalImage(thumbnail,(double) radius,(double) sigma,
- image->bias,exception);
+ exception);
(void) FormatLocaleString(label,MaxTextExtent,"charcoal %gx%g",
radius,sigma);
break;
% The format of the RadialBlurImage method is:
%
% Image *RadialBlurImage(const Image *image,const double angle,
-% const double blur,ExceptionInfo *exception)
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
*/
MagickExport Image *RadialBlurImage(const Image *image,const double angle,
- const double bias,ExceptionInfo *exception)
+ ExceptionInfo *exception)
{
CacheView
*blur_view,
continue;
}
gamma=0.0;
- pixel=bias;
+ pixel=0.0;
if ((blur_traits & BlendPixelTrait) == 0)
{
for (j=0; j < (ssize_t) n; j+=(ssize_t) step)
% The format of the SelectiveBlurImage method is:
%
% Image *SelectiveBlurImage(const Image *image,const double radius,
-% const double sigma,const double threshold,const double bias,
-% ExceptionInfo *exception)
+% const double sigma,const double threshold,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o threshold: only pixels within this contrast threshold are included
% in the blur operation.
%
-% o bias: the bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
- const double sigma,const double threshold,const double bias,
- ExceptionInfo *exception)
+ const double sigma,const double threshold,ExceptionInfo *exception)
{
#define SelectiveBlurImageTag "SelectiveBlur/Image"
continue;
}
k=kernel;
- pixel=bias;
+ pixel=0.0;
pixels=p;
intensity=(MagickRealType) GetPixelIntensity(image,p+center);
gamma=0.0;
% The format of the SharpenImage method is:
%
% Image *SharpenImage(const Image *image,const double radius,
-% const double sigma,const double bias,ExceptionInfo *exception)
+% const double sigma,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Laplacian, in pixels.
%
-% o bias: bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *SharpenImage(const Image *image,const double radius,
- const double sigma,const double bias,ExceptionInfo *exception)
+ const double sigma,ExceptionInfo *exception)
{
double
normalize;
(void) ResetMagickMemory(kernel_info,0,sizeof(*kernel_info));
kernel_info->width=width;
kernel_info->height=width;
- kernel_info->bias=bias; /* FUTURE: user bias - non-sensical! */
kernel_info->signature=MagickSignature;
kernel_info->values=(MagickRealType *) AcquireAlignedMemory(
kernel_info->width,kernel_info->width*sizeof(*kernel_info->values));
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
- unsharp_image=BlurImage(image,radius,sigma,image->bias,exception);
+ unsharp_image=BlurImage(image,radius,sigma,exception);
if (unsharp_image == (Image *) NULL)
return((Image *) NULL);
quantum_threshold=(MagickRealType) QuantumRange*threshold;
} PreviewType;
extern MagickExport Image
- *AdaptiveBlurImage(const Image *,const double,const double,const double,
- ExceptionInfo *),
- *AdaptiveSharpenImage(const Image *,const double,const double,const double,
+ *AdaptiveBlurImage(const Image *,const double,const double,ExceptionInfo *),
+ *AdaptiveSharpenImage(const Image *,const double,const double,
ExceptionInfo *),
- *BlurImage(const Image *,const double,const double,const double,
- ExceptionInfo *),
+ *BlurImage(const Image *,const double,const double,ExceptionInfo *),
*ConvolveImage(const Image *,const KernelInfo *,ExceptionInfo *),
*DespeckleImage(const Image *,ExceptionInfo *),
*EdgeImage(const Image *,const double,const double,ExceptionInfo *),
*EmbossImage(const Image *,const double,const double,ExceptionInfo *),
*GaussianBlurImage(const Image *,const double,const double,ExceptionInfo *),
*MotionBlurImage(const Image *,const double,const double,const double,
- const double,ExceptionInfo *),
+ ExceptionInfo *),
*PreviewImage(const Image *,const PreviewType,ExceptionInfo *),
- *RadialBlurImage(const Image *,const double,const double,ExceptionInfo *),
+ *RadialBlurImage(const Image *,const double,ExceptionInfo *),
*SelectiveBlurImage(const Image *,const double,const double,const double,
- const double,ExceptionInfo *),
- *ShadeImage(const Image *,const MagickBooleanType,const double,const double,
ExceptionInfo *),
- *SharpenImage(const Image *,const double,const double,const double,
+ *ShadeImage(const Image *,const MagickBooleanType,const double,const double,
ExceptionInfo *),
+ *SharpenImage(const Image *,const double,const double,ExceptionInfo *),
*SpreadImage(const Image *,const double,const PixelInterpolateMethod,
ExceptionInfo *),
*UnsharpMaskImage(const Image *,const double,const double,const double,
% The format of the CharcoalImage method is:
%
% Image *CharcoalImage(const Image *image,const double radius,
-% const double sigma,const double bias,ExceptionInfo *exception)
+% const double sigma,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *CharcoalImage(const Image *image,const double radius,
- const double sigma,const double bias,ExceptionInfo *exception)
+ const double sigma,ExceptionInfo *exception)
{
Image
*charcoal_image,
clone_image=DestroyImage(clone_image);
if (edge_image == (Image *) NULL)
return((Image *) NULL);
- charcoal_image=BlurImage(edge_image,radius,sigma,bias,exception);
+ charcoal_image=BlurImage(edge_image,radius,sigma,exception);
edge_image=DestroyImage(edge_image);
if (charcoal_image == (Image *) NULL)
return((Image *) NULL);
beta=(MagickRealType) (i+1.0)/(MagickRealType) (number_frames+1.0);
alpha=1.0-beta;
morph_image=ResizeImage(next,(size_t) (alpha*next->columns+beta*
- GetNextImageInList(next)->columns+0.5),(size_t) (alpha*
- next->rows+beta*GetNextImageInList(next)->rows+0.5),
- next->filter,next->blur,exception);
+ GetNextImageInList(next)->columns+0.5),(size_t) (alpha*next->rows+beta*
+ GetNextImageInList(next)->rows+0.5),next->filter,exception);
if (morph_image == (Image *) NULL)
{
morph_images=DestroyImageList(morph_images);
AppendImageToList(&morph_images,morph_image);
morph_images=GetLastImageInList(morph_images);
morph_image=ResizeImage(GetNextImageInList(next),morph_images->columns,
- morph_images->rows,GetNextImageInList(next)->filter,
- GetNextImageInList(next)->blur,exception);
+ morph_images->rows,GetNextImageInList(next)->filter,exception);
if (morph_image == (Image *) NULL)
{
morph_images=DestroyImageList(morph_images);
return((Image *) NULL);
picture_image=rotate_image;
picture_image->background_color=image->background_color;
- polaroid_image=ShadowImage(picture_image,80.0,2.0,0.0,quantum/3,quantum/3,
+ polaroid_image=ShadowImage(picture_image,80.0,0.0,quantum/3,quantum/3,
exception);
if (polaroid_image == (Image *) NULL)
{
% The format of the ShadowImage method is:
%
% Image *ShadowImage(const Image *image,const double alpha,
-% const double sigma,const double bias,const ssize_t x_offset,
-% const ssize_t y_offset,ExceptionInfo *exception)
+% const double sigma,const ssize_t x_offset,const ssize_t y_offset,
+% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
% o x_offset: the shadow x-offset.
%
% o y_offset: the shadow y-offset.
%
*/
MagickExport Image *ShadowImage(const Image *image,const double alpha,
- const double sigma,const double bias,const ssize_t x_offset,
- const ssize_t y_offset,ExceptionInfo *exception)
+ const double sigma,const ssize_t x_offset,const ssize_t y_offset,
+ ExceptionInfo *exception)
{
#define ShadowImageTag "Shadow/Image"
return((Image *) NULL);
}
channel_mask=SetPixelChannelMask(border_image,AlphaChannel);
- shadow_image=BlurImage(border_image,0.0,sigma,bias,exception);
+ shadow_image=BlurImage(border_image,0.0,sigma,exception);
border_image=DestroyImage(border_image);
if (shadow_image == (Image *) NULL)
return((Image *) NULL);
% The format of the SketchImage method is:
%
% Image *SketchImage(const Image *image,const double radius,
-% const double sigma,const double angle,const double bias,
-% ExceptionInfo *exception)
+% const double sigma,const double angle,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
%
% o angle: apply the effect along this angle.
%
-% o bias: the bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *SketchImage(const Image *image,const double radius,
- const double sigma,const double angle,const double bias,
- ExceptionInfo *exception)
+ const double sigma,const double angle,ExceptionInfo *exception)
{
CacheView
*random_view;
random_image=DestroyImage(random_image);
return(random_image);
}
- blur_image=MotionBlurImage(random_image,radius,sigma,angle,bias,exception);
+ blur_image=MotionBlurImage(random_image,radius,sigma,angle,exception);
random_image=DestroyImage(random_image);
if (blur_image == (Image *) NULL)
return((Image *) NULL);
% The format of the VignetteImage method is:
%
% Image *VignetteImage(const Image *image,const double radius,
-% const double sigma,const double bias,const ssize_t x,const ssize_t y,
+% const double sigma,const ssize_t x,const ssize_t y,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
% o x, y: Define the x and y ellipse offset.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *VignetteImage(const Image *image,const double radius,
- const double sigma,const double bias,const ssize_t x,const ssize_t y,
- ExceptionInfo *exception)
+ const double sigma,const ssize_t x,const ssize_t y,ExceptionInfo *exception)
{
char
ellipse[MaxTextExtent];
draw_info->primitive=AcquireString(ellipse);
(void) DrawImage(oval_image,draw_info,exception);
draw_info=DestroyDrawInfo(draw_info);
- blur_image=BlurImage(oval_image,radius,sigma,bias,exception);
+ blur_image=BlurImage(oval_image,radius,sigma,exception);
oval_image=DestroyImage(oval_image);
if (blur_image == (Image *) NULL)
{
extern MagickExport Image
*AddNoiseImage(const Image *,const NoiseType,const double,ExceptionInfo *),
*BlueShiftImage(const Image *,const double,ExceptionInfo *),
- *CharcoalImage(const Image *,const double,const double,const double,
- ExceptionInfo *),
+ *CharcoalImage(const Image *,const double,const double,ExceptionInfo *),
*ColorizeImage(const Image *,const char *,const PixelInfo *,ExceptionInfo *),
*ColorMatrixImage(const Image *,const KernelInfo *kernel,ExceptionInfo *),
*FxImage(const Image *,const char *,ExceptionInfo *),
*PolaroidImage(const Image *,const DrawInfo *,const char *,const double,
const PixelInterpolateMethod,ExceptionInfo *),
*SepiaToneImage(const Image *,const double,ExceptionInfo *),
- *ShadowImage(const Image *,const double,const double,const double,
- const ssize_t,const ssize_t,ExceptionInfo *),
+ *ShadowImage(const Image *,const double,const double,const ssize_t,
+ const ssize_t,ExceptionInfo *),
*SketchImage(const Image *,const double,const double,const double,
- const double,ExceptionInfo *),
+ ExceptionInfo *),
*SteganoImage(const Image *,const Image *,ExceptionInfo *),
*StereoImage(const Image *,const Image *,ExceptionInfo *),
*StereoAnaglyphImage(const Image *,const Image *,const ssize_t,const ssize_t,
*SwirlImage(const Image *,double,const PixelInterpolateMethod,
ExceptionInfo *),
*TintImage(const Image *,const char *,const PixelInfo *,ExceptionInfo *),
- *VignetteImage(const Image *,const double,const double,const double,
- const ssize_t,const ssize_t,ExceptionInfo *),
+ *VignetteImage(const Image *,const double,const double,const ssize_t,
+ const ssize_t,ExceptionInfo *),
*WaveImage(const Image *,const double,const double,
const PixelInterpolateMethod,ExceptionInfo *);
image->interlace=NoInterlace;
image->ticks_per_second=UndefinedTicksPerSecond;
image->compose=OverCompositeOp;
- image->blur=1.0;
(void) QueryColorCompliance(BackgroundColor,AllCompliance,
&image->background_color,exception);
(void) QueryColorCompliance(BorderColor,AllCompliance,&image->border_color,
if (option != (const char *) NULL)
(void) QueryColorCompliance(option,AllCompliance,&image->background_color,
exception);
- option=GetImageOption(image_info,"bias");
- if (option != (const char *) NULL)
- image->bias=StringToDoubleInterval(option,(double) QuantumRange+1.0);
option=GetImageOption(image_info,"black-point-compensation");
if (option != (const char *) NULL)
image->black_point_compensation=(MagickBooleanType) ParseCommandOption(
exception);
option=GetImageOption(image_info,"channel");
if (option != (const char *) NULL)
- (void) SetPixelChannelMapMask(image,ParseChannelOption(option));
+ (void) SetPixelChannelMapMask(image,(ChannelType)
+ ParseChannelOption(option));
/* FUTURE: do not sync compose to per-image compose setting here */
option=GetImageOption(image_info,"compose");
if (option != (const char *) NULL)
extract_info;
double
- bias, /* FUTURE: depreciated -- convolve bias */
- blur, /* FUTURE: depreciated -- resize file blur */
fuzz; /* current color fuzz attribute - make image_info */
FilterTypes
*/
(void) QueryColorCompliance("#0000",AllCompliance,
&image->background_color,exception);
- shadow_image=ShadowImage(image,80.0,2.0,0.0,5,5,exception);
+ shadow_image=ShadowImage(image,80.0,0.0,5,5,exception);
if (shadow_image != (Image *) NULL)
{
(void) CompositeImage(shadow_image,OverCompositeOp,image,0,0,
extern MagickPrivate Image
*MorphologyApply(const Image *,const MorphologyMethod,const ssize_t,
- const KernelInfo *,const CompositeOperator,const double,ExceptionInfo *);
+ const KernelInfo *,const CompositeOperator,ExceptionInfo *);
extern MagickPrivate void
ShowKernelInfo(const KernelInfo *),
%
% Image *MorphologyApply(const Image *image,MorphologyMethod method,
% const ssize_t iterations,const KernelInfo *kernel,
-% const CompositeMethod compose,const double bias,
-% ExceptionInfo *exception)
+% const CompositeMethod compose,ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% If 'NoCompositeOp' force image to be re-iterated by each kernel.
% Otherwise merge the results using the compose method given.
%
-% o bias: Convolution Output Bias.
-%
% o exception: return any errors or warnings in this structure.
%
*/
** for result convergence determination.
*/
static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
- const MorphologyMethod method,const KernelInfo *kernel,const double bias,
+ const MorphologyMethod method,const KernelInfo *kernel,
ExceptionInfo *exception)
{
#define MorphologyTag "Morphology/Image"
result.green =
result.blue =
result.alpha =
- result.black = bias;
+ result.black = 0.0;
/* Weighted Average of pixels using reflected kernel
result.green =
result.blue =
result.alpha =
- result.black = bias;
+ result.black = 0.0;
break;
case DilateIntensityMorphology:
case ErodeIntensityMorphology:
*/
MagickPrivate Image *MorphologyApply(const Image *image,
const MorphologyMethod method, const ssize_t iterations,
- const KernelInfo *kernel, const CompositeOperator compose,const double bias,
+ const KernelInfo *kernel, const CompositeOperator compose,
ExceptionInfo *exception)
{
CompositeOperator
/* APPLY THE MORPHOLOGICAL PRIMITIVE (curr -> work) */
count++;
changed = MorphologyPrimitive(curr_image, work_image, primitive,
- this_kernel, bias, exception);
+ this_kernel, exception);
if ( verbose == MagickTrue ) {
if ( kernel_loop > 1 )
MagickFalse,artifact);
}
/* Apply the Morphology */
- morphology_image = MorphologyApply(image, method, iterations,
- curr_kernel, compose, image->bias, exception);
+ morphology_image=MorphologyApply(image,method,iterations,curr_kernel,compose,
+ exception);
/* Cleanup and Exit */
if ( curr_kernel != kernel )
status=MagickFalse;
break;
}
- filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
- exception);
+ filter_image=ResizeImage(excerpt_image,1,1,image->filter,exception);
excerpt_image=DestroyImage(excerpt_image);
if (filter_image == (Image *) NULL)
break;
status=MagickFalse;
continue;
}
- filter_source=ResizeImage(excerpt_source,1,1,source->filter,
- source->blur,exception);
+ filter_source=ResizeImage(excerpt_source,1,1,source->filter,exception);
excerpt_source=DestroyImage(excerpt_source);
if (filter_source == (Image *) NULL)
continue;
status=MagickFalse;
break;
}
- filter_image=ResizeImage(excerpt_image,1,1,image->filter,image->blur,
- exception);
+ filter_image=ResizeImage(excerpt_image,1,1,image->filter,exception);
excerpt_image=DestroyImage(excerpt_image);
if (filter_image == (Image *) NULL)
break;
image->page=clone_image->page;
image->tile_offset=clone_image->tile_offset;
image->extract_info=clone_image->extract_info;
- image->bias=clone_image->bias;
image->filter=clone_image->filter;
- image->blur=clone_image->blur;
image->fuzz=clone_image->fuzz;
image->interlace=clone_image->interlace;
image->interpolate=clone_image->interpolate;
&image->background_color,exception);
break;
}
- if (LocaleCompare(property,"bias") == 0)
- {
- image->bias=StringToDoubleInterval(value,(double) QuantumRange+1.0);
- break;
- }
status=AddValueToSplayTree((SplayTreeInfo *) image->properties,
ConstantString(property),ConstantString(value));
break;
if (method != UndefinedVirtualPixelMethod)
(void) SetResampleFilterVirtualPixelMethod(filter[i],method);
if (interpolate != MagickFalse)
- SetResampleFilter(filter[i],PointFilter,1.0);
+ SetResampleFilter(filter[i],PointFilter);
}
return(filter);
}
resample_filter->average_defined = MagickFalse;
/* initialise the resampling filter settings */
- SetResampleFilter(resample_filter, image->filter, image->blur);
- (void) SetResampleFilterInterpolateMethod(resample_filter,
- image->interpolate);
+ SetResampleFilter(resample_filter, image->filter);
+ (void) SetResampleFilterInterpolateMethod(resample_filter,image->interpolate);
(void) SetResampleFilterVirtualPixelMethod(resample_filter,
GetImageVirtualPixelMethod(image));
-
return(resample_filter);
}
\f
resample_filter->average_defined=MagickTrue;
/* Try to get an averaged pixel color of whole image */
- average_image=ResizeImage(resample_filter->image,1,1,BoxFilter,1.0,
+ average_image=ResizeImage(resample_filter->image,1,1,BoxFilter,
resample_filter->exception);
if (average_image == (Image *) NULL)
{
% The format of the SetResampleFilter method is:
%
% void SetResampleFilter(ResampleFilter *resample_filter,
-% const FilterTypes filter,const double blur)
+% const FilterTypes filter)
%
% A description of each parameter follows:
%
%
% o filter: the resize filter for elliptical weighting LUT
%
-% o blur: filter blur factor (radial scaling) for elliptical weighting LUT
-%
*/
MagickExport void SetResampleFilter(ResampleFilter *resample_filter,
- const FilterTypes filter,const double blur)
+ const FilterTypes filter)
{
ResizeFilter
*resize_filter;
resample_filter->filter = RobidouxFilter;
resize_filter = AcquireResizeFilter(resample_filter->image,
- resample_filter->filter,blur,MagickTrue,resample_filter->exception);
+ resample_filter->filter,MagickTrue,resample_filter->exception);
if (resize_filter == (ResizeFilter *) NULL)
{
(void) ThrowMagickException(resample_filter->exception,GetMagickModule(),
extern MagickExport void
ScaleResampleFilter(ResampleFilter *,const double,const double,const double,
const double),
- SetResampleFilter(ResampleFilter *,const FilterTypes,const double);
+ SetResampleFilter(ResampleFilter *,const FilterTypes);
#if defined(__cplusplus) || defined(c_plusplus)
}
GetResizeFilterWeight(const ResizeFilter *,const MagickRealType);
extern MagickPrivate ResizeFilter
- *AcquireResizeFilter(const Image *,const FilterTypes,const MagickRealType,
- const MagickBooleanType,ExceptionInfo *),
+ *AcquireResizeFilter(const Image *,const FilterTypes,const MagickBooleanType,
+ ExceptionInfo *),
*DestroyResizeFilter(ResizeFilter *);
#if defined(__cplusplus) || defined(c_plusplus)
% The format of the AcquireResizeFilter method is:
%
% ResizeFilter *AcquireResizeFilter(const Image *image,
-% const FilterTypes filter_type, const MagickBooleanType radial,
+% const FilterTypes filter_type,const MagickBooleanType radial,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
*/
MagickPrivate ResizeFilter *AcquireResizeFilter(const Image *image,
- const FilterTypes filter,const MagickRealType blur,
- const MagickBooleanType cylindrical,ExceptionInfo *exception)
+ const FilterTypes filter,const MagickBooleanType cylindrical,
+ ExceptionInfo *exception)
{
const char
*artifact;
*/
filter_type=mapping[filter].filter;
window_type=mapping[filter].window;
- resize_filter->blur = blur; /* function argument blur factor */
/* Promote 1D Windowed Sinc Filters to a 2D Windowed Jinc filters */
if ((cylindrical != MagickFalse) && (filter_type == SincFastFilter) &&
(filter != SincFastFilter))
if ((columns == image->columns) && (rows == image->rows))
return(CloneImage(image,0,0,MagickTrue,exception));
if ((columns <= 2) || (rows <= 2))
- return(ResizeImage(image,columns,rows,image->filter,image->blur,exception));
+ return(ResizeImage(image,columns,rows,image->filter,exception));
if ((columns >= (2*image->columns)) || (rows >= (2*image->rows)))
{
Image
*/
for (width=image->columns; columns >= (2*width-1); width*=2);
for (height=image->rows; rows >= (2*height-1); height*=2);
- resize_image=ResizeImage(image,width,height,image->filter,image->blur,
- exception);
+ resize_image=ResizeImage(image,width,height,image->filter,exception);
if (resize_image == (Image *) NULL)
return((Image *) NULL);
rescale_image=LiquidRescaleImage(resize_image,columns,rows,delta_x,
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
magnify_image=ResizeImage(image,2*image->columns,2*image->rows,CubicFilter,
- 1.0,exception);
+ exception);
return(magnify_image);
}
\f
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
- minify_image=ResizeImage(image,image->columns/2,image->rows/2,CubicFilter,1.0,
+ minify_image=ResizeImage(image,image->columns/2,image->rows/2,CubicFilter,
exception);
return(minify_image);
}
% The format of the ResampleImage method is:
%
% Image *ResampleImage(Image *image,const double x_resolution,
-% const double y_resolution,const FilterTypes filter,const double blur,
+% const double y_resolution,const FilterTypes filter,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o filter: Image filter to use.
%
-% o blur: the blur factor where > 1 is blurry, < 1 is sharp.
+% o exception: return any errors or warnings in this structure.
%
*/
MagickExport Image *ResampleImage(const Image *image,const double x_resolution,
- const double y_resolution,const FilterTypes filter,const double blur,
- ExceptionInfo *exception)
+ const double y_resolution,const FilterTypes filter,ExceptionInfo *exception)
{
#define ResampleImageTag "Resample/Image"
72.0 : image->resolution.x)+0.5);
height=(size_t) (y_resolution*image->rows/(image->resolution.y == 0.0 ?
72.0 : image->resolution.y)+0.5);
- resample_image=ResizeImage(image,width,height,filter,blur,exception);
+ resample_image=ResizeImage(image,width,height,filter,exception);
if (resample_image != (Image *) NULL)
{
resample_image->resolution.x=x_resolution;
}
MagickExport Image *ResizeImage(const Image *image,const size_t columns,
- const size_t rows,const FilterTypes filter,const double blur,
- ExceptionInfo *exception)
+ const size_t rows,const FilterTypes filter,ExceptionInfo *exception)
{
#define WorkLoadFactor 0.265
if ((columns == 0) || (rows == 0))
ThrowImageException(ImageError,"NegativeOrZeroImageSize");
if ((columns == image->columns) && (rows == image->rows) &&
- (filter == UndefinedFilter) && (blur == 1.0))
+ (filter == UndefinedFilter))
return(CloneImage(image,0,0,MagickTrue,exception));
resize_image=CloneImage(image,columns,rows,MagickTrue,exception);
if (resize_image == (Image *) NULL)
if ((image->storage_class == PseudoClass) ||
(image->matte != MagickFalse) || ((x_factor*y_factor) > 1.0))
filter_type=MitchellFilter;
- resize_filter=AcquireResizeFilter(image,filter_type,blur,MagickFalse,
- exception);
+ resize_filter=AcquireResizeFilter(image,filter_type,MagickFalse,exception);
/*
Resize image.
*/
x_factor=(MagickRealType) columns/(MagickRealType) image->columns;
y_factor=(MagickRealType) rows/(MagickRealType) image->rows;
if ((x_factor*y_factor) > 0.1)
- thumbnail_image=ResizeImage(image,columns,rows,image->filter,image->blur,
- exception);
+ thumbnail_image=ResizeImage(image,columns,rows,image->filter,exception);
else
if (((SampleFactor*columns) < 128) || ((SampleFactor*rows) < 128))
- thumbnail_image=ResizeImage(image,columns,rows,image->filter,
- image->blur,exception);
+ thumbnail_image=ResizeImage(image,columns,rows,image->filter,exception);
else
{
Image
if (sample_image == (Image *) NULL)
return((Image *) NULL);
thumbnail_image=ResizeImage(sample_image,columns,rows,image->filter,
- image->blur,exception);
+ exception);
sample_image=DestroyImage(sample_image);
}
if (thumbnail_image == (Image *) NULL)
*MagnifyImage(const Image *,ExceptionInfo *),
*MinifyImage(const Image *,ExceptionInfo *),
*ResampleImage(const Image *,const double,const double,const FilterTypes,
- const double,ExceptionInfo *),
+ ExceptionInfo *),
*ResizeImage(const Image *,const size_t,const size_t,const FilterTypes,
- const double,ExceptionInfo *),
+ ExceptionInfo *),
*SampleImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*ScaleImage(const Image *,const size_t,const size_t,ExceptionInfo *),
*ThumbnailImage(const Image *,const size_t,const size_t,ExceptionInfo *);
(transform_image->rows == geometry.height))
return(MagickTrue);
resize_image=ResizeImage(transform_image,geometry.width,geometry.height,
- transform_image->filter,transform_image->blur,exception);
+ transform_image->filter,exception);
if (resize_image == (Image *) NULL)
return(MagickFalse);
transform_image=DestroyImage(transform_image);
#define MagickLibAddendum "-0"
#define MagickLibInterface 7
#define MagickLibMinInterface 7
-#define MagickReleaseDate "2012-03-22"
+#define MagickReleaseDate "2012-03-25"
#define MagickChangeDate "20110801"
#define MagickAuthoritativeURL "http://www.imagemagick.org"
#if defined(MAGICKCORE_OPENMP_SUPPORT)
{ /* get option type and argument count */
const OptionInfo *option_info = GetCommandOptionInfo(option);
count=option_info->type;
- option_type=option_info->flags;
+ option_type=(CommandOptionFlags) option_info->flags;
#if MagickCommandDebug >= 2
(void) FormatLocaleFile(stderr, "Script: %u,%u: \"%s\" matched \"%s\"\n",
cli_wand->line, cli_wand->line, option, option_info->mnemonic );
{ const OptionInfo *option_info = GetCommandOptionInfo(argv[i]);
count=option_info->type;
- option_type=option_info->flags;
+ option_type=(CommandOptionFlags) option_info->flags;
#if MagickCommandDebug >= 2
(void) FormatLocaleFile(stderr, "CLI %d: \"%s\" matched \"%s\"\n",
i, argv[i], option_info->mnemonic );
% The format of the MagickAdaptiveBlurImage method is:
%
% MagickBooleanType MagickAdaptiveBlurImage(MagickWand *wand,
-% const double radius,const double sigma,const double bias)
+% const double radius,const double sigma)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
*/
WandExport MagickBooleanType MagickAdaptiveBlurImage(MagickWand *wand,
- const double radius,const double sigma,const double bias)
+ const double radius,const double sigma)
{
Image
*sharp_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- sharp_image=AdaptiveBlurImage(wand->images,radius,sigma,bias,wand->exception);
+ sharp_image=AdaptiveBlurImage(wand->images,radius,sigma,wand->exception);
if (sharp_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,sharp_image);
% The format of the MagickAdaptiveSharpenImage method is:
%
% MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *wand,
-% const double radius,const double sigma,const double bias)
+% const double radius,const double sigma)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
*/
WandExport MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *wand,
- const double radius,const double sigma,const double bias)
+ const double radius,const double sigma)
{
Image
*sharp_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- sharp_image=AdaptiveSharpenImage(wand->images,radius,sigma,bias,
- wand->exception);
+ sharp_image=AdaptiveSharpenImage(wand->images,radius,sigma,wand->exception);
if (sharp_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,sharp_image);
% The format of the MagickBlurImage method is:
%
% MagickBooleanType MagickBlurImage(MagickWand *wand,const double radius,
-% const double sigmaconst double bias)
+% const double sigma)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the , in pixels.
%
-% o bias: the bias.
-%
*/
WandExport MagickBooleanType MagickBlurImage(MagickWand *wand,
- const double radius,const double sigma,const double bias)
+ const double radius,const double sigma)
{
Image
*blur_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- blur_image=BlurImage(wand->images,radius,sigma,bias,wand->exception);
+ blur_image=BlurImage(wand->images,radius,sigma,wand->exception);
if (blur_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,blur_image);
% The format of the MagickCharcoalImage method is:
%
% MagickBooleanType MagickCharcoalImage(MagickWand *wand,
-% const double radius,const double sigma,const double bias)
+% const double radius,const double sigma)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
*/
WandExport MagickBooleanType MagickCharcoalImage(MagickWand *wand,
- const double radius,const double sigma,const double bias)
+ const double radius,const double sigma)
{
Image
*charcoal_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- charcoal_image=CharcoalImage(wand->images,radius,sigma,bias,wand->exception);
+ charcoal_image=CharcoalImage(wand->images,radius,sigma,wand->exception);
if (charcoal_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,charcoal_image);
% The format of the MagickMotionBlurImage method is:
%
% MagickBooleanType MagickMotionBlurImage(MagickWand *wand,
-% const double radius,const double sigma,const double angle,
-% const double bias)
+% const double radius,const double sigma,const double angle)
%
% A description of each parameter follows:
%
%
*/
WandExport MagickBooleanType MagickMotionBlurImage(MagickWand *wand,
- const double radius,const double sigma,const double angle,const double bias)
+ const double radius,const double sigma,const double angle)
{
Image
*blur_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- blur_image=MotionBlurImage(wand->images,radius,sigma,angle,bias,
- wand->exception);
+ blur_image=MotionBlurImage(wand->images,radius,sigma,angle,wand->exception);
if (blur_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,blur_image);
% The format of the MagickRadialBlurImage method is:
%
% MagickBooleanType MagickRadialBlurImage(MagickWand *wand,
-% const double angle,const double bias)
+% const double angle)
%
% A description of each parameter follows:
%
%
% o angle: the angle of the blur in degrees.
%
-% o bias: the bias.
-%
*/
WandExport MagickBooleanType MagickRadialBlurImage(MagickWand *wand,
- const double angle,const double bias)
+ const double angle)
{
Image
*blur_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- blur_image=RadialBlurImage(wand->images,angle,bias,wand->exception);
+ blur_image=RadialBlurImage(wand->images,angle,wand->exception);
if (blur_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,blur_image);
%
% MagickBooleanType MagickResampleImage(MagickWand *wand,
% const double x_resolution,const double y_resolution,
-% const FilterTypes filter,const double blur)
+% const FilterTypes filter)
%
% A description of each parameter follows:
%
%
% o filter: Image filter to use.
%
-% o blur: the blur factor where > 1 is blurry, < 1 is sharp.
-%
*/
WandExport MagickBooleanType MagickResampleImage(MagickWand *wand,
- const double x_resolution,const double y_resolution,const FilterTypes filter,
- const double blur)
+ const double x_resolution,const double y_resolution,const FilterTypes filter)
{
Image
*resample_image;
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
resample_image=ResampleImage(wand->images,x_resolution,y_resolution,filter,
- blur,wand->exception);
+ wand->exception);
if (resample_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,resample_image);
% The format of the MagickResizeImage method is:
%
% MagickBooleanType MagickResizeImage(MagickWand *wand,
-% const size_t columns,const size_t rows,
-% const FilterTypes filter,const double blur)
+% const size_t columns,const size_t rows,const FilterTypes filter)
%
% A description of each parameter follows:
%
%
% o filter: Image filter to use.
%
-% o blur: the blur factor where > 1 is blurry, < 1 is sharp.
-%
*/
WandExport MagickBooleanType MagickResizeImage(MagickWand *wand,
- const size_t columns,const size_t rows,const FilterTypes filter,
- const double blur)
+ const size_t columns,const size_t rows,const FilterTypes filter)
{
Image
*resize_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- resize_image=ResizeImage(wand->images,columns,rows,filter,blur,
- wand->exception);
+ resize_image=ResizeImage(wand->images,columns,rows,filter,wand->exception);
if (resize_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,resize_image);
% The format of the MagickSelectiveBlurImage method is:
%
% MagickBooleanType MagickSelectiveBlurImage(MagickWand *wand,
-% const double radius,const double sigma,const double threshold,
-% const double bias)
+% const double radius,const double sigma,const double threshold)
%
% A description of each parameter follows:
%
% o threshold: only pixels within this contrast threshold are included
% in the blur operation.
%
-% o bias: the bias.
-%
*/
WandExport MagickBooleanType MagickSelectiveBlurImage(MagickWand *wand,
- const double radius,const double sigma,const double threshold,
- const double bias)
+ const double radius,const double sigma,const double threshold)
{
Image
*blur_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- blur_image=SelectiveBlurImage(wand->images,radius,sigma,threshold,bias,
+ blur_image=SelectiveBlurImage(wand->images,radius,sigma,threshold,
wand->exception);
if (blur_image == (Image *) NULL)
return(MagickFalse);
% %
% %
% %
-% M a g i c k S e t I m a g e B i a s %
-% %
-% %
-% %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-% MagickSetImageBias() sets the image bias for any method that convolves an
-% image (e.g. MagickConvolveImage()).
-%
-% The format of the MagickSetImageBias method is:
-%
-% MagickBooleanType MagickSetImageBias(MagickWand *wand,
-% const double bias)
-%
-% A description of each parameter follows:
-%
-% o wand: the magick wand.
-%
-% o bias: the image bias.
-%
-*/
-WandExport MagickBooleanType MagickSetImageBias(MagickWand *wand,
- const double bias)
-{
- assert(wand != (MagickWand *) NULL);
- assert(wand->signature == WandSignature);
- if (wand->debug != MagickFalse)
- (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- if (wand->images == (Image *) NULL)
- ThrowWandException(WandError,"ContainsNoImages",wand->name);
- wand->images->bias=bias;
- return(MagickTrue);
-}
-\f
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% %
-% %
-% %
% M a g i c k S e t I m a g e B l u e P r i m a r y %
% %
% %
%
% The format of the MagickShadowImage method is:
%
-% MagickBooleanType MagickShadowImage(MagickWand *wand,
-% const double alpha,const double sigma,const double bias,
-% const ssize_t x,const ssize_t y)
+% MagickBooleanType MagickShadowImage(MagickWand *wand,const double alpha,
+% const double sigma,const ssize_t x,const ssize_t y)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
% o x: the shadow x-offset.
%
% o y: the shadow y-offset.
%
*/
WandExport MagickBooleanType MagickShadowImage(MagickWand *wand,
- const double alpha,const double sigma,const double bias,const ssize_t x,
- const ssize_t y)
+ const double alpha,const double sigma,const ssize_t x,const ssize_t y)
{
Image
*shadow_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- shadow_image=ShadowImage(wand->images,alpha,sigma,bias,x,y,wand->exception);
+ shadow_image=ShadowImage(wand->images,alpha,sigma,x,y,wand->exception);
if (shadow_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,shadow_image);
% The format of the MagickSharpenImage method is:
%
% MagickBooleanType MagickSharpenImage(MagickWand *wand,
-% const double radius,const double sigma,const double bias)
+% const double radius,const double sigma)
%
% A description of each parameter follows:
%
%
% o sigma: the standard deviation of the Gaussian, in pixels.
%
-% o bias: the bias.
-%
*/
WandExport MagickBooleanType MagickSharpenImage(MagickWand *wand,
- const double radius,const double sigma,const double bias)
+ const double radius,const double sigma)
{
Image
*sharp_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- sharp_image=SharpenImage(wand->images,radius,sigma,bias,wand->exception);
+ sharp_image=SharpenImage(wand->images,radius,sigma,wand->exception);
if (sharp_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,sharp_image);
% The format of the MagickSketchImage method is:
%
% MagickBooleanType MagickSketchImage(MagickWand *wand,
-% const double radius,const double sigma,const double angle,
-% const double bias)
+% const double radius,const double sigma,const double angle)
%
% A description of each parameter follows:
%
%
% o angle: apply the effect along this angle.
%
-% o bias: the bias.
-%
*/
WandExport MagickBooleanType MagickSketchImage(MagickWand *wand,
- const double radius,const double sigma,const double angle,const double bias)
+ const double radius,const double sigma,const double angle)
{
Image
*sketch_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- sketch_image=SketchImage(wand->images,radius,sigma,angle,bias,
- wand->exception);
+ sketch_image=SketchImage(wand->images,radius,sigma,angle,wand->exception);
if (sketch_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,sketch_image);
% The format of the MagickVignetteImage method is:
%
% MagickBooleanType MagickVignetteImage(MagickWand *wand,
-% const double radius,const double sigma,const double bias,
-% const ssize_t x,const ssize_t y)
+% const double radius,const double sigma,const ssize_t x,
+% const ssize_t y)
%
% A description of each parameter follows:
%
%
% o sigma: the sigma.
%
-% o bias: the bias.
-%
% o x, y: Define the x and y ellipse offset.
%
*/
WandExport MagickBooleanType MagickVignetteImage(MagickWand *wand,
- const double radius,const double sigma,const double bias,const ssize_t x,
- const ssize_t y)
+ const double radius,const double sigma,const ssize_t x,const ssize_t y)
{
Image
*vignette_image;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
if (wand->images == (Image *) NULL)
ThrowWandException(WandError,"ContainsNoImages",wand->name);
- vignette_image=VignetteImage(wand->images,radius,sigma,bias,x,y,
- wand->exception);
+ vignette_image=VignetteImage(wand->images,radius,sigma,x,y,wand->exception);
if (vignette_image == (Image *) NULL)
return(MagickFalse);
ReplaceImageInList(&wand->images,vignette_image);
MagickGetImagePixelInterpolateMethod(MagickWand *);
extern WandExport MagickBooleanType
- MagickAdaptiveBlurImage(MagickWand *,const double,const double,const double),
+ MagickAdaptiveBlurImage(MagickWand *,const double,const double),
MagickAdaptiveResizeImage(MagickWand *,const size_t,const size_t),
- MagickAdaptiveSharpenImage(MagickWand *,const double,const double,
- const double),
+ MagickAdaptiveSharpenImage(MagickWand *,const double,const double),
MagickAdaptiveThresholdImage(MagickWand *,const size_t,const size_t,
const double),
MagickAddImage(MagickWand *,const MagickWand *),
MagickAutoLevelImage(MagickWand *),
MagickBlackThresholdImage(MagickWand *,const PixelWand *),
MagickBlueShiftImage(MagickWand *,const double),
- MagickBlurImage(MagickWand *,const double,const double,const double),
+ MagickBlurImage(MagickWand *,const double,const double),
MagickBorderImage(MagickWand *,const PixelWand *,const size_t,const size_t,
const CompositeOperator compose),
MagickBrightnessContrastImage(MagickWand *,const double,const double),
- MagickCharcoalImage(MagickWand *,const double,const double,const double),
+ MagickCharcoalImage(MagickWand *,const double,const double),
MagickChopImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t),
MagickClampImage(MagickWand *),
MagickModulateImage(MagickWand *,const double,const double,const double),
MagickMorphologyImage(MagickWand *,MorphologyMethod,const ssize_t,
KernelInfo *),
- MagickMotionBlurImage(MagickWand *,const double,const double,const double,
- const double),
+ MagickMotionBlurImage(MagickWand *,const double,const double,const double),
MagickNegateImage(MagickWand *,const MagickBooleanType),
MagickNewImage(MagickWand *,const size_t,const size_t,const PixelWand *),
MagickNextImage(MagickWand *),
const size_t,const MagickBooleanType,const MagickBooleanType),
MagickQuantizeImages(MagickWand *,const size_t,const ColorspaceType,
const size_t,const MagickBooleanType,const MagickBooleanType),
- MagickRadialBlurImage(MagickWand *,const double,const double),
+ MagickRadialBlurImage(MagickWand *,const double),
MagickRaiseImage(MagickWand *,const size_t,const size_t,const ssize_t,
const ssize_t,const MagickBooleanType),
MagickRandomThresholdImage(MagickWand *,const double,const double),
MagickReduceNoiseImage(MagickWand *,const double),
MagickRemapImage(MagickWand *,const MagickWand *,const DitherMethod),
MagickRemoveImage(MagickWand *),
- MagickResampleImage(MagickWand *,const double,const double,const FilterTypes,
- const double),
+ MagickResampleImage(MagickWand *,const double,const double,const FilterTypes),
MagickResetImagePage(MagickWand *,const char *),
- MagickResizeImage(MagickWand *,const size_t,const size_t,const FilterTypes,
- const double),
+ MagickResizeImage(MagickWand *,const size_t,const size_t,const FilterTypes),
MagickRollImage(MagickWand *,const ssize_t,const ssize_t),
MagickRotateImage(MagickWand *,const PixelWand *,const double),
MagickSampleImage(MagickWand *,const size_t,const size_t),
MagickScaleImage(MagickWand *,const size_t,const size_t),
MagickSegmentImage(MagickWand *,const ColorspaceType,const MagickBooleanType,
const double,const double),
- MagickSelectiveBlurImage(MagickWand *,const double,const double,const double,
- const double),
+ MagickSelectiveBlurImage(MagickWand *,const double,const double,const double),
MagickSeparateImage(MagickWand *,const ChannelType),
MagickSepiaToneImage(MagickWand *,const double),
MagickSetImage(MagickWand *,const MagickWand *),
MagickSetImageAlphaChannel(MagickWand *,const AlphaChannelType),
MagickSetImageBackgroundColor(MagickWand *,const PixelWand *),
- MagickSetImageBias(MagickWand *,const double),
MagickSetImageBluePrimary(MagickWand *,const double,const double),
MagickSetImageBorderColor(MagickWand *,const PixelWand *),
MagickSetImageClipMask(MagickWand *,const MagickWand *),
MagickSetImageWhitePoint(MagickWand *,const double,const double),
MagickShadeImage(MagickWand *,const MagickBooleanType,const double,
const double),
- MagickShadowImage(MagickWand *,const double,const double,const double,
- const ssize_t,const ssize_t),
- MagickSharpenImage(MagickWand *,const double,const double,const double),
+ MagickShadowImage(MagickWand *,const double,const double,const ssize_t,
+ const ssize_t),
+ MagickSharpenImage(MagickWand *,const double,const double),
MagickShaveImage(MagickWand *,const size_t,const size_t),
MagickShearImage(MagickWand *,const PixelWand *,const double,const double),
MagickSigmoidalContrastImage(MagickWand *,const MagickBooleanType,
const double,const double),
- MagickSketchImage(MagickWand *,const double,const double,const double,
- const double),
+ MagickSketchImage(MagickWand *,const double,const double,const double),
MagickSolarizeImage(MagickWand *,const double),
MagickSparseColorImage(MagickWand *,const SparseColorMethod,const size_t,
const double *),
MagickUniqueImageColors(MagickWand *),
MagickUnsharpMaskImage(MagickWand *,const double,const double,const double,
const double),
- MagickVignetteImage(MagickWand *,const double,const double,const double,
- const ssize_t,const ssize_t),
+ MagickVignetteImage(MagickWand *,const double,const double,const ssize_t,
+ const ssize_t),
MagickWaveImage(MagickWand *,const double,const double,
const PixelInterpolateMethod),
MagickWhiteThresholdImage(MagickWand *,const PixelWand *),
#include "MagickCore/string-private.h"
#include "MagickCore/thread-private.h"
#include "MagickCore/utility-private.h"
-\f
+cache\f
/*
Constant declaration.
*/
flags=ParseGeometry(argv[i+1],&geometry_info);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
- if ((flags & XiValue) == 0)
- geometry_info.xi=0.0;
mogrify_image=AdaptiveBlurImage(*image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,exception);
+ geometry_info.sigma,exception);
break;
}
if (LocaleCompare("adaptive-resize",option+1) == 0)
flags=ParseGeometry(argv[i+1],&geometry_info);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
- if ((flags & XiValue) == 0)
- geometry_info.xi=0.0;
mogrify_image=AdaptiveSharpenImage(*image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,exception);
+ geometry_info.sigma,exception);
break;
}
if (LocaleCompare("affine",option+1) == 0)
if ((flags & XiValue) == 0)
geometry_info.xi=0.0;
mogrify_image=BlurImage(*image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,exception);
+ geometry_info.sigma,exception);
break;
}
if (LocaleCompare("border",option+1) == 0)
if ((flags & XiValue) == 0)
geometry_info.xi=1.0;
mogrify_image=CharcoalImage(*image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,exception);
+ geometry_info.sigma,exception);
break;
}
if (LocaleCompare("chop",option+1) == 0)
kernel_info=AcquireKernelInfo(argv[i+1]);
if (kernel_info == (KernelInfo *) NULL)
break;
- kernel_info->bias=(*image)->bias;
mogrify_image=ConvolveImage(*image,kernel_info,exception);
kernel_info=DestroyKernelInfo(kernel_info);
break;
(void) CloneString(&(*image)->geometry,argv[i+1]);
else
mogrify_image=ResizeImage(*image,geometry.width,geometry.height,
- (*image)->filter,(*image)->blur,exception);
+ (*image)->filter,exception);
break;
}
if (LocaleCompare("gravity",option+1) == 0)
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
mogrify_image=MotionBlurImage(*image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
+ geometry_info.sigma,geometry_info.xi,exception);
break;
}
break;
*/
(void) SyncImageSettings(mogrify_info,*image,exception);
flags=ParseGeometry(argv[i+1],&geometry_info);
- mogrify_image=RadialBlurImage(*image,geometry_info.rho,
- geometry_info.sigma,exception);
+ mogrify_image=RadialBlurImage(*image,geometry_info.rho,exception);
break;
}
if (LocaleCompare("raise",option+1) == 0)
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
mogrify_image=ResampleImage(*image,geometry_info.rho,
- geometry_info.sigma,(*image)->filter,(*image)->blur,exception);
+ geometry_info.sigma,(*image)->filter,exception);
break;
}
if (LocaleCompare("resize",option+1) == 0)
(void) SyncImageSettings(mogrify_info,*image,exception);
(void) ParseRegionGeometry(*image,argv[i+1],&geometry,exception);
mogrify_image=ResizeImage(*image,geometry.width,geometry.height,
- (*image)->filter,(*image)->blur,exception);
+ (*image)->filter,exception);
break;
}
if (LocaleCompare("roll",option+1) == 0)
if ((flags & PercentValue) != 0)
geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
mogrify_image=SelectiveBlurImage(*image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
+ geometry_info.sigma,geometry_info.xi,exception);
break;
}
if (LocaleCompare("separate",option+1) == 0)
if ((flags & PsiValue) == 0)
geometry_info.psi=4.0;
mogrify_image=ShadowImage(*image,geometry_info.rho,
- geometry_info.sigma,(*image)->bias,(ssize_t)
- ceil(geometry_info.xi-0.5),(ssize_t) ceil(geometry_info.psi-0.5),
- exception);
+ geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),
+ (ssize_t) ceil(geometry_info.psi-0.5),exception);
break;
}
if (LocaleCompare("sharpen",option+1) == 0)
if ((flags & XiValue) == 0)
geometry_info.xi=0.0;
mogrify_image=SharpenImage(*image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,exception);
+ geometry_info.sigma,exception);
break;
}
if (LocaleCompare("shave",option+1) == 0)
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
mogrify_image=SketchImage(*image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,geometry_info.psi,exception);
+ geometry_info.sigma,geometry_info.xi,exception);
break;
}
if (LocaleCompare("solarize",option+1) == 0)
if ((flags & PsiValue) == 0)
geometry_info.psi=0.1*(*image)->rows;
mogrify_image=VignetteImage(*image,geometry_info.rho,
- geometry_info.sigma,(*image)->bias,(ssize_t)
- ceil(geometry_info.xi-0.5),(ssize_t) ceil(geometry_info.psi-0.5),
- exception);
+ geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),
+ (ssize_t) ceil(geometry_info.psi-0.5),exception);
break;
}
if (LocaleCompare("virtual-pixel",option+1) == 0)
if (parse < 0)
CLIWandExceptArgBreak(OptionError,"UnrecognizedEndianType",
option,arg1);
- _image_info->endian=(EndianType) arg1;
+ _image_info->endian=(EndianType) (*arg1);
(void) SetImageOption(_image_info,option+1,arg1);
break;
}
flags=ParseGeometry(arg1,&geometry_info);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
- if ((flags & XiValue) == 0)
- geometry_info.xi=0.0;
new_image=AdaptiveBlurImage(_image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,_exception);
+ geometry_info.sigma,_exception);
break;
}
if (LocaleCompare("adaptive-resize",option+1) == 0)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
(void) ParseRegionGeometry(_image,arg1,&geometry,_exception);
new_image=AdaptiveResizeImage(_image,geometry.width,geometry.height,
- _exception);
+ _exception);
break;
}
if (LocaleCompare("adaptive-sharpen",option+1) == 0)
flags=ParseGeometry(arg1,&geometry_info);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
- if ((flags & XiValue) == 0)
- geometry_info.xi=0.0;
new_image=AdaptiveSharpenImage(_image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,_exception);
+ geometry_info.sigma,_exception);
break;
}
if (LocaleCompare("alpha",option+1) == 0)
}
if (LocaleCompare("blur",option+1) == 0)
{
- /* FUTURE: use of "bias" in a blur is non-sensible */
if (IsGeometry(arg1) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
- if ((flags & XiValue) == 0)
- geometry_info.xi=0.0;
- new_image=BlurImage(_image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,_exception);
+ new_image=BlurImage(_image,geometry_info.rho,geometry_info.sigma,
+ _exception);
break;
}
if (LocaleCompare("border",option+1) == 0)
if ((flags & XiValue) == 0)
geometry_info.xi=1.0;
new_image=CharcoalImage(_image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,_exception);
+ geometry_info.sigma,_exception);
break;
}
if (LocaleCompare("chop",option+1) == 0)
kernel_info=AcquireKernelInfo(arg1);
if (kernel_info == (KernelInfo *) NULL)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
- kernel_info->bias=_image->bias;
new_image=ConvolveImage(_image,kernel_info,_exception);
kernel_info=DestroyKernelInfo(kernel_info);
break;
(void) CloneString(&_image->geometry,arg1);
else
new_image=ResizeImage(_image,geometry.width,geometry.height,
- _image->filter,_image->blur,_exception);
+ _image->filter,_exception);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=MotionBlurImage(_image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,geometry_info.psi,
- _exception);
+ geometry_info.sigma,geometry_info.xi,_exception);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
if (IsGeometry(arg1) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
- new_image=RadialBlurImage(_image,geometry_info.rho,
- geometry_info.sigma,_exception);
+ new_image=RadialBlurImage(_image,geometry_info.rho,_exception);
break;
}
if (LocaleCompare("raise",option+1) == 0)
}
if (LocaleCompare("resample",option+1) == 0)
{
- /* FUTURE: remove blur arguemnt - no longer used
- Roll into a resize special operation */
+ /* Roll into a resize special operation */
if (IsGeometry(arg1) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
new_image=ResampleImage(_image,geometry_info.rho,
- geometry_info.sigma,_image->filter,_image->blur,_exception);
+ geometry_info.sigma,_image->filter,_exception);
break;
}
if (LocaleCompare("resize",option+1) == 0)
{
- /* FUTURE: remove blur argument - no longer used */
if (IsGeometry(arg1) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
(void) ParseRegionGeometry(_image,arg1,&geometry,_exception);
new_image=ResizeImage(_image,geometry.width,geometry.height,
- _image->filter,_image->blur,_exception);
+ _image->filter,_exception);
break;
}
if (LocaleCompare("roll",option+1) == 0)
if ((flags & PercentValue) != 0)
geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
new_image=SelectiveBlurImage(_image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,geometry_info.psi,_exception);
+ geometry_info.sigma,geometry_info.xi,_exception);
break;
}
if (LocaleCompare("separate",option+1) == 0)
geometry_info.xi=4.0;
if ((flags & PsiValue) == 0)
geometry_info.psi=4.0;
- new_image=ShadowImage(_image,geometry_info.rho,
- geometry_info.sigma,_image->bias,(ssize_t)
- ceil(geometry_info.xi-0.5),(ssize_t) ceil(geometry_info.psi-0.5),
- _exception);
+ new_image=ShadowImage(_image,geometry_info.rho,geometry_info.sigma,
+ (ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
+ ceil(geometry_info.psi-0.5),_exception);
break;
}
if (LocaleCompare("sharpen",option+1) == 0)
geometry_info.sigma=1.0;
if ((flags & XiValue) == 0)
geometry_info.xi=0.0;
- new_image=SharpenImage(_image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,_exception);
+ new_image=SharpenImage(_image,geometry_info.rho,geometry_info.sigma,
+ _exception);
break;
}
if (LocaleCompare("shave",option+1) == 0)
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=SketchImage(_image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,geometry_info.psi,_exception);
+ geometry_info.sigma,geometry_info.xi,_exception);
break;
}
if (LocaleCompare("solarize",option+1) == 0)
if ((flags & PsiValue) == 0)
geometry_info.psi=0.1*_image->rows;
new_image=VignetteImage(_image,geometry_info.rho,geometry_info.sigma,
- _image->bias,(ssize_t) ceil(geometry_info.xi-0.5),
- (ssize_t) ceil(geometry_info.psi-0.5),_exception);
+ (ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
+ ceil(geometry_info.psi-0.5),_exception);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
Stack
*node;
- node = (void *)cli_wand->image_list_stack;
+ node = (Stack *)cli_wand->image_list_stack;
if ( node == (Stack *)NULL)
CLIWandExceptionReturn(OptionError,"UnbalancedParenthesis",option);
cli_wand->image_list_stack = node->next;
Stack
*node;
- node = (void *)cli_wand->image_info_stack;
+ node = (Stack *)cli_wand->image_info_stack;
if ( node == (Stack *)NULL)
CLIWandExceptionReturn(OptionError,"UnbalancedCurlyBraces",option);
cli_wand->image_info_stack = node->next;
fclose(token_info->stream);
if (token_info->token != (char *) NULL )
- token_info->token=RelinquishMagickMemory(token_info->token);
+ token_info->token=(char *) RelinquishMagickMemory(token_info->token);
token_info=(ScriptTokenInfo *) RelinquishMagickMemory(token_info);
return(token_info);
}
{"bordercolor", StringReference}, {"color", StringReference},
{"compose", MagickComposeOptions} } },
{ "Blur", { {"geometry", StringReference}, {"radius", RealReference},
- {"sigma", RealReference}, {"bias", RealReference},
- {"channel", MagickChannelOptions} } },
+ {"sigma", RealReference}, {"channel", MagickChannelOptions} } },
{ "Chop", { {"geometry", StringReference}, {"width", IntegerReference},
{"height", IntegerReference}, {"x", IntegerReference},
{"y", IntegerReference} } },
{ "Shade", { {"geometry", StringReference}, {"azimuth", RealReference},
{"elevation", RealReference}, {"gray", MagickBooleanOptions} } },
{ "Sharpen", { {"geometry", StringReference}, {"radius", RealReference},
- {"sigma", RealReference}, {"bias", RealReference},
- {"channel", MagickChannelOptions} } },
+ {"sigma", RealReference}, {"channel", MagickChannelOptions} } },
{ "Shear", { {"geometry", StringReference}, {"x", RealReference},
{"y", RealReference}, { "fill", StringReference},
{"color", StringReference} } },
{"interpolate", MagickInterpolateOptions} } },
{ "Resize", { {"geometry", StringReference}, {"width", IntegerReference},
{"height", IntegerReference}, {"filter", MagickFilterOptions},
- {"support", StringReference }, {"blur", RealReference } } },
+ {"support", StringReference } } },
{ "Zoom", { {"geometry", StringReference}, {"width", IntegerReference},
{"height", IntegerReference}, {"filter", MagickFilterOptions},
- {"support", RealReference }, {"blur", RealReference } } },
+ {"support", RealReference } } },
{ "Annotate", { {"text", StringReference}, {"font", StringReference},
{"pointsize", RealReference}, {"density", StringReference},
{"undercolor", StringReference}, {"stroke", StringReference},
{ "Threshold", { {"threshold", StringReference},
{"channel", MagickChannelOptions} } },
{ "Charcoal", { {"geometry", StringReference}, {"radius", RealReference},
- {"sigma", RealReference}, {"biabias", RealReference} } },
+ {"sigma", RealReference} } },
{ "Trim", { {"fuzz", StringReference} } },
{ "Wave", { {"geometry", StringReference}, {"amplitude", RealReference},
{"wavelength", RealReference},
{"channel", MagickChannelOptions} } },
{ "MotionBlur", { {"geometry", StringReference},
{"radius", RealReference}, {"sigma", RealReference},
- {"angle", RealReference}, {"bias", RealReference},
- {"channel", MagickChannelOptions} } },
+ {"angle", RealReference}, {"channel", MagickChannelOptions} } },
{ "OrderedDither", { {"threshold", StringReference},
{"channel", MagickChannelOptions} } },
{ "Shave", { {"geometry", StringReference}, {"width", IntegerReference},
{"background", StringReference} } },
{ "Difference", { {"image", ImageReference}, {"fuzz", StringReference} } },
{ "AdaptiveThreshold", { {"geometry", StringReference},
- {"width", IntegerReference}, {"height", IntegerReference},
- {"bias", RealReference} } },
+ {"width", IntegerReference}, {"height", IntegerReference} } },
{ "Resample", { {"density", StringReference}, {"x", RealReference},
{"y", RealReference}, {"filter", MagickFilterOptions},
- {"support", RealReference }, {"blur", RealReference } } },
+ {"support", RealReference } } },
{ "Describe", { {"file", FileReference} } },
{ "BlackThreshold", { {"threshold", StringReference},
{"channel", MagickChannelOptions} } },
{ "WhiteThreshold", { {"threshold", StringReference},
{"channel", MagickChannelOptions} } },
{ "RadialBlur", { {"geometry", StringReference}, {"angle", RealReference},
- {"bias", RealReference}, {"channel", MagickChannelOptions} } },
+ {"channel", MagickChannelOptions} } },
{ "Thumbnail", { {"geometry", StringReference}, {"width", IntegerReference},
{"height", IntegerReference} } },
{ "Strip", },
{ "AutoOrient", },
{ "AdaptiveBlur", { {"geometry", StringReference},
{"radius", RealReference}, {"sigma", RealReference},
- {"bias", RealReference}, {"channel", MagickChannelOptions} } },
+ {"channel", MagickChannelOptions} } },
{ "Sketch", { {"geometry", StringReference},
{"radius", RealReference}, {"sigma", RealReference},
- {"angle", RealReference}, {"bias", RealReference} } },
+ {"angle", RealReference} } },
{ "UniqueColors", },
{ "AdaptiveResize", { {"geometry", StringReference},
{"width", IntegerReference}, {"height", IntegerReference},
{"virtual-pixel", MagickVirtualPixelOptions} } },
{ "SelectiveBlur", { {"geometry", StringReference},
{"radius", RealReference}, {"sigma", RealReference},
- {"threshold", RealReference}, {"bias", RealReference},
- {"channel", MagickChannelOptions} } },
+ {"threshold", RealReference}, {"channel", MagickChannelOptions} } },
{ "HaldClut", { {"image", ImageReference},
{"channel", MagickChannelOptions} } },
{ "BlueShift", { {"factor", StringReference} } },
image->background_color=target_color;
break;
}
- if (LocaleCompare(attribute,"bias") == 0)
- {
- for ( ; image; image=image->next)
- image->bias=StringToDoubleInterval(SvPV(sval,na),(double)
- QuantumRange+1.0);
- break;
- }
if (LocaleCompare(attribute,"blue-primary") == 0)
{
for ( ; image; image=image->next)
PUSHs(s ? sv_2mortal(s) : &sv_undef);
continue;
}
- if (LocaleCompare(attribute,"bias") == 0)
- {
- if (image != (Image *) NULL)
- s=newSVnv(image->bias);
- PUSHs(s ? sv_2mortal(s) : &sv_undef);
- continue;
- }
if (LocaleCompare(attribute,"blue-primary") == 0)
{
if (image == (Image *) NULL)
if (attribute_flag[2] != 0)
geometry_info.sigma=argument_list[2].real_reference;
if (attribute_flag[3] != 0)
- geometry_info.xi=argument_list[3].real_reference;
- if (attribute_flag[4] != 0)
- channel=(ChannelType) argument_list[4].integer_reference;
+ channel=(ChannelType) argument_list[3].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
image=BlurImage(image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,exception);
+ exception);
if (image != (Image *) NULL)
(void) SetPixelChannelMask(image,channel_mask);
break;
if (attribute_flag[2] != 0)
geometry_info.sigma=argument_list[2].real_reference;
if (attribute_flag[3] != 0)
- geometry_info.xi=argument_list[3].real_reference;
- if (attribute_flag[4] != 0)
- channel=(ChannelType) argument_list[4].integer_reference;
+ channel=(ChannelType) argument_list[3].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
image=SharpenImage(image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,exception);
+ exception);
if (image != (Image *) NULL)
(void) SetPixelChannelMask(image,channel_mask);
break;
if (attribute_flag[4] != 0)
SetImageArtifact(image,"filter:support",
argument_list[4].string_reference);
- if (attribute_flag[5] == 0)
- argument_list[5].real_reference=1.0;
image=ResizeImage(image,geometry.width,geometry.height,
(FilterTypes) argument_list[3].integer_reference,
- argument_list[5].real_reference,exception);
+ exception);
break;
}
case 33: /* Annotate */
geometry_info.rho=argument_list[1].real_reference;
if (attribute_flag[2] != 0)
geometry_info.sigma=argument_list[2].real_reference;
- if (attribute_flag[3] != 0)
- geometry_info.xi=argument_list[3].real_reference;
image=CharcoalImage(image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,exception);
+ exception);
break;
}
case 59: /* Trim */
if (attribute_flag[1] != 0)
channel=(ChannelType) argument_list[1].integer_reference;
if (attribute_flag[2] != 0)
- image->bias=StringToDoubleInterval(
- argument_list[2].string_reference,(double) QuantumRange+1.0);
+ SetImageArtifact(image,"filter:blur",
+ argument_list[2].string_reference);
if (attribute_flag[3] != 0)
{
kernel=AcquireKernelInfo(argument_list[3].string_reference);
break;
}
channel_mask=SetPixelChannelMask(image,channel);
- kernel->bias=image->bias;
image=ConvolveImage(image,kernel,exception);
if (image != (Image *) NULL)
(void) SetPixelChannelMask(image,channel_mask);
if (attribute_flag[3] != 0)
geometry_info.xi=argument_list[3].real_reference;
if (attribute_flag[4] != 0)
- geometry_info.psi=argument_list[4].real_reference;
- if (attribute_flag[5] != 0)
- channel=(ChannelType) argument_list[5].integer_reference;
+ channel=(ChannelType) argument_list[4].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
image=MotionBlurImage(image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,geometry_info.psi,exception);
+ geometry_info.xi,exception);
if (image != (Image *) NULL)
(void) SetPixelChannelMask(image,channel_mask);
break;
if (attribute_flag[4] == 0)
SetImageArtifact(image,"filter:support",
argument_list[4].string_reference);
- if (attribute_flag[5] != 0)
- argument_list[5].real_reference=1.0;
width=(size_t) (geometry_info.rho*image->columns/
(image->resolution.x == 0.0 ? 72.0 : image->resolution.x)+0.5);
height=(size_t) (geometry_info.sigma*image->rows/
(image->resolution.y == 0.0 ? 72.0 : image->resolution.y)+0.5);
image=ResizeImage(image,width,height,(FilterTypes)
- argument_list[3].integer_reference,argument_list[5].real_reference,
- exception);
+ argument_list[3].integer_reference,exception);
if (image != (Image *) NULL)
{
image->resolution.x=geometry_info.rho;
if (attribute_flag[1] != 0)
geometry_info.rho=argument_list[1].real_reference;
if (attribute_flag[2] != 0)
- geometry_info.sigma=argument_list[2].real_reference;
- if (attribute_flag[3] != 0)
- channel=(ChannelType) argument_list[3].integer_reference;
+ channel=(ChannelType) argument_list[2].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
- image=RadialBlurImage(image,geometry_info.rho,geometry_info.sigma,
- exception);
+ image=RadialBlurImage(image,geometry_info.rho,exception);
if (image != (Image *) NULL)
(void) SetPixelChannelMask(image,channel_mask);
break;
geometry_info.xi=argument_list[3].integer_reference;
if (attribute_flag[4] != 0)
geometry_info.psi=argument_list[4].integer_reference;
- image=ShadowImage(image,geometry_info.rho,geometry_info.sigma,0.0,
+ image=ShadowImage(image,geometry_info.rho,geometry_info.sigma,
(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
ceil(geometry_info.psi-0.5),exception);
break;
if (attribute_flag[5] != 0)
(void) QueryColorCompliance(argument_list[5].string_reference,
AllCompliance,&image->background_color,exception);
- image=VignetteImage(image,geometry_info.rho,geometry_info.sigma,0.0,
+ image=VignetteImage(image,geometry_info.rho,geometry_info.sigma,
(ssize_t) ceil(geometry_info.xi-0.5),(ssize_t)
ceil(geometry_info.psi-0.5),exception);
break;
channel=(ChannelType) argument_list[4].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
image=AdaptiveSharpenImage(image,geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,exception);
+ geometry_info.sigma,exception);
if (image != (Image *) NULL)
(void) SetPixelChannelMask(image,channel_mask);
break;
if (attribute_flag[2] != 0)
geometry_info.sigma=argument_list[2].real_reference;
if (attribute_flag[3] != 0)
- geometry_info.xi=argument_list[3].real_reference;
- if (attribute_flag[4] != 0)
- channel=(ChannelType) argument_list[4].integer_reference;
+ channel=(ChannelType) argument_list[3].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
image=AdaptiveBlurImage(image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,exception);
+ exception);
if (image != (Image *) NULL)
(void) SetPixelChannelMask(image,channel_mask);
break;
geometry_info.sigma=argument_list[2].real_reference;
if (attribute_flag[3] != 0)
geometry_info.xi=argument_list[3].real_reference;
- if (attribute_flag[4] != 0)
- geometry_info.psi=argument_list[4].real_reference;
image=SketchImage(image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,geometry_info.psi,exception);
+ geometry_info.xi,exception);
break;
}
case 104: /* UniqueColors */
if (attribute_flag[4] != 0)
SetImageArtifact(image,"filter:support",
argument_list[4].string_reference);
- if (attribute_flag[5] != 0)
- image->blur=argument_list[5].real_reference;
image=AdaptiveResizeImage(image,geometry.width,geometry.height,
exception);
break;
geometry_info.sigma=argument_list[2].real_reference;
if (attribute_flag[3] != 0)
geometry_info.xi=argument_list[3].integer_reference;;
- if (attribute_flag[4] != 0)
- geometry_info.psi=argument_list[4].integer_reference;;
if (attribute_flag[5] != 0)
channel=(ChannelType) argument_list[5].integer_reference;
channel_mask=SetPixelChannelMask(image,channel);
image=SelectiveBlurImage(image,geometry_info.rho,geometry_info.sigma,
- geometry_info.xi,geometry_info.psi,exception);
+ geometry_info.xi,exception);
if (image != (Image *) NULL)
(void) SetPixelChannelMask(image,channel_mask);
break;
status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
if (status == MagickFalse)
return(status);
- hrz_image=ResizeImage(image,256,240,image->filter,image->blur,exception);
+ hrz_image=ResizeImage(image,256,240,image->filter,exception);
if (hrz_image == (Image *) NULL)
return(MagickFalse);
if (IsRGBColorspace(hrz_image->colorspace) == MagickFalse)
}
channel_mask=SetPixelChannelMask(msl_info->image[n],channel);
blur_image=BlurImage(msl_info->image[n],geometry_info.rho,
- geometry_info.sigma,geometry_info.xi,
- msl_info->exception);
+ geometry_info.sigma,msl_info->exception);
(void) SetPixelChannelMapMask(msl_info->image[n],channel_mask);
if (blur_image == (Image *) NULL)
break;
}
if (LocaleCompare((const char *) tag, "charcoal") == 0)
{
- double bias = 0.0,
+ double
radius = 0.0,
sigma = 1.0;
msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
- case 'B':
- case 'b':
- {
- if (LocaleCompare(keyword, "bias") == 0)
- {
- bias=StringToDouble(value,(char **) NULL);
- break;
- }
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
- break;
- }
case 'R':
case 'r':
{
Image
*newImage;
- newImage=CharcoalImage(msl_info->image[n],radius,sigma,bias,
+ newImage=CharcoalImage(msl_info->image[n],radius,sigma,
msl_info->exception);
if (newImage == (Image *) NULL)
break;
msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
- case 'b':
- {
- if (LocaleCompare(keyword,"blur") == 0)
- {
- msl_info->image[n]->blur=StringToDouble(value,
- (char **) NULL);
- break;
- }
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
- break;
- }
case 'G':
case 'g':
{
(factor*(msl_info->image[n]->resolution.y == 0.0 ? DefaultResolution :
msl_info->image[n]->resolution.y))+0.5);
resample_image=ResizeImage(msl_info->image[n],width,height,
- msl_info->image[n]->filter,msl_info->image[n]->blur,
- msl_info->exception);
+ msl_info->image[n]->filter,msl_info->exception);
if (resample_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
if (LocaleCompare((const char *) tag,"resize") == 0)
{
- double
- blur;
-
FilterTypes
filter;
break;
}
filter=UndefinedFilter;
- blur=1.0;
if (attributes != (const xmlChar **) NULL)
for (i=0; (attributes[i] != (const xmlChar *) NULL); i++)
{
keyword);
break;
}
- case 'S':
- case 's':
- {
- if (LocaleCompare(keyword,"support") == 0)
- {
- blur=StringToDouble(value,(char **) NULL);
- break;
- }
- ThrowMSLException(OptionError,"UnrecognizedAttribute",
- keyword);
- break;
- }
case 'W':
case 'w':
{
}
}
resize_image=ResizeImage(msl_info->image[n],geometry.width,
- geometry.height,filter,blur,msl_info->exception);
+ geometry.height,filter,msl_info->exception);
if (resize_image == (Image *) NULL)
break;
msl_info->image[n]=DestroyImage(msl_info->image[n]);
}
}
shadow_image=ShadowImage(msl_info->image[n],geometry_info.rho,
- geometry_info.sigma,0.0,(ssize_t) ceil(geometry_info.xi-0.5),
+ geometry_info.sigma,(ssize_t) ceil(geometry_info.xi-0.5),
(ssize_t) ceil(geometry_info.psi-0.5),msl_info->exception);
if (shadow_image == (Image *) NULL)
break;
}
if (LocaleCompare((const char *) tag,"sharpen") == 0)
{
- double bias = 0.0,
+ double
radius = 0.0,
sigma = 1.0;
msl_info->attributes[n],(const char *) attributes[i],&exception));
switch (*keyword)
{
- case 'B':
- case 'b':
- {
- if (LocaleCompare(keyword, "bias") == 0)
- {
- bias = StringToDouble(value,(char **) NULL);
- break;
- }
- ThrowMSLException(OptionError,"UnrecognizedAttribute",keyword);
- break;
- }
case 'R':
case 'r':
{
Image
*newImage;
- newImage=SharpenImage(msl_info->image[n],radius,sigma,bias,
+ newImage=SharpenImage(msl_info->image[n],radius,sigma,
msl_info->exception);
if (newImage == (Image *) NULL)
break;
&image_info->background_color,exception);
break;
}
- if (LocaleCompare(keyword,"bias") == 0)
- {
- if (image == (Image *) NULL)
- break;
- image->bias=StringToDoubleInterval(value,QuantumRange);
- break;
- }
if (LocaleCompare(keyword,"blue-primary") == 0)
{
if (image == (Image *) NULL)
if ((geometry.height % 2) != 0)
geometry.height--;
tile_image=ResizeImage(image,geometry.width,geometry.height,TriangleFilter,
- 1.0,exception);
+ exception);
if (tile_image == (Image *) NULL)
return(MagickFalse);
flags=ParseGeometry(page_geometry,&geometry_info);
if (IsRGBColorspace(image->colorspace) == MagickFalse)
(void) TransformImageColorspace(tile_image,YCCColorspace,exception);
downsample_image=ResizeImage(tile_image,tile_image->columns/2,
- tile_image->rows/2,TriangleFilter,1.0,exception);
+ tile_image->rows/2,TriangleFilter,exception);
if (downsample_image == (Image *) NULL)
return(MagickFalse);
/*
#include "MagickCore/blob.h"
#include "MagickCore/blob-private.h"
#include "MagickCore/cache.h"
+#include "MagickCore/channel.h"
#include "MagickCore/color.h"
#include "MagickCore/color-private.h"
#include "MagickCore/colormap.h"
rows/=2;
resolution.x/=2;
resolution.y/=2;
- pyramid_image=ResizeImage(next,columns,rows,image->filter,image->blur,
- exception);
+ pyramid_image=ResizeImage(next,columns,rows,image->filter,exception);
if (pyramid_image == (Image *) NULL)
break;
pyramid_image->resolution=resolution;
SetGeometry(image,&geometry);
(void) ParseMetaGeometry(PiconGeometry,&geometry.x,&geometry.y,
&geometry.width,&geometry.height);
- picon=ResizeImage(image,geometry.width,geometry.height,TriangleFilter,1.0,
+ picon=ResizeImage(image,geometry.width,geometry.height,TriangleFilter,
exception);
blob_info=CloneImageInfo(image_info);
(void) AcquireUniqueFilename(blob_info->filename);
Scale image.
*/
resize_image=ResizeImage(chroma_image,image->columns,image->rows,
- TriangleFilter,1.0,exception);
+ TriangleFilter,exception);
chroma_image=DestroyImage(chroma_image);
if (resize_image == (Image *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
image->depth=(size_t) (quantum == 1 ? 8 : 16);
width=image->columns+(image->columns & (horizontal_factor-1));
height=image->rows+(image->rows & (vertical_factor-1));
- yuv_image=ResizeImage(image,width,height,TriangleFilter,1.0,exception);
+ yuv_image=ResizeImage(image,width,height,TriangleFilter,exception);
if (yuv_image == (Image *) NULL)
{
(void) CloseBlob(image);
Downsample image.
*/
chroma_image=ResizeImage(image,width/horizontal_factor,
- height/vertical_factor,TriangleFilter,1.0,exception);
+ height/vertical_factor,TriangleFilter,exception);
if (chroma_image == (Image *) NULL)
{
(void) CloseBlob(image);
<name>ImageMagick</name>
<shortdesc xml:lang="en">ImageMagick: convert, edit, and compose images.</shortdesc>
<homepage rdf:resource="http://www.imagemagick.org/"/>
- <created>2012-03-22</created>
+ <created>2012-03-25</created>
<description xml:lang="en">
ImageMagick® is a software suite to create, edit, compose, or convert bitmap images. It can read and write images in a variety of formats (over 100) including DPX, EXR, GIF, JPEG, JPEG-2000, PDF, PhotoCD, PNG, Postscript, SVG, and TIFF. Use ImageMagick to resize, flip, mirror, rotate, distort, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and Bézier curves.
<release>
<Version>
<name>stable</name>
- <created>2012-03-22</created>
+ <created>2012-03-25</created>
<revision>7.0.0</revision>
</Version>
</release>
<configure name="LIB_VERSION" value="0x700"/>
<configure name="LIB_VERSION_NUMBER" value="7,0,0,0"/>
<configure name="SVN_REVISION" value="7202" />
- <configure name="RELEASE_DATE" value="2012-03-22"/>
+ <configure name="RELEASE_DATE" value="2012-03-25"/>
<configure name="CONFIGURE" value="./configure "/>
<configure name="PREFIX" value="/usr/local"/>
<configure name="EXEC-PREFIX" value="/usr/local"/>
projects / imagemagick / commitdiff