% MagickCore Option Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% March 2000 %
% %
% %
-% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "MagickCore/effect.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-private.h"
+#include "MagickCore/fourier.h"
#include "MagickCore/fx.h"
#include "MagickCore/gem.h"
#include "MagickCore/geometry.h"
#include "MagickCore/montage.h"
#include "MagickCore/morphology.h"
#include "MagickCore/option.h"
+#include "MagickCore/pixel.h"
#include "MagickCore/policy.h"
#include "MagickCore/property.h"
#include "MagickCore/quantize.h"
{ "Start", LeftAlign, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedAlign, UndefinedOptionFlag, MagickFalse }
},
- AlphaOptions[] =
+ AlphaChannelOptions[] =
{
{ "Undefined", UndefinedAlphaChannel, UndefinedOptionFlag, MagickTrue },
{ "Activate", ActivateAlphaChannel, UndefinedOptionFlag, MagickFalse },
{ "1", MagickTrue, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, MagickFalse, UndefinedOptionFlag, MagickFalse }
},
+ CacheOptions[] =
+ {
+ { "Disk", DiskCache, UndefinedOptionFlag, MagickFalse },
+ { "Distributed", DistributedCache, UndefinedOptionFlag, MagickFalse },
+ { "Map", MapCache, UndefinedOptionFlag, MagickFalse },
+ { "Memory", MemoryCache, UndefinedOptionFlag, MagickFalse },
+ { "Ping", PingCache, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, MagickFalse, UndefinedOptionFlag, MagickFalse }
+ },
ChannelOptions[] =
{
{ "Undefined", UndefinedChannel, UndefinedOptionFlag, MagickTrue },
sort -k 1.2 t1 | diff t1 -
Should not show any differences...
*/
- { "(", 0L, SpecialOptionFlag, MagickTrue },
- { ")", 0L, SpecialOptionFlag, MagickTrue },
- { "{", 0L, SpecialOptionFlag, MagickTrue },
- { "}", 0L, SpecialOptionFlag, MagickTrue },
- { "--", 1L, SpecialOptionFlag, MagickTrue },
+ { "(", 0L, NoImageOperatorFlag, MagickTrue },
+ { ")", 0L, NoImageOperatorFlag, MagickTrue },
+ { "{", 0L, NoImageOperatorFlag, MagickTrue },
+ { "}", 0L, NoImageOperatorFlag, MagickTrue },
+ { "--", 1L, NoImageOperatorFlag, MagickTrue },
{ "+adaptive-blur", 1L, DeprecateOptionFlag, MagickTrue },
- { "-adaptive-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-adaptive-blur", 1L, SimpleOperatorFlag, MagickFalse },
{ "+adaptive-resize", 1L, DeprecateOptionFlag, MagickTrue },
- { "-adaptive-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-adaptive-resize", 1L, SimpleOperatorFlag, MagickFalse },
{ "+adaptive-sharpen", 1L, DeprecateOptionFlag, MagickTrue },
- { "-adaptive-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-adaptive-sharpen", 1L, SimpleOperatorFlag, MagickFalse },
{ "+adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-adjoin", 0L, ImageInfoOptionFlag, MagickFalse },
- { "+affine", 0L, DeprecateOptionFlag | DrawInfoOptionFlag, MagickTrue },
- { "-affine", 1L, DeprecateOptionFlag | DrawInfoOptionFlag, MagickTrue },
+ { "+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, SimpleOperatorOptionFlag, MagickFalse },
+ { "-alpha", 1L, SimpleOperatorFlag, MagickFalse },
{ "+annotate", 0L, DeprecateOptionFlag, MagickTrue },
- { "-annotate", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-annotate", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse },
{ "+antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+append", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-append", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+attenuate", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-attenuate", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+authenticate", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-authenticate", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+auto-gamma", 0L, DeprecateOptionFlag, MagickTrue },
- { "-auto-gamma", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-auto-gamma", 0L, SimpleOperatorFlag, MagickFalse },
{ "+auto-level", 0L, DeprecateOptionFlag, MagickTrue },
- { "-auto-level", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-auto-level", 0L, SimpleOperatorFlag, MagickFalse },
{ "+auto-orient", 0L, DeprecateOptionFlag, MagickTrue },
- { "-auto-orient", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+average", 0L, DeprecateOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
- { "-average", 0L, DeprecateOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
- { "+backdrop", 0L, NonMagickOptionFlag, MagickFalse },
- { "-backdrop", 1L, NonMagickOptionFlag, MagickFalse },
+ { "-auto-orient", 0L, SimpleOperatorFlag, MagickFalse },
+ { "+average", 0L, DeprecateOptionFlag, MagickTrue },
+ { "-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", 0L, GenesisOptionFlag, MagickFalse },
+ { "+bench", 1L, DeprecateOptionFlag, MagickTrue },
{ "-bench", 1L, GenesisOptionFlag, MagickFalse },
{ "+bias", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-bias", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+black-threshold", 0L, DeprecateOptionFlag, MagickTrue },
- { "-black-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-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, SimpleOperatorOptionFlag, MagickFalse },
- { "-blue-shift", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+blue-shift", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-blue-shift", 1L, SimpleOperatorFlag, MagickFalse },
{ "+blur", 0L, DeprecateOptionFlag, MagickTrue },
- { "-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-blur", 1L, SimpleOperatorFlag, MagickFalse },
{ "+border", 1L, DeprecateOptionFlag, MagickTrue },
- { "-border", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-border", 1L, SimpleOperatorFlag, MagickFalse },
{ "+bordercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-bordercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+borderwidth", 0L, NonMagickOptionFlag, MagickFalse },
{ "-borderwidth", 1L, NonMagickOptionFlag, MagickFalse },
- { "+box", 0L, DeprecateOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
- { "-box", 1L, DeprecateOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
+ { "+box", 0L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
+ { "-box", 1L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue },
{ "+brightness-contrast", 0L, DeprecateOptionFlag, MagickTrue },
- { "-brightness-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-brightness-contrast", 1L, SimpleOperatorFlag, MagickFalse },
{ "+cache", 0L, GlobalOptionFlag, MagickFalse },
{ "-cache", 1L, GlobalOptionFlag, MagickFalse },
- { "+caption", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-caption", 1L, ImageInfoOptionFlag, 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, SimpleOperatorOptionFlag, MagickFalse },
+ { "-cdl", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+channel", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-channel", 1L, ImageInfoOptionFlag, MagickFalse },
- { "-channel-fx", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+charcoal", 0L, DeprecateOptionFlag, MagickTrue },
- { "-charcoal", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-channel-fx", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+charcoal", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-charcoal", 1L, SimpleOperatorFlag, MagickFalse },
{ "+chop", 1L, DeprecateOptionFlag, MagickTrue },
- { "-chop", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-chop", 1L, SimpleOperatorFlag, MagickFalse },
{ "+clamp", 0L, DeprecateOptionFlag, MagickTrue },
- { "-clamp", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+clip", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-clip", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+clip-mask", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-clip-mask", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+clip-path", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-clip-path", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+clone", 0L, SpecialOptionFlag, MagickFalse },
- { "-clone", 1L, SpecialOptionFlag, MagickFalse },
+ { "-clamp", 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 },
+ { "+clone", 0L, NoImageOperatorFlag, MagickFalse },
+ { "-clone", 1L, NoImageOperatorFlag, MagickFalse },
{ "+clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-clut", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-clut", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+coalesce", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-coalesce", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-coalesce", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+color-matrix", 1L, DeprecateOptionFlag, MagickTrue },
- { "-color-matrix", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-color-matrix", 1L, SimpleOperatorFlag, MagickFalse },
{ "+colorize", 1L, DeprecateOptionFlag, MagickTrue },
- { "-colorize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-colorize", 1L, SimpleOperatorFlag, MagickFalse },
{ "+colormap", 0L, NonMagickOptionFlag, MagickFalse },
{ "-colormap", 1L, NonMagickOptionFlag, MagickFalse },
{ "+colors", 1L, DeprecateOptionFlag, MagickTrue },
- { "-colors", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+colorspace", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "-colorspace", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "+combine", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-combine", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+comment", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-comment", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-colors", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+colorspace", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "-colorspace", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "+combine", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-combine", 0L, 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 },
- { "-composite", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-composite", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+compress", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-compress", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+concurrent", 0L, GenesisOptionFlag, MagickFalse },
+ { "+concurrent", 0L, DeprecateOptionFlag, MagickTrue },
{ "-concurrent", 0L, GenesisOptionFlag, MagickFalse },
- { "+contrast", 0L, DeprecateOptionFlag, MagickTrue },
- { "-contrast", 0L, DeprecateOptionFlag, MagickTrue },
+ { "+contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+ { "-contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+contrast-stretch", 1L, DeprecateOptionFlag, MagickTrue },
- { "-contrast-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-contrast-stretch", 1L, SimpleOperatorFlag, MagickFalse },
{ "+convolve", 1L, DeprecateOptionFlag, MagickTrue },
- { "-convolve", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-convolve", 1L, SimpleOperatorFlag, MagickFalse },
{ "+crop", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-crop", 1L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-crop", 1L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
{ "+cycle", 1L, DeprecateOptionFlag, MagickTrue },
- { "-cycle", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+debug", 0L, GlobalOptionFlag|GenesisOptionFlag | FireOptionFlag, MagickFalse },
- { "-debug", 1L, GlobalOptionFlag|GenesisOptionFlag | FireOptionFlag, MagickFalse },
+ { "-cycle", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+debug", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
+ { "-debug", 1L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
{ "+decipher", 1L, DeprecateOptionFlag, MagickTrue },
- { "-decipher", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-decipher", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+deconstruct", 0L, DeprecateOptionFlag, MagickTrue },
- { "-deconstruct", 0L, DeprecateOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
- { "+define", 1L, ImageInfoOptionFlag, MagickFalse },
- { "-define", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-deconstruct", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue },
+ { "+define", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
+ { "-define", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
{ "+delay", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-delay", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+delete", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-delete", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+delete", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-delete", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+density", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-density", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+depth", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-depth", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "+depth", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "-depth", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
{ "+descend", 0L, NonMagickOptionFlag, MagickFalse },
{ "-descend", 1L, NonMagickOptionFlag, MagickFalse },
- { "+deskew", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-deskew", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+deskew", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-deskew", 1L, SimpleOperatorFlag, MagickFalse },
{ "+despeckle", 0L, DeprecateOptionFlag, MagickTrue },
- { "-despeckle", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-despeckle", 0L, SimpleOperatorFlag, MagickFalse },
{ "+direction", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-direction", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+displace", 0L, NonMagickOptionFlag, MagickFalse },
{ "-dispose", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+dissolve", 0L, NonMagickOptionFlag, MagickFalse },
{ "-dissolve", 1L, NonMagickOptionFlag, MagickFalse },
- { "+distort", 2L, SimpleOperatorOptionFlag, MagickFalse },
- { "-distort", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+dissimilarity-threshold", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-dissimilarity-threshold", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, 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, SimpleOperatorOptionFlag, MagickFalse },
- { "+duplicate", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-duplicate", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-draw", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+duplicate", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-duplicate", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+duration", 1L, GenesisOptionFlag, MagickFalse },
{ "-duration", 1L, GenesisOptionFlag, MagickFalse },
{ "+edge", 1L, DeprecateOptionFlag, MagickTrue },
- { "-edge", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-edge", 1L, SimpleOperatorFlag, MagickFalse },
{ "+emboss", 1L, DeprecateOptionFlag, MagickTrue },
- { "-emboss", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-emboss", 1L, SimpleOperatorFlag, MagickFalse },
{ "+encipher", 1L, DeprecateOptionFlag, MagickTrue },
- { "-encipher", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-encipher", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+encoding", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-encoding", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "+endian", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-endian", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+enhance", 0L, DeprecateOptionFlag, MagickTrue },
- { "-enhance", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-enhance", 0L, SimpleOperatorFlag, MagickFalse },
{ "+equalize", 0L, DeprecateOptionFlag, MagickTrue },
- { "-equalize", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-equalize", 0L, SimpleOperatorFlag, MagickFalse },
{ "+evaluate", 2L, DeprecateOptionFlag, MagickTrue },
- { "-evaluate", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-evaluate", 2L, SimpleOperatorFlag, MagickFalse },
{ "+evaluate-sequence", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-evaluate-sequence", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-evaluate-sequence", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "-exit", 0L, SpecialOptionFlag, MagickFalse },
{ "+extent", 1L, DeprecateOptionFlag, MagickTrue },
- { "-extent", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-extent", 1L, SimpleOperatorFlag, MagickFalse },
{ "+extract", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-extract", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+family", 0L, DeprecateOptionFlag, MagickTrue },
{ "-family", 1L, DrawInfoOptionFlag, MagickFalse },
- { "+features", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-features", 1L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+fft", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-fft", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+features", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-features", 1L, SimpleOperatorFlag | 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 },
{ "-filter", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+flatten", 0L, DeprecateOptionFlag, MagickTrue },
- { "-flatten", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-flatten", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+flip", 0L, DeprecateOptionFlag, MagickTrue },
- { "-flip", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+floodfill", 2L, SimpleOperatorOptionFlag, MagickFalse },
- { "-floodfill", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-flip", 0L, SimpleOperatorFlag, MagickFalse },
+ { "+floodfill", 2L, SimpleOperatorFlag, MagickFalse },
+ { "-floodfill", 2L, SimpleOperatorFlag, MagickFalse },
{ "+flop", 0L, DeprecateOptionFlag, MagickTrue },
- { "-flop", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-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, MagickFalse },
+ { "-format", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+frame", 1L, DeprecateOptionFlag, MagickTrue },
- { "-frame", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-frame", 1L, SimpleOperatorFlag, MagickFalse },
{ "+function", 2L, DeprecateOptionFlag, MagickTrue },
- { "-function", 2L,SimpleOperatorOptionFlag, MagickFalse },
+ { "-function", 2L,SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse },
{ "+fuzz", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-fuzz", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+fx", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-fx", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+gamma", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-gamma", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-fx", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+gamma", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-gamma", 1L, SimpleOperatorFlag, MagickFalse },
{ "+gaussian", 1L, DeprecateOptionFlag, MagickTrue },
- { "-gaussian", 1L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+ { "-gaussian", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+gaussian-blur", 1L, DeprecateOptionFlag, MagickTrue },
- { "-gaussian-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+geometry", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-geometry", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-gaussian-blur", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+geometry", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-geometry", 1L, SimpleOperatorFlag, MagickFalse },
{ "+gravity", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-gravity", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
+ { "+grayscale", 1L, SimpleOperatorFlag, MagickTrue },
+ { "-grayscale", 1L, SimpleOperatorFlag, MagickFalse },
{ "+green-primary", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-green-primary", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+hald-clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-hald-clut", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+highlight-color", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-highlight-color", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-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", 1L, NonMagickOptionFlag, MagickFalse },
+ { "-iconic", 0L, NonMagickOptionFlag, MagickFalse },
{ "+identify", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-identify", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+ift", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-ift", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-identify", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+immutable", 0L, NonMagickOptionFlag, MagickFalse },
{ "-immutable", 0L, NonMagickOptionFlag, MagickFalse },
{ "+implode", 0L, DeprecateOptionFlag, MagickTrue },
- { "-implode", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+insert", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-insert", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-implode", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+insert", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-insert", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+intensity", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-intensity", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+intent", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-intent", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+interlace", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+interpolate", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-interpolate", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+interpolative-resize", 1L, DeprecateOptionFlag, MagickTrue },
- { "-interpolative-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-interpolative-resize", 1L, SimpleOperatorFlag, 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 },
+ { "+label", 0L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "-label", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+lat", 1L, DeprecateOptionFlag, MagickTrue },
- { "-lat", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-lat", 1L, SimpleOperatorFlag, MagickFalse },
{ "+layers", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-layers", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+level", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-level", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+level-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-level-colors", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-layers", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+level", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-level", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+level-colors", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-level-colors", 1L, SimpleOperatorFlag, MagickFalse },
{ "+limit", 0L, DeprecateOptionFlag, MagickTrue },
- { "-limit", 2L, GlobalOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-limit", 2L, GlobalOptionFlag | FireOptionFlag, MagickFalse },
{ "+linear-stretch", 1L, DeprecateOptionFlag, MagickTrue },
- { "-linear-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-linear-stretch", 1L, SimpleOperatorFlag, MagickFalse },
{ "+liquid-rescale", 1L, DeprecateOptionFlag, MagickTrue },
- { "-liquid-rescale", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-liquid-rescale", 1L, SimpleOperatorFlag, MagickFalse },
{ "+list", 0L, DeprecateOptionFlag, MagickTrue },
- { "-list", 1L, SpecialOptionFlag, MagickFalse },
+ { "-list", 1L, NoImageOperatorFlag, MagickFalse },
{ "+log", 0L, DeprecateOptionFlag, MagickFalse },
{ "-log", 1L, GlobalOptionFlag, MagickFalse },
{ "+loop", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-loop", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+lowlight-color", 1L, DeprecateOptionFlag, MagickTrue },
- { "-lowlight-color", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+magnify", 0L, NonMagickOptionFlag, MagickFalse },
- { "-magnify", 1L, NonMagickOptionFlag, MagickFalse },
- { "+map", 0L, DeprecateOptionFlag | ListOperatorOptionFlag | FireOptionFlag, MagickTrue },
- { "-map", 1L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
- { "+mask", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-mask", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+matte", 0L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
- { "-matte", 0L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
+ { "+lowlight-color", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-lowlight-color", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "+magnify", 0L, DeprecateOptionFlag, MagickTrue },
+ { "-magnify", 0L, SimpleOperatorFlag, MagickFalse },
+ { "+map", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue },
+ { "-map", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+ { "+mask", 0L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "-mask", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "+matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+ { "-matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+mattecolor", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-mattecolor", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+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, DeprecateOptionFlag | SimpleOperatorOptionFlag | FireOptionFlag, MagickTrue },
- { "+metric", 0L, NonMagickOptionFlag, MagickFalse },
- { "-metric", 1L, NonMagickOptionFlag, MagickFalse },
+ { "-median", 1L, ReplacedOptionFlag | SimpleOperatorFlag | FireOptionFlag, MagickTrue },
+ { "+metric", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse },
+ { "-metric", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
{ "-minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "+moments", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-moments", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
{ "+mode", 1L, NonMagickOptionFlag, MagickFalse },
- { "-mode", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-mode", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+modulate", 1L, DeprecateOptionFlag, MagickTrue },
- { "-modulate", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "-monitor", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "-modulate", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "-monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
{ "+monochrome", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-monochrome", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "-monochrome", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
{ "+morph", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-morph", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-morph", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+morphology", 2L, DeprecateOptionFlag, MagickTrue },
- { "-morphology", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-morphology", 2L, SimpleOperatorFlag, MagickFalse },
{ "+mosaic", 0L, DeprecateOptionFlag, MagickTrue },
- { "-mosaic", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-mosaic", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+motion-blur", 1L, DeprecateOptionFlag, MagickTrue },
- { "-motion-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-motion-blur", 1L, SimpleOperatorFlag, MagickFalse },
{ "+name", 0L, NonMagickOptionFlag, MagickFalse },
{ "-name", 1L, NonMagickOptionFlag, MagickFalse },
- { "+negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-negate", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-noise", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-noop", 0L, SpecialOptionFlag, MagickFalse },
+ { "+negate", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-negate", 0L, SimpleOperatorFlag, MagickFalse },
+ { "+noise", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-noise", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "-noop", 0L, NoImageOperatorFlag, MagickFalse },
{ "+normalize", 0L, DeprecateOptionFlag, MagickTrue },
- { "-normalize", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+opaque", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-opaque", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-normalize", 0L, SimpleOperatorFlag, MagickFalse },
+ { "+opaque", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-opaque", 1L, SimpleOperatorFlag, MagickFalse },
{ "+ordered-dither", 0L, DeprecateOptionFlag, MagickTrue },
- { "-ordered-dither", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-ordered-dither", 1L, SimpleOperatorFlag, MagickFalse },
{ "+orient", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-orient", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+origin", 0L, DeprecateOptionFlag, MagickTrue },
- { "-origin", 1L, DeprecateOptionFlag, MagickTrue },
{ "+page", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-page", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+paint", 0L, DeprecateOptionFlag, MagickTrue },
- { "-paint", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-paint", 1L, SimpleOperatorFlag, MagickFalse },
{ "+path", 0L, NonMagickOptionFlag, MagickFalse },
{ "-path", 1L, NonMagickOptionFlag, MagickFalse },
{ "+pause", 0L, NonMagickOptionFlag, MagickFalse },
{ "-ping", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+pointsize", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-pointsize", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+polaroid", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-polaroid", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+polaroid", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-polaroid", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+poly", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
+ { "-poly", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+posterize", 1L, DeprecateOptionFlag, MagickTrue },
- { "-posterize", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-posterize", 1L, SimpleOperatorFlag, MagickFalse },
{ "+precision", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-precision", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+preview", 0L, DeprecateOptionFlag, MagickTrue },
{ "-preview", 1L, GlobalOptionFlag, MagickFalse },
{ "+print", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-print", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-print", 1L, NoImageOperatorFlag | AlwaysInterpretArgsFlag | FireOptionFlag, MagickFalse },
{ "+process", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-process", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "+profile", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-profile", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-process", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "+profile", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-profile", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, 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, MagickTrue },
- { "-radial-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+raise", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-raise", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-rotational-blur", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+raise", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-raise", 1L, SimpleOperatorFlag, MagickFalse },
{ "+random-threshold", 1L, DeprecateOptionFlag, MagickTrue },
- { "-random-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-read", 1L, SpecialOptionFlag, MagickFalse },
+ { "-random-threshold", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-read", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+recolor", 1L, DeprecateOptionFlag, MagickTrue },
- { "-recolor", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-recolor", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
{ "+red-primary", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-red-primary", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+regard-warnings", 0L, GenesisOptionFlag, MagickFalse },
- { "-regard-warnings", 0L, GenesisOptionFlag, MagickFalse },
- { "+region", 0L, SpecialOptionFlag, MagickFalse },
- { "-region", 1L, SpecialOptionFlag, MagickFalse },
- { "+remap", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-remap", 1L, SimpleOperatorOptionFlag, 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, SimpleOperatorOptionFlag, MagickFalse },
- { "-repage", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+repage", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-repage", 1L, SimpleOperatorFlag, MagickFalse },
{ "+resample", 1L, DeprecateOptionFlag, MagickTrue },
- { "-resample", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-resample", 1L, SimpleOperatorFlag, MagickFalse },
{ "+resize", 1L, DeprecateOptionFlag, MagickTrue },
- { "-resize", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+respect-parenthesis", 0L, SpecialOptionFlag, MagickFalse },
- { "-respect-parenthesis", 0L, SpecialOptionFlag, MagickFalse },
+ { "-resize", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
+ { "-respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+reverse", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-reverse", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-reverse", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+roll", 1L, DeprecateOptionFlag, MagickTrue },
- { "-roll", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-roll", 1L, SimpleOperatorFlag, MagickFalse },
{ "+rotate", 1L, DeprecateOptionFlag, MagickTrue },
- { "-rotate", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-rotate", 1L, SimpleOperatorFlag, MagickFalse },
{ "+sample", 1L, DeprecateOptionFlag, MagickTrue },
- { "-sample", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-sample", 1L, SimpleOperatorFlag, MagickFalse },
{ "+sampling-factor", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-sampling-factor", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+sans", 1L, SpecialOptionFlag, MagickTrue },
- { "-sans", 1L, SpecialOptionFlag, MagickTrue },
- { "+sans0", 0L, SpecialOptionFlag, MagickTrue }, /* equivelent to 'noop' */
- { "-sans0", 0L, SpecialOptionFlag, MagickTrue },
- { "+sans2", 2L, SpecialOptionFlag, MagickTrue },
- { "-sans2", 2L, SpecialOptionFlag, MagickTrue },
+ { "+sans", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "-sans", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "+sans0", 0L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, /* equivelent to 'noop' */
+ { "-sans0", 0L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "+sans1", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "-sans1", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, /* equivelent to 'sans' */
+ { "+sans2", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
+ { "-sans2", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue },
{ "+scale", 1L, DeprecateOptionFlag, MagickTrue },
- { "-scale", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-scale", 1L, SimpleOperatorFlag, MagickFalse },
{ "+scene", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-scene", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+scenes", 0L, NonMagickOptionFlag, MagickFalse },
{ "-scenes", 1L, NonMagickOptionFlag, MagickFalse },
{ "+screen", 0L, NonMagickOptionFlag, MagickFalse },
{ "-screen", 1L, NonMagickOptionFlag, MagickFalse },
+ { "-script", 1L, SpecialOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+seed", 0L, GlobalOptionFlag, MagickFalse },
{ "-seed", 1L, GlobalOptionFlag, MagickFalse },
{ "+segment", 1L, DeprecateOptionFlag, MagickTrue },
- { "-segment", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-segment", 1L, SimpleOperatorFlag, MagickFalse },
{ "+selective-blur", 1L, DeprecateOptionFlag, MagickTrue },
- { "-selective-blur", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-selective-blur", 1L, SimpleOperatorFlag, MagickFalse },
{ "+separate", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue },
- { "-separate", 0L, SimpleOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-separate", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse },
{ "+sepia-tone", 1L, DeprecateOptionFlag, MagickTrue },
- { "-sepia-tone", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+set", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-set", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-sepia-tone", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+set", 1L, NoImageOperatorFlag, MagickFalse },
+ { "-set", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+shade", 0L, DeprecateOptionFlag, MagickTrue },
- { "-shade", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-shade", 1L, SimpleOperatorFlag, MagickFalse },
{ "+shadow", 1L, DeprecateOptionFlag, MagickTrue },
- { "-shadow", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-shadow", 1L, SimpleOperatorFlag, MagickFalse },
{ "+shared-memory", 0L, NonMagickOptionFlag, MagickFalse },
{ "-shared-memory", 1L, NonMagickOptionFlag, MagickFalse },
{ "+sharpen", 1L, DeprecateOptionFlag, MagickTrue },
- { "-sharpen", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-sharpen", 1L, SimpleOperatorFlag, MagickFalse },
{ "+shave", 1L, DeprecateOptionFlag, MagickTrue },
- { "-shave", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-shave", 1L, SimpleOperatorFlag, MagickFalse },
{ "+shear", 1L, DeprecateOptionFlag, MagickTrue },
- { "-shear", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+sigmoidal-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-sigmoidal-contrast", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-shear", 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, SimpleOperatorOptionFlag, MagickFalse },
- { "+smush", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-smush", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "-sketch", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+snaps", 0L, NonMagickOptionFlag, MagickFalse },
{ "-snaps", 1L, NonMagickOptionFlag, MagickFalse },
{ "+solarize", 1L, DeprecateOptionFlag, MagickTrue },
- { "-solarize", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+sparse-color", 2L, DeprecateOptionFlag, MagickTrue },
- { "-sparse-color", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-solarize", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+sparse-color", 1L, DeprecateOptionFlag, MagickTrue },
+ { "-sparse-color", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse },
{ "+splice", 1L, DeprecateOptionFlag, MagickTrue },
- { "-splice", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-splice", 1L, SimpleOperatorFlag, MagickFalse },
{ "+spread", 1L, DeprecateOptionFlag, MagickTrue },
- { "-spread", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-spread", 1L, SimpleOperatorFlag, MagickFalse },
{ "+statistic", 2L, DeprecateOptionFlag, MagickTrue },
- { "-statistic", 2L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-statistic", 2L, SimpleOperatorFlag, MagickFalse },
{ "+stegano", 0L, NonMagickOptionFlag, MagickFalse },
{ "-stegano", 1L, NonMagickOptionFlag, MagickFalse },
{ "+stereo", 0L, DeprecateOptionFlag, MagickTrue },
{ "-stereo", 1L, NonMagickOptionFlag, MagickFalse },
{ "+stretch", 1L, DeprecateOptionFlag, MagickTrue },
- { "-stretch", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-stretch", 1L, SimpleOperatorFlag, MagickFalse },
{ "+strip", 0L, DeprecateOptionFlag, MagickTrue },
- { "-strip", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-strip", 0L, SimpleOperatorFlag, 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, NonMagickOptionFlag, MagickFalse },
- { "-subimage-search", 0L, NonMagickOptionFlag, MagickFalse },
- { "+swap", 0L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-swap", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse },
+ { "-subimage", 0L, ListOperatorFlag, MagickFalse },
+ { "+swap", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse },
+ { "-swap", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse },
{ "+swirl", 1L, DeprecateOptionFlag, MagickTrue },
- { "-swirl", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-swirl", 1L, SimpleOperatorFlag, MagickFalse },
{ "+synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-synchronize", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+taint", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+text-font", 0L, NonMagickOptionFlag, MagickFalse },
{ "-text-font", 1L, NonMagickOptionFlag, MagickFalse },
{ "+texture", 0L, ImageInfoOptionFlag, MagickFalse },
- { "-texture", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+threshold", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-texture", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "+threshold", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-threshold", 1L, SimpleOperatorFlag, MagickFalse },
{ "+thumbnail", 1L, DeprecateOptionFlag, MagickTrue },
- { "-thumbnail", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+tile", 0L, DrawInfoOptionFlag, MagickFalse },
- { "-tile", 1L, DrawInfoOptionFlag, MagickFalse },
+ { "-thumbnail", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+tile", 0L, DrawInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
+ { "-tile", 1L, DrawInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse },
{ "+tile-offset", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-tile-offset", 1L, ImageInfoOptionFlag, MagickFalse },
- { "+tint", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-tint", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+tint", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-tint", 1L, SimpleOperatorFlag, MagickFalse },
{ "+title", 0L, NonMagickOptionFlag, MagickFalse },
{ "-title", 1L, NonMagickOptionFlag, MagickFalse },
{ "+transform", 0L, DeprecateOptionFlag, MagickTrue },
- { "-transform", 0L, DeprecateOptionFlag | SimpleOperatorOptionFlag, MagickTrue },
- { "+transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "-transparent", 1L, SimpleOperatorOptionFlag, MagickFalse },
- { "+transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
+ { "-transform", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue },
+ { "+transparent", 1L, SimpleOperatorFlag, MagickFalse },
+ { "-transparent", 1L, SimpleOperatorFlag, MagickFalse },
+ { "+transparent-color", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-transparent-color", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+transpose", 0L, DeprecateOptionFlag, MagickTrue },
- { "-transpose", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-transpose", 0L, SimpleOperatorFlag, MagickFalse },
{ "+transverse", 0L, DeprecateOptionFlag, MagickTrue },
- { "-transverse", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-transverse", 0L, SimpleOperatorFlag, MagickFalse },
{ "+treedepth", 1L, DeprecateOptionFlag, MagickTrue },
{ "-treedepth", 1L, QuantizeInfoOptionFlag, MagickFalse },
{ "+trim", 0L, DeprecateOptionFlag, MagickTrue },
- { "-trim", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "+type", 0L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
- { "-type", 1L, ImageInfoOptionFlag | SimpleOperatorOptionFlag, MagickFalse },
+ { "-trim", 0L, SimpleOperatorFlag, MagickFalse },
+ { "+type", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
+ { "-type", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse },
{ "+undercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
{ "-undercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse },
- { "+unique", 0L, SimpleOperatorOptionFlag, MagickFalse },
- { "-unique", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "+unique", 0L, SimpleOperatorFlag, MagickFalse },
+ { "-unique", 0L, SimpleOperatorFlag, MagickFalse },
{ "+unique-colors", 0L, DeprecateOptionFlag, MagickTrue },
- { "-unique-colors", 0L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-unique-colors", 0L, SimpleOperatorFlag, MagickFalse },
{ "+units", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-units", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+unsharp", 1L, DeprecateOptionFlag, MagickTrue },
- { "-unsharp", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-unsharp", 1L, SimpleOperatorFlag, MagickFalse },
{ "+update", 0L, NonMagickOptionFlag, MagickFalse },
{ "-update", 1L, NonMagickOptionFlag, MagickFalse },
{ "+use-pixmap", 0L, NonMagickOptionFlag, MagickFalse },
{ "+verbose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-verbose", 0L, ImageInfoOptionFlag, MagickFalse },
{ "+version", 0L, DeprecateOptionFlag, MagickTrue },
- { "-version", 0L, SpecialOptionFlag, MagickFalse },
+ { "-version", 0L, NoImageOperatorFlag, MagickFalse },
{ "+view", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-view", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+vignette", 1L, DeprecateOptionFlag, MagickTrue },
- { "-vignette", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-vignette", 1L, SimpleOperatorFlag, MagickFalse },
{ "+virtual-pixel", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-virtual-pixel", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+visual", 0L, NonMagickOptionFlag, MagickFalse },
{ "+watermark", 0L, NonMagickOptionFlag, MagickFalse },
{ "-watermark", 1L, NonMagickOptionFlag, MagickFalse },
{ "+wave", 1L, DeprecateOptionFlag, MagickTrue },
- { "-wave", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-wave", 1L, SimpleOperatorFlag, MagickFalse },
{ "+weight", 1L, DeprecateOptionFlag, MagickTrue },
{ "-weight", 1L, DrawInfoOptionFlag, MagickFalse },
{ "+white-point", 0L, ImageInfoOptionFlag, MagickFalse },
{ "-white-point", 1L, ImageInfoOptionFlag, MagickFalse },
{ "+white-threshold", 1L, DeprecateOptionFlag, MagickTrue },
- { "-white-threshold", 1L, SimpleOperatorOptionFlag, MagickFalse },
+ { "-white-threshold", 1L, SimpleOperatorFlag, MagickFalse },
{ "+window", 0L, NonMagickOptionFlag, MagickFalse },
{ "-window", 1L, NonMagickOptionFlag, MagickFalse },
{ "+window-group", 0L, NonMagickOptionFlag, MagickFalse },
{ "-window-group", 1L, NonMagickOptionFlag, MagickFalse },
- { "+write", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
- { "-write", 1L, ListOperatorOptionFlag | FireOptionFlag, MagickFalse },
+ { "+write", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
+ { "-write", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse },
{ (char *) NULL, 0L, UndefinedOptionFlag, MagickFalse }
},
ComposeOptions[] =
{ "Divide", DivideDstCompositeOp, DeprecateOptionFlag, MagickTrue },
{ "Minus", MinusDstCompositeOp, DeprecateOptionFlag, MagickTrue },
{ "Threshold", ThresholdCompositeOp, DeprecateOptionFlag, MagickTrue },
+ { "CopyOpacity", CopyAlphaCompositeOp, UndefinedOptionFlag, MagickTrue },
{ (char *) NULL, UndefinedCompositeOp, UndefinedOptionFlag, MagickFalse }
},
CompressOptions[] =
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 },
- { "Rec601Luma", Rec601LumaColorspace, UndefinedOptionFlag, MagickFalse },
{ "Rec601YCbCr", Rec601YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
- { "Rec709Luma", Rec709LumaColorspace, UndefinedOptionFlag, MagickFalse },
{ "Rec709YCbCr", Rec709YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
{ "RGB", RGBColorspace, UndefinedOptionFlag, MagickFalse },
+ { "scRGB", scRGBColorspace, UndefinedOptionFlag, MagickFalse },
{ "sRGB", sRGBColorspace, UndefinedOptionFlag, MagickFalse },
{ "Transparent", TransparentColorspace, UndefinedOptionFlag, MagickFalse },
{ "XYZ", XYZColorspace, UndefinedOptionFlag, MagickFalse },
{ "YCbCr", YCbCrColorspace, UndefinedOptionFlag, MagickFalse },
+ { "YDbDr", YDbDrColorspace, UndefinedOptionFlag, MagickFalse },
{ "YCC", YCCColorspace, UndefinedOptionFlag, MagickFalse },
{ "YIQ", YIQColorspace, UndefinedOptionFlag, MagickFalse },
{ "YPbPr", YPbPrColorspace, UndefinedOptionFlag, MagickFalse },
{ "YUV", YUVColorspace, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedColorspace, UndefinedOptionFlag, MagickFalse }
},
+ 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 }
+ },
DataTypeOptions[] =
{
{ "Undefined", UndefinedData, UndefinedOptionFlag, MagickTrue },
{ "Bohman", BohmanFilter, UndefinedOptionFlag, MagickFalse },
{ "Box", BoxFilter, UndefinedOptionFlag, MagickFalse },
{ "Catrom", CatromFilter, UndefinedOptionFlag, MagickFalse },
+ { "Cosine", CosineFilter, UndefinedOptionFlag, MagickFalse },
{ "Cubic", CubicFilter, UndefinedOptionFlag, MagickFalse },
{ "Gaussian", GaussianFilter, UndefinedOptionFlag, MagickFalse },
{ "Hamming", HammingFilter, UndefinedOptionFlag, MagickFalse },
- { "Hanning", HanningFilter, UndefinedOptionFlag, MagickFalse },
+ { "Hann", HannFilter, UndefinedOptionFlag, MagickFalse },
+ { "Hanning", HannFilter, UndefinedOptionFlag, MagickTrue }, /*misspell*/
{ "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 },
+ { "LanczosRadius", LanczosRadiusFilter, UndefinedOptionFlag, MagickFalse },
+ { "LanczosSharp", LanczosSharpFilter, UndefinedOptionFlag, MagickFalse },
{ "Mitchell", MitchellFilter, UndefinedOptionFlag, MagickFalse },
{ "Parzen", ParzenFilter, UndefinedOptionFlag, MagickFalse },
{ "Point", PointFilter, UndefinedOptionFlag, MagickFalse },
{ "Quadratic", QuadraticFilter, UndefinedOptionFlag, MagickFalse },
{ "Robidoux", RobidouxFilter, UndefinedOptionFlag, MagickFalse },
+ { "RobidouxSharp", RobidouxSharpFilter, UndefinedOptionFlag, MagickFalse },
{ "Sinc", SincFilter, UndefinedOptionFlag, MagickFalse },
{ "SincFast", SincFastFilter, UndefinedOptionFlag, MagickFalse },
+ { "Spline", SplineFilter, UndefinedOptionFlag, MagickFalse },
{ "Triangle", TriangleFilter, UndefinedOptionFlag, MagickFalse },
- { "Welsh", WelshFilter, UndefinedOptionFlag, MagickFalse },
- /* For backward compatibility - must be after "Jinc" */
- { "Bessel", JincFilter, UndefinedOptionFlag, MagickTrue },
+ { "Welch", WelchFilter, UndefinedOptionFlag, MagickFalse },
+ { "Welsh", WelchFilter, UndefinedOptionFlag, MagickTrue }, /*misspell*/
{ (char *) NULL, UndefinedFilter, UndefinedOptionFlag, MagickFalse }
},
FunctionOptions[] =
{ "South", SouthGravity, UndefinedOptionFlag, MagickFalse },
{ "SouthWest", SouthWestGravity, UndefinedOptionFlag, MagickFalse },
{ "West", WestGravity, UndefinedOptionFlag, MagickFalse },
- { "Static", StaticGravity, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedGravity, UndefinedOptionFlag, MagickFalse }
},
IntentOptions[] =
{
{ "Undefined", UndefinedInterpolatePixel, UndefinedOptionFlag, MagickTrue },
{ "Average", AverageInterpolatePixel, UndefinedOptionFlag, MagickFalse },
- { "Bicubic", BicubicInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Average4", AverageInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Average9", Average9InterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Average16", Average16InterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Background", BackgroundInterpolatePixel, UndefinedOptionFlag, MagickFalse },
{ "Bilinear", BilinearInterpolatePixel, UndefinedOptionFlag, MagickFalse },
- { "filter", FilterInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Blend", BlendInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Catrom", CatromInterpolatePixel, UndefinedOptionFlag, MagickFalse },
{ "Integer", IntegerInterpolatePixel, UndefinedOptionFlag, MagickFalse },
{ "Mesh", MeshInterpolatePixel, UndefinedOptionFlag, MagickFalse },
- { "Nearest", NearestNeighborInterpolatePixel, UndefinedOptionFlag, MagickFalse },
- { "NearestNeighbor", NearestNeighborInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "Nearest", NearestInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+ { "NearestNeighbor", NearestInterpolatePixel, UndefinedOptionFlag, MagickTrue },
{ "Spline", SplineInterpolatePixel, UndefinedOptionFlag, MagickFalse },
+/* { "Filter", FilterInterpolatePixel, UndefinedOptionFlag, MagickFalse }, */
{ (char *) NULL, UndefinedInterpolatePixel, UndefinedOptionFlag, MagickFalse }
},
KernelOptions[] =
{ "LoG", LoGKernel, UndefinedOptionFlag, MagickFalse },
{ "Blur", BlurKernel, UndefinedOptionFlag, MagickFalse },
{ "Comet", CometKernel, UndefinedOptionFlag, MagickFalse },
+ { "Binomial", BinomialKernel, UndefinedOptionFlag, MagickFalse },
{ "Laplacian", LaplacianKernel, UndefinedOptionFlag, MagickFalse },
{ "Sobel", SobelKernel, UndefinedOptionFlag, MagickFalse },
{ "FreiChen", FreiChenKernel, 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 },
ListOptions[] =
{
{ "Align", MagickAlignOptions, UndefinedOptionFlag, MagickFalse },
- { "Alpha", MagickAlphaOptions, UndefinedOptionFlag, MagickFalse },
+ { "Alpha", MagickAlphaChannelOptions, UndefinedOptionFlag, MagickFalse },
{ "Boolean", MagickBooleanOptions, UndefinedOptionFlag, MagickFalse },
+ { "Cache", MagickCacheOptions, UndefinedOptionFlag, MagickFalse },
{ "Channel", MagickChannelOptions, UndefinedOptionFlag, MagickFalse },
{ "Class", MagickClassOptions, UndefinedOptionFlag, MagickFalse },
{ "ClipPath", MagickClipPathOptions, UndefinedOptionFlag, MagickFalse },
{ "Color", MagickColorOptions, UndefinedOptionFlag, MagickFalse },
{ "Colorspace", MagickColorspaceOptions, UndefinedOptionFlag, MagickFalse },
{ "Command", MagickCommandOptions, UndefinedOptionFlag, MagickFalse },
+ { "Complex", MagickComplexOptions, UndefinedOptionFlag, MagickFalse },
{ "Compose", MagickComposeOptions, UndefinedOptionFlag, MagickFalse },
{ "Compress", MagickCompressOptions, UndefinedOptionFlag, MagickFalse },
{ "Configure", MagickConfigureOptions, UndefinedOptionFlag, MagickFalse },
{ "Format", MagickFormatOptions, UndefinedOptionFlag, MagickFalse },
{ "Function", MagickFunctionOptions, UndefinedOptionFlag, MagickFalse },
{ "Gravity", MagickGravityOptions, UndefinedOptionFlag, MagickFalse },
+ { "Intensity", MagickPixelIntensityOptions, UndefinedOptionFlag, MagickFalse },
{ "Intent", MagickIntentOptions, UndefinedOptionFlag, MagickFalse },
{ "Interlace", MagickInterlaceOptions, UndefinedOptionFlag, MagickFalse },
{ "Interpolate", MagickInterpolateOptions, UndefinedOptionFlag, MagickFalse },
{ "Noise", MagickNoiseOptions, UndefinedOptionFlag, MagickFalse },
{ "Orientation", MagickOrientationOptions, UndefinedOptionFlag, MagickFalse },
{ "PixelChannel", MagickPixelChannelOptions, UndefinedOptionFlag, MagickFalse },
+ { "PixelIntensity", MagickPixelIntensityOptions, UndefinedOptionFlag, MagickFalse },
+ { "PixelMask", MagickPixelMaskOptions, UndefinedOptionFlag, MagickFalse },
{ "PixelTrait", MagickPixelTraitOptions, UndefinedOptionFlag, MagickFalse },
{ "Policy", MagickPolicyOptions, UndefinedOptionFlag, MagickFalse },
{ "PolicyDomain", MagickPolicyDomainOptions, UndefinedOptionFlag, MagickFalse },
{ "Blob", BlobEvent, UndefinedOptionFlag, MagickFalse },
{ "Cache", CacheEvent, UndefinedOptionFlag, MagickFalse },
{ "Coder", CoderEvent, UndefinedOptionFlag, MagickFalse },
+ { "Command", CommandEvent, UndefinedOptionFlag, MagickFalse },
{ "Configure", ConfigureEvent, UndefinedOptionFlag, MagickFalse },
{ "Deprecate", DeprecateEvent, UndefinedOptionFlag, MagickFalse },
{ "Draw", DrawEvent, UndefinedOptionFlag, MagickFalse },
},
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[] =
{
{ "K", BlackPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "M", MagentaPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Magenta", MagentaPixelChannel, UndefinedOptionFlag, MagickFalse },
- { "Mask", MaskPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "R", RedPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "ReadMask", ReadMaskPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Red", RedPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Sync", SyncPixelChannel, UndefinedOptionFlag, MagickFalse },
+ { "WriteMask", WriteMaskPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Y", YellowPixelChannel, UndefinedOptionFlag, MagickFalse },
{ "Yellow", YellowPixelChannel, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedPixelChannel, UndefinedOptionFlag, MagickFalse }
},
+ PixelIntensityOptions[] =
+ {
+ { "Undefined", UndefinedPixelIntensityMethod, UndefinedOptionFlag, MagickTrue },
+ { "Average", AveragePixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Brightness", BrightnessPixelIntensityMethod, UndefinedOptionFlag, MagickFalse },
+ { "Lightness", LightnessPixelIntensityMethod, 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[] =
+ {
+ { "Undefined", UndefinedPixelMask, UndefinedOptionFlag, MagickTrue },
+ { "R", ReadPixelMask, UndefinedOptionFlag, MagickFalse },
+ { "Read", ReadPixelMask, UndefinedOptionFlag, MagickFalse },
+ { "W", WritePixelMask, UndefinedOptionFlag, MagickFalse },
+ { "Write", WritePixelMask, UndefinedOptionFlag, MagickFalse },
+ { (char *) NULL, UndefinedPixelMask, UndefinedOptionFlag, MagickFalse }
+ },
PixelTraitOptions[] =
{
{ "Undefined", UndefinedPixelTrait, UndefinedOptionFlag, MagickTrue },
{ "Median", MedianStatistic, UndefinedOptionFlag, MagickFalse },
{ "Minimum", MinimumStatistic, UndefinedOptionFlag, MagickFalse },
{ "Mode", ModeStatistic, UndefinedOptionFlag, MagickFalse },
- { "Nonpeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse },
+ { "NonPeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse },
{ "StandardDeviation", StandardDeviationStatistic, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedMethod, UndefinedOptionFlag, MagickFalse }
},
{ "Undefined", UndefinedType, UndefinedOptionFlag, MagickTrue },
{ "Bilevel", BilevelType, UndefinedOptionFlag, MagickFalse },
{ "ColorSeparation", ColorSeparationType, UndefinedOptionFlag, MagickFalse },
+ { "ColorSeparationAlpha", ColorSeparationMatteType, UndefinedOptionFlag, MagickFalse },
{ "ColorSeparationMatte", ColorSeparationMatteType, UndefinedOptionFlag, MagickFalse },
{ "Grayscale", GrayscaleType, UndefinedOptionFlag, MagickFalse },
+ { "GrayscaleAlpha", GrayscaleMatteType, UndefinedOptionFlag, MagickFalse },
{ "GrayscaleMatte", GrayscaleMatteType, 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 },
{ "TrueColor", TrueColorType, UndefinedOptionFlag, MagickFalse },
{ (char *) NULL, UndefinedType, UndefinedOptionFlag, MagickFalse }
{
{ "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 },
{ "HorizontalTile", HorizontalTileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
{ "HorizontalTileEdge", HorizontalTileEdgeVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
{ "Mirror", MirrorVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
+ { "None", TransparentVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
{ "Random", RandomVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
{ "Tile", TileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
{ "Transparent", TransparentVirtualPixelMethod, UndefinedOptionFlag, MagickFalse },
switch (option)
{
case MagickAlignOptions: return(AlignOptions);
- case MagickAlphaOptions: return(AlphaOptions);
+ 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 MagickComplexOptions: return(ComplexOptions);
case MagickComposeOptions: return(ComposeOptions);
case MagickCompressOptions: return(CompressOptions);
case MagickDataTypeOptions: return(DataTypeOptions);
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);
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% CloneImageOptions() clones one or more image options.
+% CloneImageOptions() clones all global image options, to another image_info
%
% The format of the CloneImageOptions method is:
%
%
% A description of each parameter follows:
%
-% o image_info: the image info.
+% o image_info: the image info to recieve the cloned options.
%
-% o clone_info: the clone image info.
+% o clone_info: the source image info for options to clone.
%
*/
MagickExport MagickBooleanType CloneImageOptions(ImageInfo *image_info,
assert(clone_info != (const ImageInfo *) NULL);
assert(clone_info->signature == MagickSignature);
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
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DefineImageOption() associates an assignment string of the form
-% "key=value" with an image option. It is equivelent to SetImageOption().
+% "key=value" with a global image option. It is equivelent to
+% SetImageOption().
%
% The format of the DefineImageOption method is:
%
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DeleteImageOption() deletes an key from the image map.
+% DeleteImageOption() deletes an key from the global image options.
%
% Returns MagickTrue is the option is found and deleted from the Options.
%
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% DestroyImageOptions() releases memory associated with image option values.
+% DestroyImageOptions() destroys all global options and associated memory
+% attached to the given image_info image list.
%
% The format of the DestroyDefines method is:
%
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetImageOption() gets a value associated with an image option.
+% GetImageOption() gets a value associated with the global image options.
+%
+% The returned string is a constant string in the tree and should NOT be
+% freed by the caller.
%
% The format of the GetImageOption method is:
%
% to speed up the lookup for that very large table, and returns both the
% type (arg count) and flags (arg type).
%
-% This search reduces linear search of over 500 options (250 tests of
+% This search reduces linear search of over 500 options (250 tests on
% average) to about 10 lookups!
%
% The format of the GetCommandOptionInfo method is:
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
-% GetNextImageOption() gets the next image option value.
+% GetNextImageOption() gets the next global option value.
%
% The format of the GetNextImageOption method is:
%
if ((*option != '-') && (*option != '+'))
return(MagickFalse);
if (strlen(option) == 1)
- return(MagickFalse);
+ return(IsMagickTrue( (*option == '{') || (*option == '}')
+ || (*option == '[') || (*option == ']') ));
option++;
+ if (*option == '-')
+ return(MagickTrue);
if (isalpha((int) ((unsigned char) *option)) == 0)
return(MagickFalse);
return(MagickTrue);
%
% RemoveImageOption() removes an option from the image and returns its value.
%
+% In this case the ConstantString() value returned should be freed by the
+% caller when finished.
+%
% The format of the RemoveImageOption method is:
%
% char *RemoveImageOption(ImageInfo *image_info,const char *option)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ResetImageOptions() resets the image_info option. That is, it deletes
-% all options associated with the image_info structure.
+% all global options associated with the image_info structure.
%
% The format of the ResetImageOptions method is:
%
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
-
- /* This should not be here! - but others might */
- if (LocaleCompare(option,"size") == 0)
+ /*
+ Specific global option settings.
+ */
+ if (LocaleCompare(option,"size") == 0) {
(void) CloneString(&image_info->size,value);
-
- /* create tree if needed - specify how key,values are to be freed */
+ return(MagickTrue);
+ }
+ /*
+ Create tree if needed - specify how key,values are to be freed.
+ */
if (image_info->options == (void *) NULL)
image_info->options=NewSplayTree(CompareSplayTreeString,
RelinquishMagickMemory,RelinquishMagickMemory);
-
- /* Delete Option if NULL */
+ /*
+ Delete Option if NULL -- empty string values are valid!
+ */
if (value == (const char *) NULL)
return(DeleteImageOption(image_info,option));
-
- /* add option and return */
+ /*
+ Add option to splay-tree.
+ */
return(AddValueToSplayTree((SplayTreeInfo *) image_info->options,
ConstantString(option),ConstantString(value)));
}
projects / imagemagick / blobdiff