~ubuntu-branches/ubuntu/oneiric/imagemagick/oneiric-updates

« back to all changes in this revision

Viewing changes to magick/option.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2011-06-15 11:05:28 UTC
  • mfrom: (6.2.11 sid)
  • Revision ID: james.westby@ubuntu.com-20110615110528-08jgo07a4846xh8d
Tags: 8:6.6.0.4-3ubuntu1
* Resynchronise with Debian (LP: #797595).  Remaining changes:
  - Make ufraw-batch (universe) a suggestion instead of a recommendation.
  - Make debian/rules install target depend on check; they cannot reliably
    be run in parallel.
  - Don't set MAKEFLAGS in debian/rules; just pass it to the build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
80
80
static const OptionInfo
81
81
  AlignOptions[] =
82
82
  {
83
 
    { "Undefined", (ssize_t) UndefinedAlign, MagickTrue },
84
 
    { "Center", (ssize_t) CenterAlign, MagickFalse },
85
 
    { "End", (ssize_t) RightAlign, MagickFalse },
86
 
    { "Left", (ssize_t) LeftAlign, MagickFalse },
87
 
    { "Middle", (ssize_t) CenterAlign, MagickFalse },
88
 
    { "Right", (ssize_t) RightAlign, MagickFalse },
89
 
    { "Start", (ssize_t) LeftAlign, MagickFalse },
90
 
    { (char *) NULL, (ssize_t) UndefinedAlign, MagickFalse }
 
83
    { "Undefined", (long) UndefinedAlign, MagickTrue },
 
84
    { "Center", (long) CenterAlign, MagickFalse },
 
85
    { "End", (long) RightAlign, MagickFalse },
 
86
    { "Left", (long) LeftAlign, MagickFalse },
 
87
    { "Middle", (long) CenterAlign, MagickFalse },
 
88
    { "Right", (long) RightAlign, MagickFalse },
 
89
    { "Start", (long) LeftAlign, MagickFalse },
 
90
    { (char *) NULL, (long) UndefinedAlign, MagickFalse }
91
91
  },
92
92
  AlphaOptions[] =
93
93
  {
94
 
    { "Undefined", (ssize_t) UndefinedAlphaChannel, MagickTrue },
95
 
    { "Activate", (ssize_t) ActivateAlphaChannel, MagickFalse },
96
 
    { "Background", (ssize_t) BackgroundAlphaChannel, MagickFalse },
97
 
    { "Copy", (ssize_t) CopyAlphaChannel, MagickFalse },
98
 
    { "Deactivate", (ssize_t) DeactivateAlphaChannel, MagickFalse },
99
 
    { "Extract", (ssize_t) ExtractAlphaChannel, MagickFalse },
100
 
    { "Off", (ssize_t) DeactivateAlphaChannel, MagickFalse },
101
 
    { "On", (ssize_t) ActivateAlphaChannel, MagickFalse },
102
 
    { "Opaque", (ssize_t) OpaqueAlphaChannel, MagickFalse },
103
 
    { "Set", (ssize_t) SetAlphaChannel, MagickFalse },
104
 
    { "Shape", (ssize_t) ShapeAlphaChannel, MagickFalse },
105
 
    { "Reset", (ssize_t) SetAlphaChannel, MagickTrue },  /* deprecated */
106
 
    { "Transparent", (ssize_t) TransparentAlphaChannel, MagickFalse },
107
 
    { (char *) NULL, (ssize_t) UndefinedAlphaChannel, MagickFalse }
 
94
    { "Undefined", (long) UndefinedAlphaChannel, MagickTrue },
 
95
    { "Activate", (long) ActivateAlphaChannel, MagickFalse },
 
96
    { "Background", (long) BackgroundAlphaChannel, MagickFalse },
 
97
    { "Copy", (long) CopyAlphaChannel, MagickFalse },
 
98
    { "Deactivate", (long) DeactivateAlphaChannel, MagickFalse },
 
99
    { "Extract", (long) ExtractAlphaChannel, MagickFalse },
 
100
    { "Off", (long) DeactivateAlphaChannel, MagickFalse },
 
101
    { "On", (long) ActivateAlphaChannel, MagickFalse },
 
102
    { "Opaque", (long) OpaqueAlphaChannel, MagickFalse },
 
103
    { "Set", (long) SetAlphaChannel, MagickFalse },
 
104
    { "Shape", (long) ShapeAlphaChannel, MagickFalse },
 
105
    { "Reset", (long) SetAlphaChannel, MagickTrue }, /* deprecated */
 
106
    { "Transparent", (long) TransparentAlphaChannel, MagickFalse },
 
107
    { (char *) NULL, (long) UndefinedAlphaChannel, MagickFalse }
108
108
  },
109
109
  BooleanOptions[] =
110
110
  {
116
116
  },
117
117
  ChannelOptions[] =
118
118
  {
119
 
    { "Undefined", (ssize_t) UndefinedChannel, MagickTrue },
120
 
    { "All", (ssize_t) AllChannels, MagickFalse },
121
 
    { "Alpha", (ssize_t) OpacityChannel, MagickFalse },
122
 
    { "Black", (ssize_t) BlackChannel, MagickFalse },
123
 
    { "Blue", (ssize_t) BlueChannel, MagickFalse },
124
 
    { "Cyan", (ssize_t) CyanChannel, MagickFalse },
125
 
    { "Default", (ssize_t) DefaultChannels, MagickFalse },
126
 
    { "Gray", (ssize_t) GrayChannel, MagickFalse },
127
 
    { "Green", (ssize_t) GreenChannel, MagickFalse },
128
 
    { "Hue", (ssize_t) RedChannel, MagickFalse },
129
 
    { "Index", (ssize_t) IndexChannel, MagickFalse },
130
 
    { "Lightness", (ssize_t) BlueChannel, MagickFalse },
131
 
    { "Luminance", (ssize_t) BlueChannel, MagickFalse },
132
 
    { "Luminosity", (ssize_t) BlueChannel, MagickFalse },  /* deprecated */
133
 
    { "Magenta", (ssize_t) MagentaChannel, MagickFalse },
134
 
    { "Matte", (ssize_t) OpacityChannel, MagickFalse },
135
 
    { "Opacity", (ssize_t) OpacityChannel, MagickFalse },
136
 
    { "Red", (ssize_t) RedChannel, MagickFalse },
137
 
    { "Saturation", (ssize_t) GreenChannel, MagickFalse },
138
 
    { "Yellow", (ssize_t) YellowChannel, MagickFalse },
139
 
    { "Sync", (ssize_t) SyncChannels, MagickFalse },
140
 
    { (char *) NULL, (ssize_t) UndefinedChannel, MagickFalse }
 
119
    { "Undefined", (long) UndefinedChannel, MagickTrue },
 
120
    { "All", (long) AllChannels, MagickFalse },
 
121
    { "Alpha", (long) OpacityChannel, MagickFalse },
 
122
    { "Black", (long) BlackChannel, MagickFalse },
 
123
    { "Blue", (long) BlueChannel, MagickFalse },
 
124
    { "Cyan", (long) CyanChannel, MagickFalse },
 
125
    { "Default", (long) DefaultChannels, MagickFalse },
 
126
    { "Gray", (long) GrayChannel, MagickFalse },
 
127
    { "Green", (long) GreenChannel, MagickFalse },
 
128
    { "Hue", (long) RedChannel, MagickFalse },
 
129
    { "Index", (long) IndexChannel, MagickFalse },
 
130
    { "Lightness", (long) BlueChannel, MagickFalse },
 
131
    { "Luminance", (long) BlueChannel, MagickFalse },
 
132
    { "Luminosity", (long) BlueChannel, MagickFalse },  /* deprecated */
 
133
    { "Magenta", (long) MagentaChannel, MagickFalse },
 
134
    { "Matte", (long) OpacityChannel, MagickFalse },
 
135
    { "Opacity", (long) OpacityChannel, MagickFalse },
 
136
    { "Red", (long) RedChannel, MagickFalse },
 
137
    { "Saturation", (long) GreenChannel, MagickFalse },
 
138
    { "Yellow", (long) YellowChannel, MagickFalse },
 
139
    { "Sync", (long) SyncChannels, MagickFalse },   /* special channel flag */
 
140
    { (char *) NULL, (long) UndefinedChannel, MagickFalse }
141
141
  },
142
142
  ClassOptions[] =
143
143
  {
144
 
    { "Undefined", (ssize_t) UndefinedClass, MagickTrue },
145
 
    { "DirectClass", (ssize_t) DirectClass, MagickFalse },
146
 
    { "PseudoClass", (ssize_t) PseudoClass, MagickFalse },
147
 
    { (char *) NULL, (ssize_t) UndefinedClass, MagickFalse }
 
144
    { "Undefined", (long) UndefinedClass, MagickTrue },
 
145
    { "DirectClass", (long) DirectClass, MagickFalse },
 
146
    { "PseudoClass", (long) PseudoClass, MagickFalse },
 
147
    { (char *) NULL, (long) UndefinedClass, MagickFalse }
148
148
  },
149
149
  ClipPathOptions[] =
150
150
  {
151
 
    { "Undefined", (ssize_t) UndefinedPathUnits, MagickTrue },
152
 
    { "ObjectBoundingBox", (ssize_t) ObjectBoundingBox, MagickFalse },
153
 
    { "UserSpace", (ssize_t) UserSpace, MagickFalse },
154
 
    { "UserSpaceOnUse", (ssize_t) UserSpaceOnUse, MagickFalse },
155
 
    { (char *) NULL, (ssize_t) UndefinedPathUnits, MagickFalse }
 
151
    { "Undefined", (long) UndefinedPathUnits, MagickTrue },
 
152
    { "ObjectBoundingBox", (long) ObjectBoundingBox, MagickFalse },
 
153
    { "UserSpace", (long) UserSpace, MagickFalse },
 
154
    { "UserSpaceOnUse", (long) UserSpaceOnUse, MagickFalse },
 
155
    { (char *) NULL, (long) UndefinedPathUnits, MagickFalse }
156
156
  },
157
157
  CommandOptions[] =
158
158
  {
176
176
    { "-append", 0L, MagickFalse },
177
177
    { "+authenticate", 0L, MagickFalse },
178
178
    { "-authenticate", 1L, MagickFalse },
179
 
    { "+auto-gamma", 0L, MagickTrue },
180
 
    { "-auto-gamma", 0L, MagickTrue },
181
 
    { "+auto-level", 0L, MagickTrue },
182
 
    { "-auto-level", 0L, MagickTrue },
 
179
    { "+auto-gamma", 0L, MagickTrue },   /* under development */
 
180
    { "-auto-gamma", 0L, MagickTrue },   /* under development */
 
181
    { "+auto-level", 0L, MagickTrue },   /* under development */
 
182
    { "-auto-level", 0L, MagickTrue },   /* under development */
183
183
    { "+auto-orient", 0L, MagickFalse },
184
184
    { "-auto-orient", 0L, MagickFalse },
185
185
    { "+average", 0L, MagickFalse },
238
238
    { "-colorize", 1L, MagickFalse },
239
239
    { "+colormap", 0L, MagickFalse },
240
240
    { "-colormap", 1L, MagickFalse },
241
 
    { "+color-matrix", 0L, MagickFalse },
242
 
    { "-color-matrix", 1L, MagickFalse },
243
241
    { "+colors", 0L, MagickFalse },
244
242
    { "-colors", 1L, MagickFalse },
245
243
    { "+colorspace", 0L, MagickFalse },
288
286
    { "-deskew", 1L, MagickFalse },
289
287
    { "+despeckle", 0L, MagickFalse },
290
288
    { "-despeckle", 0L, MagickFalse },
291
 
    { "+direction", 0L, MagickFalse },
292
 
    { "-direction", 1L, MagickFalse },
293
289
    { "+displace", 0L, MagickFalse },
294
290
    { "-displace", 1L, MagickFalse },
295
291
    { "+display", 0L, MagickFalse },
686
682
    { "-window-group", 1L, MagickFalse },
687
683
    { "+write", 1L, MagickFalse },
688
684
    { "-write", 1L, MagickFalse },
689
 
    { (char *) NULL, (ssize_t) 0L, MagickFalse }
 
685
    { (char *) NULL, (long) 0L, MagickFalse }
690
686
  },
691
687
  ComposeOptions[] =
692
688
  {
693
 
    { "Undefined", (ssize_t) UndefinedCompositeOp, MagickTrue },
694
 
    { "Atop", (ssize_t) AtopCompositeOp, MagickFalse },
695
 
    { "Blend", (ssize_t) BlendCompositeOp, MagickFalse },
696
 
    { "Blur", (ssize_t) BlurCompositeOp, MagickFalse },
697
 
    { "Bumpmap", (ssize_t) BumpmapCompositeOp, MagickFalse },
698
 
    { "ChangeMask", (ssize_t) ChangeMaskCompositeOp, MagickFalse },
699
 
    { "Clear", (ssize_t) ClearCompositeOp, MagickFalse },
700
 
    { "ColorBurn", (ssize_t) ColorBurnCompositeOp, MagickFalse },
701
 
    { "ColorDodge", (ssize_t) ColorDodgeCompositeOp, MagickFalse },
702
 
    { "Colorize", (ssize_t) ColorizeCompositeOp, MagickFalse },
703
 
    { "CopyBlack", (ssize_t) CopyBlackCompositeOp, MagickFalse },
704
 
    { "CopyBlue", (ssize_t) CopyBlueCompositeOp, MagickFalse },
705
 
    { "CopyCyan", (ssize_t) CopyCyanCompositeOp, MagickFalse },
706
 
    { "CopyGreen", (ssize_t) CopyGreenCompositeOp, MagickFalse },
707
 
    { "Copy", (ssize_t) CopyCompositeOp, MagickFalse },
708
 
    { "CopyMagenta", (ssize_t) CopyMagentaCompositeOp, MagickFalse },
709
 
    { "CopyOpacity", (ssize_t) CopyOpacityCompositeOp, MagickFalse },
710
 
    { "CopyRed", (ssize_t) CopyRedCompositeOp, MagickFalse },
711
 
    { "CopyYellow", (ssize_t) CopyYellowCompositeOp, MagickFalse },
712
 
    { "Darken", (ssize_t) DarkenCompositeOp, MagickFalse },
713
 
    { "Divide", (ssize_t) DivideCompositeOp, MagickFalse },
714
 
    { "Dst", (ssize_t) DstCompositeOp, MagickFalse },
715
 
    { "Difference", (ssize_t) DifferenceCompositeOp, MagickFalse },
716
 
    { "Displace", (ssize_t) DisplaceCompositeOp, MagickFalse },
717
 
    { "Dissolve", (ssize_t) DissolveCompositeOp, MagickFalse },
718
 
    { "Distort", (ssize_t) DistortCompositeOp, MagickFalse },
719
 
    { "DstAtop", (ssize_t) DstAtopCompositeOp, MagickFalse },
720
 
    { "DstIn", (ssize_t) DstInCompositeOp, MagickFalse },
721
 
    { "DstOut", (ssize_t) DstOutCompositeOp, MagickFalse },
722
 
    { "DstOver", (ssize_t) DstOverCompositeOp, MagickFalse },
723
 
    { "Dst", (ssize_t) DstCompositeOp, MagickFalse },
724
 
    { "Exclusion", (ssize_t) ExclusionCompositeOp, MagickFalse },
725
 
    { "HardLight", (ssize_t) HardLightCompositeOp, MagickFalse },
726
 
    { "Hue", (ssize_t) HueCompositeOp, MagickFalse },
727
 
    { "In", (ssize_t) InCompositeOp, MagickFalse },
728
 
    { "Lighten", (ssize_t) LightenCompositeOp, MagickFalse },
729
 
    { "LinearBurn", (ssize_t) LinearBurnCompositeOp, MagickFalse },
730
 
    { "LinearDodge", (ssize_t) LinearDodgeCompositeOp, MagickFalse },
731
 
    { "LinearLight", (ssize_t) LinearLightCompositeOp, MagickFalse },
732
 
    { "Luminize", (ssize_t) LuminizeCompositeOp, MagickFalse },
733
 
    { "Mathematics", (ssize_t) MathematicsCompositeOp, MagickFalse },
734
 
    { "Minus", (ssize_t) MinusCompositeOp, MagickFalse },
735
 
    { "Modulate", (ssize_t) ModulateCompositeOp, MagickFalse },
736
 
    { "ModulusAdd", (ssize_t) ModulusAddCompositeOp, MagickFalse },
737
 
    { "ModulusSubtract", (ssize_t) ModulusSubtractCompositeOp, MagickFalse },
738
 
    { "Multiply", (ssize_t) MultiplyCompositeOp, MagickFalse },
739
 
    { "None", (ssize_t) NoCompositeOp, MagickFalse },
740
 
    { "Out", (ssize_t) OutCompositeOp, MagickFalse },
741
 
    { "Overlay", (ssize_t) OverlayCompositeOp, MagickFalse },
742
 
    { "Over", (ssize_t) OverCompositeOp, MagickFalse },
743
 
    { "PegtopLight", (ssize_t) PegtopLightCompositeOp, MagickFalse },
744
 
    { "PinLight", (ssize_t) PinLightCompositeOp, MagickFalse },
745
 
    { "Plus", (ssize_t) PlusCompositeOp, MagickFalse },
746
 
    { "Replace", (ssize_t) ReplaceCompositeOp, MagickFalse },
747
 
    { "Saturate", (ssize_t) SaturateCompositeOp, MagickFalse },
748
 
    { "Screen", (ssize_t) ScreenCompositeOp, MagickFalse },
749
 
    { "SoftLight", (ssize_t) SoftLightCompositeOp, MagickFalse },
750
 
    { "Src", (ssize_t) SrcCompositeOp, MagickFalse },
751
 
    { "SrcAtop", (ssize_t) SrcAtopCompositeOp, MagickFalse },
752
 
    { "SrcIn", (ssize_t) SrcInCompositeOp, MagickFalse },
753
 
    { "SrcOut", (ssize_t) SrcOutCompositeOp, MagickFalse },
754
 
    { "SrcOver", (ssize_t) SrcOverCompositeOp, MagickFalse },
755
 
    { "Src", (ssize_t) SrcCompositeOp, MagickFalse },
756
 
    { "VividLight", (ssize_t) VividLightCompositeOp, MagickFalse },
757
 
    { "Xor", (ssize_t) XorCompositeOp, MagickFalse },
758
 
    { "Add", (ssize_t) AddCompositeOp, MagickTrue }, /* deprecate */
759
 
    { "Subtract", (ssize_t) SubtractCompositeOp, MagickTrue }, /* deprecate */
760
 
    { "Threshold", (ssize_t) ThresholdCompositeOp, MagickTrue }, /* deprecate */
761
 
    { (char *) NULL, (ssize_t) UndefinedCompositeOp, MagickFalse }
 
689
    { "Undefined", (long) UndefinedCompositeOp, MagickTrue },
 
690
    { "Add", (long) AddCompositeOp, MagickFalse },
 
691
    { "Atop", (long) AtopCompositeOp, MagickFalse },
 
692
    { "Blend", (long) BlendCompositeOp, MagickFalse },
 
693
    { "Blur", (long) BlurCompositeOp, MagickFalse },
 
694
    { "Bumpmap", (long) BumpmapCompositeOp, MagickFalse },
 
695
    { "ChangeMask", (long) ChangeMaskCompositeOp, MagickFalse },
 
696
    { "Clear", (long) ClearCompositeOp, MagickFalse },
 
697
    { "ColorBurn", (long) ColorBurnCompositeOp, MagickFalse },
 
698
    { "ColorDodge", (long) ColorDodgeCompositeOp, MagickFalse },
 
699
    { "Colorize", (long) ColorizeCompositeOp, MagickFalse },
 
700
    { "CopyBlack", (long) CopyBlackCompositeOp, MagickFalse },
 
701
    { "CopyBlue", (long) CopyBlueCompositeOp, MagickFalse },
 
702
    { "CopyCyan", (long) CopyCyanCompositeOp, MagickFalse },
 
703
    { "CopyGreen", (long) CopyGreenCompositeOp, MagickFalse },
 
704
    { "Copy", (long) CopyCompositeOp, MagickFalse },
 
705
    { "CopyMagenta", (long) CopyMagentaCompositeOp, MagickFalse },
 
706
    { "CopyOpacity", (long) CopyOpacityCompositeOp, MagickFalse },
 
707
    { "CopyRed", (long) CopyRedCompositeOp, MagickFalse },
 
708
    { "CopyYellow", (long) CopyYellowCompositeOp, MagickFalse },
 
709
    { "Darken", (long) DarkenCompositeOp, MagickFalse },
 
710
    { "Divide", (long) DivideCompositeOp, MagickFalse },
 
711
    { "Dst", (long) DstCompositeOp, MagickFalse },
 
712
    { "Difference", (long) DifferenceCompositeOp, MagickFalse },
 
713
    { "Displace", (long) DisplaceCompositeOp, MagickFalse },
 
714
    { "Dissolve", (long) DissolveCompositeOp, MagickFalse },
 
715
    { "Distort", (long) DistortCompositeOp, MagickFalse },
 
716
    { "DstAtop", (long) DstAtopCompositeOp, MagickFalse },
 
717
    { "DstIn", (long) DstInCompositeOp, MagickFalse },
 
718
    { "DstOut", (long) DstOutCompositeOp, MagickFalse },
 
719
    { "DstOver", (long) DstOverCompositeOp, MagickFalse },
 
720
    { "Dst", (long) DstCompositeOp, MagickFalse },
 
721
    { "Exclusion", (long) ExclusionCompositeOp, MagickFalse },
 
722
    { "HardLight", (long) HardLightCompositeOp, MagickFalse },
 
723
    { "Hue", (long) HueCompositeOp, MagickFalse },
 
724
    { "In", (long) InCompositeOp, MagickFalse },
 
725
    { "Lighten", (long) LightenCompositeOp, MagickFalse },
 
726
    { "LinearBurn", (long) LinearBurnCompositeOp, MagickFalse },
 
727
    { "LinearDodge", (long) LinearDodgeCompositeOp, MagickFalse },
 
728
    { "LinearLight", (long) LinearLightCompositeOp, MagickFalse },
 
729
    { "Luminize", (long) LuminizeCompositeOp, MagickFalse },
 
730
    { "Mathematics", (long) MathematicsCompositeOp, MagickFalse },
 
731
    { "Minus", (long) MinusCompositeOp, MagickFalse },
 
732
    { "Modulate", (long) ModulateCompositeOp, MagickFalse },
 
733
    { "Multiply", (long) MultiplyCompositeOp, MagickFalse },
 
734
    { "None", (long) NoCompositeOp, MagickFalse },
 
735
    { "Out", (long) OutCompositeOp, MagickFalse },
 
736
    { "Overlay", (long) OverlayCompositeOp, MagickFalse },
 
737
    { "Over", (long) OverCompositeOp, MagickFalse },
 
738
    { "PegtopLight", (long) PegtopLightCompositeOp, MagickFalse },
 
739
    { "PinLight", (long) PinLightCompositeOp, MagickFalse },
 
740
    { "Plus", (long) PlusCompositeOp, MagickFalse },
 
741
    { "Replace", (long) ReplaceCompositeOp, MagickFalse },
 
742
    { "Saturate", (long) SaturateCompositeOp, MagickFalse },
 
743
    { "Screen", (long) ScreenCompositeOp, MagickFalse },
 
744
    { "SoftLight", (long) SoftLightCompositeOp, MagickFalse },
 
745
    { "Src", (long) SrcCompositeOp, MagickFalse },
 
746
    { "SrcAtop", (long) SrcAtopCompositeOp, MagickFalse },
 
747
    { "SrcIn", (long) SrcInCompositeOp, MagickFalse },
 
748
    { "SrcOut", (long) SrcOutCompositeOp, MagickFalse },
 
749
    { "SrcOver", (long) SrcOverCompositeOp, MagickFalse },
 
750
    { "Src", (long) SrcCompositeOp, MagickFalse },
 
751
    { "Subtract", (long) SubtractCompositeOp, MagickFalse },
 
752
    { "Threshold", (long) ThresholdCompositeOp, MagickTrue }, /* depreciate */
 
753
    { "VividLight", (long) VividLightCompositeOp, MagickFalse },
 
754
    { "Xor", (long) XorCompositeOp, MagickFalse },
 
755
    { (char *) NULL, (long) UndefinedCompositeOp, MagickFalse }
762
756
  },
763
757
  CompressOptions[] =
764
758
  {
765
 
    { "Undefined", (ssize_t) UndefinedCompression, MagickTrue },
766
 
    { "B44", (ssize_t) B44Compression, MagickFalse },
767
 
    { "B44A", (ssize_t) B44ACompression, MagickFalse },
768
 
    { "BZip", (ssize_t) BZipCompression, MagickFalse },
769
 
    { "DXT1", (ssize_t) DXT1Compression, MagickFalse },
770
 
    { "DXT3", (ssize_t) DXT3Compression, MagickFalse },
771
 
    { "DXT5", (ssize_t) DXT5Compression, MagickFalse },
772
 
    { "Fax", (ssize_t) FaxCompression, MagickFalse },
773
 
    { "Group4", (ssize_t) Group4Compression, MagickFalse },
774
 
    { "JPEG", (ssize_t) JPEGCompression, MagickFalse },
775
 
    { "JPEG2000", (ssize_t) JPEG2000Compression, MagickFalse },
776
 
    { "Lossless", (ssize_t) LosslessJPEGCompression, MagickFalse },
777
 
    { "LosslessJPEG", (ssize_t) LosslessJPEGCompression, MagickFalse },
778
 
    { "LZW", (ssize_t) LZWCompression, MagickFalse },
779
 
    { "None", (ssize_t) NoCompression, MagickFalse },
780
 
    { "Piz", (ssize_t) PizCompression, MagickFalse },
781
 
    { "Pxr24", (ssize_t) Pxr24Compression, MagickFalse },
782
 
    { "RLE", (ssize_t) RLECompression, MagickFalse },
783
 
    { "Zip", (ssize_t) ZipCompression, MagickFalse },
784
 
    { "RunlengthEncoded", (ssize_t) RLECompression, MagickFalse },
785
 
    { "ZipS", (ssize_t) ZipSCompression, MagickFalse },
786
 
    { (char *) NULL, (ssize_t) UndefinedCompression, MagickFalse }
 
759
    { "Undefined", (long) UndefinedCompression, MagickTrue },
 
760
    { "B44", (long) B44Compression, MagickFalse },
 
761
    { "B44A", (long) B44ACompression, MagickFalse },
 
762
    { "BZip", (long) BZipCompression, MagickFalse },
 
763
    { "DXT1", (long) DXT1Compression, MagickFalse },
 
764
    { "DXT3", (long) DXT3Compression, MagickFalse },
 
765
    { "DXT5", (long) DXT5Compression, MagickFalse },
 
766
    { "Fax", (long) FaxCompression, MagickFalse },
 
767
    { "Group4", (long) Group4Compression, MagickFalse },
 
768
    { "JPEG", (long) JPEGCompression, MagickFalse },
 
769
    { "JPEG2000", (long) JPEG2000Compression, MagickFalse },
 
770
    { "Lossless", (long) LosslessJPEGCompression, MagickFalse },
 
771
    { "LosslessJPEG", (long) LosslessJPEGCompression, MagickFalse },
 
772
    { "LZW", (long) LZWCompression, MagickFalse },
 
773
    { "None", (long) NoCompression, MagickFalse },
 
774
    { "Piz", (long) PizCompression, MagickFalse },
 
775
    { "Pxr24", (long) Pxr24Compression, MagickFalse },
 
776
    { "RLE", (long) RLECompression, MagickFalse },
 
777
    { "Zip", (long) ZipCompression, MagickFalse },
 
778
    { "RunlengthEncoded", (long) RLECompression, MagickFalse },
 
779
    { "ZipS", (long) ZipSCompression, MagickFalse },
 
780
    { (char *) NULL, (long) UndefinedCompression, MagickFalse }
787
781
  },
788
782
  ColorspaceOptions[] =
789
783
  {
790
 
    { "Undefined", (ssize_t) UndefinedColorspace, MagickTrue },
791
 
    { "CMY", (ssize_t) CMYColorspace, MagickFalse },
792
 
    { "CMYK", (ssize_t) CMYKColorspace, MagickFalse },
793
 
    { "Gray", (ssize_t) GRAYColorspace, MagickFalse },
794
 
    { "HSB", (ssize_t) HSBColorspace, MagickFalse },
795
 
    { "HSL", (ssize_t) HSLColorspace, MagickFalse },
796
 
    { "HWB", (ssize_t) HWBColorspace, MagickFalse },
797
 
    { "Lab", (ssize_t) LabColorspace, MagickFalse },
798
 
    { "Log", (ssize_t) LogColorspace, MagickFalse },
799
 
    { "OHTA", (ssize_t) OHTAColorspace, MagickFalse },
800
 
    { "Rec601Luma", (ssize_t) Rec601LumaColorspace, MagickFalse },
801
 
    { "Rec601YCbCr", (ssize_t) Rec601YCbCrColorspace, MagickFalse },
802
 
    { "Rec709Luma", (ssize_t) Rec709LumaColorspace, MagickFalse },
803
 
    { "Rec709YCbCr", (ssize_t) Rec709YCbCrColorspace, MagickFalse },
804
 
    { "RGB", (ssize_t) RGBColorspace, MagickFalse },
805
 
    { "sRGB", (ssize_t) sRGBColorspace, MagickFalse },
806
 
    { "Transparent", (ssize_t) TransparentColorspace, MagickFalse },
807
 
    { "XYZ", (ssize_t) XYZColorspace, MagickFalse },
808
 
    { "YCbCr", (ssize_t) YCbCrColorspace, MagickFalse },
809
 
    { "YCC", (ssize_t) YCCColorspace, MagickFalse },
810
 
    { "YIQ", (ssize_t) YIQColorspace, MagickFalse },
811
 
    { "YPbPr", (ssize_t) YPbPrColorspace, MagickFalse },
812
 
    { "YUV", (ssize_t) YUVColorspace, MagickFalse },
813
 
    { (char *) NULL, (ssize_t) UndefinedColorspace, MagickFalse }
 
784
    { "Undefined", (long) UndefinedColorspace, MagickTrue },
 
785
    { "CMY", (long) CMYColorspace, MagickFalse },
 
786
    { "CMYK", (long) CMYKColorspace, MagickFalse },
 
787
    { "Gray", (long) GRAYColorspace, MagickFalse },
 
788
    { "HSB", (long) HSBColorspace, MagickFalse },
 
789
    { "HSL", (long) HSLColorspace, MagickFalse },
 
790
    { "HWB", (long) HWBColorspace, MagickFalse },
 
791
    { "Lab", (long) LabColorspace, MagickFalse },
 
792
    { "Log", (long) LogColorspace, MagickFalse },
 
793
    { "OHTA", (long) OHTAColorspace, MagickFalse },
 
794
    { "Rec601Luma", (long) Rec601LumaColorspace, MagickFalse },
 
795
    { "Rec601YCbCr", (long) Rec601YCbCrColorspace, MagickFalse },
 
796
    { "Rec709Luma", (long) Rec709LumaColorspace, MagickFalse },
 
797
    { "Rec709YCbCr", (long) Rec709YCbCrColorspace, MagickFalse },
 
798
    { "RGB", (long) RGBColorspace, MagickFalse },
 
799
    { "sRGB", (long) sRGBColorspace, MagickFalse },
 
800
    { "Transparent", (long) TransparentColorspace, MagickFalse },
 
801
    { "XYZ", (long) XYZColorspace, MagickFalse },
 
802
    { "YCbCr", (long) YCbCrColorspace, MagickFalse },
 
803
    { "YCC", (long) YCCColorspace, MagickFalse },
 
804
    { "YIQ", (long) YIQColorspace, MagickFalse },
 
805
    { "YPbPr", (long) YPbPrColorspace, MagickFalse },
 
806
    { "YUV", (long) YUVColorspace, MagickFalse },
 
807
    { (char *) NULL, (long) UndefinedColorspace, MagickFalse }
814
808
  },
815
809
  DataTypeOptions[] =
816
810
  {
817
 
    { "Undefined", (ssize_t) UndefinedData, MagickTrue },
818
 
    { "Byte", (ssize_t) ByteData, MagickFalse },
819
 
    { "Long", (ssize_t) LongData, MagickFalse },
820
 
    { "Short", (ssize_t) ShortData, MagickFalse },
821
 
    { "String", (ssize_t) StringData, MagickFalse },
822
 
    { (char *) NULL, (ssize_t) UndefinedData, MagickFalse }
 
811
    { "Undefined", (long) UndefinedData, MagickTrue },
 
812
    { "Byte", (long) ByteData, MagickFalse },
 
813
    { "Long", (long) LongData, MagickFalse },
 
814
    { "Short", (long) ShortData, MagickFalse },
 
815
    { "String", (long) StringData, MagickFalse },
 
816
    { (char *) NULL, (long) UndefinedData, MagickFalse }
823
817
  },
824
818
  DecorateOptions[] =
825
819
  {
826
 
    { "Undefined", (ssize_t) UndefinedDecoration, MagickTrue },
827
 
    { "LineThrough", (ssize_t) LineThroughDecoration, MagickFalse },
828
 
    { "None", (ssize_t) NoDecoration, MagickFalse },
829
 
    { "Overline", (ssize_t) OverlineDecoration, MagickFalse },
830
 
    { "Underline", (ssize_t) UnderlineDecoration, MagickFalse },
831
 
    { (char *) NULL, (ssize_t) UndefinedDecoration, MagickFalse }
832
 
  },
833
 
  DirectionOptions[] =
834
 
  {
835
 
    { "Undefined", (ssize_t) UndefinedDirection, MagickTrue },
836
 
    { "right-to-left", (ssize_t) RightToLeftDirection, MagickFalse },
837
 
    { "left-to-right", (ssize_t) LeftToRightDirection, MagickFalse },
838
 
    { (char *) NULL, (ssize_t) UndefinedDirection, MagickFalse }
 
820
    { "Undefined", (long) UndefinedDecoration, MagickTrue },
 
821
    { "LineThrough", (long) LineThroughDecoration, MagickFalse },
 
822
    { "None", (long) NoDecoration, MagickFalse },
 
823
    { "Overline", (long) OverlineDecoration, MagickFalse },
 
824
    { "Underline", (long) UnderlineDecoration, MagickFalse },
 
825
    { (char *) NULL, (long) UndefinedDecoration, MagickFalse }
839
826
  },
840
827
  DisposeOptions[] =
841
828
  {
842
 
    { "Undefined", (ssize_t) UndefinedDispose, MagickTrue },
843
 
    { "Background", (ssize_t) BackgroundDispose, MagickFalse },
844
 
    { "None", (ssize_t) NoneDispose, MagickFalse },
845
 
    { "Previous", (ssize_t) PreviousDispose, MagickFalse },
846
 
    { "Undefined", (ssize_t) UndefinedDispose, MagickFalse },
847
 
    { "0", (ssize_t) UndefinedDispose, MagickFalse },
848
 
    { "1", (ssize_t) NoneDispose, MagickFalse },
849
 
    { "2", (ssize_t) BackgroundDispose, MagickFalse },
850
 
    { "3", (ssize_t) PreviousDispose, MagickFalse },
851
 
    { (char *) NULL, (ssize_t) UndefinedDispose, MagickFalse }
 
829
    { "Background", (long) BackgroundDispose, MagickFalse },
 
830
    { "None", (long) NoneDispose, MagickFalse },
 
831
    { "Previous", (long) PreviousDispose, MagickFalse },
 
832
    { "Undefined", (long) UndefinedDispose, MagickFalse },
 
833
    { "0", (long) UndefinedDispose, MagickFalse },
 
834
    { "1", (long) NoneDispose, MagickFalse },
 
835
    { "2", (long) BackgroundDispose, MagickFalse },
 
836
    { "3", (long) PreviousDispose, MagickFalse },
 
837
    { (char *) NULL, (long) UndefinedDispose, MagickFalse }
852
838
  },
853
839
  DistortOptions[] =
854
840
  {
855
 
    { "Undefined", (ssize_t) UndefinedDistortion, MagickTrue },
856
 
    { "Affine", (ssize_t) AffineDistortion, MagickFalse },
857
 
    { "AffineProjection", (ssize_t) AffineProjectionDistortion, MagickFalse },
858
 
    { "ScaleRotateTranslate", (ssize_t) ScaleRotateTranslateDistortion, MagickFalse },
859
 
    { "SRT", (ssize_t) ScaleRotateTranslateDistortion, MagickFalse },
860
 
    { "Perspective", (ssize_t) PerspectiveDistortion, MagickFalse },
861
 
    { "PerspectiveProjection", (ssize_t) PerspectiveProjectionDistortion, MagickFalse },
862
 
    { "Bilinear", (ssize_t) BilinearForwardDistortion, MagickTrue },
863
 
    { "BilinearForward", (ssize_t) BilinearForwardDistortion, MagickFalse },
864
 
    { "BilinearReverse", (ssize_t) BilinearReverseDistortion, MagickFalse },
865
 
    { "Polynomial", (ssize_t) PolynomialDistortion, MagickFalse },
866
 
    { "Arc", (ssize_t) ArcDistortion, MagickFalse },
867
 
    { "Polar", (ssize_t) PolarDistortion, MagickFalse },
868
 
    { "DePolar", (ssize_t) DePolarDistortion, MagickFalse },
869
 
    { "Barrel", (ssize_t) BarrelDistortion, MagickFalse },
870
 
    { "BarrelInverse", (ssize_t) BarrelInverseDistortion, MagickFalse },
871
 
    { "Shepards", (ssize_t) ShepardsDistortion, MagickFalse },
872
 
    { (char *) NULL, (ssize_t) UndefinedDistortion, MagickFalse }
 
841
    { "Undefined", (long) UndefinedDistortion, MagickTrue },
 
842
    { "Affine", (long) AffineDistortion, MagickFalse },
 
843
    { "AffineProjection", (long) AffineProjectionDistortion, MagickFalse },
 
844
    { "ScaleRotateTranslate", (long) ScaleRotateTranslateDistortion, MagickFalse },
 
845
    { "SRT", (long) ScaleRotateTranslateDistortion, MagickFalse },
 
846
    { "Perspective", (long) PerspectiveDistortion, MagickFalse },
 
847
    { "PerspectiveProjection", (long) PerspectiveProjectionDistortion, MagickFalse },
 
848
    { "Bilinear", (long) BilinearForwardDistortion, MagickTrue },
 
849
    { "BilinearForward", (long) BilinearForwardDistortion, MagickFalse },
 
850
    { "BilinearReverse", (long) BilinearReverseDistortion, MagickFalse },
 
851
    { "Polynomial", (long) PolynomialDistortion, MagickFalse },
 
852
    { "Arc", (long) ArcDistortion, MagickFalse },
 
853
    { "Polar", (long) PolarDistortion, MagickFalse },
 
854
    { "DePolar", (long) DePolarDistortion, MagickFalse },
 
855
    { "Barrel", (long) BarrelDistortion, MagickFalse },
 
856
    { "BarrelInverse", (long) BarrelInverseDistortion, MagickFalse },
 
857
    { "Shepards", (long) ShepardsDistortion, MagickFalse },
 
858
    { (char *) NULL, (long) UndefinedDistortion, MagickFalse }
873
859
  },
874
860
  DitherOptions[] =
875
861
  {
876
 
    { "Undefined", (ssize_t) UndefinedDitherMethod, MagickTrue },
877
 
    { "None", (ssize_t) NoDitherMethod, MagickFalse },
878
 
    { "FloydSteinberg", (ssize_t) FloydSteinbergDitherMethod, MagickFalse },
879
 
    { "Riemersma", (ssize_t) RiemersmaDitherMethod, MagickFalse },
880
 
    { (char *) NULL, (ssize_t) UndefinedEndian, MagickFalse }
 
862
    { "Undefined", (long) UndefinedDitherMethod, MagickTrue },
 
863
    { "None", (long) NoDitherMethod, MagickFalse },
 
864
    { "FloydSteinberg", (long) FloydSteinbergDitherMethod, MagickFalse },
 
865
    { "Riemersma", (long) RiemersmaDitherMethod, MagickFalse },
 
866
    { (char *) NULL, (long) UndefinedEndian, MagickFalse }
881
867
  },
882
868
  EndianOptions[] =
883
869
  {
884
 
    { "Undefined", (ssize_t) UndefinedEndian, MagickTrue },
885
 
    { "LSB", (ssize_t) LSBEndian, MagickFalse },
886
 
    { "MSB", (ssize_t) MSBEndian, MagickFalse },
887
 
    { (char *) NULL, (ssize_t) UndefinedEndian, MagickFalse }
 
870
    { "Undefined", (long) UndefinedEndian, MagickTrue },
 
871
    { "LSB", (long) LSBEndian, MagickFalse },
 
872
    { "MSB", (long) MSBEndian, MagickFalse },
 
873
    { (char *) NULL, (long) UndefinedEndian, MagickFalse }
888
874
  },
889
875
  EvaluateOptions[] =
890
876
  {
891
 
    { "Undefined", (ssize_t) UndefinedEvaluateOperator, MagickTrue },
892
 
    { "Add", (ssize_t) AddEvaluateOperator, MagickFalse },
893
 
    { "AddModulus", (ssize_t) AddModulusEvaluateOperator, MagickFalse },
894
 
    { "And", (ssize_t) AndEvaluateOperator, MagickFalse },
895
 
    { "Cos", (ssize_t) CosineEvaluateOperator, MagickFalse },
896
 
    { "Cosine", (ssize_t) CosineEvaluateOperator, MagickFalse },
897
 
    { "Divide", (ssize_t) DivideEvaluateOperator, MagickFalse },
898
 
    { "GaussianNoise", (ssize_t) GaussianNoiseEvaluateOperator, MagickFalse },
899
 
    { "ImpulseNoise", (ssize_t) ImpulseNoiseEvaluateOperator, MagickFalse },
900
 
    { "LaplacianNoise", (ssize_t) LaplacianNoiseEvaluateOperator, MagickFalse },
901
 
    { "LeftShift", (ssize_t) LeftShiftEvaluateOperator, MagickFalse },
902
 
    { "Log", (ssize_t) LogEvaluateOperator, MagickFalse },
903
 
    { "Max", (ssize_t) MaxEvaluateOperator, MagickFalse },
904
 
    { "Mean", (ssize_t) MeanEvaluateOperator, MagickFalse },
905
 
    { "Min", (ssize_t) MinEvaluateOperator, MagickFalse },
906
 
    { "MultiplicativeNoise", (ssize_t) MultiplicativeNoiseEvaluateOperator, MagickFalse },
907
 
    { "Multiply", (ssize_t) MultiplyEvaluateOperator, MagickFalse },
908
 
    { "Or", (ssize_t) OrEvaluateOperator, MagickFalse },
909
 
    { "PoissonNoise", (ssize_t) PoissonNoiseEvaluateOperator, MagickFalse },
910
 
    { "Pow", (ssize_t) PowEvaluateOperator, MagickFalse },
911
 
    { "RightShift", (ssize_t) RightShiftEvaluateOperator, MagickFalse },
912
 
    { "Set", (ssize_t) SetEvaluateOperator, MagickFalse },
913
 
    { "Sin", (ssize_t) SineEvaluateOperator, MagickFalse },
914
 
    { "Sine", (ssize_t) SineEvaluateOperator, MagickFalse },
915
 
    { "Subtract", (ssize_t) SubtractEvaluateOperator, MagickFalse },
916
 
    { "Threshold", (ssize_t) ThresholdEvaluateOperator, MagickFalse },
917
 
    { "ThresholdBlack", (ssize_t) ThresholdBlackEvaluateOperator, MagickFalse },
918
 
    { "ThresholdWhite", (ssize_t) ThresholdWhiteEvaluateOperator, MagickFalse },
919
 
    { "UniformNoise", (ssize_t) UniformNoiseEvaluateOperator, MagickFalse },
920
 
    { "Xor", (ssize_t) XorEvaluateOperator, MagickFalse },
921
 
    { (char *) NULL, (ssize_t) UndefinedEvaluateOperator, MagickFalse }
 
877
    { "Undefined", (long) UndefinedEvaluateOperator, MagickTrue },
 
878
    { "Add", (long) AddEvaluateOperator, MagickFalse },
 
879
    { "AddModulus", (long) AddModulusEvaluateOperator, MagickFalse },
 
880
    { "And", (long) AndEvaluateOperator, MagickFalse },
 
881
    { "Cos", (long) CosineEvaluateOperator, MagickFalse },
 
882
    { "Cosine", (long) CosineEvaluateOperator, MagickFalse },
 
883
    { "Divide", (long) DivideEvaluateOperator, MagickFalse },
 
884
    { "GaussianNoise", (long) GaussianNoiseEvaluateOperator, MagickFalse },
 
885
    { "ImpulseNoise", (long) ImpulseNoiseEvaluateOperator, MagickFalse },
 
886
    { "LaplacianNoise", (long) LaplacianNoiseEvaluateOperator, MagickFalse },
 
887
    { "LeftShift", (long) LeftShiftEvaluateOperator, MagickFalse },
 
888
    { "Log", (long) LogEvaluateOperator, MagickFalse },
 
889
    { "Max", (long) MaxEvaluateOperator, MagickFalse },
 
890
    { "Mean", (long) MeanEvaluateOperator, MagickFalse },
 
891
    { "Min", (long) MinEvaluateOperator, MagickFalse },
 
892
    { "MultiplicativeNoise", (long) MultiplicativeNoiseEvaluateOperator, MagickFalse },
 
893
    { "Multiply", (long) MultiplyEvaluateOperator, MagickFalse },
 
894
    { "Or", (long) OrEvaluateOperator, MagickFalse },
 
895
    { "PoissonNoise", (long) PoissonNoiseEvaluateOperator, MagickFalse },
 
896
    { "Pow", (long) PowEvaluateOperator, MagickFalse },
 
897
    { "RightShift", (long) RightShiftEvaluateOperator, MagickFalse },
 
898
    { "Set", (long) SetEvaluateOperator, MagickFalse },
 
899
    { "Sin", (long) SineEvaluateOperator, MagickFalse },
 
900
    { "Sine", (long) SineEvaluateOperator, MagickFalse },
 
901
    { "Subtract", (long) SubtractEvaluateOperator, MagickFalse },
 
902
    { "Threshold", (long) ThresholdEvaluateOperator, MagickFalse },
 
903
    { "ThresholdBlack", (long) ThresholdBlackEvaluateOperator, MagickFalse },
 
904
    { "ThresholdWhite", (long) ThresholdWhiteEvaluateOperator, MagickFalse },
 
905
    { "UniformNoise", (long) UniformNoiseEvaluateOperator, MagickFalse },
 
906
    { "Xor", (long) XorEvaluateOperator, MagickFalse },
 
907
    { (char *) NULL, (long) UndefinedEvaluateOperator, MagickFalse }
922
908
  },
923
909
  FillRuleOptions[] =
924
910
  {
925
 
    { "Undefined", (ssize_t) UndefinedRule, MagickTrue },
926
 
    { "Evenodd", (ssize_t) EvenOddRule, MagickFalse },
927
 
    { "NonZero", (ssize_t) NonZeroRule, MagickFalse },
928
 
    { (char *) NULL, (ssize_t) UndefinedRule, MagickFalse }
 
911
    { "Undefined", (long) UndefinedRule, MagickTrue },
 
912
    { "Evenodd", (long) EvenOddRule, MagickFalse },
 
913
    { "NonZero", (long) NonZeroRule, MagickFalse },
 
914
    { (char *) NULL, (long) UndefinedRule, MagickFalse }
929
915
  },
930
916
  FilterOptions[] =
931
917
  {
932
 
    { "Undefined", (ssize_t) UndefinedFilter, MagickTrue },
933
 
    { "Bartlett", (ssize_t) BartlettFilter, MagickFalse },
934
 
    { "Bessel", (ssize_t) BesselFilter, MagickFalse },
935
 
    { "Blackman", (ssize_t) BlackmanFilter, MagickFalse },
936
 
    { "Bohman", (ssize_t) BohmanFilter, MagickFalse },
937
 
    { "Box", (ssize_t) BoxFilter, MagickFalse },
938
 
    { "Catrom", (ssize_t) CatromFilter, MagickFalse },
939
 
    { "Cubic", (ssize_t) CubicFilter, MagickFalse },
940
 
    { "Gaussian", (ssize_t) GaussianFilter, MagickFalse },
941
 
    { "Hamming", (ssize_t) HammingFilter, MagickFalse },
942
 
    { "Hanning", (ssize_t) HanningFilter, MagickFalse },
943
 
    { "Hermite", (ssize_t) HermiteFilter, MagickFalse },
944
 
    { "Kaiser", (ssize_t) KaiserFilter, MagickFalse },
945
 
    { "Lagrange", (ssize_t) LagrangeFilter, MagickFalse },
946
 
    { "Lanczos", (ssize_t) LanczosFilter, MagickFalse },
947
 
    { "Mitchell", (ssize_t) MitchellFilter, MagickFalse },
948
 
    { "Parzen", (ssize_t) ParzenFilter, MagickFalse },
949
 
    { "Point", (ssize_t) PointFilter, MagickFalse },
950
 
    { "Quadratic", (ssize_t) QuadraticFilter, MagickFalse },
951
 
    { "Sinc", (ssize_t) SincFilter, MagickFalse },
952
 
    { "Triangle", (ssize_t) TriangleFilter, MagickFalse },
953
 
    { "Welsh", (ssize_t) WelshFilter, MagickFalse },
954
 
    { (char *) NULL, (ssize_t) UndefinedFilter, MagickFalse }
 
918
    { "Undefined", (long) UndefinedFilter, MagickTrue },
 
919
    { "Bartlett", (long) BartlettFilter, MagickFalse },
 
920
    { "Bessel", (long) BesselFilter, MagickFalse },
 
921
    { "Blackman", (long) BlackmanFilter, MagickFalse },
 
922
    { "Bohman", (long) BohmanFilter, MagickFalse },
 
923
    { "Box", (long) BoxFilter, MagickFalse },
 
924
    { "Catrom", (long) CatromFilter, MagickFalse },
 
925
    { "Cubic", (long) CubicFilter, MagickFalse },
 
926
    { "Gaussian", (long) GaussianFilter, MagickFalse },
 
927
    { "Hamming", (long) HammingFilter, MagickFalse },
 
928
    { "Hanning", (long) HanningFilter, MagickFalse },
 
929
    { "Hermite", (long) HermiteFilter, MagickFalse },
 
930
    { "Kaiser", (long) KaiserFilter, MagickFalse },
 
931
    { "Lagrange", (long) LagrangeFilter, MagickFalse },
 
932
    { "Lanczos", (long) LanczosFilter, MagickFalse },
 
933
    { "Mitchell", (long) MitchellFilter, MagickFalse },
 
934
    { "Parzen", (long) ParzenFilter, MagickFalse },
 
935
    { "Point", (long) PointFilter, MagickFalse },
 
936
    { "Quadratic", (long) QuadraticFilter, MagickFalse },
 
937
    { "Sinc", (long) SincFilter, MagickFalse },
 
938
    { "Triangle", (long) TriangleFilter, MagickFalse },
 
939
    { "Welsh", (long) WelshFilter, MagickFalse },
 
940
    { (char *) NULL, (long) UndefinedFilter, MagickFalse }
955
941
  },
956
942
  FunctionOptions[] =
957
943
  {
958
 
    { "Undefined", (ssize_t) UndefinedFunction, MagickTrue },
959
 
    { "Polynomial", (ssize_t) PolynomialFunction, MagickFalse },
960
 
    { "Sinusoid", (ssize_t) SinusoidFunction, MagickFalse },
961
 
    { "ArcSin", (ssize_t) ArcsinFunction, MagickFalse },
962
 
    { "ArcTan", (ssize_t) ArctanFunction, MagickFalse },
963
 
    { (char *) NULL, (ssize_t) UndefinedFunction, MagickFalse }
 
944
    { "Undefined", (long) UndefinedFunction, MagickTrue },
 
945
    { "Polynomial", (long) PolynomialFunction, MagickFalse },
 
946
    { "Sinusoid", (long) SinusoidFunction, MagickFalse },
 
947
    { "ArcSin", (long) ArcsinFunction, MagickFalse },
 
948
    { "ArcTan", (long) ArctanFunction, MagickFalse },
 
949
    { (char *) NULL, (long) UndefinedFunction, MagickFalse }
964
950
  },
965
951
  GravityOptions[] =
966
952
  {
967
 
    { "Undefined", (ssize_t) UndefinedGravity, MagickTrue },
968
 
    { "None", (ssize_t) UndefinedGravity, MagickFalse },
969
 
    { "Center", (ssize_t) CenterGravity, MagickFalse },
970
 
    { "East", (ssize_t) EastGravity, MagickFalse },
971
 
    { "Forget", (ssize_t) ForgetGravity, MagickFalse },
972
 
    { "NorthEast", (ssize_t) NorthEastGravity, MagickFalse },
973
 
    { "North", (ssize_t) NorthGravity, MagickFalse },
974
 
    { "NorthWest", (ssize_t) NorthWestGravity, MagickFalse },
975
 
    { "SouthEast", (ssize_t) SouthEastGravity, MagickFalse },
976
 
    { "South", (ssize_t) SouthGravity, MagickFalse },
977
 
    { "SouthWest", (ssize_t) SouthWestGravity, MagickFalse },
978
 
    { "West", (ssize_t) WestGravity, MagickFalse },
979
 
    { "Static", (ssize_t) StaticGravity, MagickFalse },
 
953
    { "Undefined", (long) UndefinedGravity, MagickTrue },
 
954
    { "None", (long) UndefinedGravity, MagickFalse },
 
955
    { "Center", (long) CenterGravity, MagickFalse },
 
956
    { "East", (long) EastGravity, MagickFalse },
 
957
    { "Forget", (long) ForgetGravity, MagickFalse },
 
958
    { "NorthEast", (long) NorthEastGravity, MagickFalse },
 
959
    { "North", (long) NorthGravity, MagickFalse },
 
960
    { "NorthWest", (long) NorthWestGravity, MagickFalse },
 
961
    { "SouthEast", (long) SouthEastGravity, MagickFalse },
 
962
    { "South", (long) SouthGravity, MagickFalse },
 
963
    { "SouthWest", (long) SouthWestGravity, MagickFalse },
 
964
    { "West", (long) WestGravity, MagickFalse },
 
965
    { "Static", (long) StaticGravity, MagickFalse },
980
966
    { (char *) NULL, UndefinedGravity, MagickFalse }
981
967
  },
982
968
  ImageListOptions[] =
1008
994
    { "morph", MagickTrue, MagickFalse },
1009
995
    { "mosaic", MagickTrue, MagickFalse },
1010
996
    { "optimize", MagickTrue, MagickFalse },
1011
 
    { "print", MagickTrue, MagickFalse },
1012
997
    { "process", MagickTrue, MagickFalse },
1013
998
    { "quiet", MagickTrue, MagickFalse },
1014
999
    { "separate", MagickTrue, MagickFalse },
1018
1003
  },
