cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1 | /* |
| 2 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 3 | % % |
| 4 | % % |
| 5 | % % |
| 6 | % OOO PPPP TTTTT IIIII OOO N N % |
| 7 | % O O P P T I O O NN N % |
| 8 | % O O PPPP T I O O N N N % |
| 9 | % O O P T I O O N NN % |
| 10 | % OOO P T IIIII OOO N N % |
| 11 | % % |
| 12 | % % |
| 13 | % MagickCore Option Methods % |
| 14 | % % |
| 15 | % Software Design % |
cristy | de984cd | 2013-12-01 14:49:27 +0000 | [diff] [blame] | 16 | % Cristy % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 17 | % March 2000 % |
| 18 | % % |
| 19 | % % |
cristy | b56bb24 | 2014-11-25 17:12:48 +0000 | [diff] [blame] | 20 | % Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 21 | % dedicated to making software imaging solutions freely available. % |
| 22 | % % |
| 23 | % You may not use this file except in compliance with the License. You may % |
| 24 | % obtain a copy of the License at % |
| 25 | % % |
| 26 | % http://www.imagemagick.org/script/license.php % |
| 27 | % % |
| 28 | % Unless required by applicable law or agreed to in writing, software % |
| 29 | % distributed under the License is distributed on an "AS IS" BASIS, % |
| 30 | % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % |
| 31 | % See the License for the specific language governing permissions and % |
| 32 | % limitations under the License. % |
| 33 | % % |
| 34 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 35 | % |
| 36 | % |
| 37 | % |
| 38 | */ |
| 39 | |
| 40 | /* |
| 41 | Include declarations. |
| 42 | */ |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 43 | #include "MagickCore/studio.h" |
| 44 | #include "MagickCore/artifact.h" |
| 45 | #include "MagickCore/cache.h" |
| 46 | #include "MagickCore/color.h" |
| 47 | #include "MagickCore/compare.h" |
| 48 | #include "MagickCore/constitute.h" |
| 49 | #include "MagickCore/distort.h" |
| 50 | #include "MagickCore/draw.h" |
| 51 | #include "MagickCore/effect.h" |
| 52 | #include "MagickCore/exception.h" |
| 53 | #include "MagickCore/exception-private.h" |
cristy | 790190d | 2013-10-04 00:51:51 +0000 | [diff] [blame] | 54 | #include "MagickCore/fourier.h" |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 55 | #include "MagickCore/fx.h" |
| 56 | #include "MagickCore/gem.h" |
| 57 | #include "MagickCore/geometry.h" |
| 58 | #include "MagickCore/image.h" |
| 59 | #include "MagickCore/image-private.h" |
| 60 | #include "MagickCore/layer.h" |
| 61 | #include "MagickCore/mime-private.h" |
| 62 | #include "MagickCore/memory_.h" |
| 63 | #include "MagickCore/monitor.h" |
| 64 | #include "MagickCore/montage.h" |
| 65 | #include "MagickCore/morphology.h" |
| 66 | #include "MagickCore/option.h" |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 67 | #include "MagickCore/option-private.h" |
cristy | ac73d1f | 2013-03-12 00:51:09 +0000 | [diff] [blame] | 68 | #include "MagickCore/pixel.h" |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 69 | #include "MagickCore/policy.h" |
| 70 | #include "MagickCore/property.h" |
| 71 | #include "MagickCore/quantize.h" |
| 72 | #include "MagickCore/quantum.h" |
| 73 | #include "MagickCore/resample.h" |
| 74 | #include "MagickCore/resource_.h" |
| 75 | #include "MagickCore/splay-tree.h" |
| 76 | #include "MagickCore/statistic.h" |
| 77 | #include "MagickCore/string_.h" |
| 78 | #include "MagickCore/token.h" |
| 79 | #include "MagickCore/utility.h" |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 80 | |
| 81 | /* |
| 82 | ImageMagick options. |
| 83 | */ |
| 84 | static const OptionInfo |
| 85 | AlignOptions[] = |
| 86 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 87 | { "Undefined", UndefinedAlign, UndefinedOptionFlag, MagickTrue }, |
| 88 | { "Center", CenterAlign, UndefinedOptionFlag, MagickFalse }, |
| 89 | { "End", RightAlign, UndefinedOptionFlag, MagickFalse }, |
| 90 | { "Left", LeftAlign, UndefinedOptionFlag, MagickFalse }, |
| 91 | { "Middle", CenterAlign, UndefinedOptionFlag, MagickFalse }, |
| 92 | { "Right", RightAlign, UndefinedOptionFlag, MagickFalse }, |
| 93 | { "Start", LeftAlign, UndefinedOptionFlag, MagickFalse }, |
| 94 | { (char *) NULL, UndefinedAlign, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 95 | }, |
cristy | 288a353 | 2012-08-28 00:19:44 +0000 | [diff] [blame] | 96 | AlphaChannelOptions[] = |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 97 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 98 | { "Undefined", UndefinedAlphaChannel, UndefinedOptionFlag, MagickTrue }, |
| 99 | { "Activate", ActivateAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 7894d4a | 2014-09-29 12:43:59 +0000 | [diff] [blame] | 100 | { "Associate", AssociateAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 101 | { "Background", BackgroundAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
| 102 | { "Copy", CopyAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
| 103 | { "Deactivate", DeactivateAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | dd00eb3 | 2014-10-01 13:11:19 +0000 | [diff] [blame] | 104 | { "Discrete", DiscreteAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 7894d4a | 2014-09-29 12:43:59 +0000 | [diff] [blame] | 105 | { "Disassociate", DisassociateAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 106 | { "Extract", ExtractAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 17f11b0 | 2014-12-20 19:37:04 +0000 | [diff] [blame] | 107 | { "Off", OffAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
| 108 | { "On", OnAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 109 | { "Opaque", OpaqueAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6180838 | 2012-01-30 01:24:49 +0000 | [diff] [blame] | 110 | { "Remove", RemoveAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 111 | { "Set", SetAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
| 112 | { "Shape", ShapeAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 1df692a | 2011-04-23 17:09:35 +0000 | [diff] [blame] | 113 | { "Reset", SetAlphaChannel, DeprecateOptionFlag, MagickTrue }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 114 | { "Transparent", TransparentAlphaChannel, UndefinedOptionFlag, MagickFalse }, |
| 115 | { (char *) NULL, UndefinedAlphaChannel, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 116 | }, |
| 117 | BooleanOptions[] = |
| 118 | { |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 119 | { "False", MagickFalse, UndefinedOptionFlag, MagickFalse }, |
| 120 | { "True", MagickTrue, UndefinedOptionFlag, MagickFalse }, |
| 121 | { "0", MagickFalse, UndefinedOptionFlag, MagickFalse }, |
| 122 | { "1", MagickTrue, UndefinedOptionFlag, MagickFalse }, |
| 123 | { (char *) NULL, MagickFalse, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 124 | }, |
cristy | 947cef2 | 2013-01-17 14:16:40 +0000 | [diff] [blame] | 125 | CacheOptions[] = |
| 126 | { |
| 127 | { "Disk", DiskCache, UndefinedOptionFlag, MagickFalse }, |
| 128 | { "Distributed", DistributedCache, UndefinedOptionFlag, MagickFalse }, |
| 129 | { "Map", MapCache, UndefinedOptionFlag, MagickFalse }, |
| 130 | { "Memory", MemoryCache, UndefinedOptionFlag, MagickFalse }, |
| 131 | { "Ping", PingCache, UndefinedOptionFlag, MagickFalse }, |
| 132 | { (char *) NULL, MagickFalse, UndefinedOptionFlag, MagickFalse } |
| 133 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 134 | ChannelOptions[] = |
| 135 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 136 | { "Undefined", UndefinedChannel, UndefinedOptionFlag, MagickTrue }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 137 | /* special */ |
cristy | 9a9230e | 2011-04-26 14:56:14 +0000 | [diff] [blame] | 138 | { "All", CompositeChannels, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 139 | { "Sync", SyncChannels, UndefinedOptionFlag, MagickFalse }, |
| 140 | { "Default", DefaultChannels, UndefinedOptionFlag, MagickFalse }, |
| 141 | /* individual channel */ |
| 142 | { "A", AlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 953c4bd | 2012-02-24 01:04:04 +0000 | [diff] [blame] | 143 | { "Alpha", AlphaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 144 | { "Black", BlackChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 145 | { "B", BlueChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 146 | { "Blue", BlueChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 147 | { "C", CyanChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 148 | { "Cyan", CyanChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 149 | { "Gray", GrayChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 150 | { "G", GreenChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 151 | { "Green", GreenChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 152 | { "H", RedChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 153 | { "Hue", RedChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 154 | { "K", BlackChannel, UndefinedOptionFlag, MagickFalse }, |
| 155 | { "L", BlueChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 156 | { "Lightness", BlueChannel, UndefinedOptionFlag, MagickFalse }, |
| 157 | { "Luminance", BlueChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 1df692a | 2011-04-23 17:09:35 +0000 | [diff] [blame] | 158 | { "Luminosity", BlueChannel, DeprecateOptionFlag, MagickTrue }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 159 | { "M", MagentaChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 160 | { "Magenta", MagentaChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 161 | { "Matte", AlphaChannel, DeprecateOptionFlag, MagickTrue },/*depreciate*/ |
| 162 | { "Opacity", AlphaChannel, DeprecateOptionFlag, MagickTrue },/*depreciate*/ |
| 163 | { "R", RedChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 164 | { "Red", RedChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 165 | { "S", GreenChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 166 | { "Saturation", GreenChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 167 | { "Y", YellowChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 168 | { "Yellow", YellowChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 169 | { (char *) NULL, UndefinedChannel, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 170 | }, |
| 171 | ClassOptions[] = |
| 172 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 173 | { "Undefined", UndefinedClass, UndefinedOptionFlag, MagickTrue }, |
| 174 | { "DirectClass", DirectClass, UndefinedOptionFlag, MagickFalse }, |
| 175 | { "PseudoClass", PseudoClass, UndefinedOptionFlag, MagickFalse }, |
| 176 | { (char *) NULL, UndefinedClass, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 177 | }, |
| 178 | ClipPathOptions[] = |
| 179 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 180 | { "Undefined", UndefinedPathUnits, UndefinedOptionFlag, MagickTrue }, |
| 181 | { "ObjectBoundingBox", ObjectBoundingBox, UndefinedOptionFlag, MagickFalse }, |
| 182 | { "UserSpace", UserSpace, UndefinedOptionFlag, MagickFalse }, |
| 183 | { "UserSpaceOnUse", UserSpaceOnUse, UndefinedOptionFlag, MagickFalse }, |
| 184 | { (char *) NULL, UndefinedPathUnits, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 185 | }, |
| 186 | CommandOptions[] = |
| 187 | { |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 188 | /* |
| 189 | Must be ordered lexigraphically. |
| 190 | */ |
cristy | 6e64895 | 2014-09-16 23:28:18 +0000 | [diff] [blame] | 191 | { "+alpha", 1L, DeprecateOptionFlag, MagickTrue }, |
| 192 | { "-alpha", 1L, SimpleOperatorFlag, MagickFalse }, |
| 193 | { "+background", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 194 | { "-background", 1L, ImageInfoOptionFlag, MagickFalse }, |
| 195 | { "+format", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 196 | { "-format", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 197 | { "-quiet", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse }, |
| 198 | { "+quiet", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse }, |
| 199 | { "-regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 200 | { "+regard-warnings", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 201 | { "+repage", 0L, SimpleOperatorFlag, MagickFalse }, |
| 202 | { "-repage", 1L, SimpleOperatorFlag, MagickFalse }, |
| 203 | { "+size", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 204 | { "-size", 1L, ImageInfoOptionFlag, MagickFalse }, |
| 205 | { "+virtual-pixel", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 206 | { "-virtual-pixel", 1L, ImageInfoOptionFlag, MagickFalse }, |
| 207 | { "+blur", 0L, DeprecateOptionFlag, MagickTrue }, |
| 208 | { "-blur", 1L, SimpleOperatorFlag, MagickFalse }, |
| 209 | { "+resize", 1L, DeprecateOptionFlag, MagickTrue }, |
| 210 | { "-resize", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 211 | { "(", 0L, NoImageOperatorFlag, MagickTrue }, |
| 212 | { ")", 0L, NoImageOperatorFlag, MagickTrue }, |
| 213 | { "{", 0L, NoImageOperatorFlag, MagickTrue }, |
| 214 | { "}", 0L, NoImageOperatorFlag, MagickTrue }, |
| 215 | { "--", 1L, NoImageOperatorFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 216 | { "+adaptive-blur", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 217 | { "-adaptive-blur", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 218 | { "+adaptive-resize", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 219 | { "-adaptive-resize", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 220 | { "+adaptive-sharpen", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 221 | { "-adaptive-sharpen", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 222 | { "-adjoin", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 223 | { "+adjoin", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 975a8d7 | 2012-04-12 13:54:36 +0000 | [diff] [blame] | 224 | { "+affine", 0L, ReplacedOptionFlag | DrawInfoOptionFlag, MagickTrue }, |
| 225 | { "-affine", 1L, ReplacedOptionFlag | DrawInfoOptionFlag, MagickTrue }, |
anthony | 31f1bf7 | 2012-01-30 12:37:22 +0000 | [diff] [blame] | 226 | { "+affinity", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 227 | { "-affinity", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 228 | { "+annotate", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 964d28e | 2012-05-17 23:39:46 +0000 | [diff] [blame] | 229 | { "-annotate", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 230 | { "-antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 231 | { "+antialias", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 232 | { "-append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 233 | { "+append", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 234 | { "+attenuate", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 92c93bd | 2012-03-19 14:02:47 +0000 | [diff] [blame] | 235 | { "-attenuate", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 236 | { "+authenticate", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 237 | { "-authenticate", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 238 | { "+auto-gamma", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 239 | { "-auto-gamma", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 240 | { "+auto-level", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 241 | { "-auto-level", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 242 | { "+auto-orient", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 243 | { "-auto-orient", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 975a8d7 | 2012-04-12 13:54:36 +0000 | [diff] [blame] | 244 | { "+average", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 245 | { "-average", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 246 | { "+backdrop", 0L, NonMagickOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 247 | { "-backdrop", 1L, NonMagickOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 8226e72 | 2012-04-05 14:25:46 +0000 | [diff] [blame] | 248 | { "+bench", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 9a6469e | 2011-05-04 11:07:31 +0000 | [diff] [blame] | 249 | { "-bench", 1L, GenesisOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 250 | { "+bias", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 251 | { "-bias", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 252 | { "-black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 253 | { "+black-point-compensation", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 254 | { "+black-threshold", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 255 | { "-black-threshold", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 256 | { "+blend", 0L, NonMagickOptionFlag, MagickFalse }, |
| 257 | { "-blend", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 258 | { "+blue-primary", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 259 | { "-blue-primary", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 260 | { "-blue-shift", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 261 | { "+blue-shift", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 262 | { "+border", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 263 | { "-border", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 264 | { "+bordercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 265 | { "-bordercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 266 | { "+borderwidth", 0L, NonMagickOptionFlag, MagickFalse }, |
| 267 | { "-borderwidth", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 975a8d7 | 2012-04-12 13:54:36 +0000 | [diff] [blame] | 268 | { "+box", 0L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue }, |
| 269 | { "-box", 1L, ReplacedOptionFlag | ImageInfoOptionFlag | DrawInfoOptionFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 270 | { "+brightness-contrast", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 271 | { "-brightness-contrast", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 272 | { "+cache", 0L, GlobalOptionFlag, MagickFalse }, |
| 273 | { "-cache", 1L, GlobalOptionFlag, MagickFalse }, |
cristy | 2fc10e5 | 2014-04-26 14:13:53 +0000 | [diff] [blame] | 274 | { "+canny", 1L, DeprecateOptionFlag, MagickTrue }, |
cristy | bd7d96a | 2014-04-19 20:27:43 +0000 | [diff] [blame] | 275 | { "-canny", 1L, SimpleOperatorFlag, MagickTrue }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 276 | { "+caption", 0L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 277 | { "-caption", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 278 | { "+cdl", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 279 | { "-cdl", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
cristy | 17ada02 | 2014-11-07 22:12:23 +0000 | [diff] [blame] | 280 | { "+channel", 0L, SimpleOperatorFlag, MagickFalse }, |
| 281 | { "-channel", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 282 | { "-channel-fx", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | f57e548 | 2013-02-17 22:11:27 +0000 | [diff] [blame] | 283 | { "+charcoal", 1L, DeprecateOptionFlag, MagickTrue }, |
| 284 | { "-charcoal", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 285 | { "+chop", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 286 | { "-chop", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 287 | { "+clamp", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 288 | { "-clamp", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 289 | { "-clip", 0L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 290 | { "+clip", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 291 | { "+clip-mask", 0L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 292 | { "-clip-mask", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 293 | { "-clip-path", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 294 | { "+clip-path", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 295 | { "+clone", 0L, NoImageOperatorFlag, MagickFalse }, |
| 296 | { "-clone", 1L, NoImageOperatorFlag, MagickFalse }, |
anthony | 9401275 | 2012-03-06 04:14:34 +0000 | [diff] [blame] | 297 | { "+clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 298 | { "-clut", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 9401275 | 2012-03-06 04:14:34 +0000 | [diff] [blame] | 299 | { "+coalesce", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 300 | { "-coalesce", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 301 | { "+colorize", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 302 | { "-colorize", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 303 | { "+colormap", 0L, NonMagickOptionFlag, MagickFalse }, |
| 304 | { "-colormap", 1L, NonMagickOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 305 | { "+color-matrix", 1L, DeprecateOptionFlag, MagickTrue }, |
| 306 | { "-color-matrix", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 307 | { "+colors", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 308 | { "-colors", 1L, SimpleOperatorFlag, MagickFalse }, |
| 309 | { "+colorspace", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
| 310 | { "-colorspace", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
anthony | 5a4ff37 | 2013-05-01 04:48:57 +0000 | [diff] [blame] | 311 | { "-combine", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 312 | { "+combine", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 313 | { "+comment", 0L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 314 | { "-comment", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
cristy | a111cac | 2013-08-20 00:30:49 +0000 | [diff] [blame] | 315 | { "+compare", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
| 316 | { "-compare", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | 34919ed | 2013-10-06 15:42:40 +0000 | [diff] [blame] | 317 | { "+complex", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
cristy | 1141c85 | 2013-10-04 15:17:30 +0000 | [diff] [blame] | 318 | { "-complex", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 319 | { "+compose", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 320 | { "-compose", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 9401275 | 2012-03-06 04:14:34 +0000 | [diff] [blame] | 321 | { "+composite", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 322 | { "-composite", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 323 | { "+compress", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 324 | { "-compress", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 8226e72 | 2012-04-05 14:25:46 +0000 | [diff] [blame] | 325 | { "+concurrent", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | ebb73a2 | 2012-03-22 14:25:52 +0000 | [diff] [blame] | 326 | { "-concurrent", 0L, GenesisOptionFlag, MagickFalse }, |
cristy | bb93b80 | 2014-10-25 13:32:45 +0000 | [diff] [blame] | 327 | { "+connected-components", 1L, DeprecateOptionFlag, MagickTrue }, |
| 328 | { "-connected-components", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 329 | { "-contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 330 | { "+contrast", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 331 | { "+contrast-stretch", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 332 | { "-contrast-stretch", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 333 | { "+convolve", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 334 | { "-convolve", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | 3476df8 | 2015-06-22 18:43:46 +0000 | [diff] [blame] | 335 | { "+copy", 2L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
| 336 | { "-copy", 2L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 337 | { "+crop", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 338 | { "-crop", 1L, SimpleOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 339 | { "+cycle", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 340 | { "-cycle", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 8226e72 | 2012-04-05 14:25:46 +0000 | [diff] [blame] | 341 | { "+debug", 0L, GlobalOptionFlag | FireOptionFlag, MagickFalse }, |
| 342 | { "-debug", 1L, GlobalOptionFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 343 | { "+decipher", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 344 | { "-decipher", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 31f1bf7 | 2012-01-30 12:37:22 +0000 | [diff] [blame] | 345 | { "+deconstruct", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 346 | { "-deconstruct", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue }, |
anthony | a322a83 | 2013-04-27 06:28:03 +0000 | [diff] [blame] | 347 | { "-define", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 348 | { "+define", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse }, |
anthony | fd706f9 | 2012-01-19 04:22:02 +0000 | [diff] [blame] | 349 | { "+delay", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 350 | { "-delay", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 351 | { "+delete", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
| 352 | { "-delete", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 353 | { "+density", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 354 | { "-density", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 355 | { "+depth", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
| 356 | { "-depth", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 357 | { "+descend", 0L, NonMagickOptionFlag, MagickFalse }, |
| 358 | { "-descend", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 359 | { "+deskew", 0L, SimpleOperatorFlag, MagickFalse }, |
| 360 | { "-deskew", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 361 | { "+despeckle", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 362 | { "-despeckle", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 363 | { "+direction", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 364 | { "-direction", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 365 | { "+displace", 0L, NonMagickOptionFlag, MagickFalse }, |
| 366 | { "-displace", 1L, NonMagickOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 367 | { "-display", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 368 | { "+display", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 369 | { "+dispose", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 370 | { "-dispose", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | b1d483a | 2012-04-14 12:53:56 +0000 | [diff] [blame] | 371 | { "+dissimilarity-threshold", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
| 372 | { "-dissimilarity-threshold", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 373 | { "+dissolve", 0L, NonMagickOptionFlag, MagickFalse }, |
| 374 | { "-dissolve", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 964d28e | 2012-05-17 23:39:46 +0000 | [diff] [blame] | 375 | { "-distort", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 376 | { "+distort", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 377 | { "+dither", 0L, ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse }, |
| 378 | { "-dither", 1L, ImageInfoOptionFlag | QuantizeInfoOptionFlag, MagickFalse }, |
anthony | fd706f9 | 2012-01-19 04:22:02 +0000 | [diff] [blame] | 379 | { "+draw", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 380 | { "-draw", 1L, SimpleOperatorFlag, MagickFalse }, |
| 381 | { "+duplicate", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
| 382 | { "-duplicate", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 9a6469e | 2011-05-04 11:07:31 +0000 | [diff] [blame] | 383 | { "-duration", 1L, GenesisOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 384 | { "+duration", 1L, GenesisOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 385 | { "+edge", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 386 | { "-edge", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 387 | { "+emboss", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 388 | { "-emboss", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 389 | { "+encipher", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 390 | { "-encipher", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 391 | { "+encoding", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 392 | { "-encoding", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 393 | { "+endian", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 394 | { "-endian", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 395 | { "+enhance", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 396 | { "-enhance", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 397 | { "+equalize", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 398 | { "-equalize", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 399 | { "+evaluate", 2L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 400 | { "-evaluate", 2L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 401 | { "+evaluate-sequence", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 402 | { "-evaluate-sequence", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 403 | { "-exit", 0L, SpecialOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 404 | { "+extent", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 405 | { "-extent", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 406 | { "+extract", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 407 | { "-extract", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 408 | { "+family", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | b0d5270 | 2011-05-02 03:34:24 +0000 | [diff] [blame] | 409 | { "-family", 1L, DrawInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 410 | { "+features", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse }, |
| 411 | { "-features", 1L, SimpleOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 412 | { "-fft", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 413 | { "+fft", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 414 | { "+fill", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 415 | { "-fill", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 416 | { "+filter", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 417 | { "-filter", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 31f1bf7 | 2012-01-30 12:37:22 +0000 | [diff] [blame] | 418 | { "+flatten", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 419 | { "-flatten", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 420 | { "+flip", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 421 | { "-flip", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 422 | { "-floodfill", 2L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 423 | { "+floodfill", 2L, SimpleOperatorFlag, MagickFalse }, |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 424 | { "+flop", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 425 | { "-flop", 0L, SimpleOperatorFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 426 | { "+font", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 427 | { "-font", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 428 | { "+foreground", 0L, NonMagickOptionFlag, MagickFalse }, |
| 429 | { "-foreground", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 430 | { "+frame", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 431 | { "-frame", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | fd706f9 | 2012-01-19 04:22:02 +0000 | [diff] [blame] | 432 | { "+function", 2L, DeprecateOptionFlag, MagickTrue }, |
anthony | 964d28e | 2012-05-17 23:39:46 +0000 | [diff] [blame] | 433 | { "-function", 2L,SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 434 | { "+fuzz", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 435 | { "-fuzz", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 436 | { "+fx", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 437 | { "-fx", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 438 | { "-gamma", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 439 | { "+gamma", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 440 | { "+gaussian", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 441 | { "-gaussian", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 442 | { "+gaussian-blur", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 443 | { "-gaussian-blur", 1L, SimpleOperatorFlag, MagickFalse }, |
| 444 | { "+geometry", 0L, SimpleOperatorFlag, MagickFalse }, |
| 445 | { "-geometry", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 446 | { "+gravity", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 447 | { "-gravity", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 448 | { "+grayscale", 1L, SimpleOperatorFlag, MagickTrue }, |
cristy | 17ada02 | 2014-11-07 22:12:23 +0000 | [diff] [blame] | 449 | { "-grayscale", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 450 | { "+green-primary", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 451 | { "-green-primary", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 452 | { "+hald-clut", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 453 | { "-hald-clut", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | b1d483a | 2012-04-14 12:53:56 +0000 | [diff] [blame] | 454 | { "+highlight-color", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
| 455 | { "-highlight-color", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
cristy | 2fc10e5 | 2014-04-26 14:13:53 +0000 | [diff] [blame] | 456 | { "+hough-lines", 1L, DeprecateOptionFlag, MagickTrue }, |
cristy | bd7d96a | 2014-04-19 20:27:43 +0000 | [diff] [blame] | 457 | { "-hough-lines", 1L, SimpleOperatorFlag, MagickTrue }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 458 | { "+iconGeometry", 0L, NonMagickOptionFlag, MagickFalse }, |
| 459 | { "-iconGeometry", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | a322a83 | 2013-04-27 06:28:03 +0000 | [diff] [blame] | 460 | { "-iconic", 0L, NonMagickOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 461 | { "+iconic", 0L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 462 | { "+identify", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 463 | { "-identify", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 464 | { "-ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 465 | { "+ift", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 466 | { "-immutable", 0L, NonMagickOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 467 | { "+immutable", 0L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 468 | { "+implode", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 469 | { "-implode", 1L, SimpleOperatorFlag, MagickFalse }, |
| 470 | { "+insert", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
| 471 | { "-insert", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | a14c512 | 2013-03-15 10:42:52 +0000 | [diff] [blame] | 472 | { "+intensity", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 473 | { "-intensity", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 474 | { "+intent", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 475 | { "-intent", 1L, ImageInfoOptionFlag, MagickFalse }, |
| 476 | { "+interlace", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 477 | { "-interlace", 1L, ImageInfoOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 478 | { "+interline-spacing", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 479 | { "-interline-spacing", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 480 | { "+interpolate", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 481 | { "-interpolate", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | fd706f9 | 2012-01-19 04:22:02 +0000 | [diff] [blame] | 482 | { "+interpolative-resize", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 483 | { "-interpolative-resize", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 484 | { "+interword-spacing", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 485 | { "-interword-spacing", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 486 | { "+kerning", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 487 | { "-kerning", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | 3b207f8 | 2014-09-27 14:21:20 +0000 | [diff] [blame] | 488 | { "+kuwahara", 0L, DeprecateOptionFlag, MagickTrue }, |
| 489 | { "-kuwahara", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 490 | { "+label", 0L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 491 | { "-label", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 492 | { "+lat", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 493 | { "-lat", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 494 | { "+layers", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 495 | { "-layers", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 496 | { "-level", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 497 | { "+level", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 498 | { "-level-colors", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 499 | { "+level-colors", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 500 | { "+limit", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | ea068a5 | 2012-04-09 05:46:25 +0000 | [diff] [blame] | 501 | { "-limit", 2L, GlobalOptionFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 502 | { "+linear-stretch", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 503 | { "-linear-stretch", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 504 | { "+liquid-rescale", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 505 | { "-liquid-rescale", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 506 | { "+list", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 507 | { "-list", 1L, NoImageOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 508 | { "+log", 0L, DeprecateOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 509 | { "-log", 1L, GlobalOptionFlag, MagickFalse }, |
| 510 | { "+loop", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 511 | { "-loop", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | b1d483a | 2012-04-14 12:53:56 +0000 | [diff] [blame] | 512 | { "+lowlight-color", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
| 513 | { "-lowlight-color", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
cristy | 7220ee4 | 2013-04-14 01:30:34 +0000 | [diff] [blame] | 514 | { "+magnify", 0L, DeprecateOptionFlag, MagickTrue }, |
| 515 | { "-magnify", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 516 | { "+map", 0L, ReplacedOptionFlag | ListOperatorFlag | FireOptionFlag, MagickTrue }, |
| 517 | { "-map", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
cristy | 327030c | 2015-07-25 18:05:50 +0000 | [diff] [blame] | 518 | { "+mask", 0L, DeprecateOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 519 | { "-mask", 1L, DeprecateOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 520 | { "-matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 521 | { "+matte", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 522 | { "+mattecolor", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 523 | { "-mattecolor", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 524 | { "-maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 525 | { "+maximum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
cristy | 2fc10e5 | 2014-04-26 14:13:53 +0000 | [diff] [blame] | 526 | { "+mean-shift", 1L, DeprecateOptionFlag, MagickTrue }, |
| 527 | { "-mean-shift", 1L, SimpleOperatorFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 528 | { "+median", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 529 | { "-median", 1L, ReplacedOptionFlag | SimpleOperatorFlag | FireOptionFlag, MagickTrue }, |
cristy | 6c8baa7 | 2013-08-20 00:39:06 +0000 | [diff] [blame] | 530 | { "+metric", 0L, DeprecateOptionFlag | FireOptionFlag, MagickFalse }, |
| 531 | { "-metric", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 532 | { "-minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 533 | { "+minimum", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 534 | { "+mode", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 535 | { "-mode", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 536 | { "+modulate", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 537 | { "-modulate", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 538 | { "-moments", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse }, |
| 539 | { "+moments", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 540 | { "-monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 541 | { "+monitor", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 542 | { "+monochrome", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 543 | { "-monochrome", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 544 | { "+morph", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 545 | { "-morph", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 546 | { "+morphology", 2L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 547 | { "-morphology", 2L, SimpleOperatorFlag, MagickFalse }, |
anthony | 31f1bf7 | 2012-01-30 12:37:22 +0000 | [diff] [blame] | 548 | { "+mosaic", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 549 | { "-mosaic", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 550 | { "+motion-blur", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 551 | { "-motion-blur", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 552 | { "+name", 0L, NonMagickOptionFlag, MagickFalse }, |
| 553 | { "-name", 1L, NonMagickOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 554 | { "+negate", 0L, SimpleOperatorFlag, MagickFalse }, |
cristy | 17ada02 | 2014-11-07 22:12:23 +0000 | [diff] [blame] | 555 | { "-negate", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 556 | { "-noise", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 557 | { "+noise", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 558 | { "-noop", 0L, NoImageOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 559 | { "+normalize", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 560 | { "-normalize", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 561 | { "-opaque", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 562 | { "+opaque", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 563 | { "+ordered-dither", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 564 | { "-ordered-dither", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 565 | { "+orient", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 566 | { "-orient", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 567 | { "+page", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 568 | { "-page", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 569 | { "+paint", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 570 | { "-paint", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 571 | { "+path", 0L, NonMagickOptionFlag, MagickFalse }, |
| 572 | { "-path", 1L, NonMagickOptionFlag, MagickFalse }, |
| 573 | { "+pause", 0L, NonMagickOptionFlag, MagickFalse }, |
| 574 | { "-pause", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 575 | { "-ping", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 576 | { "+ping", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 577 | { "+pointsize", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 578 | { "-pointsize", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 579 | { "+polaroid", 0L, SimpleOperatorFlag, MagickFalse }, |
| 580 | { "-polaroid", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | f56e6ad | 2012-11-11 19:29:38 +0000 | [diff] [blame] | 581 | { "+poly", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
| 582 | { "-poly", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 583 | { "+posterize", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 584 | { "-posterize", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | a3ef4ed | 2012-03-17 06:52:53 +0000 | [diff] [blame] | 585 | { "+precision", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 586 | { "-precision", 1L, ImageInfoOptionFlag, MagickFalse }, |
| 587 | { "+preview", 0L, DeprecateOptionFlag, MagickTrue }, |
| 588 | { "-preview", 1L, GlobalOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 589 | { "+print", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | a322a83 | 2013-04-27 06:28:03 +0000 | [diff] [blame] | 590 | { "-print", 1L, NoImageOperatorFlag | AlwaysInterpretArgsFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 591 | { "+process", 1L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 592 | { "-process", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
| 593 | { "+profile", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 594 | { "-profile", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 595 | { "+quality", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 596 | { "-quality", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | b0d5270 | 2011-05-02 03:34:24 +0000 | [diff] [blame] | 597 | { "+quantize", 0L, QuantizeInfoOptionFlag, MagickFalse }, |
| 598 | { "-quantize", 1L, QuantizeInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 599 | { "-raise", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 600 | { "+raise", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 601 | { "+random-threshold", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 602 | { "-random-threshold", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 603 | { "-read", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
cristy | 327030c | 2015-07-25 18:05:50 +0000 | [diff] [blame] | 604 | { "+read-mask", 0L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 605 | { "-read-mask", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 606 | { "+recolor", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 607 | { "-recolor", 1L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 608 | { "+red-primary", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 609 | { "-red-primary", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 610 | { "+region", 0L, NoImageOperatorFlag, MagickFalse }, |
| 611 | { "-region", 1L, NoImageOperatorFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 612 | { "+remap", 0L, ListOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse }, |
| 613 | { "-remap", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 614 | { "+remote", 0L, NonMagickOptionFlag, MagickFalse }, |
| 615 | { "-remote", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | b0d5270 | 2011-05-02 03:34:24 +0000 | [diff] [blame] | 616 | { "-render", 0L, DrawInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 617 | { "+render", 0L, DrawInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 618 | { "+resample", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 619 | { "-resample", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | d111fda | 2012-04-13 03:07:40 +0000 | [diff] [blame] | 620 | { "-respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 621 | { "+respect-parenthesis", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 622 | { "+reverse", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 623 | { "-reverse", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 624 | { "+roll", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 625 | { "-roll", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 626 | { "+rotate", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 627 | { "-rotate", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 628 | { "-rotational-blur", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 629 | { "+sample", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 630 | { "-sample", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 631 | { "+sampling-factor", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 632 | { "-sampling-factor", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 633 | { "-sans0", 0L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 634 | { "+sans0", 0L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, /* equivelent to 'noop' */ |
anthony | 0da1e9c | 2012-11-17 05:28:22 +0000 | [diff] [blame] | 635 | { "+sans1", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, |
| 636 | { "-sans1", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, /* equivelent to 'sans' */ |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 637 | { "-sans", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, |
| 638 | { "+sans", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 639 | { "-sans2", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 640 | { "+sans2", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickTrue }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 641 | { "+scale", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 642 | { "-scale", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 643 | { "+scene", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 644 | { "-scene", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 645 | { "+scenes", 0L, NonMagickOptionFlag, MagickFalse }, |
| 646 | { "-scenes", 1L, NonMagickOptionFlag, MagickFalse }, |
| 647 | { "+screen", 0L, NonMagickOptionFlag, MagickFalse }, |
| 648 | { "-screen", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 649 | { "-script", 1L, SpecialOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 650 | { "+seed", 0L, GlobalOptionFlag, MagickFalse }, |
| 651 | { "-seed", 1L, GlobalOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 652 | { "+segment", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 653 | { "-segment", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 654 | { "+selective-blur", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 655 | { "-selective-blur", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 656 | { "+separate", 0L, DeprecateOptionFlag | FireOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 657 | { "-separate", 0L, SimpleOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 658 | { "+sepia-tone", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 659 | { "-sepia-tone", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | a322a83 | 2013-04-27 06:28:03 +0000 | [diff] [blame] | 660 | { "+set", 1L, NoImageOperatorFlag, MagickFalse }, |
anthony | 0da1e9c | 2012-11-17 05:28:22 +0000 | [diff] [blame] | 661 | { "-set", 2L, NoImageOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 662 | { "+shade", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 663 | { "-shade", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 664 | { "+shadow", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 665 | { "-shadow", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 666 | { "+shared-memory", 0L, NonMagickOptionFlag, MagickFalse }, |
| 667 | { "-shared-memory", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 668 | { "+sharpen", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 669 | { "-sharpen", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 670 | { "+shave", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 671 | { "-shave", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 672 | { "+shear", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 673 | { "-shear", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 674 | { "-sigmoidal-contrast", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 675 | { "+sigmoidal-contrast", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 676 | { "+silent", 0L, NonMagickOptionFlag, MagickFalse }, |
| 677 | { "-silent", 1L, NonMagickOptionFlag, MagickFalse }, |
cristy | 62e5218 | 2013-03-15 14:26:17 +0000 | [diff] [blame] | 678 | { "+similarity-threshold", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
| 679 | { "-similarity-threshold", 1L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 680 | { "+sketch", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 681 | { "-sketch", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 682 | { "-smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 683 | { "+smush", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 684 | { "+snaps", 0L, NonMagickOptionFlag, MagickFalse }, |
| 685 | { "-snaps", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 686 | { "+solarize", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 687 | { "-solarize", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | b1d483a | 2012-04-14 12:53:56 +0000 | [diff] [blame] | 688 | { "+sparse-color", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 964d28e | 2012-05-17 23:39:46 +0000 | [diff] [blame] | 689 | { "-sparse-color", 2L, SimpleOperatorFlag | AlwaysInterpretArgsFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 690 | { "+splice", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 691 | { "-splice", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 692 | { "+spread", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 693 | { "-spread", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 694 | { "+statistic", 2L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 695 | { "-statistic", 2L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 696 | { "+stegano", 0L, NonMagickOptionFlag, MagickFalse }, |
| 697 | { "-stegano", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 698 | { "+stereo", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 699 | { "-stereo", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 700 | { "+stretch", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 701 | { "-stretch", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 702 | { "+strip", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 703 | { "-strip", 0L, SimpleOperatorFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 704 | { "+stroke", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
| 705 | { "-stroke", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 706 | { "-strokewidth", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 707 | { "+strokewidth", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | b0d5270 | 2011-05-02 03:34:24 +0000 | [diff] [blame] | 708 | { "+style", 0L, DrawInfoOptionFlag, MagickFalse }, |
| 709 | { "-style", 1L, DrawInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 710 | { "-subimage", 0L, ListOperatorFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 711 | { "-subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
| 712 | { "+subimage-search", 0L, NonMagickOptionFlag | ImageInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 713 | { "+swap", 0L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
| 714 | { "-swap", 1L, ListOperatorFlag | FireOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 715 | { "+swirl", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 716 | { "-swirl", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 717 | { "-synchronize", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 718 | { "+synchronize", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 719 | { "-taint", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 720 | { "+taint", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 721 | { "+text-font", 0L, NonMagickOptionFlag, MagickFalse }, |
| 722 | { "-text-font", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 723 | { "+texture", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 724 | { "-texture", 1L, ImageInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 725 | { "+threshold", 0L, SimpleOperatorFlag, MagickFalse }, |
| 726 | { "-threshold", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 727 | { "+thumbnail", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 728 | { "-thumbnail", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 729 | { "+tile", 0L, DrawInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 730 | { "-tile", 1L, DrawInfoOptionFlag | NeverInterpretArgsFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 731 | { "+tile-offset", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 732 | { "-tile-offset", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 733 | { "-tint", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 734 | { "+tint", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 735 | { "+title", 0L, NonMagickOptionFlag, MagickFalse }, |
| 736 | { "-title", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 737 | { "+transform", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 738 | { "-transform", 0L, ReplacedOptionFlag | SimpleOperatorFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 739 | { "-transparent", 1L, SimpleOperatorFlag, MagickFalse }, |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 740 | { "+transparent", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | b1d483a | 2012-04-14 12:53:56 +0000 | [diff] [blame] | 741 | { "+transparent-color", 0L, ImageInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 742 | { "-transparent-color", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 743 | { "+transpose", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 744 | { "-transpose", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 745 | { "+transverse", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 746 | { "-transverse", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 747 | { "+treedepth", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | b0d5270 | 2011-05-02 03:34:24 +0000 | [diff] [blame] | 748 | { "-treedepth", 1L, QuantizeInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 749 | { "+trim", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 750 | { "-trim", 0L, SimpleOperatorFlag, MagickFalse }, |
| 751 | { "+type", 0L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
| 752 | { "-type", 1L, ImageInfoOptionFlag | SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 753 | { "+undercolor", 0L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
cristy | a79a348 | 2011-05-03 17:14:22 +0000 | [diff] [blame] | 754 | { "-undercolor", 1L, ImageInfoOptionFlag | DrawInfoOptionFlag, MagickFalse }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 755 | { "-unique", 0L, SimpleOperatorFlag, MagickFalse }, |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 756 | { "+unique", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 757 | { "+unique-colors", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 758 | { "-unique-colors", 0L, SimpleOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 759 | { "+units", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 760 | { "-units", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 761 | { "+unsharp", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 762 | { "-unsharp", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 763 | { "+update", 0L, NonMagickOptionFlag, MagickFalse }, |
| 764 | { "-update", 1L, NonMagickOptionFlag, MagickFalse }, |
| 765 | { "+use-pixmap", 0L, NonMagickOptionFlag, MagickFalse }, |
| 766 | { "-use-pixmap", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | b0d5270 | 2011-05-02 03:34:24 +0000 | [diff] [blame] | 767 | { "-verbose", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 768 | { "+verbose", 0L, ImageInfoOptionFlag, MagickFalse }, |
cristy | c404ff6 | 2012-02-05 15:17:09 +0000 | [diff] [blame] | 769 | { "+version", 0L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 770 | { "-version", 0L, NoImageOperatorFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 771 | { "+view", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 772 | { "-view", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 773 | { "+vignette", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 774 | { "-vignette", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 775 | { "+visual", 0L, NonMagickOptionFlag, MagickFalse }, |
| 776 | { "-visual", 1L, NonMagickOptionFlag, MagickFalse }, |
| 777 | { "+watermark", 0L, NonMagickOptionFlag, MagickFalse }, |
| 778 | { "-watermark", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 779 | { "+wave", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 780 | { "-wave", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 781 | { "+weight", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | b0d5270 | 2011-05-02 03:34:24 +0000 | [diff] [blame] | 782 | { "-weight", 1L, DrawInfoOptionFlag, MagickFalse }, |
anthony | de1a57f | 2011-05-02 09:45:30 +0000 | [diff] [blame] | 783 | { "+white-point", 0L, ImageInfoOptionFlag, MagickFalse }, |
| 784 | { "-white-point", 1L, ImageInfoOptionFlag, MagickFalse }, |
anthony | 72feaa6 | 2012-01-17 06:46:23 +0000 | [diff] [blame] | 785 | { "+white-threshold", 1L, DeprecateOptionFlag, MagickTrue }, |
anthony | 464f1c4 | 2012-04-22 08:51:01 +0000 | [diff] [blame] | 786 | { "-white-threshold", 1L, SimpleOperatorFlag, MagickFalse }, |
anthony | 668f43a | 2012-02-20 14:55:32 +0000 | [diff] [blame] | 787 | { "+window", 0L, NonMagickOptionFlag, MagickFalse }, |
| 788 | { "-window", 1L, NonMagickOptionFlag, MagickFalse }, |
| 789 | { "+window-group", 0L, NonMagickOptionFlag, MagickFalse }, |
| 790 | { "-window-group", 1L, NonMagickOptionFlag, MagickFalse }, |
anthony | 4837ac2 | 2012-05-18 23:39:48 +0000 | [diff] [blame] | 791 | { "-write", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse }, |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 792 | { "+write", 1L, NoImageOperatorFlag | NeverInterpretArgsFlag | FireOptionFlag, MagickFalse }, |
cristy | 327030c | 2015-07-25 18:05:50 +0000 | [diff] [blame] | 793 | { "+write-mask", 0L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
| 794 | { "-write-mask", 1L, SimpleOperatorFlag | NeverInterpretArgsFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 795 | { (char *) NULL, 0L, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 796 | }, |
| 797 | ComposeOptions[] = |
| 798 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 799 | { "Undefined", UndefinedCompositeOp, UndefinedOptionFlag, MagickTrue }, |
| 800 | { "Atop", AtopCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 801 | { "Blend", BlendCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 802 | { "Blur", BlurCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 803 | { "Bumpmap", BumpmapCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 804 | { "ChangeMask", ChangeMaskCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 805 | { "Clear", ClearCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 806 | { "ColorBurn", ColorBurnCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 807 | { "ColorDodge", ColorDodgeCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 808 | { "Colorize", ColorizeCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | e4a4047 | 2011-12-22 02:56:19 +0000 | [diff] [blame] | 809 | { "CopyAlpha", CopyAlphaCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 810 | { "CopyBlack", CopyBlackCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 811 | { "CopyBlue", CopyBlueCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 812 | { "CopyCyan", CopyCyanCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 813 | { "CopyGreen", CopyGreenCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 814 | { "Copy", CopyCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 815 | { "CopyMagenta", CopyMagentaCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 816 | { "CopyRed", CopyRedCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 817 | { "CopyYellow", CopyYellowCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 818 | { "Darken", DarkenCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 819 | { "DarkenIntensity", DarkenIntensityCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 820 | { "DivideDst", DivideDstCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 821 | { "DivideSrc", DivideSrcCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 822 | { "Dst", DstCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 823 | { "Difference", DifferenceCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 824 | { "Displace", DisplaceCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 825 | { "Dissolve", DissolveCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 826 | { "Distort", DistortCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 827 | { "DstAtop", DstAtopCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 828 | { "DstIn", DstInCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 829 | { "DstOut", DstOutCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 830 | { "DstOver", DstOverCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 831 | { "Exclusion", ExclusionCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 832 | { "HardLight", HardLightCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 99fc217 | 2014-06-26 10:30:53 +0000 | [diff] [blame] | 833 | { "HardMix", HardMixCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 834 | { "Hue", HueCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 835 | { "In", InCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 9862146 | 2011-12-31 22:31:11 +0000 | [diff] [blame] | 836 | { "Intensity", IntensityCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 837 | { "Lighten", LightenCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 838 | { "LightenIntensity", LightenIntensityCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 839 | { "LinearBurn", LinearBurnCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 840 | { "LinearDodge", LinearDodgeCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 841 | { "LinearLight", LinearLightCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 842 | { "Luminize", LuminizeCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 843 | { "Mathematics", MathematicsCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 844 | { "MinusDst", MinusDstCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 845 | { "MinusSrc", MinusSrcCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 846 | { "Modulate", ModulateCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 847 | { "ModulusAdd", ModulusAddCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 848 | { "ModulusSubtract", ModulusSubtractCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 849 | { "Multiply", MultiplyCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 850 | { "None", NoCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 851 | { "Out", OutCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 852 | { "Overlay", OverlayCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 853 | { "Over", OverCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 854 | { "PegtopLight", PegtopLightCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 855 | { "PinLight", PinLightCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 856 | { "Plus", PlusCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 857 | { "Replace", ReplaceCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 858 | { "Saturate", SaturateCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 859 | { "Screen", ScreenCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 860 | { "SoftLight", SoftLightCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 861 | { "Src", SrcCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 862 | { "SrcAtop", SrcAtopCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 863 | { "SrcIn", SrcInCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 864 | { "SrcOut", SrcOutCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 865 | { "SrcOver", SrcOverCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 866 | { "VividLight", VividLightCompositeOp, UndefinedOptionFlag, MagickFalse }, |
| 867 | { "Xor", XorCompositeOp, UndefinedOptionFlag, MagickFalse }, |
cristy | 1df692a | 2011-04-23 17:09:35 +0000 | [diff] [blame] | 868 | { "Divide", DivideDstCompositeOp, DeprecateOptionFlag, MagickTrue }, |
| 869 | { "Minus", MinusDstCompositeOp, DeprecateOptionFlag, MagickTrue }, |
cristy | c280c87 | 2015-07-12 22:52:41 +0000 | [diff] [blame] | 870 | { "Subtract", ModulusSubtractCompositeOp, DeprecateOptionFlag, MagickTrue }, |
| 871 | { "Add", ModulusAddCompositeOp, DeprecateOptionFlag, MagickTrue }, |
cristy | 1df692a | 2011-04-23 17:09:35 +0000 | [diff] [blame] | 872 | { "Threshold", ThresholdCompositeOp, DeprecateOptionFlag, MagickTrue }, |
anthony | ea068a5 | 2012-04-09 05:46:25 +0000 | [diff] [blame] | 873 | { "CopyOpacity", CopyAlphaCompositeOp, UndefinedOptionFlag, MagickTrue }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 874 | { (char *) NULL, UndefinedCompositeOp, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 875 | }, |
| 876 | CompressOptions[] = |
| 877 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 878 | { "Undefined", UndefinedCompression, UndefinedOptionFlag, MagickTrue }, |
| 879 | { "B44", B44Compression, UndefinedOptionFlag, MagickFalse }, |
| 880 | { "B44A", B44ACompression, UndefinedOptionFlag, MagickFalse }, |
| 881 | { "BZip", BZipCompression, UndefinedOptionFlag, MagickFalse }, |
| 882 | { "DXT1", DXT1Compression, UndefinedOptionFlag, MagickFalse }, |
| 883 | { "DXT3", DXT3Compression, UndefinedOptionFlag, MagickFalse }, |
| 884 | { "DXT5", DXT5Compression, UndefinedOptionFlag, MagickFalse }, |
| 885 | { "Fax", FaxCompression, UndefinedOptionFlag, MagickFalse }, |
| 886 | { "Group4", Group4Compression, UndefinedOptionFlag, MagickFalse }, |
cristy | 6d5e20f | 2011-04-25 13:48:54 +0000 | [diff] [blame] | 887 | { "JBIG1", JBIG1Compression, UndefinedOptionFlag, MagickFalse }, |
| 888 | { "JBIG2", JBIG2Compression, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 889 | { "JPEG", JPEGCompression, UndefinedOptionFlag, MagickFalse }, |
| 890 | { "JPEG2000", JPEG2000Compression, UndefinedOptionFlag, MagickFalse }, |
| 891 | { "Lossless", LosslessJPEGCompression, UndefinedOptionFlag, MagickFalse }, |
| 892 | { "LosslessJPEG", LosslessJPEGCompression, UndefinedOptionFlag, MagickFalse }, |
| 893 | { "LZMA", LZMACompression, UndefinedOptionFlag, MagickFalse }, |
| 894 | { "LZW", LZWCompression, UndefinedOptionFlag, MagickFalse }, |
| 895 | { "None", NoCompression, UndefinedOptionFlag, MagickFalse }, |
| 896 | { "Piz", PizCompression, UndefinedOptionFlag, MagickFalse }, |
| 897 | { "Pxr24", Pxr24Compression, UndefinedOptionFlag, MagickFalse }, |
| 898 | { "RLE", RLECompression, UndefinedOptionFlag, MagickFalse }, |
| 899 | { "Zip", ZipCompression, UndefinedOptionFlag, MagickFalse }, |
| 900 | { "RunlengthEncoded", RLECompression, UndefinedOptionFlag, MagickFalse }, |
| 901 | { "ZipS", ZipSCompression, UndefinedOptionFlag, MagickFalse }, |
| 902 | { (char *) NULL, UndefinedCompression, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 903 | }, |
| 904 | ColorspaceOptions[] = |
| 905 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 906 | { "Undefined", UndefinedColorspace, UndefinedOptionFlag, MagickTrue }, |
cristy | 978b6a3 | 2012-06-24 15:17:32 +0000 | [diff] [blame] | 907 | { "CIELab", LabColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 908 | { "CMY", CMYColorspace, UndefinedOptionFlag, MagickFalse }, |
| 909 | { "CMYK", CMYKColorspace, UndefinedOptionFlag, MagickFalse }, |
| 910 | { "Gray", GRAYColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 722fc0c | 2012-08-04 23:15:43 +0000 | [diff] [blame] | 911 | { "HCL", HCLColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 710cbd4 | 2013-05-02 21:39:35 +0000 | [diff] [blame] | 912 | { "HCLp", HCLpColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 913 | { "HSB", HSBColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | af64eb2 | 2013-05-02 14:07:10 +0000 | [diff] [blame] | 914 | { "HSI", HSIColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 915 | { "HSL", HSLColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 246c313 | 2013-05-02 16:35:53 +0000 | [diff] [blame] | 916 | { "HSV", HSVColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 917 | { "HWB", HWBColorspace, UndefinedOptionFlag, MagickFalse }, |
| 918 | { "Lab", LabColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 1f09931 | 2012-08-29 17:22:14 +0000 | [diff] [blame] | 919 | { "LCH", LCHColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | df42b17 | 2013-04-05 13:35:37 +0000 | [diff] [blame] | 920 | { "LCHab", LCHabColorspace, UndefinedOptionFlag, MagickFalse }, |
| 921 | { "LCHuv", LCHuvColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 09d746f | 2012-08-29 17:54:59 +0000 | [diff] [blame] | 922 | { "LMS", LMSColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 923 | { "Log", LogColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | cb82c8e | 2012-08-01 12:54:37 +0000 | [diff] [blame] | 924 | { "Luv", LuvColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 925 | { "OHTA", OHTAColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 926 | { "Rec601YCbCr", Rec601YCbCrColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 927 | { "Rec709YCbCr", Rec709YCbCrColorspace, UndefinedOptionFlag, MagickFalse }, |
| 928 | { "RGB", RGBColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 3463233 | 2013-05-03 10:21:05 +0000 | [diff] [blame] | 929 | { "scRGB", scRGBColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 930 | { "sRGB", sRGBColorspace, UndefinedOptionFlag, MagickFalse }, |
| 931 | { "Transparent", TransparentColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 7894d4a | 2014-09-29 12:43:59 +0000 | [diff] [blame] | 932 | { "xyY", xyYColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 933 | { "XYZ", XYZColorspace, UndefinedOptionFlag, MagickFalse }, |
| 934 | { "YCbCr", YCbCrColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | c282d1b | 2013-05-06 23:37:48 +0000 | [diff] [blame] | 935 | { "YDbDr", YDbDrColorspace, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 936 | { "YCC", YCCColorspace, UndefinedOptionFlag, MagickFalse }, |
| 937 | { "YIQ", YIQColorspace, UndefinedOptionFlag, MagickFalse }, |
| 938 | { "YPbPr", YPbPrColorspace, UndefinedOptionFlag, MagickFalse }, |
| 939 | { "YUV", YUVColorspace, UndefinedOptionFlag, MagickFalse }, |
| 940 | { (char *) NULL, UndefinedColorspace, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 941 | }, |
cristy | 790190d | 2013-10-04 00:51:51 +0000 | [diff] [blame] | 942 | ComplexOptions[] = |
| 943 | { |
| 944 | { "Undefined", UndefinedComplexOperator, UndefinedOptionFlag, MagickTrue }, |
cristy | 19f7886 | 2013-10-05 22:21:46 +0000 | [diff] [blame] | 945 | { "Add", AddComplexOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | 790190d | 2013-10-04 00:51:51 +0000 | [diff] [blame] | 946 | { "Conjugate", ConjugateComplexOperator, UndefinedOptionFlag, MagickFalse }, |
| 947 | { "Divide", DivideComplexOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | f46941c | 2013-10-06 22:25:41 +0000 | [diff] [blame] | 948 | { "MagnitudePhase", MagnitudePhaseComplexOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | 790190d | 2013-10-04 00:51:51 +0000 | [diff] [blame] | 949 | { "Multiply", MultiplyComplexOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | f46941c | 2013-10-06 22:25:41 +0000 | [diff] [blame] | 950 | { "RealImaginary", RealImaginaryComplexOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | 19f7886 | 2013-10-05 22:21:46 +0000 | [diff] [blame] | 951 | { "Subtract", SubtractComplexOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | 790190d | 2013-10-04 00:51:51 +0000 | [diff] [blame] | 952 | { (char *) NULL, UndefinedComplexOperator, UndefinedOptionFlag, MagickFalse } |
| 953 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 954 | DataTypeOptions[] = |
| 955 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 956 | { "Undefined", UndefinedData, UndefinedOptionFlag, MagickTrue }, |
| 957 | { "Byte", ByteData, UndefinedOptionFlag, MagickFalse }, |
| 958 | { "Long", LongData, UndefinedOptionFlag, MagickFalse }, |
| 959 | { "Short", ShortData, UndefinedOptionFlag, MagickFalse }, |
| 960 | { "String", StringData, UndefinedOptionFlag, MagickFalse }, |
| 961 | { (char *) NULL, UndefinedData, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 962 | }, |
| 963 | DecorateOptions[] = |
| 964 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 965 | { "Undefined", UndefinedDecoration, UndefinedOptionFlag, MagickTrue }, |
| 966 | { "LineThrough", LineThroughDecoration, UndefinedOptionFlag, MagickFalse }, |
| 967 | { "None", NoDecoration, UndefinedOptionFlag, MagickFalse }, |
| 968 | { "Overline", OverlineDecoration, UndefinedOptionFlag, MagickFalse }, |
| 969 | { "Underline", UnderlineDecoration, UndefinedOptionFlag, MagickFalse }, |
| 970 | { (char *) NULL, UndefinedDecoration, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 971 | }, |
cristy | c9b1295 | 2010-03-28 01:12:28 +0000 | [diff] [blame] | 972 | DirectionOptions[] = |
| 973 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 974 | { "Undefined", UndefinedDirection, UndefinedOptionFlag, MagickTrue }, |
| 975 | { "right-to-left", RightToLeftDirection, UndefinedOptionFlag, MagickFalse }, |
| 976 | { "left-to-right", LeftToRightDirection, UndefinedOptionFlag, MagickFalse }, |
| 977 | { (char *) NULL, UndefinedDirection, UndefinedOptionFlag, MagickFalse } |
cristy | c9b1295 | 2010-03-28 01:12:28 +0000 | [diff] [blame] | 978 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 979 | DisposeOptions[] = |
| 980 | { |
cristy | c8b42a4 | 2014-12-17 14:37:53 +0000 | [diff] [blame] | 981 | { "Undefined", UndefinedDispose, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 982 | { "Background", BackgroundDispose, UndefinedOptionFlag, MagickFalse }, |
| 983 | { "None", NoneDispose, UndefinedOptionFlag, MagickFalse }, |
| 984 | { "Previous", PreviousDispose, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 985 | { "0", UndefinedDispose, UndefinedOptionFlag, MagickFalse }, |
| 986 | { "1", NoneDispose, UndefinedOptionFlag, MagickFalse }, |
| 987 | { "2", BackgroundDispose, UndefinedOptionFlag, MagickFalse }, |
| 988 | { "3", PreviousDispose, UndefinedOptionFlag, MagickFalse }, |
| 989 | { (char *) NULL, UndefinedDispose, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 990 | }, |
| 991 | DistortOptions[] = |
| 992 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 993 | { "Affine", AffineDistortion, UndefinedOptionFlag, MagickFalse }, |
| 994 | { "AffineProjection", AffineProjectionDistortion, UndefinedOptionFlag, MagickFalse }, |
| 995 | { "ScaleRotateTranslate", ScaleRotateTranslateDistortion, UndefinedOptionFlag, MagickFalse }, |
| 996 | { "SRT", ScaleRotateTranslateDistortion, UndefinedOptionFlag, MagickFalse }, |
| 997 | { "Perspective", PerspectiveDistortion, UndefinedOptionFlag, MagickFalse }, |
| 998 | { "PerspectiveProjection", PerspectiveProjectionDistortion, UndefinedOptionFlag, MagickFalse }, |
| 999 | { "Bilinear", BilinearForwardDistortion, UndefinedOptionFlag, MagickTrue }, |
| 1000 | { "BilinearForward", BilinearForwardDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1001 | { "BilinearReverse", BilinearReverseDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1002 | { "Polynomial", PolynomialDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1003 | { "Arc", ArcDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1004 | { "Polar", PolarDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1005 | { "DePolar", DePolarDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1006 | { "Barrel", BarrelDistortion, UndefinedOptionFlag, MagickFalse }, |
anthony | e0d9bbd | 2011-06-15 01:05:57 +0000 | [diff] [blame] | 1007 | { "Cylinder2Plane", Cylinder2PlaneDistortion, UndefinedOptionFlag, MagickTrue }, |
| 1008 | { "Plane2Cylinder", Plane2CylinderDistortion, UndefinedOptionFlag, MagickTrue }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1009 | { "BarrelInverse", BarrelInverseDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1010 | { "Shepards", ShepardsDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1011 | { "Resize", ResizeDistortion, UndefinedOptionFlag, MagickFalse }, |
| 1012 | { (char *) NULL, UndefinedDistortion, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1013 | }, |
| 1014 | DitherOptions[] = |
| 1015 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1016 | { "Undefined", UndefinedDitherMethod, UndefinedOptionFlag, MagickTrue }, |
| 1017 | { "None", NoDitherMethod, UndefinedOptionFlag, MagickFalse }, |
| 1018 | { "FloydSteinberg", FloydSteinbergDitherMethod, UndefinedOptionFlag, MagickFalse }, |
| 1019 | { "Riemersma", RiemersmaDitherMethod, UndefinedOptionFlag, MagickFalse }, |
| 1020 | { (char *) NULL, UndefinedEndian, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1021 | }, |
| 1022 | EndianOptions[] = |
| 1023 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1024 | { "Undefined", UndefinedEndian, UndefinedOptionFlag, MagickTrue }, |
| 1025 | { "LSB", LSBEndian, UndefinedOptionFlag, MagickFalse }, |
| 1026 | { "MSB", MSBEndian, UndefinedOptionFlag, MagickFalse }, |
| 1027 | { (char *) NULL, UndefinedEndian, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1028 | }, |
| 1029 | EvaluateOptions[] = |
| 1030 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1031 | { "Undefined", UndefinedEvaluateOperator, UndefinedOptionFlag, MagickTrue }, |
| 1032 | { "Abs", AbsEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1033 | { "Add", AddEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1034 | { "AddModulus", AddModulusEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1035 | { "And", AndEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1036 | { "Cos", CosineEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1037 | { "Cosine", CosineEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1038 | { "Divide", DivideEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1039 | { "Exp", ExponentialEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1040 | { "Exponential", ExponentialEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1041 | { "GaussianNoise", GaussianNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1042 | { "ImpulseNoise", ImpulseNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1043 | { "LaplacianNoise", LaplacianNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1044 | { "LeftShift", LeftShiftEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1045 | { "Log", LogEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1046 | { "Max", MaxEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1047 | { "Mean", MeanEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1048 | { "Median", MedianEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1049 | { "Min", MinEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1050 | { "MultiplicativeNoise", MultiplicativeNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1051 | { "Multiply", MultiplyEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1052 | { "Or", OrEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1053 | { "PoissonNoise", PoissonNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1054 | { "Pow", PowEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1055 | { "RightShift", RightShiftEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | 7c4c78f | 2014-06-15 21:57:39 +0000 | [diff] [blame] | 1056 | { "RMS", RootMeanSquareEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1057 | { "RootMeanSquare", RootMeanSquareEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1058 | { "Set", SetEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1059 | { "Sin", SineEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1060 | { "Sine", SineEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1061 | { "Subtract", SubtractEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | 12a3f8e | 2012-01-31 01:53:19 +0000 | [diff] [blame] | 1062 | { "Sum", SumEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1063 | { "Threshold", ThresholdEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1064 | { "ThresholdBlack", ThresholdBlackEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1065 | { "ThresholdWhite", ThresholdWhiteEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1066 | { "UniformNoise", UniformNoiseEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1067 | { "Xor", XorEvaluateOperator, UndefinedOptionFlag, MagickFalse }, |
| 1068 | { (char *) NULL, UndefinedEvaluateOperator, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1069 | }, |
| 1070 | FillRuleOptions[] = |
| 1071 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1072 | { "Undefined", UndefinedRule, UndefinedOptionFlag, MagickTrue }, |
| 1073 | { "Evenodd", EvenOddRule, UndefinedOptionFlag, MagickFalse }, |
| 1074 | { "NonZero", NonZeroRule, UndefinedOptionFlag, MagickFalse }, |
| 1075 | { (char *) NULL, UndefinedRule, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1076 | }, |
| 1077 | FilterOptions[] = |
| 1078 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1079 | { "Undefined", UndefinedFilter, UndefinedOptionFlag, MagickTrue }, |
| 1080 | { "Bartlett", BartlettFilter, UndefinedOptionFlag, MagickFalse }, |
| 1081 | { "Blackman", BlackmanFilter, UndefinedOptionFlag, MagickFalse }, |
| 1082 | { "Bohman", BohmanFilter, UndefinedOptionFlag, MagickFalse }, |
| 1083 | { "Box", BoxFilter, UndefinedOptionFlag, MagickFalse }, |
| 1084 | { "Catrom", CatromFilter, UndefinedOptionFlag, MagickFalse }, |
anthony | 5d4a170 | 2012-05-08 01:22:41 +0000 | [diff] [blame] | 1085 | { "Cosine", CosineFilter, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1086 | { "Cubic", CubicFilter, UndefinedOptionFlag, MagickFalse }, |
| 1087 | { "Gaussian", GaussianFilter, UndefinedOptionFlag, MagickFalse }, |
| 1088 | { "Hamming", HammingFilter, UndefinedOptionFlag, MagickFalse }, |
anthony | f60ffd7 | 2012-08-20 03:25:30 +0000 | [diff] [blame] | 1089 | { "Hann", HannFilter, UndefinedOptionFlag, MagickFalse }, |
| 1090 | { "Hanning", HannFilter, UndefinedOptionFlag, MagickTrue }, /*misspell*/ |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1091 | { "Hermite", HermiteFilter, UndefinedOptionFlag, MagickFalse }, |
| 1092 | { "Jinc", JincFilter, UndefinedOptionFlag, MagickFalse }, |
| 1093 | { "Kaiser", KaiserFilter, UndefinedOptionFlag, MagickFalse }, |
| 1094 | { "Lagrange", LagrangeFilter, UndefinedOptionFlag, MagickFalse }, |
| 1095 | { "Lanczos", LanczosFilter, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1096 | { "Lanczos2", Lanczos2Filter, UndefinedOptionFlag, MagickFalse }, |
| 1097 | { "Lanczos2Sharp", Lanczos2SharpFilter, UndefinedOptionFlag, MagickFalse }, |
anthony | aa80642 | 2012-10-17 00:56:10 +0000 | [diff] [blame] | 1098 | { "LanczosRadius", LanczosRadiusFilter, UndefinedOptionFlag, MagickFalse }, |
| 1099 | { "LanczosSharp", LanczosSharpFilter, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1100 | { "Mitchell", MitchellFilter, UndefinedOptionFlag, MagickFalse }, |
| 1101 | { "Parzen", ParzenFilter, UndefinedOptionFlag, MagickFalse }, |
| 1102 | { "Point", PointFilter, UndefinedOptionFlag, MagickFalse }, |
| 1103 | { "Quadratic", QuadraticFilter, UndefinedOptionFlag, MagickFalse }, |
| 1104 | { "Robidoux", RobidouxFilter, UndefinedOptionFlag, MagickFalse }, |
anthony | 4553109 | 2012-04-23 00:33:53 +0000 | [diff] [blame] | 1105 | { "RobidouxSharp", RobidouxSharpFilter, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1106 | { "Sinc", SincFilter, UndefinedOptionFlag, MagickFalse }, |
| 1107 | { "SincFast", SincFastFilter, UndefinedOptionFlag, MagickFalse }, |
anthony | cf4e33d | 2012-06-08 07:33:23 +0000 | [diff] [blame] | 1108 | { "Spline", SplineFilter, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1109 | { "Triangle", TriangleFilter, UndefinedOptionFlag, MagickFalse }, |
anthony | f60ffd7 | 2012-08-20 03:25:30 +0000 | [diff] [blame] | 1110 | { "Welch", WelchFilter, UndefinedOptionFlag, MagickFalse }, |
| 1111 | { "Welsh", WelchFilter, UndefinedOptionFlag, MagickTrue }, /*misspell*/ |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1112 | { (char *) NULL, UndefinedFilter, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1113 | }, |
| 1114 | FunctionOptions[] = |
| 1115 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1116 | { "Undefined", UndefinedFunction, UndefinedOptionFlag, MagickTrue }, |
| 1117 | { "Polynomial", PolynomialFunction, UndefinedOptionFlag, MagickFalse }, |
| 1118 | { "Sinusoid", SinusoidFunction, UndefinedOptionFlag, MagickFalse }, |
| 1119 | { "ArcSin", ArcsinFunction, UndefinedOptionFlag, MagickFalse }, |
| 1120 | { "ArcTan", ArctanFunction, UndefinedOptionFlag, MagickFalse }, |
| 1121 | { (char *) NULL, UndefinedFunction, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1122 | }, |
dirk | 84c7c04 | 2015-07-12 13:01:35 +0000 | [diff] [blame] | 1123 | GradientOptions[] = |
| 1124 | { |
| 1125 | { "Undefined", UndefinedGradient, UndefinedOptionFlag, MagickTrue }, |
| 1126 | { "Linear", LinearGradient, UndefinedOptionFlag, MagickFalse }, |
| 1127 | { "Radial", RadialGradient, UndefinedOptionFlag, MagickFalse }, |
| 1128 | { (char *) NULL, UndefinedRule, UndefinedOptionFlag, MagickFalse } |
| 1129 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1130 | GravityOptions[] = |
| 1131 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1132 | { "Undefined", UndefinedGravity, UndefinedOptionFlag, MagickTrue }, |
| 1133 | { "None", UndefinedGravity, UndefinedOptionFlag, MagickFalse }, |
| 1134 | { "Center", CenterGravity, UndefinedOptionFlag, MagickFalse }, |
| 1135 | { "East", EastGravity, UndefinedOptionFlag, MagickFalse }, |
| 1136 | { "Forget", ForgetGravity, UndefinedOptionFlag, MagickFalse }, |
| 1137 | { "NorthEast", NorthEastGravity, UndefinedOptionFlag, MagickFalse }, |
| 1138 | { "North", NorthGravity, UndefinedOptionFlag, MagickFalse }, |
| 1139 | { "NorthWest", NorthWestGravity, UndefinedOptionFlag, MagickFalse }, |
| 1140 | { "SouthEast", SouthEastGravity, UndefinedOptionFlag, MagickFalse }, |
| 1141 | { "South", SouthGravity, UndefinedOptionFlag, MagickFalse }, |
| 1142 | { "SouthWest", SouthWestGravity, UndefinedOptionFlag, MagickFalse }, |
| 1143 | { "West", WestGravity, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1144 | { (char *) NULL, UndefinedGravity, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1145 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1146 | IntentOptions[] = |
| 1147 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1148 | { "Undefined", UndefinedIntent, UndefinedOptionFlag, MagickTrue }, |
| 1149 | { "Absolute", AbsoluteIntent, UndefinedOptionFlag, MagickFalse }, |
| 1150 | { "Perceptual", PerceptualIntent, UndefinedOptionFlag, MagickFalse }, |
| 1151 | { "Relative", RelativeIntent, UndefinedOptionFlag, MagickFalse }, |
| 1152 | { "Saturation", SaturationIntent, UndefinedOptionFlag, MagickFalse }, |
| 1153 | { (char *) NULL, UndefinedIntent, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1154 | }, |
| 1155 | InterlaceOptions[] = |
| 1156 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1157 | { "Undefined", UndefinedInterlace, UndefinedOptionFlag, MagickTrue }, |
| 1158 | { "Line", LineInterlace, UndefinedOptionFlag, MagickFalse }, |
| 1159 | { "None", NoInterlace, UndefinedOptionFlag, MagickFalse }, |
| 1160 | { "Plane", PlaneInterlace, UndefinedOptionFlag, MagickFalse }, |
| 1161 | { "Partition", PartitionInterlace, UndefinedOptionFlag, MagickFalse }, |
| 1162 | { "GIF", GIFInterlace, UndefinedOptionFlag, MagickFalse }, |
| 1163 | { "JPEG", JPEGInterlace, UndefinedOptionFlag, MagickFalse }, |
| 1164 | { "PNG", PNGInterlace, UndefinedOptionFlag, MagickFalse }, |
| 1165 | { (char *) NULL, UndefinedInterlace, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1166 | }, |
| 1167 | InterpolateOptions[] = |
| 1168 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1169 | { "Undefined", UndefinedInterpolatePixel, UndefinedOptionFlag, MagickTrue }, |
| 1170 | { "Average", AverageInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
anthony | cf4e33d | 2012-06-08 07:33:23 +0000 | [diff] [blame] | 1171 | { "Average4", AverageInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
| 1172 | { "Average9", Average9InterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
| 1173 | { "Average16", Average16InterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
| 1174 | { "Background", BackgroundInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1175 | { "Bilinear", BilinearInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
anthony | cf4e33d | 2012-06-08 07:33:23 +0000 | [diff] [blame] | 1176 | { "Blend", BlendInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
| 1177 | { "Catrom", CatromInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1178 | { "Integer", IntegerInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
| 1179 | { "Mesh", MeshInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
anthony | cf4e33d | 2012-06-08 07:33:23 +0000 | [diff] [blame] | 1180 | { "Nearest", NearestInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
| 1181 | { "NearestNeighbor", NearestInterpolatePixel, UndefinedOptionFlag, MagickTrue }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1182 | { "Spline", SplineInterpolatePixel, UndefinedOptionFlag, MagickFalse }, |
anthony | cf4e33d | 2012-06-08 07:33:23 +0000 | [diff] [blame] | 1183 | /* { "Filter", FilterInterpolatePixel, UndefinedOptionFlag, MagickFalse }, */ |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1184 | { (char *) NULL, UndefinedInterpolatePixel, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1185 | }, |
anthony | 602ab9b | 2010-01-05 08:06:50 +0000 | [diff] [blame] | 1186 | KernelOptions[] = |
| 1187 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1188 | { "Undefined", UndefinedKernel, UndefinedOptionFlag, MagickTrue }, |
| 1189 | { "Unity", UnityKernel, UndefinedOptionFlag, MagickFalse }, |
| 1190 | { "Gaussian", GaussianKernel, UndefinedOptionFlag, MagickFalse }, |
| 1191 | { "DoG", DoGKernel, UndefinedOptionFlag, MagickFalse }, |
| 1192 | { "LoG", LoGKernel, UndefinedOptionFlag, MagickFalse }, |
| 1193 | { "Blur", BlurKernel, UndefinedOptionFlag, MagickFalse }, |
| 1194 | { "Comet", CometKernel, UndefinedOptionFlag, MagickFalse }, |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 1195 | { "Binomial", BinomialKernel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1196 | { "Laplacian", LaplacianKernel, UndefinedOptionFlag, MagickFalse }, |
| 1197 | { "Sobel", SobelKernel, UndefinedOptionFlag, MagickFalse }, |
| 1198 | { "FreiChen", FreiChenKernel, UndefinedOptionFlag, MagickFalse }, |
| 1199 | { "Roberts", RobertsKernel, UndefinedOptionFlag, MagickFalse }, |
| 1200 | { "Prewitt", PrewittKernel, UndefinedOptionFlag, MagickFalse }, |
| 1201 | { "Compass", CompassKernel, UndefinedOptionFlag, MagickFalse }, |
| 1202 | { "Kirsch", KirschKernel, UndefinedOptionFlag, MagickFalse }, |
| 1203 | { "Diamond", DiamondKernel, UndefinedOptionFlag, MagickFalse }, |
| 1204 | { "Square", SquareKernel, UndefinedOptionFlag, MagickFalse }, |
| 1205 | { "Rectangle", RectangleKernel, UndefinedOptionFlag, MagickFalse }, |
| 1206 | { "Disk", DiskKernel, UndefinedOptionFlag, MagickFalse }, |
| 1207 | { "Octagon", OctagonKernel, UndefinedOptionFlag, MagickFalse }, |
| 1208 | { "Plus", PlusKernel, UndefinedOptionFlag, MagickFalse }, |
| 1209 | { "Cross", CrossKernel, UndefinedOptionFlag, MagickFalse }, |
| 1210 | { "Ring", RingKernel, UndefinedOptionFlag, MagickFalse }, |
| 1211 | { "Peaks", PeaksKernel, UndefinedOptionFlag, MagickFalse }, |
| 1212 | { "Edges", EdgesKernel, UndefinedOptionFlag, MagickFalse }, |
| 1213 | { "Corners", CornersKernel, UndefinedOptionFlag, MagickFalse }, |
| 1214 | { "Diagonals", DiagonalsKernel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1215 | { "LineEnds", LineEndsKernel, UndefinedOptionFlag, MagickFalse }, |
| 1216 | { "LineJunctions", LineJunctionsKernel, UndefinedOptionFlag, MagickFalse }, |
| 1217 | { "Ridges", RidgesKernel, UndefinedOptionFlag, MagickFalse }, |
| 1218 | { "ConvexHull", ConvexHullKernel, UndefinedOptionFlag, MagickFalse }, |
| 1219 | { "ThinSe", ThinSEKernel, UndefinedOptionFlag, MagickFalse }, |
| 1220 | { "Skeleton", SkeletonKernel, UndefinedOptionFlag, MagickFalse }, |
| 1221 | { "Chebyshev", ChebyshevKernel, UndefinedOptionFlag, MagickFalse }, |
| 1222 | { "Manhattan", ManhattanKernel, UndefinedOptionFlag, MagickFalse }, |
| 1223 | { "Octagonal", OctagonalKernel, UndefinedOptionFlag, MagickFalse }, |
| 1224 | { "Euclidean", EuclideanKernel, UndefinedOptionFlag, MagickFalse }, |
cristy | 1df692a | 2011-04-23 17:09:35 +0000 | [diff] [blame] | 1225 | { "User Defined", UserDefinedKernel, UndefinedOptionFlag, MagickTrue }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1226 | { (char *) NULL, UndefinedKernel, UndefinedOptionFlag, MagickFalse } |
anthony | 602ab9b | 2010-01-05 08:06:50 +0000 | [diff] [blame] | 1227 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1228 | LayerOptions[] = |
| 1229 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1230 | { "Undefined", UndefinedLayer, UndefinedOptionFlag, MagickTrue }, |
| 1231 | { "Coalesce", CoalesceLayer, UndefinedOptionFlag, MagickFalse }, |
| 1232 | { "CompareAny", CompareAnyLayer, UndefinedOptionFlag, MagickFalse }, |
| 1233 | { "CompareClear", CompareClearLayer, UndefinedOptionFlag, MagickFalse }, |
| 1234 | { "CompareOverlay", CompareOverlayLayer, UndefinedOptionFlag, MagickFalse }, |
| 1235 | { "Dispose", DisposeLayer, UndefinedOptionFlag, MagickFalse }, |
| 1236 | { "Optimize", OptimizeLayer, UndefinedOptionFlag, MagickFalse }, |
| 1237 | { "OptimizeFrame", OptimizeImageLayer, UndefinedOptionFlag, MagickFalse }, |
| 1238 | { "OptimizePlus", OptimizePlusLayer, UndefinedOptionFlag, MagickFalse }, |
| 1239 | { "OptimizeTransparency", OptimizeTransLayer, UndefinedOptionFlag, MagickFalse }, |
| 1240 | { "RemoveDups", RemoveDupsLayer, UndefinedOptionFlag, MagickFalse }, |
| 1241 | { "RemoveZero", RemoveZeroLayer, UndefinedOptionFlag, MagickFalse }, |
| 1242 | { "Composite", CompositeLayer, UndefinedOptionFlag, MagickFalse }, |
| 1243 | { "Merge", MergeLayer, UndefinedOptionFlag, MagickFalse }, |
| 1244 | { "Flatten", FlattenLayer, UndefinedOptionFlag, MagickFalse }, |
| 1245 | { "Mosaic", MosaicLayer, UndefinedOptionFlag, MagickFalse }, |
| 1246 | { "TrimBounds", TrimBoundsLayer, UndefinedOptionFlag, MagickFalse }, |
| 1247 | { (char *) NULL, UndefinedLayer, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1248 | }, |
| 1249 | LineCapOptions[] = |
| 1250 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1251 | { "Undefined", UndefinedCap, UndefinedOptionFlag, MagickTrue }, |
| 1252 | { "Butt", ButtCap, UndefinedOptionFlag, MagickFalse }, |
| 1253 | { "Round", RoundCap, UndefinedOptionFlag, MagickFalse }, |
| 1254 | { "Square", SquareCap, UndefinedOptionFlag, MagickFalse }, |
| 1255 | { (char *) NULL, UndefinedCap, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1256 | }, |
| 1257 | LineJoinOptions[] = |
| 1258 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1259 | { "Undefined", UndefinedJoin, UndefinedOptionFlag, MagickTrue }, |
| 1260 | { "Bevel", BevelJoin, UndefinedOptionFlag, MagickFalse }, |
| 1261 | { "Miter", MiterJoin, UndefinedOptionFlag, MagickFalse }, |
| 1262 | { "Round", RoundJoin, UndefinedOptionFlag, MagickFalse }, |
| 1263 | { (char *) NULL, UndefinedJoin, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1264 | }, |
| 1265 | ListOptions[] = |
| 1266 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1267 | { "Align", MagickAlignOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 288a353 | 2012-08-28 00:19:44 +0000 | [diff] [blame] | 1268 | { "Alpha", MagickAlphaChannelOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1269 | { "Boolean", MagickBooleanOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 947cef2 | 2013-01-17 14:16:40 +0000 | [diff] [blame] | 1270 | { "Cache", MagickCacheOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1271 | { "Channel", MagickChannelOptions, UndefinedOptionFlag, MagickFalse }, |
| 1272 | { "Class", MagickClassOptions, UndefinedOptionFlag, MagickFalse }, |
| 1273 | { "ClipPath", MagickClipPathOptions, UndefinedOptionFlag, MagickFalse }, |
| 1274 | { "Coder", MagickCoderOptions, UndefinedOptionFlag, MagickFalse }, |
| 1275 | { "Color", MagickColorOptions, UndefinedOptionFlag, MagickFalse }, |
| 1276 | { "Colorspace", MagickColorspaceOptions, UndefinedOptionFlag, MagickFalse }, |
| 1277 | { "Command", MagickCommandOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 790190d | 2013-10-04 00:51:51 +0000 | [diff] [blame] | 1278 | { "Complex", MagickComplexOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1279 | { "Compose", MagickComposeOptions, UndefinedOptionFlag, MagickFalse }, |
| 1280 | { "Compress", MagickCompressOptions, UndefinedOptionFlag, MagickFalse }, |
| 1281 | { "Configure", MagickConfigureOptions, UndefinedOptionFlag, MagickFalse }, |
| 1282 | { "DataType", MagickDataTypeOptions, UndefinedOptionFlag, MagickFalse }, |
| 1283 | { "Debug", MagickDebugOptions, UndefinedOptionFlag, MagickFalse }, |
| 1284 | { "Decoration", MagickDecorateOptions, UndefinedOptionFlag, MagickFalse }, |
| 1285 | { "Delegate", MagickDelegateOptions, UndefinedOptionFlag, MagickFalse }, |
| 1286 | { "Direction", MagickDirectionOptions, UndefinedOptionFlag, MagickFalse }, |
| 1287 | { "Dispose", MagickDisposeOptions, UndefinedOptionFlag, MagickFalse }, |
| 1288 | { "Distort", MagickDistortOptions, UndefinedOptionFlag, MagickFalse }, |
| 1289 | { "Dither", MagickDitherOptions, UndefinedOptionFlag, MagickFalse }, |
| 1290 | { "Endian", MagickEndianOptions, UndefinedOptionFlag, MagickFalse }, |
| 1291 | { "Evaluate", MagickEvaluateOptions, UndefinedOptionFlag, MagickFalse }, |
| 1292 | { "FillRule", MagickFillRuleOptions, UndefinedOptionFlag, MagickFalse }, |
| 1293 | { "Filter", MagickFilterOptions, UndefinedOptionFlag, MagickFalse }, |
| 1294 | { "Font", MagickFontOptions, UndefinedOptionFlag, MagickFalse }, |
| 1295 | { "Format", MagickFormatOptions, UndefinedOptionFlag, MagickFalse }, |
| 1296 | { "Function", MagickFunctionOptions, UndefinedOptionFlag, MagickFalse }, |
| 1297 | { "Gravity", MagickGravityOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | f210446 | 2013-03-13 16:13:08 +0000 | [diff] [blame] | 1298 | { "Intensity", MagickPixelIntensityOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1299 | { "Intent", MagickIntentOptions, UndefinedOptionFlag, MagickFalse }, |
| 1300 | { "Interlace", MagickInterlaceOptions, UndefinedOptionFlag, MagickFalse }, |
| 1301 | { "Interpolate", MagickInterpolateOptions, UndefinedOptionFlag, MagickFalse }, |
| 1302 | { "Kernel", MagickKernelOptions, UndefinedOptionFlag, MagickFalse }, |
| 1303 | { "Layers", MagickLayerOptions, UndefinedOptionFlag, MagickFalse }, |
| 1304 | { "LineCap", MagickLineCapOptions, UndefinedOptionFlag, MagickFalse }, |
| 1305 | { "LineJoin", MagickLineJoinOptions, UndefinedOptionFlag, MagickFalse }, |
| 1306 | { "List", MagickListOptions, UndefinedOptionFlag, MagickFalse }, |
| 1307 | { "Locale", MagickLocaleOptions, UndefinedOptionFlag, MagickFalse }, |
| 1308 | { "LogEvent", MagickLogEventOptions, UndefinedOptionFlag, MagickFalse }, |
| 1309 | { "Log", MagickLogOptions, UndefinedOptionFlag, MagickFalse }, |
| 1310 | { "Magic", MagickMagicOptions, UndefinedOptionFlag, MagickFalse }, |
| 1311 | { "Method", MagickMethodOptions, UndefinedOptionFlag, MagickFalse }, |
| 1312 | { "Metric", MagickMetricOptions, UndefinedOptionFlag, MagickFalse }, |
| 1313 | { "Mime", MagickMimeOptions, UndefinedOptionFlag, MagickFalse }, |
| 1314 | { "Mode", MagickModeOptions, UndefinedOptionFlag, MagickFalse }, |
| 1315 | { "Morphology", MagickMorphologyOptions, UndefinedOptionFlag, MagickFalse }, |
| 1316 | { "Module", MagickModuleOptions, UndefinedOptionFlag, MagickFalse }, |
| 1317 | { "Noise", MagickNoiseOptions, UndefinedOptionFlag, MagickFalse }, |
| 1318 | { "Orientation", MagickOrientationOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1319 | { "PixelChannel", MagickPixelChannelOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | ac73d1f | 2013-03-12 00:51:09 +0000 | [diff] [blame] | 1320 | { "PixelIntensity", MagickPixelIntensityOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 18fd443 | 2013-03-22 01:26:09 +0000 | [diff] [blame] | 1321 | { "PixelMask", MagickPixelMaskOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1322 | { "PixelTrait", MagickPixelTraitOptions, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1323 | { "Policy", MagickPolicyOptions, UndefinedOptionFlag, MagickFalse }, |
| 1324 | { "PolicyDomain", MagickPolicyDomainOptions, UndefinedOptionFlag, MagickFalse }, |
| 1325 | { "PolicyRights", MagickPolicyRightsOptions, UndefinedOptionFlag, MagickFalse }, |
| 1326 | { "Preview", MagickPreviewOptions, UndefinedOptionFlag, MagickFalse }, |
| 1327 | { "Primitive", MagickPrimitiveOptions, UndefinedOptionFlag, MagickFalse }, |
| 1328 | { "QuantumFormat", MagickQuantumFormatOptions, UndefinedOptionFlag, MagickFalse }, |
| 1329 | { "Resource", MagickResourceOptions, UndefinedOptionFlag, MagickFalse }, |
| 1330 | { "SparseColor", MagickSparseColorOptions, UndefinedOptionFlag, MagickFalse }, |
| 1331 | { "Statistic", MagickStatisticOptions, UndefinedOptionFlag, MagickFalse }, |
| 1332 | { "Storage", MagickStorageOptions, UndefinedOptionFlag, MagickFalse }, |
| 1333 | { "Stretch", MagickStretchOptions, UndefinedOptionFlag, MagickFalse }, |
| 1334 | { "Style", MagickStyleOptions, UndefinedOptionFlag, MagickFalse }, |
| 1335 | { "Threshold", MagickThresholdOptions, UndefinedOptionFlag, MagickFalse }, |
| 1336 | { "Type", MagickTypeOptions, UndefinedOptionFlag, MagickFalse }, |
| 1337 | { "Units", MagickResolutionOptions, UndefinedOptionFlag, MagickFalse }, |
| 1338 | { "Undefined", MagickUndefinedOptions, UndefinedOptionFlag, MagickTrue }, |
| 1339 | { "Validate", MagickValidateOptions, UndefinedOptionFlag, MagickFalse }, |
| 1340 | { "VirtualPixel", MagickVirtualPixelOptions, UndefinedOptionFlag, MagickFalse }, |
| 1341 | { (char *) NULL, MagickUndefinedOptions, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1342 | }, |
| 1343 | LogEventOptions[] = |
| 1344 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1345 | { "Undefined", UndefinedEvents, UndefinedOptionFlag, MagickTrue }, |
| 1346 | { "All", (AllEvents &~ TraceEvent), UndefinedOptionFlag, MagickFalse }, |
cristy | 68b1497 | 2011-10-26 14:54:58 +0000 | [diff] [blame] | 1347 | { "Accelerate", AccelerateEvent, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1348 | { "Annotate", AnnotateEvent, UndefinedOptionFlag, MagickFalse }, |
| 1349 | { "Blob", BlobEvent, UndefinedOptionFlag, MagickFalse }, |
| 1350 | { "Cache", CacheEvent, UndefinedOptionFlag, MagickFalse }, |
| 1351 | { "Coder", CoderEvent, UndefinedOptionFlag, MagickFalse }, |
anthony | a322a83 | 2013-04-27 06:28:03 +0000 | [diff] [blame] | 1352 | { "Command", CommandEvent, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1353 | { "Configure", ConfigureEvent, UndefinedOptionFlag, MagickFalse }, |
| 1354 | { "Deprecate", DeprecateEvent, UndefinedOptionFlag, MagickFalse }, |
| 1355 | { "Draw", DrawEvent, UndefinedOptionFlag, MagickFalse }, |
| 1356 | { "Exception", ExceptionEvent, UndefinedOptionFlag, MagickFalse }, |
| 1357 | { "Locale", LocaleEvent, UndefinedOptionFlag, MagickFalse }, |
| 1358 | { "Module", ModuleEvent, UndefinedOptionFlag, MagickFalse }, |
| 1359 | { "None", NoEvents, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1360 | { "Pixel", PixelEvent, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1361 | { "Policy", PolicyEvent, UndefinedOptionFlag, MagickFalse }, |
| 1362 | { "Resource", ResourceEvent, UndefinedOptionFlag, MagickFalse }, |
| 1363 | { "Trace", TraceEvent, UndefinedOptionFlag, MagickFalse }, |
| 1364 | { "Transform", TransformEvent, UndefinedOptionFlag, MagickFalse }, |
| 1365 | { "User", UserEvent, UndefinedOptionFlag, MagickFalse }, |
| 1366 | { "Wand", WandEvent, UndefinedOptionFlag, MagickFalse }, |
| 1367 | { "X11", X11Event, UndefinedOptionFlag, MagickFalse }, |
| 1368 | { (char *) NULL, UndefinedEvents, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1369 | }, |
| 1370 | MetricOptions[] = |
| 1371 | { |
cristy | a6efb49 | 2013-07-10 23:57:14 +0000 | [diff] [blame] | 1372 | { "Undefined", UndefinedErrorMetric, UndefinedOptionFlag, MagickTrue }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1373 | { "AE", AbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse }, |
| 1374 | { "Fuzz", FuzzErrorMetric, UndefinedOptionFlag, MagickFalse }, |
| 1375 | { "MAE", MeanAbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse }, |
cristy | 03fa69f | 2014-01-08 18:36:49 +0000 | [diff] [blame] | 1376 | { "MEPP", MeanErrorPerPixelErrorMetric, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1377 | { "MSE", MeanSquaredErrorMetric, UndefinedOptionFlag, MagickFalse }, |
| 1378 | { "NCC", NormalizedCrossCorrelationErrorMetric, UndefinedOptionFlag, MagickFalse }, |
| 1379 | { "PAE", PeakAbsoluteErrorMetric, UndefinedOptionFlag, MagickFalse }, |
cristy | bed8f95 | 2014-01-08 18:26:15 +0000 | [diff] [blame] | 1380 | { "PHASh", PerceptualHashErrorMetric, UndefinedOptionFlag, MagickFalse }, |
cristy | 03d6f86 | 2014-01-08 18:34:48 +0000 | [diff] [blame] | 1381 | { "PSNR", PeakSignalToNoiseRatioErrorMetric, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1382 | { "RMSE", RootMeanSquaredErrorMetric, UndefinedOptionFlag, MagickFalse }, |
cristy | a6efb49 | 2013-07-10 23:57:14 +0000 | [diff] [blame] | 1383 | { (char *) NULL, UndefinedErrorMetric, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1384 | }, |
| 1385 | MethodOptions[] = |
| 1386 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1387 | { "Undefined", UndefinedMethod, UndefinedOptionFlag, MagickTrue }, |
| 1388 | { "FillToBorder", FillToBorderMethod, UndefinedOptionFlag, MagickFalse }, |
| 1389 | { "Floodfill", FloodfillMethod, UndefinedOptionFlag, MagickFalse }, |
| 1390 | { "Point", PointMethod, UndefinedOptionFlag, MagickFalse }, |
| 1391 | { "Replace", ReplaceMethod, UndefinedOptionFlag, MagickFalse }, |
| 1392 | { "Reset", ResetMethod, UndefinedOptionFlag, MagickFalse }, |
| 1393 | { (char *) NULL, UndefinedMethod, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1394 | }, |
| 1395 | ModeOptions[] = |
| 1396 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1397 | { "Undefined", UndefinedMode, UndefinedOptionFlag, MagickTrue }, |
| 1398 | { "Concatenate", ConcatenateMode, UndefinedOptionFlag, MagickFalse }, |
| 1399 | { "Frame", FrameMode, UndefinedOptionFlag, MagickFalse }, |
| 1400 | { "Unframe", UnframeMode, UndefinedOptionFlag, MagickFalse }, |
| 1401 | { (char *) NULL, UndefinedMode, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1402 | }, |
anthony | 602ab9b | 2010-01-05 08:06:50 +0000 | [diff] [blame] | 1403 | MorphologyOptions[] = |
| 1404 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1405 | { "Undefined", UndefinedMorphology, UndefinedOptionFlag, MagickTrue }, |
| 1406 | { "Correlate", CorrelateMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1407 | { "Convolve", ConvolveMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1408 | { "Dilate", DilateMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1409 | { "Erode", ErodeMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1410 | { "Close", CloseMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1411 | { "Open", OpenMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1412 | { "DilateIntensity", DilateIntensityMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1413 | { "ErodeIntensity", ErodeIntensityMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1414 | { "CloseIntensity", CloseIntensityMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1415 | { "OpenIntensity", OpenIntensityMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1416 | { "DilateI", DilateIntensityMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1417 | { "ErodeI", ErodeIntensityMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1418 | { "CloseI", CloseIntensityMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1419 | { "OpenI", OpenIntensityMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1420 | { "Smooth", SmoothMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1421 | { "EdgeOut", EdgeOutMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1422 | { "EdgeIn", EdgeInMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1423 | { "Edge", EdgeMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1424 | { "TopHat", TopHatMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1425 | { "BottomHat", BottomHatMorphology, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1426 | { "Hmt", HitAndMissMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1427 | { "HitNMiss", HitAndMissMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1428 | { "HitAndMiss", HitAndMissMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1429 | { "Thinning", ThinningMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1430 | { "Thicken", ThickenMorphology, UndefinedOptionFlag, MagickFalse }, |
anthony | f34d9b2 | 2012-02-22 06:11:08 +0000 | [diff] [blame] | 1431 | { "Distance", DistanceMorphology, UndefinedOptionFlag, MagickFalse }, |
| 1432 | { "IterativeDistance", IterativeDistanceMorphology, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1433 | { "Voronoi", VoronoiMorphology, UndefinedOptionFlag, MagickTrue }, |
| 1434 | { (char *) NULL, UndefinedMorphology, UndefinedOptionFlag, MagickFalse } |
anthony | 602ab9b | 2010-01-05 08:06:50 +0000 | [diff] [blame] | 1435 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1436 | NoiseOptions[] = |
| 1437 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1438 | { "Undefined", UndefinedNoise, UndefinedOptionFlag, MagickTrue }, |
| 1439 | { "Gaussian", GaussianNoise, UndefinedOptionFlag, MagickFalse }, |
| 1440 | { "Impulse", ImpulseNoise, UndefinedOptionFlag, MagickFalse }, |
| 1441 | { "Laplacian", LaplacianNoise, UndefinedOptionFlag, MagickFalse }, |
| 1442 | { "Multiplicative", MultiplicativeGaussianNoise, UndefinedOptionFlag, MagickFalse }, |
| 1443 | { "Poisson", PoissonNoise, UndefinedOptionFlag, MagickFalse }, |
| 1444 | { "Random", RandomNoise, UndefinedOptionFlag, MagickFalse }, |
| 1445 | { "Uniform", UniformNoise, UndefinedOptionFlag, MagickFalse }, |
| 1446 | { (char *) NULL, UndefinedNoise, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1447 | }, |
| 1448 | OrientationOptions[] = |
| 1449 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1450 | { "Undefined", UndefinedOrientation, UndefinedOptionFlag, MagickTrue }, |
| 1451 | { "TopLeft", TopLeftOrientation, UndefinedOptionFlag, MagickFalse }, |
| 1452 | { "TopRight", TopRightOrientation, UndefinedOptionFlag, MagickFalse }, |
| 1453 | { "BottomRight", BottomRightOrientation, UndefinedOptionFlag, MagickFalse }, |
| 1454 | { "BottomLeft", BottomLeftOrientation, UndefinedOptionFlag, MagickFalse }, |
| 1455 | { "LeftTop", LeftTopOrientation, UndefinedOptionFlag, MagickFalse }, |
| 1456 | { "RightTop", RightTopOrientation, UndefinedOptionFlag, MagickFalse }, |
| 1457 | { "RightBottom", RightBottomOrientation, UndefinedOptionFlag, MagickFalse }, |
| 1458 | { "LeftBottom", LeftBottomOrientation, UndefinedOptionFlag, MagickFalse }, |
| 1459 | { (char *) NULL, UndefinedOrientation, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1460 | }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1461 | PixelChannelOptions[] = |
| 1462 | { |
| 1463 | { "Undefined", UndefinedPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 542dd0b | 2012-03-18 19:10:09 +0000 | [diff] [blame] | 1464 | { "A", AlphaPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1465 | { "Alpha", AlphaPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 542dd0b | 2012-03-18 19:10:09 +0000 | [diff] [blame] | 1466 | { "B", BluePixelChannel, UndefinedOptionFlag, MagickFalse }, |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 1467 | { "Bk", BlackPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1468 | { "Black", BlackPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1469 | { "Blue", BluePixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1470 | { "Cb", CbPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1471 | { "Composite", CompositePixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 542dd0b | 2012-03-18 19:10:09 +0000 | [diff] [blame] | 1472 | { "C", CyanPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1473 | { "Cr", CrPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1474 | { "Cyan", CyanPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1475 | { "Gray", GrayPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 542dd0b | 2012-03-18 19:10:09 +0000 | [diff] [blame] | 1476 | { "G", GreenPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1477 | { "Green", GreenPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1478 | { "Index", IndexPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1479 | { "Intensity", IntensityPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 542dd0b | 2012-03-18 19:10:09 +0000 | [diff] [blame] | 1480 | { "K", BlackPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1481 | { "M", MagentaPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1482 | { "Magenta", MagentaPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 542dd0b | 2012-03-18 19:10:09 +0000 | [diff] [blame] | 1483 | { "R", RedPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 883fde1 | 2013-04-08 00:50:13 +0000 | [diff] [blame] | 1484 | { "ReadMask", ReadMaskPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1485 | { "Red", RedPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1486 | { "Sync", SyncPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 883fde1 | 2013-04-08 00:50:13 +0000 | [diff] [blame] | 1487 | { "WriteMask", WriteMaskPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 542dd0b | 2012-03-18 19:10:09 +0000 | [diff] [blame] | 1488 | { "Y", YellowPixelChannel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1489 | { "Yellow", YellowPixelChannel, UndefinedOptionFlag, MagickFalse }, |
| 1490 | { (char *) NULL, UndefinedPixelChannel, UndefinedOptionFlag, MagickFalse } |
| 1491 | }, |
cristy | ac73d1f | 2013-03-12 00:51:09 +0000 | [diff] [blame] | 1492 | PixelIntensityOptions[] = |
| 1493 | { |
| 1494 | { "Undefined", UndefinedPixelIntensityMethod, UndefinedOptionFlag, MagickTrue }, |
cristy | 13609b4 | 2013-10-30 21:36:37 +0000 | [diff] [blame] | 1495 | { "Average", AveragePixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
| 1496 | { "Brightness", BrightnessPixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
| 1497 | { "Lightness", LightnessPixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
cristy | e801b52 | 2014-06-30 18:05:50 +0000 | [diff] [blame] | 1498 | { "Mean", AveragePixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
cristy | 13609b4 | 2013-10-30 21:36:37 +0000 | [diff] [blame] | 1499 | { "MS", MSPixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
| 1500 | { "Rec601Luma", Rec601LumaPixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
| 1501 | { "Rec601Luminance", Rec601LuminancePixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
| 1502 | { "Rec709Luma", Rec709LumaPixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
| 1503 | { "Rec709Luminance", Rec709LuminancePixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
| 1504 | { "RMS", RMSPixelIntensityMethod, UndefinedOptionFlag, MagickFalse }, |
cristy | ac73d1f | 2013-03-12 00:51:09 +0000 | [diff] [blame] | 1505 | { (char *) NULL, UndefinedPixelIntensityMethod, UndefinedOptionFlag, MagickFalse } |
| 1506 | }, |
cristy | 18fd443 | 2013-03-22 01:26:09 +0000 | [diff] [blame] | 1507 | PixelMaskOptions[] = |
| 1508 | { |
| 1509 | { "Undefined", UndefinedPixelMask, UndefinedOptionFlag, MagickTrue }, |
| 1510 | { "R", ReadPixelMask, UndefinedOptionFlag, MagickFalse }, |
| 1511 | { "Read", ReadPixelMask, UndefinedOptionFlag, MagickFalse }, |
| 1512 | { "W", WritePixelMask, UndefinedOptionFlag, MagickFalse }, |
| 1513 | { "Write", WritePixelMask, UndefinedOptionFlag, MagickFalse }, |
| 1514 | { (char *) NULL, UndefinedPixelMask, UndefinedOptionFlag, MagickFalse } |
| 1515 | }, |
cristy | 6dcb9b8 | 2011-10-23 23:21:25 +0000 | [diff] [blame] | 1516 | PixelTraitOptions[] = |
| 1517 | { |
| 1518 | { "Undefined", UndefinedPixelTrait, UndefinedOptionFlag, MagickTrue }, |
| 1519 | { "Blend", BlendPixelTrait, UndefinedOptionFlag, MagickFalse }, |
| 1520 | { "Copy", CopyPixelTrait, UndefinedOptionFlag, MagickFalse }, |
| 1521 | { "Update", UpdatePixelTrait, UndefinedOptionFlag, MagickFalse }, |
| 1522 | { (char *) NULL, UndefinedPixelTrait, UndefinedOptionFlag, MagickFalse } |
| 1523 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1524 | PolicyDomainOptions[] = |
| 1525 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1526 | { "Undefined", UndefinedPolicyDomain, UndefinedOptionFlag, MagickTrue }, |
| 1527 | { "Coder", CoderPolicyDomain, UndefinedOptionFlag, MagickFalse }, |
| 1528 | { "Delegate", DelegatePolicyDomain, UndefinedOptionFlag, MagickFalse }, |
| 1529 | { "Filter", FilterPolicyDomain, UndefinedOptionFlag, MagickFalse }, |
| 1530 | { "Path", PathPolicyDomain, UndefinedOptionFlag, MagickFalse }, |
| 1531 | { "Resource", ResourcePolicyDomain, UndefinedOptionFlag, MagickFalse }, |
| 1532 | { "System", SystemPolicyDomain, UndefinedOptionFlag, MagickFalse }, |
| 1533 | { (char *) NULL, UndefinedPolicyDomain, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1534 | }, |
| 1535 | PolicyRightsOptions[] = |
| 1536 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1537 | { "Undefined", UndefinedPolicyRights, UndefinedOptionFlag, MagickTrue }, |
| 1538 | { "None", NoPolicyRights, UndefinedOptionFlag, MagickFalse }, |
| 1539 | { "Read", ReadPolicyRights, UndefinedOptionFlag, MagickFalse }, |
| 1540 | { "Write", WritePolicyRights, UndefinedOptionFlag, MagickFalse }, |
| 1541 | { "Execute", ExecutePolicyRights, UndefinedOptionFlag, MagickFalse }, |
| 1542 | { (char *) NULL, UndefinedPolicyRights, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1543 | }, |
| 1544 | PreviewOptions[] = |
| 1545 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1546 | { "Undefined", UndefinedPreview, UndefinedOptionFlag, MagickTrue }, |
| 1547 | { "AddNoise", AddNoisePreview, UndefinedOptionFlag, MagickFalse }, |
| 1548 | { "Blur", BlurPreview, UndefinedOptionFlag, MagickFalse }, |
| 1549 | { "Brightness", BrightnessPreview, UndefinedOptionFlag, MagickFalse }, |
| 1550 | { "Charcoal", CharcoalDrawingPreview, UndefinedOptionFlag, MagickFalse }, |
| 1551 | { "Despeckle", DespecklePreview, UndefinedOptionFlag, MagickFalse }, |
| 1552 | { "Dull", DullPreview, UndefinedOptionFlag, MagickFalse }, |
| 1553 | { "EdgeDetect", EdgeDetectPreview, UndefinedOptionFlag, MagickFalse }, |
| 1554 | { "Gamma", GammaPreview, UndefinedOptionFlag, MagickFalse }, |
| 1555 | { "Grayscale", GrayscalePreview, UndefinedOptionFlag, MagickFalse }, |
| 1556 | { "Hue", HuePreview, UndefinedOptionFlag, MagickFalse }, |
| 1557 | { "Implode", ImplodePreview, UndefinedOptionFlag, MagickFalse }, |
| 1558 | { "JPEG", JPEGPreview, UndefinedOptionFlag, MagickFalse }, |
| 1559 | { "OilPaint", OilPaintPreview, UndefinedOptionFlag, MagickFalse }, |
| 1560 | { "Quantize", QuantizePreview, UndefinedOptionFlag, MagickFalse }, |
| 1561 | { "Raise", RaisePreview, UndefinedOptionFlag, MagickFalse }, |
| 1562 | { "ReduceNoise", ReduceNoisePreview, UndefinedOptionFlag, MagickFalse }, |
| 1563 | { "Roll", RollPreview, UndefinedOptionFlag, MagickFalse }, |
| 1564 | { "Rotate", RotatePreview, UndefinedOptionFlag, MagickFalse }, |
| 1565 | { "Saturation", SaturationPreview, UndefinedOptionFlag, MagickFalse }, |
| 1566 | { "Segment", SegmentPreview, UndefinedOptionFlag, MagickFalse }, |
| 1567 | { "Shade", ShadePreview, UndefinedOptionFlag, MagickFalse }, |
| 1568 | { "Sharpen", SharpenPreview, UndefinedOptionFlag, MagickFalse }, |
| 1569 | { "Shear", ShearPreview, UndefinedOptionFlag, MagickFalse }, |
| 1570 | { "Solarize", SolarizePreview, UndefinedOptionFlag, MagickFalse }, |
| 1571 | { "Spiff", SpiffPreview, UndefinedOptionFlag, MagickFalse }, |
| 1572 | { "Spread", SpreadPreview, UndefinedOptionFlag, MagickFalse }, |
| 1573 | { "Swirl", SwirlPreview, UndefinedOptionFlag, MagickFalse }, |
| 1574 | { "Threshold", ThresholdPreview, UndefinedOptionFlag, MagickFalse }, |
| 1575 | { "Wave", WavePreview, UndefinedOptionFlag, MagickFalse }, |
| 1576 | { (char *) NULL, UndefinedPreview, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1577 | }, |
| 1578 | PrimitiveOptions[] = |
| 1579 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1580 | { "Undefined", UndefinedPrimitive, UndefinedOptionFlag, MagickTrue }, |
dirk | 34e1a21 | 2015-03-22 16:45:12 +0000 | [diff] [blame] | 1581 | { "Alpha", AlphaPrimitive, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1582 | { "Arc", ArcPrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1583 | { "Bezier", BezierPrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1584 | { "Circle", CirclePrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1585 | { "Color", ColorPrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1586 | { "Ellipse", EllipsePrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1587 | { "Image", ImagePrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1588 | { "Line", LinePrimitive, UndefinedOptionFlag, MagickFalse }, |
cristy | be863de | 2015-03-31 00:27:44 +0000 | [diff] [blame] | 1589 | { "Matte", AlphaPrimitive, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1590 | { "Path", PathPrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1591 | { "Point", PointPrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1592 | { "Polygon", PolygonPrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1593 | { "Polyline", PolylinePrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1594 | { "Rectangle", RectanglePrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1595 | { "RoundRectangle", RoundRectanglePrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1596 | { "Text", TextPrimitive, UndefinedOptionFlag, MagickFalse }, |
| 1597 | { (char *) NULL, UndefinedPrimitive, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1598 | }, |
| 1599 | QuantumFormatOptions[] = |
| 1600 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1601 | { "Undefined", UndefinedQuantumFormat, UndefinedOptionFlag, MagickTrue }, |
| 1602 | { "FloatingPoint", FloatingPointQuantumFormat, UndefinedOptionFlag, MagickFalse }, |
| 1603 | { "Signed", SignedQuantumFormat, UndefinedOptionFlag, MagickFalse }, |
| 1604 | { "Unsigned", UnsignedQuantumFormat, UndefinedOptionFlag, MagickFalse }, |
| 1605 | { (char *) NULL, FloatingPointQuantumFormat, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1606 | }, |
| 1607 | ResolutionOptions[] = |
| 1608 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1609 | { "Undefined", UndefinedResolution, UndefinedOptionFlag, MagickTrue }, |
| 1610 | { "PixelsPerInch", PixelsPerInchResolution, UndefinedOptionFlag, MagickFalse }, |
| 1611 | { "PixelsPerCentimeter", PixelsPerCentimeterResolution, UndefinedOptionFlag, MagickFalse }, |
| 1612 | { (char *) NULL, UndefinedResolution, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1613 | }, |
| 1614 | ResourceOptions[] = |
| 1615 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1616 | { "Undefined", UndefinedResource, UndefinedOptionFlag, MagickTrue }, |
| 1617 | { "Area", AreaResource, UndefinedOptionFlag, MagickFalse }, |
| 1618 | { "Disk", DiskResource, UndefinedOptionFlag, MagickFalse }, |
| 1619 | { "File", FileResource, UndefinedOptionFlag, MagickFalse }, |
cristy | ba158d9 | 2014-12-21 23:17:23 +0000 | [diff] [blame] | 1620 | { "Height", HeightResource, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1621 | { "Map", MapResource, UndefinedOptionFlag, MagickFalse }, |
| 1622 | { "Memory", MemoryResource, UndefinedOptionFlag, MagickFalse }, |
| 1623 | { "Thread", ThreadResource, UndefinedOptionFlag, MagickFalse }, |
| 1624 | { "Time", TimeResource, UndefinedOptionFlag, MagickFalse }, |
cristy | ba158d9 | 2014-12-21 23:17:23 +0000 | [diff] [blame] | 1625 | { "Width", WidthResource, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1626 | { (char *) NULL, UndefinedResource, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1627 | }, |
| 1628 | SparseColorOptions[] = |
| 1629 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1630 | { "Undefined", UndefinedDistortion, UndefinedOptionFlag, MagickTrue }, |
| 1631 | { "Barycentric", BarycentricColorInterpolate, UndefinedOptionFlag, MagickFalse }, |
| 1632 | { "Bilinear", BilinearColorInterpolate, UndefinedOptionFlag, MagickFalse }, |
anthony | 09d867c | 2011-04-26 08:28:41 +0000 | [diff] [blame] | 1633 | { "Inverse", InverseColorInterpolate, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1634 | { "Shepards", ShepardsColorInterpolate, UndefinedOptionFlag, MagickFalse }, |
| 1635 | { "Voronoi", VoronoiColorInterpolate, UndefinedOptionFlag, MagickFalse }, |
| 1636 | { (char *) NULL, UndefinedResource, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1637 | }, |
cristy | 0834d64 | 2011-03-18 18:26:08 +0000 | [diff] [blame] | 1638 | StatisticOptions[] = |
| 1639 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1640 | { "Undefined", UndefinedStatistic, UndefinedOptionFlag, MagickTrue }, |
| 1641 | { "Gradient", GradientStatistic, UndefinedOptionFlag, MagickFalse }, |
| 1642 | { "Maximum", MaximumStatistic, UndefinedOptionFlag, MagickFalse }, |
| 1643 | { "Mean", MeanStatistic, UndefinedOptionFlag, MagickFalse }, |
| 1644 | { "Median", MedianStatistic, UndefinedOptionFlag, MagickFalse }, |
| 1645 | { "Minimum", MinimumStatistic, UndefinedOptionFlag, MagickFalse }, |
| 1646 | { "Mode", ModeStatistic, UndefinedOptionFlag, MagickFalse }, |
anthony | 975a8d7 | 2012-04-12 13:54:36 +0000 | [diff] [blame] | 1647 | { "NonPeak", NonpeakStatistic, UndefinedOptionFlag, MagickFalse }, |
cristy | 180908c | 2014-06-15 13:01:43 +0000 | [diff] [blame] | 1648 | { "RootMeanSquare", RootMeanSquareStatistic, UndefinedOptionFlag, MagickFalse }, |
| 1649 | { "RMS", RootMeanSquareStatistic, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1650 | { "StandardDeviation", StandardDeviationStatistic, UndefinedOptionFlag, MagickFalse }, |
| 1651 | { (char *) NULL, UndefinedMethod, UndefinedOptionFlag, MagickFalse } |
cristy | 0834d64 | 2011-03-18 18:26:08 +0000 | [diff] [blame] | 1652 | }, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1653 | StorageOptions[] = |
| 1654 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1655 | { "Undefined", UndefinedPixel, UndefinedOptionFlag, MagickTrue }, |
| 1656 | { "Char", CharPixel, UndefinedOptionFlag, MagickFalse }, |
| 1657 | { "Double", DoublePixel, UndefinedOptionFlag, MagickFalse }, |
| 1658 | { "Float", FloatPixel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1659 | { "Long", LongPixel, UndefinedOptionFlag, MagickFalse }, |
cristy | 6c9e168 | 2012-01-07 21:37:44 +0000 | [diff] [blame] | 1660 | { "LongLong", LongLongPixel, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1661 | { "Quantum", QuantumPixel, UndefinedOptionFlag, MagickFalse }, |
| 1662 | { "Short", ShortPixel, UndefinedOptionFlag, MagickFalse }, |
| 1663 | { (char *) NULL, UndefinedResource, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1664 | }, |
| 1665 | StretchOptions[] = |
| 1666 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1667 | { "Undefined", UndefinedStretch, UndefinedOptionFlag, MagickTrue }, |
| 1668 | { "Any", AnyStretch, UndefinedOptionFlag, MagickFalse }, |
| 1669 | { "Condensed", CondensedStretch, UndefinedOptionFlag, MagickFalse }, |
| 1670 | { "Expanded", ExpandedStretch, UndefinedOptionFlag, MagickFalse }, |
| 1671 | { "ExtraCondensed", ExtraCondensedStretch, UndefinedOptionFlag, MagickFalse }, |
| 1672 | { "ExtraExpanded", ExtraExpandedStretch, UndefinedOptionFlag, MagickFalse }, |
| 1673 | { "Normal", NormalStretch, UndefinedOptionFlag, MagickFalse }, |
| 1674 | { "SemiCondensed", SemiCondensedStretch, UndefinedOptionFlag, MagickFalse }, |
| 1675 | { "SemiExpanded", SemiExpandedStretch, UndefinedOptionFlag, MagickFalse }, |
| 1676 | { "UltraCondensed", UltraCondensedStretch, UndefinedOptionFlag, MagickFalse }, |
| 1677 | { "UltraExpanded", UltraExpandedStretch, UndefinedOptionFlag, MagickFalse }, |
| 1678 | { (char *) NULL, UndefinedStretch, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1679 | }, |
| 1680 | StyleOptions[] = |
| 1681 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1682 | { "Undefined", UndefinedStyle, UndefinedOptionFlag, MagickTrue }, |
| 1683 | { "Any", AnyStyle, UndefinedOptionFlag, MagickFalse }, |
| 1684 | { "Italic", ItalicStyle, UndefinedOptionFlag, MagickFalse }, |
| 1685 | { "Normal", NormalStyle, UndefinedOptionFlag, MagickFalse }, |
| 1686 | { "Oblique", ObliqueStyle, UndefinedOptionFlag, MagickFalse }, |
| 1687 | { (char *) NULL, UndefinedStyle, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1688 | }, |
| 1689 | TypeOptions[] = |
| 1690 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1691 | { "Undefined", UndefinedType, UndefinedOptionFlag, MagickTrue }, |
| 1692 | { "Bilevel", BilevelType, UndefinedOptionFlag, MagickFalse }, |
| 1693 | { "ColorSeparation", ColorSeparationType, UndefinedOptionFlag, MagickFalse }, |
cristy | def23e5 | 2015-01-22 11:52:01 +0000 | [diff] [blame] | 1694 | { "ColorSeparationAlpha", ColorSeparationAlphaType, UndefinedOptionFlag, MagickFalse }, |
| 1695 | { "ColorSeparationMatte", ColorSeparationAlphaType, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1696 | { "Grayscale", GrayscaleType, UndefinedOptionFlag, MagickFalse }, |
cristy | def23e5 | 2015-01-22 11:52:01 +0000 | [diff] [blame] | 1697 | { "GrayscaleAlpha", GrayscaleAlphaType, UndefinedOptionFlag, MagickFalse }, |
| 1698 | { "GrayscaleMatte", GrayscaleAlphaType, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1699 | { "Optimize", OptimizeType, UndefinedOptionFlag, MagickFalse }, |
| 1700 | { "Palette", PaletteType, UndefinedOptionFlag, MagickFalse }, |
cristy | def23e5 | 2015-01-22 11:52:01 +0000 | [diff] [blame] | 1701 | { "PaletteBilevelAlpha", PaletteBilevelAlphaType, UndefinedOptionFlag, MagickFalse }, |
| 1702 | { "PaletteBilevelMatte", PaletteBilevelAlphaType, UndefinedOptionFlag, MagickFalse }, |
| 1703 | { "PaletteAlpha", PaletteAlphaType, UndefinedOptionFlag, MagickFalse }, |
| 1704 | { "PaletteMatte", PaletteAlphaType, UndefinedOptionFlag, MagickFalse }, |
| 1705 | { "TrueColorAlpha", TrueColorAlphaType, UndefinedOptionFlag, MagickFalse }, |
| 1706 | { "TrueColorMatte", TrueColorAlphaType, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1707 | { "TrueColor", TrueColorType, UndefinedOptionFlag, MagickFalse }, |
| 1708 | { (char *) NULL, UndefinedType, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1709 | }, |
| 1710 | ValidateOptions[] = |
| 1711 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1712 | { "Undefined", UndefinedValidate, UndefinedOptionFlag, MagickTrue }, |
| 1713 | { "All", AllValidate, UndefinedOptionFlag, MagickFalse }, |
cristy | 80e870e | 2013-05-07 12:23:02 +0000 | [diff] [blame] | 1714 | { "Colorspace", ColorspaceValidate, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1715 | { "Compare", CompareValidate, UndefinedOptionFlag, MagickFalse }, |
| 1716 | { "Composite", CompositeValidate, UndefinedOptionFlag, MagickFalse }, |
| 1717 | { "Convert", ConvertValidate, UndefinedOptionFlag, MagickFalse }, |
cristy | 247eebde | 2013-06-13 01:01:43 +0000 | [diff] [blame] | 1718 | { "FormatsDisk", FormatsDiskValidate, UndefinedOptionFlag, MagickFalse }, |
| 1719 | { "FormatsMap", FormatsMapValidate, UndefinedOptionFlag, MagickFalse }, |
| 1720 | { "FormatsMemory", FormatsMemoryValidate, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1721 | { "Identify", IdentifyValidate, UndefinedOptionFlag, MagickFalse }, |
| 1722 | { "ImportExport", ImportExportValidate, UndefinedOptionFlag, MagickFalse }, |
| 1723 | { "Montage", MontageValidate, UndefinedOptionFlag, MagickFalse }, |
| 1724 | { "Stream", StreamValidate, UndefinedOptionFlag, MagickFalse }, |
| 1725 | { "None", NoValidate, UndefinedOptionFlag, MagickFalse }, |
| 1726 | { (char *) NULL, UndefinedValidate, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1727 | }, |
| 1728 | VirtualPixelOptions[] = |
| 1729 | { |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1730 | { "Undefined", UndefinedVirtualPixelMethod, UndefinedOptionFlag, MagickTrue }, |
| 1731 | { "Background", BackgroundVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1732 | { "Black", BlackVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
cristy | 1df692a | 2011-04-23 17:09:35 +0000 | [diff] [blame] | 1733 | { "Constant", BackgroundVirtualPixelMethod, DeprecateOptionFlag, MagickTrue }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1734 | { "CheckerTile", CheckerTileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1735 | { "Dither", DitherVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1736 | { "Edge", EdgeVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1737 | { "Gray", GrayVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1738 | { "HorizontalTile", HorizontalTileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1739 | { "HorizontalTileEdge", HorizontalTileEdgeVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1740 | { "Mirror", MirrorVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
anthony | 7a4d610 | 2012-07-01 09:48:25 +0000 | [diff] [blame] | 1741 | { "None", TransparentVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1742 | { "Random", RandomVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1743 | { "Tile", TileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1744 | { "Transparent", TransparentVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1745 | { "VerticalTile", VerticalTileVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1746 | { "VerticalTileEdge", VerticalTileEdgeVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1747 | { "White", WhiteVirtualPixelMethod, UndefinedOptionFlag, MagickFalse }, |
| 1748 | { (char *) NULL, UndefinedVirtualPixelMethod, UndefinedOptionFlag, MagickFalse } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1749 | }; |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 1750 | |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1751 | /* |
| 1752 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1753 | % % |
| 1754 | % % |
| 1755 | % % |
| 1756 | % C l o n e I m a g e O p t i o n s % |
| 1757 | % % |
| 1758 | % % |
| 1759 | % % |
| 1760 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1761 | % |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 1762 | % CloneImageOptions() clones all global image options, to another image_info |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1763 | % |
| 1764 | % The format of the CloneImageOptions method is: |
| 1765 | % |
| 1766 | % MagickBooleanType CloneImageOptions(ImageInfo *image_info, |
| 1767 | % const ImageInfo *clone_info) |
| 1768 | % |
| 1769 | % A description of each parameter follows: |
| 1770 | % |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 1771 | % o image_info: the image info to recieve the cloned options. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1772 | % |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 1773 | % o clone_info: the source image info for options to clone. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1774 | % |
| 1775 | */ |
| 1776 | MagickExport MagickBooleanType CloneImageOptions(ImageInfo *image_info, |
| 1777 | const ImageInfo *clone_info) |
| 1778 | { |
| 1779 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 1780 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1781 | if (image_info->debug != MagickFalse) |
| 1782 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 1783 | image_info->filename); |
| 1784 | assert(clone_info != (const ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 1785 | assert(clone_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1786 | if (clone_info->options != (void *) NULL) |
cristy | 0774287 | 2013-07-19 13:43:08 +0000 | [diff] [blame] | 1787 | { |
| 1788 | if (image_info->options != (void *) NULL) |
| 1789 | DestroyImageOptions(image_info); |
| 1790 | image_info->options=CloneSplayTree((SplayTreeInfo *) clone_info->options, |
| 1791 | (void *(*)(void *)) ConstantString,(void *(*)(void *)) ConstantString); |
| 1792 | } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1793 | return(MagickTrue); |
| 1794 | } |
| 1795 | |
| 1796 | /* |
| 1797 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1798 | % % |
| 1799 | % % |
| 1800 | % % |
| 1801 | % D e f i n e I m a g e O p t i o n % |
| 1802 | % % |
| 1803 | % % |
| 1804 | % % |
| 1805 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1806 | % |
anthony | 8ea7983 | 2011-10-05 10:08:39 +0000 | [diff] [blame] | 1807 | % DefineImageOption() associates an assignment string of the form |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 1808 | % "key=value" with a global image option. It is equivelent to |
| 1809 | % SetImageOption(). |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1810 | % |
| 1811 | % The format of the DefineImageOption method is: |
| 1812 | % |
| 1813 | % MagickBooleanType DefineImageOption(ImageInfo *image_info, |
| 1814 | % const char *option) |
| 1815 | % |
| 1816 | % A description of each parameter follows: |
| 1817 | % |
| 1818 | % o image_info: the image info. |
| 1819 | % |
anthony | 8ea7983 | 2011-10-05 10:08:39 +0000 | [diff] [blame] | 1820 | % o option: the image option assignment string. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1821 | % |
| 1822 | */ |
| 1823 | MagickExport MagickBooleanType DefineImageOption(ImageInfo *image_info, |
| 1824 | const char *option) |
| 1825 | { |
| 1826 | char |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 1827 | key[MagickPathExtent], |
| 1828 | value[MagickPathExtent]; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1829 | |
| 1830 | register char |
| 1831 | *p; |
| 1832 | |
| 1833 | assert(image_info != (ImageInfo *) NULL); |
| 1834 | assert(option != (const char *) NULL); |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 1835 | (void) CopyMagickString(key,option,MagickPathExtent); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1836 | for (p=key; *p != '\0'; p++) |
| 1837 | if (*p == '=') |
| 1838 | break; |
| 1839 | *value='\0'; |
| 1840 | if (*p == '=') |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 1841 | (void) CopyMagickString(value,p+1,MagickPathExtent); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1842 | *p='\0'; |
| 1843 | return(SetImageOption(image_info,key,value)); |
| 1844 | } |
| 1845 | |
| 1846 | /* |
| 1847 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1848 | % % |
| 1849 | % % |
| 1850 | % % |
| 1851 | % D e l e t e I m a g e O p t i o n % |
| 1852 | % % |
| 1853 | % % |
| 1854 | % % |
| 1855 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1856 | % |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 1857 | % DeleteImageOption() deletes an key from the global image options. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1858 | % |
anthony | ebb73a2 | 2012-03-22 14:25:52 +0000 | [diff] [blame] | 1859 | % Returns MagickTrue is the option is found and deleted from the Options. |
| 1860 | % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1861 | % The format of the DeleteImageOption method is: |
| 1862 | % |
| 1863 | % MagickBooleanType DeleteImageOption(ImageInfo *image_info, |
| 1864 | % const char *key) |
| 1865 | % |
| 1866 | % A description of each parameter follows: |
| 1867 | % |
| 1868 | % o image_info: the image info. |
| 1869 | % |
| 1870 | % o option: the image option. |
| 1871 | % |
| 1872 | */ |
| 1873 | MagickExport MagickBooleanType DeleteImageOption(ImageInfo *image_info, |
| 1874 | const char *option) |
| 1875 | { |
| 1876 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 1877 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1878 | if (image_info->debug != MagickFalse) |
| 1879 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 1880 | image_info->filename); |
| 1881 | if (image_info->options == (void *) NULL) |
| 1882 | return(MagickFalse); |
| 1883 | return(DeleteNodeFromSplayTree((SplayTreeInfo *) image_info->options,option)); |
| 1884 | } |
| 1885 | |
| 1886 | /* |
| 1887 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1888 | % % |
| 1889 | % % |
| 1890 | % % |
| 1891 | % D e s t r o y I m a g e O p t i o n s % |
| 1892 | % % |
| 1893 | % % |
| 1894 | % % |
| 1895 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1896 | % |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 1897 | % DestroyImageOptions() destroys all global options and associated memory |
| 1898 | % attached to the given image_info image list. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1899 | % |
| 1900 | % The format of the DestroyDefines method is: |
| 1901 | % |
| 1902 | % void DestroyImageOptions(ImageInfo *image_info) |
| 1903 | % |
| 1904 | % A description of each parameter follows: |
| 1905 | % |
| 1906 | % o image_info: the image info. |
| 1907 | % |
| 1908 | */ |
| 1909 | MagickExport void DestroyImageOptions(ImageInfo *image_info) |
| 1910 | { |
| 1911 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 1912 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1913 | if (image_info->debug != MagickFalse) |
| 1914 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 1915 | image_info->filename); |
| 1916 | if (image_info->options != (void *) NULL) |
| 1917 | image_info->options=DestroySplayTree((SplayTreeInfo *) image_info->options); |
| 1918 | } |
| 1919 | |
| 1920 | /* |
| 1921 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1922 | % % |
| 1923 | % % |
| 1924 | % % |
| 1925 | % G e t I m a g e O p t i o n % |
| 1926 | % % |
| 1927 | % % |
| 1928 | % % |
| 1929 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1930 | % |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 1931 | % GetImageOption() gets a value associated with the global image options. |
| 1932 | % |
| 1933 | % The returned string is a constant string in the tree and should NOT be |
| 1934 | % freed by the caller. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1935 | % |
| 1936 | % The format of the GetImageOption method is: |
| 1937 | % |
| 1938 | % const char *GetImageOption(const ImageInfo *image_info, |
cristy | e3f7779 | 2011-10-07 00:09:09 +0000 | [diff] [blame] | 1939 | % const char *option) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1940 | % |
| 1941 | % A description of each parameter follows: |
| 1942 | % |
| 1943 | % o image_info: the image info. |
| 1944 | % |
cristy | e3f7779 | 2011-10-07 00:09:09 +0000 | [diff] [blame] | 1945 | % o option: the option. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1946 | % |
| 1947 | */ |
| 1948 | MagickExport const char *GetImageOption(const ImageInfo *image_info, |
anthony | 7df2b83 | 2011-10-06 11:55:25 +0000 | [diff] [blame] | 1949 | const char *option) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1950 | { |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1951 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 1952 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1953 | if (image_info->debug != MagickFalse) |
| 1954 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 1955 | image_info->filename); |
| 1956 | if (image_info->options == (void *) NULL) |
| 1957 | return((const char *) NULL); |
cristy | e3f7779 | 2011-10-07 00:09:09 +0000 | [diff] [blame] | 1958 | return((const char *) GetValueFromSplayTree((SplayTreeInfo *) |
| 1959 | image_info->options,option)); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1960 | } |
| 1961 | |
| 1962 | /* |
| 1963 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1964 | % % |
| 1965 | % % |
| 1966 | % % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1967 | % G e t C o m m a n d O p t i o n F l a g s % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1968 | % % |
| 1969 | % % |
| 1970 | % % |
| 1971 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 1972 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1973 | % GetCommandOptionFlags() parses a string and returns an enumerated option |
| 1974 | % flags(s). Return a value of -1 if no such option is found. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1975 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1976 | % The format of the GetCommandOptionFlags method is: |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1977 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1978 | % ssize_t GetCommandOptionFlags(const CommandOption option, |
| 1979 | % const MagickBooleanType list,const char *options) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1980 | % |
| 1981 | % A description of each parameter follows: |
| 1982 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 1983 | % o option: Index to the option table to lookup |
| 1984 | % |
| 1985 | % o list: A option other than zero permits more than one option separated by |
| 1986 | % a comma or pipe. |
| 1987 | % |
| 1988 | % o options: One or more options separated by commas. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1989 | % |
| 1990 | */ |
| 1991 | |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 1992 | static const OptionInfo *GetOptionInfo(const CommandOption option) |
| 1993 | { |
| 1994 | switch (option) |
| 1995 | { |
| 1996 | case MagickAlignOptions: return(AlignOptions); |
| 1997 | case MagickAlphaChannelOptions: return(AlphaChannelOptions); |
| 1998 | case MagickBooleanOptions: return(BooleanOptions); |
| 1999 | case MagickCacheOptions: return(CacheOptions); |
| 2000 | case MagickChannelOptions: return(ChannelOptions); |
| 2001 | case MagickClassOptions: return(ClassOptions); |
| 2002 | case MagickClipPathOptions: return(ClipPathOptions); |
| 2003 | case MagickColorspaceOptions: return(ColorspaceOptions); |
| 2004 | case MagickCommandOptions: return(CommandOptions); |
| 2005 | case MagickComplexOptions: return(ComplexOptions); |
| 2006 | case MagickComposeOptions: return(ComposeOptions); |
| 2007 | case MagickCompressOptions: return(CompressOptions); |
| 2008 | case MagickDataTypeOptions: return(DataTypeOptions); |
| 2009 | case MagickDebugOptions: return(LogEventOptions); |
| 2010 | case MagickDecorateOptions: return(DecorateOptions); |
| 2011 | case MagickDirectionOptions: return(DirectionOptions); |
| 2012 | case MagickDisposeOptions: return(DisposeOptions); |
| 2013 | case MagickDistortOptions: return(DistortOptions); |
| 2014 | case MagickDitherOptions: return(DitherOptions); |
| 2015 | case MagickEndianOptions: return(EndianOptions); |
| 2016 | case MagickEvaluateOptions: return(EvaluateOptions); |
| 2017 | case MagickFillRuleOptions: return(FillRuleOptions); |
| 2018 | case MagickFilterOptions: return(FilterOptions); |
| 2019 | case MagickFunctionOptions: return(FunctionOptions); |
dirk | 84c7c04 | 2015-07-12 13:01:35 +0000 | [diff] [blame] | 2020 | case MagickGradientOptions: return(GradientOptions); |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 2021 | case MagickGravityOptions: return(GravityOptions); |
| 2022 | case MagickIntentOptions: return(IntentOptions); |
| 2023 | case MagickInterlaceOptions: return(InterlaceOptions); |
| 2024 | case MagickInterpolateOptions: return(InterpolateOptions); |
| 2025 | case MagickKernelOptions: return(KernelOptions); |
| 2026 | case MagickLayerOptions: return(LayerOptions); |
| 2027 | case MagickLineCapOptions: return(LineCapOptions); |
| 2028 | case MagickLineJoinOptions: return(LineJoinOptions); |
| 2029 | case MagickListOptions: return(ListOptions); |
| 2030 | case MagickLogEventOptions: return(LogEventOptions); |
| 2031 | case MagickMetricOptions: return(MetricOptions); |
| 2032 | case MagickMethodOptions: return(MethodOptions); |
| 2033 | case MagickModeOptions: return(ModeOptions); |
| 2034 | case MagickMorphologyOptions: return(MorphologyOptions); |
| 2035 | case MagickNoiseOptions: return(NoiseOptions); |
| 2036 | case MagickOrientationOptions: return(OrientationOptions); |
| 2037 | case MagickPixelChannelOptions: return(PixelChannelOptions); |
| 2038 | case MagickPixelIntensityOptions: return(PixelIntensityOptions); |
| 2039 | case MagickPixelMaskOptions: return(PixelMaskOptions); |
| 2040 | case MagickPixelTraitOptions: return(PixelTraitOptions); |
| 2041 | case MagickPolicyDomainOptions: return(PolicyDomainOptions); |
| 2042 | case MagickPolicyRightsOptions: return(PolicyRightsOptions); |
| 2043 | case MagickPreviewOptions: return(PreviewOptions); |
| 2044 | case MagickPrimitiveOptions: return(PrimitiveOptions); |
| 2045 | case MagickQuantumFormatOptions: return(QuantumFormatOptions); |
| 2046 | case MagickResolutionOptions: return(ResolutionOptions); |
| 2047 | case MagickResourceOptions: return(ResourceOptions); |
| 2048 | case MagickSparseColorOptions: return(SparseColorOptions); |
| 2049 | case MagickStatisticOptions: return(StatisticOptions); |
| 2050 | case MagickStorageOptions: return(StorageOptions); |
| 2051 | case MagickStretchOptions: return(StretchOptions); |
| 2052 | case MagickStyleOptions: return(StyleOptions); |
| 2053 | case MagickTypeOptions: return(TypeOptions); |
| 2054 | case MagickValidateOptions: return(ValidateOptions); |
| 2055 | case MagickVirtualPixelOptions: return(VirtualPixelOptions); |
| 2056 | default: break; |
| 2057 | } |
| 2058 | return((const OptionInfo *) NULL); |
| 2059 | } |
| 2060 | |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2061 | MagickExport ssize_t GetCommandOptionFlags(const CommandOption option, |
| 2062 | const MagickBooleanType list,const char *options) |
| 2063 | { |
| 2064 | char |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2065 | token[MagickPathExtent]; |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2066 | |
| 2067 | const OptionInfo |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2068 | *command_info, |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2069 | *option_info; |
| 2070 | |
| 2071 | int |
| 2072 | sentinel; |
| 2073 | |
| 2074 | MagickBooleanType |
| 2075 | negate; |
| 2076 | |
| 2077 | register char |
| 2078 | *q; |
| 2079 | |
| 2080 | register const char |
| 2081 | *p; |
| 2082 | |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2083 | register ssize_t |
| 2084 | i; |
| 2085 | |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2086 | ssize_t |
| 2087 | option_types; |
| 2088 | |
| 2089 | option_info=GetOptionInfo(option); |
| 2090 | if (option_info == (const OptionInfo *) NULL) |
anthony | e8f5649 | 2012-02-12 12:39:02 +0000 | [diff] [blame] | 2091 | return(UndefinedOptionFlag); |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2092 | option_types=0; |
| 2093 | sentinel=','; |
| 2094 | if (strchr(options,'|') != (char *) NULL) |
| 2095 | sentinel='|'; |
| 2096 | for (p=options; p != (char *) NULL; p=strchr(p,sentinel)) |
| 2097 | { |
| 2098 | while (((isspace((int) ((unsigned char) *p)) != 0) || (*p == sentinel)) && |
| 2099 | (*p != '\0')) |
| 2100 | p++; |
| 2101 | negate=(*p == '!') ? MagickTrue : MagickFalse; |
| 2102 | if (negate != MagickFalse) |
| 2103 | p++; |
| 2104 | q=token; |
| 2105 | while (((isspace((int) ((unsigned char) *p)) == 0) && (*p != sentinel)) && |
| 2106 | (*p != '\0')) |
| 2107 | { |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2108 | if ((q-token) >= (MagickPathExtent-1)) |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2109 | break; |
| 2110 | *q++=(*p++); |
| 2111 | } |
| 2112 | *q='\0'; |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 2113 | for (i=0; option_info[i].mnemonic != (char *) NULL; i++) |
| 2114 | if (LocaleCompare(token,option_info[i].mnemonic) == 0) |
| 2115 | break; |
| 2116 | command_info=option_info+i; |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2117 | if ((command_info->mnemonic == (const char *) NULL) && |
| 2118 | ((strchr(token+1,'-') != (char *) NULL) || |
| 2119 | (strchr(token+1,'_') != (char *) NULL))) |
| 2120 | { |
| 2121 | while ((q=strchr(token+1,'-')) != (char *) NULL) |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2122 | (void) CopyMagickString(q,q+1,MagickPathExtent-strlen(q)); |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2123 | while ((q=strchr(token+1,'_')) != (char *) NULL) |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2124 | (void) CopyMagickString(q,q+1,MagickPathExtent-strlen(q)); |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 2125 | for (i=0; option_info[i].mnemonic != (char *) NULL; i++) |
| 2126 | if (LocaleCompare(token,option_info[i].mnemonic) == 0) |
| 2127 | break; |
| 2128 | command_info=option_info+i; |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2129 | } |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2130 | if (command_info->mnemonic == (const char *) NULL) |
| 2131 | return(-1); |
| 2132 | if (negate != MagickFalse) |
| 2133 | option_types=option_types &~ command_info->flags; |
| 2134 | else |
| 2135 | option_types=option_types | command_info->flags; |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2136 | if (list == MagickFalse) |
| 2137 | break; |
| 2138 | } |
| 2139 | return(option_types); |
| 2140 | } |
| 2141 | |
| 2142 | /* |
| 2143 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2144 | % % |
| 2145 | % % |
| 2146 | % % |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 2147 | % G e t C o m m a n d O p t i o n I n f o % |
| 2148 | % % |
| 2149 | % % |
| 2150 | % % |
| 2151 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2152 | % |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 2153 | % GetCommandOptionInfo() returns a pointer to the matching OptionInfo entry |
| 2154 | % for the "CommandOptions" table. It returns both the type (argument count) |
| 2155 | % and flags (argument type). |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 2156 | % |
| 2157 | % The format of the GetCommandOptionInfo method is: |
| 2158 | % |
cristy | 2de4a8b | 2014-09-10 22:48:09 +0000 | [diff] [blame] | 2159 | % const char **GetCommandOptionInfo(const char *option) |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 2160 | % |
| 2161 | % A description of each parameter follows: |
| 2162 | % |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 2163 | % o option: the option. |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 2164 | % |
| 2165 | */ |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 2166 | MagickExport const OptionInfo *GetCommandOptionInfo(const char *option) |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 2167 | { |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 2168 | register ssize_t |
| 2169 | i; |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 2170 | |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 2171 | for (i=0; CommandOptions[i].mnemonic != (char *) NULL; i++) |
| 2172 | if (LocaleCompare(option,CommandOptions[i].mnemonic) == 0) |
| 2173 | break; |
| 2174 | return(CommandOptions+i); |
anthony | 686b1a3 | 2012-02-15 14:50:53 +0000 | [diff] [blame] | 2175 | } |
| 2176 | |
| 2177 | /* |
| 2178 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2179 | % % |
| 2180 | % % |
| 2181 | % % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2182 | % G e t C o m m a n d O p t i o n s % |
| 2183 | % % |
| 2184 | % % |
| 2185 | % % |
| 2186 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2187 | % |
cristy | b1da206 | 2014-09-10 12:51:49 +0000 | [diff] [blame] | 2188 | % GetCommandOptions() returns a list of command options. |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2189 | % |
| 2190 | % The format of the GetCommandOptions method is: |
| 2191 | % |
cristy | b1da206 | 2014-09-10 12:51:49 +0000 | [diff] [blame] | 2192 | % const char **GetCommandOptions(const CommandOption option) |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2193 | % |
| 2194 | % A description of each parameter follows: |
| 2195 | % |
cristy | b1da206 | 2014-09-10 12:51:49 +0000 | [diff] [blame] | 2196 | % o option: the option. |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2197 | % |
| 2198 | */ |
cristy | b1da206 | 2014-09-10 12:51:49 +0000 | [diff] [blame] | 2199 | MagickExport char **GetCommandOptions(const CommandOption option) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2200 | { |
| 2201 | char |
cristy | b1da206 | 2014-09-10 12:51:49 +0000 | [diff] [blame] | 2202 | **options; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2203 | |
| 2204 | const OptionInfo |
| 2205 | *option_info; |
| 2206 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2207 | register ssize_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2208 | i; |
| 2209 | |
cristy | b1da206 | 2014-09-10 12:51:49 +0000 | [diff] [blame] | 2210 | option_info=GetOptionInfo(option); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2211 | if (option_info == (const OptionInfo *) NULL) |
| 2212 | return((char **) NULL); |
| 2213 | for (i=0; option_info[i].mnemonic != (const char *) NULL; i++) ; |
cristy | b1da206 | 2014-09-10 12:51:49 +0000 | [diff] [blame] | 2214 | options=(char **) AcquireQuantumMemory((size_t) i+1UL,sizeof(*options)); |
| 2215 | if (options == (char **) NULL) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2216 | ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); |
| 2217 | for (i=0; option_info[i].mnemonic != (const char *) NULL; i++) |
cristy | b1da206 | 2014-09-10 12:51:49 +0000 | [diff] [blame] | 2218 | options[i]=AcquireString(option_info[i].mnemonic); |
| 2219 | options[i]=(char *) NULL; |
| 2220 | return(options); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2221 | } |
| 2222 | |
| 2223 | /* |
| 2224 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2225 | % % |
| 2226 | % % |
| 2227 | % % |
| 2228 | % G e t N e x t I m a g e O p t i o n % |
| 2229 | % % |
| 2230 | % % |
| 2231 | % % |
| 2232 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2233 | % |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 2234 | % GetNextImageOption() gets the next global option value. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2235 | % |
| 2236 | % The format of the GetNextImageOption method is: |
| 2237 | % |
| 2238 | % char *GetNextImageOption(const ImageInfo *image_info) |
| 2239 | % |
| 2240 | % A description of each parameter follows: |
| 2241 | % |
| 2242 | % o image_info: the image info. |
| 2243 | % |
| 2244 | */ |
| 2245 | MagickExport char *GetNextImageOption(const ImageInfo *image_info) |
| 2246 | { |
| 2247 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 2248 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2249 | if (image_info->debug != MagickFalse) |
| 2250 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 2251 | image_info->filename); |
| 2252 | if (image_info->options == (void *) NULL) |
| 2253 | return((char *) NULL); |
| 2254 | return((char *) GetNextKeyInSplayTree((SplayTreeInfo *) image_info->options)); |
| 2255 | } |
| 2256 | |
| 2257 | /* |
| 2258 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2259 | % % |
| 2260 | % % |
| 2261 | % % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2262 | % I s C o m m a n d O p t i o n % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2263 | % % |
| 2264 | % % |
| 2265 | % % |
| 2266 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2267 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2268 | % IsCommandOption() returns MagickTrue if the option begins with a - or + and |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2269 | % the first character that follows is alphanumeric. |
| 2270 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2271 | % The format of the IsCommandOption method is: |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2272 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2273 | % MagickBooleanType IsCommandOption(const char *option) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2274 | % |
| 2275 | % A description of each parameter follows: |
| 2276 | % |
| 2277 | % o option: the option. |
| 2278 | % |
| 2279 | */ |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2280 | MagickExport MagickBooleanType IsCommandOption(const char *option) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2281 | { |
| 2282 | assert(option != (const char *) NULL); |
| 2283 | if ((*option != '-') && (*option != '+')) |
| 2284 | return(MagickFalse); |
| 2285 | if (strlen(option) == 1) |
dirk | b9dbc29 | 2015-07-26 09:50:00 +0000 | [diff] [blame^] | 2286 | return(((*option == '{') || (*option == '}') || (*option == '[') || |
| 2287 | (*option == ']')) ? MagickTrue : MagickFalse); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2288 | option++; |
anthony | e5b3965 | 2012-04-21 05:37:29 +0000 | [diff] [blame] | 2289 | if (*option == '-') |
| 2290 | return(MagickTrue); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2291 | if (isalpha((int) ((unsigned char) *option)) == 0) |
| 2292 | return(MagickFalse); |
| 2293 | return(MagickTrue); |
| 2294 | } |
| 2295 | |
| 2296 | /* |
| 2297 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2298 | % % |
| 2299 | % % |
| 2300 | % % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2301 | % C o m m a n d O p t i o n T o M n e m o n i c % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2302 | % % |
| 2303 | % % |
| 2304 | % % |
| 2305 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2306 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2307 | % CommandOptionToMnemonic() returns an enumerated value as a mnemonic. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2308 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2309 | % The format of the CommandOptionToMnemonic method is: |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2310 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2311 | % const char *CommandOptionToMnemonic(const CommandOption option, |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2312 | % const ssize_t type) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2313 | % |
| 2314 | % A description of each parameter follows: |
| 2315 | % |
| 2316 | % o option: the option. |
| 2317 | % |
| 2318 | % o type: one or more values separated by commas. |
| 2319 | % |
| 2320 | */ |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2321 | MagickExport const char *CommandOptionToMnemonic(const CommandOption option, |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2322 | const ssize_t type) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2323 | { |
| 2324 | const OptionInfo |
| 2325 | *option_info; |
| 2326 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2327 | register ssize_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2328 | i; |
| 2329 | |
| 2330 | option_info=GetOptionInfo(option); |
| 2331 | if (option_info == (const OptionInfo *) NULL) |
| 2332 | return((const char *) NULL); |
| 2333 | for (i=0; option_info[i].mnemonic != (const char *) NULL; i++) |
| 2334 | if (type == option_info[i].type) |
| 2335 | break; |
| 2336 | if (option_info[i].mnemonic == (const char *) NULL) |
dirk | 8862904 | 2014-12-18 20:05:33 +0000 | [diff] [blame] | 2337 | return("Unrecognized"); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2338 | return(option_info[i].mnemonic); |
| 2339 | } |
| 2340 | |
| 2341 | /* |
| 2342 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2343 | % % |
| 2344 | % % |
| 2345 | % % |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2346 | % I s O p t i o n M e m b e r % |
| 2347 | % % |
| 2348 | % % |
| 2349 | % % |
| 2350 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2351 | % |
| 2352 | % IsOptionMember() returns MagickTrue if the option is a member of the options |
| 2353 | % list (e.g. ICC is a member of xmp,icc,iptc). |
| 2354 | % |
| 2355 | % The format of the IsOptionMember function is: |
| 2356 | % |
| 2357 | % MagickBooleanType IsOptionMember(const char *option, |
| 2358 | % const char *options) |
| 2359 | % |
| 2360 | % A description of each parameter follows: |
| 2361 | % |
| 2362 | % o option: an option or option expression (e.g. ICC or *). |
| 2363 | % |
| 2364 | % o options: one or more options separated by commas. |
| 2365 | % |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2366 | */ |
cristy | 0f975d1 | 2014-06-25 18:44:04 +0000 | [diff] [blame] | 2367 | MagickExport MagickBooleanType IsOptionMember(const char *option, |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2368 | const char *options) |
| 2369 | { |
| 2370 | char |
| 2371 | **option_list, |
| 2372 | *string; |
| 2373 | |
| 2374 | int |
| 2375 | number_options; |
| 2376 | |
cristy | 53b6cc3 | 2014-06-25 13:13:33 +0000 | [diff] [blame] | 2377 | MagickBooleanType |
| 2378 | member; |
| 2379 | |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2380 | register ssize_t |
| 2381 | i; |
| 2382 | |
| 2383 | /* |
| 2384 | Is option a member of the options list? |
| 2385 | */ |
cristy | 53b6cc3 | 2014-06-25 13:13:33 +0000 | [diff] [blame] | 2386 | if (options == (const char *) NULL) |
| 2387 | return(MagickFalse); |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2388 | string=ConstantString(options); |
| 2389 | (void) SubstituteString(&string,","," "); |
| 2390 | option_list=StringToArgv(string,&number_options); |
| 2391 | string=DestroyString(string); |
| 2392 | if (option_list == (char **) NULL) |
| 2393 | return(MagickFalse); |
cristy | 53b6cc3 | 2014-06-25 13:13:33 +0000 | [diff] [blame] | 2394 | member=MagickFalse; |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2395 | for (i=1; i < (ssize_t) number_options; i++) |
| 2396 | { |
| 2397 | if ((*option_list[i] == '!') && |
| 2398 | (LocaleCompare(option,option_list[i]+1) == 0)) |
cristy | 53b6cc3 | 2014-06-25 13:13:33 +0000 | [diff] [blame] | 2399 | break; |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2400 | if (GlobExpression(option,option_list[i],MagickTrue) != MagickFalse) |
cristy | 53b6cc3 | 2014-06-25 13:13:33 +0000 | [diff] [blame] | 2401 | { |
| 2402 | member=MagickTrue; |
| 2403 | break; |
| 2404 | } |
| 2405 | option_list[i]=DestroyString(option_list[i]); |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2406 | } |
cristy | 53b6cc3 | 2014-06-25 13:13:33 +0000 | [diff] [blame] | 2407 | for ( ; i < (ssize_t) number_options; i++) |
| 2408 | option_list[i]=DestroyString(option_list[i]); |
| 2409 | option_list=(char **) RelinquishMagickMemory(option_list); |
| 2410 | return(member); |
cristy | 71ffec4 | 2014-06-25 12:52:49 +0000 | [diff] [blame] | 2411 | } |
| 2412 | |
| 2413 | /* |
| 2414 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2415 | % % |
| 2416 | % % |
| 2417 | % % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2418 | % L i s t C o m m a n d O p t i o n s % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2419 | % % |
| 2420 | % % |
| 2421 | % % |
| 2422 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2423 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2424 | % ListCommandOptions() lists the contents of enumerated option type(s). |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2425 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2426 | % The format of the ListCommandOptions method is: |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2427 | % |
cristy | 2b9582a | 2011-07-04 17:38:56 +0000 | [diff] [blame] | 2428 | % MagickBooleanType ListCommandOptions(FILE *file, |
| 2429 | % const CommandOption option,ExceptionInfo *exception) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2430 | % |
| 2431 | % A description of each parameter follows: |
| 2432 | % |
| 2433 | % o file: list options to this file handle. |
| 2434 | % |
| 2435 | % o option: list these options. |
| 2436 | % |
| 2437 | % o exception: return any errors or warnings in this structure. |
| 2438 | % |
| 2439 | */ |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2440 | MagickExport MagickBooleanType ListCommandOptions(FILE *file, |
| 2441 | const CommandOption option,ExceptionInfo *magick_unused(exception)) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2442 | { |
| 2443 | const OptionInfo |
| 2444 | *option_info; |
| 2445 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2446 | register ssize_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2447 | i; |
| 2448 | |
| 2449 | if (file == (FILE *) NULL) |
| 2450 | file=stdout; |
| 2451 | option_info=GetOptionInfo(option); |
| 2452 | if (option_info == (const OptionInfo *) NULL) |
| 2453 | return(MagickFalse); |
| 2454 | for (i=0; option_info[i].mnemonic != (char *) NULL; i++) |
| 2455 | { |
| 2456 | if (option_info[i].stealth != MagickFalse) |
| 2457 | continue; |
cristy | b51dff5 | 2011-05-19 16:55:47 +0000 | [diff] [blame] | 2458 | (void) FormatLocaleFile(file,"%s\n",option_info[i].mnemonic); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2459 | } |
| 2460 | return(MagickTrue); |
| 2461 | } |
| 2462 | |
| 2463 | /* |
| 2464 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2465 | % % |
| 2466 | % % |
| 2467 | % % |
| 2468 | % P a r s e C h a n n e l O p t i o n % |
| 2469 | % % |
| 2470 | % % |
| 2471 | % % |
| 2472 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2473 | % |
| 2474 | % ParseChannelOption() parses a string and returns an enumerated channel |
| 2475 | % type(s). |
| 2476 | % |
| 2477 | % The format of the ParseChannelOption method is: |
| 2478 | % |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2479 | % ssize_t ParseChannelOption(const char *channels) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2480 | % |
| 2481 | % A description of each parameter follows: |
| 2482 | % |
| 2483 | % o options: One or more values separated by commas. |
| 2484 | % |
| 2485 | */ |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2486 | MagickExport ssize_t ParseChannelOption(const char *channels) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2487 | { |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2488 | register ssize_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2489 | i; |
| 2490 | |
cristy | b9902b7 | 2010-10-05 18:21:50 +0000 | [diff] [blame] | 2491 | ssize_t |
| 2492 | channel; |
| 2493 | |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2494 | channel=ParseCommandOption(MagickChannelOptions,MagickTrue,channels); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2495 | if (channel >= 0) |
| 2496 | return(channel); |
| 2497 | channel=0; |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2498 | for (i=0; i < (ssize_t) strlen(channels); i++) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2499 | { |
| 2500 | switch (channels[i]) |
| 2501 | { |
| 2502 | case 'A': |
| 2503 | case 'a': |
| 2504 | { |
cristy | 953c4bd | 2012-02-24 01:04:04 +0000 | [diff] [blame] | 2505 | channel|=AlphaChannel; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2506 | break; |
| 2507 | } |
| 2508 | case 'B': |
| 2509 | case 'b': |
| 2510 | { |
| 2511 | channel|=BlueChannel; |
| 2512 | break; |
| 2513 | } |
| 2514 | case 'C': |
| 2515 | case 'c': |
| 2516 | { |
| 2517 | channel|=CyanChannel; |
| 2518 | break; |
| 2519 | } |
| 2520 | case 'g': |
| 2521 | case 'G': |
| 2522 | { |
| 2523 | channel|=GreenChannel; |
| 2524 | break; |
| 2525 | } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2526 | case 'K': |
| 2527 | case 'k': |
| 2528 | { |
| 2529 | channel|=BlackChannel; |
| 2530 | break; |
| 2531 | } |
| 2532 | case 'M': |
| 2533 | case 'm': |
| 2534 | { |
| 2535 | channel|=MagentaChannel; |
| 2536 | break; |
| 2537 | } |
| 2538 | case 'o': |
| 2539 | case 'O': |
| 2540 | { |
anthony | 30b912a | 2012-03-22 01:20:28 +0000 | [diff] [blame] | 2541 | channel|=AlphaChannel; /* depreciate */ |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2542 | break; |
| 2543 | } |
| 2544 | case 'R': |
| 2545 | case 'r': |
| 2546 | { |
| 2547 | channel|=RedChannel; |
| 2548 | break; |
| 2549 | } |
| 2550 | case 'Y': |
| 2551 | case 'y': |
| 2552 | { |
| 2553 | channel|=YellowChannel; |
| 2554 | break; |
| 2555 | } |
| 2556 | case ',': |
| 2557 | { |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 2558 | ssize_t |
cristy | 3e4015d | 2010-10-05 18:18:56 +0000 | [diff] [blame] | 2559 | type; |
| 2560 | |
| 2561 | /* |
| 2562 | Gather the additional channel flags and merge with shorthand. |
| 2563 | */ |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2564 | type=ParseCommandOption(MagickChannelOptions,MagickTrue,channels+i+1); |
cristy | 3e4015d | 2010-10-05 18:18:56 +0000 | [diff] [blame] | 2565 | if (type < 0) |
| 2566 | return(type); |
| 2567 | channel|=type; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2568 | return(channel); |
| 2569 | } |
| 2570 | default: |
| 2571 | return(-1); |
| 2572 | } |
| 2573 | } |
| 2574 | return(channel); |
| 2575 | } |
| 2576 | |
| 2577 | /* |
| 2578 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2579 | % % |
| 2580 | % % |
| 2581 | % % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2582 | % P a r s e C o m m a n d O p t i o n % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2583 | % % |
| 2584 | % % |
| 2585 | % % |
| 2586 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2587 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2588 | % ParseCommandOption() parses a string and returns an enumerated option |
anthony | ce2716b | 2011-04-22 09:51:34 +0000 | [diff] [blame] | 2589 | % type(s). Return a value of -1 if no such option is found. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2590 | % |
cristy | 042ee78 | 2011-04-22 18:48:30 +0000 | [diff] [blame] | 2591 | % The format of the ParseCommandOption method is: |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2592 | % |
cristy | 0dbbb45 | 2014-09-11 00:24:21 +0000 | [diff] [blame] | 2593 | % ssize_t ParseCommandOption(const CommandOption option, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2594 | % const MagickBooleanType list,const char *options) |
| 2595 | % |
| 2596 | % A description of each parameter follows: |
| 2597 | % |
cristy | 0dbbb45 | 2014-09-11 00:24:21 +0000 | [diff] [blame] | 2598 | % o option: Index to the option table to lookup |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2599 | % |
| 2600 | % o list: A option other than zero permits more than one option separated by |
| 2601 | % a comma or pipe. |
| 2602 | % |
| 2603 | % o options: One or more options separated by commas. |
| 2604 | % |
| 2605 | */ |
cristy | 0dbbb45 | 2014-09-11 00:24:21 +0000 | [diff] [blame] | 2606 | MagickExport ssize_t ParseCommandOption(const CommandOption option, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2607 | const MagickBooleanType list,const char *options) |
| 2608 | { |
| 2609 | char |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2610 | token[MagickPathExtent]; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2611 | |
| 2612 | const OptionInfo |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2613 | *command_info, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2614 | *option_info; |
| 2615 | |
| 2616 | int |
| 2617 | sentinel; |
| 2618 | |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2619 | MagickBooleanType |
| 2620 | negate; |
| 2621 | |
| 2622 | register char |
| 2623 | *q; |
| 2624 | |
| 2625 | register const char |
| 2626 | *p; |
| 2627 | |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2628 | register ssize_t |
| 2629 | i; |
| 2630 | |
cristy | b9902b7 | 2010-10-05 18:21:50 +0000 | [diff] [blame] | 2631 | ssize_t |
| 2632 | option_types; |
| 2633 | |
cristy | 359b929 | 2015-06-28 22:58:24 +0000 | [diff] [blame] | 2634 | if (options == (const char *) NULL) |
| 2635 | return(-1); |
cristy | 0dbbb45 | 2014-09-11 00:24:21 +0000 | [diff] [blame] | 2636 | option_info=GetOptionInfo(option); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2637 | if (option_info == (const OptionInfo *) NULL) |
| 2638 | return(-1); |
| 2639 | option_types=0; |
| 2640 | sentinel=','; |
| 2641 | if (strchr(options,'|') != (char *) NULL) |
| 2642 | sentinel='|'; |
| 2643 | for (p=options; p != (char *) NULL; p=strchr(p,sentinel)) |
| 2644 | { |
| 2645 | while (((isspace((int) ((unsigned char) *p)) != 0) || (*p == sentinel)) && |
| 2646 | (*p != '\0')) |
| 2647 | p++; |
| 2648 | negate=(*p == '!') ? MagickTrue : MagickFalse; |
| 2649 | if (negate != MagickFalse) |
| 2650 | p++; |
| 2651 | q=token; |
| 2652 | while (((isspace((int) ((unsigned char) *p)) == 0) && (*p != sentinel)) && |
| 2653 | (*p != '\0')) |
| 2654 | { |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2655 | if ((q-token) >= (MagickPathExtent-1)) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2656 | break; |
| 2657 | *q++=(*p++); |
| 2658 | } |
| 2659 | *q='\0'; |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 2660 | for (i=0; option_info[i].mnemonic != (char *) NULL; i++) |
| 2661 | if (LocaleCompare(token,option_info[i].mnemonic) == 0) |
| 2662 | break; |
| 2663 | command_info=option_info+i; |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2664 | if ((command_info->mnemonic == (const char *) NULL) && |
| 2665 | ((strchr(token+1,'-') != (char *) NULL) || |
| 2666 | (strchr(token+1,'_') != (char *) NULL))) |
| 2667 | { |
| 2668 | while ((q=strchr(token+1,'-')) != (char *) NULL) |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2669 | (void) CopyMagickString(q,q+1,MagickPathExtent-strlen(q)); |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2670 | while ((q=strchr(token+1,'_')) != (char *) NULL) |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2671 | (void) CopyMagickString(q,q+1,MagickPathExtent-strlen(q)); |
cristy | 6284185 | 2014-09-12 15:24:39 +0000 | [diff] [blame] | 2672 | for (i=0; option_info[i].mnemonic != (char *) NULL; i++) |
| 2673 | if (LocaleCompare(token,option_info[i].mnemonic) == 0) |
| 2674 | break; |
| 2675 | command_info=option_info+i; |
cristy | 141ad9a | 2014-09-11 23:37:24 +0000 | [diff] [blame] | 2676 | } |
| 2677 | if (command_info->mnemonic == (const char *) NULL) |
| 2678 | return(-1); |
| 2679 | if (negate != MagickFalse) |
| 2680 | option_types=option_types &~ command_info->type; |
| 2681 | else |
| 2682 | option_types=option_types | command_info->type; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2683 | if (list == MagickFalse) |
| 2684 | break; |
| 2685 | } |
| 2686 | return(option_types); |
| 2687 | } |
| 2688 | |
| 2689 | /* |
| 2690 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2691 | % % |
| 2692 | % % |
| 2693 | % % |
cristy | 953c4bd | 2012-02-24 01:04:04 +0000 | [diff] [blame] | 2694 | % P a r s e P i x e l C h a n n e l O p t i o n % |
| 2695 | % % |
| 2696 | % % |
| 2697 | % % |
| 2698 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2699 | % |
| 2700 | % ParsePixelChannelOption() parses a string and returns an enumerated pixel |
| 2701 | % channel type(s). |
| 2702 | % |
| 2703 | % The format of the ParsePixelChannelOption method is: |
| 2704 | % |
| 2705 | % ssize_t ParsePixelChannelOption(const char *channels) |
| 2706 | % |
| 2707 | % A description of each parameter follows: |
| 2708 | % |
cristy | d04e7bf | 2012-03-03 19:19:12 +0000 | [diff] [blame] | 2709 | % o channels: One or more channels separated by commas. |
cristy | 953c4bd | 2012-02-24 01:04:04 +0000 | [diff] [blame] | 2710 | % |
| 2711 | */ |
| 2712 | MagickExport ssize_t ParsePixelChannelOption(const char *channels) |
| 2713 | { |
cristy | d04e7bf | 2012-03-03 19:19:12 +0000 | [diff] [blame] | 2714 | char |
cristy | a15140f | 2012-03-04 01:21:15 +0000 | [diff] [blame] | 2715 | *q, |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 2716 | token[MagickPathExtent]; |
cristy | 953c4bd | 2012-02-24 01:04:04 +0000 | [diff] [blame] | 2717 | |
| 2718 | ssize_t |
| 2719 | channel; |
| 2720 | |
cristy | a15140f | 2012-03-04 01:21:15 +0000 | [diff] [blame] | 2721 | GetMagickToken(channels,NULL,token); |
cristy | d4311d4 | 2012-03-18 23:03:10 +0000 | [diff] [blame] | 2722 | if ((*token == ';') || (*token == '|')) |
| 2723 | return(RedPixelChannel); |
cristy | a15140f | 2012-03-04 01:21:15 +0000 | [diff] [blame] | 2724 | channel=ParseCommandOption(MagickPixelChannelOptions,MagickTrue,token); |
cristy | 953c4bd | 2012-02-24 01:04:04 +0000 | [diff] [blame] | 2725 | if (channel >= 0) |
| 2726 | return(channel); |
cristy | a15140f | 2012-03-04 01:21:15 +0000 | [diff] [blame] | 2727 | q=(char *) token; |
cristy | b01e49e | 2014-09-09 22:59:01 +0000 | [diff] [blame] | 2728 | channel=(ssize_t) InterpretLocaleValue(token,&q); |
cristy | abb241b | 2012-03-06 01:12:58 +0000 | [diff] [blame] | 2729 | if ((q == token) || (channel < 0) || (channel >= MaxPixelChannels)) |
cristy | d04e7bf | 2012-03-03 19:19:12 +0000 | [diff] [blame] | 2730 | return(-1); |
cristy | 953c4bd | 2012-02-24 01:04:04 +0000 | [diff] [blame] | 2731 | return(channel); |
| 2732 | } |
| 2733 | |
| 2734 | /* |
| 2735 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2736 | % % |
| 2737 | % % |
| 2738 | % % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2739 | % R e m o v e I m a g e O p t i o n % |
| 2740 | % % |
| 2741 | % % |
| 2742 | % % |
| 2743 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2744 | % |
| 2745 | % RemoveImageOption() removes an option from the image and returns its value. |
| 2746 | % |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 2747 | % In this case the ConstantString() value returned should be freed by the |
| 2748 | % caller when finished. |
| 2749 | % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2750 | % The format of the RemoveImageOption method is: |
| 2751 | % |
| 2752 | % char *RemoveImageOption(ImageInfo *image_info,const char *option) |
| 2753 | % |
| 2754 | % A description of each parameter follows: |
| 2755 | % |
| 2756 | % o image_info: the image info. |
| 2757 | % |
| 2758 | % o option: the image option. |
| 2759 | % |
| 2760 | */ |
| 2761 | MagickExport char *RemoveImageOption(ImageInfo *image_info,const char *option) |
| 2762 | { |
| 2763 | char |
| 2764 | *value; |
| 2765 | |
| 2766 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 2767 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2768 | if (image_info->debug != MagickFalse) |
| 2769 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 2770 | image_info->filename); |
| 2771 | if (image_info->options == (void *) NULL) |
| 2772 | return((char *) NULL); |
| 2773 | value=(char *) RemoveNodeFromSplayTree((SplayTreeInfo *) |
| 2774 | image_info->options,option); |
| 2775 | return(value); |
| 2776 | } |
| 2777 | |
| 2778 | /* |
| 2779 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2780 | % % |
| 2781 | % % |
| 2782 | % % |
| 2783 | % R e s e t I m a g e O p t i o n % |
| 2784 | % % |
| 2785 | % % |
| 2786 | % % |
| 2787 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2788 | % |
| 2789 | % ResetImageOptions() resets the image_info option. That is, it deletes |
anthony | 40ca0b9 | 2012-08-02 13:23:28 +0000 | [diff] [blame] | 2790 | % all global options associated with the image_info structure. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2791 | % |
| 2792 | % The format of the ResetImageOptions method is: |
| 2793 | % |
| 2794 | % ResetImageOptions(ImageInfo *image_info) |
| 2795 | % |
| 2796 | % A description of each parameter follows: |
| 2797 | % |
| 2798 | % o image_info: the image info. |
| 2799 | % |
| 2800 | */ |
| 2801 | MagickExport void ResetImageOptions(const ImageInfo *image_info) |
| 2802 | { |
| 2803 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 2804 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2805 | if (image_info->debug != MagickFalse) |
| 2806 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 2807 | image_info->filename); |
| 2808 | if (image_info->options == (void *) NULL) |
| 2809 | return; |
| 2810 | ResetSplayTree((SplayTreeInfo *) image_info->options); |
| 2811 | } |
| 2812 | |
| 2813 | /* |
| 2814 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2815 | % % |
| 2816 | % % |
| 2817 | % % |
| 2818 | % R e s e t I m a g e O p t i o n I t e r a t o r % |
| 2819 | % % |
| 2820 | % % |
| 2821 | % % |
| 2822 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2823 | % |
| 2824 | % ResetImageOptionIterator() resets the image_info values iterator. Use it |
| 2825 | % in conjunction with GetNextImageOption() to iterate over all the values |
| 2826 | % associated with an image option. |
| 2827 | % |
| 2828 | % The format of the ResetImageOptionIterator method is: |
| 2829 | % |
| 2830 | % ResetImageOptionIterator(ImageInfo *image_info) |
| 2831 | % |
| 2832 | % A description of each parameter follows: |
| 2833 | % |
| 2834 | % o image_info: the image info. |
| 2835 | % |
| 2836 | */ |
| 2837 | MagickExport void ResetImageOptionIterator(const ImageInfo *image_info) |
| 2838 | { |
| 2839 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 2840 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2841 | if (image_info->debug != MagickFalse) |
| 2842 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 2843 | image_info->filename); |
| 2844 | if (image_info->options == (void *) NULL) |
| 2845 | return; |
| 2846 | ResetSplayTreeIterator((SplayTreeInfo *) image_info->options); |
| 2847 | } |
| 2848 | |
| 2849 | /* |
| 2850 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2851 | % % |
| 2852 | % % |
| 2853 | % % |
| 2854 | % S e t I m a g e O p t i o n % |
| 2855 | % % |
| 2856 | % % |
| 2857 | % % |
| 2858 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 2859 | % |
| 2860 | % SetImageOption() associates an value with an image option. |
| 2861 | % |
| 2862 | % The format of the SetImageOption method is: |
| 2863 | % |
| 2864 | % MagickBooleanType SetImageOption(ImageInfo *image_info, |
| 2865 | % const char *option,const char *value) |
| 2866 | % |
| 2867 | % A description of each parameter follows: |
| 2868 | % |
| 2869 | % o image_info: the image info. |
| 2870 | % |
| 2871 | % o option: the image option. |
| 2872 | % |
| 2873 | % o values: the image option values. |
| 2874 | % |
| 2875 | */ |
| 2876 | MagickExport MagickBooleanType SetImageOption(ImageInfo *image_info, |
| 2877 | const char *option,const char *value) |
| 2878 | { |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2879 | assert(image_info != (ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 2880 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2881 | if (image_info->debug != MagickFalse) |
| 2882 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 2883 | image_info->filename); |
cristy | c96a1ba | 2013-03-28 13:05:04 +0000 | [diff] [blame] | 2884 | /* |
| 2885 | Specific global option settings. |
| 2886 | */ |
anthony | a322a83 | 2013-04-27 06:28:03 +0000 | [diff] [blame] | 2887 | if (LocaleCompare(option,"size") == 0) { |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2888 | (void) CloneString(&image_info->size,value); |
anthony | a322a83 | 2013-04-27 06:28:03 +0000 | [diff] [blame] | 2889 | return(MagickTrue); |
| 2890 | } |
cristy | c96a1ba | 2013-03-28 13:05:04 +0000 | [diff] [blame] | 2891 | /* |
| 2892 | Create tree if needed - specify how key,values are to be freed. |
| 2893 | */ |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2894 | if (image_info->options == (void *) NULL) |
| 2895 | image_info->options=NewSplayTree(CompareSplayTreeString, |
| 2896 | RelinquishMagickMemory,RelinquishMagickMemory); |
cristy | c96a1ba | 2013-03-28 13:05:04 +0000 | [diff] [blame] | 2897 | /* |
| 2898 | Delete Option if NULL -- empty string values are valid! |
| 2899 | */ |
anthony | d181ea0 | 2011-10-12 07:44:13 +0000 | [diff] [blame] | 2900 | if (value == (const char *) NULL) |
| 2901 | return(DeleteImageOption(image_info,option)); |
cristy | c96a1ba | 2013-03-28 13:05:04 +0000 | [diff] [blame] | 2902 | /* |
| 2903 | Add option to splay-tree. |
| 2904 | */ |
cristy | e3f7779 | 2011-10-07 00:09:09 +0000 | [diff] [blame] | 2905 | return(AddValueToSplayTree((SplayTreeInfo *) image_info->options, |
| 2906 | ConstantString(option),ConstantString(value))); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 2907 | } |