ChannelOptions[] =
{
{ "Undefined", UndefinedChannel, UndefinedOptionFlag, MagickTrue },
+ /* special */
{ "All", CompositeChannels, UndefinedOptionFlag, MagickFalse },
- { "Alpha", OpacityChannel, UndefinedOptionFlag, MagickFalse },
+ { "Sync", SyncChannels, UndefinedOptionFlag, MagickFalse },
+ { "Default", DefaultChannels, UndefinedOptionFlag, MagickFalse },
+ /* individual channel */
+ { "A", AlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Alpha", AlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "Black", BlackChannel, UndefinedOptionFlag, MagickFalse },
+ { "B", BlueChannel, UndefinedOptionFlag, MagickFalse },
{ "Blue", BlueChannel, UndefinedOptionFlag, MagickFalse },
+ { "C", CyanChannel, UndefinedOptionFlag, MagickFalse },
{ "Cyan", CyanChannel, UndefinedOptionFlag, MagickFalse },
- { "Default", DefaultChannels, UndefinedOptionFlag, MagickFalse },
{ "Gray", GrayChannel, UndefinedOptionFlag, MagickFalse },
+ { "G", GreenChannel, UndefinedOptionFlag, MagickFalse },
{ "Green", GreenChannel, UndefinedOptionFlag, MagickFalse },
+ { "H", RedChannel, UndefinedOptionFlag, MagickFalse },
{ "Hue", RedChannel, UndefinedOptionFlag, MagickFalse },
+ { "K", BlackChannel, UndefinedOptionFlag, MagickFalse },
+ { "L", BlueChannel, UndefinedOptionFlag, MagickFalse },
{ "Lightness", BlueChannel, UndefinedOptionFlag, MagickFalse },
{ "Luminance", BlueChannel, UndefinedOptionFlag, MagickFalse },
{ "Luminosity", BlueChannel, DeprecateOptionFlag, MagickTrue },
+ { "M", MagentaChannel, UndefinedOptionFlag, MagickFalse },
{ "Magenta", MagentaChannel, UndefinedOptionFlag, MagickFalse },
- { "Matte", OpacityChannel, UndefinedOptionFlag, MagickFalse },
- { "Opacity", OpacityChannel, UndefinedOptionFlag, MagickFalse },
+ { "Matte", AlphaChannel, DeprecateOptionFlag, MagickTrue },/*depreciate*/
+ { "Opacity", AlphaChannel, DeprecateOptionFlag, MagickTrue },/*depreciate*/
+ { "R", RedChannel, UndefinedOptionFlag, MagickFalse },
{ "Red", RedChannel, UndefinedOptionFlag, MagickFalse },
+ { "S", GreenChannel, UndefinedOptionFlag, MagickFalse },
{ "Saturation", GreenChannel, UndefinedOptionFlag, MagickFalse },
+ { "Y", YellowChannel, UndefinedOptionFlag, MagickFalse },
{ "Yellow", YellowChannel, UndefinedOptionFlag, MagickFalse },
- { "Sync", SyncChannels, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedChannel, UndefinedOptionFlag, MagickFalse }
},
ClassOptions[] =
},
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...
+ */
{ "(", 0L, SpecialOptionFlag, MagickTrue },
{ ")", 0L, SpecialOptionFlag, MagickTrue },
- { "+adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "{", 0L, SpecialOptionFlag, MagickTrue },
+ { "}", 0L, SpecialOptionFlag, MagickTrue },
+ { "--", 1L, SpecialOptionFlag, MagickTrue },
{ "+adaptive-blur", 1L, DeprecateOptionFlag, MagickTrue },
{ "-adaptive-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+adaptive-resize", 1L, DeprecateOptionFlag, MagickTrue },
{ "-adaptive-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+adaptive-sharpen", 1L, DeprecateOptionFlag, MagickTrue },
{ "-adaptive-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+affine", 0L, DrawInfoOptionFlag | DeprecateOptionFlag, MagickTrue },
- { "-affine", 1L, DrawInfoOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "+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 },
{ "+append", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "-append", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+attenuate", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-attenuate", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-attenuate", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+authenticate", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-authenticate", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+auto-gamma", 0L, DeprecateOptionFlag, MagickTrue },
{ "-auto-level", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "+auto-orient", 0L, DeprecateOptionFlag, MagickTrue },
{ "-auto-orient", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+average", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickTrue },
- { "-average", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickTrue },
- { "+backdrop", 0L, NonConvertOptionFlag, MagickFalse },
- { "-backdrop", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+average", 0L, DeprecateOptionFlag, MagickTrue },
+ { "-average", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
+ { "+backdrop", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-backdrop", 1L, NonMagickOptionFlag, MagickFalse },
{ "+background", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-background", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+bench", 0L, GenesisOptionFlag, MagickFalse },
+ { "+bench", 1L, DeprecateOptionFlag, MagickTrue },
{ "-bench", 1L, GenesisOptionFlag, MagickFalse },
{ "+bias", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-bias", 1L, ImageInfoOptionFlag, MagickFalse },
{ "-black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+black-threshold", 0L, DeprecateOptionFlag, MagickTrue },
{ "-black-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+blend", 0L, NonConvertOptionFlag, MagickFalse },
- { "-blend", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+blend", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-blend", 1L, NonMagickOptionFlag, MagickFalse },
{ "+blue-primary", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-blue-primary", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+blue-shift", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "-border", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+bordercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-bordercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+borderwidth", 0L, NonConvertOptionFlag, MagickFalse },
- { "-borderwidth", 1L, NonConvertOptionFlag, MagickFalse },
- { "+box", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag | DeprecateOptionFlag, MagickTrue },
- { "-box", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "+borderwidth", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-borderwidth", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+box", 0L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
+ { "-box", 1L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
{ "+brightness-contrast", 0L, DeprecateOptionFlag, MagickTrue },
{ "-brightness-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+cache", 0L, GlobalOptionFlag, MagickFalse },
{ "-caption", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+cdl", 1L, DeprecateOptionFlag, MagickTrue },
{ "-cdl", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+channel", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "-channel", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "+channel", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-channel", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-channel-fx", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+charcoal", 0L, DeprecateOptionFlag, MagickTrue },
{ "-charcoal", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "+chop", 1L, DeprecateOptionFlag, MagickTrue },
{ "-clip-path", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+clone", 0L, SpecialOptionFlag, MagickFalse },
{ "-clone", 1L, SpecialOptionFlag, MagickFalse },
- { "+clut", 0L, FireOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "+clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-clut", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+coalesce", 0L, FireOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "+coalesce", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-coalesce", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+colorize", 1L, DeprecateOptionFlag, MagickTrue },
- { "-colorize", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+colormap", 0L, NonConvertOptionFlag, MagickFalse },
- { "-colormap", 1L, NonConvertOptionFlag, MagickFalse },
{ "+color-matrix", 1L, DeprecateOptionFlag, MagickTrue },
{ "-color-matrix", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+colorize", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-colorize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+colormap", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-colormap", 1L, NonMagickOptionFlag, MagickFalse },
{ "+colors", 1L, DeprecateOptionFlag, MagickTrue },
- { "-colors", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+colorspace", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
{ "-colorspace", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "+combine", 0L, FireOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "+combine", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-combine", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+comment", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-comment", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+compose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-compose", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+composite", 0L, FireOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "+composite", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-composite", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+compress", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-compress", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+concurrent", 0L, GenesisOptionFlag, MagickTrue },
- { "-concurrent", 0L, GenesisOptionFlag, MagickTrue },
- { "+contrast", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-contrast", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+concurrent", 0L, DeprecateOptionFlag, MagickTrue },
+ { "-concurrent", 0L, GenesisOptionFlag, MagickFalse },
+ { "+contrast", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+ { "-contrast", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
{ "+contrast-stretch", 1L, DeprecateOptionFlag, MagickTrue },
{ "-contrast-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+convolve", 1L, DeprecateOptionFlag, MagickTrue },
{ "-crop", 1L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+cycle", 1L, DeprecateOptionFlag, MagickTrue },
{ "-cycle", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+debug", 0L, GlobalOptionFlag|GenesisOptionFlag | FireOptionFlag, MagickFalse },
- { "-debug", 1L, GlobalOptionFlag|GenesisOptionFlag | FireOptionFlag, MagickFalse },
+ { "+debug", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
+ { "-debug", 1L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
{ "+decipher", 1L, DeprecateOptionFlag, MagickTrue },
{ "-decipher", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+deconstruct", 0L, DeprecateOptionFlag, MagickTrue },
- { "-deconstruct", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "-deconstruct", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
{ "+define", 1L, ImageInfoOptionFlag, MagickFalse },
{ "-define", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+delay", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-delete", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+density", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-density", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+depth", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-depth", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+descend", 0L, NonConvertOptionFlag, MagickFalse },
- { "-descend", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+depth", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "-depth", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "+descend", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-descend", 1L, NonMagickOptionFlag, MagickFalse },
{ "+deskew", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-deskew", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+despeckle", 0L, DeprecateOptionFlag, MagickTrue },
{ "-despeckle", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "+direction", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-direction", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+displace", 0L, NonConvertOptionFlag, MagickFalse },
- { "-displace", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+displace", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-displace", 1L, NonMagickOptionFlag, MagickFalse },
{ "+display", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-display", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+dispose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-dispose", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+dissolve", 0L, NonConvertOptionFlag, MagickFalse },
- { "-dissolve", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+dissolve", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-dissolve", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+dissimilarity-threshold", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-dissimilarity-threshold", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
{ "+distort", 2L, SimpleOperatorOptionFlag, MagickFalse },
{ "-distort", 2L, SimpleOperatorOptionFlag, MagickFalse },
{ "+dither", 0L, ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse },
{ "-evaluate", 2L, SimpleOperatorOptionFlag, MagickFalse },
{ "+evaluate-sequence", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-evaluate-sequence", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-exit", 1L, SpecialOptionFlag, MagickFalse },
+ { "-exit", 0L, SpecialOptionFlag, MagickFalse },
{ "+extent", 1L, DeprecateOptionFlag, MagickTrue },
{ "-extent", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+extract", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-flatten", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+flip", 0L, DeprecateOptionFlag, MagickTrue },
{ "-flip", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+flop", 0L, DeprecateOptionFlag, MagickTrue },
- { "-flop", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "+floodfill", 2L, SimpleOperatorOptionFlag, MagickFalse },
{ "-floodfill", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+flop", 0L, DeprecateOptionFlag, MagickTrue },
+ { "-flop", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "+font", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-font", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+foreground", 0L, NonConvertOptionFlag, MagickFalse },
- { "-foreground", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+foreground", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-foreground", 1L, NonMagickOptionFlag, MagickFalse },
{ "+format", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-format", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+frame", 1L, DeprecateOptionFlag, MagickTrue },
{ "+gamma", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-gamma", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+gaussian", 1L, DeprecateOptionFlag, MagickTrue },
- { "-gaussian", 1L, SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "-gaussian", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
{ "+gaussian-blur", 1L, DeprecateOptionFlag, MagickTrue },
{ "-gaussian-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+geometry", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-green-primary", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+hald-clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-hald-clut", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+highlight-color", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-highlight-color", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+iconGeometry", 0L, NonConvertOptionFlag, MagickFalse },
- { "-iconGeometry", 1L, NonConvertOptionFlag, MagickFalse },
- { "+iconic", 0L, NonConvertOptionFlag, MagickFalse },
- { "-iconic", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+highlight-color", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-highlight-color", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "+iconGeometry", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-iconGeometry", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+iconic", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-iconic", 1L, NonMagickOptionFlag, MagickFalse },
{ "+identify", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-identify", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+ift", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "-ift", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+immutable", 0L, NonConvertOptionFlag, MagickFalse },
- { "-immutable", 0L, NonConvertOptionFlag, MagickFalse },
+ { "+immutable", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-immutable", 0L, NonMagickOptionFlag, MagickFalse },
{ "+implode", 0L, DeprecateOptionFlag, MagickTrue },
{ "-implode", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+insert", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "-interline-spacing", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+interpolate", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-interpolate", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+interword-spacing", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "-interword-spacing", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+interpolative-resize", 1L, DeprecateOptionFlag, MagickTrue },
{ "-interpolative-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+interword-spacing", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "-interword-spacing", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+kerning", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-kerning", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+label", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+level-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "-level-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+limit", 0L, DeprecateOptionFlag, MagickTrue },
- { "-limit", 2L, GlobalOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-limit", 2L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
{ "+linear-stretch", 1L, DeprecateOptionFlag, MagickTrue },
{ "-linear-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+liquid-rescale", 1L, DeprecateOptionFlag, MagickTrue },
{ "-liquid-rescale", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+list", 0L, DeprecateOptionFlag, MagickTrue },
- { "-list", 1L, GlobalOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-list", 1L, SpecialOptionFlag, MagickFalse },
{ "+log", 0L, DeprecateOptionFlag, MagickFalse },
{ "-log", 1L, GlobalOptionFlag, MagickFalse },
{ "+loop", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-loop", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+lowlight-color", 1L, DeprecateOptionFlag, MagickTrue },
- { "-lowlight-color", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+magnify", 0L, NonConvertOptionFlag, MagickFalse },
- { "-magnify", 1L, NonConvertOptionFlag, MagickFalse },
- { "+map", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickTrue },
- { "-map", 1L, SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "+lowlight-color", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-lowlight-color", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "+magnify", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-magnify", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+map", 0L, ReplacedOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
+ { "-map", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
{ "+mask", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-mask", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+matte", 0L, SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickTrue },
- { "-matte", 0L, SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "+matte", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+ { "-matte", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
{ "+mattecolor", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-mattecolor", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "+median", 1L, DeprecateOptionFlag, MagickTrue },
- { "-median", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "+metric", 0L, NonConvertOptionFlag, MagickFalse },
- { "-metric", 1L, NonConvertOptionFlag, MagickFalse },
+ { "-median", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag | FireOptionFlag, MagickTrue },
+ { "+metric", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-metric", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "+mode", 1L, NonConvertOptionFlag, MagickFalse },
- { "-mode", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+mode", 1L, NonMagickOptionFlag, MagickFalse },
+ { "-mode", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
{ "+modulate", 1L, DeprecateOptionFlag, MagickTrue },
{ "-modulate", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
{ "-mosaic", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+motion-blur", 1L, DeprecateOptionFlag, MagickTrue },
{ "-motion-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+name", 0L, NonConvertOptionFlag, MagickFalse },
- { "-name", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+name", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-name", 1L, NonMagickOptionFlag, MagickFalse },
{ "+negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "+noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-noise", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
{ "-noop", 0L, SpecialOptionFlag, MagickFalse },
{ "+normalize", 0L, DeprecateOptionFlag, MagickTrue },
{ "-normalize", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-ordered-dither", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+orient", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-orient", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+origin", 0L, DeprecateOptionFlag, MagickTrue },
- { "-origin", 1L, DeprecateOptionFlag, MagickTrue },
{ "+page", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-page", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+paint", 0L, DeprecateOptionFlag, MagickTrue },
{ "-paint", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+path", 0L, NonConvertOptionFlag, MagickFalse },
- { "-path", 1L, NonConvertOptionFlag, MagickFalse },
- { "+pause", 0L, NonConvertOptionFlag, MagickFalse },
- { "-pause", 1L, NonConvertOptionFlag, MagickFalse },
- { "+passphrase", 0L, DeprecateOptionFlag, MagickTrue },
- { "-passphrase", 1L, DeprecateOptionFlag, MagickTrue },
+ { "+path", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-path", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+pause", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-pause", 1L, NonMagickOptionFlag, MagickFalse },
{ "+ping", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-ping", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+pointsize", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-polaroid", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+posterize", 1L, DeprecateOptionFlag, MagickTrue },
{ "-posterize", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+precision", 0L, GlobalOptionFlag, MagickFalse },
- { "-precision", 1L, GlobalOptionFlag, MagickFalse },
- { "+preview", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "-preview", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "+precision", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-precision", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+preview", 0L, DeprecateOptionFlag, MagickTrue },
+ { "-preview", 1L, GlobalOptionFlag, MagickFalse },
{ "+print", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-print", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+process", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-raise", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+random-threshold", 1L, DeprecateOptionFlag, MagickTrue },
{ "-random-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-read", 1L, ListOperatorOptionFlag, MagickFalse },
+ { "-read", 1L, SpecialOptionFlag, MagickFalse },
{ "+recolor", 1L, DeprecateOptionFlag, MagickTrue },
- { "-recolor", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-recolor", 1L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
{ "+red-primary", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-red-primary", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+regard-warnings", 0L, GenesisOptionFlag, MagickFalse },
- { "-regard-warnings", 0L, GenesisOptionFlag, MagickFalse },
+ { "+regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+region", 0L, SpecialOptionFlag, MagickFalse },
{ "-region", 1L, SpecialOptionFlag, MagickFalse },
- { "+remote", 0L, NonConvertOptionFlag, MagickFalse },
- { "-remote", 1L, NonConvertOptionFlag, MagickFalse },
- { "+render", 0L, DrawInfoOptionFlag, MagickFalse },
- { "-render", 0L, DrawInfoOptionFlag, MagickFalse },
{ "+remap", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "-remap", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+remote", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-remote", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+render", 0L, DrawInfoOptionFlag, MagickFalse },
+ { "-render", 0L, DrawInfoOptionFlag, MagickFalse },
{ "+repage", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-repage", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+resample", 1L, DeprecateOptionFlag, MagickTrue },
{ "-resample", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+resize", 1L, DeprecateOptionFlag, MagickTrue },
{ "-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+respect-parenthesis", 0L, SpecialOptionFlag, MagickFalse },
- { "-respect-parenthesis", 0L, SpecialOptionFlag, MagickFalse },
+ { "+respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+reverse", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-reverse", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+roll", 1L, DeprecateOptionFlag, MagickTrue },
{ "-sample", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+sampling-factor", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-sampling-factor", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+sans", 1L, SpecialOptionFlag, MagickTrue }, /* equivelent 'noop' */
+ { "+sans", 1L, SpecialOptionFlag, MagickTrue },
{ "-sans", 1L, SpecialOptionFlag, MagickTrue },
- { "+sans0", 0L, SpecialOptionFlag, MagickTrue },
+ { "+sans0", 0L, SpecialOptionFlag, MagickTrue }, /* equivelent to 'noop' */
{ "-sans0", 0L, SpecialOptionFlag, MagickTrue },
{ "+sans2", 2L, SpecialOptionFlag, MagickTrue },
{ "-sans2", 2L, SpecialOptionFlag, MagickTrue },
{ "-scale", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+scene", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-scene", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+scenes", 0L, NonConvertOptionFlag, MagickFalse },
- { "-scenes", 1L, NonConvertOptionFlag, MagickFalse },
- { "+screen", 0L, NonConvertOptionFlag, MagickFalse },
- { "-screen", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+scenes", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-scenes", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+screen", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-screen", 1L, NonMagickOptionFlag, MagickFalse },
+ { "-script", 1L, UndefinedOptionFlag, MagickFalse }, /* special handling */
{ "+seed", 0L, GlobalOptionFlag, MagickFalse },
{ "-seed", 1L, GlobalOptionFlag, MagickFalse },
{ "+segment", 1L, DeprecateOptionFlag, MagickTrue },
{ "-shade", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+shadow", 1L, DeprecateOptionFlag, MagickTrue },
{ "-shadow", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+shared-memory", 0L, NonConvertOptionFlag, MagickFalse },
- { "-shared-memory", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+shared-memory", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-shared-memory", 1L, NonMagickOptionFlag, MagickFalse },
{ "+sharpen", 1L, DeprecateOptionFlag, MagickTrue },
{ "-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+shave", 1L, DeprecateOptionFlag, MagickTrue },
{ "-shear", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+sigmoidal-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "-sigmoidal-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+silent", 0L, NonConvertOptionFlag, MagickFalse },
- { "-silent", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+silent", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-silent", 1L, NonMagickOptionFlag, MagickFalse },
{ "+size", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-size", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+sketch", 1L, DeprecateOptionFlag, MagickTrue },
{ "-sketch", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+smush", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "-smush", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+snaps", 0L, NonConvertOptionFlag, MagickFalse },
- { "-snaps", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+snaps", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-snaps", 1L, NonMagickOptionFlag, MagickFalse },
{ "+solarize", 1L, DeprecateOptionFlag, MagickTrue },
{ "-solarize", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+sparse-color", 2L, DeprecateOptionFlag, MagickTrue },
+ { "+sparse-color", 1L, DeprecateOptionFlag, MagickTrue },
{ "-sparse-color", 2L, SimpleOperatorOptionFlag, MagickFalse },
{ "+splice", 1L, DeprecateOptionFlag, MagickTrue },
{ "-splice", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "-spread", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+statistic", 2L, DeprecateOptionFlag, MagickTrue },
{ "-statistic", 2L, SimpleOperatorOptionFlag, MagickFalse },
- { "+stegano", 0L, NonConvertOptionFlag, MagickFalse },
- { "-stegano", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+stegano", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-stegano", 1L, NonMagickOptionFlag, MagickFalse },
{ "+stereo", 0L, DeprecateOptionFlag, MagickTrue },
- { "-stereo", 1L, NonConvertOptionFlag, MagickFalse },
+ { "-stereo", 1L, NonMagickOptionFlag, MagickFalse },
{ "+stretch", 1L, DeprecateOptionFlag, MagickTrue },
{ "-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+strip", 0L, DeprecateOptionFlag, MagickTrue },
{ "-strokewidth", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+style", 0L, DrawInfoOptionFlag, MagickFalse },
{ "-style", 1L, DrawInfoOptionFlag, MagickFalse },
- { "+subimage-search", 0L, NonConvertOptionFlag, MagickFalse },
- { "-subimage-search", 0L, NonConvertOptionFlag, MagickFalse },
+// { "+subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+// { "-subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-subimage", 0L, ListOperatorOptionFlag, MagickFalse },
{ "+swap", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "-swap", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
{ "+swirl", 1L, DeprecateOptionFlag, MagickTrue },
{ "-synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+taint", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-taint", 0L, ImageInfoOptionFlag, MagickFalse },
- { "+text-font", 0L, NonConvertOptionFlag, MagickFalse },
- { "-text-font", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+text-font", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-text-font", 1L, NonMagickOptionFlag, MagickFalse },
{ "+texture", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-texture", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+threshold", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-tile-offset", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+tint", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "-tint", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+title", 0L, NonConvertOptionFlag, MagickFalse },
- { "-title", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+title", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-title", 1L, NonMagickOptionFlag, MagickFalse },
{ "+transform", 0L, DeprecateOptionFlag, MagickTrue },
- { "-transform", 0L, SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickTrue },
+ { "-transform", 0L, ReplacedOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
{ "+transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "-transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+transparent-color", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+transpose", 0L, DeprecateOptionFlag, MagickTrue },
{ "-transpose", 0L, SimpleOperatorOptionFlag, MagickFalse },
{ "-units", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+unsharp", 1L, DeprecateOptionFlag, MagickTrue },
{ "-unsharp", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+update", 0L, NonConvertOptionFlag, MagickFalse },
- { "-update", 1L, NonConvertOptionFlag, MagickFalse },
- { "+use-pixmap", 0L, NonConvertOptionFlag, MagickFalse },
- { "-use-pixmap", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+update", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-update", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+use-pixmap", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-use-pixmap", 1L, NonMagickOptionFlag, MagickFalse },
{ "+verbose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-verbose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+version", 0L, DeprecateOptionFlag, MagickTrue },
{ "-view", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+vignette", 1L, DeprecateOptionFlag, MagickTrue },
{ "-vignette", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+virtual-pixel", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "-virtual-pixel", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "+visual", 0L, NonConvertOptionFlag, MagickFalse },
- { "-visual", 1L, NonConvertOptionFlag, MagickFalse },
- { "+watermark", 0L, NonConvertOptionFlag, MagickFalse },
- { "-watermark", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+virtual-pixel", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-virtual-pixel", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+visual", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-visual", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+watermark", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-watermark", 1L, NonMagickOptionFlag, MagickFalse },
{ "+wave", 1L, DeprecateOptionFlag, MagickTrue },
{ "-wave", 1L, SimpleOperatorOptionFlag, MagickFalse },
{ "+weight", 1L, DeprecateOptionFlag, MagickTrue },
{ "-white-point", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+white-threshold", 1L, DeprecateOptionFlag, MagickTrue },
{ "-white-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+window", 0L, NonConvertOptionFlag, MagickFalse },
- { "-window", 1L, NonConvertOptionFlag, MagickFalse },
- { "+window-group", 0L, NonConvertOptionFlag, MagickFalse },
- { "-window-group", 1L, NonConvertOptionFlag, MagickFalse },
- { "+write", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-write", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+window", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-window", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+window-group", 0L, NonMagickOptionFlag, MagickFalse },
+ { "-window-group", 1L, NonMagickOptionFlag, MagickFalse },
+ { "+write", 1L, SpecialOptionFlag | FireOptionFlag, MagickFalse },
+ { "-write", 1L, SpecialOptionFlag | FireOptionFlag, MagickFalse },
{ (char *) NULL, 0L, UndefinedOptionFlag, MagickFalse }
},
ComposeOptions[] =
{ "DstIn", DstInCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "DstOut", DstOutCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "DstOver", DstOverCompositeOp, UndefinedOptionFlag, MagickFalse },
- { "Dst", DstCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Exclusion", ExclusionCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "HardLight", HardLightCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Hue", HueCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "SrcIn", SrcInCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "SrcOut", SrcOutCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "SrcOver", SrcOverCompositeOp, UndefinedOptionFlag, MagickFalse },
- { "Src", SrcCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "VividLight", VividLightCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Xor", XorCompositeOp, UndefinedOptionFlag, MagickFalse },
{ "Divide", DivideDstCompositeOp, DeprecateOptionFlag, MagickTrue },
{ "Minus", MinusDstCompositeOp, DeprecateOptionFlag, MagickTrue },
{ "Threshold", ThresholdCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { "CopyOpacity", CopyAlphaCompositeOp, UndefinedOptionFlag, MagickTrue },
{ (char *) NULL, UndefinedCompositeOp, UndefinedOptionFlag, MagickFalse }
},
CompressOptions[] =
},
DistortOptions[] =
{
- { "Undefined", UndefinedDistortion, UndefinedOptionFlag, MagickTrue },
{ "Affine", AffineDistortion, UndefinedOptionFlag, MagickFalse },
{ "AffineProjection", AffineProjectionDistortion, UndefinedOptionFlag, MagickFalse },
{ "ScaleRotateTranslate", ScaleRotateTranslateDistortion, UndefinedOptionFlag, MagickFalse },
{ "filter", FilterInterpolatePixel, UndefinedOptionFlag, MagickFalse },
{ "Integer", IntegerInterpolatePixel, UndefinedOptionFlag, MagickFalse },
{ "Mesh", MeshInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Nearest", NearestNeighborInterpolatePixel, UndefinedOptionFlag, MagickFalse },
{ "NearestNeighbor", NearestNeighborInterpolatePixel, UndefinedOptionFlag, MagickFalse },
{ "Spline", SplineInterpolatePixel, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedInterpolatePixel, UndefinedOptionFlag, MagickFalse }
{ "Edge", EdgeMorphology, UndefinedOptionFlag, MagickFalse },
{ "TopHat", TopHatMorphology, UndefinedOptionFlag, MagickFalse },
{ "BottomHat", BottomHatMorphology, UndefinedOptionFlag, MagickFalse },
- { "Distance", DistanceMorphology, UndefinedOptionFlag, MagickFalse },
{ "Hmt", HitAndMissMorphology, UndefinedOptionFlag, MagickFalse },
{ "HitNMiss", HitAndMissMorphology, UndefinedOptionFlag, MagickFalse },
{ "HitAndMiss", HitAndMissMorphology, UndefinedOptionFlag, MagickFalse },
{ "Thinning", ThinningMorphology, UndefinedOptionFlag, MagickFalse },
{ "Thicken", ThickenMorphology, UndefinedOptionFlag, MagickFalse },
+ { "Distance", DistanceMorphology, UndefinedOptionFlag, MagickFalse },
+ { "IterativeDistance", IterativeDistanceMorphology, UndefinedOptionFlag, MagickFalse },
{ "Voronoi", VoronoiMorphology, UndefinedOptionFlag, MagickTrue },
{ (char *) NULL, UndefinedMorphology, UndefinedOptionFlag, MagickFalse }
},
PixelChannelOptions[] =
{
{ "Undefined", UndefinedPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "A", AlphaPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Alpha", AlphaPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "B", BluePixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "Bk", BlackPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Black", BlackPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Blue", BluePixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Cb", CbPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Composite", CompositePixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "C", CyanPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Cr", CrPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Cyan", CyanPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Gray", GrayPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "G", GreenPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Green", GreenPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Index", IndexPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Intensity", IntensityPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "K", BlackPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "M", MagentaPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Magenta", MagentaPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Mask", MaskPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "R", RedPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Red", RedPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Sync", SyncPixelChannel, UndefinedOptionFlag, MagickFalse },
- { "Y", YPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "Y", YellowPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Yellow", YellowPixelChannel, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedPixelChannel, UndefinedOptionFlag, MagickFalse }
},
{ "Median", MedianStatistic, UndefinedOptionFlag, MagickFalse },
{ "Minimum", MinimumStatistic, UndefinedOptionFlag, MagickFalse },
{ "Mode", ModeStatistic, UndefinedOptionFlag, MagickFalse },
- { "Nonpeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse },
+ { "NonPeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse },
{ "StandardDeviation", StandardDeviationStatistic, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedMethod, UndefinedOptionFlag, MagickFalse }
},
{ (char *) NULL, UndefinedVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }
};
\f
+static const OptionInfo *GetOptionInfo(const CommandOption option)
+{
+ switch (option)
+ {
+ case MagickAlignOptions: return(AlignOptions);
+ case MagickAlphaOptions: return(AlphaOptions);
+ case MagickBooleanOptions: return(BooleanOptions);
+ 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 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);
+}
+\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
%
% DeleteImageOption() deletes an key from the image map.
%
+% Returns MagickTrue is the option is found and deleted from the Options.
+%
% The format of the DeleteImageOption method is:
%
% MagickBooleanType DeleteImageOption(ImageInfo *image_info,
%
*/
-static const OptionInfo *GetOptionInfo(const CommandOption option)
-{
- switch (option)
- {
- case MagickAlignOptions: return(AlignOptions);
- case MagickAlphaOptions: return(AlphaOptions);
- case MagickBooleanOptions: return(BooleanOptions);
- 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 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);
-}
-
MagickExport ssize_t GetCommandOptionFlags(const CommandOption option,
const MagickBooleanType list,const char *options)
{
% %
% %
% %
+% G e t C o m m a n d O p t i o n I n f o %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% 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 of
+% average) to about 10 lookups!
+%
+% The format of the GetCommandOptionInfo method is:
+%
+% const char **GetCommandOptions(const CommandOption value)
+%
+% A description of each parameter follows:
+%
+% o value: the value.
+%
+*/
+MagickExport const OptionInfo *GetCommandOptionInfo(const char *value)
+{
+ 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] );
+ }
+
+ /* 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]);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
% G e t C o m m a n d O p t i o n s %
% %
% %
case 'A':
case 'a':
{
- channel|=OpacityChannel;
+ channel|=AlphaChannel;
break;
}
case 'B':
case 'o':
case 'O':
{
- channel|=OpacityChannel;
+ channel|=AlphaChannel; /* depreciate */
break;
}
case 'R':
% %
% %
% %
+% P a r s e P i x e l C h a n n e l O p t i o n %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% ParsePixelChannelOption() parses a string and returns an enumerated pixel
+% channel type(s).
+%
+% The format of the ParsePixelChannelOption method is:
+%
+% ssize_t ParsePixelChannelOption(const char *channels)
+%
+% A description of each parameter follows:
+%
+% o channels: One or more channels separated by commas.
+%
+*/
+MagickExport ssize_t ParsePixelChannelOption(const char *channels)
+{
+ char
+ *q,
+ token[MaxTextExtent];
+
+ ssize_t
+ channel;
+
+ GetMagickToken(channels,NULL,token);
+ if ((*token == ';') || (*token == '|'))
+ return(RedPixelChannel);
+ channel=ParseCommandOption(MagickPixelChannelOptions,MagickTrue,token);
+ if (channel >= 0)
+ return(channel);
+ q=(char *) token;
+ channel=InterpretLocaleValue(token,&q);
+ if ((q == token) || (channel < 0) || (channel >= MaxPixelChannels))
+ return(-1);
+ return(channel);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
% R e m o v e I m a g e O p t i o n %
% %
% %