1019
1004
  IntentOptions[] =
1020
1005
  {
1021
 
    { "Undefined", (ssize_t) UndefinedIntent, MagickTrue },
1022
 
    { "Absolute", (ssize_t) AbsoluteIntent, MagickFalse },
1023
 
    { "Perceptual", (ssize_t) PerceptualIntent, MagickFalse },
1024
 
    { "Relative", (ssize_t) RelativeIntent, MagickFalse },
1025
 
    { "Saturation", (ssize_t) SaturationIntent, MagickFalse },
1026
 
    { (char *) NULL, (ssize_t) UndefinedIntent, MagickFalse }
 
1006
    { "Undefined", (long) UndefinedIntent, MagickTrue },
 
1007
    { "Absolute", (long) AbsoluteIntent, MagickFalse },
 
1008
    { "Perceptual", (long) PerceptualIntent, MagickFalse },
 
1009
    { "Relative", (long) RelativeIntent, MagickFalse },
 
1010
    { "Saturation", (long) SaturationIntent, MagickFalse },
 
1011
    { (char *) NULL, (long) UndefinedIntent, MagickFalse }
1027
1012
  },
1028
1013
  InterlaceOptions[] =
1029
1014
  {
1030
 
    { "Undefined", (ssize_t) UndefinedInterlace, MagickTrue },
1031
 
    { "Line", (ssize_t) LineInterlace, MagickFalse },
1032
 
    { "None", (ssize_t) NoInterlace, MagickFalse },
1033
 
    { "Plane", (ssize_t) PlaneInterlace, MagickFalse },
1034
 
    { "Partition", (ssize_t) PartitionInterlace, MagickFalse },
1035
 
    { "GIF", (ssize_t) GIFInterlace, MagickFalse },
1036
 
    { "JPEG", (ssize_t) JPEGInterlace, MagickFalse },
1037
 
    { "PNG", (ssize_t) PNGInterlace, MagickFalse },
1038
 
    { (char *) NULL, (ssize_t) UndefinedInterlace, MagickFalse }
 
1015
    { "Undefined", (long) UndefinedInterlace, MagickTrue },
 
1016
    { "Line", (long) LineInterlace, MagickFalse },
 
1017
    { "None", (long) NoInterlace, MagickFalse },
 
1018
    { "Plane", (long) PlaneInterlace, MagickFalse },
 
1019
    { "Partition", (long) PartitionInterlace, MagickFalse },
 
1020
    { "GIF", (long) GIFInterlace, MagickFalse },
 
1021
    { "JPEG", (long) JPEGInterlace, MagickFalse },
 
1022
    { "PNG", (long) PNGInterlace, MagickFalse },
 
1023
    { (char *) NULL, (long) UndefinedInterlace, MagickFalse }
1039
1024
  },
