% MagickCore Option Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% March 2000 %
% %
% %
-% Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/effect.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-private.h"
+#include "MagickCore/fourier.h"
#include "MagickCore/fx.h"
#include "MagickCore/gem.h"
#include "MagickCore/geometry.h"
#include "MagickCore/montage.h"
#include "MagickCore/morphology.h"
#include "MagickCore/option.h"
+#include "MagickCore/option-private.h"
#include "MagickCore/pixel.h"
#include "MagickCore/policy.h"
#include "MagickCore/property.h"
{
{ "Undefined", UndefinedAlphaChannel, UndefinedOptionFlag, MagickTrue },
{ "Activate", ActivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Associate", AssociateAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Background", BackgroundAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Copy", CopyAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Deactivate", DeactivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Discrete", DiscreteAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Disassociate", DisassociateAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Extract", ExtractAlphaChannel, UndefinedOptionFlag, MagickFalse },
- { "Off", DeactivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
- { "On", ActivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Off", OffAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "On", OnAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Opaque", OpaqueAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Remove", RemoveAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Set", SetAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "UserSpaceOnUse", UserSpaceOnUse, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedPathUnits, UndefinedOptionFlag, MagickFalse }
},
+ ColorspaceOptions[] =
+ {
+ { "Undefined", UndefinedColorspace, UndefinedOptionFlag, MagickTrue },
+ { "CIELab", LabColorspace, UndefinedOptionFlag, MagickFalse },
+ { "CMY", CMYColorspace, UndefinedOptionFlag, MagickFalse },
+ { "CMYK", CMYKColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Gray", GRAYColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HCL", HCLColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HCLp", HCLpColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HSB", HSBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HSI", HSIColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HSL", HSLColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HSV", HSVColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HWB", HWBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Lab", LabColorspace, UndefinedOptionFlag, MagickFalse },
+ { "LCH", LCHColorspace, UndefinedOptionFlag, MagickFalse },
+ { "LCHab", LCHabColorspace, UndefinedOptionFlag, MagickFalse },
+ { "LCHuv", LCHuvColorspace, UndefinedOptionFlag, MagickFalse },
+ { "LMS", LMSColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Log", LogColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Luv", LuvColorspace, UndefinedOptionFlag, MagickFalse },
+ { "OHTA", OHTAColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Rec601YCbCr", Rec601YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Rec709YCbCr", Rec709YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
+ { "RGB", RGBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "scRGB", scRGBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "sRGB", sRGBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Transparent", TransparentColorspace, UndefinedOptionFlag, MagickFalse },
+ { "xyY", xyYColorspace, UndefinedOptionFlag, MagickFalse },
+ { "XYZ", XYZColorspace, UndefinedOptionFlag, MagickFalse },
+ { "YCbCr", YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
+ { "YDbDr", YDbDrColorspace, UndefinedOptionFlag, MagickFalse },
+ { "YCC", YCCColorspace, UndefinedOptionFlag, MagickFalse },
+ { "YIQ", YIQColorspace, UndefinedOptionFlag, MagickFalse },
+ { "YPbPr", YPbPrColorspace, UndefinedOptionFlag, MagickFalse },
+ { "YUV", YUVColorspace, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedColorspace, UndefinedOptionFlag, MagickFalse }
+ },
+ ComplexOptions[] =
+ {
+ { "Undefined", UndefinedComplexOperator, UndefinedOptionFlag, MagickTrue },
+ { "Add", AddComplexOperator, UndefinedOptionFlag, MagickFalse },
+ { "Conjugate", ConjugateComplexOperator, UndefinedOptionFlag, MagickFalse },
+ { "Divide", DivideComplexOperator, UndefinedOptionFlag, MagickFalse },
+ { "MagnitudePhase", MagnitudePhaseComplexOperator, UndefinedOptionFlag, MagickFalse },
+ { "Multiply", MultiplyComplexOperator, UndefinedOptionFlag, MagickFalse },
+ { "RealImaginary", RealImaginaryComplexOperator, UndefinedOptionFlag, MagickFalse },
+ { "Subtract", SubtractComplexOperator, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedComplexOperator, UndefinedOptionFlag, MagickFalse }
+ },
CommandOptions[] =
{
- /* WARNING: this must be sorted by name, then by switch character
- So that it can be referenced using a binary search for speed.
- See GetCommandOptionInfo() below for details.
-
- Check on sort...
- magick -list command > t1
- sort -k 1.2 t1 | diff t1 -
- Should not show any differences...
+ /*
+ Must be ordered lexigraphically.
*/
+ { "+alpha", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-alpha", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+background", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-background", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+format", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-format", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "-quiet", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
+ { "+quiet", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
+ { "-regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+repage", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-repage", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+size", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-size", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+virtual-pixel", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-virtual-pixel", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+blur", 0L, DeprecateOptionFlag, MagickTrue },
+ { "-blur", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+resize", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-resize", 1L, SimpleOperatorFlag, MagickFalse },
{ "(", 0L, NoImageOperatorFlag, MagickTrue },
{ ")", 0L, NoImageOperatorFlag, MagickTrue },
{ "{", 0L, NoImageOperatorFlag, MagickTrue },
{ "-adaptive-resize", 1L, SimpleOperatorFlag, MagickFalse },
{ "+adaptive-sharpen", 1L, DeprecateOptionFlag, MagickTrue },
{ "-adaptive-sharpen", 1L, SimpleOperatorFlag, MagickFalse },
- { "+adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+affine", 0L, ReplacedOptionFlag | DrawInfoOptionFlag, MagickTrue },
{ "-affine", 1L, ReplacedOptionFlag | DrawInfoOptionFlag, MagickTrue },
{ "+affinity", 0L, DeprecateOptionFlag, MagickTrue },
{ "-affinity", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "+alpha", 1L, DeprecateOptionFlag, MagickTrue },
- { "-alpha", 1L, SimpleOperatorFlag, MagickFalse },
{ "+annotate", 0L, DeprecateOptionFlag, MagickTrue },
{ "-annotate", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse },
- { "+antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+attenuate", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-attenuate", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+authenticate", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-average", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue },
{ "+backdrop", 0L, NonMagickOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "-backdrop", 1L, NonMagickOptionFlag | NeverInterpretArgsFlag, MagickFalse },
- { "+background", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-background", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+bench", 1L, DeprecateOptionFlag, MagickTrue },
{ "-bench", 1L, GenesisOptionFlag, MagickFalse },
{ "+bias", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-bias", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+black-threshold", 0L, DeprecateOptionFlag, MagickTrue },
{ "-black-threshold", 1L, SimpleOperatorFlag, MagickFalse },
{ "+blend", 0L, NonMagickOptionFlag, MagickFalse },
{ "-blend", 1L, NonMagickOptionFlag, MagickFalse },
{ "+blue-primary", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-blue-primary", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+blue-shift", 1L, SimpleOperatorFlag, MagickFalse },
{ "-blue-shift", 1L, SimpleOperatorFlag, MagickFalse },
- { "+blur", 0L, DeprecateOptionFlag, MagickTrue },
- { "-blur", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+blue-shift", 1L, SimpleOperatorFlag, MagickFalse },
{ "+border", 1L, DeprecateOptionFlag, MagickTrue },
{ "-border", 1L, SimpleOperatorFlag, MagickFalse },
{ "+bordercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-brightness-contrast", 1L, SimpleOperatorFlag, MagickFalse },
{ "+cache", 0L, GlobalOptionFlag, MagickFalse },
{ "-cache", 1L, GlobalOptionFlag, MagickFalse },
+ { "+canny", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-canny", 1L, SimpleOperatorFlag, MagickTrue },
{ "+caption", 0L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "-caption", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+cdl", 1L, DeprecateOptionFlag, MagickTrue },
{ "-cdl", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
- { "+channel", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-channel", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+channel", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-channel", 1L, SimpleOperatorFlag, MagickFalse },
{ "-channel-fx", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+charcoal", 1L, DeprecateOptionFlag, MagickTrue },
{ "-charcoal", 1L, SimpleOperatorFlag, MagickFalse },
{ "-chop", 1L, SimpleOperatorFlag, MagickFalse },
{ "+clamp", 0L, DeprecateOptionFlag, MagickTrue },
{ "-clamp", 0L, SimpleOperatorFlag, MagickFalse },
- { "+clip", 0L, SimpleOperatorFlag, MagickFalse },
{ "-clip", 0L, SimpleOperatorFlag, MagickFalse },
+ { "+clip", 0L, SimpleOperatorFlag, MagickFalse },
{ "+clip-mask", 0L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "-clip-mask", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
- { "+clip-path", 1L, SimpleOperatorFlag, MagickFalse },
{ "-clip-path", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+clip-path", 1L, SimpleOperatorFlag, MagickFalse },
{ "+clone", 0L, NoImageOperatorFlag, MagickFalse },
{ "-clone", 1L, NoImageOperatorFlag, MagickFalse },
{ "+clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-clut", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+coalesce", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-coalesce", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
- { "+color-matrix", 1L, DeprecateOptionFlag, MagickTrue },
- { "-color-matrix", 1L, SimpleOperatorFlag, MagickFalse },
{ "+colorize", 1L, DeprecateOptionFlag, MagickTrue },
{ "-colorize", 1L, SimpleOperatorFlag, MagickFalse },
{ "+colormap", 0L, NonMagickOptionFlag, MagickFalse },
{ "-colormap", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+color-matrix", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-color-matrix", 1L, SimpleOperatorFlag, MagickFalse },
{ "+colors", 1L, DeprecateOptionFlag, MagickTrue },
{ "-colors", 1L, SimpleOperatorFlag, MagickFalse },
{ "+colorspace", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
{ "-colorspace", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
- { "+combine", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-combine", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+combine", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+comment", 0L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "-comment", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "+compare", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "-compare", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+complex", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "-complex", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+compose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-compose", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+composite", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-compress", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+concurrent", 0L, DeprecateOptionFlag, MagickTrue },
{ "-concurrent", 0L, GenesisOptionFlag, MagickFalse },
- { "+contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+ { "+connected-components", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-connected-components", 1L, SimpleOperatorFlag, MagickFalse },
{ "-contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+ { "+contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+contrast-stretch", 1L, DeprecateOptionFlag, MagickTrue },
{ "-contrast-stretch", 1L, SimpleOperatorFlag, MagickFalse },
{ "+convolve", 1L, DeprecateOptionFlag, MagickTrue },
{ "-convolve", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+copy", 2L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "-copy", 2L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+crop", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-crop", 1L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
{ "+cycle", 1L, DeprecateOptionFlag, MagickTrue },
{ "-decipher", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+deconstruct", 0L, DeprecateOptionFlag, MagickTrue },
{ "-deconstruct", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue },
- { "+define", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
{ "-define", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
+ { "+define", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
{ "+delay", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-delay", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+delete", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-direction", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+displace", 0L, NonMagickOptionFlag, MagickFalse },
{ "-displace", 1L, NonMagickOptionFlag, MagickFalse },
- { "+display", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-display", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+display", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+dispose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-dispose", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+dissolve", 0L, NonMagickOptionFlag, MagickFalse },
- { "-dissolve", 1L, NonMagickOptionFlag, MagickFalse },
{ "+dissimilarity-threshold", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
{ "-dissimilarity-threshold", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
- { "+distort", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse },
+ { "+dissolve", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-dissolve", 1L, NonMagickOptionFlag, MagickFalse },
{ "-distort", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse },
+ { "+distort", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse },
{ "+dither", 0L, ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse },
{ "-dither", 1L, ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse },
{ "+draw", 0L, DeprecateOptionFlag, MagickTrue },
{ "-draw", 1L, SimpleOperatorFlag, MagickFalse },
{ "+duplicate", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-duplicate", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
- { "+duration", 1L, GenesisOptionFlag, MagickFalse },
{ "-duration", 1L, GenesisOptionFlag, MagickFalse },
+ { "+duration", 1L, GenesisOptionFlag, MagickFalse },
{ "+edge", 1L, DeprecateOptionFlag, MagickTrue },
{ "-edge", 1L, SimpleOperatorFlag, MagickFalse },
{ "+emboss", 1L, DeprecateOptionFlag, MagickTrue },
{ "-family", 1L, DrawInfoOptionFlag, MagickFalse },
{ "+features", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
{ "-features", 1L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
- { "+fft", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-fft", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+fft", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+fill", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-fill", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+filter", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-flatten", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+flip", 0L, DeprecateOptionFlag, MagickTrue },
{ "-flip", 0L, SimpleOperatorFlag, MagickFalse },
- { "+floodfill", 2L, SimpleOperatorFlag, MagickFalse },
{ "-floodfill", 2L, SimpleOperatorFlag, MagickFalse },
+ { "+floodfill", 2L, SimpleOperatorFlag, MagickFalse },
{ "+flop", 0L, DeprecateOptionFlag, MagickTrue },
{ "-flop", 0L, SimpleOperatorFlag, MagickFalse },
{ "+font", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-font", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+foreground", 0L, NonMagickOptionFlag, MagickFalse },
{ "-foreground", 1L, NonMagickOptionFlag, MagickFalse },
- { "+format", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-format", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+frame", 1L, DeprecateOptionFlag, MagickTrue },
{ "-frame", 1L, SimpleOperatorFlag, MagickFalse },
{ "+function", 2L, DeprecateOptionFlag, MagickTrue },
{ "-fuzz", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+fx", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-fx", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
- { "+gamma", 1L, SimpleOperatorFlag, MagickFalse },
{ "-gamma", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+gamma", 1L, SimpleOperatorFlag, MagickFalse },
{ "+gaussian", 1L, DeprecateOptionFlag, MagickTrue },
{ "-gaussian", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+gaussian-blur", 1L, DeprecateOptionFlag, MagickTrue },
{ "-hald-clut", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+highlight-color", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
{ "-highlight-color", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "+hough-lines", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-hough-lines", 1L, SimpleOperatorFlag, MagickTrue },
{ "+iconGeometry", 0L, NonMagickOptionFlag, MagickFalse },
{ "-iconGeometry", 1L, NonMagickOptionFlag, MagickFalse },
- { "+iconic", 0L, NonMagickOptionFlag, MagickFalse },
{ "-iconic", 0L, NonMagickOptionFlag, MagickFalse },
+ { "+iconic", 0L, NonMagickOptionFlag, MagickFalse },
{ "+identify", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-identify", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
- { "+ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
- { "+immutable", 0L, NonMagickOptionFlag, MagickFalse },
+ { "+ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-immutable", 0L, NonMagickOptionFlag, MagickFalse },
+ { "+immutable", 0L, NonMagickOptionFlag, MagickFalse },
{ "+implode", 0L, DeprecateOptionFlag, MagickTrue },
{ "-implode", 1L, SimpleOperatorFlag, MagickFalse },
{ "+insert", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-interword-spacing", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+kerning", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-kerning", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+kuwahara", 0L, DeprecateOptionFlag, MagickTrue },
+ { "-kuwahara", 1L, SimpleOperatorFlag, MagickFalse },
{ "+label", 0L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "-label", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+lat", 1L, DeprecateOptionFlag, MagickTrue },
{ "-lat", 1L, SimpleOperatorFlag, MagickFalse },
{ "+layers", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-layers", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
- { "+level", 1L, SimpleOperatorFlag, MagickFalse },
{ "-level", 1L, SimpleOperatorFlag, MagickFalse },
- { "+level-colors", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+level", 1L, SimpleOperatorFlag, MagickFalse },
{ "-level-colors", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+level-colors", 1L, SimpleOperatorFlag, MagickFalse },
{ "+limit", 0L, DeprecateOptionFlag, MagickTrue },
{ "-limit", 2L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
{ "+linear-stretch", 1L, DeprecateOptionFlag, MagickTrue },
{ "-magnify", 0L, SimpleOperatorFlag, MagickFalse },
{ "+map", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue },
{ "-map", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
- { "+mask", 0L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
- { "-mask", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
- { "+matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+ { "+mask", 0L, DeprecateOptionFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "-mask", 1L, DeprecateOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "-matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+ { "+matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+mattecolor", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-mattecolor", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "+maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "+mean-shift", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-mean-shift", 1L, SimpleOperatorFlag, MagickTrue },
{ "+median", 1L, DeprecateOptionFlag, MagickTrue },
{ "-median", 1L, ReplacedOptionFlag | SimpleOperatorFlag | FireOptionFlag, MagickTrue },
- { "+metric", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-metric", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "+metric", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-metric", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "+minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "+mode", 1L, NonMagickOptionFlag, MagickFalse },
{ "-mode", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+modulate", 1L, DeprecateOptionFlag, MagickTrue },
{ "-modulate", 1L, SimpleOperatorFlag, MagickFalse },
- { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "-moments", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+moments", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
{ "-monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
{ "+monochrome", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-monochrome", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
{ "+morph", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-name", 1L, NonMagickOptionFlag, MagickFalse },
{ "+negate", 0L, SimpleOperatorFlag, MagickFalse },
{ "-negate", 0L, SimpleOperatorFlag, MagickFalse },
- { "+noise", 1L, SimpleOperatorFlag, MagickFalse },
{ "-noise", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "+noise", 1L, SimpleOperatorFlag, MagickFalse },
{ "-noop", 0L, NoImageOperatorFlag, MagickFalse },
{ "+normalize", 0L, DeprecateOptionFlag, MagickTrue },
{ "-normalize", 0L, SimpleOperatorFlag, MagickFalse },
- { "+opaque", 1L, SimpleOperatorFlag, MagickFalse },
{ "-opaque", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+opaque", 1L, SimpleOperatorFlag, MagickFalse },
{ "+ordered-dither", 0L, DeprecateOptionFlag, MagickTrue },
{ "-ordered-dither", 1L, SimpleOperatorFlag, MagickFalse },
{ "+orient", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-path", 1L, NonMagickOptionFlag, MagickFalse },
{ "+pause", 0L, NonMagickOptionFlag, MagickFalse },
{ "-pause", 1L, NonMagickOptionFlag, MagickFalse },
- { "+ping", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-ping", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+ping", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+pointsize", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-pointsize", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+polaroid", 0L, SimpleOperatorFlag, MagickFalse },
{ "-quality", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+quantize", 0L, QuantizeInfoOptionFlag, MagickFalse },
{ "-quantize", 1L, QuantizeInfoOptionFlag, MagickFalse },
- { "+quiet", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
- { "-quiet", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
- { "+radial-blur", 1L, DeprecateOptionFlag, MagickTrue },
- { "-radial-blur", 1L, SimpleOperatorFlag, MagickFalse },
- { "+raise", 1L, SimpleOperatorFlag, MagickFalse },
{ "-raise", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+raise", 1L, SimpleOperatorFlag, MagickFalse },
{ "+random-threshold", 1L, DeprecateOptionFlag, MagickTrue },
{ "-random-threshold", 1L, SimpleOperatorFlag, MagickFalse },
{ "-read", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "+read-mask", 0L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "-read-mask", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+recolor", 1L, DeprecateOptionFlag, MagickTrue },
{ "-recolor", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+red-primary", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-red-primary", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+region", 0L, NoImageOperatorFlag, MagickFalse },
{ "-region", 1L, NoImageOperatorFlag, MagickFalse },
{ "+remap", 0L, ListOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
{ "-remap", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+remote", 0L, NonMagickOptionFlag, MagickFalse },
{ "-remote", 1L, NonMagickOptionFlag, MagickFalse },
- { "+render", 0L, DrawInfoOptionFlag, MagickFalse },
{ "-render", 0L, DrawInfoOptionFlag, MagickFalse },
- { "+repage", 0L, SimpleOperatorFlag, MagickFalse },
- { "-repage", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+render", 0L, DrawInfoOptionFlag, MagickFalse },
{ "+resample", 1L, DeprecateOptionFlag, MagickTrue },
{ "-resample", 1L, SimpleOperatorFlag, MagickFalse },
- { "+resize", 1L, DeprecateOptionFlag, MagickTrue },
- { "-resize", 1L, SimpleOperatorFlag, MagickFalse },
- { "+respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+reverse", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-reverse", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+roll", 1L, DeprecateOptionFlag, MagickTrue },
{ "-roll", 1L, SimpleOperatorFlag, MagickFalse },
{ "+rotate", 1L, DeprecateOptionFlag, MagickTrue },
{ "-rotate", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-rotational-blur", 1L, SimpleOperatorFlag, MagickFalse },
{ "+sample", 1L, DeprecateOptionFlag, MagickTrue },
{ "-sample", 1L, SimpleOperatorFlag, MagickFalse },
{ "+sampling-factor", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-sampling-factor", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+sans", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
- { "-sans", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
- { "+sans0", 0L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, /* equivelent to 'noop' */
{ "-sans0", 0L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "+sans0", 0L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, /* equivelent to 'noop' */
{ "+sans1", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
{ "-sans1", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, /* equivelent to 'sans' */
- { "+sans2", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "-sans", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "+sans", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
{ "-sans2", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "+sans2", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
{ "+scale", 1L, DeprecateOptionFlag, MagickTrue },
{ "-scale", 1L, SimpleOperatorFlag, MagickFalse },
{ "+scene", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-shave", 1L, SimpleOperatorFlag, MagickFalse },
{ "+shear", 1L, DeprecateOptionFlag, MagickTrue },
{ "-shear", 1L, SimpleOperatorFlag, MagickFalse },
- { "+sigmoidal-contrast", 1L, SimpleOperatorFlag, MagickFalse },
{ "-sigmoidal-contrast", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+sigmoidal-contrast", 1L, SimpleOperatorFlag, MagickFalse },
{ "+silent", 0L, NonMagickOptionFlag, MagickFalse },
{ "-silent", 1L, NonMagickOptionFlag, MagickFalse },
{ "+similarity-threshold", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
{ "-similarity-threshold", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
- { "+size", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-size", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+sketch", 1L, DeprecateOptionFlag, MagickTrue },
{ "-sketch", 1L, SimpleOperatorFlag, MagickFalse },
- { "+smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+snaps", 0L, NonMagickOptionFlag, MagickFalse },
{ "-snaps", 1L, NonMagickOptionFlag, MagickFalse },
{ "+solarize", 1L, DeprecateOptionFlag, MagickTrue },
{ "-strip", 0L, SimpleOperatorFlag, MagickFalse },
{ "+stroke", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-stroke", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+strokewidth", 1L, ImageInfoOptionFlag, MagickFalse },
{ "-strokewidth", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+strokewidth", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+style", 0L, DrawInfoOptionFlag, MagickFalse },
{ "-style", 1L, DrawInfoOptionFlag, MagickFalse },
- { "+subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
- { "-subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
{ "-subimage", 0L, ListOperatorFlag, MagickFalse },
+ { "-subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "+subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
{ "+swap", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-swap", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+swirl", 1L, DeprecateOptionFlag, MagickTrue },
{ "-swirl", 1L, SimpleOperatorFlag, MagickFalse },
- { "+synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
- { "+taint", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-taint", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+taint", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+text-font", 0L, NonMagickOptionFlag, MagickFalse },
{ "-text-font", 1L, NonMagickOptionFlag, MagickFalse },
{ "+texture", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-tile", 1L, DrawInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+tile-offset", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-tile-offset", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+tint", 1L, SimpleOperatorFlag, MagickFalse },
{ "-tint", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+tint", 1L, SimpleOperatorFlag, MagickFalse },
{ "+title", 0L, NonMagickOptionFlag, MagickFalse },
{ "-title", 1L, NonMagickOptionFlag, MagickFalse },
{ "+transform", 0L, DeprecateOptionFlag, MagickTrue },
{ "-transform", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
- { "+transparent", 1L, SimpleOperatorFlag, MagickFalse },
{ "-transparent", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+transparent", 1L, SimpleOperatorFlag, MagickFalse },
{ "+transparent-color", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+transpose", 0L, DeprecateOptionFlag, MagickTrue },
{ "-type", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
{ "+undercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-undercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+unique", 0L, SimpleOperatorFlag, MagickFalse },
{ "-unique", 0L, SimpleOperatorFlag, MagickFalse },
+ { "+unique", 0L, SimpleOperatorFlag, MagickFalse },
{ "+unique-colors", 0L, DeprecateOptionFlag, MagickTrue },
{ "-unique-colors", 0L, SimpleOperatorFlag, MagickFalse },
{ "+units", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-update", 1L, NonMagickOptionFlag, MagickFalse },
{ "+use-pixmap", 0L, NonMagickOptionFlag, MagickFalse },
{ "-use-pixmap", 1L, NonMagickOptionFlag, MagickFalse },
- { "+verbose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-verbose", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+verbose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+version", 0L, DeprecateOptionFlag, MagickTrue },
{ "-version", 0L, NoImageOperatorFlag, MagickFalse },
{ "+view", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-view", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+vignette", 1L, DeprecateOptionFlag, MagickTrue },
{ "-vignette", 1L, SimpleOperatorFlag, MagickFalse },
- { "+virtual-pixel", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-virtual-pixel", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+visual", 0L, NonMagickOptionFlag, MagickFalse },
{ "-visual", 1L, NonMagickOptionFlag, MagickFalse },
{ "+watermark", 0L, NonMagickOptionFlag, MagickFalse },
{ "-window", 1L, NonMagickOptionFlag, MagickFalse },
{ "+window-group", 0L, NonMagickOptionFlag, MagickFalse },
{ "-window-group", 1L, NonMagickOptionFlag, MagickFalse },
- { "+write", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
{ "-write", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
+ { "+write", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
+ { "+write-mask", 0L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "-write-mask", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ (char *) NULL, 0L, UndefinedOptionFlag, MagickFalse }
},
+ ComplianceOptions[] =
+ {
+ { "Undefined", UndefinedCompliance, UndefinedOptionFlag, MagickTrue },
+ { "CSS", CSSCompliance, UndefinedOptionFlag, MagickFalse },
+ { "No", NoCompliance, UndefinedOptionFlag, MagickFalse },
+ { "SVG", SVGCompliance, UndefinedOptionFlag, MagickFalse },
+ { "X11", X11Compliance, UndefinedOptionFlag, MagickFalse },
+ { "XPM", XPMCompliance, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedClass, UndefinedOptionFlag, MagickFalse }
+ },
ComposeOptions[] =
{
{ "Undefined", UndefinedCompositeOp, UndefinedOptionFlag, MagickTrue },
{ "DstOver", DstOverCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Exclusion", ExclusionCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "HardLight", HardLightCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "HardMix", HardMixCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Hue", HueCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "In", InCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Intensity", IntensityCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Xor", XorCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Divide", DivideDstCompositeOp, DeprecateOptionFlag, MagickTrue },
{ "Minus", MinusDstCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { "Subtract", ModulusSubtractCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { "Add", ModulusAddCompositeOp, DeprecateOptionFlag, MagickTrue },
{ "Threshold", ThresholdCompositeOp, DeprecateOptionFlag, MagickTrue },
{ "CopyOpacity", CopyAlphaCompositeOp, UndefinedOptionFlag, MagickTrue },
{ (char *) NULL, UndefinedCompositeOp, UndefinedOptionFlag, MagickFalse }
{ "ZipS", ZipSCompression, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedCompression, UndefinedOptionFlag, MagickFalse }
},
- ColorspaceOptions[] =
- {
- { "Undefined", UndefinedColorspace, UndefinedOptionFlag, MagickTrue },
- { "CIELab", LabColorspace, UndefinedOptionFlag, MagickFalse },
- { "CMY", CMYColorspace, UndefinedOptionFlag, MagickFalse },
- { "CMYK", CMYKColorspace, UndefinedOptionFlag, MagickFalse },
- { "Gray", GRAYColorspace, UndefinedOptionFlag, MagickFalse },
- { "HCL", HCLColorspace, UndefinedOptionFlag, MagickFalse },
- { "HCLp", HCLpColorspace, UndefinedOptionFlag, MagickFalse },
- { "HSB", HSBColorspace, UndefinedOptionFlag, MagickFalse },
- { "HSI", HSIColorspace, UndefinedOptionFlag, MagickFalse },
- { "HSL", HSLColorspace, UndefinedOptionFlag, MagickFalse },
- { "HSV", HSVColorspace, UndefinedOptionFlag, MagickFalse },
- { "HWB", HWBColorspace, UndefinedOptionFlag, MagickFalse },
- { "Lab", LabColorspace, UndefinedOptionFlag, MagickFalse },
- { "LCH", LCHColorspace, UndefinedOptionFlag, MagickFalse },
- { "LCHab", LCHabColorspace, UndefinedOptionFlag, MagickFalse },
- { "LCHuv", LCHuvColorspace, UndefinedOptionFlag, MagickFalse },
- { "LMS", LMSColorspace, UndefinedOptionFlag, MagickFalse },
- { "Log", LogColorspace, UndefinedOptionFlag, MagickFalse },
- { "Luv", LuvColorspace, UndefinedOptionFlag, MagickFalse },
- { "OHTA", OHTAColorspace, UndefinedOptionFlag, MagickFalse },
- { "Rec601YCbCr", Rec601YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
- { "Rec709YCbCr", Rec709YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
- { "RGB", RGBColorspace, UndefinedOptionFlag, MagickFalse },
- { "scRGB", scRGBColorspace, UndefinedOptionFlag, MagickFalse },
- { "sRGB", sRGBColorspace, UndefinedOptionFlag, MagickFalse },
- { "Transparent", TransparentColorspace, UndefinedOptionFlag, MagickFalse },
- { "XYZ", XYZColorspace, UndefinedOptionFlag, MagickFalse },
- { "YCbCr", YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
- { "YDbDr", YDbDrColorspace, UndefinedOptionFlag, MagickFalse },
- { "YCC", YCCColorspace, UndefinedOptionFlag, MagickFalse },
- { "YIQ", YIQColorspace, UndefinedOptionFlag, MagickFalse },
- { "YPbPr", YPbPrColorspace, UndefinedOptionFlag, MagickFalse },
- { "YUV", YUVColorspace, UndefinedOptionFlag, MagickFalse },
- { (char *) NULL, UndefinedColorspace, UndefinedOptionFlag, MagickFalse }
- },
DataTypeOptions[] =
{
{ "Undefined", UndefinedData, UndefinedOptionFlag, MagickTrue },
},
DisposeOptions[] =
{
- { "Undefined", UndefinedDispose, UndefinedOptionFlag, MagickTrue },
+ { "Undefined", UndefinedDispose, UndefinedOptionFlag, MagickFalse },
{ "Background", BackgroundDispose, UndefinedOptionFlag, MagickFalse },
{ "None", NoneDispose, UndefinedOptionFlag, MagickFalse },
{ "Previous", PreviousDispose, UndefinedOptionFlag, MagickFalse },
- { "Undefined", UndefinedDispose, UndefinedOptionFlag, MagickFalse },
{ "0", UndefinedDispose, UndefinedOptionFlag, MagickFalse },
{ "1", NoneDispose, UndefinedOptionFlag, MagickFalse },
{ "2", BackgroundDispose, UndefinedOptionFlag, MagickFalse },
{ "PoissonNoise", PoissonNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse },
{ "Pow", PowEvaluateOperator, UndefinedOptionFlag, MagickFalse },
{ "RightShift", RightShiftEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "RMS", RootMeanSquareEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "RootMeanSquare", RootMeanSquareEvaluateOperator, UndefinedOptionFlag, MagickFalse },
{ "Set", SetEvaluateOperator, UndefinedOptionFlag, MagickFalse },
{ "Sin", SineEvaluateOperator, UndefinedOptionFlag, MagickFalse },
{ "Sine", SineEvaluateOperator, UndefinedOptionFlag, MagickFalse },
{ "ArcTan", ArctanFunction, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedFunction, UndefinedOptionFlag, MagickFalse }
},
+ GradientOptions[] =
+ {
+ { "Undefined", UndefinedGradient, UndefinedOptionFlag, MagickTrue },
+ { "Linear", LinearGradient, UndefinedOptionFlag, MagickFalse },
+ { "Radial", RadialGradient, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedRule, UndefinedOptionFlag, MagickFalse }
+ },
GravityOptions[] =
{
{ "Undefined", UndefinedGravity, UndefinedOptionFlag, MagickTrue },
{ "Color", MagickColorOptions, UndefinedOptionFlag, MagickFalse },
{ "Colorspace", MagickColorspaceOptions, UndefinedOptionFlag, MagickFalse },
{ "Command", MagickCommandOptions, UndefinedOptionFlag, MagickFalse },
+ { "Compliance", MagickComplianceOptions, UndefinedOptionFlag, MagickFalse },
+ { "Complex", MagickComplexOptions, UndefinedOptionFlag, MagickFalse },
{ "Compose", MagickComposeOptions, UndefinedOptionFlag, MagickFalse },
{ "Compress", MagickCompressOptions, UndefinedOptionFlag, MagickFalse },
{ "Configure", MagickConfigureOptions, UndefinedOptionFlag, MagickFalse },
{ "Font", MagickFontOptions, UndefinedOptionFlag, MagickFalse },
{ "Format", MagickFormatOptions, UndefinedOptionFlag, MagickFalse },
{ "Function", MagickFunctionOptions, UndefinedOptionFlag, MagickFalse },
+ { "Gradient", MagickGradientOptions, UndefinedOptionFlag, MagickFalse },
{ "Gravity", MagickGravityOptions, UndefinedOptionFlag, MagickFalse },
{ "Intensity", MagickPixelIntensityOptions, UndefinedOptionFlag, MagickFalse },
{ "Intent", MagickIntentOptions, UndefinedOptionFlag, MagickFalse },
{ "Undefined", MagickUndefinedOptions, UndefinedOptionFlag, MagickTrue },
{ "Validate", MagickValidateOptions, UndefinedOptionFlag, MagickFalse },
{ "VirtualPixel", MagickVirtualPixelOptions, UndefinedOptionFlag, MagickFalse },
+ { "Weight", MagickWeightOptions, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, MagickUndefinedOptions, UndefinedOptionFlag, MagickFalse }
},
LogEventOptions[] =
{ "AE", AbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse },
{ "Fuzz", FuzzErrorMetric, UndefinedOptionFlag, MagickFalse },
{ "MAE", MeanAbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse },
- { "MEPP", MeanErrorPerPixelMetric, UndefinedOptionFlag, MagickFalse },
+ { "MEPP", MeanErrorPerPixelErrorMetric, UndefinedOptionFlag, MagickFalse },
{ "MSE", MeanSquaredErrorMetric, UndefinedOptionFlag, MagickFalse },
{ "NCC", NormalizedCrossCorrelationErrorMetric, UndefinedOptionFlag, MagickFalse },
{ "PAE", PeakAbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse },
- { "PSNR", PeakSignalToNoiseRatioMetric, UndefinedOptionFlag, MagickFalse },
+ { "PHASh", PerceptualHashErrorMetric, UndefinedOptionFlag, MagickFalse },
+ { "PSNR", PeakSignalToNoiseRatioErrorMetric, UndefinedOptionFlag, MagickFalse },
{ "RMSE", RootMeanSquaredErrorMetric, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedErrorMetric, UndefinedOptionFlag, MagickFalse }
},
PixelIntensityOptions[] =
{
{ "Undefined", UndefinedPixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "Average", AveragePixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "Brightness", BrightnessPixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "Lightness", LightnessPixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "MS", MSPixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "Rec601Luma", Rec601LumaPixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "Rec601Luminance", Rec601LuminancePixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "Rec709Luma", Rec709LumaPixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "Rec709Luminance", Rec709LuminancePixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
- { "RMS", RMSPixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
+ { "Average", AveragePixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Brightness", BrightnessPixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Lightness", LightnessPixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Mean", AveragePixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "MS", MSPixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Rec601Luma", Rec601LumaPixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Rec601Luminance", Rec601LuminancePixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Rec709Luma", Rec709LumaPixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Rec709Luminance", Rec709LuminancePixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "RMS", RMSPixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedPixelIntensityMethod, UndefinedOptionFlag, MagickFalse }
},
PixelMaskOptions[] =
PrimitiveOptions[] =
{
{ "Undefined", UndefinedPrimitive, UndefinedOptionFlag, MagickTrue },
+ { "Alpha", AlphaPrimitive, UndefinedOptionFlag, MagickFalse },
{ "Arc", ArcPrimitive, UndefinedOptionFlag, MagickFalse },
{ "Bezier", BezierPrimitive, UndefinedOptionFlag, MagickFalse },
{ "Circle", CirclePrimitive, UndefinedOptionFlag, MagickFalse },
{ "Ellipse", EllipsePrimitive, UndefinedOptionFlag, MagickFalse },
{ "Image", ImagePrimitive, UndefinedOptionFlag, MagickFalse },
{ "Line", LinePrimitive, UndefinedOptionFlag, MagickFalse },
- { "Matte", MattePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Matte", AlphaPrimitive, UndefinedOptionFlag, MagickFalse },
{ "Path", PathPrimitive, UndefinedOptionFlag, MagickFalse },
{ "Point", PointPrimitive, UndefinedOptionFlag, MagickFalse },
{ "Polygon", PolygonPrimitive, UndefinedOptionFlag, MagickFalse },
{ "Area", AreaResource, UndefinedOptionFlag, MagickFalse },
{ "Disk", DiskResource, UndefinedOptionFlag, MagickFalse },
{ "File", FileResource, UndefinedOptionFlag, MagickFalse },
+ { "Height", HeightResource, UndefinedOptionFlag, MagickFalse },
{ "Map", MapResource, UndefinedOptionFlag, MagickFalse },
{ "Memory", MemoryResource, UndefinedOptionFlag, MagickFalse },
{ "Thread", ThreadResource, UndefinedOptionFlag, MagickFalse },
{ "Time", TimeResource, UndefinedOptionFlag, MagickFalse },
+ { "Width", WidthResource, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedResource, UndefinedOptionFlag, MagickFalse }
},
SparseColorOptions[] =
{ "Minimum", MinimumStatistic, UndefinedOptionFlag, MagickFalse },
{ "Mode", ModeStatistic, UndefinedOptionFlag, MagickFalse },
{ "NonPeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse },
+ { "RootMeanSquare", RootMeanSquareStatistic, UndefinedOptionFlag, MagickFalse },
+ { "RMS", RootMeanSquareStatistic, UndefinedOptionFlag, MagickFalse },
{ "StandardDeviation", StandardDeviationStatistic, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedMethod, UndefinedOptionFlag, MagickFalse }
},
{ "Undefined", UndefinedType, UndefinedOptionFlag, MagickTrue },
{ "Bilevel", BilevelType, UndefinedOptionFlag, MagickFalse },
{ "ColorSeparation", ColorSeparationType, UndefinedOptionFlag, MagickFalse },
- { "ColorSeparationAlpha", ColorSeparationMatteType, UndefinedOptionFlag, MagickFalse },
- { "ColorSeparationMatte", ColorSeparationMatteType, UndefinedOptionFlag, MagickFalse },
+ { "ColorSeparationAlpha", ColorSeparationAlphaType, UndefinedOptionFlag, MagickFalse },
+ { "ColorSeparationMatte", ColorSeparationAlphaType, UndefinedOptionFlag, MagickFalse },
{ "Grayscale", GrayscaleType, UndefinedOptionFlag, MagickFalse },
- { "GrayscaleAlpha", GrayscaleMatteType, UndefinedOptionFlag, MagickFalse },
- { "GrayscaleMatte", GrayscaleMatteType, UndefinedOptionFlag, MagickFalse },
+ { "GrayscaleAlpha", GrayscaleAlphaType, UndefinedOptionFlag, MagickFalse },
+ { "GrayscaleMatte", GrayscaleAlphaType, UndefinedOptionFlag, MagickFalse },
{ "Optimize", OptimizeType, UndefinedOptionFlag, MagickFalse },
{ "Palette", PaletteType, UndefinedOptionFlag, MagickFalse },
- { "PaletteBilevelAlpha", PaletteBilevelMatteType, UndefinedOptionFlag, MagickFalse },
- { "PaletteBilevelMatte", PaletteBilevelMatteType, UndefinedOptionFlag, MagickFalse },
- { "PaletteAlpha", PaletteMatteType, UndefinedOptionFlag, MagickFalse },
- { "PaletteMatte", PaletteMatteType, UndefinedOptionFlag, MagickFalse },
- { "TrueColorAlpha", TrueColorMatteType, UndefinedOptionFlag, MagickFalse },
- { "TrueColorMatte", TrueColorMatteType, UndefinedOptionFlag, MagickFalse },
+ { "PaletteBilevelAlpha", PaletteBilevelAlphaType, UndefinedOptionFlag, MagickFalse },
+ { "PaletteBilevelMatte", PaletteBilevelAlphaType, UndefinedOptionFlag, MagickFalse },
+ { "PaletteAlpha", PaletteAlphaType, UndefinedOptionFlag, MagickFalse },
+ { "PaletteMatte", PaletteAlphaType, UndefinedOptionFlag, MagickFalse },
+ { "TrueColorAlpha", TrueColorAlphaType, UndefinedOptionFlag, MagickFalse },
+ { "TrueColorMatte", TrueColorAlphaType, UndefinedOptionFlag, MagickFalse },
{ "TrueColor", TrueColorType, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedType, UndefinedOptionFlag, MagickFalse }
},
{ "VerticalTileEdge", VerticalTileEdgeVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
{ "White", WhiteVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }
- };
-\f
-static const OptionInfo *GetOptionInfo(const CommandOption option)
-{
- switch (option)
+ },
+ WeightOptions[] =
{
- case MagickAlignOptions: return(AlignOptions);
- case MagickAlphaChannelOptions: return(AlphaChannelOptions);
- case MagickBooleanOptions: return(BooleanOptions);
- case MagickCacheOptions: return(CacheOptions);
- case MagickChannelOptions: return(ChannelOptions);
- case MagickClassOptions: return(ClassOptions);
- case MagickClipPathOptions: return(ClipPathOptions);
- case MagickColorspaceOptions: return(ColorspaceOptions);
- case MagickCommandOptions: return(CommandOptions);
- case MagickComposeOptions: return(ComposeOptions);
- case MagickCompressOptions: return(CompressOptions);
- case MagickDataTypeOptions: return(DataTypeOptions);
- case MagickDebugOptions: return(LogEventOptions);
- case MagickDecorateOptions: return(DecorateOptions);
- case MagickDirectionOptions: return(DirectionOptions);
- case MagickDisposeOptions: return(DisposeOptions);
- case MagickDistortOptions: return(DistortOptions);
- case MagickDitherOptions: return(DitherOptions);
- case MagickEndianOptions: return(EndianOptions);
- case MagickEvaluateOptions: return(EvaluateOptions);
- case MagickFillRuleOptions: return(FillRuleOptions);
- case MagickFilterOptions: return(FilterOptions);
- case MagickFunctionOptions: return(FunctionOptions);
- case MagickGravityOptions: return(GravityOptions);
-/* case MagickImageListOptions: return(ImageListOptions); */
- case MagickIntentOptions: return(IntentOptions);
- case MagickInterlaceOptions: return(InterlaceOptions);
- case MagickInterpolateOptions: return(InterpolateOptions);
- case MagickKernelOptions: return(KernelOptions);
- case MagickLayerOptions: return(LayerOptions);
- case MagickLineCapOptions: return(LineCapOptions);
- case MagickLineJoinOptions: return(LineJoinOptions);
- case MagickListOptions: return(ListOptions);
- case MagickLogEventOptions: return(LogEventOptions);
- case MagickMetricOptions: return(MetricOptions);
- case MagickMethodOptions: return(MethodOptions);
- case MagickModeOptions: return(ModeOptions);
- case MagickMorphologyOptions: return(MorphologyOptions);
- case MagickNoiseOptions: return(NoiseOptions);
- case MagickOrientationOptions: return(OrientationOptions);
- case MagickPixelChannelOptions: return(PixelChannelOptions);
- case MagickPixelIntensityOptions: return(PixelIntensityOptions);
- case MagickPixelMaskOptions: return(PixelMaskOptions);
- case MagickPixelTraitOptions: return(PixelTraitOptions);
- case MagickPolicyDomainOptions: return(PolicyDomainOptions);
- case MagickPolicyRightsOptions: return(PolicyRightsOptions);
- case MagickPreviewOptions: return(PreviewOptions);
- case MagickPrimitiveOptions: return(PrimitiveOptions);
- case MagickQuantumFormatOptions: return(QuantumFormatOptions);
- case MagickResolutionOptions: return(ResolutionOptions);
- case MagickResourceOptions: return(ResourceOptions);
- case MagickSparseColorOptions: return(SparseColorOptions);
- case MagickStatisticOptions: return(StatisticOptions);
- case MagickStorageOptions: return(StorageOptions);
- case MagickStretchOptions: return(StretchOptions);
- case MagickStyleOptions: return(StyleOptions);
- case MagickTypeOptions: return(TypeOptions);
- case MagickValidateOptions: return(ValidateOptions);
- case MagickVirtualPixelOptions: return(VirtualPixelOptions);
- default: break;
- }
- return((const OptionInfo *) NULL);
-}
+ { "Undefined", 0L, UndefinedOptionFlag, MagickTrue },
+ { "Thin", 100L, UndefinedOptionFlag, MagickFalse },
+ { "ExtraLight", 200L, UndefinedOptionFlag, MagickFalse },
+ { "UltraLight", 200L, UndefinedOptionFlag, MagickFalse },
+ { "Light", 300L, DeprecateOptionFlag, MagickTrue },
+ { "Normal", 400L, UndefinedOptionFlag, MagickFalse },
+ { "Regular", 400L, UndefinedOptionFlag, MagickFalse },
+ { "Medium", 500L, UndefinedOptionFlag, MagickFalse },
+ { "DemiBold", 600L, UndefinedOptionFlag, MagickFalse },
+ { "SemiBold", 600L, UndefinedOptionFlag, MagickFalse },
+ { "Bold", 700L, UndefinedOptionFlag, MagickFalse },
+ { "ExtraBold", 800L, UndefinedOptionFlag, MagickFalse },
+ { "UltraBold", 800L, UndefinedOptionFlag, MagickFalse },
+ { "Heavy", 900L, UndefinedOptionFlag, MagickFalse },
+ { "Black", 900L, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, 0L, UndefinedOptionFlag, MagickFalse }
+ };
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
const ImageInfo *clone_info)
{
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(clone_info != (const ImageInfo *) NULL);
- assert(clone_info->signature == MagickSignature);
+ assert(clone_info->signature == MagickCoreSignature);
if (clone_info->options != (void *) NULL)
- image_info->options=CloneSplayTree((SplayTreeInfo *) clone_info->options,
- (void *(*)(void *)) ConstantString,(void *(*)(void *)) ConstantString);
+ {
+ if (image_info->options != (void *) NULL)
+ DestroyImageOptions(image_info);
+ image_info->options=CloneSplayTree((SplayTreeInfo *) clone_info->options,
+ (void *(*)(void *)) ConstantString,(void *(*)(void *)) ConstantString);
+ }
return(MagickTrue);
}
\f
const char *option)
{
char
- key[MaxTextExtent],
- value[MaxTextExtent];
+ key[MagickPathExtent],
+ value[MagickPathExtent];
register char
*p;
assert(image_info != (ImageInfo *) NULL);
assert(option != (const char *) NULL);
- (void) CopyMagickString(key,option,MaxTextExtent);
+ (void) CopyMagickString(key,option,MagickPathExtent);
for (p=key; *p != '\0'; p++)
if (*p == '=')
break;
*value='\0';
if (*p == '=')
- (void) CopyMagickString(value,p+1,MaxTextExtent);
+ (void) CopyMagickString(value,p+1,MagickPathExtent);
*p='\0';
return(SetImageOption(image_info,key,value));
}
const char *option)
{
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
MagickExport void DestroyImageOptions(ImageInfo *image_info)
{
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
const char *option)
{
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
%
*/
+static const OptionInfo *GetOptionInfo(const CommandOption option)
+{
+ switch (option)
+ {
+ case MagickAlignOptions: return(AlignOptions);
+ case MagickAlphaChannelOptions: return(AlphaChannelOptions);
+ case MagickBooleanOptions: return(BooleanOptions);
+ case MagickCacheOptions: return(CacheOptions);
+ case MagickChannelOptions: return(ChannelOptions);
+ case MagickClassOptions: return(ClassOptions);
+ case MagickClipPathOptions: return(ClipPathOptions);
+ case MagickColorspaceOptions: return(ColorspaceOptions);
+ case MagickCommandOptions: return(CommandOptions);
+ case MagickComplianceOptions: return(ComplianceOptions);
+ case MagickComplexOptions: return(ComplexOptions);
+ case MagickComposeOptions: return(ComposeOptions);
+ case MagickCompressOptions: return(CompressOptions);
+ case MagickDataTypeOptions: return(DataTypeOptions);
+ case MagickDebugOptions: return(LogEventOptions);
+ case MagickDecorateOptions: return(DecorateOptions);
+ case MagickDirectionOptions: return(DirectionOptions);
+ case MagickDisposeOptions: return(DisposeOptions);
+ case MagickDistortOptions: return(DistortOptions);
+ case MagickDitherOptions: return(DitherOptions);
+ case MagickEndianOptions: return(EndianOptions);
+ case MagickEvaluateOptions: return(EvaluateOptions);
+ case MagickFillRuleOptions: return(FillRuleOptions);
+ case MagickFilterOptions: return(FilterOptions);
+ case MagickFunctionOptions: return(FunctionOptions);
+ case MagickGradientOptions: return(GradientOptions);
+ case MagickGravityOptions: return(GravityOptions);
+ case MagickIntentOptions: return(IntentOptions);
+ case MagickInterlaceOptions: return(InterlaceOptions);
+ case MagickInterpolateOptions: return(InterpolateOptions);
+ case MagickKernelOptions: return(KernelOptions);
+ case MagickLayerOptions: return(LayerOptions);
+ case MagickLineCapOptions: return(LineCapOptions);
+ case MagickLineJoinOptions: return(LineJoinOptions);
+ case MagickListOptions: return(ListOptions);
+ case MagickLogEventOptions: return(LogEventOptions);
+ case MagickMetricOptions: return(MetricOptions);
+ case MagickMethodOptions: return(MethodOptions);
+ case MagickModeOptions: return(ModeOptions);
+ case MagickMorphologyOptions: return(MorphologyOptions);
+ case MagickNoiseOptions: return(NoiseOptions);
+ case MagickOrientationOptions: return(OrientationOptions);
+ case MagickPixelChannelOptions: return(PixelChannelOptions);
+ case MagickPixelIntensityOptions: return(PixelIntensityOptions);
+ case MagickPixelMaskOptions: return(PixelMaskOptions);
+ case MagickPixelTraitOptions: return(PixelTraitOptions);
+ case MagickPolicyDomainOptions: return(PolicyDomainOptions);
+ case MagickPolicyRightsOptions: return(PolicyRightsOptions);
+ case MagickPreviewOptions: return(PreviewOptions);
+ case MagickPrimitiveOptions: return(PrimitiveOptions);
+ case MagickQuantumFormatOptions: return(QuantumFormatOptions);
+ case MagickResolutionOptions: return(ResolutionOptions);
+ case MagickResourceOptions: return(ResourceOptions);
+ case MagickSparseColorOptions: return(SparseColorOptions);
+ case MagickStatisticOptions: return(StatisticOptions);
+ case MagickStorageOptions: return(StorageOptions);
+ case MagickStretchOptions: return(StretchOptions);
+ case MagickStyleOptions: return(StyleOptions);
+ case MagickTypeOptions: return(TypeOptions);
+ case MagickValidateOptions: return(ValidateOptions);
+ case MagickVirtualPixelOptions: return(VirtualPixelOptions);
+ case MagickWeightOptions: return(WeightOptions);
+ default: break;
+ }
+ return((const OptionInfo *) NULL);
+}
+
MagickExport ssize_t GetCommandOptionFlags(const CommandOption option,
const MagickBooleanType list,const char *options)
{
char
- token[MaxTextExtent];
+ token[MagickPathExtent];
const OptionInfo
+ *command_info,
*option_info;
int
while (((isspace((int) ((unsigned char) *p)) == 0) && (*p != sentinel)) &&
(*p != '\0'))
{
- if ((q-token) >= (MaxTextExtent-1))
+ if ((q-token) >= (MagickPathExtent-1))
break;
*q++=(*p++);
}
*q='\0';
for (i=0; option_info[i].mnemonic != (char *) NULL; i++)
if (LocaleCompare(token,option_info[i].mnemonic) == 0)
- {
- if (*token == '!')
- option_types=option_types &~ option_info[i].flags;
- else
- option_types=option_types | option_info[i].flags;
- break;
- }
- if ((option_info[i].mnemonic == (char *) NULL) &&
+ break;
+ command_info=option_info+i;
+ if ((command_info->mnemonic == (const char *) NULL) &&
((strchr(token+1,'-') != (char *) NULL) ||
(strchr(token+1,'_') != (char *) NULL)))
{
while ((q=strchr(token+1,'-')) != (char *) NULL)
- (void) CopyMagickString(q,q+1,MaxTextExtent-strlen(q));
+ (void) CopyMagickString(q,q+1,MagickPathExtent-strlen(q));
while ((q=strchr(token+1,'_')) != (char *) NULL)
- (void) CopyMagickString(q,q+1,MaxTextExtent-strlen(q));
+ (void) CopyMagickString(q,q+1,MagickPathExtent-strlen(q));
for (i=0; option_info[i].mnemonic != (char *) NULL; i++)
if (LocaleCompare(token,option_info[i].mnemonic) == 0)
- {
- if (*token == '!')
- option_types=option_types &~ option_info[i].flags;
- else
- option_types=option_types | option_info[i].flags;
- break;
- }
+ break;
+ command_info=option_info+i;
}
- if (option_info[i].mnemonic == (char *) NULL)
+ if (command_info->mnemonic == (const char *) NULL)
return(-1);
+ if (negate != MagickFalse)
+ option_types=option_types &~ command_info->flags;
+ else
+ option_types=option_types | command_info->flags;
if (list == MagickFalse)
break;
}
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetCommandOptionInfo() returns pointer to the matching OptionInfo entry
-% for the "CommandOptions" table only. A specialised binary search is used,
-% to speed up the lookup for that very large table, and returns both the
-% type (arg count) and flags (arg type).
-%
-% This search reduces linear search of over 500 options (250 tests on
-% average) to about 10 lookups!
+% GetCommandOptionInfo() returns a pointer to the matching OptionInfo entry
+% for the "CommandOptions" table. It returns both the type (argument count)
+% and flags (argument type).
%
% The format of the GetCommandOptionInfo method is:
%
-% const char **GetCommandOptions(const CommandOption value)
+% const char **GetCommandOptionInfo(const char *option)
%
% A description of each parameter follows:
%
-% o value: the value.
+% o option: the option.
%
*/
-MagickExport const OptionInfo *GetCommandOptionInfo(const char *value)
+MagickExport const OptionInfo *GetCommandOptionInfo(const char *option)
{
- const OptionInfo
- *option_info=CommandOptions;
-
- static ssize_t
- table_size = 0;
-
- register int
- i,l,h;
-
- assert(value != (char *) NULL);
- assert(*value != '\0');
-
- /* count up table items - first time only */
- if ( table_size == 0 )
- {
- l=-1;
- for (i=0; option_info[i].mnemonic != (const char *) NULL; i++)
- if ( LocaleCompare(value,option_info[i].mnemonic) == 0 )
- l=i;
- table_size = i;
- return( &option_info[(l>=0)?l:i] );
- }
+ register ssize_t
+ i;
- /* faster binary search of command table, now that its length is known */
- l=0;
- h=table_size;
- while ( l < h )
- {
- int cmp;
- i = (l+h)/2; /* half the bounds */
- /* compare string part, then switch character! */
- cmp=LocaleCompare(value+1,option_info[i].mnemonic+1);
- if ( cmp == 0 )
- cmp = *value - *(option_info[i].mnemonic);
-#if 0
- (void) FormatLocaleFile(stderr,
- "%d --- %u < %u < %u --- \"%s\" < \"%s\" < \"%s\"\n",
- cmp,l,i,h,option_info[l].mnemonic,option_info[i].mnemonic,
- option_info[h].mnemonic);
-#endif
- if (cmp == 0)
- return(&option_info[i]);
- if (cmp > 0) l=i+1; else h=i; /* reassign search bounds */
- }
- /* option was not found in table - return last 'null' entry. */
- return(&option_info[table_size]);
+ for (i=0; CommandOptions[i].mnemonic != (char *) NULL; i++)
+ if (LocaleCompare(option,CommandOptions[i].mnemonic) == 0)
+ break;
+ return(CommandOptions+i);
}
\f
/*
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetCommandOptions() returns a list of values.
+% GetCommandOptions() returns a list of command options.
%
% The format of the GetCommandOptions method is:
%
-% const char **GetCommandOptions(const CommandOption value)
+% const char **GetCommandOptions(const CommandOption option)
%
% A description of each parameter follows:
%
-% o value: the value.
+% o option: the option.
%
*/
-MagickExport char **GetCommandOptions(const CommandOption value)
+MagickExport char **GetCommandOptions(const CommandOption option)
{
char
- **values;
+ **options;
const OptionInfo
*option_info;
register ssize_t
i;
- option_info=GetOptionInfo(value);
+ option_info=GetOptionInfo(option);
if (option_info == (const OptionInfo *) NULL)
return((char **) NULL);
for (i=0; option_info[i].mnemonic != (const char *) NULL; i++) ;
- values=(char **) AcquireQuantumMemory((size_t) i+1UL,sizeof(*values));
- if (values == (char **) NULL)
+ options=(char **) AcquireQuantumMemory((size_t) i+1UL,sizeof(*options));
+ if (options == (char **) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
for (i=0; option_info[i].mnemonic != (const char *) NULL; i++)
- values[i]=AcquireString(option_info[i].mnemonic);
- values[i]=(char *) NULL;
- return(values);
+ options[i]=AcquireString(option_info[i].mnemonic);
+ options[i]=(char *) NULL;
+ return(options);
}
\f
/*
MagickExport char *GetNextImageOption(const ImageInfo *image_info)
{
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
if ((*option != '-') && (*option != '+'))
return(MagickFalse);
if (strlen(option) == 1)
- return(IsMagickTrue( (*option == '{') || (*option == '}')
- || (*option == '[') || (*option == ']') ));
+ return(((*option == '{') || (*option == '}') || (*option == '[') ||
+ (*option == ']')) ? MagickTrue : MagickFalse);
option++;
if (*option == '-')
return(MagickTrue);
if (type == option_info[i].type)
break;
if (option_info[i].mnemonic == (const char *) NULL)
- return("undefined");
+ return("Unrecognized");
return(option_info[i].mnemonic);
}
\f
% %
% %
% %
+% I s O p t i o n M e m b e r %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% IsOptionMember() returns MagickTrue if the option is a member of the options
+% list (e.g. ICC is a member of xmp,icc,iptc).
+%
+% The format of the IsOptionMember function is:
+%
+% MagickBooleanType IsOptionMember(const char *option,
+% const char *options)
+%
+% A description of each parameter follows:
+%
+% o option: an option or option expression (e.g. ICC or *).
+%
+% o options: one or more options separated by commas.
+%
+*/
+MagickExport MagickBooleanType IsOptionMember(const char *option,
+ const char *options)
+{
+ char
+ **option_list,
+ *string;
+
+ int
+ number_options;
+
+ MagickBooleanType
+ member;
+
+ register ssize_t
+ i;
+
+ /*
+ Is option a member of the options list?
+ */
+ if (options == (const char *) NULL)
+ return(MagickFalse);
+ string=ConstantString(options);
+ (void) SubstituteString(&string,","," ");
+ option_list=StringToArgv(string,&number_options);
+ string=DestroyString(string);
+ if (option_list == (char **) NULL)
+ return(MagickFalse);
+ member=MagickFalse;
+ for (i=1; i < (ssize_t) number_options; i++)
+ {
+ if ((*option_list[i] == '!') &&
+ (LocaleCompare(option,option_list[i]+1) == 0))
+ break;
+ if (GlobExpression(option,option_list[i],MagickTrue) != MagickFalse)
+ {
+ member=MagickTrue;
+ break;
+ }
+ option_list[i]=DestroyString(option_list[i]);
+ }
+ for ( ; i < (ssize_t) number_options; i++)
+ option_list[i]=DestroyString(option_list[i]);
+ option_list=(char **) RelinquishMagickMemory(option_list);
+ return(member);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
% L i s t C o m m a n d O p t i o n s %
% %
% %
%
% The format of the ParseCommandOption method is:
%
-% ssize_t ParseCommandOption(const CommandOption option_table,
+% ssize_t ParseCommandOption(const CommandOption option,
% const MagickBooleanType list,const char *options)
%
% A description of each parameter follows:
%
-% o option_table: Index to the option table to lookup
+% o option: Index to the option table to lookup
%
% o list: A option other than zero permits more than one option separated by
% a comma or pipe.
% o options: One or more options separated by commas.
%
*/
-MagickExport ssize_t ParseCommandOption(const CommandOption option_table,
+MagickExport ssize_t ParseCommandOption(const CommandOption option,
const MagickBooleanType list,const char *options)
{
char
- token[MaxTextExtent];
+ token[MagickPathExtent];
const OptionInfo
+ *command_info,
*option_info;
int
ssize_t
option_types;
- option_info=GetOptionInfo(option_table);
+ if (options == (const char *) NULL)
+ return(-1);
+ option_info=GetOptionInfo(option);
if (option_info == (const OptionInfo *) NULL)
return(-1);
option_types=0;
while (((isspace((int) ((unsigned char) *p)) == 0) && (*p != sentinel)) &&
(*p != '\0'))
{
- if ((q-token) >= (MaxTextExtent-1))
+ if ((q-token) >= (MagickPathExtent-1))
break;
*q++=(*p++);
}
*q='\0';
for (i=0; option_info[i].mnemonic != (char *) NULL; i++)
if (LocaleCompare(token,option_info[i].mnemonic) == 0)
- {
- if (*token == '!')
- option_types=option_types &~ option_info[i].type;
- else
- option_types=option_types | option_info[i].type;
- break;
- }
- if ((option_info[i].mnemonic == (char *) NULL) &&
+ break;
+ command_info=option_info+i;
+ if ((command_info->mnemonic == (const char *) NULL) &&
((strchr(token+1,'-') != (char *) NULL) ||
(strchr(token+1,'_') != (char *) NULL)))
- {
- while ((q=strchr(token+1,'-')) != (char *) NULL)
- (void) CopyMagickString(q,q+1,MaxTextExtent-strlen(q));
- while ((q=strchr(token+1,'_')) != (char *) NULL)
- (void) CopyMagickString(q,q+1,MaxTextExtent-strlen(q));
- for (i=0; option_info[i].mnemonic != (char *) NULL; i++)
- if (LocaleCompare(token,option_info[i].mnemonic) == 0)
- {
- if (*token == '!')
- option_types=option_types &~ option_info[i].type;
- else
- option_types=option_types | option_info[i].type;
+ {
+ while ((q=strchr(token+1,'-')) != (char *) NULL)
+ (void) CopyMagickString(q,q+1,MagickPathExtent-strlen(q));
+ while ((q=strchr(token+1,'_')) != (char *) NULL)
+ (void) CopyMagickString(q,q+1,MagickPathExtent-strlen(q));
+ for (i=0; option_info[i].mnemonic != (char *) NULL; i++)
+ if (LocaleCompare(token,option_info[i].mnemonic) == 0)
break;
- }
- }
- if (option_info[i].mnemonic == (char *) NULL)
+ command_info=option_info+i;
+ }
+ if (command_info->mnemonic == (const char *) NULL)
return(-1);
+ if (negate != MagickFalse)
+ option_types=option_types &~ command_info->type;
+ else
+ option_types=option_types | command_info->type;
if (list == MagickFalse)
break;
}
{
char
*q,
- token[MaxTextExtent];
+ token[MagickPathExtent];
ssize_t
channel;
if (channel >= 0)
return(channel);
q=(char *) token;
- channel=InterpretLocaleValue(token,&q);
+ channel=(ssize_t) InterpretLocaleValue(token,&q);
if ((q == token) || (channel < 0) || (channel >= MaxPixelChannels))
return(-1);
return(channel);
*value;
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
MagickExport void ResetImageOptions(const ImageInfo *image_info)
{
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
MagickExport void ResetImageOptionIterator(const ImageInfo *image_info)
{
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
const char *option,const char *value)
{
assert(image_info != (ImageInfo *) NULL);
- assert(image_info->signature == MagickSignature);
+ assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);