static const OptionInfo
AlignOptions[] =
{
- { "Undefined", (ssize_t) UndefinedAlign, MagickTrue },
- { "Center", (ssize_t) CenterAlign, MagickFalse },
- { "End", (ssize_t) RightAlign, MagickFalse },
- { "Left", (ssize_t) LeftAlign, MagickFalse },
- { "Middle", (ssize_t) CenterAlign, MagickFalse },
- { "Right", (ssize_t) RightAlign, MagickFalse },
- { "Start", (ssize_t) LeftAlign, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedAlign, MagickFalse }
+ { "Undefined", UndefinedAlign, UndefinedOptionFlag, MagickTrue },
+ { "Center", CenterAlign, UndefinedOptionFlag, MagickFalse },
+ { "End", RightAlign, UndefinedOptionFlag, MagickFalse },
+ { "Left", LeftAlign, UndefinedOptionFlag, MagickFalse },
+ { "Middle", CenterAlign, UndefinedOptionFlag, MagickFalse },
+ { "Right", RightAlign, UndefinedOptionFlag, MagickFalse },
+ { "Start", LeftAlign, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedAlign, UndefinedOptionFlag, MagickFalse }
},
AlphaOptions[] =
{
- { "Undefined", (ssize_t) UndefinedAlphaChannel, MagickTrue },
- { "Activate", (ssize_t) ActivateAlphaChannel, MagickFalse },
- { "Background", (ssize_t) BackgroundAlphaChannel, MagickFalse },
- { "Copy", (ssize_t) CopyAlphaChannel, MagickFalse },
- { "Deactivate", (ssize_t) DeactivateAlphaChannel, MagickFalse },
- { "Extract", (ssize_t) ExtractAlphaChannel, MagickFalse },
- { "Off", (ssize_t) DeactivateAlphaChannel, MagickFalse },
- { "On", (ssize_t) ActivateAlphaChannel, MagickFalse },
- { "Opaque", (ssize_t) OpaqueAlphaChannel, MagickFalse },
- { "Set", (ssize_t) SetAlphaChannel, MagickFalse },
- { "Shape", (ssize_t) ShapeAlphaChannel, MagickFalse },
- { "Reset", (ssize_t) SetAlphaChannel, MagickTrue }, /* deprecated */
- { "Transparent", (ssize_t) TransparentAlphaChannel, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedAlphaChannel, MagickFalse }
+ { "Undefined", UndefinedAlphaChannel, UndefinedOptionFlag, MagickTrue },
+ { "Activate", ActivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Background", BackgroundAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Copy", CopyAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Deactivate", DeactivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Extract", ExtractAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Off", DeactivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "On", ActivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Opaque", OpaqueAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Set", SetAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Shape", ShapeAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Reset", SetAlphaChannel, DeprecateOptionFlag, MagickTrue },
+ { "Transparent", TransparentAlphaChannel, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedAlphaChannel, UndefinedOptionFlag, MagickFalse }
},
BooleanOptions[] =
{
- { "False", 0L, MagickFalse },
- { "True", 1L, MagickFalse },
- { "0", 0L, MagickFalse },
- { "1", 1L, MagickFalse },
- { (char *) NULL, 0L, MagickFalse }
+ { "False", 0L, UndefinedOptionFlag, MagickFalse },
+ { "True", 1L, UndefinedOptionFlag, MagickFalse },
+ { "0", 0L, UndefinedOptionFlag, MagickFalse },
+ { "1", 1L, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, 0L, UndefinedOptionFlag, MagickFalse }
},
ChannelOptions[] =
{
- { "Undefined", (ssize_t) UndefinedChannel, MagickTrue },
- { "All", (ssize_t) AllChannels, MagickFalse },
- { "Alpha", (ssize_t) OpacityChannel, MagickFalse },
- { "Black", (ssize_t) BlackChannel, MagickFalse },
- { "Blue", (ssize_t) BlueChannel, MagickFalse },
- { "Cyan", (ssize_t) CyanChannel, MagickFalse },
- { "Default", (ssize_t) DefaultChannels, MagickFalse },
- { "Gray", (ssize_t) GrayChannel, MagickFalse },
- { "Green", (ssize_t) GreenChannel, MagickFalse },
- { "Hue", (ssize_t) RedChannel, MagickFalse },
- { "Index", (ssize_t) IndexChannel, MagickFalse },
- { "Lightness", (ssize_t) BlueChannel, MagickFalse },
- { "Luminance", (ssize_t) BlueChannel, MagickFalse },
- { "Luminosity", (ssize_t) BlueChannel, MagickFalse }, /* deprecated */
- { "Magenta", (ssize_t) MagentaChannel, MagickFalse },
- { "Matte", (ssize_t) OpacityChannel, MagickFalse },
- { "Opacity", (ssize_t) OpacityChannel, MagickFalse },
- { "Red", (ssize_t) RedChannel, MagickFalse },
- { "Saturation", (ssize_t) GreenChannel, MagickFalse },
- { "Yellow", (ssize_t) YellowChannel, MagickFalse },
- { "Sync", (ssize_t) SyncChannels, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedChannel, MagickFalse }
+ { "Undefined", UndefinedChannel, UndefinedOptionFlag, MagickTrue },
+ { "All", CompositeChannels, UndefinedOptionFlag, MagickFalse },
+ { "Alpha", OpacityChannel, UndefinedOptionFlag, MagickFalse },
+ { "Black", BlackChannel, UndefinedOptionFlag, MagickFalse },
+ { "Blue", BlueChannel, UndefinedOptionFlag, MagickFalse },
+ { "Cyan", CyanChannel, UndefinedOptionFlag, MagickFalse },
+ { "Default", DefaultChannels, UndefinedOptionFlag, MagickFalse },
+ { "Gray", GrayChannel, UndefinedOptionFlag, MagickFalse },
+ { "Green", GreenChannel, UndefinedOptionFlag, MagickFalse },
+ { "Hue", RedChannel, UndefinedOptionFlag, MagickFalse },
+ { "Index", IndexChannel, UndefinedOptionFlag, MagickFalse },
+ { "Lightness", BlueChannel, UndefinedOptionFlag, MagickFalse },
+ { "Luminance", BlueChannel, UndefinedOptionFlag, MagickFalse },
+ { "Luminosity", BlueChannel, DeprecateOptionFlag, MagickTrue },
+ { "Magenta", MagentaChannel, UndefinedOptionFlag, MagickFalse },
+ { "Matte", OpacityChannel, UndefinedOptionFlag, MagickFalse },
+ { "Opacity", OpacityChannel, UndefinedOptionFlag, MagickFalse },
+ { "Red", RedChannel, UndefinedOptionFlag, MagickFalse },
+ { "Saturation", GreenChannel, UndefinedOptionFlag, MagickFalse },
+ { "Yellow", YellowChannel, UndefinedOptionFlag, MagickFalse },
+ { "Sync", SyncChannels, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedChannel, UndefinedOptionFlag, MagickFalse }
},
ClassOptions[] =
{
- { "Undefined", (ssize_t) UndefinedClass, MagickTrue },
- { "DirectClass", (ssize_t) DirectClass, MagickFalse },
- { "PseudoClass", (ssize_t) PseudoClass, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedClass, MagickFalse }
+ { "Undefined", UndefinedClass, UndefinedOptionFlag, MagickTrue },
+ { "DirectClass", DirectClass, UndefinedOptionFlag, MagickFalse },
+ { "PseudoClass", PseudoClass, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedClass, UndefinedOptionFlag, MagickFalse }
},
ClipPathOptions[] =
{
- { "Undefined", (ssize_t) UndefinedPathUnits, MagickTrue },
- { "ObjectBoundingBox", (ssize_t) ObjectBoundingBox, MagickFalse },
- { "UserSpace", (ssize_t) UserSpace, MagickFalse },
- { "UserSpaceOnUse", (ssize_t) UserSpaceOnUse, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedPathUnits, MagickFalse }
+ { "Undefined", UndefinedPathUnits, UndefinedOptionFlag, MagickTrue },
+ { "ObjectBoundingBox", ObjectBoundingBox, UndefinedOptionFlag, MagickFalse },
+ { "UserSpace", UserSpace, UndefinedOptionFlag, MagickFalse },
+ { "UserSpaceOnUse", UserSpaceOnUse, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedPathUnits, UndefinedOptionFlag, MagickFalse }
},
CommandOptions[] =
{
- { "+adjoin", 0L, MagickFalse },
- { "-adjoin", 0L, MagickFalse },
- { "+adaptive-sharpen", 1L, MagickFalse },
- { "-adaptive-sharpen", 1L, MagickFalse },
- { "+adaptive-threshold", 1L, MagickFalse },
- { "-adaptive-threshold", 1L, MagickFalse },
- { "+affine", 0L, MagickFalse },
- { "-affine", 1L, MagickFalse },
- { "+affinity", 0L, MagickFalse },
- { "-affinity", 1L, MagickFalse },
- { "+alpha", 1L, MagickFalse },
- { "-alpha", 1L, MagickFalse },
- { "+annotate", 0L, MagickFalse },
- { "-annotate", 2L, MagickFalse },
- { "+antialias", 0L, MagickFalse },
- { "-antialias", 0L, MagickFalse },
- { "+append", 0L, MagickFalse },
- { "-append", 0L, MagickFalse },
- { "+authenticate", 0L, MagickFalse },
- { "-authenticate", 1L, MagickFalse },
- { "+auto-gamma", 0L, MagickTrue },
- { "-auto-gamma", 0L, MagickTrue },
- { "+auto-level", 0L, MagickTrue },
- { "-auto-level", 0L, MagickTrue },
- { "+auto-orient", 0L, MagickFalse },
- { "-auto-orient", 0L, MagickFalse },
- { "+average", 0L, MagickFalse },
- { "-average", 0L, MagickFalse },
- { "+backdrop", 0L, MagickFalse },
- { "-backdrop", 1L, MagickFalse },
- { "+background", 0L, MagickFalse },
- { "-background", 1L, MagickFalse },
- { "+bench", 0L, MagickTrue },
- { "-bench", 1L, MagickTrue },
- { "+bias", 0L, MagickFalse },
- { "-bias", 1L, MagickFalse },
- { "+black-threshold", 0L, MagickFalse },
- { "-black-threshold", 1L, MagickFalse },
- { "+blend", 0L, MagickFalse },
- { "-blend", 1L, MagickFalse },
- { "+blue-primary", 0L, MagickFalse },
- { "-blue-primary", 1L, MagickFalse },
- { "+blue-shift", 1L, MagickFalse },
- { "-blue-shift", 1L, MagickFalse },
- { "+blur", 0L, MagickFalse },
- { "-blur", 1L, MagickFalse },
- { "+border", 0L, MagickFalse },
- { "-border", 1L, MagickFalse },
- { "+bordercolor", 0L, MagickFalse },
- { "-bordercolor", 1L, MagickFalse },
- { "+borderwidth", 0L, MagickFalse },
- { "-borderwidth", 1L, MagickFalse },
- { "+box", 0L, MagickFalse },
- { "-box", 1L, MagickFalse },
- { "+brightness-contrast", 0L, MagickFalse },
- { "-brightness-contrast", 1L, MagickFalse },
- { "+cache", 0L, MagickFalse },
- { "-cache", 1L, MagickFalse },
- { "+cdl", 1L, MagickFalse },
- { "-cdl", 1L, MagickFalse },
- { "+channel", 0L, MagickFalse },
- { "-channel", 1L, MagickFalse },
- { "+charcoal", 0L, MagickFalse },
- { "-charcoal", 0L, MagickFalse },
- { "+chop", 0L, MagickFalse },
- { "-chop", 1L, MagickFalse },
- { "+clip", 0L, MagickFalse },
- { "-clip", 0L, MagickFalse },
- { "+clip-mask", 0L, MagickFalse },
- { "-clip-mask", 1L, MagickFalse },
- { "+clip-path", 0L, MagickFalse },
- { "-clip-path", 1L, MagickFalse },
- { "+clone", 0L, MagickFalse },
- { "-clone", 1L, MagickFalse },
- { "+clut", 0L, MagickFalse },
- { "-clut", 0L, MagickFalse },
- { "+coalesce", 0L, MagickFalse },
- { "-coalesce", 0L, MagickFalse },
- { "+colorize", 0L, MagickFalse },
- { "-colorize", 1L, MagickFalse },
- { "+colormap", 0L, MagickFalse },
- { "-colormap", 1L, MagickFalse },
- { "+color-matrix", 0L, MagickFalse },
- { "-color-matrix", 1L, MagickFalse },
- { "+colors", 0L, MagickFalse },
- { "-colors", 1L, MagickFalse },
- { "+colorspace", 0L, MagickFalse },
- { "-colorspace", 1L, MagickFalse },
- { "+combine", 0L, MagickFalse },
- { "-combine", 0L, MagickFalse },
- { "+comment", 0L, MagickFalse },
- { "-comment", 1L, MagickFalse },
- { "+compose", 0L, MagickFalse },
- { "-compose", 1L, MagickFalse },
- { "+composite", 0L, MagickFalse },
- { "-composite", 0L, MagickFalse },
- { "+compress", 0L, MagickFalse },
- { "-compress", 1L, MagickFalse },
- { "+concurrent", 0L, MagickTrue },
- { "-concurrent", 0L, MagickTrue },
- { "+contrast", 0L, MagickFalse },
- { "-contrast", 0L, MagickFalse },
- { "+contrast-stretch", 0L, MagickFalse },
- { "-contrast-stretch", 1L, MagickFalse },
- { "+convolve", 0L, MagickFalse },
- { "-convolve", 1L, MagickFalse },
- { "+crop", 0L, MagickFalse },
- { "-crop", 1L, MagickFalse },
- { "+cycle", 0L, MagickFalse },
- { "-cycle", 1L, MagickFalse },
- { "+debug", 0L, MagickFalse },
- { "-debug", 1L, MagickFalse },
- { "+decipher", 1L, MagickFalse },
- { "-decipher", 1L, MagickFalse },
- { "+deconstruct", 0L, MagickFalse },
- { "-deconstruct", 0L, MagickFalse },
- { "+define", 1L, MagickFalse },
- { "-define", 1L, MagickFalse },
- { "+delay", 0L, MagickFalse },
- { "-delay", 1L, MagickFalse },
- { "+delete", 0L, MagickFalse },
- { "-delete", 1L, MagickFalse },
- { "+density", 0L, MagickFalse },
- { "-density", 1L, MagickFalse },
- { "+depth", 0L, MagickFalse },
- { "-depth", 1L, MagickFalse },
- { "+descend", 0L, MagickFalse },
- { "-descend", 1L, MagickFalse },
- { "+deskew", 0L, MagickFalse },
- { "-deskew", 1L, MagickFalse },
- { "+despeckle", 0L, MagickFalse },
- { "-despeckle", 0L, MagickFalse },
- { "+direction", 0L, MagickFalse },
- { "-direction", 1L, MagickFalse },
- { "+displace", 0L, MagickFalse },
- { "-displace", 1L, MagickFalse },
- { "+display", 0L, MagickFalse },
- { "-display", 1L, MagickFalse },
- { "+dispose", 0L, MagickFalse },
- { "-dispose", 1L, MagickFalse },
- { "+dissolve", 0L, MagickFalse },
- { "-dissolve", 1L, MagickFalse },
- { "+distort", 2L, MagickFalse },
- { "-distort", 2L, MagickFalse },
- { "+dither", 0L, MagickFalse },
- { "-dither", 1L, MagickFalse },
- { "+draw", 0L, MagickFalse },
- { "-draw", 1L, MagickFalse },
- { "+duplicate", 0L, MagickFalse },
- { "-duplicate", 1L, MagickFalse },
- { "+duration", 1L, MagickFalse },
- { "-duration", 1L, MagickFalse },
- { "+edge", 0L, MagickFalse },
- { "-edge", 1L, MagickFalse },
- { "+emboss", 0L, MagickFalse },
- { "-emboss", 1L, MagickFalse },
- { "+encipher", 1L, MagickFalse },
- { "-encipher", 1L, MagickFalse },
- { "+encoding", 0L, MagickFalse },
- { "-encoding", 1L, MagickFalse },
- { "+endian", 0L, MagickFalse },
- { "-endian", 1L, MagickFalse },
- { "+enhance", 0L, MagickFalse },
- { "-enhance", 0L, MagickFalse },
- { "+equalize", 0L, MagickFalse },
- { "-equalize", 0L, MagickFalse },
- { "+evaluate", 0L, MagickFalse },
- { "-evaluate", 2L, MagickFalse },
- { "+evaluate-sequence", 0L, MagickFalse },
- { "-evaluate-sequence", 1L, MagickFalse },
- { "+extent", 0L, MagickFalse },
- { "-extent", 1L, MagickFalse },
- { "+extract", 0L, MagickFalse },
- { "-extract", 1L, MagickFalse },
- { "+family", 0L, MagickFalse },
- { "-family", 1L, MagickFalse },
- { "+fft", 0L, MagickFalse },
- { "-fft", 0L, MagickFalse },
- { "+fill", 0L, MagickFalse },
- { "-fill", 1L, MagickFalse },
- { "+filter", 0L, MagickFalse },
- { "-filter", 1L, MagickFalse },
- { "+flatten", 0L, MagickFalse },
- { "-flatten", 0L, MagickFalse },
- { "+flip", 0L, MagickFalse },
- { "-flip", 0L, MagickFalse },
- { "+floodfill", 0L, MagickFalse },
- { "-floodfill", 2L, MagickFalse },
- { "+flop", 0L, MagickFalse },
- { "-flop", 0L, MagickFalse },
- { "+font", 0L, MagickFalse },
- { "-font", 1L, MagickFalse },
- { "+foreground", 0L, MagickFalse },
- { "-foreground", 1L, MagickFalse },
- { "+format", 0L, MagickFalse },
- { "-format", 1L, MagickFalse },
- { "+frame", 0L, MagickFalse },
- { "-frame", 1L, MagickFalse },
- { "+fuzz", 0L, MagickFalse },
- { "-fuzz", 1L, MagickFalse },
- { "+fx", 0L, MagickFalse },
- { "-fx", 1L, MagickFalse },
- { "+gamma", 0L, MagickFalse },
- { "-gamma", 1L, MagickFalse },
- { "+gaussian", 0L, MagickFalse },
- { "-gaussian", 1L, MagickFalse },
- { "+gaussian-blur", 0L, MagickFalse },
- { "-gaussian-blur", 1L, MagickFalse },
- { "+geometry", 0L, MagickFalse },
- { "-geometry", 1L, MagickFalse },
- { "+gravity", 0L, MagickFalse },
- { "-gravity", 1L, MagickFalse },
- { "+green-primary", 0L, MagickFalse },
- { "-green-primary", 1L, MagickFalse },
- { "+hald-clut", 0L, MagickFalse },
- { "-hald-clut", 0L, MagickFalse },
- { "+help", 0L, MagickFalse },
- { "-help", 0L, MagickFalse },
- { "+highlight-color", 1L, MagickFalse },
- { "-highlight-color", 1L, MagickFalse },
- { "+iconGeometry", 0L, MagickFalse },
- { "-iconGeometry", 1L, MagickFalse },
- { "+iconic", 0L, MagickFalse },
- { "-iconic", 1L, MagickFalse },
- { "+identify", 0L, MagickFalse },
- { "-identify", 0L, MagickFalse },
- { "+immutable", 0L, MagickFalse },
- { "-immutable", 0L, MagickFalse },
- { "+implode", 0L, MagickFalse },
- { "-implode", 1L, MagickFalse },
- { "+insert", 0L, MagickFalse },
- { "-insert", 1L, MagickFalse },
- { "+intent", 0L, MagickFalse },
- { "-intent", 1L, MagickFalse },
- { "+interlace", 0L, MagickFalse },
- { "-interlace", 1L, MagickFalse },
- { "+interpolate", 0L, MagickFalse },
- { "-interpolate", 1L, MagickFalse },
- { "+interword-spacing", 0L, MagickFalse },
- { "-interword-spacing", 1L, MagickFalse },
- { "+kerning", 0L, MagickFalse },
- { "-kerning", 1L, MagickFalse },
- { "+label", 0L, MagickFalse },
- { "-label", 1L, MagickFalse },
- { "+lat", 0L, MagickFalse },
- { "-lat", 1L, MagickFalse },
- { "+layers", 0L, MagickFalse },
- { "-layers", 1L, MagickFalse },
- { "+level", 1L, MagickFalse },
- { "-level", 1L, MagickFalse },
- { "+level-colors", 1L, MagickFalse },
- { "-level-colors", 1L, MagickFalse },
- { "+limit", 0L, MagickFalse },
- { "-limit", 2L, MagickFalse },
- { "+linear-stretch", 0L, MagickFalse },
- { "-linear-stretch", 1L, MagickFalse },
- { "+linewidth", 0L, MagickFalse },
- { "-linewidth", 1L, MagickFalse },
- { "+liquid-rescale", 0L, MagickFalse },
- { "-liquid-rescale", 1L, MagickFalse },
- { "+list", 0L, MagickFalse },
- { "-list", 1L, MagickFalse },
- { "+log", 0L, MagickFalse },
- { "-log", 1L, MagickFalse },
- { "+loop", 0L, MagickFalse },
- { "-loop", 1L, MagickFalse },
- { "+lowlight-color", 1L, MagickFalse },
- { "-lowlight-color", 1L, MagickFalse },
- { "+magnify", 0L, MagickFalse },
- { "-magnify", 1L, MagickFalse },
- { "+map", 0L, MagickFalse },
- { "-map", 1L, MagickFalse },
- { "+mask", 0L, MagickFalse },
- { "-mask", 1L, MagickFalse },
- { "+matte", 0L, MagickFalse },
- { "-matte", 0L, MagickFalse },
- { "+mattecolor", 0L, MagickFalse },
- { "-mattecolor", 1L, MagickFalse },
- { "+maximum", 0L, MagickFalse },
- { "-maximum", 0L, MagickFalse },
- { "+median", 0L, MagickFalse },
- { "-median", 1L, MagickFalse },
- { "+metric", 0L, MagickFalse },
- { "-metric", 1L, MagickFalse },
- { "+minimum", 0L, MagickFalse },
- { "-minimum", 0L, MagickFalse },
- { "+mode", 0L, MagickFalse },
- { "-mode", 1L, MagickFalse },
- { "+modulate", 0L, MagickFalse },
- { "-modulate", 1L, MagickFalse },
- { "+monitor", 0L, MagickFalse },
- { "-monitor", 0L, MagickFalse },
- { "+monochrome", 0L, MagickFalse },
- { "-monochrome", 0L, MagickFalse },
- { "+morph", 0L, MagickFalse },
- { "-morph", 1L, MagickFalse },
- { "+morphology", 0L, MagickFalse },
- { "-morphology", 2L, MagickFalse },
- { "+mosaic", 0L, MagickFalse },
- { "-mosaic", 0L, MagickFalse },
- { "+motion-blur", 0L, MagickFalse },
- { "-motion-blur", 1L, MagickFalse },
- { "+name", 0L, MagickFalse },
- { "-name", 1L, MagickFalse },
- { "+negate", 0L, MagickFalse },
- { "-negate", 0L, MagickFalse },
- { "+noise", 1L, MagickFalse },
- { "-noise", 1L, MagickFalse },
- { "+noop", 0L, MagickFalse },
- { "-noop", 0L, MagickFalse },
- { "+normalize", 0L, MagickFalse },
- { "-normalize", 0L, MagickFalse },
- { "+opaque", 1L, MagickFalse },
- { "-opaque", 1L, MagickFalse },
- { "+ordered-dither", 0L, MagickFalse },
- { "-ordered-dither", 1L, MagickFalse },
- { "+orient", 0L, MagickFalse },
- { "-orient", 1L, MagickFalse },
- { "+origin", 0L, MagickFalse },
- { "-origin", 1L, MagickFalse },
- { "+page", 0L, MagickFalse },
- { "-page", 1L, MagickFalse },
- { "+paint", 0L, MagickFalse },
- { "-paint", 1L, MagickFalse },
- { "+path", 0L, MagickFalse },
- { "-path", 1L, MagickFalse },
- { "+pause", 0L, MagickFalse },
- { "-pause", 1L, MagickFalse },
- { "+passphrase", 0L, MagickFalse },
- { "-passphrase", 1L, MagickFalse },
- { "+pen", 0L, MagickFalse },
- { "-pen", 1L, MagickFalse },
- { "+ping", 0L, MagickFalse },
- { "-ping", 0L, MagickFalse },
- { "+pointsize", 0L, MagickFalse },
- { "-pointsize", 1L, MagickFalse },
- { "+polaroid", 0L, MagickFalse },
- { "-polaroid", 1L, MagickFalse },
- { "+posterize", 0L, MagickFalse },
- { "-posterize", 1L, MagickFalse },
- { "+preview", 0L, MagickFalse },
- { "-preview", 1L, MagickFalse },
- { "+process", 0L, MagickFalse },
- { "-process", 1L, MagickFalse },
- { "+profile", 1L, MagickFalse },
- { "-profile", 1L, MagickFalse },
- { "+quality", 0L, MagickFalse },
- { "-quality", 1L, MagickFalse },
- { "+quiet", 0L, MagickFalse },
- { "-quiet", 0L, MagickFalse },
- { "+radial-blur", 0L, MagickFalse },
- { "-radial-blur", 1L, MagickFalse },
- { "+raise", 0L, MagickFalse },
- { "-raise", 1L, MagickFalse },
- { "+random-threshold", 0L, MagickFalse },
- { "-random-threshold", 1L, MagickFalse },
- { "+recolor", 0L, MagickFalse },
- { "-recolor", 1L, MagickFalse },
- { "+red-primary", 0L, MagickFalse },
- { "-red-primary", 1L, MagickFalse },
- { "+regard-warnings", 0L, MagickFalse },
- { "-regard-warnings", 0L, MagickFalse },
- { "+region", 0L, MagickFalse },
- { "-region", 1L, MagickFalse },
- { "+remote", 0L, MagickFalse },
- { "-remote", 1L, MagickFalse },
- { "+render", 0L, MagickFalse },
- { "-render", 0L, MagickFalse },
- { "+repage", 0L, MagickFalse },
- { "-repage", 1L, MagickFalse },
- { "+resample", 0L, MagickFalse },
- { "-resample", 1L, MagickFalse },
- { "+resize", 0L, MagickFalse },
- { "-resize", 1L, MagickFalse },
- { "+respect-parenthesis", 0L, MagickFalse },
- { "-respect-parenthesis", 0L, MagickFalse },
- { "+reverse", 0L, MagickFalse },
- { "-reverse", 0L, MagickFalse },
- { "+roll", 0L, MagickFalse },
- { "-roll", 1L, MagickFalse },
- { "+rotate", 0L, MagickFalse },
- { "-rotate", 1L, MagickFalse },
- { "+sample", 0L, MagickFalse },
- { "-sample", 1L, MagickFalse },
- { "+sampling-factor", 0L, MagickFalse },
- { "-sampling-factor", 1L, MagickFalse },
- { "+sans", 0L, MagickFalse },
- { "-sans", 1L, MagickFalse },
- { "+sans0", 0L, MagickFalse },
- { "-sans0", 0L, MagickFalse },
- { "+sans2", 2L, MagickFalse },
- { "-sans2", 2L, MagickFalse },
- { "+scale", 0L, MagickFalse },
- { "-scale", 1L, MagickFalse },
- { "+scene", 0L, MagickFalse },
- { "-scene", 1L, MagickFalse },
- { "+scenes", 0L, MagickFalse },
- { "-scenes", 1L, MagickFalse },
- { "+screen", 0L, MagickFalse },
- { "-screen", 1L, MagickFalse },
- { "+seed", 0L, MagickFalse },
- { "-seed", 1L, MagickFalse },
- { "+segment", 0L, MagickFalse },
- { "-segment", 1L, MagickFalse },
- { "+separate", 0L, MagickFalse },
- { "-separate", 0L, MagickFalse },
- { "+sepia-tone", 0L, MagickFalse },
- { "-sepia-tone", 1L, MagickFalse },
- { "+set", 1L, MagickFalse },
- { "-set", 2L, MagickFalse },
- { "+shade", 0L, MagickFalse },
- { "-shade", 1L, MagickFalse },
- { "+shadow", 0L, MagickFalse },
- { "-shadow", 1L, MagickFalse },
- { "+shared-memory", 0L, MagickFalse },
- { "-shared-memory", 1L, MagickFalse },
- { "+sharpen", 0L, MagickFalse },
- { "-sharpen", 1L, MagickFalse },
- { "+shave", 0L, MagickFalse },
- { "-shave", 1L, MagickFalse },
- { "+shear", 0L, MagickFalse },
- { "-shear", 1L, MagickFalse },
- { "+sigmoidal-contrast", 0L, MagickFalse },
- { "-sigmoidal-contrast", 1L, MagickFalse },
- { "+silent", 0L, MagickFalse },
- { "-silent", 1L, MagickFalse },
- { "+size", 0L, MagickFalse },
- { "-size", 1L, MagickFalse },
- { "+sketch", 0L, MagickFalse },
- { "-sketch", 1L, MagickFalse },
- { "+smush", 1L, MagickFalse },
- { "-smush", 1L, MagickFalse },
- { "+snaps", 0L, MagickFalse },
- { "-snaps", 1L, MagickFalse },
- { "+solarize", 0L, MagickFalse },
- { "-solarize", 1L, MagickFalse },
- { "+splice", 0L, MagickFalse },
- { "-splice", 1L, MagickFalse },
- { "+sparse-color", 2L, MagickFalse },
- { "-sparse-color", 2L, MagickFalse },
- { "+spread", 0L, MagickFalse },
- { "-spread", 1L, MagickFalse },
- { "+statistic", 2L, MagickFalse },
- { "-statistic", 2L, MagickFalse },
- { "+stegano", 0L, MagickFalse },
- { "-stegano", 1L, MagickFalse },
- { "+stereo", 0L, MagickFalse },
- { "-stereo", 1L, MagickFalse },
- { "+stretch", 0L, MagickFalse },
- { "-stretch", 1L, MagickFalse },
- { "+strip", 0L, MagickFalse },
- { "-strip", 0L, MagickFalse },
- { "+stroke", 0L, MagickFalse },
- { "-stroke", 1L, MagickFalse },
- { "+strokewidth", 0L, MagickFalse },
- { "-strokewidth", 1L, MagickFalse },
- { "+style", 0L, MagickFalse },
- { "-style", 1L, MagickFalse },
- { "+subimage-search", 0L, MagickFalse },
- { "-subimage-search", 0L, MagickFalse },
- { "+swap", 0L, MagickFalse },
- { "-swap", 1L, MagickFalse },
- { "+swirl", 0L, MagickFalse },
- { "-swirl", 1L, MagickFalse },
- { "+synchronize", 0L, MagickFalse },
- { "-synchronize", 0L, MagickFalse },
- { "+taint", 0L, MagickFalse },
- { "-taint", 0L, MagickFalse },
- { "+text-font", 0L, MagickFalse },
- { "-text-font", 1L, MagickFalse },
- { "+texture", 0L, MagickFalse },
- { "-texture", 1L, MagickFalse },
- { "+threshold", 0L, MagickFalse },
- { "-threshold", 1L, MagickFalse },
- { "+thumbnail", 0L, MagickFalse },
- { "-thumbnail", 1L, MagickFalse },
- { "+thumnail", 0L, MagickFalse },
- { "-thumnail", 1L, MagickFalse },
- { "+tile", 0L, MagickFalse },
- { "-tile", 1L, MagickFalse },
- { "+tile-offset", 0L, MagickFalse },
- { "-tile-offset", 1L, MagickFalse },
- { "+tint", 0L, MagickFalse },
- { "-tint", 1L, MagickFalse },
- { "+title", 0L, MagickFalse },
- { "-title", 1L, MagickFalse },
- { "+transform", 0L, MagickFalse },
- { "-transform", 0L, MagickFalse },
- { "+transparent", 1L, MagickFalse },
- { "-transparent", 1L, MagickFalse },
- { "+transparent-color", 1L, MagickFalse },
- { "-transparent-color", 1L, MagickFalse },
- { "+transpose", 0L, MagickFalse },
- { "-transpose", 0L, MagickFalse },
- { "+transverse", 0L, MagickFalse },
- { "-transverse", 0L, MagickFalse },
- { "+treedepth", 0L, MagickFalse },
- { "-treedepth", 1L, MagickFalse },
- { "+trim", 0L, MagickFalse },
- { "-trim", 0L, MagickFalse },
- { "+type", 0L, MagickFalse },
- { "-type", 1L, MagickFalse },
- { "+undercolor", 0L, MagickFalse },
- { "-undercolor", 1L, MagickFalse },
- { "+unique-colors", 0L, MagickFalse },
- { "-unique-colors", 0L, MagickFalse },
- { "+units", 0L, MagickFalse },
- { "-units", 1L, MagickFalse },
- { "+unsharp", 0L, MagickFalse },
- { "-unsharp", 1L, MagickFalse },
- { "+update", 0L, MagickFalse },
- { "-update", 1L, MagickFalse },
- { "+use-pixmap", 0L, MagickFalse },
- { "-use-pixmap", 1L, MagickFalse },
- { "+verbose", 0L, MagickFalse },
- { "-verbose", 0L, MagickFalse },
- { "+version", 0L, MagickFalse },
- { "-version", 1L, MagickFalse },
- { "+view", 0L, MagickFalse },
- { "-view", 1L, MagickFalse },
- { "+vignette", 0L, MagickFalse },
- { "-vignette", 1L, MagickFalse },
- { "+virtual-pixel", 0L, MagickFalse },
- { "-virtual-pixel", 1L, MagickFalse },
- { "+visual", 0L, MagickFalse },
- { "-visual", 1L, MagickFalse },
- { "+watermark", 0L, MagickFalse },
- { "-watermark", 1L, MagickFalse },
- { "+wave", 0L, MagickFalse },
- { "-wave", 1L, MagickFalse },
- { "+weight", 0L, MagickFalse },
- { "-weight", 1L, MagickFalse },
- { "+white-point", 0L, MagickFalse },
- { "-white-point", 1L, MagickFalse },
- { "+white-threshold", 0L, MagickFalse },
- { "-white-threshold", 1L, MagickFalse },
- { "+window", 0L, MagickFalse },
- { "-window", 1L, MagickFalse },
- { "+window-group", 0L, MagickFalse },
- { "-window-group", 1L, MagickFalse },
- { "+write", 1L, MagickFalse },
- { "-write", 1L, MagickFalse },
- { (char *) NULL, (ssize_t) 0L, MagickFalse }
+ { "+adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+adaptive-blur", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-adaptive-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+adaptive-resize", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-adaptive-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+adaptive-sharpen", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-adaptive-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+affine", 0L, DrawInfoOptionFlag, MagickFalse },
+ { "-affine", 1L, DrawInfoOptionFlag, MagickFalse },
+ { "+affinity", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-affinity", 1L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "+alpha", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-alpha", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+annotate", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-annotate", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "-antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+append", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-append", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+attenuate", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-attenuate", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+authenticate", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-authenticate", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+auto-gamma", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-auto-gamma", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+auto-level", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-auto-level", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+auto-orient", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-auto-orient", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+average", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-average", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+backdrop", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-backdrop", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+background", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-background", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+bench", 0L, GenesisOptionFlag, MagickFalse },
+ { "-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-threshold", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-black-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+blend", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-blend", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+blue-primary", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-blue-primary", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+blue-shift", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-blue-shift", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+blur", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+border", 1L, DeprecateOptionFlag, 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, MagickFalse },
+ { "-box", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+brightness-contrast", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-brightness-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+cache", 0L, GlobalOptionFlag, MagickFalse },
+ { "-cache", 1L, GlobalOptionFlag, MagickFalse },
+ { "+cdl", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-cdl", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+channel", 0L, ImageInfoOptionFlag | ListOperatorOptionFlag, MagickFalse },
+ { "-channel", 1L, ImageInfoOptionFlag | ListOperatorOptionFlag, MagickFalse },
+ { "+charcoal", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-charcoal", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+chop", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-chop", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+clamp", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-clamp", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+clip", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-clip", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+clip-mask", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-clip-mask", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+clip-path", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-clip-path", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+clone", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "-clone", 1L, SpecialOperatorOptionFlag, MagickFalse },
+ { "+clut", 0L, FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-clut", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+coalesce", 0L, FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-coalesce", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+colorize", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-colorize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+colormap", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-colormap", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+color-matrix", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-color-matrix", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+colors", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-colors", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+colorspace", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "-colorspace", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "+combine", 0L, FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-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, MagickFalse },
+ { "-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 },
+ { "+contrast-stretch", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-contrast-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+convolve", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-convolve", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+crop", 1L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-crop", 1L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+cycle", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-cycle", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+debug", 0L, GlobalOptionFlag|GenesisOptionFlag | FireOptionFlag, MagickFalse },
+ { "-debug", 1L, GlobalOptionFlag|GenesisOptionFlag | FireOptionFlag, MagickFalse },
+ { "+decipher", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-decipher", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+deconstruct", 0L, FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-deconstruct", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+define", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-define", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+delay", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-delay", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+delete", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-delete", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+density", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-density", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+depth", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-depth", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+descend", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-descend", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+deskew", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-deskew", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+despeckle", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-despeckle", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+direction", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-direction", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+displace", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-displace", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+display", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-display", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+dispose", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-dispose", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+dissolve", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-dissolve", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+distort", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-distort", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+dither", 0L, ListOperatorOptionFlag | ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse },
+ { "-dither", 1L, ListOperatorOptionFlag | ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse },
+ { "+draw", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-draw", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+duplicate", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-duplicate", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+duration", 1L, GenesisOptionFlag, MagickFalse },
+ { "-duration", 1L, GenesisOptionFlag, MagickFalse },
+ { "+edge", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-edge", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+emboss", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-emboss", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+encipher", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-encipher", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+encoding", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-encoding", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+endian", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-endian", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+enhance", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-enhance", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+equalize", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-equalize", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+evaluate", 2L, DeprecateOptionFlag, MagickFalse },
+ { "-evaluate", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+evaluate-sequence", 1L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-evaluate-sequence", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+extent", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-extent", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+extract", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-extract", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+family", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-family", 1L, DrawInfoOptionFlag, MagickFalse },
+ { "+features", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-features", 1L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+fft", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-fft", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+fill", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "-fill", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+filter", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-filter", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+flatten", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-flatten", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+flip", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-flip", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+flop", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-flop", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+floodfill", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-floodfill", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+font", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "-font", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+foreground", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-foreground", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+format", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-format", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+frame", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-frame", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+fuzz", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-fuzz", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+fx", 1L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-fx", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+gamma", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-gamma", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+gaussian", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-gaussian", 1L, SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+gaussian-blur", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-gaussian-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+geometry", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-geometry", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+gravity", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "-gravity", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+green-primary", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-green-primary", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+hald-clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-hald-clut", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+help", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "-help", 0L, SpecialOperatorOptionFlag, 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 },
+ { "+identify", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-identify", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+ift", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-ift", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+immutable", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-immutable", 0L, NonConvertOptionFlag, MagickFalse },
+ { "+implode", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-implode", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+insert", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-insert", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+intent", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-intent", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+interlace", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-interlace", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+interline-spacing", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, 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 },
+ { "+kerning", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "-kerning", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+label", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-label", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+lat", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-lat", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+layers", 1L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-layers", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+level", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-level", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+level-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-level-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+limit", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
+ { "-limit", 2L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
+ { "+linear-stretch", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-linear-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+linewidth", 0L, DrawInfoOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-linewidth", 1L, DrawInfoOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+liquid-rescale", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-liquid-rescale", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+list", 0L, GlobalOptionFlag, MagickFalse },
+ { "-list", 1L, GlobalOptionFlag, MagickFalse },
+ { "+log", 0L, GlobalOptionFlag, MagickFalse },
+ { "-log", 1L, GlobalOptionFlag, MagickFalse },
+ { "+loop", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-loop", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+lowlight-color", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-lowlight-color", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+magnify", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-magnify", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+map", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-map", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+mask", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-mask", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+matte", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-matte", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+mattecolor", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-mattecolor", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-maximum", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+median", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-median", 1L, SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+metric", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-metric", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-minimum", 0L, ImageInfoOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+mode", 1L, NonConvertOptionFlag, MagickFalse },
+ { "-mode", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+modulate", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-modulate", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "-monitor", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "+monochrome", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-monochrome", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "+morph", 1L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-morph", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+morphology", 2L, DeprecateOptionFlag, MagickFalse },
+ { "-morphology", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+mosaic", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-mosaic", 0L, ListOperatorOptionFlag | FireOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+motion-blur", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-motion-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+name", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-name", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+noop", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "-noop", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "+normalize", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-normalize", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+opaque", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-opaque", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+ordered-dither", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-ordered-dither", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+orient", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-orient", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+origin", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-origin", 1L, DeprecateOptionFlag, MagickFalse },
+ { "+page", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-page", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+paint", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-paint", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+path", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "-path", 1L, SpecialOperatorOptionFlag, MagickFalse },
+ { "+pause", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-pause", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+passphrase", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-passphrase", 1L, DeprecateOptionFlag, MagickFalse },
+ { "+pen", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "-pen", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+ping", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-ping", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+pointsize", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "-pointsize", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+polaroid", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-polaroid", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+posterize", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-posterize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+preview", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-preview", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+print", 1L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-print", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+process", 1L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-process", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+profile", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-profile", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+quality", 0L, ImageInfoOptionFlag, 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, MagickFalse },
+ { "-radial-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+raise", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-raise", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+random-threshold", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-random-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+recolor", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-recolor", 1L, SimpleOperatorOptionFlag | DeprecateOptionFlag, MagickFalse },
+ { "+red-primary", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-red-primary", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+regard-warnings", 0L, GenesisOptionFlag, MagickFalse },
+ { "-regard-warnings", 0L, GenesisOptionFlag, MagickFalse },
+ { "+region", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "-region", 1L, SpecialOperatorOptionFlag, MagickFalse },
+ { "+remote", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-remote", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+render", 0L, DrawInfoOptionFlag, MagickFalse },
+ { "-render", 0L, DrawInfoOptionFlag, MagickFalse },
+ { "+remap", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-remap", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+repage", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-repage", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+resample", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-resample", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+resize", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+respect-parenthesis", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "-respect-parenthesis", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "+reverse", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-reverse", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+roll", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-roll", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+rotate", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-rotate", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+sample", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-sample", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+sampling-factor", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-sampling-factor", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+sans", 1L, NonConvertOptionFlag, MagickTrue },
+ { "-sans", 1L, NonConvertOptionFlag, MagickTrue },
+ { "+sans0", 0L, NonConvertOptionFlag, MagickTrue },
+ { "-sans0", 0L, NonConvertOptionFlag, MagickTrue },
+ { "+sans2", 2L, NonConvertOptionFlag, MagickTrue },
+ { "-sans2", 2L, NonConvertOptionFlag, MagickTrue },
+ { "+scale", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-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 },
+ { "+seed", 0L, GlobalOptionFlag, MagickFalse },
+ { "-seed", 1L, GlobalOptionFlag, MagickFalse },
+ { "+segment", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-segment", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+selective-blur", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-selective-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+separate", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-separate", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+sepia-tone", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-sepia-tone", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+set", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "-set", 2L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "+shade", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-shade", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+shadow", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-shadow", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+shared-memory", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-shared-memory", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+sharpen", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+shave", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-shave", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+shear", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-shear", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+sigmoidal-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-sigmoidal-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+silent", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-silent", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+size", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-size", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+sketch", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-sketch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+smush", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-smush", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+snaps", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-snaps", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+solarize", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-solarize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+sparse-color", 2L, DeprecateOptionFlag, MagickFalse },
+ { "-sparse-color", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+splice", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-splice", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+spread", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-spread", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+statistic", 2L, DeprecateOptionFlag, MagickFalse },
+ { "-statistic", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+stegano", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-stegano", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+stereo", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-stereo", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+stretch", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+strip", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-strip", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+stroke", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "-stroke", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+strokewidth", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-strokewidth", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+style", 0L, DrawInfoOptionFlag, MagickFalse },
+ { "-style", 1L, DrawInfoOptionFlag, MagickFalse },
+ { "+subimage-search", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-subimage-search", 0L, NonConvertOptionFlag, MagickFalse },
+ { "+swap", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-swap", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+swirl", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-swirl", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+taint", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-taint", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+text-font", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-text-font", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+texture", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-texture", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+threshold", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+thumbnail", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-thumbnail", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+tile", 0L, DrawInfoOptionFlag, MagickFalse },
+ { "-tile", 1L, DrawInfoOptionFlag, MagickFalse },
+ { "+tile-offset", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-tile-offset", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+tint", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-tint", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+title", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-title", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+transform", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-transform", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+transpose", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-transpose", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+transverse", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-transverse", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+treedepth", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-treedepth", 1L, QuantizeInfoOptionFlag, MagickFalse },
+ { "+trim", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-trim", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+type", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "-type", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "+undercolor", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-undercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+unique", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-unique", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+unique-colors", 0L, DeprecateOptionFlag, MagickFalse },
+ { "-unique-colors", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+units", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-units", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+unsharp", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-unsharp", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+update", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-update", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+use-pixmap", 0L, NonConvertOptionFlag, MagickFalse },
+ { "-use-pixmap", 1L, NonConvertOptionFlag, MagickFalse },
+ { "+verbose", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-verbose", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "+version", 0L, SpecialOperatorOptionFlag, MagickFalse },
+ { "-version", 1L, SpecialOperatorOptionFlag, MagickFalse },
+ { "+view", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-view", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+vignette", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-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 },
+ { "+wave", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-wave", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+weight", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-weight", 1L, DrawInfoOptionFlag, MagickFalse },
+ { "+white-point", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-white-point", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+white-threshold", 1L, DeprecateOptionFlag, MagickFalse },
+ { "-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 },
+ { (char *) NULL, 0L, UndefinedOptionFlag, MagickFalse }
},
ComposeOptions[] =
{
- { "Undefined", (ssize_t) UndefinedCompositeOp, MagickTrue },
- { "Atop", (ssize_t) AtopCompositeOp, MagickFalse },
- { "Blend", (ssize_t) BlendCompositeOp, MagickFalse },
- { "Blur", (ssize_t) BlurCompositeOp, MagickFalse },
- { "Bumpmap", (ssize_t) BumpmapCompositeOp, MagickFalse },
- { "ChangeMask", (ssize_t) ChangeMaskCompositeOp, MagickFalse },
- { "Clear", (ssize_t) ClearCompositeOp, MagickFalse },
- { "ColorBurn", (ssize_t) ColorBurnCompositeOp, MagickFalse },
- { "ColorDodge", (ssize_t) ColorDodgeCompositeOp, MagickFalse },
- { "Colorize", (ssize_t) ColorizeCompositeOp, MagickFalse },
- { "CopyBlack", (ssize_t) CopyBlackCompositeOp, MagickFalse },
- { "CopyBlue", (ssize_t) CopyBlueCompositeOp, MagickFalse },
- { "CopyCyan", (ssize_t) CopyCyanCompositeOp, MagickFalse },
- { "CopyGreen", (ssize_t) CopyGreenCompositeOp, MagickFalse },
- { "Copy", (ssize_t) CopyCompositeOp, MagickFalse },
- { "CopyMagenta", (ssize_t) CopyMagentaCompositeOp, MagickFalse },
- { "CopyOpacity", (ssize_t) CopyOpacityCompositeOp, MagickFalse },
- { "CopyRed", (ssize_t) CopyRedCompositeOp, MagickFalse },
- { "CopyYellow", (ssize_t) CopyYellowCompositeOp, MagickFalse },
- { "Darken", (ssize_t) DarkenCompositeOp, MagickFalse },
- { "DivideDst", (ssize_t) DivideDstCompositeOp, MagickFalse },
- { "DivideSrc", (ssize_t) DivideSrcCompositeOp, MagickFalse },
- { "Dst", (ssize_t) DstCompositeOp, MagickFalse },
- { "Difference", (ssize_t) DifferenceCompositeOp, MagickFalse },
- { "Displace", (ssize_t) DisplaceCompositeOp, MagickFalse },
- { "Dissolve", (ssize_t) DissolveCompositeOp, MagickFalse },
- { "Distort", (ssize_t) DistortCompositeOp, MagickFalse },
- { "DstAtop", (ssize_t) DstAtopCompositeOp, MagickFalse },
- { "DstIn", (ssize_t) DstInCompositeOp, MagickFalse },
- { "DstOut", (ssize_t) DstOutCompositeOp, MagickFalse },
- { "DstOver", (ssize_t) DstOverCompositeOp, MagickFalse },
- { "Dst", (ssize_t) DstCompositeOp, MagickFalse },
- { "Exclusion", (ssize_t) ExclusionCompositeOp, MagickFalse },
- { "HardLight", (ssize_t) HardLightCompositeOp, MagickFalse },
- { "Hue", (ssize_t) HueCompositeOp, MagickFalse },
- { "In", (ssize_t) InCompositeOp, MagickFalse },
- { "Lighten", (ssize_t) LightenCompositeOp, MagickFalse },
- { "LinearBurn", (ssize_t) LinearBurnCompositeOp, MagickFalse },
- { "LinearDodge", (ssize_t) LinearDodgeCompositeOp, MagickFalse },
- { "LinearLight", (ssize_t) LinearLightCompositeOp, MagickFalse },
- { "Luminize", (ssize_t) LuminizeCompositeOp, MagickFalse },
- { "Mathematics", (ssize_t) MathematicsCompositeOp, MagickFalse },
- { "MinusDst", (ssize_t) MinusDstCompositeOp, MagickFalse },
- { "MinusSrc", (ssize_t) MinusSrcCompositeOp, MagickFalse },
- { "Modulate", (ssize_t) ModulateCompositeOp, MagickFalse },
- { "ModulusAdd", (ssize_t) ModulusAddCompositeOp, MagickFalse },
- { "ModulusSubtract", (ssize_t) ModulusSubtractCompositeOp, MagickFalse },
- { "Multiply", (ssize_t) MultiplyCompositeOp, MagickFalse },
- { "None", (ssize_t) NoCompositeOp, MagickFalse },
- { "Out", (ssize_t) OutCompositeOp, MagickFalse },
- { "Overlay", (ssize_t) OverlayCompositeOp, MagickFalse },
- { "Over", (ssize_t) OverCompositeOp, MagickFalse },
- { "PegtopLight", (ssize_t) PegtopLightCompositeOp, MagickFalse },
- { "PinLight", (ssize_t) PinLightCompositeOp, MagickFalse },
- { "Plus", (ssize_t) PlusCompositeOp, MagickFalse },
- { "Replace", (ssize_t) ReplaceCompositeOp, MagickFalse },
- { "Saturate", (ssize_t) SaturateCompositeOp, MagickFalse },
- { "Screen", (ssize_t) ScreenCompositeOp, MagickFalse },
- { "SoftLight", (ssize_t) SoftLightCompositeOp, MagickFalse },
- { "Src", (ssize_t) SrcCompositeOp, MagickFalse },
- { "SrcAtop", (ssize_t) SrcAtopCompositeOp, MagickFalse },
- { "SrcIn", (ssize_t) SrcInCompositeOp, MagickFalse },
- { "SrcOut", (ssize_t) SrcOutCompositeOp, MagickFalse },
- { "SrcOver", (ssize_t) SrcOverCompositeOp, MagickFalse },
- { "Src", (ssize_t) SrcCompositeOp, MagickFalse },
- { "VividLight", (ssize_t) VividLightCompositeOp, MagickFalse },
- { "Xor", (ssize_t) XorCompositeOp, MagickFalse },
- { "Add", (ssize_t) AddCompositeOp, MagickTrue }, /* deprecate */
- { "Divide", (ssize_t) DivideDstCompositeOp, MagickTrue }, /* deprecate */
- { "Minus", (ssize_t) MinusDstCompositeOp, MagickTrue }, /* deprecate */
- { "Subtract", (ssize_t) SubtractCompositeOp, MagickTrue }, /* deprecate */
- { "Threshold", (ssize_t) ThresholdCompositeOp, MagickTrue }, /* deprecate */
- { (char *) NULL, (ssize_t) UndefinedCompositeOp, MagickFalse }
+ { "Undefined", UndefinedCompositeOp, UndefinedOptionFlag, MagickTrue },
+ { "Atop", AtopCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Blend", BlendCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Blur", BlurCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Bumpmap", BumpmapCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "ChangeMask", ChangeMaskCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Clear", ClearCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "ColorBurn", ColorBurnCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "ColorDodge", ColorDodgeCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Colorize", ColorizeCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "CopyBlack", CopyBlackCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "CopyBlue", CopyBlueCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "CopyCyan", CopyCyanCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "CopyGreen", CopyGreenCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Copy", CopyCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "CopyMagenta", CopyMagentaCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "CopyOpacity", CopyOpacityCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "CopyRed", CopyRedCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "CopyYellow", CopyYellowCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Darken", DarkenCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "DarkenIntensity", DarkenIntensityCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "DivideDst", DivideDstCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "DivideSrc", DivideSrcCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Dst", DstCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Difference", DifferenceCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Displace", DisplaceCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Dissolve", DissolveCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Distort", DistortCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "DstAtop", DstAtopCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "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 },
+ { "In", InCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Lighten", LightenCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "LightenIntensity", LightenIntensityCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "LinearBurn", LinearBurnCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "LinearDodge", LinearDodgeCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "LinearLight", LinearLightCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Luminize", LuminizeCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Mathematics", MathematicsCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "MinusDst", MinusDstCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "MinusSrc", MinusSrcCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Modulate", ModulateCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "ModulusAdd", ModulusAddCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "ModulusSubtract", ModulusSubtractCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Multiply", MultiplyCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "None", NoCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Out", OutCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Overlay", OverlayCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Over", OverCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "PegtopLight", PegtopLightCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "PinLight", PinLightCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Plus", PlusCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Replace", ReplaceCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Saturate", SaturateCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Screen", ScreenCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "SoftLight", SoftLightCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "Src", SrcCompositeOp, UndefinedOptionFlag, MagickFalse },
+ { "SrcAtop", SrcAtopCompositeOp, 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 },
+ { "Add", AddCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { "Divide", DivideDstCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { "Minus", MinusDstCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { "Subtract", SubtractCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { "Threshold", ThresholdCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { (char *) NULL, UndefinedCompositeOp, UndefinedOptionFlag, MagickFalse }
},
CompressOptions[] =
{
- { "Undefined", (ssize_t) UndefinedCompression, MagickTrue },
- { "B44", (ssize_t) B44Compression, MagickFalse },
- { "B44A", (ssize_t) B44ACompression, MagickFalse },
- { "BZip", (ssize_t) BZipCompression, MagickFalse },
- { "DXT1", (ssize_t) DXT1Compression, MagickFalse },
- { "DXT3", (ssize_t) DXT3Compression, MagickFalse },
- { "DXT5", (ssize_t) DXT5Compression, MagickFalse },
- { "Fax", (ssize_t) FaxCompression, MagickFalse },
- { "Group4", (ssize_t) Group4Compression, MagickFalse },
- { "JPEG", (ssize_t) JPEGCompression, MagickFalse },
- { "JPEG2000", (ssize_t) JPEG2000Compression, MagickFalse },
- { "Lossless", (ssize_t) LosslessJPEGCompression, MagickFalse },
- { "LosslessJPEG", (ssize_t) LosslessJPEGCompression, MagickFalse },
- { "LZMA", (ssize_t) LZMACompression, MagickFalse },
- { "LZW", (ssize_t) LZWCompression, MagickFalse },
- { "None", (ssize_t) NoCompression, MagickFalse },
- { "Piz", (ssize_t) PizCompression, MagickFalse },
- { "Pxr24", (ssize_t) Pxr24Compression, MagickFalse },
- { "RLE", (ssize_t) RLECompression, MagickFalse },
- { "Zip", (ssize_t) ZipCompression, MagickFalse },
- { "RunlengthEncoded", (ssize_t) RLECompression, MagickFalse },
- { "ZipS", (ssize_t) ZipSCompression, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedCompression, MagickFalse }
+ { "Undefined", UndefinedCompression, UndefinedOptionFlag, MagickTrue },
+ { "B44", B44Compression, UndefinedOptionFlag, MagickFalse },
+ { "B44A", B44ACompression, UndefinedOptionFlag, MagickFalse },
+ { "BZip", BZipCompression, UndefinedOptionFlag, MagickFalse },
+ { "DXT1", DXT1Compression, UndefinedOptionFlag, MagickFalse },
+ { "DXT3", DXT3Compression, UndefinedOptionFlag, MagickFalse },
+ { "DXT5", DXT5Compression, UndefinedOptionFlag, MagickFalse },
+ { "Fax", FaxCompression, UndefinedOptionFlag, MagickFalse },
+ { "Group4", Group4Compression, UndefinedOptionFlag, MagickFalse },
+ { "JBIG1", JBIG1Compression, UndefinedOptionFlag, MagickFalse },
+ { "JBIG2", JBIG2Compression, UndefinedOptionFlag, MagickFalse },
+ { "JPEG", JPEGCompression, UndefinedOptionFlag, MagickFalse },
+ { "JPEG2000", JPEG2000Compression, UndefinedOptionFlag, MagickFalse },
+ { "Lossless", LosslessJPEGCompression, UndefinedOptionFlag, MagickFalse },
+ { "LosslessJPEG", LosslessJPEGCompression, UndefinedOptionFlag, MagickFalse },
+ { "LZMA", LZMACompression, UndefinedOptionFlag, MagickFalse },
+ { "LZW", LZWCompression, UndefinedOptionFlag, MagickFalse },
+ { "None", NoCompression, UndefinedOptionFlag, MagickFalse },
+ { "Piz", PizCompression, UndefinedOptionFlag, MagickFalse },
+ { "Pxr24", Pxr24Compression, UndefinedOptionFlag, MagickFalse },
+ { "RLE", RLECompression, UndefinedOptionFlag, MagickFalse },
+ { "Zip", ZipCompression, UndefinedOptionFlag, MagickFalse },
+ { "RunlengthEncoded", RLECompression, UndefinedOptionFlag, MagickFalse },
+ { "ZipS", ZipSCompression, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedCompression, UndefinedOptionFlag, MagickFalse }
},
ColorspaceOptions[] =
{
- { "Undefined", (ssize_t) UndefinedColorspace, MagickTrue },
- { "CMY", (ssize_t) CMYColorspace, MagickFalse },
- { "CMYK", (ssize_t) CMYKColorspace, MagickFalse },
- { "Gray", (ssize_t) GRAYColorspace, MagickFalse },
- { "HSB", (ssize_t) HSBColorspace, MagickFalse },
- { "HSL", (ssize_t) HSLColorspace, MagickFalse },
- { "HWB", (ssize_t) HWBColorspace, MagickFalse },
- { "Lab", (ssize_t) LabColorspace, MagickFalse },
- { "Log", (ssize_t) LogColorspace, MagickFalse },
- { "OHTA", (ssize_t) OHTAColorspace, MagickFalse },
- { "Rec601Luma", (ssize_t) Rec601LumaColorspace, MagickFalse },
- { "Rec601YCbCr", (ssize_t) Rec601YCbCrColorspace, MagickFalse },
- { "Rec709Luma", (ssize_t) Rec709LumaColorspace, MagickFalse },
- { "Rec709YCbCr", (ssize_t) Rec709YCbCrColorspace, MagickFalse },
- { "RGB", (ssize_t) RGBColorspace, MagickFalse },
- { "sRGB", (ssize_t) sRGBColorspace, MagickFalse },
- { "Transparent", (ssize_t) TransparentColorspace, MagickFalse },
- { "XYZ", (ssize_t) XYZColorspace, MagickFalse },
- { "YCbCr", (ssize_t) YCbCrColorspace, MagickFalse },
- { "YCC", (ssize_t) YCCColorspace, MagickFalse },
- { "YIQ", (ssize_t) YIQColorspace, MagickFalse },
- { "YPbPr", (ssize_t) YPbPrColorspace, MagickFalse },
- { "YUV", (ssize_t) YUVColorspace, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedColorspace, MagickFalse }
+ { "Undefined", UndefinedColorspace, UndefinedOptionFlag, MagickTrue },
+ { "CMY", CMYColorspace, UndefinedOptionFlag, MagickFalse },
+ { "CMYK", CMYKColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Gray", GRAYColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HSB", HSBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HSL", HSLColorspace, UndefinedOptionFlag, MagickFalse },
+ { "HWB", HWBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Lab", LabColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Log", LogColorspace, UndefinedOptionFlag, MagickFalse },
+ { "OHTA", OHTAColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Rec601Luma", Rec601LumaColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Rec601YCbCr", Rec601YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Rec709Luma", Rec709LumaColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Rec709YCbCr", Rec709YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
+ { "RGB", RGBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "sRGB", sRGBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "Transparent", TransparentColorspace, UndefinedOptionFlag, MagickFalse },
+ { "XYZ", XYZColorspace, UndefinedOptionFlag, MagickFalse },
+ { "YCbCr", YCbCrColorspace, 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", (ssize_t) UndefinedData, MagickTrue },
- { "Byte", (ssize_t) ByteData, MagickFalse },
- { "Long", (ssize_t) LongData, MagickFalse },
- { "Short", (ssize_t) ShortData, MagickFalse },
- { "String", (ssize_t) StringData, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedData, MagickFalse }
+ { "Undefined", UndefinedData, UndefinedOptionFlag, MagickTrue },
+ { "Byte", ByteData, UndefinedOptionFlag, MagickFalse },
+ { "Long", LongData, UndefinedOptionFlag, MagickFalse },
+ { "Short", ShortData, UndefinedOptionFlag, MagickFalse },
+ { "String", StringData, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedData, UndefinedOptionFlag, MagickFalse }
},
DecorateOptions[] =
{
- { "Undefined", (ssize_t) UndefinedDecoration, MagickTrue },
- { "LineThrough", (ssize_t) LineThroughDecoration, MagickFalse },
- { "None", (ssize_t) NoDecoration, MagickFalse },
- { "Overline", (ssize_t) OverlineDecoration, MagickFalse },
- { "Underline", (ssize_t) UnderlineDecoration, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedDecoration, MagickFalse }
+ { "Undefined", UndefinedDecoration, UndefinedOptionFlag, MagickTrue },
+ { "LineThrough", LineThroughDecoration, UndefinedOptionFlag, MagickFalse },
+ { "None", NoDecoration, UndefinedOptionFlag, MagickFalse },
+ { "Overline", OverlineDecoration, UndefinedOptionFlag, MagickFalse },
+ { "Underline", UnderlineDecoration, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedDecoration, UndefinedOptionFlag, MagickFalse }
},
DirectionOptions[] =
{
- { "Undefined", (ssize_t) UndefinedDirection, MagickTrue },
- { "right-to-left", (ssize_t) RightToLeftDirection, MagickFalse },
- { "left-to-right", (ssize_t) LeftToRightDirection, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedDirection, MagickFalse }
+ { "Undefined", UndefinedDirection, UndefinedOptionFlag, MagickTrue },
+ { "right-to-left", RightToLeftDirection, UndefinedOptionFlag, MagickFalse },
+ { "left-to-right", LeftToRightDirection, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedDirection, UndefinedOptionFlag, MagickFalse }
},
DisposeOptions[] =
{
- { "Undefined", (ssize_t) UndefinedDispose, MagickTrue },
- { "Background", (ssize_t) BackgroundDispose, MagickFalse },
- { "None", (ssize_t) NoneDispose, MagickFalse },
- { "Previous", (ssize_t) PreviousDispose, MagickFalse },
- { "Undefined", (ssize_t) UndefinedDispose, MagickFalse },
- { "0", (ssize_t) UndefinedDispose, MagickFalse },
- { "1", (ssize_t) NoneDispose, MagickFalse },
- { "2", (ssize_t) BackgroundDispose, MagickFalse },
- { "3", (ssize_t) PreviousDispose, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedDispose, MagickFalse }
+ { "Undefined", UndefinedDispose, UndefinedOptionFlag, MagickTrue },
+ { "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 },
+ { "3", PreviousDispose, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedDispose, UndefinedOptionFlag, MagickFalse }
},
DistortOptions[] =
{
- { "Undefined", (ssize_t) UndefinedDistortion, MagickTrue },
- { "Affine", (ssize_t) AffineDistortion, MagickFalse },
- { "AffineProjection", (ssize_t) AffineProjectionDistortion, MagickFalse },
- { "ScaleRotateTranslate", (ssize_t) ScaleRotateTranslateDistortion, MagickFalse },
- { "SRT", (ssize_t) ScaleRotateTranslateDistortion, MagickFalse },
- { "Perspective", (ssize_t) PerspectiveDistortion, MagickFalse },
- { "PerspectiveProjection", (ssize_t) PerspectiveProjectionDistortion, MagickFalse },
- { "Bilinear", (ssize_t) BilinearForwardDistortion, MagickTrue },
- { "BilinearForward", (ssize_t) BilinearForwardDistortion, MagickFalse },
- { "BilinearReverse", (ssize_t) BilinearReverseDistortion, MagickFalse },
- { "Polynomial", (ssize_t) PolynomialDistortion, MagickFalse },
- { "Arc", (ssize_t) ArcDistortion, MagickFalse },
- { "Polar", (ssize_t) PolarDistortion, MagickFalse },
- { "DePolar", (ssize_t) DePolarDistortion, MagickFalse },
- { "Barrel", (ssize_t) BarrelDistortion, MagickFalse },
- { "BarrelInverse", (ssize_t) BarrelInverseDistortion, MagickFalse },
- { "Shepards", (ssize_t) ShepardsDistortion, MagickFalse },
- { "Resize", (ssize_t) ResizeDistortion, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedDistortion, MagickFalse }
+ { "Undefined", UndefinedDistortion, UndefinedOptionFlag, MagickTrue },
+ { "Affine", AffineDistortion, UndefinedOptionFlag, MagickFalse },
+ { "AffineProjection", AffineProjectionDistortion, UndefinedOptionFlag, MagickFalse },
+ { "ScaleRotateTranslate", ScaleRotateTranslateDistortion, UndefinedOptionFlag, MagickFalse },
+ { "SRT", ScaleRotateTranslateDistortion, UndefinedOptionFlag, MagickFalse },
+ { "Perspective", PerspectiveDistortion, UndefinedOptionFlag, MagickFalse },
+ { "PerspectiveProjection", PerspectiveProjectionDistortion, UndefinedOptionFlag, MagickFalse },
+ { "Bilinear", BilinearForwardDistortion, UndefinedOptionFlag, MagickTrue },
+ { "BilinearForward", BilinearForwardDistortion, UndefinedOptionFlag, MagickFalse },
+ { "BilinearReverse", BilinearReverseDistortion, UndefinedOptionFlag, MagickFalse },
+ { "Polynomial", PolynomialDistortion, UndefinedOptionFlag, MagickFalse },
+ { "Arc", ArcDistortion, UndefinedOptionFlag, MagickFalse },
+ { "Polar", PolarDistortion, UndefinedOptionFlag, MagickFalse },
+ { "DePolar", DePolarDistortion, UndefinedOptionFlag, MagickFalse },
+ { "Barrel", BarrelDistortion, UndefinedOptionFlag, MagickFalse },
+ { "BarrelInverse", BarrelInverseDistortion, UndefinedOptionFlag, MagickFalse },
+ { "Shepards", ShepardsDistortion, UndefinedOptionFlag, MagickFalse },
+ { "Resize", ResizeDistortion, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedDistortion, UndefinedOptionFlag, MagickFalse }
},
DitherOptions[] =
{
- { "Undefined", (ssize_t) UndefinedDitherMethod, MagickTrue },
- { "None", (ssize_t) NoDitherMethod, MagickFalse },
- { "FloydSteinberg", (ssize_t) FloydSteinbergDitherMethod, MagickFalse },
- { "Riemersma", (ssize_t) RiemersmaDitherMethod, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedEndian, MagickFalse }
+ { "Undefined", UndefinedDitherMethod, UndefinedOptionFlag, MagickTrue },
+ { "None", NoDitherMethod, UndefinedOptionFlag, MagickFalse },
+ { "FloydSteinberg", FloydSteinbergDitherMethod, UndefinedOptionFlag, MagickFalse },
+ { "Riemersma", RiemersmaDitherMethod, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedEndian, UndefinedOptionFlag, MagickFalse }
},
EndianOptions[] =
{
- { "Undefined", (ssize_t) UndefinedEndian, MagickTrue },
- { "LSB", (ssize_t) LSBEndian, MagickFalse },
- { "MSB", (ssize_t) MSBEndian, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedEndian, MagickFalse }
+ { "Undefined", UndefinedEndian, UndefinedOptionFlag, MagickTrue },
+ { "LSB", LSBEndian, UndefinedOptionFlag, MagickFalse },
+ { "MSB", MSBEndian, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedEndian, UndefinedOptionFlag, MagickFalse }
},
EvaluateOptions[] =
{
- { "Undefined", (ssize_t) UndefinedEvaluateOperator, MagickTrue },
- { "Abs", (ssize_t) AbsEvaluateOperator, MagickFalse },
- { "Add", (ssize_t) AddEvaluateOperator, MagickFalse },
- { "AddModulus", (ssize_t) AddModulusEvaluateOperator, MagickFalse },
- { "And", (ssize_t) AndEvaluateOperator, MagickFalse },
- { "Cos", (ssize_t) CosineEvaluateOperator, MagickFalse },
- { "Cosine", (ssize_t) CosineEvaluateOperator, MagickFalse },
- { "Divide", (ssize_t) DivideEvaluateOperator, MagickFalse },
- { "Exp", (ssize_t) ExponentialEvaluateOperator, MagickFalse },
- { "Exponential", (ssize_t) ExponentialEvaluateOperator, MagickFalse },
- { "GaussianNoise", (ssize_t) GaussianNoiseEvaluateOperator, MagickFalse },
- { "ImpulseNoise", (ssize_t) ImpulseNoiseEvaluateOperator, MagickFalse },
- { "LaplacianNoise", (ssize_t) LaplacianNoiseEvaluateOperator, MagickFalse },
- { "LeftShift", (ssize_t) LeftShiftEvaluateOperator, MagickFalse },
- { "Log", (ssize_t) LogEvaluateOperator, MagickFalse },
- { "Max", (ssize_t) MaxEvaluateOperator, MagickFalse },
- { "Mean", (ssize_t) MeanEvaluateOperator, MagickFalse },
- { "Median", (ssize_t) MedianEvaluateOperator, MagickFalse },
- { "Min", (ssize_t) MinEvaluateOperator, MagickFalse },
- { "MultiplicativeNoise", (ssize_t) MultiplicativeNoiseEvaluateOperator, MagickFalse },
- { "Multiply", (ssize_t) MultiplyEvaluateOperator, MagickFalse },
- { "Or", (ssize_t) OrEvaluateOperator, MagickFalse },
- { "PoissonNoise", (ssize_t) PoissonNoiseEvaluateOperator, MagickFalse },
- { "Pow", (ssize_t) PowEvaluateOperator, MagickFalse },
- { "RightShift", (ssize_t) RightShiftEvaluateOperator, MagickFalse },
- { "Set", (ssize_t) SetEvaluateOperator, MagickFalse },
- { "Sin", (ssize_t) SineEvaluateOperator, MagickFalse },
- { "Sine", (ssize_t) SineEvaluateOperator, MagickFalse },
- { "Subtract", (ssize_t) SubtractEvaluateOperator, MagickFalse },
- { "Threshold", (ssize_t) ThresholdEvaluateOperator, MagickFalse },
- { "ThresholdBlack", (ssize_t) ThresholdBlackEvaluateOperator, MagickFalse },
- { "ThresholdWhite", (ssize_t) ThresholdWhiteEvaluateOperator, MagickFalse },
- { "UniformNoise", (ssize_t) UniformNoiseEvaluateOperator, MagickFalse },
- { "Xor", (ssize_t) XorEvaluateOperator, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedEvaluateOperator, MagickFalse }
+ { "Undefined", UndefinedEvaluateOperator, UndefinedOptionFlag, MagickTrue },
+ { "Abs", AbsEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Add", AddEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "AddModulus", AddModulusEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "And", AndEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Cos", CosineEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Cosine", CosineEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Divide", DivideEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Exp", ExponentialEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Exponential", ExponentialEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "GaussianNoise", GaussianNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "ImpulseNoise", ImpulseNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "LaplacianNoise", LaplacianNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "LeftShift", LeftShiftEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Log", LogEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Max", MaxEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Mean", MeanEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Median", MedianEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Min", MinEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "MultiplicativeNoise", MultiplicativeNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Multiply", MultiplyEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Or", OrEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "PoissonNoise", PoissonNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Pow", PowEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "RightShift", RightShiftEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Set", SetEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Sin", SineEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Sine", SineEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Subtract", SubtractEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Threshold", ThresholdEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "ThresholdBlack", ThresholdBlackEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "ThresholdWhite", ThresholdWhiteEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "UniformNoise", UniformNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { "Xor", XorEvaluateOperator, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedEvaluateOperator, UndefinedOptionFlag, MagickFalse }
},
FillRuleOptions[] =
{
- { "Undefined", (ssize_t) UndefinedRule, MagickTrue },
- { "Evenodd", (ssize_t) EvenOddRule, MagickFalse },
- { "NonZero", (ssize_t) NonZeroRule, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedRule, MagickFalse }
+ { "Undefined", UndefinedRule, UndefinedOptionFlag, MagickTrue },
+ { "Evenodd", EvenOddRule, UndefinedOptionFlag, MagickFalse },
+ { "NonZero", NonZeroRule, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedRule, UndefinedOptionFlag, MagickFalse }
},
FilterOptions[] =
{
- { "Undefined", (ssize_t) UndefinedFilter, MagickTrue },
- { "Bartlett", (ssize_t) BartlettFilter, MagickFalse },
- { "Blackman", (ssize_t) BlackmanFilter, MagickFalse },
- { "Bohman", (ssize_t) BohmanFilter, MagickFalse },
- { "Box", (ssize_t) BoxFilter, MagickFalse },
- { "Catrom", (ssize_t) CatromFilter, MagickFalse },
- { "Cubic", (ssize_t) CubicFilter, MagickFalse },
- { "Gaussian", (ssize_t) GaussianFilter, MagickFalse },
- { "Hamming", (ssize_t) HammingFilter, MagickFalse },
- { "Hanning", (ssize_t) HanningFilter, MagickFalse },
- { "Hermite", (ssize_t) HermiteFilter, MagickFalse },
- { "Jinc", (ssize_t) JincFilter, MagickFalse },
- { "Kaiser", (ssize_t) KaiserFilter, MagickFalse },
- { "Lagrange", (ssize_t) LagrangeFilter, MagickFalse },
- { "Lanczos", (ssize_t) LanczosFilter, MagickFalse },
- { "LanczosSharp", (ssize_t) LanczosSharpFilter, MagickFalse },
- { "Lanczos2", (ssize_t) Lanczos2Filter, MagickFalse },
- { "Lanczos2Sharp", (ssize_t) Lanczos2SharpFilter, MagickFalse },
- { "Mitchell", (ssize_t) MitchellFilter, MagickFalse },
- { "Parzen", (ssize_t) ParzenFilter, MagickFalse },
- { "Point", (ssize_t) PointFilter, MagickFalse },
- { "Quadratic", (ssize_t) QuadraticFilter, MagickFalse },
- { "Robidoux", (ssize_t) RobidouxFilter, MagickFalse },
- { "Sinc", (ssize_t) SincFilter, MagickFalse },
- { "SincFast", (ssize_t) SincFastFilter, MagickFalse },
- { "Triangle", (ssize_t) TriangleFilter, MagickFalse },
- { "Welsh", (ssize_t) WelshFilter, MagickFalse },
+ { "Undefined", UndefinedFilter, UndefinedOptionFlag, MagickTrue },
+ { "Bartlett", BartlettFilter, UndefinedOptionFlag, MagickFalse },
+ { "Blackman", BlackmanFilter, UndefinedOptionFlag, MagickFalse },
+ { "Bohman", BohmanFilter, UndefinedOptionFlag, MagickFalse },
+ { "Box", BoxFilter, UndefinedOptionFlag, MagickFalse },
+ { "Catrom", CatromFilter, UndefinedOptionFlag, MagickFalse },
+ { "Cubic", CubicFilter, UndefinedOptionFlag, MagickFalse },
+ { "Gaussian", GaussianFilter, UndefinedOptionFlag, MagickFalse },
+ { "Hamming", HammingFilter, UndefinedOptionFlag, MagickFalse },
+ { "Hanning", HanningFilter, UndefinedOptionFlag, MagickFalse },
+ { "Hermite", HermiteFilter, UndefinedOptionFlag, MagickFalse },
+ { "Jinc", JincFilter, UndefinedOptionFlag, MagickFalse },
+ { "Kaiser", KaiserFilter, UndefinedOptionFlag, MagickFalse },
+ { "Lagrange", LagrangeFilter, UndefinedOptionFlag, MagickFalse },
+ { "Lanczos", LanczosFilter, UndefinedOptionFlag, MagickFalse },
+ { "LanczosSharp", LanczosSharpFilter, UndefinedOptionFlag, MagickFalse },
+ { "Lanczos2", Lanczos2Filter, UndefinedOptionFlag, MagickFalse },
+ { "Lanczos2Sharp", Lanczos2SharpFilter, UndefinedOptionFlag, MagickFalse },
+ { "Mitchell", MitchellFilter, UndefinedOptionFlag, MagickFalse },
+ { "Parzen", ParzenFilter, UndefinedOptionFlag, MagickFalse },
+ { "Point", PointFilter, UndefinedOptionFlag, MagickFalse },
+ { "Quadratic", QuadraticFilter, UndefinedOptionFlag, MagickFalse },
+ { "Robidoux", RobidouxFilter, UndefinedOptionFlag, MagickFalse },
+ { "Sinc", SincFilter, UndefinedOptionFlag, MagickFalse },
+ { "SincFast", SincFastFilter, UndefinedOptionFlag, MagickFalse },
+ { "Triangle", TriangleFilter, UndefinedOptionFlag, MagickFalse },
+ { "Welsh", WelshFilter, UndefinedOptionFlag, MagickFalse },
/* For backward compatibility - must be after "Jinc" */
- { "Bessel", (ssize_t) JincFilter, MagickTrue },
- { (char *) NULL, (ssize_t) UndefinedFilter, MagickFalse }
+ { "Bessel", JincFilter, UndefinedOptionFlag, MagickTrue },
+ { (char *) NULL, UndefinedFilter, UndefinedOptionFlag, MagickFalse }
},
FunctionOptions[] =
{
- { "Undefined", (ssize_t) UndefinedFunction, MagickTrue },
- { "Polynomial", (ssize_t) PolynomialFunction, MagickFalse },
- { "Sinusoid", (ssize_t) SinusoidFunction, MagickFalse },
- { "ArcSin", (ssize_t) ArcsinFunction, MagickFalse },
- { "ArcTan", (ssize_t) ArctanFunction, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedFunction, MagickFalse }
+ { "Undefined", UndefinedFunction, UndefinedOptionFlag, MagickTrue },
+ { "Polynomial", PolynomialFunction, UndefinedOptionFlag, MagickFalse },
+ { "Sinusoid", SinusoidFunction, UndefinedOptionFlag, MagickFalse },
+ { "ArcSin", ArcsinFunction, UndefinedOptionFlag, MagickFalse },
+ { "ArcTan", ArctanFunction, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedFunction, UndefinedOptionFlag, MagickFalse }
},
GravityOptions[] =
{
- { "Undefined", (ssize_t) UndefinedGravity, MagickTrue },
- { "None", (ssize_t) UndefinedGravity, MagickFalse },
- { "Center", (ssize_t) CenterGravity, MagickFalse },
- { "East", (ssize_t) EastGravity, MagickFalse },
- { "Forget", (ssize_t) ForgetGravity, MagickFalse },
- { "NorthEast", (ssize_t) NorthEastGravity, MagickFalse },
- { "North", (ssize_t) NorthGravity, MagickFalse },
- { "NorthWest", (ssize_t) NorthWestGravity, MagickFalse },
- { "SouthEast", (ssize_t) SouthEastGravity, MagickFalse },
- { "South", (ssize_t) SouthGravity, MagickFalse },
- { "SouthWest", (ssize_t) SouthWestGravity, MagickFalse },
- { "West", (ssize_t) WestGravity, MagickFalse },
- { "Static", (ssize_t) StaticGravity, MagickFalse },
- { (char *) NULL, UndefinedGravity, MagickFalse }
- },
- ImageListOptions[] =
- {
- { "append", MagickTrue, MagickFalse },
- { "affinity", MagickTrue, MagickFalse },
- { "average", MagickTrue, MagickFalse },
- { "clut", MagickTrue, MagickFalse },
- { "coalesce", MagickTrue, MagickFalse },
- { "combine", MagickTrue, MagickFalse },
- { "composite", MagickTrue, MagickFalse },
- { "crop", MagickTrue, MagickFalse },
- { "debug", MagickTrue, MagickFalse },
- { "deconstruct", MagickTrue, MagickFalse },
- { "delete", MagickTrue, MagickFalse },
- { "duplicate", MagickTrue, MagickFalse },
- { "evaluate-sequence", MagickTrue, MagickFalse },
- { "fft", MagickTrue, MagickFalse },
- { "flatten", MagickTrue, MagickFalse },
- { "fx", MagickTrue, MagickFalse },
- { "hald-clut", MagickTrue, MagickFalse },
- { "ift", MagickTrue, MagickFalse },
- { "identify", MagickTrue, MagickFalse },
- { "insert", MagickTrue, MagickFalse },
- { "layers", MagickTrue, MagickFalse },
- { "limit", MagickTrue, MagickFalse },
- { "map", MagickTrue, MagickFalse },
- { "maximum", MagickTrue, MagickFalse },
- { "minimum", MagickTrue, MagickFalse },
- { "morph", MagickTrue, MagickFalse },
- { "mosaic", MagickTrue, MagickFalse },
- { "optimize", MagickTrue, MagickFalse },
- { "print", MagickTrue, MagickFalse },
- { "process", MagickTrue, MagickFalse },
- { "quiet", MagickTrue, MagickFalse },
- { "separate", MagickTrue, MagickFalse },
- { "smush", MagickTrue, MagickFalse },
- { "swap", MagickTrue, MagickFalse },
- { "write", MagickTrue, MagickFalse },
- { (char *) NULL, MagickFalse, MagickFalse }
+ { "Undefined", UndefinedGravity, UndefinedOptionFlag, MagickTrue },
+ { "None", UndefinedGravity, UndefinedOptionFlag, MagickFalse },
+ { "Center", CenterGravity, UndefinedOptionFlag, MagickFalse },
+ { "East", EastGravity, UndefinedOptionFlag, MagickFalse },
+ { "Forget", ForgetGravity, UndefinedOptionFlag, MagickFalse },
+ { "NorthEast", NorthEastGravity, UndefinedOptionFlag, MagickFalse },
+ { "North", NorthGravity, UndefinedOptionFlag, MagickFalse },
+ { "NorthWest", NorthWestGravity, UndefinedOptionFlag, MagickFalse },
+ { "SouthEast", SouthEastGravity, UndefinedOptionFlag, MagickFalse },
+ { "South", SouthGravity, UndefinedOptionFlag, MagickFalse },
+ { "SouthWest", SouthWestGravity, UndefinedOptionFlag, MagickFalse },
+ { "West", WestGravity, UndefinedOptionFlag, MagickFalse },
+ { "Static", StaticGravity, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedGravity, UndefinedOptionFlag, MagickFalse }
},
IntentOptions[] =
{
- { "Undefined", (ssize_t) UndefinedIntent, MagickTrue },
- { "Absolute", (ssize_t) AbsoluteIntent, MagickFalse },
- { "Perceptual", (ssize_t) PerceptualIntent, MagickFalse },
- { "Relative", (ssize_t) RelativeIntent, MagickFalse },
- { "Saturation", (ssize_t) SaturationIntent, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedIntent, MagickFalse }
+ { "Undefined", UndefinedIntent, UndefinedOptionFlag, MagickTrue },
+ { "Absolute", AbsoluteIntent, UndefinedOptionFlag, MagickFalse },
+ { "Perceptual", PerceptualIntent, UndefinedOptionFlag, MagickFalse },
+ { "Relative", RelativeIntent, UndefinedOptionFlag, MagickFalse },
+ { "Saturation", SaturationIntent, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedIntent, UndefinedOptionFlag, MagickFalse }
},
InterlaceOptions[] =
{
- { "Undefined", (ssize_t) UndefinedInterlace, MagickTrue },
- { "Line", (ssize_t) LineInterlace, MagickFalse },
- { "None", (ssize_t) NoInterlace, MagickFalse },
- { "Plane", (ssize_t) PlaneInterlace, MagickFalse },
- { "Partition", (ssize_t) PartitionInterlace, MagickFalse },
- { "GIF", (ssize_t) GIFInterlace, MagickFalse },
- { "JPEG", (ssize_t) JPEGInterlace, MagickFalse },
- { "PNG", (ssize_t) PNGInterlace, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedInterlace, MagickFalse }
+ { "Undefined", UndefinedInterlace, UndefinedOptionFlag, MagickTrue },
+ { "Line", LineInterlace, UndefinedOptionFlag, MagickFalse },
+ { "None", NoInterlace, UndefinedOptionFlag, MagickFalse },
+ { "Plane", PlaneInterlace, UndefinedOptionFlag, MagickFalse },
+ { "Partition", PartitionInterlace, UndefinedOptionFlag, MagickFalse },
+ { "GIF", GIFInterlace, UndefinedOptionFlag, MagickFalse },
+ { "JPEG", JPEGInterlace, UndefinedOptionFlag, MagickFalse },
+ { "PNG", PNGInterlace, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedInterlace, UndefinedOptionFlag, MagickFalse }
},
InterpolateOptions[] =
{
- { "Undefined", (ssize_t) UndefinedInterpolatePixel, MagickTrue },
- { "Average", (ssize_t) AverageInterpolatePixel, MagickFalse },
- { "Bicubic", (ssize_t) BicubicInterpolatePixel, MagickFalse },
- { "Bilinear", (ssize_t) BilinearInterpolatePixel, MagickFalse },
- { "filter", (ssize_t) FilterInterpolatePixel, MagickFalse },
- { "Integer", (ssize_t) IntegerInterpolatePixel, MagickFalse },
- { "Mesh", (ssize_t) MeshInterpolatePixel, MagickFalse },
- { "NearestNeighbor", (ssize_t) NearestNeighborInterpolatePixel, MagickFalse },
- { "Spline", (ssize_t) SplineInterpolatePixel, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedInterpolatePixel, MagickFalse }
+ { "Undefined", UndefinedInterpolatePixel, UndefinedOptionFlag, MagickTrue },
+ { "Average", AverageInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Bicubic", BicubicInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Bilinear", BilinearInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "filter", FilterInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Integer", IntegerInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Mesh", MeshInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "NearestNeighbor", NearestNeighborInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Spline", SplineInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedInterpolatePixel, UndefinedOptionFlag, MagickFalse }
},
KernelOptions[] =
{
- { "Undefined", (ssize_t) UndefinedKernel, MagickTrue },
- { "Unity", (ssize_t) UnityKernel, MagickFalse },
- { "Gaussian", (ssize_t) GaussianKernel, MagickFalse },
- { "DoG", (ssize_t) DoGKernel, MagickFalse },
- { "LoG", (ssize_t) LoGKernel, MagickFalse },
- { "Blur", (ssize_t) BlurKernel, MagickFalse },
- { "Comet", (ssize_t) CometKernel, MagickFalse },
- { "Laplacian", (ssize_t) LaplacianKernel, MagickFalse },
- { "Sobel", (ssize_t) SobelKernel, MagickFalse },
- { "FreiChen", (ssize_t) FreiChenKernel, MagickFalse },
- { "Roberts", (ssize_t) RobertsKernel, MagickFalse },
- { "Prewitt", (ssize_t) PrewittKernel, MagickFalse },
- { "Compass", (ssize_t) CompassKernel, MagickFalse },
- { "Kirsch", (ssize_t) KirschKernel, MagickFalse },
- { "Diamond", (ssize_t) DiamondKernel, MagickFalse },
- { "Square", (ssize_t) SquareKernel, MagickFalse },
- { "Rectangle", (ssize_t) RectangleKernel, MagickFalse },
- { "Disk", (ssize_t) DiskKernel, MagickFalse },
- { "Octagon", (ssize_t) OctagonKernel, MagickFalse },
- { "Plus", (ssize_t) PlusKernel, MagickFalse },
- { "Cross", (ssize_t) CrossKernel, MagickFalse },
- { "Ring", (ssize_t) RingKernel, MagickFalse },
- { "Peaks", (ssize_t) PeaksKernel, MagickFalse },
- { "Edges", (ssize_t) EdgesKernel, MagickFalse },
- { "Corners", (ssize_t) CornersKernel, MagickFalse },
- { "Diagonals", (ssize_t) DiagonalsKernel, MagickFalse },
- { "ThinDiagonals", (ssize_t) DiagonalsKernel, MagickTrue }, /* depreciated */
- { "LineEnds", (ssize_t) LineEndsKernel, MagickFalse },
- { "LineJunctions", (ssize_t) LineJunctionsKernel, MagickFalse },
- { "Ridges", (ssize_t) RidgesKernel, MagickFalse },
- { "ConvexHull", (ssize_t) ConvexHullKernel, MagickFalse },
- { "ThinSe", (ssize_t) ThinSEKernel, MagickFalse },
- { "Skeleton", (ssize_t) SkeletonKernel, MagickFalse },
- { "Chebyshev", (ssize_t) ChebyshevKernel, MagickFalse },
- { "Manhattan", (ssize_t) ManhattanKernel, MagickFalse },
- { "Octagonal", (ssize_t) OctagonalKernel, MagickFalse },
- { "Euclidean", (ssize_t) EuclideanKernel, MagickFalse },
- { "User Defined", (ssize_t) UserDefinedKernel, MagickTrue }, /* internal */
- { (char *) NULL, (ssize_t) UndefinedKernel, MagickFalse }
+ { "Undefined", UndefinedKernel, UndefinedOptionFlag, MagickTrue },
+ { "Unity", UnityKernel, UndefinedOptionFlag, MagickFalse },
+ { "Gaussian", GaussianKernel, UndefinedOptionFlag, MagickFalse },
+ { "DoG", DoGKernel, UndefinedOptionFlag, MagickFalse },
+ { "LoG", LoGKernel, UndefinedOptionFlag, MagickFalse },
+ { "Blur", BlurKernel, UndefinedOptionFlag, MagickFalse },
+ { "Comet", CometKernel, UndefinedOptionFlag, MagickFalse },
+ { "Laplacian", LaplacianKernel, UndefinedOptionFlag, MagickFalse },
+ { "Sobel", SobelKernel, UndefinedOptionFlag, MagickFalse },
+ { "FreiChen", FreiChenKernel, UndefinedOptionFlag, MagickFalse },
+ { "Roberts", RobertsKernel, UndefinedOptionFlag, MagickFalse },
+ { "Prewitt", PrewittKernel, UndefinedOptionFlag, MagickFalse },
+ { "Compass", CompassKernel, UndefinedOptionFlag, MagickFalse },
+ { "Kirsch", KirschKernel, UndefinedOptionFlag, MagickFalse },
+ { "Diamond", DiamondKernel, UndefinedOptionFlag, MagickFalse },
+ { "Square", SquareKernel, UndefinedOptionFlag, MagickFalse },
+ { "Rectangle", RectangleKernel, UndefinedOptionFlag, MagickFalse },
+ { "Disk", DiskKernel, UndefinedOptionFlag, MagickFalse },
+ { "Octagon", OctagonKernel, UndefinedOptionFlag, MagickFalse },
+ { "Plus", PlusKernel, UndefinedOptionFlag, MagickFalse },
+ { "Cross", CrossKernel, UndefinedOptionFlag, MagickFalse },
+ { "Ring", RingKernel, UndefinedOptionFlag, MagickFalse },
+ { "Peaks", PeaksKernel, UndefinedOptionFlag, MagickFalse },
+ { "Edges", EdgesKernel, UndefinedOptionFlag, MagickFalse },
+ { "Corners", CornersKernel, UndefinedOptionFlag, MagickFalse },
+ { "Diagonals", DiagonalsKernel, UndefinedOptionFlag, MagickFalse },
+ { "ThinDiagonals", DiagonalsKernel, DeprecateOptionFlag, MagickTrue },
+ { "LineEnds", LineEndsKernel, UndefinedOptionFlag, MagickFalse },
+ { "LineJunctions", LineJunctionsKernel, UndefinedOptionFlag, MagickFalse },
+ { "Ridges", RidgesKernel, UndefinedOptionFlag, MagickFalse },
+ { "ConvexHull", ConvexHullKernel, UndefinedOptionFlag, MagickFalse },
+ { "ThinSe", ThinSEKernel, UndefinedOptionFlag, MagickFalse },
+ { "Skeleton", SkeletonKernel, UndefinedOptionFlag, MagickFalse },
+ { "Chebyshev", ChebyshevKernel, UndefinedOptionFlag, MagickFalse },
+ { "Manhattan", ManhattanKernel, UndefinedOptionFlag, MagickFalse },
+ { "Octagonal", OctagonalKernel, UndefinedOptionFlag, MagickFalse },
+ { "Euclidean", EuclideanKernel, UndefinedOptionFlag, MagickFalse },
+ { "User Defined", UserDefinedKernel, UndefinedOptionFlag, MagickTrue },
+ { (char *) NULL, UndefinedKernel, UndefinedOptionFlag, MagickFalse }
},
LayerOptions[] =
{
- { "Undefined", (ssize_t) UndefinedLayer, MagickTrue },
- { "Coalesce", (ssize_t) CoalesceLayer, MagickFalse },
- { "CompareAny", (ssize_t) CompareAnyLayer, MagickFalse },
- { "CompareClear", (ssize_t) CompareClearLayer, MagickFalse },
- { "CompareOverlay", (ssize_t) CompareOverlayLayer, MagickFalse },
- { "Dispose", (ssize_t) DisposeLayer, MagickFalse },
- { "Optimize", (ssize_t) OptimizeLayer, MagickFalse },
- { "OptimizeFrame", (ssize_t) OptimizeImageLayer, MagickFalse },
- { "OptimizePlus", (ssize_t) OptimizePlusLayer, MagickFalse },
- { "OptimizeTransparency", (ssize_t) OptimizeTransLayer, MagickFalse },
- { "RemoveDups", (ssize_t) RemoveDupsLayer, MagickFalse },
- { "RemoveZero", (ssize_t) RemoveZeroLayer, MagickFalse },
- { "Composite", (ssize_t) CompositeLayer, MagickFalse },
- { "Merge", (ssize_t) MergeLayer, MagickFalse },
- { "Flatten", (ssize_t) FlattenLayer, MagickFalse },
- { "Mosaic", (ssize_t) MosaicLayer, MagickFalse },
- { "TrimBounds", (ssize_t) TrimBoundsLayer, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedLayer, MagickFalse }
+ { "Undefined", UndefinedLayer, UndefinedOptionFlag, MagickTrue },
+ { "Coalesce", CoalesceLayer, UndefinedOptionFlag, MagickFalse },
+ { "CompareAny", CompareAnyLayer, UndefinedOptionFlag, MagickFalse },
+ { "CompareClear", CompareClearLayer, UndefinedOptionFlag, MagickFalse },
+ { "CompareOverlay", CompareOverlayLayer, UndefinedOptionFlag, MagickFalse },
+ { "Dispose", DisposeLayer, UndefinedOptionFlag, MagickFalse },
+ { "Optimize", OptimizeLayer, UndefinedOptionFlag, MagickFalse },
+ { "OptimizeFrame", OptimizeImageLayer, UndefinedOptionFlag, MagickFalse },
+ { "OptimizePlus", OptimizePlusLayer, UndefinedOptionFlag, MagickFalse },
+ { "OptimizeTransparency", OptimizeTransLayer, UndefinedOptionFlag, MagickFalse },
+ { "RemoveDups", RemoveDupsLayer, UndefinedOptionFlag, MagickFalse },
+ { "RemoveZero", RemoveZeroLayer, UndefinedOptionFlag, MagickFalse },
+ { "Composite", CompositeLayer, UndefinedOptionFlag, MagickFalse },
+ { "Merge", MergeLayer, UndefinedOptionFlag, MagickFalse },
+ { "Flatten", FlattenLayer, UndefinedOptionFlag, MagickFalse },
+ { "Mosaic", MosaicLayer, UndefinedOptionFlag, MagickFalse },
+ { "TrimBounds", TrimBoundsLayer, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedLayer, UndefinedOptionFlag, MagickFalse }
},
LineCapOptions[] =
{
- { "Undefined", (ssize_t) UndefinedCap, MagickTrue },
- { "Butt", (ssize_t) ButtCap, MagickFalse },
- { "Round", (ssize_t) RoundCap, MagickFalse },
- { "Square", (ssize_t) SquareCap, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedCap, MagickFalse }
+ { "Undefined", UndefinedCap, UndefinedOptionFlag, MagickTrue },
+ { "Butt", ButtCap, UndefinedOptionFlag, MagickFalse },
+ { "Round", RoundCap, UndefinedOptionFlag, MagickFalse },
+ { "Square", SquareCap, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedCap, UndefinedOptionFlag, MagickFalse }
},
LineJoinOptions[] =
{
- { "Undefined", (ssize_t) UndefinedJoin, MagickTrue },
- { "Bevel", (ssize_t) BevelJoin, MagickFalse },
- { "Miter", (ssize_t) MiterJoin, MagickFalse },
- { "Round", (ssize_t) RoundJoin, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedJoin, MagickFalse }
+ { "Undefined", UndefinedJoin, UndefinedOptionFlag, MagickTrue },
+ { "Bevel", BevelJoin, UndefinedOptionFlag, MagickFalse },
+ { "Miter", MiterJoin, UndefinedOptionFlag, MagickFalse },
+ { "Round", RoundJoin, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedJoin, UndefinedOptionFlag, MagickFalse }
},
ListOptions[] =
{
- { "Align", (ssize_t) MagickAlignOptions, MagickFalse },
- { "Alpha", (ssize_t) MagickAlphaOptions, MagickFalse },
- { "Boolean", (ssize_t) MagickBooleanOptions, MagickFalse },
- { "Channel", (ssize_t) MagickChannelOptions, MagickFalse },
- { "Class", (ssize_t) MagickClassOptions, MagickFalse },
- { "ClipPath", (ssize_t) MagickClipPathOptions, MagickFalse },
- { "Coder", (ssize_t) MagickCoderOptions, MagickFalse },
- { "Color", (ssize_t) MagickColorOptions, MagickFalse },
- { "Colorspace", (ssize_t) MagickColorspaceOptions, MagickFalse },
- { "Command", (ssize_t) MagickCommandOptions, MagickFalse },
- { "Compose", (ssize_t) MagickComposeOptions, MagickFalse },
- { "Compress", (ssize_t) MagickCompressOptions, MagickFalse },
- { "Configure", (ssize_t) MagickConfigureOptions, MagickFalse },
- { "DataType", (ssize_t) MagickDataTypeOptions, MagickFalse },
- { "Debug", (ssize_t) MagickDebugOptions, MagickFalse },
- { "Decoration", (ssize_t) MagickDecorateOptions, MagickFalse },
- { "Delegate", (ssize_t) MagickDelegateOptions, MagickFalse },
- { "Direction", (ssize_t) MagickDirectionOptions, MagickFalse },
- { "Dispose", (ssize_t) MagickDisposeOptions, MagickFalse },
- { "Distort", (ssize_t) MagickDistortOptions, MagickFalse },
- { "Dither", (ssize_t) MagickDitherOptions, MagickFalse },
- { "Endian", (ssize_t) MagickEndianOptions, MagickFalse },
- { "Evaluate", (ssize_t) MagickEvaluateOptions, MagickFalse },
- { "FillRule", (ssize_t) MagickFillRuleOptions, MagickFalse },
- { "Filter", (ssize_t) MagickFilterOptions, MagickFalse },
- { "Font", (ssize_t) MagickFontOptions, MagickFalse },
- { "Format", (ssize_t) MagickFormatOptions, MagickFalse },
- { "Function", (ssize_t) MagickFunctionOptions, MagickFalse },
- { "Gravity", (ssize_t) MagickGravityOptions, MagickFalse },
- { "ImageList", (ssize_t) MagickImageListOptions, MagickFalse },
- { "Intent", (ssize_t) MagickIntentOptions, MagickFalse },
- { "Interlace", (ssize_t) MagickInterlaceOptions, MagickFalse },
- { "Interpolate", (ssize_t) MagickInterpolateOptions, MagickFalse },
- { "Kernel", (ssize_t) MagickKernelOptions, MagickFalse },
- { "Layers", (ssize_t) MagickLayerOptions, MagickFalse },
- { "LineCap", (ssize_t) MagickLineCapOptions, MagickFalse },
- { "LineJoin", (ssize_t) MagickLineJoinOptions, MagickFalse },
- { "List", (ssize_t) MagickListOptions, MagickFalse },
- { "Locale", (ssize_t) MagickLocaleOptions, MagickFalse },
- { "LogEvent", (ssize_t) MagickLogEventOptions, MagickFalse },
- { "Log", (ssize_t) MagickLogOptions, MagickFalse },
- { "Magic", (ssize_t) MagickMagicOptions, MagickFalse },
- { "Method", (ssize_t) MagickMethodOptions, MagickFalse },
- { "Metric", (ssize_t) MagickMetricOptions, MagickFalse },
- { "Mime", (ssize_t) MagickMimeOptions, MagickFalse },
- { "Mode", (ssize_t) MagickModeOptions, MagickFalse },
- { "Morphology", (ssize_t) MagickMorphologyOptions, MagickFalse },
- { "Module", (ssize_t) MagickModuleOptions, MagickFalse },
- { "Noise", (ssize_t) MagickNoiseOptions, MagickFalse },
- { "Orientation", (ssize_t) MagickOrientationOptions, MagickFalse },
- { "Policy", (ssize_t) MagickPolicyOptions, MagickFalse },
- { "PolicyDomain", (ssize_t) MagickPolicyDomainOptions, MagickFalse },
- { "PolicyRights", (ssize_t) MagickPolicyRightsOptions, MagickFalse },
- { "Preview", (ssize_t) MagickPreviewOptions, MagickFalse },
- { "Primitive", (ssize_t) MagickPrimitiveOptions, MagickFalse },
- { "QuantumFormat", (ssize_t) MagickQuantumFormatOptions, MagickFalse },
- { "Resource", (ssize_t) MagickResourceOptions, MagickFalse },
- { "SparseColor", (ssize_t) MagickSparseColorOptions, MagickFalse },
- { "Storage", (ssize_t) MagickStorageOptions, MagickFalse },
- { "Stretch", (ssize_t) MagickStretchOptions, MagickFalse },
- { "Style", (ssize_t) MagickStyleOptions, MagickFalse },
- { "Threshold", (ssize_t) MagickThresholdOptions, MagickFalse },
- { "Type", (ssize_t) MagickTypeOptions, MagickFalse },
- { "Units", (ssize_t) MagickResolutionOptions, MagickFalse },
- { "Undefined", (ssize_t) MagickUndefinedOptions, MagickTrue },
- { "Validate", (ssize_t) MagickValidateOptions, MagickFalse },
- { "VirtualPixel", (ssize_t) MagickVirtualPixelOptions, MagickFalse },
- { (char *) NULL, (ssize_t) MagickUndefinedOptions, MagickFalse }
+ { "Align", MagickAlignOptions, UndefinedOptionFlag, MagickFalse },
+ { "Alpha", MagickAlphaOptions, UndefinedOptionFlag, MagickFalse },
+ { "Boolean", MagickBooleanOptions, UndefinedOptionFlag, MagickFalse },
+ { "Channel", MagickChannelOptions, UndefinedOptionFlag, MagickFalse },
+ { "Class", MagickClassOptions, UndefinedOptionFlag, MagickFalse },
+ { "ClipPath", MagickClipPathOptions, UndefinedOptionFlag, MagickFalse },
+ { "Coder", MagickCoderOptions, UndefinedOptionFlag, MagickFalse },
+ { "Color", MagickColorOptions, UndefinedOptionFlag, MagickFalse },
+ { "Colorspace", MagickColorspaceOptions, UndefinedOptionFlag, MagickFalse },
+ { "Command", MagickCommandOptions, UndefinedOptionFlag, MagickFalse },
+ { "Compose", MagickComposeOptions, UndefinedOptionFlag, MagickFalse },
+ { "Compress", MagickCompressOptions, UndefinedOptionFlag, MagickFalse },
+ { "Configure", MagickConfigureOptions, UndefinedOptionFlag, MagickFalse },
+ { "DataType", MagickDataTypeOptions, UndefinedOptionFlag, MagickFalse },
+ { "Debug", MagickDebugOptions, UndefinedOptionFlag, MagickFalse },
+ { "Decoration", MagickDecorateOptions, UndefinedOptionFlag, MagickFalse },
+ { "Delegate", MagickDelegateOptions, UndefinedOptionFlag, MagickFalse },
+ { "Direction", MagickDirectionOptions, UndefinedOptionFlag, MagickFalse },
+ { "Dispose", MagickDisposeOptions, UndefinedOptionFlag, MagickFalse },
+ { "Distort", MagickDistortOptions, UndefinedOptionFlag, MagickFalse },
+ { "Dither", MagickDitherOptions, UndefinedOptionFlag, MagickFalse },
+ { "Endian", MagickEndianOptions, UndefinedOptionFlag, MagickFalse },
+ { "Evaluate", MagickEvaluateOptions, UndefinedOptionFlag, MagickFalse },
+ { "FillRule", MagickFillRuleOptions, UndefinedOptionFlag, MagickFalse },
+ { "Filter", MagickFilterOptions, UndefinedOptionFlag, MagickFalse },
+ { "Font", MagickFontOptions, UndefinedOptionFlag, MagickFalse },
+ { "Format", MagickFormatOptions, UndefinedOptionFlag, MagickFalse },
+ { "Function", MagickFunctionOptions, UndefinedOptionFlag, MagickFalse },
+ { "Gravity", MagickGravityOptions, UndefinedOptionFlag, MagickFalse },
+ { "Intent", MagickIntentOptions, UndefinedOptionFlag, MagickFalse },
+ { "Interlace", MagickInterlaceOptions, UndefinedOptionFlag, MagickFalse },
+ { "Interpolate", MagickInterpolateOptions, UndefinedOptionFlag, MagickFalse },
+ { "Kernel", MagickKernelOptions, UndefinedOptionFlag, MagickFalse },
+ { "Layers", MagickLayerOptions, UndefinedOptionFlag, MagickFalse },
+ { "LineCap", MagickLineCapOptions, UndefinedOptionFlag, MagickFalse },
+ { "LineJoin", MagickLineJoinOptions, UndefinedOptionFlag, MagickFalse },
+ { "List", MagickListOptions, UndefinedOptionFlag, MagickFalse },
+ { "Locale", MagickLocaleOptions, UndefinedOptionFlag, MagickFalse },
+ { "LogEvent", MagickLogEventOptions, UndefinedOptionFlag, MagickFalse },
+ { "Log", MagickLogOptions, UndefinedOptionFlag, MagickFalse },
+ { "Magic", MagickMagicOptions, UndefinedOptionFlag, MagickFalse },
+ { "Method", MagickMethodOptions, UndefinedOptionFlag, MagickFalse },
+ { "Metric", MagickMetricOptions, UndefinedOptionFlag, MagickFalse },
+ { "Mime", MagickMimeOptions, UndefinedOptionFlag, MagickFalse },
+ { "Mode", MagickModeOptions, UndefinedOptionFlag, MagickFalse },
+ { "Morphology", MagickMorphologyOptions, UndefinedOptionFlag, MagickFalse },
+ { "Module", MagickModuleOptions, UndefinedOptionFlag, MagickFalse },
+ { "Noise", MagickNoiseOptions, UndefinedOptionFlag, MagickFalse },
+ { "Orientation", MagickOrientationOptions, UndefinedOptionFlag, MagickFalse },
+ { "Policy", MagickPolicyOptions, UndefinedOptionFlag, MagickFalse },
+ { "PolicyDomain", MagickPolicyDomainOptions, UndefinedOptionFlag, MagickFalse },
+ { "PolicyRights", MagickPolicyRightsOptions, UndefinedOptionFlag, MagickFalse },
+ { "Preview", MagickPreviewOptions, UndefinedOptionFlag, MagickFalse },
+ { "Primitive", MagickPrimitiveOptions, UndefinedOptionFlag, MagickFalse },
+ { "QuantumFormat", MagickQuantumFormatOptions, UndefinedOptionFlag, MagickFalse },
+ { "Resource", MagickResourceOptions, UndefinedOptionFlag, MagickFalse },
+ { "SparseColor", MagickSparseColorOptions, UndefinedOptionFlag, MagickFalse },
+ { "Statistic", MagickStatisticOptions, UndefinedOptionFlag, MagickFalse },
+ { "Storage", MagickStorageOptions, UndefinedOptionFlag, MagickFalse },
+ { "Stretch", MagickStretchOptions, UndefinedOptionFlag, MagickFalse },
+ { "Style", MagickStyleOptions, UndefinedOptionFlag, MagickFalse },
+ { "Threshold", MagickThresholdOptions, UndefinedOptionFlag, MagickFalse },
+ { "Type", MagickTypeOptions, UndefinedOptionFlag, MagickFalse },
+ { "Units", MagickResolutionOptions, UndefinedOptionFlag, MagickFalse },
+ { "Undefined", MagickUndefinedOptions, UndefinedOptionFlag, MagickTrue },
+ { "Validate", MagickValidateOptions, UndefinedOptionFlag, MagickFalse },
+ { "VirtualPixel", MagickVirtualPixelOptions, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, MagickUndefinedOptions, UndefinedOptionFlag, MagickFalse }
},
LogEventOptions[] =
{
- { "Undefined", (ssize_t) UndefinedEvents, MagickTrue },
- { "All", (ssize_t) (AllEvents &~ TraceEvent), MagickFalse },
- { "Annotate", (ssize_t) AnnotateEvent, MagickFalse },
- { "Blob", (ssize_t) BlobEvent, MagickFalse },
- { "Cache", (ssize_t) CacheEvent, MagickFalse },
- { "Coder", (ssize_t) CoderEvent, MagickFalse },
- { "Configure", (ssize_t) ConfigureEvent, MagickFalse },
- { "Deprecate", (ssize_t) DeprecateEvent, MagickFalse },
- { "Draw", (ssize_t) DrawEvent, MagickFalse },
- { "Exception", (ssize_t) ExceptionEvent, MagickFalse },
- { "Locale", (ssize_t) LocaleEvent, MagickFalse },
- { "Module", (ssize_t) ModuleEvent, MagickFalse },
- { "None", (ssize_t) NoEvents, MagickFalse },
- { "Policy", (ssize_t) PolicyEvent, MagickFalse },
- { "Resource", (ssize_t) ResourceEvent, MagickFalse },
- { "Trace", (ssize_t) TraceEvent, MagickFalse },
- { "Transform", (ssize_t) TransformEvent, MagickFalse },
- { "User", (ssize_t) UserEvent, MagickFalse },
- { "Wand", (ssize_t) WandEvent, MagickFalse },
- { "X11", (ssize_t) X11Event, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedEvents, MagickFalse }
+ { "Undefined", UndefinedEvents, UndefinedOptionFlag, MagickTrue },
+ { "All", (AllEvents &~ TraceEvent), UndefinedOptionFlag, MagickFalse },
+ { "Annotate", AnnotateEvent, UndefinedOptionFlag, MagickFalse },
+ { "Blob", BlobEvent, UndefinedOptionFlag, MagickFalse },
+ { "Cache", CacheEvent, UndefinedOptionFlag, MagickFalse },
+ { "Coder", CoderEvent, UndefinedOptionFlag, MagickFalse },
+ { "Configure", ConfigureEvent, UndefinedOptionFlag, MagickFalse },
+ { "Deprecate", DeprecateEvent, UndefinedOptionFlag, MagickFalse },
+ { "Draw", DrawEvent, UndefinedOptionFlag, MagickFalse },
+ { "Exception", ExceptionEvent, UndefinedOptionFlag, MagickFalse },
+ { "Locale", LocaleEvent, UndefinedOptionFlag, MagickFalse },
+ { "Module", ModuleEvent, UndefinedOptionFlag, MagickFalse },
+ { "None", NoEvents, UndefinedOptionFlag, MagickFalse },
+ { "Policy", PolicyEvent, UndefinedOptionFlag, MagickFalse },
+ { "Resource", ResourceEvent, UndefinedOptionFlag, MagickFalse },
+ { "Trace", TraceEvent, UndefinedOptionFlag, MagickFalse },
+ { "Transform", TransformEvent, UndefinedOptionFlag, MagickFalse },
+ { "User", UserEvent, UndefinedOptionFlag, MagickFalse },
+ { "Wand", WandEvent, UndefinedOptionFlag, MagickFalse },
+ { "X11", X11Event, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedEvents, UndefinedOptionFlag, MagickFalse }
},
MetricOptions[] =
{
- { "Undefined", (ssize_t) UndefinedMetric, MagickTrue },
- { "AE", (ssize_t) AbsoluteErrorMetric, MagickFalse },
- { "Fuzz", (ssize_t) FuzzErrorMetric, MagickFalse },
- { "MAE", (ssize_t) MeanAbsoluteErrorMetric, MagickFalse },
- { "MEPP", (ssize_t) MeanErrorPerPixelMetric, MagickFalse },
- { "MSE", (ssize_t) MeanSquaredErrorMetric, MagickFalse },
- { "NCC", (ssize_t) NormalizedCrossCorrelationErrorMetric, MagickFalse },
- { "PAE", (ssize_t) PeakAbsoluteErrorMetric, MagickFalse },
- { "PSNR", (ssize_t) PeakSignalToNoiseRatioMetric, MagickFalse },
- { "RMSE", (ssize_t) RootMeanSquaredErrorMetric, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedMetric, MagickFalse }
+ { "Undefined", UndefinedMetric, UndefinedOptionFlag, MagickTrue },
+ { "AE", AbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse },
+ { "Fuzz", FuzzErrorMetric, UndefinedOptionFlag, MagickFalse },
+ { "MAE", MeanAbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse },
+ { "MEPP", MeanErrorPerPixelMetric, UndefinedOptionFlag, MagickFalse },
+ { "MSE", MeanSquaredErrorMetric, UndefinedOptionFlag, MagickFalse },
+ { "NCC", NormalizedCrossCorrelationErrorMetric, UndefinedOptionFlag, MagickFalse },
+ { "PAE", PeakAbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse },
+ { "PSNR", PeakSignalToNoiseRatioMetric, UndefinedOptionFlag, MagickFalse },
+ { "RMSE", RootMeanSquaredErrorMetric, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedMetric, UndefinedOptionFlag, MagickFalse }
},
MethodOptions[] =
{
- { "Undefined", (ssize_t) UndefinedMethod, MagickTrue },
- { "FillToBorder", (ssize_t) FillToBorderMethod, MagickFalse },
- { "Floodfill", (ssize_t) FloodfillMethod, MagickFalse },
- { "Point", (ssize_t) PointMethod, MagickFalse },
- { "Replace", (ssize_t) ReplaceMethod, MagickFalse },
- { "Reset", (ssize_t) ResetMethod, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedMethod, MagickFalse }
+ { "Undefined", UndefinedMethod, UndefinedOptionFlag, MagickTrue },
+ { "FillToBorder", FillToBorderMethod, UndefinedOptionFlag, MagickFalse },
+ { "Floodfill", FloodfillMethod, UndefinedOptionFlag, MagickFalse },
+ { "Point", PointMethod, UndefinedOptionFlag, MagickFalse },
+ { "Replace", ReplaceMethod, UndefinedOptionFlag, MagickFalse },
+ { "Reset", ResetMethod, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedMethod, UndefinedOptionFlag, MagickFalse }
},
ModeOptions[] =
{
- { "Undefined", (ssize_t) UndefinedMode, MagickTrue },
- { "Concatenate", (ssize_t) ConcatenateMode, MagickFalse },
- { "Frame", (ssize_t) FrameMode, MagickFalse },
- { "Unframe", (ssize_t) UnframeMode, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedMode, MagickFalse }
+ { "Undefined", UndefinedMode, UndefinedOptionFlag, MagickTrue },
+ { "Concatenate", ConcatenateMode, UndefinedOptionFlag, MagickFalse },
+ { "Frame", FrameMode, UndefinedOptionFlag, MagickFalse },
+ { "Unframe", UnframeMode, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedMode, UndefinedOptionFlag, MagickFalse }
},
MorphologyOptions[] =
{
- { "Undefined", (ssize_t) UndefinedMorphology, MagickTrue },
- { "Correlate", (ssize_t) CorrelateMorphology, MagickFalse },
- { "Convolve", (ssize_t) ConvolveMorphology, MagickFalse },
- { "Dilate", (ssize_t) DilateMorphology, MagickFalse },
- { "Erode", (ssize_t) ErodeMorphology, MagickFalse },
- { "Close", (ssize_t) CloseMorphology, MagickFalse },
- { "Open", (ssize_t) OpenMorphology, MagickFalse },
- { "DilateIntensity", (ssize_t) DilateIntensityMorphology, MagickFalse },
- { "ErodeIntensity", (ssize_t) ErodeIntensityMorphology, MagickFalse },
- { "CloseIntensity", (ssize_t) CloseIntensityMorphology, MagickFalse },
- { "OpenIntensity", (ssize_t) OpenIntensityMorphology, MagickFalse },
- { "DilateI", (ssize_t) DilateIntensityMorphology, MagickFalse },
- { "ErodeI", (ssize_t) ErodeIntensityMorphology, MagickFalse },
- { "CloseI", (ssize_t) CloseIntensityMorphology, MagickFalse },
- { "OpenI", (ssize_t) OpenIntensityMorphology, MagickFalse },
- { "Smooth", (ssize_t) SmoothMorphology, MagickFalse },
- { "EdgeOut", (ssize_t) EdgeOutMorphology, MagickFalse },
- { "EdgeIn", (ssize_t) EdgeInMorphology, MagickFalse },
- { "Edge", (ssize_t) EdgeMorphology, MagickFalse },
- { "TopHat", (ssize_t) TopHatMorphology, MagickFalse },
- { "BottomHat", (ssize_t) BottomHatMorphology, MagickFalse },
- { "Distance", (ssize_t) DistanceMorphology, MagickFalse },
- { "Hmt", (ssize_t) HitAndMissMorphology, MagickFalse },
- { "HitNMiss", (ssize_t) HitAndMissMorphology, MagickFalse },
- { "HitAndMiss", (ssize_t) HitAndMissMorphology, MagickFalse },
- { "Thinning", (ssize_t) ThinningMorphology, MagickFalse },
- { "Thicken", (ssize_t) ThickenMorphology, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedMorphology, MagickFalse }
+ { "Undefined", UndefinedMorphology, UndefinedOptionFlag, MagickTrue },
+ { "Correlate", CorrelateMorphology, UndefinedOptionFlag, MagickFalse },
+ { "Convolve", ConvolveMorphology, UndefinedOptionFlag, MagickFalse },
+ { "Dilate", DilateMorphology, UndefinedOptionFlag, MagickFalse },
+ { "Erode", ErodeMorphology, UndefinedOptionFlag, MagickFalse },
+ { "Close", CloseMorphology, UndefinedOptionFlag, MagickFalse },
+ { "Open", OpenMorphology, UndefinedOptionFlag, MagickFalse },
+ { "DilateIntensity", DilateIntensityMorphology, UndefinedOptionFlag, MagickFalse },
+ { "ErodeIntensity", ErodeIntensityMorphology, UndefinedOptionFlag, MagickFalse },
+ { "CloseIntensity", CloseIntensityMorphology, UndefinedOptionFlag, MagickFalse },
+ { "OpenIntensity", OpenIntensityMorphology, UndefinedOptionFlag, MagickFalse },
+ { "DilateI", DilateIntensityMorphology, UndefinedOptionFlag, MagickFalse },
+ { "ErodeI", ErodeIntensityMorphology, UndefinedOptionFlag, MagickFalse },
+ { "CloseI", CloseIntensityMorphology, UndefinedOptionFlag, MagickFalse },
+ { "OpenI", OpenIntensityMorphology, UndefinedOptionFlag, MagickFalse },
+ { "Smooth", SmoothMorphology, UndefinedOptionFlag, MagickFalse },
+ { "EdgeOut", EdgeOutMorphology, UndefinedOptionFlag, MagickFalse },
+ { "EdgeIn", EdgeInMorphology, 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 },
+ { "Voronoi", VoronoiMorphology, UndefinedOptionFlag, MagickTrue },
+ { (char *) NULL, UndefinedMorphology, UndefinedOptionFlag, MagickFalse }
},
NoiseOptions[] =
{
- { "Undefined", (ssize_t) UndefinedNoise, MagickTrue },
- { "Gaussian", (ssize_t) (ssize_t) GaussianNoise, MagickFalse },
- { "Impulse", (ssize_t) ImpulseNoise, MagickFalse },
- { "Laplacian", (ssize_t) LaplacianNoise, MagickFalse },
- { "Multiplicative", (ssize_t) MultiplicativeGaussianNoise, MagickFalse },
- { "Poisson", (ssize_t) PoissonNoise, MagickFalse },
- { "Random", (ssize_t) RandomNoise, MagickFalse },
- { "Uniform", (ssize_t) UniformNoise, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedNoise, MagickFalse }
+ { "Undefined", UndefinedNoise, UndefinedOptionFlag, MagickTrue },
+ { "Gaussian", GaussianNoise, UndefinedOptionFlag, MagickFalse },
+ { "Impulse", ImpulseNoise, UndefinedOptionFlag, MagickFalse },
+ { "Laplacian", LaplacianNoise, UndefinedOptionFlag, MagickFalse },
+ { "Multiplicative", MultiplicativeGaussianNoise, UndefinedOptionFlag, MagickFalse },
+ { "Poisson", PoissonNoise, UndefinedOptionFlag, MagickFalse },
+ { "Random", RandomNoise, UndefinedOptionFlag, MagickFalse },
+ { "Uniform", UniformNoise, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedNoise, UndefinedOptionFlag, MagickFalse }
},
OrientationOptions[] =
{
- { "Undefined", (ssize_t) UndefinedOrientation, MagickTrue },
- { "TopLeft", (ssize_t) TopLeftOrientation, MagickFalse },
- { "TopRight", (ssize_t) TopRightOrientation, MagickFalse },
- { "BottomRight", (ssize_t) BottomRightOrientation, MagickFalse },
- { "BottomLeft", (ssize_t) BottomLeftOrientation, MagickFalse },
- { "LeftTop", (ssize_t) LeftTopOrientation, MagickFalse },
- { "RightTop", (ssize_t) RightTopOrientation, MagickFalse },
- { "RightBottom", (ssize_t) RightBottomOrientation, MagickFalse },
- { "LeftBottom", (ssize_t) LeftBottomOrientation, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedOrientation, MagickFalse }
+ { "Undefined", UndefinedOrientation, UndefinedOptionFlag, MagickTrue },
+ { "TopLeft", TopLeftOrientation, UndefinedOptionFlag, MagickFalse },
+ { "TopRight", TopRightOrientation, UndefinedOptionFlag, MagickFalse },
+ { "BottomRight", BottomRightOrientation, UndefinedOptionFlag, MagickFalse },
+ { "BottomLeft", BottomLeftOrientation, UndefinedOptionFlag, MagickFalse },
+ { "LeftTop", LeftTopOrientation, UndefinedOptionFlag, MagickFalse },
+ { "RightTop", RightTopOrientation, UndefinedOptionFlag, MagickFalse },
+ { "RightBottom", RightBottomOrientation, UndefinedOptionFlag, MagickFalse },
+ { "LeftBottom", LeftBottomOrientation, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedOrientation, UndefinedOptionFlag, MagickFalse }
},
PolicyDomainOptions[] =
{
- { "Undefined", (ssize_t) UndefinedPolicyDomain, MagickTrue },
- { "Coder", (ssize_t) CoderPolicyDomain, MagickFalse },
- { "Delegate", (ssize_t) DelegatePolicyDomain, MagickFalse },
- { "Filter", (ssize_t) FilterPolicyDomain, MagickFalse },
- { "Path", (ssize_t) PathPolicyDomain, MagickFalse },
- { "Resource", (ssize_t) ResourcePolicyDomain, MagickFalse },
- { "System", (ssize_t) SystemPolicyDomain, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedPolicyDomain, MagickFalse }
+ { "Undefined", UndefinedPolicyDomain, UndefinedOptionFlag, MagickTrue },
+ { "Coder", CoderPolicyDomain, UndefinedOptionFlag, MagickFalse },
+ { "Delegate", DelegatePolicyDomain, UndefinedOptionFlag, MagickFalse },
+ { "Filter", FilterPolicyDomain, UndefinedOptionFlag, MagickFalse },
+ { "Path", PathPolicyDomain, UndefinedOptionFlag, MagickFalse },
+ { "Resource", ResourcePolicyDomain, UndefinedOptionFlag, MagickFalse },
+ { "System", SystemPolicyDomain, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedPolicyDomain, UndefinedOptionFlag, MagickFalse }
},
PolicyRightsOptions[] =
{
- { "Undefined", (ssize_t) UndefinedPolicyRights, MagickTrue },
- { "None", (ssize_t) NoPolicyRights, MagickFalse },
- { "Read", (ssize_t) ReadPolicyRights, MagickFalse },
- { "Write", (ssize_t) WritePolicyRights, MagickFalse },
- { "Execute", (ssize_t) ExecutePolicyRights, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedPolicyRights, MagickFalse }
+ { "Undefined", UndefinedPolicyRights, UndefinedOptionFlag, MagickTrue },
+ { "None", NoPolicyRights, UndefinedOptionFlag, MagickFalse },
+ { "Read", ReadPolicyRights, UndefinedOptionFlag, MagickFalse },
+ { "Write", WritePolicyRights, UndefinedOptionFlag, MagickFalse },
+ { "Execute", ExecutePolicyRights, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedPolicyRights, UndefinedOptionFlag, MagickFalse }
},
PreviewOptions[] =
{
- { "Undefined", (ssize_t) UndefinedPreview, MagickTrue },
- { "AddNoise", (ssize_t) AddNoisePreview, MagickFalse },
- { "Blur", (ssize_t) BlurPreview, MagickFalse },
- { "Brightness", (ssize_t) BrightnessPreview, MagickFalse },
- { "Charcoal", (ssize_t) CharcoalDrawingPreview, MagickFalse },
- { "Despeckle", (ssize_t) DespecklePreview, MagickFalse },
- { "Dull", (ssize_t) DullPreview, MagickFalse },
- { "EdgeDetect", (ssize_t) EdgeDetectPreview, MagickFalse },
- { "Gamma", (ssize_t) GammaPreview, MagickFalse },
- { "Grayscale", (ssize_t) GrayscalePreview, MagickFalse },
- { "Hue", (ssize_t) HuePreview, MagickFalse },
- { "Implode", (ssize_t) ImplodePreview, MagickFalse },
- { "JPEG", (ssize_t) JPEGPreview, MagickFalse },
- { "OilPaint", (ssize_t) OilPaintPreview, MagickFalse },
- { "Quantize", (ssize_t) QuantizePreview, MagickFalse },
- { "Raise", (ssize_t) RaisePreview, MagickFalse },
- { "ReduceNoise", (ssize_t) ReduceNoisePreview, MagickFalse },
- { "Roll", (ssize_t) RollPreview, MagickFalse },
- { "Rotate", (ssize_t) RotatePreview, MagickFalse },
- { "Saturation", (ssize_t) SaturationPreview, MagickFalse },
- { "Segment", (ssize_t) SegmentPreview, MagickFalse },
- { "Shade", (ssize_t) ShadePreview, MagickFalse },
- { "Sharpen", (ssize_t) SharpenPreview, MagickFalse },
- { "Shear", (ssize_t) ShearPreview, MagickFalse },
- { "Solarize", (ssize_t) SolarizePreview, MagickFalse },
- { "Spiff", (ssize_t) SpiffPreview, MagickFalse },
- { "Spread", (ssize_t) SpreadPreview, MagickFalse },
- { "Swirl", (ssize_t) SwirlPreview, MagickFalse },
- { "Threshold", (ssize_t) ThresholdPreview, MagickFalse },
- { "Wave", (ssize_t) WavePreview, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedPreview, MagickFalse }
+ { "Undefined", UndefinedPreview, UndefinedOptionFlag, MagickTrue },
+ { "AddNoise", AddNoisePreview, UndefinedOptionFlag, MagickFalse },
+ { "Blur", BlurPreview, UndefinedOptionFlag, MagickFalse },
+ { "Brightness", BrightnessPreview, UndefinedOptionFlag, MagickFalse },
+ { "Charcoal", CharcoalDrawingPreview, UndefinedOptionFlag, MagickFalse },
+ { "Despeckle", DespecklePreview, UndefinedOptionFlag, MagickFalse },
+ { "Dull", DullPreview, UndefinedOptionFlag, MagickFalse },
+ { "EdgeDetect", EdgeDetectPreview, UndefinedOptionFlag, MagickFalse },
+ { "Gamma", GammaPreview, UndefinedOptionFlag, MagickFalse },
+ { "Grayscale", GrayscalePreview, UndefinedOptionFlag, MagickFalse },
+ { "Hue", HuePreview, UndefinedOptionFlag, MagickFalse },
+ { "Implode", ImplodePreview, UndefinedOptionFlag, MagickFalse },
+ { "JPEG", JPEGPreview, UndefinedOptionFlag, MagickFalse },
+ { "OilPaint", OilPaintPreview, UndefinedOptionFlag, MagickFalse },
+ { "Quantize", QuantizePreview, UndefinedOptionFlag, MagickFalse },
+ { "Raise", RaisePreview, UndefinedOptionFlag, MagickFalse },
+ { "ReduceNoise", ReduceNoisePreview, UndefinedOptionFlag, MagickFalse },
+ { "Roll", RollPreview, UndefinedOptionFlag, MagickFalse },
+ { "Rotate", RotatePreview, UndefinedOptionFlag, MagickFalse },
+ { "Saturation", SaturationPreview, UndefinedOptionFlag, MagickFalse },
+ { "Segment", SegmentPreview, UndefinedOptionFlag, MagickFalse },
+ { "Shade", ShadePreview, UndefinedOptionFlag, MagickFalse },
+ { "Sharpen", SharpenPreview, UndefinedOptionFlag, MagickFalse },
+ { "Shear", ShearPreview, UndefinedOptionFlag, MagickFalse },
+ { "Solarize", SolarizePreview, UndefinedOptionFlag, MagickFalse },
+ { "Spiff", SpiffPreview, UndefinedOptionFlag, MagickFalse },
+ { "Spread", SpreadPreview, UndefinedOptionFlag, MagickFalse },
+ { "Swirl", SwirlPreview, UndefinedOptionFlag, MagickFalse },
+ { "Threshold", ThresholdPreview, UndefinedOptionFlag, MagickFalse },
+ { "Wave", WavePreview, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedPreview, UndefinedOptionFlag, MagickFalse }
},
PrimitiveOptions[] =
{
- { "Undefined", (ssize_t) UndefinedPrimitive, MagickTrue },
- { "Arc", (ssize_t) ArcPrimitive, MagickFalse },
- { "Bezier", (ssize_t) BezierPrimitive, MagickFalse },
- { "Circle", (ssize_t) CirclePrimitive, MagickFalse },
- { "Color", (ssize_t) ColorPrimitive, MagickFalse },
- { "Ellipse", (ssize_t) EllipsePrimitive, MagickFalse },
- { "Image", (ssize_t) ImagePrimitive, MagickFalse },
- { "Line", (ssize_t) LinePrimitive, MagickFalse },
- { "Matte", (ssize_t) MattePrimitive, MagickFalse },
- { "Path", (ssize_t) PathPrimitive, MagickFalse },
- { "Point", (ssize_t) PointPrimitive, MagickFalse },
- { "Polygon", (ssize_t) PolygonPrimitive, MagickFalse },
- { "Polyline", (ssize_t) PolylinePrimitive, MagickFalse },
- { "Rectangle", (ssize_t) RectanglePrimitive, MagickFalse },
- { "roundRectangle", (ssize_t) RoundRectanglePrimitive, MagickFalse },
- { "Text", (ssize_t) TextPrimitive, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedPrimitive, MagickFalse }
+ { "Undefined", UndefinedPrimitive, UndefinedOptionFlag, MagickTrue },
+ { "Arc", ArcPrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Bezier", BezierPrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Circle", CirclePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Color", ColorPrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Ellipse", EllipsePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Image", ImagePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Line", LinePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Matte", MattePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Path", PathPrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Point", PointPrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Polygon", PolygonPrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Polyline", PolylinePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Rectangle", RectanglePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "RoundRectangle", RoundRectanglePrimitive, UndefinedOptionFlag, MagickFalse },
+ { "Text", TextPrimitive, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedPrimitive, UndefinedOptionFlag, MagickFalse }
},
QuantumFormatOptions[] =
{
- { "Undefined", (ssize_t) UndefinedQuantumFormat, MagickTrue },
- { "FloatingPoint", (ssize_t) FloatingPointQuantumFormat, MagickFalse },
- { "Signed", (ssize_t) SignedQuantumFormat, MagickFalse },
- { "Unsigned", (ssize_t) UnsignedQuantumFormat, MagickFalse },
- { (char *) NULL, (ssize_t) FloatingPointQuantumFormat, MagickFalse }
+ { "Undefined", UndefinedQuantumFormat, UndefinedOptionFlag, MagickTrue },
+ { "FloatingPoint", FloatingPointQuantumFormat, UndefinedOptionFlag, MagickFalse },
+ { "Signed", SignedQuantumFormat, UndefinedOptionFlag, MagickFalse },
+ { "Unsigned", UnsignedQuantumFormat, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, FloatingPointQuantumFormat, UndefinedOptionFlag, MagickFalse }
},
ResolutionOptions[] =
{
- { "Undefined", (ssize_t) UndefinedResolution, MagickTrue },
- { "PixelsPerInch", (ssize_t) PixelsPerInchResolution, MagickFalse },
- { "PixelsPerCentimeter", (ssize_t) PixelsPerCentimeterResolution, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedResolution, MagickFalse }
+ { "Undefined", UndefinedResolution, UndefinedOptionFlag, MagickTrue },
+ { "PixelsPerInch", PixelsPerInchResolution, UndefinedOptionFlag, MagickFalse },
+ { "PixelsPerCentimeter", PixelsPerCentimeterResolution, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedResolution, UndefinedOptionFlag, MagickFalse }
},
ResourceOptions[] =
{
- { "Undefined", (ssize_t) UndefinedResource, MagickTrue },
- { "Area", (ssize_t) AreaResource, MagickFalse },
- { "Disk", (ssize_t) DiskResource, MagickFalse },
- { "File", (ssize_t) FileResource, MagickFalse },
- { "Map", (ssize_t) MapResource, MagickFalse },
- { "Memory", (ssize_t) MemoryResource, MagickFalse },
- { "Thread", (ssize_t) ThreadResource, MagickFalse },
- { "Time", (ssize_t) TimeResource, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedResource, MagickFalse }
+ { "Undefined", UndefinedResource, UndefinedOptionFlag, MagickTrue },
+ { "Area", AreaResource, UndefinedOptionFlag, MagickFalse },
+ { "Disk", DiskResource, UndefinedOptionFlag, MagickFalse },
+ { "File", FileResource, UndefinedOptionFlag, MagickFalse },
+ { "Map", MapResource, UndefinedOptionFlag, MagickFalse },
+ { "Memory", MemoryResource, UndefinedOptionFlag, MagickFalse },
+ { "Thread", ThreadResource, UndefinedOptionFlag, MagickFalse },
+ { "Time", TimeResource, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedResource, UndefinedOptionFlag, MagickFalse }
},
SparseColorOptions[] =
{
- { "Undefined", (ssize_t) UndefinedDistortion, MagickTrue },
- { "Barycentric", (ssize_t) BarycentricColorInterpolate, MagickFalse },
- { "Bilinear", (ssize_t) BilinearColorInterpolate, MagickFalse },
- { "Shepards", (ssize_t) ShepardsColorInterpolate, MagickFalse },
- { "Voronoi", (ssize_t) VoronoiColorInterpolate, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedResource, MagickFalse }
+ { "Undefined", UndefinedDistortion, UndefinedOptionFlag, MagickTrue },
+ { "Barycentric", BarycentricColorInterpolate, UndefinedOptionFlag, MagickFalse },
+ { "Bilinear", BilinearColorInterpolate, UndefinedOptionFlag, MagickFalse },
+ { "Inverse", InverseColorInterpolate, UndefinedOptionFlag, MagickFalse },
+ { "Shepards", ShepardsColorInterpolate, UndefinedOptionFlag, MagickFalse },
+ { "Voronoi", VoronoiColorInterpolate, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedResource, UndefinedOptionFlag, MagickFalse }
},
StatisticOptions[] =
{
- { "Undefined", (ssize_t) UndefinedStatistic, MagickTrue },
- { "BottomHat", (ssize_t) BottomHatStatistic, MagickFalse },
- { "Gradient", (ssize_t) GradientStatistic, MagickFalse },
- { "Maximum", (ssize_t) MaximumStatistic, MagickFalse },
- { "Mean", (ssize_t) MeanStatistic, MagickFalse },
- { "Median", (ssize_t) MedianStatistic, MagickFalse },
- { "Minimum", (ssize_t) MinimumStatistic, MagickFalse },
- { "Mode", (ssize_t) ModeStatistic, MagickFalse },
- { "Nonpeak", (ssize_t) NonpeakStatistic, MagickFalse },
- { "StandardDeviation", (ssize_t) StandardDeviationStatistic, MagickFalse },
- { "TopHat", (ssize_t) TopHatStatistic, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedMethod, MagickFalse }
+ { "Undefined", UndefinedStatistic, UndefinedOptionFlag, MagickTrue },
+ { "Gradient", GradientStatistic, UndefinedOptionFlag, MagickFalse },
+ { "Maximum", MaximumStatistic, UndefinedOptionFlag, MagickFalse },
+ { "Mean", MeanStatistic, UndefinedOptionFlag, MagickFalse },
+ { "Median", MedianStatistic, UndefinedOptionFlag, MagickFalse },
+ { "Minimum", MinimumStatistic, UndefinedOptionFlag, MagickFalse },
+ { "Mode", ModeStatistic, UndefinedOptionFlag, MagickFalse },
+ { "Nonpeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse },
+ { "StandardDeviation", StandardDeviationStatistic, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedMethod, UndefinedOptionFlag, MagickFalse }
},
StorageOptions[] =
{
- { "Undefined", (ssize_t) UndefinedPixel, MagickTrue },
- { "Char", (ssize_t) CharPixel, MagickFalse },
- { "Double", (ssize_t) DoublePixel, MagickFalse },
- { "Float", (ssize_t) FloatPixel, MagickFalse },
- { "Integer", (ssize_t) IntegerPixel, MagickFalse },
- { "Long", (ssize_t) LongPixel, MagickFalse },
- { "Quantum", (ssize_t) QuantumPixel, MagickFalse },
- { "Short", (ssize_t) ShortPixel, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedResource, MagickFalse }
+ { "Undefined", UndefinedPixel, UndefinedOptionFlag, MagickTrue },
+ { "Char", CharPixel, UndefinedOptionFlag, MagickFalse },
+ { "Double", DoublePixel, UndefinedOptionFlag, MagickFalse },
+ { "Float", FloatPixel, UndefinedOptionFlag, MagickFalse },
+ { "Integer", IntegerPixel, UndefinedOptionFlag, MagickFalse },
+ { "Long", LongPixel, UndefinedOptionFlag, MagickFalse },
+ { "Quantum", QuantumPixel, UndefinedOptionFlag, MagickFalse },
+ { "Short", ShortPixel, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedResource, UndefinedOptionFlag, MagickFalse }
},
StretchOptions[] =
{
- { "Undefined", (ssize_t) UndefinedStretch, MagickTrue },
- { "Any", (ssize_t) AnyStretch, MagickFalse },
- { "Condensed", (ssize_t) CondensedStretch, MagickFalse },
- { "Expanded", (ssize_t) ExpandedStretch, MagickFalse },
- { "ExtraCondensed", (ssize_t) ExtraCondensedStretch, MagickFalse },
- { "ExtraExpanded", (ssize_t) ExtraExpandedStretch, MagickFalse },
- { "Normal", (ssize_t) NormalStretch, MagickFalse },
- { "SemiCondensed", (ssize_t) SemiCondensedStretch, MagickFalse },
- { "SemiExpanded", (ssize_t) SemiExpandedStretch, MagickFalse },
- { "UltraCondensed", (ssize_t) UltraCondensedStretch, MagickFalse },
- { "UltraExpanded", (ssize_t) UltraExpandedStretch, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedStretch, MagickFalse }
+ { "Undefined", UndefinedStretch, UndefinedOptionFlag, MagickTrue },
+ { "Any", AnyStretch, UndefinedOptionFlag, MagickFalse },
+ { "Condensed", CondensedStretch, UndefinedOptionFlag, MagickFalse },
+ { "Expanded", ExpandedStretch, UndefinedOptionFlag, MagickFalse },
+ { "ExtraCondensed", ExtraCondensedStretch, UndefinedOptionFlag, MagickFalse },
+ { "ExtraExpanded", ExtraExpandedStretch, UndefinedOptionFlag, MagickFalse },
+ { "Normal", NormalStretch, UndefinedOptionFlag, MagickFalse },
+ { "SemiCondensed", SemiCondensedStretch, UndefinedOptionFlag, MagickFalse },
+ { "SemiExpanded", SemiExpandedStretch, UndefinedOptionFlag, MagickFalse },
+ { "UltraCondensed", UltraCondensedStretch, UndefinedOptionFlag, MagickFalse },
+ { "UltraExpanded", UltraExpandedStretch, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedStretch, UndefinedOptionFlag, MagickFalse }
},
StyleOptions[] =
{
- { "Undefined", (ssize_t) UndefinedStyle, MagickTrue },
- { "Any", (ssize_t) AnyStyle, MagickFalse },
- { "Italic", (ssize_t) ItalicStyle, MagickFalse },
- { "Normal", (ssize_t) NormalStyle, MagickFalse },
- { "Oblique", (ssize_t) ObliqueStyle, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedStyle, MagickFalse }
+ { "Undefined", UndefinedStyle, UndefinedOptionFlag, MagickTrue },
+ { "Any", AnyStyle, UndefinedOptionFlag, MagickFalse },
+ { "Italic", ItalicStyle, UndefinedOptionFlag, MagickFalse },
+ { "Normal", NormalStyle, UndefinedOptionFlag, MagickFalse },
+ { "Oblique", ObliqueStyle, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedStyle, UndefinedOptionFlag, MagickFalse }
},
TypeOptions[] =
{
- { "Undefined", (ssize_t) UndefinedType, MagickTrue },
- { "Bilevel", (ssize_t) BilevelType, MagickFalse },
- { "ColorSeparation", (ssize_t) ColorSeparationType, MagickFalse },
- { "ColorSeparationMatte", (ssize_t) ColorSeparationMatteType, MagickFalse },
- { "Grayscale", (ssize_t) GrayscaleType, MagickFalse },
- { "GrayscaleMatte", (ssize_t) GrayscaleMatteType, MagickFalse },
- { "Optimize", (ssize_t) OptimizeType, MagickFalse },
- { "Palette", (ssize_t) PaletteType, MagickFalse },
- { "PaletteBilevelMatte", (ssize_t) PaletteBilevelMatteType, MagickFalse },
- { "PaletteMatte", (ssize_t) PaletteMatteType, MagickFalse },
- { "TrueColorMatte", (ssize_t) TrueColorMatteType, MagickFalse },
- { "TrueColor", (ssize_t) TrueColorType, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedType, MagickFalse }
+ { "Undefined", UndefinedType, UndefinedOptionFlag, MagickTrue },
+ { "Bilevel", BilevelType, UndefinedOptionFlag, MagickFalse },
+ { "ColorSeparation", ColorSeparationType, UndefinedOptionFlag, MagickFalse },
+ { "ColorSeparationMatte", ColorSeparationMatteType, UndefinedOptionFlag, MagickFalse },
+ { "Grayscale", GrayscaleType, UndefinedOptionFlag, MagickFalse },
+ { "GrayscaleMatte", GrayscaleMatteType, UndefinedOptionFlag, MagickFalse },
+ { "Optimize", OptimizeType, UndefinedOptionFlag, MagickFalse },
+ { "Palette", PaletteType, UndefinedOptionFlag, MagickFalse },
+ { "PaletteBilevelMatte", PaletteBilevelMatteType, UndefinedOptionFlag, MagickFalse },
+ { "PaletteMatte", PaletteMatteType, UndefinedOptionFlag, MagickFalse },
+ { "TrueColorMatte", TrueColorMatteType, UndefinedOptionFlag, MagickFalse },
+ { "TrueColor", TrueColorType, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedType, UndefinedOptionFlag, MagickFalse }
},
ValidateOptions[] =
{
- { "Undefined", (ssize_t) UndefinedValidate, MagickTrue },
- { "All", (ssize_t) AllValidate, MagickFalse },
- { "Compare", (ssize_t) CompareValidate, MagickFalse },
- { "Composite", (ssize_t) CompositeValidate, MagickFalse },
- { "Convert", (ssize_t) ConvertValidate, MagickFalse },
- { "FormatsInMemory", (ssize_t) FormatsInMemoryValidate, MagickFalse },
- { "FormatsOnDisk", (ssize_t) FormatsOnDiskValidate, MagickFalse },
- { "Identify", (ssize_t) IdentifyValidate, MagickFalse },
- { "ImportExport", (ssize_t) ImportExportValidate, MagickFalse },
- { "Montage", (ssize_t) MontageValidate, MagickFalse },
- { "Stream", (ssize_t) StreamValidate, MagickFalse },
- { "None", (ssize_t) NoValidate, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedValidate, MagickFalse }
+ { "Undefined", UndefinedValidate, UndefinedOptionFlag, MagickTrue },
+ { "All", AllValidate, UndefinedOptionFlag, MagickFalse },
+ { "Compare", CompareValidate, UndefinedOptionFlag, MagickFalse },
+ { "Composite", CompositeValidate, UndefinedOptionFlag, MagickFalse },
+ { "Convert", ConvertValidate, UndefinedOptionFlag, MagickFalse },
+ { "FormatsInMemory", FormatsInMemoryValidate, UndefinedOptionFlag, MagickFalse },
+ { "FormatsOnDisk", FormatsOnDiskValidate, UndefinedOptionFlag, MagickFalse },
+ { "Identify", IdentifyValidate, UndefinedOptionFlag, MagickFalse },
+ { "ImportExport", ImportExportValidate, UndefinedOptionFlag, MagickFalse },
+ { "Montage", MontageValidate, UndefinedOptionFlag, MagickFalse },
+ { "Stream", StreamValidate, UndefinedOptionFlag, MagickFalse },
+ { "None", NoValidate, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedValidate, UndefinedOptionFlag, MagickFalse }
},
VirtualPixelOptions[] =
{
- { "Undefined", (ssize_t) UndefinedVirtualPixelMethod, MagickTrue },
- { "Background", (ssize_t) BackgroundVirtualPixelMethod, MagickFalse },
- { "Black", (ssize_t) BlackVirtualPixelMethod, MagickFalse },
- { "Constant", (ssize_t) BackgroundVirtualPixelMethod, MagickTrue }, /* deprecated */
- { "CheckerTile", (ssize_t) CheckerTileVirtualPixelMethod, MagickFalse },
- { "Dither", (ssize_t) DitherVirtualPixelMethod, MagickFalse },
- { "Edge", (ssize_t) EdgeVirtualPixelMethod, MagickFalse },
- { "Gray", (ssize_t) GrayVirtualPixelMethod, MagickFalse },
- { "HorizontalTile", (ssize_t) HorizontalTileVirtualPixelMethod, MagickFalse },
- { "HorizontalTileEdge", (ssize_t) HorizontalTileEdgeVirtualPixelMethod, MagickFalse },
- { "Mirror", (ssize_t) MirrorVirtualPixelMethod, MagickFalse },
- { "Random", (ssize_t) RandomVirtualPixelMethod, MagickFalse },
- { "Tile", (ssize_t) TileVirtualPixelMethod, MagickFalse },
- { "Transparent", (ssize_t) TransparentVirtualPixelMethod, MagickFalse },
- { "VerticalTile", (ssize_t) VerticalTileVirtualPixelMethod, MagickFalse },
- { "VerticalTileEdge", (ssize_t) VerticalTileEdgeVirtualPixelMethod, MagickFalse },
- { "White", (ssize_t) WhiteVirtualPixelMethod, MagickFalse },
- { (char *) NULL, (ssize_t) UndefinedVirtualPixelMethod, MagickFalse }
+ { "Undefined", UndefinedVirtualPixelMethod, UndefinedOptionFlag, MagickTrue },
+ { "Background", BackgroundVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Black", BlackVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Constant", BackgroundVirtualPixelMethod, DeprecateOptionFlag, MagickTrue },
+ { "CheckerTile", CheckerTileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Dither", DitherVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Edge", EdgeVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Gray", GrayVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "HorizontalTile", HorizontalTileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "HorizontalTileEdge", HorizontalTileEdgeVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Mirror", MirrorVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Random", RandomVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Tile", TileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "Transparent", TransparentVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "VerticalTile", VerticalTileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "VerticalTileEdge", VerticalTileEdgeVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "White", WhiteVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }
};
\f
/*
% %
% %
% %
-% G e t M a g i c k O p t i o n s %
+% G e t C o m m a n d O p t i o n F l a g s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetMagickOptions() returns a list of values.
+% GetCommandOptionFlags() parses a string and returns an enumerated option
+% flags(s). Return a value of -1 if no such option is found.
%
-% The format of the GetMagickOptions method is:
+% The format of the GetCommandOptionFlags method is:
%
-% const char **GetMagickOptions(const MagickOption value)
+% ssize_t GetCommandOptionFlags(const CommandOption option,
+% const MagickBooleanType list,const char *options)
%
% A description of each parameter follows:
%
-% o value: the value.
+% 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.
%
*/
-static const OptionInfo *GetOptionInfo(const MagickOption option)
+static const OptionInfo *GetOptionInfo(const CommandOption option)
{
switch (option)
{
case MagickFilterOptions: return(FilterOptions);
case MagickFunctionOptions: return(FunctionOptions);
case MagickGravityOptions: return(GravityOptions);
- case MagickImageListOptions: return(ImageListOptions);
+/* case MagickImageListOptions: return(ImageListOptions); */
case MagickIntentOptions: return(IntentOptions);
case MagickInterlaceOptions: return(InterlaceOptions);
case MagickInterpolateOptions: return(InterpolateOptions);
return((const OptionInfo *) NULL);
}
-MagickExport char **GetMagickOptions(const MagickOption value)
+MagickExport ssize_t GetCommandOptionFlags(const CommandOption option,
+ const MagickBooleanType list,const char *options)
+{
+ char
+ token[MaxTextExtent];
+
+ const OptionInfo
+ *option_info;
+
+ int
+ sentinel;
+
+ MagickBooleanType
+ negate;
+
+ register char
+ *q;
+
+ register const char
+ *p;
+
+ register ssize_t
+ i;
+
+ ssize_t
+ option_types;
+
+ option_info=GetOptionInfo(option);
+ if (option_info == (const OptionInfo *) NULL)
+ return(-1);
+ option_types=0;
+ sentinel=',';
+ if (strchr(options,'|') != (char *) NULL)
+ sentinel='|';
+ for (p=options; p != (char *) NULL; p=strchr(p,sentinel))
+ {
+ while (((isspace((int) ((unsigned char) *p)) != 0) || (*p == sentinel)) &&
+ (*p != '\0'))
+ p++;
+ negate=(*p == '!') ? MagickTrue : MagickFalse;
+ if (negate != MagickFalse)
+ p++;
+ q=token;
+ while (((isspace((int) ((unsigned char) *p)) == 0) && (*p != sentinel)) &&
+ (*p != '\0'))
+ {
+ if ((q-token) >= (MaxTextExtent-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) &&
+ ((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].flags;
+ else
+ option_types=option_types | option_info[i].flags;
+ break;
+ }
+ }
+ if (option_info[i].mnemonic == (char *) NULL)
+ return(-1);
+ if (list == MagickFalse)
+ break;
+ }
+ return(option_types);
+}
+\f
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% %
+% %
+% %
+% G e t C o m m a n d O p t i o n s %
+% %
+% %
+% %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+% GetCommandOptions() returns a list of values.
+%
+% The format of the GetCommandOptions method is:
+%
+% const char **GetCommandOptions(const CommandOption value)
+%
+% A description of each parameter follows:
+%
+% o value: the value.
+%
+*/
+MagickExport char **GetCommandOptions(const CommandOption value)
{
char
**values;
% %
% %
% %
-% I s M a g i c k O p t i o n %
+% I s C o m m a n d O p t i o n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% IsMagickOption() returns MagickTrue if the option begins with a - or + and
+% IsCommandOption() returns MagickTrue if the option begins with a - or + and
% the first character that follows is alphanumeric.
%
-% The format of the IsMagickOption method is:
+% The format of the IsCommandOption method is:
%
-% MagickBooleanType IsMagickOption(const char *option)
+% MagickBooleanType IsCommandOption(const char *option)
%
% A description of each parameter follows:
%
% o option: the option.
%
*/
-MagickExport MagickBooleanType IsMagickOption(const char *option)
+MagickExport MagickBooleanType IsCommandOption(const char *option)
{
assert(option != (const char *) NULL);
if ((*option != '-') && (*option != '+'))
% %
% %
% %
-% M a g i c k O p t i o n T o M n e m o n i c %
+% C o m m a n d O p t i o n T o M n e m o n i c %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% MagickOptionToMnemonic() returns an enumerated value as a mnemonic.
+% CommandOptionToMnemonic() returns an enumerated value as a mnemonic.
%
-% The format of the MagickOptionToMnemonic method is:
+% The format of the CommandOptionToMnemonic method is:
%
-% const char *MagickOptionToMnemonic(const MagickOption option,
+% const char *CommandOptionToMnemonic(const CommandOption option,
% const ssize_t type)
%
% A description of each parameter follows:
% o type: one or more values separated by commas.
%
*/
-MagickExport const char *MagickOptionToMnemonic(const MagickOption option,
+MagickExport const char *CommandOptionToMnemonic(const CommandOption option,
const ssize_t type)
{
const OptionInfo
% %
% %
% %
-% L i s t M a g i c k O p t i o n s %
+% L i s t C o m m a n d O p t i o n s %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% ListMagickOptions() lists the contents of enumerated option type(s).
+% ListCommandOptions() lists the contents of enumerated option type(s).
%
-% The format of the ListMagickOptions method is:
+% The format of the ListCommandOptions method is:
%
-% MagickBooleanType ListMagickOptions(FILE *file,const MagickOption option,
+% MagickBooleanType ListCommandOptions(FILE *file,const CommandOption option,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
% o exception: return any errors or warnings in this structure.
%
*/
-MagickExport MagickBooleanType ListMagickOptions(FILE *file,
- const MagickOption option,ExceptionInfo *magick_unused(exception))
+MagickExport MagickBooleanType ListCommandOptions(FILE *file,
+ const CommandOption option,ExceptionInfo *magick_unused(exception))
{
const OptionInfo
*option_info;
{
if (option_info[i].stealth != MagickFalse)
continue;
- (void) fprintf(file,"%s\n",option_info[i].mnemonic);
+ (void) FormatLocaleFile(file,"%s\n",option_info[i].mnemonic);
}
return(MagickTrue);
}
ssize_t
channel;
- channel=ParseMagickOption(MagickChannelOptions,MagickTrue,channels);
+ channel=ParseCommandOption(MagickChannelOptions,MagickTrue,channels);
if (channel >= 0)
return(channel);
channel=0;
/*
Gather the additional channel flags and merge with shorthand.
*/
- type=ParseMagickOption(MagickChannelOptions,MagickTrue,channels+i+1);
+ type=ParseCommandOption(MagickChannelOptions,MagickTrue,channels+i+1);
if (type < 0)
return(type);
channel|=type;
% %
% %
% %
-% P a r s e M a g i c k O p t i o n %
+% P a r s e C o m m a n d O p t i o n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% ParseMagickOption() parses a string and returns an enumerated option type(s).
+% ParseCommandOption() parses a string and returns an enumerated option
+% type(s). Return a value of -1 if no such option is found.
%
-% The format of the ParseMagickOption method is:
+% The format of the ParseCommandOption method is:
%
-% ssize_t ParseMagickOption(const MagickOption option,
+% ssize_t ParseCommandOption(const CommandOption option,
% const MagickBooleanType list,const char *options)
%
% A description of each parameter follows:
% o options: One or more options separated by commas.
%
*/
-MagickExport ssize_t ParseMagickOption(const MagickOption option,
+MagickExport ssize_t ParseCommandOption(const CommandOption option,
const MagickBooleanType list,const char *options)
{
char
while (((isspace((int) ((unsigned char) *p)) == 0) && (*p != sentinel)) &&
(*p != '\0'))
{
- if ((q-token) >= MaxTextExtent)
+ if ((q-token) >= (MaxTextExtent-1))
break;
*q++=(*p++);
}
projects / imagemagick / blobdiff