1040
1025
  InterpolateOptions[] =
1041
1026
  {
1042
 
    { "Undefined", (ssize_t) UndefinedInterpolatePixel, MagickTrue },
1043
 
    { "Average", (ssize_t) AverageInterpolatePixel, MagickFalse },
1044
 
    { "Bicubic", (ssize_t) BicubicInterpolatePixel, MagickFalse },
1045
 
    { "Bilinear", (ssize_t) BilinearInterpolatePixel, MagickFalse },
1046
 
    { "filter", (ssize_t) FilterInterpolatePixel, MagickFalse },
1047
 
    { "Integer", (ssize_t) IntegerInterpolatePixel, MagickFalse },
1048
 
    { "Mesh", (ssize_t) MeshInterpolatePixel, MagickFalse },
1049
 
    { "NearestNeighbor", (ssize_t) NearestNeighborInterpolatePixel, MagickFalse },
1050
 
    { "Spline", (ssize_t) SplineInterpolatePixel, MagickFalse },
1051
 
    { (char *) NULL, (ssize_t) UndefinedInterpolatePixel, MagickFalse }
 
1027
    { "Undefined", (long) UndefinedInterpolatePixel, MagickTrue },
 
1028
    { "Average", (long) AverageInterpolatePixel, MagickFalse },
 
1029
    { "Bicubic", (long) BicubicInterpolatePixel, MagickFalse },
 
1030
    { "Bilinear", (long) BilinearInterpolatePixel, MagickFalse },
 
1031
    { "filter", (long) FilterInterpolatePixel, MagickFalse },
 
1032
    { "Integer", (long) IntegerInterpolatePixel, MagickFalse },
 
1033
    { "Mesh", (long) MeshInterpolatePixel, MagickFalse },
 
1034
    { "NearestNeighbor", (long) NearestNeighborInterpolatePixel, MagickFalse },
 
1035
    { "Spline", (long) SplineInterpolatePixel, MagickFalse },
 
1036
    { (char *) NULL, (long) UndefinedInterpolatePixel, MagickFalse }
1052
1037
  },
