{ const char *artifact=GetImageArtifact(image,"distort:viewport");
viewport_given = MagickFalse;
if ( artifact != (const char *) NULL ) {
- (void) ParseAbsoluteGeometry(artifact,&geometry);
- viewport_given = MagickTrue;
+ if (IfMagickFalse(IsGeometry(artifact)))
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ OptionWarning,"InvalidSetting","'%s' '%s'",
+ "distort:viewport",artifact);
+ else {
+ (void) ParseAbsoluteGeometry(artifact,&geometry);
+ viewport_given = MagickTrue;
+ }
}
}
/* Verbose output */
- if ( IfMagickTrue(IsStringTrue(GetImageArtifact(image,"verbose"))) ) {
+ if ( IfStringTrue(GetImageArtifact(image,"verbose")) ) {
register ssize_t
i;
char image_gen[MaxTextExtent];
}
/* Verbose output */
- if ( IfMagickTrue(IsStringTrue(GetImageArtifact(image,"verbose"))) ) {
+ if ( IfStringTrue(GetImageArtifact(image,"verbose")) ) {
switch (sparse_method) {
case BarycentricColorInterpolate:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% MorphologyApply() applies a morphological method, multiple times using
-% a list of multiple kernels.
+% a list of multiple kernels. This is the method that should be called by
+% other 'operators' that internally use morphology operations as part of
+% their processing.
%
% It is basically equivalent to as MorphologyImage() (see below) but
% without any user controls. This allows internel programs to use this
% It is MorphologyImage() task to extract any such user controls, and
% pass them to this function for processing.
%
-% More specifically kernels are not normalized/scaled/blended by the
-% 'convolve:scale' Image Artifact (setting), nor is the convolve bias
-% ('convolve:bias' artifact) looked at, but must be supplied from the
-% function arguments.
+% More specifically all given kernels should already be scaled, normalised,
+% and blended appropriatally before being parred to this routine. The
+% appropriate bias, and compose (typically 'UndefinedComposeOp') given.
%
% The format of the MorphologyApply method is:
%
** composition or re-iteration of results, and compound morphology methods
** that is based on multiple low-level (staged) morphology methods.
**
-** Basically this provides the complex grue between the requested morphology
+** Basically this provides the complex glue between the requested morphology
** method and raw low-level implementation (above).
*/
MagickPrivate Image *MorphologyApply(const Image *image,
% the above internal function MorphologyApply().
%
% User defined settings include...
-% * Output Bias for Convolution and correlation ('-define convolve:bias=??")
-% * Kernel Scale/normalize settings ("-define convolve:scale=??")
+% * Output Bias for Convolution and correlation ("-define convolve:bias=??")
+% * Kernel Scale/normalize settings ("-define convolve:scale=??")
% This can also includes the addition of a scaled unity kernel.
-% * Show Kernel being applied ("-define showkernel=1")
+% * Show Kernel being applied ("-define showkernel=1")
+%
+% Other operators that do not want user supplied options interfering,
+% especially "convolve:bias" and "showkernel" should use MorphologyApply()
+% directly.
%
% The format of the MorphologyImage method is:
%
% Image *MorphologyImage(const Image *image,MorphologyMethod method,
% const ssize_t iterations,KernelInfo *kernel,ExceptionInfo *exception)
%
-% Image *MorphologyImage(const Image *image, const ChannelType
-% channel,MorphologyMethod method,const ssize_t iterations,
-% KernelInfo *kernel,ExceptionInfo *exception)
-%
% A description of each parameter follows:
%
% o image: the image.
double
bias;
+ curr_kernel = (KernelInfo *) kernel;
+ bias=0.0;
+ compose = (ssize_t)UndefinedCompositeOp; /* use default for method */
+
/* Apply Convolve/Correlate Normalization and Scaling Factors.
* This is done BEFORE the ShowKernelInfo() function is called so that
* users can see the results of the 'option:convolve:scale' option.
*/
- curr_kernel = (KernelInfo *) kernel;
- bias=0.0; /* curr_kernel->bias; should we get from kernel */
- if ( method == ConvolveMorphology || method == CorrelateMorphology )
- {
+ if ( method == ConvolveMorphology || method == CorrelateMorphology ) {
const char
*artifact;
+ /* Get the bias value as it will be needed */
+ artifact = GetImageArtifact(image,"convolve:bias");
+ if ( artifact != (const char *) NULL) {
+ if (IfMagickFalse(IsGeometry(artifact)))
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ OptionWarning,"InvalidSetting","'%s' '%s'",
+ "convolve:bias",artifact);
+ else
+ bias=StringToDoubleInterval(artifact,(double) QuantumRange+1.0);
+ }
+
+ /* Scale kernel according to user wishes */
artifact = GetImageArtifact(image,"convolve:scale");
if ( artifact != (const char *)NULL ) {
- if ( curr_kernel == kernel )
- curr_kernel = CloneKernelInfo(kernel);
- if (curr_kernel == (KernelInfo *) NULL) {
- curr_kernel=DestroyKernelInfo(curr_kernel);
- return((Image *) NULL);
+ if (IfMagickFalse(IsGeometry(artifact)))
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ OptionWarning,"InvalidSetting","'%s' '%s'",
+ "convolve:scale",artifact);
+ else {
+ if ( curr_kernel == kernel )
+ curr_kernel = CloneKernelInfo(kernel);
+ if (curr_kernel == (KernelInfo *) NULL)
+ return((Image *) NULL);
+ ScaleGeometryKernelInfo(curr_kernel, artifact);
}
- ScaleGeometryKernelInfo(curr_kernel, artifact);
}
-
- artifact = GetImageArtifact(image,"convolve:bias");
- compose = UndefinedCompositeOp; /* use default for method */
- if ( artifact != (const char *) NULL)
- bias=StringToDouble(artifact, (char **) NULL);
}
/* display the (normalized) kernel via stderr */
- if ( IfMagickTrue(IsStringTrue(GetImageArtifact(image,"showkernel")))
- || IfMagickTrue(IsStringTrue(GetImageArtifact(image,"convolve:showkernel")))
- || IfMagickTrue(IsStringTrue(GetImageArtifact(image,"morphology:showkernel"))) )
+ if ( IfStringTrue(GetImageArtifact(image,"showkernel"))
+ || IfStringTrue(GetImageArtifact(image,"convolve:showkernel"))
+ || IfStringTrue(GetImageArtifact(image,"morphology:showkernel")) )
ShowKernelInfo(curr_kernel);
/* Override the default handling of multi-kernel morphology results
*/
{ const char
*artifact;
- compose = UndefinedCompositeOp; /* use default for method */
+ ssize_t
+ parse;
+
artifact = GetImageArtifact(image,"morphology:compose");
- if ( artifact != (const char *) NULL)
- compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
+ if ( artifact != (const char *) NULL) {
+ parse=ParseCommandOption(MagickComposeOptions,
MagickFalse,artifact);
+ if ( parse < 0 )
+ (void) ThrowMagickException(exception,GetMagickModule(),
+ OptionWarning,"UnrecognizedComposeOperator","'%s' '%s'",
+ "morphology:compose",artifact);
+ else
+ compose=(CompositeOperator)parse;
+ }
}
/* Apply the Morphology */
morphology_image = MorphologyApply(image,method,iterations,
MagickExport void ScaleGeometryKernelInfo (KernelInfo *kernel,
const char *geometry)
{
- GeometryFlags
+ //GeometryFlags
+ int
flags;
GeometryInfo
args;
SetGeometryInfo(&args);
- flags = (GeometryFlags) ParseGeometry(geometry, &args);
+ flags = ParseGeometry(geometry, &args);
#if 0
/* For Debugging Geometry Input */
maximum,
negative_range,
positive_range,
- angle,
- bias;
+ angle;
struct _KernelInfo
*next;
ImageInfoOptionFlag = 0x0001, /* Setting stored in ImageInfo */
DrawInfoOptionFlag = 0x0002, /* Setting stored in DrawInfo */
QuantizeInfoOptionFlag = 0x0004, /* Setting stored in QuantizeInfo */
- GlobalOptionFlag = 0x0008, /* Global Setting */
+ GlobalOptionFlag = 0x0008, /* Global Setting or Control */
SettingOptionFlags = 0x000F, /* mask for all setting options */
SimpleOperatorOptionFlag = 0x0010, /* Simple Image processing operator */
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(UndefinedFilter < filter && filter < SentinelFilter);
assert(exception != (ExceptionInfo *) NULL);
filter_type=mapping[filter].filter;
window_type=mapping[filter].window;
/* Promote 1D Windowed Sinc Filters to a 2D Windowed Jinc filters */
- if ((cylindrical != MagickFalse) && (filter_type == SincFastFilter) &&
+ if( IfMagickTrue(cylindrical) && (filter_type == SincFastFilter) &&
(filter != SincFastFilter))
filter_type=JincFilter; /* 1D Windowed Sinc => 2D Windowed Jinc filters */
/* Expert filter setting override */
option=ParseCommandOption(MagickFilterOptions,MagickFalse,artifact);
if ((UndefinedFilter < option) && (option < SentinelFilter))
{
- filter_type=cylindrical != MagickFalse ? JincFilter :
- SincFastFilter;
+ filter_type= IfMagickTrue(cylindrical) ? JincFilter
+ : SincFastFilter;
window_type=(FilterTypes) option;
}
}
/*
Filter Modifications for orthogonal/cylindrical usage.
*/
- if (cylindrical != MagickFalse)
+ if( IfMagickTrue(cylindrical) )
switch (filter_type)
{
case BoxFilter:
#pragma omp master
{
#endif
- artifact=GetImageArtifact(image,"filter:verbose");
- if (IfMagickTrue(IsStringTrue(artifact)))
+ if (IfStringTrue(GetImageArtifact(image,"filter:verbose")))
{
double
support,
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
resize_image=CloneImage(image,columns,rows,MagickTrue,exception);
if (resize_image == (Image *) NULL)
return((Image *) NULL);
- if (SetImageStorageClass(resize_image,DirectClass,exception) == MagickFalse)
+ if( IfMagickFalse(SetImageStorageClass(resize_image,DirectClass,exception)) )
{
resize_image=DestroyImage(resize_image);
return((Image *) NULL);
register ssize_t
x;
- if (status == MagickFalse)
+ if( IfMagickFalse(status) )
continue;
q=QueueCacheViewAuthenticPixels(resize_view,0,y,resize_image->columns,1,
exception);
}
q+=GetPixelChannels(resize_image);
}
- if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
+ if( IfMagickFalse(SyncCacheViewAuthenticPixels(resize_view,exception)) )
continue;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
#endif
proceed=SetImageProgress(image,InterpolativeResizeImageTag,progress++,
image->rows);
- if (proceed == MagickFalse)
+ if( IfMagickFalse(proceed) )
status=MagickFalse;
}
}
resize_view=DestroyCacheView(resize_view);
image_view=DestroyCacheView(image_view);
- if (status == MagickFalse)
+ if( IfMagickFalse(status) )
resize_image=DestroyImage(resize_image);
return(resize_image);
}
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
register ssize_t
x;
- if (status == MagickFalse)
+ if( IfMagickFalse(status) )
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
if (p == (const Quantum *) NULL)
pixels=(gfloat *) RelinquishMagickMemory(pixels);
return((Image *) NULL);
}
- if (SetImageStorageClass(rescale_image,DirectClass,exception) == MagickFalse)
+ if( IfMagickFalse(SetImageStorageClass(rescale_image,DirectClass,exception)) )
{
pixels=(gfloat *) RelinquishMagickMemory(pixels);
rescale_image=DestroyImage(rescale_image);
SetPixelChannel(rescale_image,channel,ClampToQuantum(QuantumRange*
packet[i]),q);
}
- if (SyncCacheViewAuthenticPixels(rescale_view,exception) == MagickFalse)
+ if( IfMagickFalse(SyncCacheViewAuthenticPixels(rescale_view,exception)) )
break;
}
rescale_view=DestroyCacheView(rescale_view);
{
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
scale=MagickMax(1.0/x_factor+MagickEpsilon,1.0);
support=scale*GetResizeFilterSupport(resize_filter);
storage_class=support > 0.5 ? DirectClass : image->storage_class;
- if (SetImageStorageClass(resize_image,storage_class,exception) == MagickFalse)
+ if( IfMagickFalse(SetImageStorageClass(resize_image,storage_class,exception)) )
return(MagickFalse);
if (support < 0.5)
{
start,
stop;
- if (status == MagickFalse)
+ if( IfMagickFalse(status) )
continue;
bisect=(MagickRealType) (x+0.5)/x_factor+MagickEpsilon;
start=(ssize_t) MagickMax(bisect-support+0.5,0.0);
}
q+=GetPixelChannels(resize_image);
}
- if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
+ if( IfMagickFalse(SyncCacheViewAuthenticPixels(resize_view,exception)) )
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
#pragma omp critical (MagickCore_HorizontalFilter)
#endif
proceed=SetImageProgress(image,ResizeImageTag,(*offset)++,span);
- if (proceed == MagickFalse)
+ if( IfMagickFalse(proceed) )
status=MagickFalse;
}
}
scale=MagickMax(1.0/y_factor+MagickEpsilon,1.0);
support=scale*GetResizeFilterSupport(resize_filter);
storage_class=support > 0.5 ? DirectClass : image->storage_class;
- if (SetImageStorageClass(resize_image,storage_class,exception) == MagickFalse)
+ if( IfMagickFalse(SetImageStorageClass(resize_image,storage_class,exception)) )
return(MagickFalse);
if (support < 0.5)
{
start,
stop;
- if (status == MagickFalse)
+ if( IfMagickFalse(status) )
continue;
bisect=(MagickRealType) (y+0.5)/y_factor+MagickEpsilon;
start=(ssize_t) MagickMax(bisect-support+0.5,0.0);
}
q+=GetPixelChannels(resize_image);
}
- if (SyncCacheViewAuthenticPixels(resize_view,exception) == MagickFalse)
+ if( IfMagickFalse(SyncCacheViewAuthenticPixels(resize_view,exception)) )
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
#pragma omp critical (MagickCore_VerticalFilter)
#endif
proceed=SetImageProgress(image,ResizeImageTag,(*offset)++,span);
- if (proceed == MagickFalse)
+ if( IfMagickFalse(proceed) )
status=MagickFalse;
}
}
*/
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
filter_type=PointFilter;
else
if ((image->storage_class == PseudoClass) ||
- (image->matte != MagickFalse) || ((x_factor*y_factor) > 1.0))
+ IfMagickTrue(image->matte) ||
+ ((x_factor*y_factor) > 1.0))
filter_type=MitchellFilter;
resize_filter=AcquireResizeFilter(image,filter_type,MagickFalse,exception);
/*
*/
filter_image=DestroyImage(filter_image);
resize_filter=DestroyResizeFilter(resize_filter);
- if (status == MagickFalse)
+ if( IfMagickFalse(status) )
{
resize_image=DestroyImage(resize_image);
return((Image *) NULL);
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
ssize_t
y_offset;
- if (status == MagickFalse)
+ if( IfMagickFalse(status) )
continue;
y_offset=(ssize_t) (((MagickRealType) y+0.5)*image->rows/
sample_image->rows);
}
q+=GetPixelChannels(sample_image);
}
- if (SyncCacheViewAuthenticPixels(sample_view,exception) == MagickFalse)
+ if( IfMagickFalse(SyncCacheViewAuthenticPixels(sample_view,exception)) )
status=MagickFalse;
if (image->progress_monitor != (MagickProgressMonitor) NULL)
{
#pragma omp critical (MagickCore_SampleImage)
#endif
proceed=SetImageProgress(image,SampleImageTag,progress++,image->rows);
- if (proceed == MagickFalse)
+ if( IfMagickFalse(proceed) )
status=MagickFalse;
}
}
*/
assert(image != (const Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
scale_image=CloneImage(image,columns,rows,MagickTrue,exception);
if (scale_image == (Image *) NULL)
return((Image *) NULL);
- if (SetImageStorageClass(scale_image,DirectClass,exception) == MagickFalse)
+ if( IfMagickFalse(SetImageStorageClass(scale_image,DirectClass,exception)) )
{
scale_image=DestroyImage(scale_image);
return((Image *) NULL);
*/
while (scale.y < span.y)
{
- if ((next_row != MagickFalse) &&
- (number_rows < (ssize_t) image->rows))
+ if( IfMagickTrue(next_row) && (number_rows < (ssize_t) image->rows))
{
/*
Read a new scanline.
scale.y=(double) scale_image->rows/(double) image->rows;
next_row=MagickTrue;
}
- if ((next_row != MagickFalse) && (number_rows < (ssize_t) image->rows))
+ if( IfMagickTrue(next_row) && (number_rows < (ssize_t) image->rows))
{
/*
Read a new scanline.
scale.x=(double) scale_image->columns/(double) image->columns;
while (scale.x >= span.x)
{
- if (next_column != MagickFalse)
+ if( IfMagickTrue(next_column) )
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
pixel[i]=0.0;
}
if (scale.x > 0)
{
- if (next_column != MagickFalse)
+ if( IfMagickTrue(next_column) )
{
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
pixel[i]=0.0;
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
pixel[i]+=span.x*scanline[(x-1)*GetPixelChannels(image)+i];
}
- if ((next_column == MagickFalse) &&
+ if( IfMagickFalse(next_column) &&
((ssize_t) n < (ssize_t) scale_image->columns))
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
q+=GetPixelChannels(scale_image);
}
}
- if (SyncCacheViewAuthenticPixels(scale_view,exception) == MagickFalse)
+ if( IfMagickFalse(SyncCacheViewAuthenticPixels(scale_view,exception)) )
break;
proceed=SetImageProgress(image,ScaleImageTag,(MagickOffsetType) y,
image->rows);
- if (proceed == MagickFalse)
+ if( IfMagickFalse(proceed) )
break;
}
scale_view=DestroyCacheView(scale_view);
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
+ if( IfMagickTrue(image->debug) )
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickSignature);
if (thumbnail_image == (Image *) NULL)
return(thumbnail_image);
(void) ParseAbsoluteGeometry("0x0+0+0",&thumbnail_image->page);
- if (thumbnail_image->matte == MagickFalse)
+ if( IfMagickFalse(thumbnail_image->matte) )
(void) SetImageAlphaChannel(thumbnail_image,OpaqueAlphaChannel,exception);
thumbnail_image->depth=8;
thumbnail_image->interlace=NoInterlace;
image->magick_filename);
(void) SetImageProperty(thumbnail_image,"Thumb::URI",value,exception);
(void) CopyMagickString(value,image->magick_filename,MaxTextExtent);
- if (GetPathAttributes(image->filename,&attributes) != MagickFalse)
+ if( IfMagickTrue(GetPathAttributes(image->filename,&attributes)) )
{
(void) FormatLocaleString(value,MaxTextExtent,"%.20g",(double)
attributes.st_mtime);
BackgroundColor[] = "#fff", /* white */
BorderColor[] = "#dfdfdf", /* sRGB gray */
MatteColor[] = "#bdbdbd"; /* slightly darker gray */
+
+/* For Debugging Geometry Input */
+#define ReportGeometry(flags,info) \
+ (void) FormatLocaleFile(stderr, "Geometry = 0x%04X : %lg x %lg %+lg %+lg\n", \
+ flags, info.rho, info.sigma, info.xi, info.psi )
\f
/*
** Function to report on the progress of image operations
{
if (LocaleCompare("adaptive-blur",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=AdaptiveBlurImage(_image,geometry_info.rho,
}
if (LocaleCompare("adaptive-sharpen",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=AdaptiveSharpenImage(_image,geometry_info.rho,
*text,
geometry[MaxTextExtent];
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
SetGeometryInfo(&geometry_info);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
text=InterpretImageProperties(_image_info,_image,arg2,
{
geometry_info.rho=1.5;
if (IfNormalOp) {
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
}
new_image=BlueShiftImage(_image,geometry_info.rho,_exception);
break;
}
if (LocaleCompare("blur",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=BlurImage(_image,geometry_info.rho,geometry_info.sigma,
const char*
value;
- if (IfMagickFalse(IsGeometry(arg1)))
+ flags=ParsePageGeometry(_image,arg1,&geometry,_exception);
+ if ((flags & RhoValue) == 0)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
+ if ((flags & SigmaValue) == 0)
+ geometry.height=geometry.width;
value=GetImageOption(_image_info,"compose");
if (value != (const char *) NULL)
else
compose=OverCompositeOp; /* use Over not _image->compose */
- flags=ParsePageGeometry(_image,arg1,&geometry,_exception);
- if ((flags & SigmaValue) == 0)
- geometry.height=geometry.width;
new_image=BorderImage(_image,&geometry,compose,_exception);
break;
}
MagickStatusType
flags;
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
brightness=geometry_info.rho;
contrast=0.0;
if ((flags & SigmaValue) != 0)
}
if (LocaleCompare("charcoal",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
if ((flags & XiValue) == 0)
MagickStatusType
flags;
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
black_point=geometry_info.rho;
white_point=(flags & SigmaValue) != 0 ? geometry_info.sigma :
black_point;
kernel_info=AcquireKernelInfo(arg1);
if (kernel_info == (KernelInfo *) NULL)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
- /* kernel_info->bias=_image->bias; -- FUTURE: check this path! */
- new_image=ConvolveImage(_image,kernel_info,_exception);
+ new_image=MorphologyImage(_image,ConvolveMorphology,1,kernel_info,
+ _exception);
kernel_info=DestroyKernelInfo(kernel_info);
break;
}
{
if (LocaleCompare("edge",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=EdgeImage(_image,geometry_info.rho,geometry_info.sigma,
{
if (LocaleCompare("lat",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & PercentValue) != 0)
geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
new_image=AdaptiveThresholdImage(_image,(size_t) geometry_info.rho,
MagickStatusType
flags;
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
black_point=geometry_info.rho;
white_point=(MagickRealType) QuantumRange;
if ((flags & SigmaValue) != 0)
MagickStatusType
flags;
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
black_point=geometry_info.rho;
white_point=(MagickRealType) _image->columns*_image->rows;
if ((flags & SigmaValue) != 0)
}
if (LocaleCompare("motion-blur",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=MotionBlurImage(_image,geometry_info.rho,
{
if (LocaleCompare("paint",option+1) == 0)
{
- (void) ParseGeometry(arg1,&geometry_info);
+ flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
new_image=OilPaintImage(_image,geometry_info.rho,geometry_info.sigma,
_exception);
break;
random_info=DestroyRandomInfo(random_info);
}
else {
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
angle=geometry_info.rho;
}
caption=GetImageProperty(_image,"caption",_exception);
}
if (LocaleCompare("posterize",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
+ flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
- (void) ParseGeometry(arg1,&geometry_info);
(void) PosterizeImage(_image,(size_t) geometry_info.rho,
_quantize_info->dither,_exception);
break;
{
if (LocaleCompare("radial-blur",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
new_image=RadialBlurImage(_image,geometry_info.rho,_exception);
break;
}
if (LocaleCompare("resample",option+1) == 0)
{
/* FUTURE: Roll into a resize special operation */
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
new_image=ResampleImage(_image,geometry_info.rho,
}
if (LocaleCompare("rotate",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
+ flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
- if (strchr(arg1,'>') != (char *) NULL)
- if (_image->columns <= _image->rows)
- break;
- if (strchr(arg1,'<') != (char *) NULL)
- if (_image->columns >= _image->rows)
- break;
- (void) ParseGeometry(arg1,&geometry_info);
+ if ((flags & GreaterValue) != 0 && (_image->columns >= _image->rows))
+ break;
+ if ((flags & LessValue) != 0 && (_image->columns >= _image->rows))
+ break;
new_image=RotateImage(_image,geometry_info.rho,_exception);
break;
}
}
if (LocaleCompare("segment",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
(void) SegmentImage(_image,_image->colorspace,
}
if (LocaleCompare("selective-blur",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
+ if ((flags & SigmaValue) == 0)
+ geometry_info.sigma=1.0;
if ((flags & PercentValue) != 0)
geometry_info.xi=(double) QuantumRange*geometry_info.xi/100.0;
new_image=SelectiveBlurImage(_image,geometry_info.rho,
}
if (LocaleCompare("shade",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
- if ((flags & SigmaValue) == 0)
- geometry_info.sigma=1.0;
+ if (((flags & RhoValue) == 0) || ((flags & SigmaValue) == 0))
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
new_image=ShadeImage(_image,normal_op,geometry_info.rho,
geometry_info.sigma,_exception);
break;
}
if (LocaleCompare("shadow",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
if ((flags & XiValue) == 0)
}
if (LocaleCompare("sharpen",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
if ((flags & XiValue) == 0)
}
if (LocaleCompare("shear",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
new_image=ShearImage(_image,geometry_info.rho,
}
if (LocaleCompare("sigmoidal-contrast",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=(double) QuantumRange/2.0;
if ((flags & PercentValue) != 0)
}
if (LocaleCompare("sketch",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=SketchImage(_image,geometry_info.rho,
if ( parse < 0 )
CLIWandExceptArgBreak(OptionError,"UnrecognizedStatisticType",
option,arg1);
- if (IfMagickFalse(IsGeometry(arg2)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg2);
flags=ParseGeometry(arg2,&geometry_info);
+ if ((flags & RhoValue) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg2);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=geometry_info.rho;
new_image=StatisticImage(_image,(StatisticType)parse,
}
if (LocaleCompare("unsharp",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
if ((flags & XiValue) == 0)
}
if (LocaleCompare("vignette",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
if ((flags & XiValue) == 0)
{
if (LocaleCompare("wave",option+1) == 0)
{
- if (IfMagickFalse(IsGeometry(arg1)))
- CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
flags=ParseGeometry(arg1,&geometry_info);
+ if ((flags & (RhoValue|SigmaValue)) == 0)
+ CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if ((flags & SigmaValue) == 0)
geometry_info.sigma=1.0;
new_image=WaveImage(_image,geometry_info.rho,geometry_info.sigma,
<message name="GeometryDoesNotContainImage">
geometry does not contain image
</message>
- <message name="InvalidUseOfOption">
- invalid use of option
- </message>
<message name="InvalidArgument">
invalid argument for option
</message>
+ <message name="InvalidUseOfOption">
+ invalid use of option
+ </message>
<message name="InvalidGeometry">
invalid geometry
</message>
<message name="InvalidNumberList">
invalid list of numbers
</message>
+ <message name="InvalidSetting">
+ invalid setting
+ </message>
<message name="ImagesAreNotTheSameSize">
images are not the same size
</message>
<message name="GeometryDoesNotContainImage">
geometry does not contain image
</message>
+ <message name="InvalidSetting">
+ invalid setting
+ </message>
<message name="NoSuchElement">
no such element in list
</message>
<message name="GeometryDoesNotContainImage">
image non incluse dans la géométrie
</message>
- <message name="InvalidUseOfOption">
- Invalide utilisation de l'option
- </message>
<message name="InvalidArgument">
argument invalide pour l'option
</message>
+ <message name="InvalidUseOfOption">
+ Invalide utilisation de l'option
+ </message>
<message name="InvalidGeometry">
géométrie invalide
</message>
<message name="InvalidNumberList">
liste des numéros non valide
</message>
+ <message name="InvalidSetting">
+ invalide de réglage
+ </message>
<message name="ImagesAreNotTheSameSize">
images diffèrent par la taille
</message>
<message name="GeometryDoesNotContainImage">
image non incluse dans la géométrie
</message>
+ <message name="InvalidSetting">
+ invalide de réglage
+ </message>
<message name="NoSuchElement">
élément absent de la liste
</message>
projects / imagemagick / commitdiff