Update web pages

[imagemagick] / MagickCore / option.c

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