1053
1038
  KernelOptions[] =
1054
1039
  {
1055
 
    { "Undefined", (ssize_t) UndefinedKernel, MagickTrue },
1056
 
    { "Unity", (ssize_t) UnityKernel, MagickFalse },
1057
 
    { "Gaussian", (ssize_t) GaussianKernel, MagickFalse },
1058
 
    { "DoG", (ssize_t) DoGKernel, MagickFalse },
1059
 
    { "LoG", (ssize_t) LoGKernel, MagickFalse },
1060
 
    { "Blur", (ssize_t) BlurKernel, MagickFalse },
1061
 
    { "Comet", (ssize_t) CometKernel, MagickFalse },
1062
 
    { "Laplacian", (ssize_t) LaplacianKernel, MagickFalse },
1063
 
    { "Sobel", (ssize_t) SobelKernel, MagickFalse },
1064
 
    { "FreiChen", (ssize_t) FreiChenKernel, MagickFalse },
1065
 
    { "Roberts", (ssize_t) RobertsKernel, MagickFalse },
1066
 
    { "Prewitt", (ssize_t) PrewittKernel, MagickFalse },
1067
 
    { "Compass", (ssize_t) CompassKernel, MagickFalse },
1068
 
    { "Kirsch", (ssize_t) KirschKernel, MagickFalse },
1069
 
    { "Rectangle", (ssize_t) RectangleKernel, MagickFalse },
1070
 
    { "Square", (ssize_t) SquareKernel, MagickFalse },
1071
 
    { "Diamond", (ssize_t) DiamondKernel, MagickFalse },
1072
 
    { "Disk", (ssize_t) DiskKernel, MagickFalse },
1073
 
    { "Plus", (ssize_t) PlusKernel, MagickFalse },
1074
 
    { "Cross", (ssize_t) CrossKernel, MagickFalse },
1075
 
    { "Ring", (ssize_t) RingKernel, MagickFalse },
1076
 
    { "Peaks", (ssize_t) PeaksKernel, MagickFalse },
1077
 
    { "Edges", (ssize_t) EdgesKernel, MagickFalse },
1078
 
    { "Corners", (ssize_t) CornersKernel, MagickFalse },
1079
 
    { "ThinDiagonals", (ssize_t) ThinDiagonalsKernel, MagickFalse },
1080
 
    { "LineEnds", (ssize_t) LineEndsKernel, MagickFalse },
1081
 
    { "LineJunctions", (ssize_t) LineJunctionsKernel, MagickFalse },
1082
 
    { "Ridges", (ssize_t) RidgesKernel, MagickFalse },
1083
 
    { "ConvexHull", (ssize_t) ConvexHullKernel, MagickFalse },
1084
 
    { "Skeleton", (ssize_t) SkeletonKernel, MagickFalse },
1085
 
    { "Chebyshev", (ssize_t) ChebyshevKernel, MagickFalse },
1086
 
    { "Manhattan", (ssize_t) ManhattanKernel, MagickFalse },
1087
 
    { "Euclidean", (ssize_t) EuclideanKernel, MagickFalse },
1088
 
    { "User Defined", (ssize_t) UserDefinedKernel, MagickTrue }, /* internal */
1089
 
    { (char *) NULL, (ssize_t) UndefinedKernel, MagickFalse }
 
1040
    { "Undefined", (long) UndefinedKernel, MagickTrue },
 
1041
    { "Gaussian", (long) GaussianKernel, MagickFalse },
 
1042
    { "Blur", (long) BlurKernel, MagickFalse },
 
1043
    { "Comet", (long) CometKernel, MagickFalse },
 
1044
    { "Laplacian", (long) LaplacianKernel, MagickTrue }, /* not implemented */
 
1045
    { "DOG", (long) DOGKernel, MagickTrue },             /* not implemented */
 
1046
    { "LOG", (long) LOGKernel, MagickTrue },             /* not implemented */
 
1047
    { "Rectangle", (long) RectangleKernel, MagickFalse },
 
1048
    { "Square", (long) SquareKernel, MagickFalse },
 
1049
    { "Diamond", (long) DiamondKernel, MagickFalse },
 
1050
    { "Disk", (long) DiskKernel, MagickFalse },
 
1051
    { "Plus", (long) PlusKernel, MagickFalse },
 
1052
    { "Chebyshev", (long) ChebyshevKernel, MagickFalse },
 
1053
    { "Manhatten", (long) ManhattenKernel, MagickFalse },
 
1054
    { "Euclidean", (long) EuclideanKernel, MagickFalse },
 
1055
    { "User Defined", (long) UserDefinedKernel, MagickTrue }, /* internel */
 
1056
    { (char *) NULL, (long) UndefinedKernel, MagickFalse }
1090
1057
  },
1091
1058
  LayerOptions[] =
