% March 2000 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "magick/property.h"
#include "magick/quantize.h"
#include "magick/quantum.h"
+#include "magick/resample.h"
#include "magick/resource_.h"
#include "magick/splay-tree.h"
#include "magick/statistic.h"
static const OptionInfo
AlignOptions[] =
{
- { "Undefined", (long) UndefinedAlign, MagickTrue },
- { "Center", (long) CenterAlign, MagickFalse },
- { "End", (long) RightAlign, MagickFalse },
- { "Left", (long) LeftAlign, MagickFalse },
- { "Middle", (long) CenterAlign, MagickFalse },
- { "Right", (long) RightAlign, MagickFalse },
- { "Start", (long) LeftAlign, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedAlphaChannel, MagickTrue },
- { "Activate", (long) ActivateAlphaChannel, MagickFalse },
- { "Background", (long) BackgroundAlphaChannel, MagickFalse },
- { "Copy", (long) CopyAlphaChannel, MagickFalse },
- { "Deactivate", (long) DeactivateAlphaChannel, MagickFalse },
- { "Extract", (long) ExtractAlphaChannel, MagickFalse },
- { "Off", (long) DeactivateAlphaChannel, MagickFalse },
- { "On", (long) ActivateAlphaChannel, MagickFalse },
- { "Opaque", (long) OpaqueAlphaChannel, MagickFalse },
- { "Set", (long) SetAlphaChannel, MagickFalse },
- { "Shape", (long) ShapeAlphaChannel, MagickFalse },
- { "Reset", (long) SetAlphaChannel, MagickTrue }, /* deprecated */
- { "Transparent", (long) TransparentAlphaChannel, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedChannel, MagickTrue },
- { "All", (long) AllChannels, MagickFalse },
- { "Alpha", (long) OpacityChannel, MagickFalse },
- { "Black", (long) BlackChannel, MagickFalse },
- { "Blue", (long) BlueChannel, MagickFalse },
- { "Cyan", (long) CyanChannel, MagickFalse },
- { "Default", (long) DefaultChannels, MagickFalse },
- { "Gray", (long) GrayChannel, MagickFalse },
- { "Green", (long) GreenChannel, MagickFalse },
- { "Hue", (long) RedChannel, MagickFalse },
- { "Index", (long) IndexChannel, MagickFalse },
- { "Lightness", (long) BlueChannel, MagickFalse },
- { "Luminance", (long) BlueChannel, MagickFalse },
- { "Luminosity", (long) BlueChannel, MagickFalse }, /* deprecated */
- { "Magenta", (long) MagentaChannel, MagickFalse },
- { "Matte", (long) OpacityChannel, MagickFalse },
- { "Opacity", (long) OpacityChannel, MagickFalse },
- { "Red", (long) RedChannel, MagickFalse },
- { "Saturation", (long) GreenChannel, MagickFalse },
- { "Yellow", (long) YellowChannel, MagickFalse },
- { "Sync", (long) SyncChannels, MagickFalse }, /* special channel flag */
- { (char *) NULL, (long) 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", (long) UndefinedClass, MagickTrue },
- { "DirectClass", (long) DirectClass, MagickFalse },
- { "PseudoClass", (long) PseudoClass, MagickFalse },
- { (char *) NULL, (long) UndefinedClass, MagickFalse }
+ { "Undefined", UndefinedClass, UndefinedOptionFlag, MagickTrue },
+ { "DirectClass", DirectClass, UndefinedOptionFlag, MagickFalse },
+ { "PseudoClass", PseudoClass, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedClass, UndefinedOptionFlag, MagickFalse }
},
ClipPathOptions[] =
{
- { "Undefined", (long) UndefinedPathUnits, MagickTrue },
- { "ObjectBoundingBox", (long) ObjectBoundingBox, MagickFalse },
- { "UserSpace", (long) UserSpace, MagickFalse },
- { "UserSpaceOnUse", (long) UserSpaceOnUse, MagickFalse },
- { (char *) NULL, (long) 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 }, /* under development */
- { "-auto-gamma", 0L, MagickTrue }, /* under development */
- { "+auto-level", 0L, MagickTrue }, /* under development */
- { "-auto-level", 0L, MagickTrue }, /* under development */
- { "+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 },
- { "+duration", 1L, MagickTrue },
- { "-duration", 1L, MagickTrue },
- { "+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 },
- { "+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 },
- { "+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 },
- { "+swap", 0L, MagickFalse },
- { "-swap", 1L, MagickFalse },
- { "+swirl", 0L, MagickFalse },
- { "-swirl", 1L, 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, (long) 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", (long) UndefinedCompositeOp, MagickTrue },
- { "Atop", (long) AtopCompositeOp, MagickFalse },
- { "Blend", (long) BlendCompositeOp, MagickFalse },
- { "Blur", (long) BlurCompositeOp, MagickFalse },
- { "Bumpmap", (long) BumpmapCompositeOp, MagickFalse },
- { "ChangeMask", (long) ChangeMaskCompositeOp, MagickFalse },
- { "Clear", (long) ClearCompositeOp, MagickFalse },
- { "ColorBurn", (long) ColorBurnCompositeOp, MagickFalse },
- { "ColorDodge", (long) ColorDodgeCompositeOp, MagickFalse },
- { "Colorize", (long) ColorizeCompositeOp, MagickFalse },
- { "CopyBlack", (long) CopyBlackCompositeOp, MagickFalse },
- { "CopyBlue", (long) CopyBlueCompositeOp, MagickFalse },
- { "CopyCyan", (long) CopyCyanCompositeOp, MagickFalse },
- { "CopyGreen", (long) CopyGreenCompositeOp, MagickFalse },
- { "Copy", (long) CopyCompositeOp, MagickFalse },
- { "CopyMagenta", (long) CopyMagentaCompositeOp, MagickFalse },
- { "CopyOpacity", (long) CopyOpacityCompositeOp, MagickFalse },
- { "CopyRed", (long) CopyRedCompositeOp, MagickFalse },
- { "CopyYellow", (long) CopyYellowCompositeOp, MagickFalse },
- { "Darken", (long) DarkenCompositeOp, MagickFalse },
- { "Divide", (long) DivideCompositeOp, MagickFalse },
- { "Dst", (long) DstCompositeOp, MagickFalse },
- { "Difference", (long) DifferenceCompositeOp, MagickFalse },
- { "Displace", (long) DisplaceCompositeOp, MagickFalse },
- { "Dissolve", (long) DissolveCompositeOp, MagickFalse },
- { "Distort", (long) DistortCompositeOp, MagickFalse },
- { "DstAtop", (long) DstAtopCompositeOp, MagickFalse },
- { "DstIn", (long) DstInCompositeOp, MagickFalse },
- { "DstOut", (long) DstOutCompositeOp, MagickFalse },
- { "DstOver", (long) DstOverCompositeOp, MagickFalse },
- { "Dst", (long) DstCompositeOp, MagickFalse },
- { "Exclusion", (long) ExclusionCompositeOp, MagickFalse },
- { "HardLight", (long) HardLightCompositeOp, MagickFalse },
- { "Hue", (long) HueCompositeOp, MagickFalse },
- { "In", (long) InCompositeOp, MagickFalse },
- { "Lighten", (long) LightenCompositeOp, MagickFalse },
- { "LinearBurn", (long) LinearBurnCompositeOp, MagickFalse },
- { "LinearDodge", (long) LinearDodgeCompositeOp, MagickFalse },
- { "LinearLight", (long) LinearLightCompositeOp, MagickFalse },
- { "Luminize", (long) LuminizeCompositeOp, MagickFalse },
- { "Mathematics", (long) MathematicsCompositeOp, MagickFalse },
- { "Minus", (long) MinusCompositeOp, MagickFalse },
- { "Modulate", (long) ModulateCompositeOp, MagickFalse },
- { "ModulusAdd", (long) ModulusAddCompositeOp, MagickFalse },
- { "ModulusSubtract", (long) ModulusSubtractCompositeOp, MagickFalse },
- { "Multiply", (long) MultiplyCompositeOp, MagickFalse },
- { "None", (long) NoCompositeOp, MagickFalse },
- { "Out", (long) OutCompositeOp, MagickFalse },
- { "Overlay", (long) OverlayCompositeOp, MagickFalse },
- { "Over", (long) OverCompositeOp, MagickFalse },
- { "PegtopLight", (long) PegtopLightCompositeOp, MagickFalse },
- { "PinLight", (long) PinLightCompositeOp, MagickFalse },
- { "Plus", (long) PlusCompositeOp, MagickFalse },
- { "Replace", (long) ReplaceCompositeOp, MagickFalse },
- { "Saturate", (long) SaturateCompositeOp, MagickFalse },
- { "Screen", (long) ScreenCompositeOp, MagickFalse },
- { "SoftLight", (long) SoftLightCompositeOp, MagickFalse },
- { "Src", (long) SrcCompositeOp, MagickFalse },
- { "SrcAtop", (long) SrcAtopCompositeOp, MagickFalse },
- { "SrcIn", (long) SrcInCompositeOp, MagickFalse },
- { "SrcOut", (long) SrcOutCompositeOp, MagickFalse },
- { "SrcOver", (long) SrcOverCompositeOp, MagickFalse },
- { "Src", (long) SrcCompositeOp, MagickFalse },
- { "VividLight", (long) VividLightCompositeOp, MagickFalse },
- { "Xor", (long) XorCompositeOp, MagickFalse },
- { "Add", (long) AddCompositeOp, MagickTrue }, /* depreciate */
- { "Subtract", (long) SubtractCompositeOp, MagickTrue }, /* depreciate */
- { "Threshold", (long) ThresholdCompositeOp, MagickTrue }, /* depreciate */
- { (char *) NULL, (long) 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", (long) UndefinedCompression, MagickTrue },
- { "B44", (long) B44Compression, MagickFalse },
- { "B44A", (long) B44ACompression, MagickFalse },
- { "BZip", (long) BZipCompression, MagickFalse },
- { "DXT1", (long) DXT1Compression, MagickFalse },
- { "DXT3", (long) DXT3Compression, MagickFalse },
- { "DXT5", (long) DXT5Compression, MagickFalse },
- { "Fax", (long) FaxCompression, MagickFalse },
- { "Group4", (long) Group4Compression, MagickFalse },
- { "JPEG", (long) JPEGCompression, MagickFalse },
- { "JPEG2000", (long) JPEG2000Compression, MagickFalse },
- { "Lossless", (long) LosslessJPEGCompression, MagickFalse },
- { "LosslessJPEG", (long) LosslessJPEGCompression, MagickFalse },
- { "LZW", (long) LZWCompression, MagickFalse },
- { "None", (long) NoCompression, MagickFalse },
- { "Piz", (long) PizCompression, MagickFalse },
- { "Pxr24", (long) Pxr24Compression, MagickFalse },
- { "RLE", (long) RLECompression, MagickFalse },
- { "Zip", (long) ZipCompression, MagickFalse },
- { "RunlengthEncoded", (long) RLECompression, MagickFalse },
- { "ZipS", (long) ZipSCompression, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedColorspace, MagickTrue },
- { "CMY", (long) CMYColorspace, MagickFalse },
- { "CMYK", (long) CMYKColorspace, MagickFalse },
- { "Gray", (long) GRAYColorspace, MagickFalse },
- { "HSB", (long) HSBColorspace, MagickFalse },
- { "HSL", (long) HSLColorspace, MagickFalse },
- { "HWB", (long) HWBColorspace, MagickFalse },
- { "Lab", (long) LabColorspace, MagickFalse },
- { "Log", (long) LogColorspace, MagickFalse },
- { "OHTA", (long) OHTAColorspace, MagickFalse },
- { "Rec601Luma", (long) Rec601LumaColorspace, MagickFalse },
- { "Rec601YCbCr", (long) Rec601YCbCrColorspace, MagickFalse },
- { "Rec709Luma", (long) Rec709LumaColorspace, MagickFalse },
- { "Rec709YCbCr", (long) Rec709YCbCrColorspace, MagickFalse },
- { "RGB", (long) RGBColorspace, MagickFalse },
- { "sRGB", (long) sRGBColorspace, MagickFalse },
- { "Transparent", (long) TransparentColorspace, MagickFalse },
- { "XYZ", (long) XYZColorspace, MagickFalse },
- { "YCbCr", (long) YCbCrColorspace, MagickFalse },
- { "YCC", (long) YCCColorspace, MagickFalse },
- { "YIQ", (long) YIQColorspace, MagickFalse },
- { "YPbPr", (long) YPbPrColorspace, MagickFalse },
- { "YUV", (long) YUVColorspace, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedData, MagickTrue },
- { "Byte", (long) ByteData, MagickFalse },
- { "Long", (long) LongData, MagickFalse },
- { "Short", (long) ShortData, MagickFalse },
- { "String", (long) StringData, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedDecoration, MagickTrue },
- { "LineThrough", (long) LineThroughDecoration, MagickFalse },
- { "None", (long) NoDecoration, MagickFalse },
- { "Overline", (long) OverlineDecoration, MagickFalse },
- { "Underline", (long) UnderlineDecoration, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedDirection, MagickTrue },
- { "right-to-left", (long) RightToLeftDirection, MagickFalse },
- { "left-to-right", (long) LeftToRightDirection, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedDispose, MagickTrue },
- { "Background", (long) BackgroundDispose, MagickFalse },
- { "None", (long) NoneDispose, MagickFalse },
- { "Previous", (long) PreviousDispose, MagickFalse },
- { "Undefined", (long) UndefinedDispose, MagickFalse },
- { "0", (long) UndefinedDispose, MagickFalse },
- { "1", (long) NoneDispose, MagickFalse },
- { "2", (long) BackgroundDispose, MagickFalse },
- { "3", (long) PreviousDispose, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedDistortion, MagickTrue },
- { "Affine", (long) AffineDistortion, MagickFalse },
- { "AffineProjection", (long) AffineProjectionDistortion, MagickFalse },
- { "ScaleRotateTranslate", (long) ScaleRotateTranslateDistortion, MagickFalse },
- { "SRT", (long) ScaleRotateTranslateDistortion, MagickFalse },
- { "Perspective", (long) PerspectiveDistortion, MagickFalse },
- { "PerspectiveProjection", (long) PerspectiveProjectionDistortion, MagickFalse },
- { "Bilinear", (long) BilinearForwardDistortion, MagickTrue },
- { "BilinearForward", (long) BilinearForwardDistortion, MagickFalse },
- { "BilinearReverse", (long) BilinearReverseDistortion, MagickFalse },
- { "Polynomial", (long) PolynomialDistortion, MagickFalse },
- { "Arc", (long) ArcDistortion, MagickFalse },
- { "Polar", (long) PolarDistortion, MagickFalse },
- { "DePolar", (long) DePolarDistortion, MagickFalse },
- { "Barrel", (long) BarrelDistortion, MagickFalse },
- { "BarrelInverse", (long) BarrelInverseDistortion, MagickFalse },
- { "Shepards", (long) ShepardsDistortion, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedDitherMethod, MagickTrue },
- { "None", (long) NoDitherMethod, MagickFalse },
- { "FloydSteinberg", (long) FloydSteinbergDitherMethod, MagickFalse },
- { "Riemersma", (long) RiemersmaDitherMethod, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedEndian, MagickTrue },
- { "LSB", (long) LSBEndian, MagickFalse },
- { "MSB", (long) MSBEndian, MagickFalse },
- { (char *) NULL, (long) UndefinedEndian, MagickFalse }
+ { "Undefined", UndefinedEndian, UndefinedOptionFlag, MagickTrue },
+ { "LSB", LSBEndian, UndefinedOptionFlag, MagickFalse },
+ { "MSB", MSBEndian, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedEndian, UndefinedOptionFlag, MagickFalse }
},
EvaluateOptions[] =
{
- { "Undefined", (long) UndefinedEvaluateOperator, MagickTrue },
- { "Add", (long) AddEvaluateOperator, MagickFalse },
- { "AddModulus", (long) AddModulusEvaluateOperator, MagickFalse },
- { "And", (long) AndEvaluateOperator, MagickFalse },
- { "Cos", (long) CosineEvaluateOperator, MagickFalse },
- { "Cosine", (long) CosineEvaluateOperator, MagickFalse },
- { "Divide", (long) DivideEvaluateOperator, MagickFalse },
- { "GaussianNoise", (long) GaussianNoiseEvaluateOperator, MagickFalse },
- { "ImpulseNoise", (long) ImpulseNoiseEvaluateOperator, MagickFalse },
- { "LaplacianNoise", (long) LaplacianNoiseEvaluateOperator, MagickFalse },
- { "LeftShift", (long) LeftShiftEvaluateOperator, MagickFalse },
- { "Log", (long) LogEvaluateOperator, MagickFalse },
- { "Max", (long) MaxEvaluateOperator, MagickFalse },
- { "Mean", (long) MeanEvaluateOperator, MagickFalse },
- { "Min", (long) MinEvaluateOperator, MagickFalse },
- { "MultiplicativeNoise", (long) MultiplicativeNoiseEvaluateOperator, MagickFalse },
- { "Multiply", (long) MultiplyEvaluateOperator, MagickFalse },
- { "Or", (long) OrEvaluateOperator, MagickFalse },
- { "PoissonNoise", (long) PoissonNoiseEvaluateOperator, MagickFalse },
- { "Pow", (long) PowEvaluateOperator, MagickFalse },
- { "RightShift", (long) RightShiftEvaluateOperator, MagickFalse },
- { "Set", (long) SetEvaluateOperator, MagickFalse },
- { "Sin", (long) SineEvaluateOperator, MagickFalse },
- { "Sine", (long) SineEvaluateOperator, MagickFalse },
- { "Subtract", (long) SubtractEvaluateOperator, MagickFalse },
- { "Threshold", (long) ThresholdEvaluateOperator, MagickFalse },
- { "ThresholdBlack", (long) ThresholdBlackEvaluateOperator, MagickFalse },
- { "ThresholdWhite", (long) ThresholdWhiteEvaluateOperator, MagickFalse },
- { "UniformNoise", (long) UniformNoiseEvaluateOperator, MagickFalse },
- { "Xor", (long) XorEvaluateOperator, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedRule, MagickTrue },
- { "Evenodd", (long) EvenOddRule, MagickFalse },
- { "NonZero", (long) NonZeroRule, MagickFalse },
- { (char *) NULL, (long) UndefinedRule, MagickFalse }
+ { "Undefined", UndefinedRule, UndefinedOptionFlag, MagickTrue },
+ { "Evenodd", EvenOddRule, UndefinedOptionFlag, MagickFalse },
+ { "NonZero", NonZeroRule, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedRule, UndefinedOptionFlag, MagickFalse }
},
FilterOptions[] =
{
- { "Undefined", (long) UndefinedFilter, MagickTrue },
- { "Bartlett", (long) BartlettFilter, MagickFalse },
- { "Bessel", (long) BesselFilter, MagickFalse },
- { "Blackman", (long) BlackmanFilter, MagickFalse },
- { "Bohman", (long) BohmanFilter, MagickFalse },
- { "Box", (long) BoxFilter, MagickFalse },
- { "Catrom", (long) CatromFilter, MagickFalse },
- { "Cubic", (long) CubicFilter, MagickFalse },
- { "Gaussian", (long) GaussianFilter, MagickFalse },
- { "Hamming", (long) HammingFilter, MagickFalse },
- { "Hanning", (long) HanningFilter, MagickFalse },
- { "Hermite", (long) HermiteFilter, MagickFalse },
- { "Kaiser", (long) KaiserFilter, MagickFalse },
- { "Lagrange", (long) LagrangeFilter, MagickFalse },
- { "Lanczos", (long) LanczosFilter, MagickFalse },
- { "Mitchell", (long) MitchellFilter, MagickFalse },
- { "Parzen", (long) ParzenFilter, MagickFalse },
- { "Point", (long) PointFilter, MagickFalse },
- { "Quadratic", (long) QuadraticFilter, MagickFalse },
- { "Sinc", (long) SincFilter, MagickFalse },
- { "Triangle", (long) TriangleFilter, MagickFalse },
- { "Welsh", (long) WelshFilter, MagickFalse },
- { (char *) NULL, (long) UndefinedFilter, 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", JincFilter, UndefinedOptionFlag, MagickTrue },
+ { (char *) NULL, UndefinedFilter, UndefinedOptionFlag, MagickFalse }
},
FunctionOptions[] =
{
- { "Undefined", (long) UndefinedFunction, MagickTrue },
- { "Polynomial", (long) PolynomialFunction, MagickFalse },
- { "Sinusoid", (long) SinusoidFunction, MagickFalse },
- { "ArcSin", (long) ArcsinFunction, MagickFalse },
- { "ArcTan", (long) ArctanFunction, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedGravity, MagickTrue },
- { "None", (long) UndefinedGravity, MagickFalse },
- { "Center", (long) CenterGravity, MagickFalse },
- { "East", (long) EastGravity, MagickFalse },
- { "Forget", (long) ForgetGravity, MagickFalse },
- { "NorthEast", (long) NorthEastGravity, MagickFalse },
- { "North", (long) NorthGravity, MagickFalse },
- { "NorthWest", (long) NorthWestGravity, MagickFalse },
- { "SouthEast", (long) SouthEastGravity, MagickFalse },
- { "South", (long) SouthGravity, MagickFalse },
- { "SouthWest", (long) SouthWestGravity, MagickFalse },
- { "West", (long) WestGravity, MagickFalse },
- { "Static", (long) 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 },
- { "evaluate-seqence", 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 },
- { "process", MagickTrue, MagickFalse },
- { "quiet", MagickTrue, MagickFalse },
- { "separate", 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", (long) UndefinedIntent, MagickTrue },
- { "Absolute", (long) AbsoluteIntent, MagickFalse },
- { "Perceptual", (long) PerceptualIntent, MagickFalse },
- { "Relative", (long) RelativeIntent, MagickFalse },
- { "Saturation", (long) SaturationIntent, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedInterlace, MagickTrue },
- { "Line", (long) LineInterlace, MagickFalse },
- { "None", (long) NoInterlace, MagickFalse },
- { "Plane", (long) PlaneInterlace, MagickFalse },
- { "Partition", (long) PartitionInterlace, MagickFalse },
- { "GIF", (long) GIFInterlace, MagickFalse },
- { "JPEG", (long) JPEGInterlace, MagickFalse },
- { "PNG", (long) PNGInterlace, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedInterpolatePixel, MagickTrue },
- { "Average", (long) AverageInterpolatePixel, MagickFalse },
- { "Bicubic", (long) BicubicInterpolatePixel, MagickFalse },
- { "Bilinear", (long) BilinearInterpolatePixel, MagickFalse },
- { "filter", (long) FilterInterpolatePixel, MagickFalse },
- { "Integer", (long) IntegerInterpolatePixel, MagickFalse },
- { "Mesh", (long) MeshInterpolatePixel, MagickFalse },
- { "NearestNeighbor", (long) NearestNeighborInterpolatePixel, MagickFalse },
- { "Spline", (long) SplineInterpolatePixel, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedKernel, MagickTrue },
- { "Gaussian", (long) GaussianKernel, MagickFalse },
- { "Blur", (long) BlurKernel, MagickFalse },
- { "Comet", (long) CometKernel, MagickFalse },
- { "Laplacian", (long) LaplacianKernel, MagickTrue }, /* not implemented */
- { "DOG", (long) DOGKernel, MagickTrue }, /* not implemented */
- { "LOG", (long) LOGKernel, MagickTrue }, /* not implemented */
- { "Rectangle", (long) RectangleKernel, MagickFalse },
- { "Square", (long) SquareKernel, MagickFalse },
- { "Diamond", (long) DiamondKernel, MagickFalse },
- { "Disk", (long) DiskKernel, MagickFalse },
- { "Plus", (long) PlusKernel, MagickFalse },
- { "Chebyshev", (long) ChebyshevKernel, MagickFalse },
- { "Manhatten", (long) ManhattenKernel, MagickFalse },
- { "Euclidean", (long) EuclideanKernel, MagickFalse },
- { "User Defined", (long) UserDefinedKernel, MagickTrue }, /* internel */
- { (char *) NULL, (long) 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", (long) UndefinedLayer, MagickTrue },
- { "Coalesce", (long) CoalesceLayer, MagickFalse },
- { "CompareAny", (long) CompareAnyLayer, MagickFalse },
- { "CompareClear", (long) CompareClearLayer, MagickFalse },
- { "CompareOverlay", (long) CompareOverlayLayer, MagickFalse },
- { "Dispose", (long) DisposeLayer, MagickFalse },
- { "Optimize", (long) OptimizeLayer, MagickFalse },
- { "OptimizeFrame", (long) OptimizeImageLayer, MagickFalse },
- { "OptimizePlus", (long) OptimizePlusLayer, MagickFalse },
- { "OptimizeTransparency", (long) OptimizeTransLayer, MagickFalse },
- { "RemoveDups", (long) RemoveDupsLayer, MagickFalse },
- { "RemoveZero", (long) RemoveZeroLayer, MagickFalse },
- { "Composite", (long) CompositeLayer, MagickFalse },
- { "Merge", (long) MergeLayer, MagickFalse },
- { "Flatten", (long) FlattenLayer, MagickFalse },
- { "Mosaic", (long) MosaicLayer, MagickFalse },
- { "TrimBounds", (long) TrimBoundsLayer, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedCap, MagickTrue },
- { "Butt", (long) ButtCap, MagickFalse },
- { "Round", (long) RoundCap, MagickFalse },
- { "Square", (long) SquareCap, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedJoin, MagickTrue },
- { "Bevel", (long) BevelJoin, MagickFalse },
- { "Miter", (long) MiterJoin, MagickFalse },
- { "Round", (long) RoundJoin, MagickFalse },
- { (char *) NULL, (long) 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", (long) MagickAlignOptions, MagickFalse },
- { "Alpha", (long) MagickAlphaOptions, MagickFalse },
- { "Boolean", (long) MagickBooleanOptions, MagickFalse },
- { "Channel", (long) MagickChannelOptions, MagickFalse },
- { "Class", (long) MagickClassOptions, MagickFalse },
- { "ClipPath", (long) MagickClipPathOptions, MagickFalse },
- { "Coder", (long) MagickCoderOptions, MagickFalse },
- { "Color", (long) MagickColorOptions, MagickFalse },
- { "Colorspace", (long) MagickColorspaceOptions, MagickFalse },
- { "Command", (long) MagickCommandOptions, MagickFalse },
- { "Compose", (long) MagickComposeOptions, MagickFalse },
- { "Compress", (long) MagickCompressOptions, MagickFalse },
- { "Configure", (long) MagickConfigureOptions, MagickFalse },
- { "DataType", (long) MagickDataTypeOptions, MagickFalse },
- { "Debug", (long) MagickDebugOptions, MagickFalse },
- { "Decoration", (long) MagickDecorateOptions, MagickFalse },
- { "Delegate", (long) MagickDelegateOptions, MagickFalse },
- { "Direction", (long) MagickDirectionOptions, MagickFalse },
- { "Dispose", (long) MagickDisposeOptions, MagickFalse },
- { "Distort", (long) MagickDistortOptions, MagickFalse },
- { "Dither", (long) MagickDitherOptions, MagickFalse },
- { "Endian", (long) MagickEndianOptions, MagickFalse },
- { "Evaluate", (long) MagickEvaluateOptions, MagickFalse },
- { "FillRule", (long) MagickFillRuleOptions, MagickFalse },
- { "Filter", (long) MagickFilterOptions, MagickFalse },
- { "Font", (long) MagickFontOptions, MagickFalse },
- { "Format", (long) MagickFormatOptions, MagickFalse },
- { "Function", (long) MagickFunctionOptions, MagickFalse },
- { "Gravity", (long) MagickGravityOptions, MagickFalse },
- { "ImageList", (long) MagickImageListOptions, MagickFalse },
- { "Intent", (long) MagickIntentOptions, MagickFalse },
- { "Interlace", (long) MagickInterlaceOptions, MagickFalse },
- { "Interpolate", (long) MagickInterpolateOptions, MagickFalse },
- { "Kernel", (long) MagickKernelOptions, MagickFalse },
- { "Layers", (long) MagickLayerOptions, MagickFalse },
- { "LineCap", (long) MagickLineCapOptions, MagickFalse },
- { "LineJoin", (long) MagickLineJoinOptions, MagickFalse },
- { "List", (long) MagickListOptions, MagickFalse },
- { "Locale", (long) MagickLocaleOptions, MagickFalse },
- { "LogEvent", (long) MagickLogEventOptions, MagickFalse },
- { "Log", (long) MagickLogOptions, MagickFalse },
- { "Magic", (long) MagickMagicOptions, MagickFalse },
- { "Method", (long) MagickMethodOptions, MagickFalse },
- { "Metric", (long) MagickMetricOptions, MagickFalse },
- { "Mime", (long) MagickMimeOptions, MagickFalse },
- { "Mode", (long) MagickModeOptions, MagickFalse },
- { "Morphology", (long) MagickMorphologyOptions, MagickFalse },
- { "Module", (long) MagickModuleOptions, MagickFalse },
- { "Noise", (long) MagickNoiseOptions, MagickFalse },
- { "Orientation", (long) MagickOrientationOptions, MagickFalse },
- { "Policy", (long) MagickPolicyOptions, MagickFalse },
- { "PolicyDomain", (long) MagickPolicyDomainOptions, MagickFalse },
- { "PolicyRights", (long) MagickPolicyRightsOptions, MagickFalse },
- { "Preview", (long) MagickPreviewOptions, MagickFalse },
- { "Primitive", (long) MagickPrimitiveOptions, MagickFalse },
- { "QuantumFormat", (long) MagickQuantumFormatOptions, MagickFalse },
- { "Resource", (long) MagickResourceOptions, MagickFalse },
- { "SparseColor", (long) MagickSparseColorOptions, MagickFalse },
- { "Storage", (long) MagickStorageOptions, MagickFalse },
- { "Stretch", (long) MagickStretchOptions, MagickFalse },
- { "Style", (long) MagickStyleOptions, MagickFalse },
- { "Threshold", (long) MagickThresholdOptions, MagickFalse },
- { "Type", (long) MagickTypeOptions, MagickFalse },
- { "Units", (long) MagickResolutionOptions, MagickFalse },
- { "Undefined", (long) MagickUndefinedOptions, MagickTrue },
- { "Validate", (long) MagickValidateOptions, MagickFalse },
- { "VirtualPixel", (long) MagickVirtualPixelOptions, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedEvents, MagickTrue },
- { "All", (long) (AllEvents &~ TraceEvent), MagickFalse },
- { "Annotate", (long) AnnotateEvent, MagickFalse },
- { "Blob", (long) BlobEvent, MagickFalse },
- { "Cache", (long) CacheEvent, MagickFalse },
- { "Coder", (long) CoderEvent, MagickFalse },
- { "Configure", (long) ConfigureEvent, MagickFalse },
- { "Deprecate", (long) DeprecateEvent, MagickFalse },
- { "Draw", (long) DrawEvent, MagickFalse },
- { "Exception", (long) ExceptionEvent, MagickFalse },
- { "Locale", (long) LocaleEvent, MagickFalse },
- { "Module", (long) ModuleEvent, MagickFalse },
- { "None", (long) NoEvents, MagickFalse },
- { "Policy", (long) PolicyEvent, MagickFalse },
- { "Resource", (long) ResourceEvent, MagickFalse },
- { "Trace", (long) TraceEvent, MagickFalse },
- { "Transform", (long) TransformEvent, MagickFalse },
- { "User", (long) UserEvent, MagickFalse },
- { "Wand", (long) WandEvent, MagickFalse },
- { "X11", (long) X11Event, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedMetric, MagickTrue },
- { "AE", (long) AbsoluteErrorMetric, MagickFalse },
- { "MAE", (long) MeanAbsoluteErrorMetric, MagickFalse },
- { "MEPP", (long) MeanErrorPerPixelMetric, MagickFalse },
- { "MSE", (long) MeanSquaredErrorMetric, MagickFalse },
- { "PAE", (long) PeakAbsoluteErrorMetric, MagickFalse },
- { "PSNR", (long) PeakSignalToNoiseRatioMetric, MagickFalse },
- { "RMSE", (long) RootMeanSquaredErrorMetric, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedMethod, MagickTrue },
- { "FillToBorder", (long) FillToBorderMethod, MagickFalse },
- { "Floodfill", (long) FloodfillMethod, MagickFalse },
- { "Point", (long) PointMethod, MagickFalse },
- { "Replace", (long) ReplaceMethod, MagickFalse },
- { "Reset", (long) ResetMethod, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedMode, MagickTrue },
- { "Concatenate", (long) ConcatenateMode, MagickFalse },
- { "Frame", (long) FrameMode, MagickFalse },
- { "Unframe", (long) UnframeMode, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedMorphology, MagickTrue },
- { "Correlate", (long) CorrelateMorphology, MagickFalse },
- { "Convolve", (long) ConvolveMorphology, MagickFalse },
- { "Dilate", (long) DilateMorphology, MagickFalse },
- { "Erode", (long) ErodeMorphology, MagickFalse },
- { "Close", (long) CloseMorphology, MagickFalse },
- { "Open", (long) OpenMorphology, MagickFalse },
- { "DilateIntensity", (long) DilateIntensityMorphology, MagickFalse },
- { "ErodeIntensity", (long) ErodeIntensityMorphology, MagickFalse },
- { "CloseIntensity", (long) CloseIntensityMorphology, MagickFalse },
- { "OpenIntensity", (long) OpenIntensityMorphology, MagickFalse },
- { "DilateI", (long) DilateIntensityMorphology, MagickFalse },
- { "ErodeI", (long) ErodeIntensityMorphology, MagickFalse },
- { "CloseI", (long) CloseIntensityMorphology, MagickFalse },
- { "OpenI", (long) OpenIntensityMorphology, MagickFalse },
- { "EdgeOut", (long) EdgeOutMorphology, MagickFalse },
- { "EdgeIn", (long) EdgeInMorphology, MagickFalse },
- { "Edge", (long) EdgeMorphology, MagickFalse },
- { "TopHat", (long) TopHatMorphology, MagickFalse },
- { "BottomHat", (long) BottomHatMorphology, MagickFalse },
- { "Distance", (long) DistanceMorphology, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedNoise, MagickTrue },
- { "Gaussian", (long) (long) GaussianNoise, MagickFalse },
- { "Impulse", (long) ImpulseNoise, MagickFalse },
- { "Laplacian", (long) LaplacianNoise, MagickFalse },
- { "Multiplicative", (long) MultiplicativeGaussianNoise, MagickFalse },
- { "Poisson", (long) PoissonNoise, MagickFalse },
- { "Random", (long) RandomNoise, MagickFalse },
- { "Uniform", (long) UniformNoise, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedOrientation, MagickTrue },
- { "TopLeft", (long) TopLeftOrientation, MagickFalse },
- { "TopRight", (long) TopRightOrientation, MagickFalse },
- { "BottomRight", (long) BottomRightOrientation, MagickFalse },
- { "BottomLeft", (long) BottomLeftOrientation, MagickFalse },
- { "LeftTop", (long) LeftTopOrientation, MagickFalse },
- { "RightTop", (long) RightTopOrientation, MagickFalse },
- { "RightBottom", (long) RightBottomOrientation, MagickFalse },
- { "LeftBottom", (long) LeftBottomOrientation, 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", (long) UndefinedPolicyDomain, MagickTrue },
- { "Coder", (long) CoderPolicyDomain, MagickFalse },
- { "Delegate", (long) DelegatePolicyDomain, MagickFalse },
- { "Filter", (long) FilterPolicyDomain, MagickFalse },
- { "Path", (long) PathPolicyDomain, MagickFalse },
- { "Resource", (long) ResourcePolicyDomain, MagickFalse },
- { "System", (long) SystemPolicyDomain, 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", (long) UndefinedPolicyRights, MagickTrue },
- { "None", (long) NoPolicyRights, MagickFalse },
- { "Read", (long) ReadPolicyRights, MagickFalse },
- { "Write", (long) WritePolicyRights, MagickFalse },
- { "Execute", (long) ExecutePolicyRights, 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", (long) UndefinedPreview, MagickTrue },
- { "AddNoise", (long) AddNoisePreview, MagickFalse },
- { "Blur", (long) BlurPreview, MagickFalse },
- { "Brightness", (long) BrightnessPreview, MagickFalse },
- { "Charcoal", (long) CharcoalDrawingPreview, MagickFalse },
- { "Despeckle", (long) DespecklePreview, MagickFalse },
- { "Dull", (long) DullPreview, MagickFalse },
- { "EdgeDetect", (long) EdgeDetectPreview, MagickFalse },
- { "Gamma", (long) GammaPreview, MagickFalse },
- { "Grayscale", (long) GrayscalePreview, MagickFalse },
- { "Hue", (long) HuePreview, MagickFalse },
- { "Implode", (long) ImplodePreview, MagickFalse },
- { "JPEG", (long) JPEGPreview, MagickFalse },
- { "OilPaint", (long) OilPaintPreview, MagickFalse },
- { "Quantize", (long) QuantizePreview, MagickFalse },
- { "Raise", (long) RaisePreview, MagickFalse },
- { "ReduceNoise", (long) ReduceNoisePreview, MagickFalse },
- { "Roll", (long) RollPreview, MagickFalse },
- { "Rotate", (long) RotatePreview, MagickFalse },
- { "Saturation", (long) SaturationPreview, MagickFalse },
- { "Segment", (long) SegmentPreview, MagickFalse },
- { "Shade", (long) ShadePreview, MagickFalse },
- { "Sharpen", (long) SharpenPreview, MagickFalse },
- { "Shear", (long) ShearPreview, MagickFalse },
- { "Solarize", (long) SolarizePreview, MagickFalse },
- { "Spiff", (long) SpiffPreview, MagickFalse },
- { "Spread", (long) SpreadPreview, MagickFalse },
- { "Swirl", (long) SwirlPreview, MagickFalse },
- { "Threshold", (long) ThresholdPreview, MagickFalse },
- { "Wave", (long) WavePreview, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedPrimitive, MagickTrue },
- { "Arc", (long) ArcPrimitive, MagickFalse },
- { "Bezier", (long) BezierPrimitive, MagickFalse },
- { "Circle", (long) CirclePrimitive, MagickFalse },
- { "Color", (long) ColorPrimitive, MagickFalse },
- { "Ellipse", (long) EllipsePrimitive, MagickFalse },
- { "Image", (long) ImagePrimitive, MagickFalse },
- { "Line", (long) LinePrimitive, MagickFalse },
- { "Matte", (long) MattePrimitive, MagickFalse },
- { "Path", (long) PathPrimitive, MagickFalse },
- { "Point", (long) PointPrimitive, MagickFalse },
- { "Polygon", (long) PolygonPrimitive, MagickFalse },
- { "Polyline", (long) PolylinePrimitive, MagickFalse },
- { "Rectangle", (long) RectanglePrimitive, MagickFalse },
- { "roundRectangle", (long) RoundRectanglePrimitive, MagickFalse },
- { "Text", (long) TextPrimitive, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedQuantumFormat, MagickTrue },
- { "FloatingPoint", (long) FloatingPointQuantumFormat, MagickFalse },
- { "Signed", (long) SignedQuantumFormat, MagickFalse },
- { "Unsigned", (long) UnsignedQuantumFormat, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedResolution, MagickTrue },
- { "PixelsPerInch", (long) PixelsPerInchResolution, MagickFalse },
- { "PixelsPerCentimeter", (long) PixelsPerCentimeterResolution, MagickFalse },
- { (char *) NULL, (long) UndefinedResolution, MagickFalse }
+ { "Undefined", UndefinedResolution, UndefinedOptionFlag, MagickTrue },
+ { "PixelsPerInch", PixelsPerInchResolution, UndefinedOptionFlag, MagickFalse },
+ { "PixelsPerCentimeter", PixelsPerCentimeterResolution, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedResolution, UndefinedOptionFlag, MagickFalse }
},
ResourceOptions[] =
{
- { "Undefined", (long) UndefinedResource, MagickTrue },
- { "Area", (long) AreaResource, MagickFalse },
- { "Disk", (long) DiskResource, MagickFalse },
- { "File", (long) FileResource, MagickFalse },
- { "Map", (long) MapResource, MagickFalse },
- { "Memory", (long) MemoryResource, MagickFalse },
- { "Thread", (long) ThreadResource, MagickFalse },
- { "Time", (long) TimeResource, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedDistortion, MagickTrue },
- { "Barycentric", (long) BarycentricColorInterpolate, MagickFalse },
- { "Bilinear", (long) BilinearColorInterpolate, MagickFalse },
- { "Shepards", (long) ShepardsColorInterpolate, MagickFalse },
- { "Voronoi", (long) VoronoiColorInterpolate, MagickFalse },
- { (char *) NULL, (long) 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", 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", (long) UndefinedPixel, MagickTrue },
- { "Char", (long) CharPixel, MagickFalse },
- { "Double", (long) DoublePixel, MagickFalse },
- { "Float", (long) FloatPixel, MagickFalse },
- { "Integer", (long) IntegerPixel, MagickFalse },
- { "Long", (long) LongPixel, MagickFalse },
- { "Quantum", (long) QuantumPixel, MagickFalse },
- { "Short", (long) ShortPixel, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedStretch, MagickTrue },
- { "Any", (long) AnyStretch, MagickFalse },
- { "Condensed", (long) CondensedStretch, MagickFalse },
- { "Expanded", (long) ExpandedStretch, MagickFalse },
- { "ExtraCondensed", (long) ExtraCondensedStretch, MagickFalse },
- { "ExtraExpanded", (long) ExtraExpandedStretch, MagickFalse },
- { "Normal", (long) NormalStretch, MagickFalse },
- { "SemiCondensed", (long) SemiCondensedStretch, MagickFalse },
- { "SemiExpanded", (long) SemiExpandedStretch, MagickFalse },
- { "UltraCondensed", (long) UltraCondensedStretch, MagickFalse },
- { "UltraExpanded", (long) UltraExpandedStretch, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedStyle, MagickTrue },
- { "Any", (long) AnyStyle, MagickFalse },
- { "Italic", (long) ItalicStyle, MagickFalse },
- { "Normal", (long) NormalStyle, MagickFalse },
- { "Oblique", (long) ObliqueStyle, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedType, MagickTrue },
- { "Bilevel", (long) BilevelType, MagickFalse },
- { "ColorSeparation", (long) ColorSeparationType, MagickFalse },
- { "ColorSeparationMatte", (long) ColorSeparationMatteType, MagickFalse },
- { "Grayscale", (long) GrayscaleType, MagickFalse },
- { "GrayscaleMatte", (long) GrayscaleMatteType, MagickFalse },
- { "Optimize", (long) OptimizeType, MagickFalse },
- { "Palette", (long) PaletteType, MagickFalse },
- { "PaletteBilevelMatte", (long) PaletteBilevelMatteType, MagickFalse },
- { "PaletteMatte", (long) PaletteMatteType, MagickFalse },
- { "TrueColorMatte", (long) TrueColorMatteType, MagickFalse },
- { "TrueColor", (long) TrueColorType, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedValidate, MagickTrue },
- { "All", (long) AllValidate, MagickFalse },
- { "Compare", (long) CompareValidate, MagickFalse },
- { "Composite", (long) CompositeValidate, MagickFalse },
- { "Convert", (long) ConvertValidate, MagickFalse },
- { "FormatsInMemory", (long) FormatsInMemoryValidate, MagickFalse },
- { "FormatsOnDisk", (long) FormatsOnDiskValidate, MagickFalse },
- { "Identify", (long) IdentifyValidate, MagickFalse },
- { "ImportExport", (long) ImportExportValidate, MagickFalse },
- { "Montage", (long) MontageValidate, MagickFalse },
- { "Stream", (long) StreamValidate, MagickFalse },
- { "None", (long) NoValidate, MagickFalse },
- { (char *) NULL, (long) 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", (long) UndefinedVirtualPixelMethod, MagickTrue },
- { "Background", (long) BackgroundVirtualPixelMethod, MagickFalse },
- { "Black", (long) BlackVirtualPixelMethod, MagickFalse },
- { "Constant", (long) BackgroundVirtualPixelMethod, MagickTrue }, /* deprecated */
- { "CheckerTile", (long) CheckerTileVirtualPixelMethod, MagickFalse },
- { "Dither", (long) DitherVirtualPixelMethod, MagickFalse },
- { "Edge", (long) EdgeVirtualPixelMethod, MagickFalse },
- { "Gray", (long) GrayVirtualPixelMethod, MagickFalse },
- { "HorizontalTile", (long) HorizontalTileVirtualPixelMethod, MagickFalse },
- { "HorizontalTileEdge", (long) HorizontalTileEdgeVirtualPixelMethod, MagickFalse },
- { "Mirror", (long) MirrorVirtualPixelMethod, MagickFalse },
- { "Random", (long) RandomVirtualPixelMethod, MagickFalse },
- { "Tile", (long) TileVirtualPixelMethod, MagickFalse },
- { "Transparent", (long) TransparentVirtualPixelMethod, MagickFalse },
- { "VerticalTile", (long) VerticalTileVirtualPixelMethod, MagickFalse },
- { "VerticalTileEdge", (long) VerticalTileEdgeVirtualPixelMethod, MagickFalse },
- { "White", (long) WhiteVirtualPixelMethod, MagickFalse },
- { (char *) NULL, (long) 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);
case MagickResolutionOptions: return(ResolutionOptions);
case MagickResourceOptions: return(ResourceOptions);
case MagickSparseColorOptions: return(SparseColorOptions);
+ case MagickStatisticOptions: return(StatisticOptions);
case MagickStorageOptions: return(StorageOptions);
case MagickStretchOptions: return(StretchOptions);
case MagickStyleOptions: return(StyleOptions);
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;
const OptionInfo
*option_info;
- register long
+ register ssize_t
i;
option_info=GetOptionInfo(value);
% %
% %
% %
-% 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 long type)
+% 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,
- const long type)
+MagickExport const char *CommandOptionToMnemonic(const CommandOption option,
+ const ssize_t type)
{
const OptionInfo
*option_info;
- register long
+ register ssize_t
i;
option_info=GetOptionInfo(option);
% %
% %
% %
-% 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;
- register long
+ register ssize_t
i;
if (file == (FILE *) NULL)
{
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);
}
%
% The format of the ParseChannelOption method is:
%
-% long ParseChannelOption(const char *channels)
+% ssize_t ParseChannelOption(const char *channels)
%
% A description of each parameter follows:
%
% o options: One or more values separated by commas.
%
*/
-MagickExport long ParseChannelOption(const char *channels)
+MagickExport ssize_t ParseChannelOption(const char *channels)
{
- long
- channel;
-
- register long
+ register ssize_t
i;
- channel=ParseMagickOption(MagickChannelOptions,MagickTrue,channels);
+ ssize_t
+ channel;
+
+ channel=ParseCommandOption(MagickChannelOptions,MagickTrue,channels);
if (channel >= 0)
return(channel);
channel=0;
- for (i=0; i < (long) strlen(channels); i++)
+ for (i=0; i < (ssize_t) strlen(channels); i++)
{
switch (channels[i])
{
}
case ',':
{
+ ssize_t
+ type;
+
/*
- More channel flags follow shorthand. For example "RGB,sync"
- Gather the additional channel flags and merge with shorthand
+ Gather the additional channel flags and merge with shorthand.
*/
- long
- more_channel;
- more_channel=ParseMagickOption(MagickChannelOptions,MagickTrue,
- channels+i+1);
- if (more_channel < 0)
- return(more_channel);
- channel |= more_channel;
+ type=ParseCommandOption(MagickChannelOptions,MagickTrue,channels+i+1);
+ if (type < 0)
+ return(type);
+ channel|=type;
return(channel);
}
default:
% %
% %
% %
-% 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:
%
-% long 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 long ParseMagickOption(const MagickOption option,
+MagickExport ssize_t ParseCommandOption(const CommandOption option,
const MagickBooleanType list,const char *options)
{
char
int
sentinel;
- long
- option_types;
-
MagickBooleanType
negate;
register const char
*p;
- register long
+ register ssize_t
i;
+ ssize_t
+ option_types;
+
option_info=GetOptionInfo(option);
if (option_info == (const OptionInfo *) NULL)
return(-1);
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