1092
1059
  {
1093
 
    { "Undefined", (ssize_t) UndefinedLayer, MagickTrue },
1094
 
    { "Coalesce", (ssize_t) CoalesceLayer, MagickFalse },
1095
 
    { "CompareAny", (ssize_t) CompareAnyLayer, MagickFalse },
1096
 
    { "CompareClear", (ssize_t) CompareClearLayer, MagickFalse },
1097
 
    { "CompareOverlay", (ssize_t) CompareOverlayLayer, MagickFalse },
1098
 
    { "Dispose", (ssize_t) DisposeLayer, MagickFalse },
1099
 
    { "Optimize", (ssize_t) OptimizeLayer, MagickFalse },
1100
 
    { "OptimizeFrame", (ssize_t) OptimizeImageLayer, MagickFalse },
1101
 
    { "OptimizePlus", (ssize_t) OptimizePlusLayer, MagickFalse },
1102
 
    { "OptimizeTransparency", (ssize_t) OptimizeTransLayer, MagickFalse },
1103
 
    { "RemoveDups", (ssize_t) RemoveDupsLayer, MagickFalse },
1104
 
    { "RemoveZero", (ssize_t) RemoveZeroLayer, MagickFalse },
1105
 
    { "Composite", (ssize_t) CompositeLayer, MagickFalse },
1106
 
    { "Merge", (ssize_t) MergeLayer, MagickFalse },
1107
 
    { "Flatten", (ssize_t) FlattenLayer, MagickFalse },
1108
 
    { "Mosaic", (ssize_t) MosaicLayer, MagickFalse },
1109
 
    { "TrimBounds", (ssize_t) TrimBoundsLayer, MagickFalse },
1110
 
    { (char *) NULL, (ssize_t) UndefinedLayer, MagickFalse }
 
1060
    { "Undefined", (long) UndefinedLayer, MagickTrue },
 
1061
    { "Coalesce", (long) CoalesceLayer, MagickFalse },
 
1062
    { "CompareAny", (long) CompareAnyLayer, MagickFalse },
 
1063
    { "CompareClear", (long) CompareClearLayer, MagickFalse },
 
1064
    { "CompareOverlay", (long) CompareOverlayLayer, MagickFalse },
 
1065
    { "Dispose", (long) DisposeLayer, MagickFalse },
 
1066
    { "Optimize", (long) OptimizeLayer, MagickFalse },
 
1067
    { "OptimizeFrame", (long) OptimizeImageLayer, MagickFalse },
 
1068
    { "OptimizePlus", (long) OptimizePlusLayer, MagickFalse },
 
1069
    { "OptimizeTransparency", (long) OptimizeTransLayer, MagickFalse },
 
1070
    { "RemoveDups", (long) RemoveDupsLayer, MagickFalse },
 
1071
    { "RemoveZero", (long) RemoveZeroLayer, MagickFalse },
 
1072
    { "Composite", (long) CompositeLayer, MagickFalse },
 
1073
    { "Merge", (long) MergeLayer, MagickFalse },
 
1074
    { "Flatten", (long) FlattenLayer, MagickFalse },
 
1075
    { "Mosaic", (long) MosaicLayer, MagickFalse },
 
1076
    { "TrimBounds", (long) TrimBoundsLayer, MagickFalse },
 
1077
    { (char *) NULL, (long) UndefinedLayer, MagickFalse }
1111
1078
  },
1112
1079
  LineCapOptions[] =
1113
1080
  {
1114
 
    { "Undefined", (ssize_t) UndefinedCap, MagickTrue },
1115
 
    { "Butt", (ssize_t) ButtCap, MagickFalse },
1116
 
    { "Round", (ssize_t) RoundCap, MagickFalse },
1117
 
    { "Square", (ssize_t) SquareCap, MagickFalse },
1118
 
    { (char *) NULL, (ssize_t) UndefinedCap, MagickFalse }
 
1081
    { "Undefined", (long) UndefinedCap, MagickTrue },
 
1082
    { "Butt", (long) ButtCap, MagickFalse },
 
1083
    { "Round", (long) RoundCap, MagickFalse },
 
1084
    { "Square", (long) SquareCap, MagickFalse },
 
1085
    { (char *) NULL, (long) UndefinedCap, MagickFalse }
1119
1086
  },
1120
1087
  LineJoinOptions[] =
1121
1088
  {
1122
 
    { "Undefined", (ssize_t) UndefinedJoin, MagickTrue },
1123
 
    { "Bevel", (ssize_t) BevelJoin, MagickFalse },
1124
 
    { "Miter", (ssize_t) MiterJoin, MagickFalse },
1125
 
    { "Round", (ssize_t) RoundJoin, MagickFalse },
1126
 
    { (char *) NULL, (ssize_t) UndefinedJoin, MagickFalse }
 
1089
    { "Undefined", (long) UndefinedJoin, MagickTrue },
 
1090
    { "Bevel", (long) BevelJoin, MagickFalse },
 
1091
    { "Miter", (long) MiterJoin, MagickFalse },
 
1092
    { "Round", (long) RoundJoin, MagickFalse },
 
1093
    { (char *) NULL, (long) UndefinedJoin, MagickFalse }
1127
1094
  },
1128
1095
  ListOptions[] =
1129
1096
  {
1130
 
    { "Align", (ssize_t) MagickAlignOptions, MagickFalse },
1131
 
    { "Alpha", (ssize_t) MagickAlphaOptions, MagickFalse },
1132
 
    { "Boolean", (ssize_t) MagickBooleanOptions, MagickFalse },
1133
 
    { "Channel", (ssize_t) MagickChannelOptions, MagickFalse },
1134
 
    { "Class", (ssize_t) MagickClassOptions, MagickFalse },
1135
 
    { "ClipPath", (ssize_t) MagickClipPathOptions, MagickFalse },
1136
 
    { "Coder", (ssize_t) MagickCoderOptions, MagickFalse },
1137
 
    { "Color", (ssize_t) MagickColorOptions, MagickFalse },
1138
 
    { "Colorspace", (ssize_t) MagickColorspaceOptions, MagickFalse },
1139
 
    { "Command", (ssize_t) MagickCommandOptions, MagickFalse },
1140
 
    { "Compose", (ssize_t) MagickComposeOptions, MagickFalse },
1141
 
    { "Compress", (ssize_t) MagickCompressOptions, MagickFalse },
1142
 
    { "Configure", (ssize_t) MagickConfigureOptions, MagickFalse },
1143
 
    { "DataType", (ssize_t) MagickDataTypeOptions, MagickFalse },
1144
 
    { "Debug", (ssize_t) MagickDebugOptions, MagickFalse },
1145
 
    { "Decoration", (ssize_t) MagickDecorateOptions, MagickFalse },
1146
 
    { "Delegate", (ssize_t) MagickDelegateOptions, MagickFalse },
1147
 
    { "Direction", (ssize_t) MagickDirectionOptions, MagickFalse },
1148
 
    { "Dispose", (ssize_t) MagickDisposeOptions, MagickFalse },
1149
 
    { "Distort", (ssize_t) MagickDistortOptions, MagickFalse },
1150
 
    { "Dither", (ssize_t) MagickDitherOptions, MagickFalse },
1151
 
    { "Endian", (ssize_t) MagickEndianOptions, MagickFalse },
1152
 
    { "Evaluate", (ssize_t) MagickEvaluateOptions, MagickFalse },
1153
 
    { "FillRule", (ssize_t) MagickFillRuleOptions, MagickFalse },
1154
 
    { "Filter", (ssize_t) MagickFilterOptions, MagickFalse },
1155
 
    { "Font", (ssize_t) MagickFontOptions, MagickFalse },
1156
 
    { "Format", (ssize_t) MagickFormatOptions, MagickFalse },
1157
 
    { "Function", (ssize_t) MagickFunctionOptions, MagickFalse },
1158
 
    { "Gravity", (ssize_t) MagickGravityOptions, MagickFalse },
1159
 
    { "ImageList", (ssize_t) MagickImageListOptions, MagickFalse },
1160
 
    { "Intent", (ssize_t) MagickIntentOptions, MagickFalse },
1161
 
    { "Interlace", (ssize_t) MagickInterlaceOptions, MagickFalse },
1162
 
    { "Interpolate", (ssize_t) MagickInterpolateOptions, MagickFalse },
1163
 
    { "Kernel", (ssize_t) MagickKernelOptions, MagickFalse },
1164
 
    { "Layers", (ssize_t) MagickLayerOptions, MagickFalse },
1165
 
    { "LineCap", (ssize_t) MagickLineCapOptions, MagickFalse },
1166
 
    { "LineJoin", (ssize_t) MagickLineJoinOptions, MagickFalse },
1167
 
    { "List", (ssize_t) MagickListOptions, MagickFalse },
1168
 
    { "Locale", (ssize_t) MagickLocaleOptions, MagickFalse },
1169
 
    { "LogEvent", (ssize_t) MagickLogEventOptions, MagickFalse },
1170
 
    { "Log", (ssize_t) MagickLogOptions, MagickFalse },
1171
 
    { "Magic", (ssize_t) MagickMagicOptions, MagickFalse },
1172
 
    { "Method", (ssize_t) MagickMethodOptions, MagickFalse },
1173
 
    { "Metric", (ssize_t) MagickMetricOptions, MagickFalse },
1174
 
    { "Mime", (ssize_t) MagickMimeOptions, MagickFalse },
1175
 
    { "Mode", (ssize_t) MagickModeOptions, MagickFalse },
1176
 
    { "Morphology", (ssize_t) MagickMorphologyOptions, MagickFalse },
1177
 
    { "Module", (ssize_t) MagickModuleOptions, MagickFalse },
1178
 
    { "Noise", (ssize_t) MagickNoiseOptions, MagickFalse },
1179
 
    { "Orientation", (ssize_t) MagickOrientationOptions, MagickFalse },
1180
 
    { "Policy", (ssize_t) MagickPolicyOptions, MagickFalse },
1181
 
    { "PolicyDomain", (ssize_t) MagickPolicyDomainOptions, MagickFalse },
1182
 
    { "PolicyRights", (ssize_t) MagickPolicyRightsOptions, MagickFalse },
1183
 
    { "Preview", (ssize_t) MagickPreviewOptions, MagickFalse },
1184
 
    { "Primitive", (ssize_t) MagickPrimitiveOptions, MagickFalse },
1185
 
    { "QuantumFormat", (ssize_t) MagickQuantumFormatOptions, MagickFalse },
1186
 
    { "Resource", (ssize_t) MagickResourceOptions, MagickFalse },
1187
 
    { "SparseColor", (ssize_t) MagickSparseColorOptions, MagickFalse },
1188
 
    { "Storage", (ssize_t) MagickStorageOptions, MagickFalse },
1189
 
    { "Stretch", (ssize_t) MagickStretchOptions, MagickFalse },
1190
 
    { "Style", (ssize_t) MagickStyleOptions, MagickFalse },
1191
 
    { "Threshold", (ssize_t) MagickThresholdOptions, MagickFalse },
1192
 
    { "Type", (ssize_t) MagickTypeOptions, MagickFalse },
1193
 
    { "Units", (ssize_t) MagickResolutionOptions, MagickFalse },
1194
 
    { "Undefined", (ssize_t) MagickUndefinedOptions, MagickTrue },
1195
 
    { "Validate", (ssize_t) MagickValidateOptions, MagickFalse },
1196
 
    { "VirtualPixel", (ssize_t) MagickVirtualPixelOptions, MagickFalse },
1197
 
    { (char *) NULL, (ssize_t) MagickUndefinedOptions, MagickFalse }
 
1097
    { "Align", (long) MagickAlignOptions, MagickFalse },
 
1098
    { "Alpha", (long) MagickAlphaOptions, MagickFalse },
 
1099
    { "Boolean", (long) MagickBooleanOptions, MagickFalse },
 
1100
    { "Channel", (long) MagickChannelOptions, MagickFalse },
 
1101
    { "Class", (long) MagickClassOptions, MagickFalse },
 
1102
    { "ClipPath", (long) MagickClipPathOptions, MagickFalse },
 
1103
    { "Coder", (long) MagickCoderOptions, MagickFalse },
 
1104
    { "Color", (long) MagickColorOptions, MagickFalse },
 
1105
    { "Colorspace", (long) MagickColorspaceOptions, MagickFalse },
 
1106
    { "Command", (long) MagickCommandOptions, MagickFalse },
 
1107
    { "Compose", (long) MagickComposeOptions, MagickFalse },
 
1108
    { "Compress", (long) MagickCompressOptions, MagickFalse },
 
1109
    { "Configure", (long) MagickConfigureOptions, MagickFalse },
 
1110
    { "DataType", (long) MagickDataTypeOptions, MagickFalse },
 
1111
    { "Debug", (long) MagickDebugOptions, MagickFalse },
 
1112
    { "Decoration", (long) MagickDecorateOptions, MagickFalse },
 
1113
    { "Delegate", (long) MagickDelegateOptions, MagickFalse },
 
1114
    { "Dispose", (long) MagickDisposeOptions, MagickFalse },
 
1115
    { "Distort", (long) MagickDistortOptions, MagickFalse },
 
1116
    { "Dither", (long) MagickDitherOptions, MagickFalse },
 
1117
    { "Endian", (long) MagickEndianOptions, MagickFalse },
 
1118
    { "Evaluate", (long) MagickEvaluateOptions, MagickFalse },
 
1119
    { "FillRule", (long) MagickFillRuleOptions, MagickFalse },
 
1120
    { "Filter", (long) MagickFilterOptions, MagickFalse },
 
1121
    { "Font", (long) MagickFontOptions, MagickFalse },
 
1122
    { "Format", (long) MagickFormatOptions, MagickFalse },
 
1123
    { "Function", (long) MagickFunctionOptions, MagickFalse },
 
1124
    { "Gravity", (long) MagickGravityOptions, MagickFalse },
 
1125
    { "ImageList", (long) MagickImageListOptions, MagickFalse },
 
1126
    { "Intent", (long) MagickIntentOptions, MagickFalse },
 
1127
    { "Interlace", (long) MagickInterlaceOptions, MagickFalse },
 
1128
    { "Interpolate", (long) MagickInterpolateOptions, MagickFalse },
 
1129
    { "Kernel", (long) MagickKernelOptions, MagickFalse },
 
1130
    { "Layers", (long) MagickLayerOptions, MagickFalse },
 
1131
    { "LineCap", (long) MagickLineCapOptions, MagickFalse },
 
1132
    { "LineJoin", (long) MagickLineJoinOptions, MagickFalse },
 
1133
    { "List", (long) MagickListOptions, MagickFalse },
 
1134
    { "Locale", (long) MagickLocaleOptions, MagickFalse },
 
1135
    { "LogEvent", (long) MagickLogEventOptions, MagickFalse },
 
1136
    { "Log", (long) MagickLogOptions, MagickFalse },
 
1137
    { "Magic", (long) MagickMagicOptions, MagickFalse },
 
1138
    { "Method", (long) MagickMethodOptions, MagickFalse },
 
1139
    { "Metric", (long) MagickMetricOptions, MagickFalse },
 
1140
    { "Mime", (long) MagickMimeOptions, MagickFalse },
 
1141
    { "Mode", (long) MagickModeOptions, MagickFalse },
 
1142
    { "Morphology", (long) MagickMorphologyOptions, MagickFalse },
 
1143
    { "Module", (long) MagickModuleOptions, MagickFalse },
 
1144
    { "Noise", (long) MagickNoiseOptions, MagickFalse },
 
1145
    { "Orientation", (long) MagickOrientationOptions, MagickFalse },
 
1146
    { "Policy", (long) MagickPolicyOptions, MagickFalse },
 
1147
    { "PolicyDomain", (long) MagickPolicyDomainOptions, MagickFalse },
 
1148
    { "PolicyRights", (long) MagickPolicyRightsOptions, MagickFalse },
 
1149
    { "Preview", (long) MagickPreviewOptions, MagickFalse },
 
1150
    { "Primitive", (long) MagickPrimitiveOptions, MagickFalse },
 
1151
    { "QuantumFormat", (long) MagickQuantumFormatOptions, MagickFalse },
 
1152
    { "Resource", (long) MagickResourceOptions, MagickFalse },
 
1153
    { "SparseColor", (long) MagickSparseColorOptions, MagickFalse },
 
1154
    { "Storage", (long) MagickStorageOptions, MagickFalse },
 
1155
    { "Stretch", (long) MagickStretchOptions, MagickFalse },
 
1156
    { "Style", (long) MagickStyleOptions, MagickFalse },
 
1157
    { "Threshold", (long) MagickThresholdOptions, MagickFalse },
 
1158
    { "Type", (long) MagickTypeOptions, MagickFalse },
 
1159
    { "Units", (long) MagickResolutionOptions, MagickFalse },
 
1160
    { "Undefined", (long) MagickUndefinedOptions, MagickTrue },
 
1161
    { "Validate", (long) MagickValidateOptions, MagickFalse },
 
1162
    { "VirtualPixel", (long) MagickVirtualPixelOptions, MagickFalse },
 
1163
    { (char *) NULL, (long) MagickUndefinedOptions, MagickFalse }
1198
1164
  },
1199
1165
  LogEventOptions[] =
1200
1166
  {
1201
 
    { "Undefined", (ssize_t) UndefinedEvents, MagickTrue },
1202
 
    { "All", (ssize_t) (AllEvents &~ TraceEvent), MagickFalse },
1203
 
    { "Annotate", (ssize_t) AnnotateEvent, MagickFalse },
1204
 
    { "Blob", (ssize_t) BlobEvent, MagickFalse },
1205
 
    { "Cache", (ssize_t) CacheEvent, MagickFalse },
1206
 
    { "Coder", (ssize_t) CoderEvent, MagickFalse },
1207
 
    { "Configure", (ssize_t) ConfigureEvent, MagickFalse },
1208
 
    { "Deprecate", (ssize_t) DeprecateEvent, MagickFalse },
1209
 
    { "Draw", (ssize_t) DrawEvent, MagickFalse },
1210
 
    { "Exception", (ssize_t) ExceptionEvent, MagickFalse },
1211
 
    { "Locale", (ssize_t) LocaleEvent, MagickFalse },
1212
 
    { "Module", (ssize_t) ModuleEvent, MagickFalse },
1213
 
    { "None", (ssize_t) NoEvents, MagickFalse },
1214
 
    { "Policy", (ssize_t) PolicyEvent, MagickFalse },
1215
 
    { "Resource", (ssize_t) ResourceEvent, MagickFalse },
1216
 
    { "Trace", (ssize_t) TraceEvent, MagickFalse },
1217
 
    { "Transform", (ssize_t) TransformEvent, MagickFalse },
1218
 
    { "User", (ssize_t) UserEvent, MagickFalse },
1219
 
    { "Wand", (ssize_t) WandEvent, MagickFalse },
1220
 
    { "X11", (ssize_t) X11Event, MagickFalse },
1221
 
    { (char *) NULL, (ssize_t) UndefinedEvents, MagickFalse }
 
1167
    { "Undefined", (long) UndefinedEvents, MagickTrue },
 
1168
    { "All", (long) (AllEvents &~ TraceEvent), MagickFalse },
 
1169
    { "Annotate", (long) AnnotateEvent, MagickFalse },
 
1170
    { "Blob", (long) BlobEvent, MagickFalse },
 
1171
    { "Cache", (long) CacheEvent, MagickFalse },
 
1172
    { "Coder", (long) CoderEvent, MagickFalse },
 
1173
    { "Configure", (long) ConfigureEvent, MagickFalse },
 
1174
    { "Deprecate", (long) DeprecateEvent, MagickFalse },
 
1175
    { "Draw", (long) DrawEvent, MagickFalse },
 
1176
    { "Exception", (long) ExceptionEvent, MagickFalse },
 
1177
    { "Locale", (long) LocaleEvent, MagickFalse },
 
1178
    { "Module", (long) ModuleEvent, MagickFalse },
 
1179
    { "None", (long) NoEvents, MagickFalse },
 
1180
    { "Policy", (long) PolicyEvent, MagickFalse },
 
1181
    { "Resource", (long) ResourceEvent, MagickFalse },
 
1182
    { "Trace", (long) TraceEvent, MagickFalse },
 
1183
    { "Transform", (long) TransformEvent, MagickFalse },
 
1184
    { "User", (long) UserEvent, MagickFalse },
 
1185
    { "Wand", (long) WandEvent, MagickFalse },
 
1186
    { "X11", (long) X11Event, MagickFalse },
 
1187
    { (char *) NULL, (long) UndefinedEvents, MagickFalse }
1222
1188
  },
1223
1189
  MetricOptions[] =
1224
1190
  {
1225
 
    { "Undefined", (ssize_t) UndefinedMetric, MagickTrue },
1226
 
    { "AE", (ssize_t) AbsoluteErrorMetric, MagickFalse },
1227
 
    { "MAE", (ssize_t) MeanAbsoluteErrorMetric, MagickFalse },
1228
 
    { "MEPP", (ssize_t) MeanErrorPerPixelMetric, MagickFalse },
1229
 
    { "MSE", (ssize_t) MeanSquaredErrorMetric, MagickFalse },
1230
 
    { "PAE", (ssize_t) PeakAbsoluteErrorMetric, MagickFalse },
1231
 
    { "PSNR", (ssize_t) PeakSignalToNoiseRatioMetric, MagickFalse },
1232
 
    { "RMSE", (ssize_t) RootMeanSquaredErrorMetric, MagickFalse },
1233
 
    { (char *) NULL, (ssize_t) UndefinedMetric, MagickFalse }
 
1191
    { "Undefined", (long) UndefinedMetric, MagickTrue },
 
1192
    { "AE", (long) AbsoluteErrorMetric, MagickFalse },
 
1193
    { "MAE", (long) MeanAbsoluteErrorMetric, MagickFalse },
 
1194
    { "MEPP", (long) MeanErrorPerPixelMetric, MagickFalse },
 
1195
    { "MSE", (long) MeanSquaredErrorMetric, MagickFalse },
 
1196
    { "PAE", (long) PeakAbsoluteErrorMetric, MagickFalse },
 
1197
    { "PSNR", (long) PeakSignalToNoiseRatioMetric, MagickFalse },
 
1198
    { "RMSE", (long) RootMeanSquaredErrorMetric, MagickFalse },
 
1199
    { (char *) NULL, (long) UndefinedMetric, MagickFalse }
1234
1200
  },
1235
1201
  MethodOptions[] =
1236
1202
  {
1237
 
    { "Undefined", (ssize_t) UndefinedMethod, MagickTrue },
1238
 
    { "FillToBorder", (ssize_t) FillToBorderMethod, MagickFalse },
1239
 
    { "Floodfill", (ssize_t) FloodfillMethod, MagickFalse },
1240
 
    { "Point", (ssize_t) PointMethod, MagickFalse },
1241
 
    { "Replace", (ssize_t) ReplaceMethod, MagickFalse },
1242
 
    { "Reset", (ssize_t) ResetMethod, MagickFalse },
1243
 
    { (char *) NULL, (ssize_t) UndefinedMethod, MagickFalse }
 
1203
    { "Undefined", (long) UndefinedMethod, MagickTrue },
 
1204
    { "FillToBorder", (long) FillToBorderMethod, MagickFalse },
 
1205
    { "Floodfill", (long) FloodfillMethod, MagickFalse },
 
1206
    { "Point", (long) PointMethod, MagickFalse },
 
1207
    { "Replace", (long) ReplaceMethod, MagickFalse },
 
1208
    { "Reset", (long) ResetMethod, MagickFalse },
 
1209
    { (char *) NULL, (long) UndefinedMethod, MagickFalse }
1244
1210
  },
1245
1211
  ModeOptions[] =
1246
1212
  {
1247
 
    { "Undefined", (ssize_t) UndefinedMode, MagickTrue },
1248
 
    { "Concatenate", (ssize_t) ConcatenateMode, MagickFalse },
1249
 
    { "Frame", (ssize_t) FrameMode, MagickFalse },
1250
 
    { "Unframe", (ssize_t) UnframeMode, MagickFalse },
1251
 
    { (char *) NULL, (ssize_t) UndefinedMode, MagickFalse }
 
1213
    { "Undefined", (long) UndefinedMode, MagickTrue },
 
1214
    { "Concatenate", (long) ConcatenateMode, MagickFalse },
 
1215
    { "Frame", (long) FrameMode, MagickFalse },
 
1216
    { "Unframe", (long) UnframeMode, MagickFalse },
 
1217
    { (char *) NULL, (long) UndefinedMode, MagickFalse }
1252
1218
  },
1253
1219
  MorphologyOptions[] =
1254
1220
  {
1255
 
    { "Undefined", (ssize_t) UndefinedMorphology, MagickTrue },
1256
 
    { "Correlate", (ssize_t) CorrelateMorphology, MagickFalse },
1257
 
    { "Convolve", (ssize_t) ConvolveMorphology, MagickFalse },
1258
 
    { "Dilate", (ssize_t) DilateMorphology, MagickFalse },
1259
 
    { "Erode", (ssize_t) ErodeMorphology, MagickFalse },
1260
 
    { "Close", (ssize_t) CloseMorphology, MagickFalse },
1261
 
    { "Open", (ssize_t) OpenMorphology, MagickFalse },
1262
 
    { "DilateIntensity", (ssize_t) DilateIntensityMorphology, MagickFalse },
1263
 
    { "ErodeIntensity", (ssize_t) ErodeIntensityMorphology, MagickFalse },
1264
 
    { "CloseIntensity", (ssize_t) CloseIntensityMorphology, MagickFalse },
1265
 
    { "OpenIntensity", (ssize_t) OpenIntensityMorphology, MagickFalse },
1266
 
    { "DilateI", (ssize_t) DilateIntensityMorphology, MagickFalse },
1267
 
    { "ErodeI", (ssize_t) ErodeIntensityMorphology, MagickFalse },
1268
 
    { "CloseI", (ssize_t) CloseIntensityMorphology, MagickFalse },
1269
 
    { "OpenI", (ssize_t) OpenIntensityMorphology, MagickFalse },
1270
 
    { "Smooth", (ssize_t) SmoothMorphology, MagickFalse },
1271
 
    { "EdgeOut", (ssize_t) EdgeOutMorphology, MagickFalse },
1272
 
    { "EdgeIn", (ssize_t) EdgeInMorphology, MagickFalse },
1273
 
    { "Edge", (ssize_t) EdgeMorphology, MagickFalse },
1274
 
    { "TopHat", (ssize_t) TopHatMorphology, MagickFalse },
1275
 
    { "BottomHat", (ssize_t) BottomHatMorphology, MagickFalse },
1276
 
    { "Distance", (ssize_t) DistanceMorphology, MagickFalse },
1277
 
    { "HitAndMiss", (ssize_t) HitAndMissMorphology, MagickFalse },
1278
 
    { "Thinning", (ssize_t) ThinningMorphology, MagickFalse },
1279
 
    { "Thicken", (ssize_t) ThickenMorphology, MagickFalse },
1280
 
    { (char *) NULL, (ssize_t) UndefinedMorphology, MagickFalse }
 
1221
    { "Undefined", (long) UndefinedMorphology, MagickTrue },
 
1222
    { "Correlate", (long) CorrelateMorphology, MagickFalse },
 
1223
    { "Convolve", (long) ConvolveMorphology, MagickFalse },
 
1224
    { "Dilate", (long) DilateMorphology, MagickFalse },
 
1225
    { "Erode", (long) ErodeMorphology, MagickFalse },
 
1226
    { "Close", (long) CloseMorphology, MagickFalse },
 
1227
    { "Open", (long) OpenMorphology, MagickFalse },
 
1228
    { "DilateIntensity", (long) DilateIntensityMorphology, MagickFalse },
 
1229
    { "ErodeIntensity", (long) ErodeIntensityMorphology, MagickFalse },
 
1230
    { "CloseIntensity", (long) CloseIntensityMorphology, MagickFalse },
 
1231
    { "OpenIntensity", (long) OpenIntensityMorphology, MagickFalse },
 
1232
    { "DilateI", (long) DilateIntensityMorphology, MagickFalse },
 
1233
    { "ErodeI", (long) ErodeIntensityMorphology, MagickFalse },
 
1234
    { "CloseI", (long) CloseIntensityMorphology, MagickFalse },
 
1235
    { "OpenI", (long) OpenIntensityMorphology, MagickFalse },
 
1236
    { "EdgeOut", (long) EdgeOutMorphology, MagickFalse },
 
1237
    { "EdgeIn", (long) EdgeInMorphology, MagickFalse },
 
1238
    { "Edge", (long) EdgeMorphology, MagickFalse },
 
1239
    { "TopHat", (long) TopHatMorphology, MagickFalse },
 
1240
    { "BottomHat", (long) BottomHatMorphology, MagickFalse },
 
1241
    { "Distance", (long) DistanceMorphology, MagickFalse },
 
1242
    { (char *) NULL, (long) UndefinedMorphology, MagickFalse }
1281
1243
  },
1282
1244
  NoiseOptions[] =
1283
1245
  {
1284
 
    { "Undefined", (ssize_t) UndefinedNoise, MagickTrue },
1285
 
    { "Gaussian", (ssize_t) (ssize_t) GaussianNoise, MagickFalse },
1286
 
    { "Impulse", (ssize_t) ImpulseNoise, MagickFalse },
1287
 
    { "Laplacian", (ssize_t) LaplacianNoise, MagickFalse },
1288
 
    { "Multiplicative", (ssize_t) MultiplicativeGaussianNoise, MagickFalse },
1289
 
    { "Poisson", (ssize_t) PoissonNoise, MagickFalse },
1290
 
    { "Random", (ssize_t) RandomNoise, MagickFalse },
1291
 
    { "Uniform", (ssize_t) UniformNoise, MagickFalse },
1292
 
    { (char *) NULL, (ssize_t) UndefinedNoise, MagickFalse }
 
1246
    { "Undefined", (long) UndefinedNoise, MagickTrue },
 
1247
    { "Gaussian", (long) (long) GaussianNoise, MagickFalse },
 
1248
    { "Impulse", (long) ImpulseNoise, MagickFalse },
 
1249
    { "Laplacian", (long) LaplacianNoise, MagickFalse },
 
1250
    { "Multiplicative", (long) MultiplicativeGaussianNoise, MagickFalse },
 
1251
    { "Poisson", (long) PoissonNoise, MagickFalse },
 
1252
    { "Random", (long) RandomNoise, MagickFalse },
 
1253
    { "Uniform", (long) UniformNoise, MagickFalse },
 
1254
    { (char *) NULL, (long) UndefinedNoise, MagickFalse }
1293
1255
  },
1294
1256
  OrientationOptions[] =
1295
1257
  {
1296
 
    { "Undefined", (ssize_t) UndefinedOrientation, MagickTrue },
1297
 
    { "TopLeft", (ssize_t) TopLeftOrientation, MagickFalse },
1298
 
    { "TopRight", (ssize_t) TopRightOrientation, MagickFalse },
1299
 
    { "BottomRight", (ssize_t) BottomRightOrientation, MagickFalse },
1300
 
    { "BottomLeft", (ssize_t) BottomLeftOrientation, MagickFalse },
1301
 
    { "LeftTop", (ssize_t) LeftTopOrientation, MagickFalse },
1302
 
    { "RightTop", (ssize_t) RightTopOrientation, MagickFalse },
1303
 
    { "RightBottom", (ssize_t) RightBottomOrientation, MagickFalse },
1304
 
    { "LeftBottom", (ssize_t) LeftBottomOrientation, MagickFalse }
 
1258
    { "Undefined", (long) UndefinedOrientation, MagickTrue },
 
1259
    { "TopLeft", (long) TopLeftOrientation, MagickFalse },
 
1260
    { "TopRight", (long) TopRightOrientation, MagickFalse },
 
1261
    { "BottomRight", (long) BottomRightOrientation, MagickFalse },
 
1262
    { "BottomLeft", (long) BottomLeftOrientation, MagickFalse },
 
1263
    { "LeftTop", (long) LeftTopOrientation, MagickFalse },
 
1264
    { "RightTop", (long) RightTopOrientation, MagickFalse },
 
1265
    { "RightBottom", (long) RightBottomOrientation, MagickFalse },
 
1266
    { "LeftBottom", (long) LeftBottomOrientation, MagickFalse }
1305
1267
  },
1306
1268
  PolicyDomainOptions[] =
1307
1269
  {
1308
 
    { "Undefined", (ssize_t) UndefinedPolicyDomain, MagickTrue },
1309
 
    { "Coder", (ssize_t) CoderPolicyDomain, MagickFalse },
1310
 
    { "Delegate", (ssize_t) DelegatePolicyDomain, MagickFalse },
1311
 
    { "Filter", (ssize_t) FilterPolicyDomain, MagickFalse },
1312
 
    { "Path", (ssize_t) PathPolicyDomain, MagickFalse },
1313
 
    { "Resource", (ssize_t) ResourcePolicyDomain, MagickFalse },
1314
 
    { "System", (ssize_t) SystemPolicyDomain, MagickFalse }
 
1270
    { "Undefined", (long) UndefinedPolicyDomain, MagickTrue },
 
1271
    { "Coder", (long) CoderPolicyDomain, MagickFalse },
 
1272
    { "Delegate", (long) DelegatePolicyDomain, MagickFalse },
 
1273
    { "Filter", (long) FilterPolicyDomain, MagickFalse },
 
1274
    { "Path", (long) PathPolicyDomain, MagickFalse },
 
1275
    { "Resource", (long) ResourcePolicyDomain, MagickFalse },
 
1276
    { "System", (long) SystemPolicyDomain, MagickFalse }
1315
1277
  },
1316
1278
  PolicyRightsOptions[] =
1317
1279
  {
1318
 
    { "Undefined", (ssize_t) UndefinedPolicyRights, MagickTrue },
1319
 
    { "None", (ssize_t) NoPolicyRights, MagickFalse },
1320
 
    { "Read", (ssize_t) ReadPolicyRights, MagickFalse },
1321
 
    { "Write", (ssize_t) WritePolicyRights, MagickFalse },
1322
 
    { "Execute", (ssize_t) ExecutePolicyRights, MagickFalse }
 
1280
    { "Undefined", (long) UndefinedPolicyRights, MagickTrue },
 
1281
    { "None", (long) NoPolicyRights, MagickFalse },
 
1282
    { "Read", (long) ReadPolicyRights, MagickFalse },
 
1283
    { "Write", (long) WritePolicyRights, MagickFalse },
 
1284
    { "Execute", (long) ExecutePolicyRights, MagickFalse }
1323
1285
  },
1324
1286
  PreviewOptions[] =
1325
1287
  {
1326
 
    { "Undefined", (ssize_t) UndefinedPreview, MagickTrue },
1327
 
    { "AddNoise", (ssize_t) AddNoisePreview, MagickFalse },
1328
 
    { "Blur", (ssize_t) BlurPreview, MagickFalse },
1329
 
    { "Brightness", (ssize_t) BrightnessPreview, MagickFalse },
1330
 
    { "Charcoal", (ssize_t) CharcoalDrawingPreview, MagickFalse },
1331
 
    { "Despeckle", (ssize_t) DespecklePreview, MagickFalse },
1332
 
    { "Dull", (ssize_t) DullPreview, MagickFalse },
1333
 
    { "EdgeDetect", (ssize_t) EdgeDetectPreview, MagickFalse },
1334
 
    { "Gamma", (ssize_t) GammaPreview, MagickFalse },
1335
 
    { "Grayscale", (ssize_t) GrayscalePreview, MagickFalse },
1336
 
    { "Hue", (ssize_t) HuePreview, MagickFalse },
1337
 
    { "Implode", (ssize_t) ImplodePreview, MagickFalse },
1338
 
    { "JPEG", (ssize_t) JPEGPreview, MagickFalse },
1339
 
    { "OilPaint", (ssize_t) OilPaintPreview, MagickFalse },
1340
 
    { "Quantize", (ssize_t) QuantizePreview, MagickFalse },
1341
 
    { "Raise", (ssize_t) RaisePreview, MagickFalse },
1342
 
    { "ReduceNoise", (ssize_t) ReduceNoisePreview, MagickFalse },
1343
 
    { "Roll", (ssize_t) RollPreview, MagickFalse },
1344
 
    { "Rotate", (ssize_t) RotatePreview, MagickFalse },
1345
 
    { "Saturation", (ssize_t) SaturationPreview, MagickFalse },
1346
 
    { "Segment", (ssize_t) SegmentPreview, MagickFalse },
1347
 
    { "Shade", (ssize_t) ShadePreview, MagickFalse },
1348
 
    { "Sharpen", (ssize_t) SharpenPreview, MagickFalse },
1349
 
    { "Shear", (ssize_t) ShearPreview, MagickFalse },
1350
 
    { "Solarize", (ssize_t) SolarizePreview, MagickFalse },
1351
 
    { "Spiff", (ssize_t) SpiffPreview, MagickFalse },
1352
 
    { "Spread", (ssize_t) SpreadPreview, MagickFalse },
1353
 
    { "Swirl", (ssize_t) SwirlPreview, MagickFalse },
1354
 
    { "Threshold", (ssize_t) ThresholdPreview, MagickFalse },
1355
 
    { "Wave", (ssize_t) WavePreview, MagickFalse },
1356
 
    { (char *) NULL, (ssize_t) UndefinedPreview, MagickFalse }
 
1288
    { "Undefined", (long) UndefinedPreview, MagickTrue },
 
1289
    { "AddNoise", (long) AddNoisePreview, MagickFalse },
 
1290
    { "Blur", (long) BlurPreview, MagickFalse },
 
1291
    { "Brightness", (long) BrightnessPreview, MagickFalse },
 
1292
    { "Charcoal", (long) CharcoalDrawingPreview, MagickFalse },
 
1293
    { "Despeckle", (long) DespecklePreview, MagickFalse },
 
1294
    { "Dull", (long) DullPreview, MagickFalse },
 
1295
    { "EdgeDetect", (long) EdgeDetectPreview, MagickFalse },
 
1296
    { "Gamma", (long) GammaPreview, MagickFalse },
 
1297
    { "Grayscale", (long) GrayscalePreview, MagickFalse },
 
1298
    { "Hue", (long) HuePreview, MagickFalse },
 
1299
    { "Implode", (long) ImplodePreview, MagickFalse },
 
1300
    { "JPEG", (long) JPEGPreview, MagickFalse },
 
1301
    { "OilPaint", (long) OilPaintPreview, MagickFalse },
 
1302
    { "Quantize", (long) QuantizePreview, MagickFalse },
 
1303
    { "Raise", (long) RaisePreview, MagickFalse },
 
1304
    { "ReduceNoise", (long) ReduceNoisePreview, MagickFalse },
 
1305
    { "Roll", (long) RollPreview, MagickFalse },
 
1306
    { "Rotate", (long) RotatePreview, MagickFalse },
 
1307
    { "Saturation", (long) SaturationPreview, MagickFalse },
 
1308
    { "Segment", (long) SegmentPreview, MagickFalse },
 
1309
    { "Shade", (long) ShadePreview, MagickFalse },
 
1310
    { "Sharpen", (long) SharpenPreview, MagickFalse },
 
1311
    { "Shear", (long) ShearPreview, MagickFalse },
 
1312
    { "Solarize", (long) SolarizePreview, MagickFalse },
 
1313
    { "Spiff", (long) SpiffPreview, MagickFalse },
 
1314
    { "Spread", (long) SpreadPreview, MagickFalse },
 
1315
    { "Swirl", (long) SwirlPreview, MagickFalse },
 
1316
    { "Threshold", (long) ThresholdPreview, MagickFalse },
 
1317
    { "Wave", (long) WavePreview, MagickFalse },
 
1318
    { (char *) NULL, (long) UndefinedPreview, MagickFalse }
1357
1319
  },
1358
1320
  PrimitiveOptions[] =
1359
1321
  {
1360
 
    { "Undefined", (ssize_t) UndefinedPrimitive, MagickTrue },
1361
 
    { "Arc", (ssize_t) ArcPrimitive, MagickFalse },
1362
 
    { "Bezier", (ssize_t) BezierPrimitive, MagickFalse },
1363
 
    { "Circle", (ssize_t) CirclePrimitive, MagickFalse },
1364
 
    { "Color", (ssize_t) ColorPrimitive, MagickFalse },
1365
 
    { "Ellipse", (ssize_t) EllipsePrimitive, MagickFalse },
1366
 
    { "Image", (ssize_t) ImagePrimitive, MagickFalse },
1367
 
    { "Line", (ssize_t) LinePrimitive, MagickFalse },
1368
 
    { "Matte", (ssize_t) MattePrimitive, MagickFalse },
1369
 
    { "Path", (ssize_t) PathPrimitive, MagickFalse },
1370
 
    { "Point", (ssize_t) PointPrimitive, MagickFalse },
1371
 
    { "Polygon", (ssize_t) PolygonPrimitive, MagickFalse },
1372
 
    { "Polyline", (ssize_t) PolylinePrimitive, MagickFalse },
1373
 
    { "Rectangle", (ssize_t) RectanglePrimitive, MagickFalse },
1374
 
    { "roundRectangle", (ssize_t) RoundRectanglePrimitive, MagickFalse },
1375
 
    { "Text", (ssize_t) TextPrimitive, MagickFalse },
1376
 
    { (char *) NULL, (ssize_t) UndefinedPrimitive, MagickFalse }
 
1322
    { "Undefined", (long) UndefinedPrimitive, MagickTrue },
 
1323
    { "Arc", (long) ArcPrimitive, MagickFalse },
 
1324
    { "Bezier", (long) BezierPrimitive, MagickFalse },
 
1325
    { "Circle", (long) CirclePrimitive, MagickFalse },
 
1326
    { "Color", (long) ColorPrimitive, MagickFalse },
 
1327
    { "Ellipse", (long) EllipsePrimitive, MagickFalse },
 
1328
    { "Image", (long) ImagePrimitive, MagickFalse },
 
1329
    { "Line", (long) LinePrimitive, MagickFalse },
 
1330
    { "Matte", (long) MattePrimitive, MagickFalse },
 
1331
    { "Path", (long) PathPrimitive, MagickFalse },
 
1332
    { "Point", (long) PointPrimitive, MagickFalse },
 
1333
    { "Polygon", (long) PolygonPrimitive, MagickFalse },
 
1334
    { "Polyline", (long) PolylinePrimitive, MagickFalse },
 
1335
    { "Rectangle", (long) RectanglePrimitive, MagickFalse },
 
1336
    { "roundRectangle", (long) RoundRectanglePrimitive, MagickFalse },
 
1337
    { "Text", (long) TextPrimitive, MagickFalse },
 
1338
    { (char *) NULL, (long) UndefinedPrimitive, MagickFalse }
1377
1339
  },
1378
1340
  QuantumFormatOptions[] =
1379
1341
  {
1380
 
    { "Undefined", (ssize_t) UndefinedQuantumFormat, MagickTrue },
1381
 
    { "FloatingPoint", (ssize_t) FloatingPointQuantumFormat, MagickFalse },
1382
 
    { "Signed", (ssize_t) SignedQuantumFormat, MagickFalse },
1383
 
    { "Unsigned", (ssize_t) UnsignedQuantumFormat, MagickFalse },
1384
 
    { (char *) NULL, (ssize_t) FloatingPointQuantumFormat, MagickFalse }
 
1342
    { "Undefined", (long) UndefinedQuantumFormat, MagickTrue },
 
1343
    { "FloatingPoint", (long) FloatingPointQuantumFormat, MagickFalse },
 
1344
    { "Signed", (long) SignedQuantumFormat, MagickFalse },
 
1345
    { "Unsigned", (long) UnsignedQuantumFormat, MagickFalse },
 
1346
    { (char *) NULL, (long) FloatingPointQuantumFormat, MagickFalse }
1385
1347
  },
1386
1348
  ResolutionOptions[] =
1387
1349
  {
1388
 
    { "Undefined", (ssize_t) UndefinedResolution, MagickTrue },
1389
 
    { "PixelsPerInch", (ssize_t) PixelsPerInchResolution, MagickFalse },
1390
 
    { "PixelsPerCentimeter", (ssize_t) PixelsPerCentimeterResolution, MagickFalse },
1391
 
    { (char *) NULL, (ssize_t) UndefinedResolution, MagickFalse }
 
1350
    { "Undefined", (long) UndefinedResolution, MagickTrue },
 
1351
    { "PixelsPerInch", (long) PixelsPerInchResolution, MagickFalse },
 
1352
    { "PixelsPerCentimeter", (long) PixelsPerCentimeterResolution, MagickFalse },
 
1353
    { (char *) NULL, (long) UndefinedResolution, MagickFalse }
1392
1354
  },
1393
1355
  ResourceOptions[] =
1394
1356
  {
1395
 
    { "Undefined", (ssize_t) UndefinedResource, MagickTrue },
1396
 
    { "Area", (ssize_t) AreaResource, MagickFalse },
1397
 
    { "Disk", (ssize_t) DiskResource, MagickFalse },
1398
 
    { "File", (ssize_t) FileResource, MagickFalse },
1399
 
    { "Map", (ssize_t) MapResource, MagickFalse },
1400
 
    { "Memory", (ssize_t) MemoryResource, MagickFalse },
1401
 
    { "Thread", (ssize_t) ThreadResource, MagickFalse },
1402
 
    { "Time", (ssize_t) TimeResource, MagickFalse },
1403
 
    { (char *) NULL, (ssize_t) UndefinedResource, MagickFalse }
 
1357
    { "Undefined", (long) UndefinedResource, MagickTrue },
 
1358
    { "Area", (long) AreaResource, MagickFalse },
 
1359
    { "Disk", (long) DiskResource, MagickFalse },
 
1360
    { "File", (long) FileResource, MagickFalse },
 
1361
    { "Map", (long) MapResource, MagickFalse },
 
1362
    { "Memory", (long) MemoryResource, MagickFalse },
 
1363
    { "Thread", (long) ThreadResource, MagickFalse },
 
1364
    { "Time", (long) TimeResource, MagickFalse },
 
1365
    { (char *) NULL, (long) UndefinedResource, MagickFalse }
1404
1366
  },
1405
1367
  SparseColorOptions[] =
1406
1368
  {
1407
 
    { "Undefined", (ssize_t) UndefinedDistortion, MagickTrue },
1408
 
    { "Barycentric", (ssize_t) BarycentricColorInterpolate, MagickFalse },
1409
 
    { "Bilinear", (ssize_t) BilinearColorInterpolate, MagickFalse },
1410
 
    { "Shepards", (ssize_t) ShepardsColorInterpolate, MagickFalse },
1411
 
    { "Voronoi", (ssize_t) VoronoiColorInterpolate, MagickFalse },
1412
 
    { (char *) NULL, (ssize_t) UndefinedResource, MagickFalse }
 
1369
    { "Undefined", (long) UndefinedDistortion, MagickTrue },
 
1370
    { "Barycentric", (long) BarycentricColorInterpolate, MagickFalse },
 
1371
    { "Bilinear", (long) BilinearColorInterpolate, MagickFalse },
 
1372
    { "Shepards", (long) ShepardsColorInterpolate, MagickFalse },
 
1373
    { "Voronoi", (long) VoronoiColorInterpolate, MagickFalse },
 
1374
    { (char *) NULL, (long) UndefinedResource, MagickFalse }
1413
1375
  },
1414
1376
  StorageOptions[] =
1415
1377
  {
1416
 
    { "Undefined", (ssize_t) UndefinedPixel, MagickTrue },
1417
 
    { "Char", (ssize_t) CharPixel, MagickFalse },
1418
 
    { "Double", (ssize_t) DoublePixel, MagickFalse },
1419
 
    { "Float", (ssize_t) FloatPixel, MagickFalse },
1420
 
    { "Integer", (ssize_t) IntegerPixel, MagickFalse },
1421
 
    { "Long", (ssize_t) LongPixel, MagickFalse },
1422
 
    { "Quantum", (ssize_t) QuantumPixel, MagickFalse },
1423
 
    { "Short", (ssize_t) ShortPixel, MagickFalse },
1424
 
    { (char *) NULL, (ssize_t) UndefinedResource, MagickFalse }
 
1378
    { "Undefined", (long) UndefinedPixel, MagickTrue },
 
1379
    { "Char", (long) CharPixel, MagickFalse },
 
1380
    { "Double", (long) DoublePixel, MagickFalse },
 
1381
    { "Float", (long) FloatPixel, MagickFalse },
 
1382
    { "Integer", (long) IntegerPixel, MagickFalse },
 
1383
    { "Long", (long) LongPixel, MagickFalse },
 
1384
    { "Quantum", (long) QuantumPixel, MagickFalse },
 
1385
    { "Short", (long) ShortPixel, MagickFalse },
 
1386
    { (char *) NULL, (long) UndefinedResource, MagickFalse }
1425
1387
  },
1426
1388
  StretchOptions[] =
1427
1389
  {
1428
 
    { "Undefined", (ssize_t) UndefinedStretch, MagickTrue },
1429
 
    { "Any", (ssize_t) AnyStretch, MagickFalse },
1430
 
    { "Condensed", (ssize_t) CondensedStretch, MagickFalse },
1431
 
    { "Expanded", (ssize_t) ExpandedStretch, MagickFalse },
1432
 
    { "ExtraCondensed", (ssize_t) ExtraCondensedStretch, MagickFalse },
1433
 
    { "ExtraExpanded", (ssize_t) ExtraExpandedStretch, MagickFalse },
1434
 
    { "Normal", (ssize_t) NormalStretch, MagickFalse },
1435
 
    { "SemiCondensed", (ssize_t) SemiCondensedStretch, MagickFalse },
1436
 
    { "SemiExpanded", (ssize_t) SemiExpandedStretch, MagickFalse },
1437
 
    { "UltraCondensed", (ssize_t) UltraCondensedStretch, MagickFalse },
1438
 
    { "UltraExpanded", (ssize_t) UltraExpandedStretch, MagickFalse },
1439
 
    { (char *) NULL, (ssize_t) UndefinedStretch, MagickFalse }
 
1390
    { "Undefined", (long) UndefinedStretch, MagickTrue },
 
1391
    { "Any", (long) AnyStretch, MagickFalse },
 
1392
    { "Condensed", (long) CondensedStretch, MagickFalse },
 
1393
    { "Expanded", (long) ExpandedStretch, MagickFalse },
 
1394
    { "ExtraCondensed", (long) ExtraCondensedStretch, MagickFalse },
 
1395
    { "ExtraExpanded", (long) ExtraExpandedStretch, MagickFalse },
 
1396
    { "Normal", (long) NormalStretch, MagickFalse },
 
1397
    { "SemiCondensed", (long) SemiCondensedStretch, MagickFalse },
 
1398
    { "SemiExpanded", (long) SemiExpandedStretch, MagickFalse },
 
1399
    { "UltraCondensed", (long) UltraCondensedStretch, MagickFalse },
 
1400
    { "UltraExpanded", (long) UltraExpandedStretch, MagickFalse },
 
1401
    { (char *) NULL, (long) UndefinedStretch, MagickFalse }
1440
1402
  },
1441
1403
  StyleOptions[] =
1442
1404
  {
1443
 
    { "Undefined", (ssize_t) UndefinedStyle, MagickTrue },
1444
 
    { "Any", (ssize_t) AnyStyle, MagickFalse },
1445
 
    { "Italic", (ssize_t) ItalicStyle, MagickFalse },
1446
 
    { "Normal", (ssize_t) NormalStyle, MagickFalse },
1447
 
    { "Oblique", (ssize_t) ObliqueStyle, MagickFalse },
1448
 
    { (char *) NULL, (ssize_t) UndefinedStyle, MagickFalse }
 
1405
    { "Undefined", (long) UndefinedStyle, MagickTrue },
 
1406
    { "Any", (long) AnyStyle, MagickFalse },
 
1407
    { "Italic", (long) ItalicStyle, MagickFalse },
 
1408
    { "Normal", (long) NormalStyle, MagickFalse },
 
1409
    { "Oblique", (long) ObliqueStyle, MagickFalse },
 
1410
    { (char *) NULL, (long) UndefinedStyle, MagickFalse }
1449
1411
  },
1450
1412
  TypeOptions[] =
1451
1413
  {
1452
 
    { "Undefined", (ssize_t) UndefinedType, MagickTrue },
1453
 
    { "Bilevel", (ssize_t) BilevelType, MagickFalse },
1454
 
    { "ColorSeparation", (ssize_t) ColorSeparationType, MagickFalse },
1455
 
    { "ColorSeparationMatte", (ssize_t) ColorSeparationMatteType, MagickFalse },
1456
 
    { "Grayscale", (ssize_t) GrayscaleType, MagickFalse },
1457
 
    { "GrayscaleMatte", (ssize_t) GrayscaleMatteType, MagickFalse },
1458
 
    { "Optimize", (ssize_t) OptimizeType, MagickFalse },
1459
 
    { "Palette", (ssize_t) PaletteType, MagickFalse },
1460
 
    { "PaletteBilevelMatte", (ssize_t) PaletteBilevelMatteType, MagickFalse },
1461
 
    { "PaletteMatte", (ssize_t) PaletteMatteType, MagickFalse },
1462
 
    { "TrueColorMatte", (ssize_t) TrueColorMatteType, MagickFalse },
1463
 
    { "TrueColor", (ssize_t) TrueColorType, MagickFalse },
1464
 
    { (char *) NULL, (ssize_t) UndefinedType, MagickFalse }
 
1414
    { "Undefined", (long) UndefinedType, MagickTrue },
 
1415
    { "Bilevel", (long) BilevelType, MagickFalse },
 
1416
    { "ColorSeparation", (long) ColorSeparationType, MagickFalse },
 
1417
    { "ColorSeparationMatte", (long) ColorSeparationMatteType, MagickFalse },
 
1418
    { "Grayscale", (long) GrayscaleType, MagickFalse },
 
1419
    { "GrayscaleMatte", (long) GrayscaleMatteType, MagickFalse },
 
1420
    { "Optimize", (long) OptimizeType, MagickFalse },
 
1421
    { "Palette", (long) PaletteType, MagickFalse },
 
1422
    { "PaletteBilevelMatte", (long) PaletteBilevelMatteType, MagickFalse },
 
1423
    { "PaletteMatte", (long) PaletteMatteType, MagickFalse },
 
1424
    { "TrueColorMatte", (long) TrueColorMatteType, MagickFalse },
 
1425
    { "TrueColor", (long) TrueColorType, MagickFalse },
 
1426
    { (char *) NULL, (long) UndefinedType, MagickFalse }
1465
1427
  },
1466
1428
  ValidateOptions[] =
1467
1429
  {
1468
 
    { "Undefined", (ssize_t) UndefinedValidate, MagickTrue },
1469
 
    { "All", (ssize_t) AllValidate, MagickFalse },
1470
 
    { "Compare", (ssize_t) CompareValidate, MagickFalse },
1471
 
    { "Composite", (ssize_t) CompositeValidate, MagickFalse },
1472
 
    { "Convert", (ssize_t) ConvertValidate, MagickFalse },
1473
 
    { "FormatsInMemory", (ssize_t) FormatsInMemoryValidate, MagickFalse },
1474
 
    { "FormatsOnDisk", (ssize_t) FormatsOnDiskValidate, MagickFalse },
1475
 
    { "Identify", (ssize_t) IdentifyValidate, MagickFalse },
1476
 
    { "ImportExport", (ssize_t) ImportExportValidate, MagickFalse },
1477
 
    { "Montage", (ssize_t) MontageValidate, MagickFalse },
1478
 
    { "Stream", (ssize_t) StreamValidate, MagickFalse },
1479
 
    { "None", (ssize_t) NoValidate, MagickFalse },
1480
 
    { (char *) NULL, (ssize_t) UndefinedValidate, MagickFalse }
 
1430
    { "Undefined", (long) UndefinedValidate, MagickTrue },
 
1431
    { "All", (long) AllValidate, MagickFalse },
 
1432
    { "Compare", (long) CompareValidate, MagickFalse },
 
1433
    { "Composite", (long) CompositeValidate, MagickFalse },
 
1434
    { "Convert", (long) ConvertValidate, MagickFalse },
 
1435
    { "FormatsInMemory", (long) FormatsInMemoryValidate, MagickFalse },
 
1436
    { "FormatsOnDisk", (long) FormatsOnDiskValidate, MagickFalse },
 
1437
    { "Identify", (long) IdentifyValidate, MagickFalse },
 
1438
    { "ImportExport", (long) ImportExportValidate, MagickFalse },
 
1439
    { "Montage", (long) MontageValidate, MagickFalse },
 
1440
    { "Stream", (long) StreamValidate, MagickFalse },
 
1441
    { "None", (long) NoValidate, MagickFalse },
 
1442
    { (char *) NULL, (long) UndefinedValidate, MagickFalse }
1481
1443
  },
1482
1444
  VirtualPixelOptions[] =
1483
1445
  {
1484
 
    { "Undefined", (ssize_t) UndefinedVirtualPixelMethod, MagickTrue },
1485
 
    { "Background", (ssize_t) BackgroundVirtualPixelMethod, MagickFalse },
1486
 
    { "Black", (ssize_t) BlackVirtualPixelMethod, MagickFalse },
1487
 
    { "Constant", (ssize_t) BackgroundVirtualPixelMethod, MagickTrue }, /* deprecated */
1488
 
    { "CheckerTile", (ssize_t) CheckerTileVirtualPixelMethod, MagickFalse },
1489
 
    { "Dither", (ssize_t) DitherVirtualPixelMethod, MagickFalse },
1490
 
    { "Edge", (ssize_t) EdgeVirtualPixelMethod, MagickFalse },
1491
 
    { "Gray", (ssize_t) GrayVirtualPixelMethod, MagickFalse },
1492
 
    { "HorizontalTile", (ssize_t) HorizontalTileVirtualPixelMethod, MagickFalse },
1493
 
    { "HorizontalTileEdge", (ssize_t) HorizontalTileEdgeVirtualPixelMethod, MagickFalse },
1494
 
    { "Mirror", (ssize_t) MirrorVirtualPixelMethod, MagickFalse },
1495
 
    { "Random", (ssize_t) RandomVirtualPixelMethod, MagickFalse },
1496
 
    { "Tile", (ssize_t) TileVirtualPixelMethod, MagickFalse },
1497
 
    { "Transparent", (ssize_t) TransparentVirtualPixelMethod, MagickFalse },
1498
 
    { "VerticalTile", (ssize_t) VerticalTileVirtualPixelMethod, MagickFalse },
1499
 
    { "VerticalTileEdge", (ssize_t) VerticalTileEdgeVirtualPixelMethod, MagickFalse },
1500
 
    { "White", (ssize_t) WhiteVirtualPixelMethod, MagickFalse },
1501
 
    { (char *) NULL, (ssize_t) UndefinedVirtualPixelMethod, MagickFalse }
 
1446
    { "Undefined", (long) UndefinedVirtualPixelMethod, MagickTrue },
 
1447
    { "Background", (long) BackgroundVirtualPixelMethod, MagickFalse },
 
1448
    { "Black", (long) BlackVirtualPixelMethod, MagickFalse },
 
1449
    { "Constant", (long) BackgroundVirtualPixelMethod, MagickTrue }, /* deprecated */
 
1450
    { "CheckerTile", (long) CheckerTileVirtualPixelMethod, MagickFalse },
 
1451
    { "Dither", (long) DitherVirtualPixelMethod, MagickFalse },
 
1452
    { "Edge", (long) EdgeVirtualPixelMethod, MagickFalse },
 
1453
    { "Gray", (long) GrayVirtualPixelMethod, MagickFalse },
 
1454
    { "HorizontalTile", (long) HorizontalTileVirtualPixelMethod, MagickFalse },
 
1455
    { "HorizontalTileEdge", (long) HorizontalTileEdgeVirtualPixelMethod, MagickFalse },
 
1456
    { "Mirror", (long) MirrorVirtualPixelMethod, MagickFalse },
 
1457
    { "Random", (long) RandomVirtualPixelMethod, MagickFalse },
 
1458
    { "Tile", (long) TileVirtualPixelMethod, MagickFalse },
 
1459
    { "Transparent", (long) TransparentVirtualPixelMethod, MagickFalse },
 
1460
    { "VerticalTile", (long) VerticalTileVirtualPixelMethod, MagickFalse },
 
1461
    { "VerticalTileEdge", (long) VerticalTileEdgeVirtualPixelMethod, MagickFalse },
 
1462
    { "White", (long) WhiteVirtualPixelMethod, MagickFalse },
 
1463
    { (char *) NULL, (long) UndefinedVirtualPixelMethod, MagickFalse }
1502
1464
  };
1503
1465
 
1504
1466
/*
1744
1706
    case MagickDataTypeOptions: return(DataTypeOptions);
1745
1707
    case MagickDebugOptions: return(LogEventOptions);
1746
1708
    case MagickDecorateOptions: return(DecorateOptions);
1747
 
    case MagickDirectionOptions: return(DirectionOptions);
1748
1709
    case MagickDisposeOptions: return(DisposeOptions);
1749
1710
    case MagickDistortOptions: return(DistortOptions);
1750
1711
    case MagickDitherOptions: return(DitherOptions);
1797
1758
  const OptionInfo
1798
1759
    *option_info;
1799
1760
 
1800
 
  register ssize_t
 
1761
  register long
1801
1762
    i;
1802
1763
 
1803
1764
  option_info=GetOptionInfo(value);
1899
1860
%  The format of the MagickOptionToMnemonic method is:
1900
1861
%
1901
1862
%      const char *MagickOptionToMnemonic(const MagickOption option,
1902
 
%        const ssize_t type)
 
1863
%        const long type)
1903
1864
%
1904
1865
%  A description of each parameter follows:
1905
1866
%
1909
1870
%
1910
1871
*/
1911
1872
MagickExport const char *MagickOptionToMnemonic(const MagickOption option,
1912
 
  const ssize_t type)
 
1873
  const long type)
1913
1874
{
1914
1875
  const OptionInfo
1915
1876
    *option_info;
1916
1877
 
1917
 
  register ssize_t
 
1878
  register long
1918
1879
    i;
1919
1880
 
1920
1881
  option_info=GetOptionInfo(option);
1961
1922
  const OptionInfo
1962
1923
    *option_info;
1963
1924
 
1964
 
  register ssize_t
 
1925
  register long
1965
1926
    i;
1966
1927
 
1967
1928
  if (file == (FILE *) NULL)
1994
1955
%
1995
1956
%  The format of the ParseChannelOption method is:
1996
1957
%
1997
 
%      ssize_t ParseChannelOption(const char *channels)
 
1958
%      long ParseChannelOption(const char *channels)
1998
1959
%
1999
1960
%  A description of each parameter follows:
2000
1961
%
2001
1962
%    o options: One or more values separated by commas.
2002
1963
%
2003
1964
*/
2004
 
MagickExport ssize_t ParseChannelOption(const char *channels)
 
1965
MagickExport long ParseChannelOption(const char *channels)
2005
1966
{
2006
 
  ssize_t
 
1967
  long
2007
1968
    channel;
2008
1969
 
2009
 
  register ssize_t
 
1970
  register long
2010
1971
    i;
2011
1972
 
2012
1973
  channel=ParseMagickOption(MagickChannelOptions,MagickTrue,channels);
2013
1974
  if (channel >= 0)
2014
1975
    return(channel);
2015
1976
  channel=0;
2016
 
  for (i=0; i < (ssize_t) strlen(channels); i++)
 
1977
  for (i=0; i < (long) strlen(channels); i++)
2017
1978
  {
2018
1979
    switch (channels[i])
2019
1980
    {
2083
2044
          More channel flags follow shorthand.  For example "RGB,sync"
2084
2045
          Gather the additional channel flags and merge with shorthand
2085
2046
        */
2086
 
        ssize_t
 
2047
        long
2087
2048
          more_channel;
2088
2049
        more_channel=ParseMagickOption(MagickChannelOptions,MagickTrue,
2089
2050
                             channels+i+1);
2114
2075
%
2115
2076
%  The format of the ParseMagickOption method is:
2116
2077
%
2117
 
%      ssize_t ParseMagickOption(const MagickOption option,
 
2078
%      long ParseMagickOption(const MagickOption option,
2118
2079
%        const MagickBooleanType list,const char *options)
2119
2080
%
2120
2081
%  A description of each parameter follows:
2127
2088
%    o options: One or more options separated by commas.
2128
2089
%
2129
2090
*/
2130
 
MagickExport ssize_t ParseMagickOption(const MagickOption option,
 
2091
MagickExport long ParseMagickOption(const MagickOption option,
2131
2092
  const MagickBooleanType list,const char *options)
2132
2093
{
2133
2094
  char
2139
2100
  int
2140
2101
    sentinel;
2141
2102
 
2142
 
  ssize_t
 
2103
  long
2143
2104
    option_types;
2144
2105
 
2145
2106
  MagickBooleanType
2151
2112
  register const char
2152
2113
    *p;
2153
2114
 
2154
 
  register ssize_t
 
2115
  register long
2155
2116
    i;
2156
2117
 
2157
2118
  option_info=GetOptionInfo(option);