Merge pull request #119 from 5ohue/master

Create "types" module

src/lib.rs

@@ -36,15 +36,16 @@ use libc::size_t;
 #[cfg(not(target_os = "freebsd"))]
 use libc::ssize_t;
 
-pub use bindings::{ColorspaceType, DitherMethod, FilterType, GravityType, MetricType};
 pub use conversions::ToMagick;
 pub use result::MagickError;
 use result::Result;
 pub use wand::*;
+pub use types::*;
 
 mod conversions;
 mod result;
 mod wand;
+mod types;
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 
 /// This function must be called before any other ImageMagick operations

src/types/colorspace_type.rs

@@ -0,0 +1,75 @@
+use crate::bindings;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum ColorspaceType {
+    Undefined   = bindings::ColorspaceType_UndefinedColorspace,
+    CMY         = bindings::ColorspaceType_CMYColorspace,
+    CMYK        = bindings::ColorspaceType_CMYKColorspace,
+    GRAY        = bindings::ColorspaceType_GRAYColorspace,
+    HCL         = bindings::ColorspaceType_HCLColorspace,
+    HCLp        = bindings::ColorspaceType_HCLpColorspace,
+    HSB         = bindings::ColorspaceType_HSBColorspace,
+    HSI         = bindings::ColorspaceType_HSIColorspace,
+    HSL         = bindings::ColorspaceType_HSLColorspace,
+    HSV         = bindings::ColorspaceType_HSVColorspace,
+    HWB         = bindings::ColorspaceType_HWBColorspace,
+    Lab         = bindings::ColorspaceType_LabColorspace,
+    LCH         = bindings::ColorspaceType_LCHColorspace,
+    LCHab       = bindings::ColorspaceType_LCHabColorspace,
+    LCHuv       = bindings::ColorspaceType_LCHuvColorspace,
+    Log         = bindings::ColorspaceType_LogColorspace,
+    LMS         = bindings::ColorspaceType_LMSColorspace,
+    Luv         = bindings::ColorspaceType_LuvColorspace,
+    OHTA        = bindings::ColorspaceType_OHTAColorspace,
+    Rec601YCbCr = bindings::ColorspaceType_Rec601YCbCrColorspace,
+    Rec709YCbCr = bindings::ColorspaceType_Rec709YCbCrColorspace,
+    RGB         = bindings::ColorspaceType_RGBColorspace,
+    scRGB       = bindings::ColorspaceType_scRGBColorspace,
+    sRGB        = bindings::ColorspaceType_sRGBColorspace,
+    Transparent = bindings::ColorspaceType_TransparentColorspace,
+    xyY         = bindings::ColorspaceType_xyYColorspace,
+    XYZ         = bindings::ColorspaceType_XYZColorspace,
+    YCbCr       = bindings::ColorspaceType_YCbCrColorspace,
+    YCC         = bindings::ColorspaceType_YCCColorspace,
+    YDbDr       = bindings::ColorspaceType_YDbDrColorspace,
+    YIQ         = bindings::ColorspaceType_YIQColorspace,
+    YPbPr       = bindings::ColorspaceType_YPbPrColorspace,
+    YUV         = bindings::ColorspaceType_YUVColorspace,
+    LinearGRAY  = bindings::ColorspaceType_LinearGRAYColorspace,
+    Jzazbz      = bindings::ColorspaceType_JzazbzColorspace,
+    DisplayP3   = bindings::ColorspaceType_DisplayP3Colorspace,
+    Adobe98     = bindings::ColorspaceType_Adobe98Colorspace,
+    ProPhoto    = bindings::ColorspaceType_ProPhotoColorspace,
+    Oklab       = bindings::ColorspaceType_OklabColorspace,
+    Oklch       = bindings::ColorspaceType_OklchColorspace,
+}
+
+impl Default for ColorspaceType {
+    fn default() -> Self {
+        return ColorspaceType::RGB;
+    }
+}
+
+impl From<ColorspaceType> for bindings::ColorspaceType {
+    fn from(value: ColorspaceType) -> Self {
+        return value as bindings::ColorspaceType;
+    }
+}
+
+impl From<bindings::ColorspaceType> for ColorspaceType {
+    fn from(value: bindings::ColorspaceType) -> Self {
+        /*
+         * SAFETY:
+         *
+         * `ColorspaceType` has the same repr as `bindings::ColorspaceType` - u32
+         *
+         * If `value` is less than Oklch than it is in the vaild range and can be safely
+         * reinterpreted as `ColorspaceType`
+         */
+        if value <= bindings::ColorspaceType_OklchColorspace {
+            return unsafe { std::mem::transmute(value) };
+        }
+        return ColorspaceType::default();
+    }
+}

src/types/composite_operator.rs

@@ -0,0 +1,117 @@
+use crate::bindings;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum CompositeOperator {
+    Undefined        = bindings::CompositeOperator_UndefinedCompositeOp,
+    Alpha            = bindings::CompositeOperator_AlphaCompositeOp,
+    Atop             = bindings::CompositeOperator_AtopCompositeOp,
+    Blend            = bindings::CompositeOperator_BlendCompositeOp,
+    Blur             = bindings::CompositeOperator_BlurCompositeOp,
+    Bumpmap          = bindings::CompositeOperator_BumpmapCompositeOp,
+    ChangeMask       = bindings::CompositeOperator_ChangeMaskCompositeOp,
+    Clear            = bindings::CompositeOperator_ClearCompositeOp,
+    ColorBurn        = bindings::CompositeOperator_ColorBurnCompositeOp,
+    ColorDodge       = bindings::CompositeOperator_ColorDodgeCompositeOp,
+    Colorize         = bindings::CompositeOperator_ColorizeCompositeOp,
+    CopyBlack        = bindings::CompositeOperator_CopyBlackCompositeOp,
+    CopyBlue         = bindings::CompositeOperator_CopyBlueCompositeOp,
+    Copy             = bindings::CompositeOperator_CopyCompositeOp,
+    CopyCyan         = bindings::CompositeOperator_CopyCyanCompositeOp,
+    CopyGreen        = bindings::CompositeOperator_CopyGreenCompositeOp,
+    CopyMagenta      = bindings::CompositeOperator_CopyMagentaCompositeOp,
+    CopyAlpha        = bindings::CompositeOperator_CopyAlphaCompositeOp,
+    CopyRed          = bindings::CompositeOperator_CopyRedCompositeOp,
+    CopyYellow       = bindings::CompositeOperator_CopyYellowCompositeOp,
+    Darken           = bindings::CompositeOperator_DarkenCompositeOp,
+    DarkenIntensity  = bindings::CompositeOperator_DarkenIntensityCompositeOp,
+    Difference       = bindings::CompositeOperator_DifferenceCompositeOp,
+    Displace         = bindings::CompositeOperator_DisplaceCompositeOp,
+    Dissolve         = bindings::CompositeOperator_DissolveCompositeOp,
+    Distort          = bindings::CompositeOperator_DistortCompositeOp,
+    DivideDst        = bindings::CompositeOperator_DivideDstCompositeOp,
+    DivideSrc        = bindings::CompositeOperator_DivideSrcCompositeOp,
+    DstAtop          = bindings::CompositeOperator_DstAtopCompositeOp,
+    Dst              = bindings::CompositeOperator_DstCompositeOp,
+    DstIn            = bindings::CompositeOperator_DstInCompositeOp,
+    DstOut           = bindings::CompositeOperator_DstOutCompositeOp,
+    DstOver          = bindings::CompositeOperator_DstOverCompositeOp,
+    Exclusion        = bindings::CompositeOperator_ExclusionCompositeOp,
+    HardLight        = bindings::CompositeOperator_HardLightCompositeOp,
+    HardMix          = bindings::CompositeOperator_HardMixCompositeOp,
+    Hue              = bindings::CompositeOperator_HueCompositeOp,
+    In               = bindings::CompositeOperator_InCompositeOp,
+    Intensity        = bindings::CompositeOperator_IntensityCompositeOp,
+    Lighten          = bindings::CompositeOperator_LightenCompositeOp,
+    LightenIntensity = bindings::CompositeOperator_LightenIntensityCompositeOp,
+    LinearBurn       = bindings::CompositeOperator_LinearBurnCompositeOp,
+    LinearDodge      = bindings::CompositeOperator_LinearDodgeCompositeOp,
+    LinearLight      = bindings::CompositeOperator_LinearLightCompositeOp,
+    Luminize         = bindings::CompositeOperator_LuminizeCompositeOp,
+    Mathematics      = bindings::CompositeOperator_MathematicsCompositeOp,
+    MinusDst         = bindings::CompositeOperator_MinusDstCompositeOp,
+    MinusSrc         = bindings::CompositeOperator_MinusSrcCompositeOp,
+    Modulate         = bindings::CompositeOperator_ModulateCompositeOp,
+    ModulusAdd       = bindings::CompositeOperator_ModulusAddCompositeOp,
+    ModulusSubtract  = bindings::CompositeOperator_ModulusSubtractCompositeOp,
+    Multiply         = bindings::CompositeOperator_MultiplyCompositeOp,
+    No               = bindings::CompositeOperator_NoCompositeOp,
+    Out              = bindings::CompositeOperator_OutCompositeOp,
+    Over             = bindings::CompositeOperator_OverCompositeOp,
+    Overlay          = bindings::CompositeOperator_OverlayCompositeOp,
+    PegtopLight      = bindings::CompositeOperator_PegtopLightCompositeOp,
+    PinLight         = bindings::CompositeOperator_PinLightCompositeOp,
+    Plus             = bindings::CompositeOperator_PlusCompositeOp,
+    Replace          = bindings::CompositeOperator_ReplaceCompositeOp,
+    Saturate         = bindings::CompositeOperator_SaturateCompositeOp,
+    Screen           = bindings::CompositeOperator_ScreenCompositeOp,
+    SoftLight        = bindings::CompositeOperator_SoftLightCompositeOp,
+    SrcAtop          = bindings::CompositeOperator_SrcAtopCompositeOp,
+    Src              = bindings::CompositeOperator_SrcCompositeOp,
+    SrcIn            = bindings::CompositeOperator_SrcInCompositeOp,
+    SrcOut           = bindings::CompositeOperator_SrcOutCompositeOp,
+    SrcOver          = bindings::CompositeOperator_SrcOverCompositeOp,
+    Threshold        = bindings::CompositeOperator_ThresholdCompositeOp,
+    VividLight       = bindings::CompositeOperator_VividLightCompositeOp,
+    Xor              = bindings::CompositeOperator_XorCompositeOp,
+    Stereo           = bindings::CompositeOperator_StereoCompositeOp,
+    Freeze           = bindings::CompositeOperator_FreezeCompositeOp,
+    Interpolate      = bindings::CompositeOperator_InterpolateCompositeOp,
+    Negate           = bindings::CompositeOperator_NegateCompositeOp,
+    Reflect          = bindings::CompositeOperator_ReflectCompositeOp,
+    SoftBurn         = bindings::CompositeOperator_SoftBurnCompositeOp,
+    SoftDodge        = bindings::CompositeOperator_SoftDodgeCompositeOp,
+    Stamp            = bindings::CompositeOperator_StampCompositeOp,
+    RMSE             = bindings::CompositeOperator_RMSECompositeOp,
+    SaliencyBlend    = bindings::CompositeOperator_SaliencyBlendCompositeOp,
+    SeamlessBlend    = bindings::CompositeOperator_SeamlessBlendCompositeOp,
+}
+
+impl Default for CompositeOperator {
+    fn default() -> Self {
+        return CompositeOperator::Over;
+    }
+}
+
+impl From<CompositeOperator> for bindings::CompositeOperator {
+    fn from(value: CompositeOperator) -> Self {
+        return value as bindings::CompositeOperator;
+    }
+}
+
+impl From<bindings::CompositeOperator> for CompositeOperator {
+    fn from(value: bindings::CompositeOperator) -> Self {
+        /*
+         * SAFETY:
+         *
+         * `CompositeOperator` has the same repr as `bindings::CompositeOperator` - u32
+         *
+         * If `value` is less than SeamlessBlend than it is in the vaild range and can be safely
+         * reinterpreted as `CompositeOperator`
+         */
+        if value <= bindings::CompositeOperator_SeamlessBlendCompositeOp {
+            return unsafe { std::mem::transmute(value) };
+        }
+        return CompositeOperator::default();
+    }
+}

src/types/dither_method.rs

@@ -0,0 +1,22 @@
+use crate::bindings;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum DitherMethod {
+    Undefined      = bindings::DitherMethod_UndefinedDitherMethod,
+    No             = bindings::DitherMethod_NoDitherMethod,
+    Riemersma      = bindings::DitherMethod_RiemersmaDitherMethod,
+    FloydSteinberg = bindings::DitherMethod_FloydSteinbergDitherMethod,
+}
+
+impl Default for DitherMethod {
+    fn default() -> Self {
+        return DitherMethod::No;
+    }
+}
+
+impl From<DitherMethod> for bindings::DitherMethod {
+    fn from(value: DitherMethod) -> Self {
+        return value as bindings::DitherMethod;
+    }
+}

src/types/filter_type.rs

@@ -0,0 +1,45 @@
+use crate::bindings;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum FilterType {
+    Undefined     = bindings::FilterType_UndefinedFilter,
+    Point         = bindings::FilterType_PointFilter,
+    Box           = bindings::FilterType_BoxFilter,
+    Triangle      = bindings::FilterType_TriangleFilter,
+    Hermite       = bindings::FilterType_HermiteFilter,
+    Hann          = bindings::FilterType_HannFilter,
+    Hamming       = bindings::FilterType_HammingFilter,
+    Blackman      = bindings::FilterType_BlackmanFilter,
+    Gaussian      = bindings::FilterType_GaussianFilter,
+    Quadratic     = bindings::FilterType_QuadraticFilter,
+    Cubic         = bindings::FilterType_CubicFilter,
+    Catrom        = bindings::FilterType_CatromFilter,
+    Mitchell      = bindings::FilterType_MitchellFilter,
+    Jinc          = bindings::FilterType_JincFilter,
+    Sinc          = bindings::FilterType_SincFilter,
+    SincFast      = bindings::FilterType_SincFastFilter,
+    Kaiser        = bindings::FilterType_KaiserFilter,
+    Welch         = bindings::FilterType_WelchFilter,
+    Parzen        = bindings::FilterType_ParzenFilter,
+    Bohman        = bindings::FilterType_BohmanFilter,
+    Bartlett      = bindings::FilterType_BartlettFilter,
+    Lagrange      = bindings::FilterType_LagrangeFilter,
+    Lanczos       = bindings::FilterType_LanczosFilter,
+    LanczosSharp  = bindings::FilterType_LanczosSharpFilter,
+    Lanczos2      = bindings::FilterType_Lanczos2Filter,
+    Lanczos2Sharp = bindings::FilterType_Lanczos2SharpFilter,
+    Robidoux      = bindings::FilterType_RobidouxFilter,
+    RobidouxSharp = bindings::FilterType_RobidouxSharpFilter,
+    Cosine        = bindings::FilterType_CosineFilter,
+    Spline        = bindings::FilterType_SplineFilter,
+    LanczosRadius = bindings::FilterType_LanczosRadiusFilter,
+    CubicSpline   = bindings::FilterType_CubicSplineFilter,
+    Sentinel      = bindings::FilterType_SentinelFilter,
+}
+
+impl From<FilterType> for bindings::FilterType {
+    fn from(value: FilterType) -> Self {
+        return value as bindings::FilterType;
+    }
+}

src/types/gravity_type.rs

@@ -0,0 +1,49 @@
+use crate::bindings;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum GravityType {
+    Undefined = bindings::GravityType_UndefinedGravity,
+    /*
+     * Identical to `Undefined`
+     */
+    // Forget    = bindings::GravityType_ForgetGravity,
+    NorthWest = bindings::GravityType_NorthWestGravity,
+    North     = bindings::GravityType_NorthGravity,
+    NorthEast = bindings::GravityType_NorthEastGravity,
+    West      = bindings::GravityType_WestGravity,
+    Center    = bindings::GravityType_CenterGravity,
+    East      = bindings::GravityType_EastGravity,
+    SouthWest = bindings::GravityType_SouthWestGravity,
+    South     = bindings::GravityType_SouthGravity,
+    SouthEast = bindings::GravityType_SouthEastGravity,
+}
+
+impl Default for GravityType {
+    fn default() -> Self {
+        return GravityType::Undefined;
+    }
+}
+
+impl From<GravityType> for bindings::GravityType {
+    fn from(value: GravityType) -> Self {
+        return value as bindings::GravityType;
+    }
+}
+
+impl From<bindings::GravityType> for GravityType {
+    fn from(value: bindings::GravityType) -> Self {
+        /*
+         * SAFETY:
+         *
+         * `GravityType` has the same repr as `bindings::GravityType` - u32
+         *
+         * If `value` is less than SouthEast than it is in the vaild range and can be safely
+         * reinterpreted as `GravityType`
+         */
+        if value <= bindings::GravityType_SouthEastGravity {
+            return unsafe { std::mem::transmute(value) };
+        }
+        return GravityType::default();
+    }
+}

src/types/metric_type.rs

@@ -0,0 +1,29 @@
+use crate::bindings;
+
+pub enum MetricType {
+    Undefined                  = bindings::MetricType_UndefinedErrorMetric                  as isize,
+    Absolute                   = bindings::MetricType_AbsoluteErrorMetric                   as isize,
+    Fuzz                       = bindings::MetricType_FuzzErrorMetric                       as isize,
+    MeanAbsolute               = bindings::MetricType_MeanAbsoluteErrorMetric               as isize,
+    MeanErrorPerPixel          = bindings::MetricType_MeanErrorPerPixelErrorMetric          as isize,
+    MeanSquared                = bindings::MetricType_MeanSquaredErrorMetric                as isize,
+    NormalizedCrossCorrelation = bindings::MetricType_NormalizedCrossCorrelationErrorMetric as isize,
+    PeakAbsolute               = bindings::MetricType_PeakAbsoluteErrorMetric               as isize,
+    PeakSignalToNoiseRatio     = bindings::MetricType_PeakSignalToNoiseRatioErrorMetric     as isize,
+    PerceptualHash             = bindings::MetricType_PerceptualHashErrorMetric             as isize,
+    RootMeanSquared            = bindings::MetricType_RootMeanSquaredErrorMetric            as isize,
+    StructuralSimilarity       = bindings::MetricType_StructuralSimilarityErrorMetric       as isize,
+    StructuralDissimilarity    = bindings::MetricType_StructuralDissimilarityErrorMetric    as isize,
+}
+
+impl Default for MetricType {
+    fn default() -> Self {
+        return MetricType::Absolute;
+    }
+}
+
+impl From<MetricType> for bindings::MetricType {
+    fn from(value: MetricType) -> Self {
+        return value as bindings::MetricType;
+    }
+}

src/types/mod.rs

@@ -0,0 +1,15 @@
+mod colorspace_type;
+mod composite_operator;
+mod dither_method;
+mod filter_type;
+mod gravity_type;
+mod metric_type;
+mod resource_type;
+
+pub use self::colorspace_type::ColorspaceType;
+pub use self::composite_operator::CompositeOperator;
+pub use self::dither_method::DitherMethod;
+pub use self::filter_type::FilterType;
+pub use self::gravity_type::GravityType;
+pub use self::metric_type::MetricType;
+pub use self::resource_type::ResourceType;

src/types/resource_type.rs

@@ -0,0 +1,24 @@
+use crate::bindings;
+
+/// Resource type to use with [set_resource_limit](crate::MagickWand::set_resource_limit)
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ResourceType {
+    Undefined  = bindings::ResourceType_UndefinedResource  as isize,
+    Area       = bindings::ResourceType_AreaResource       as isize,
+    Disk       = bindings::ResourceType_DiskResource       as isize,
+    File       = bindings::ResourceType_FileResource       as isize,
+    Height     = bindings::ResourceType_HeightResource     as isize,
+    Map        = bindings::ResourceType_MapResource        as isize,
+    Memory     = bindings::ResourceType_MemoryResource     as isize,
+    Thread     = bindings::ResourceType_ThreadResource     as isize,
+    Throttle   = bindings::ResourceType_ThrottleResource   as isize,
+    Time       = bindings::ResourceType_TimeResource       as isize,
+    Width      = bindings::ResourceType_WidthResource      as isize,
+    ListLength = bindings::ResourceType_ListLengthResource as isize,
+}
+
+impl From<ResourceType> for bindings::ResourceType {
+    fn from(value: ResourceType) -> Self {
+        return value as bindings::ResourceType;
+    }
+}

src/wand/composite_operator.rs

@@ -1,265 +0,0 @@
-#[derive(Default, Debug, Clone, Copy)]
-pub enum CompositeOperator {
-    Undefined,
-    Alpha,
-    Atop,
-    Blend,
-    Blur,
-    Bumpmap,
-    ChangeMask,
-    Clear,
-    ColorBurn,
-    ColorDodge,
-    Colorize,
-    CopyBlack,
-    CopyBlue,
-    Copy,
-    CopyCyan,
-    CopyGreen,
-    CopyMagenta,
-    CopyAlpha,
-    CopyRed,
-    CopyYellow,
-    Darken,
-    DarkenIntensity,
-    Difference,
-    Displace,
-    Dissolve,
-    Distort,
-    DivideDst,
-    DivideSrc,
-    DstAtop,
-    Dst,
-    DstIn,
-    DstOut,
-    DstOver,
-    Exclusion,
-    HardLight,
-    HardMix,
-    Hue,
-    In,
-    Intensity,
-    Lighten,
-    LightenIntensity,
-    LinearBurn,
-    LinearDodge,
-    LinearLight,
-    Luminize,
-    Mathematics,
-    MinusDst,
-    MinusSrc,
-    Modulate,
-    ModulusAdd,
-    ModulusSubtract,
-    Multiply,
-    No,
-    Out,
-    #[default]
-    Over,
-    Overlay,
-    PegtopLight,
-    PinLight,
-    Plus,
-    Replace,
-    Saturate,
-    Screen,
-    SoftLight,
-    SrcAtop,
-    Src,
-    SrcIn,
-    SrcOut,
-    SrcOver,
-    Threshold,
-    VividLight,
-    Xor,
-    Stereo,
-    Freeze,
-    Interpolate,
-    Negate,
-    Reflect,
-    SoftBurn,
-    SoftDodge,
-    Stamp,
-    RMSE,
-    SaliencyBlend,
-    SeamlessBlend,
-}
-
-impl From<CompositeOperator> for crate::bindings::CompositeOperator {
-    fn from(value: CompositeOperator) -> Self {
-        match value {
-            CompositeOperator::Undefined        => crate::bindings::CompositeOperator_UndefinedCompositeOp,
-            CompositeOperator::Alpha            => crate::bindings::CompositeOperator_AlphaCompositeOp,
-            CompositeOperator::Atop             => crate::bindings::CompositeOperator_AtopCompositeOp,
-            CompositeOperator::Blend            => crate::bindings::CompositeOperator_BlendCompositeOp,
-            CompositeOperator::Blur             => crate::bindings::CompositeOperator_BlurCompositeOp,
-            CompositeOperator::Bumpmap          => crate::bindings::CompositeOperator_BumpmapCompositeOp,
-            CompositeOperator::ChangeMask       => crate::bindings::CompositeOperator_ChangeMaskCompositeOp,
-            CompositeOperator::Clear            => crate::bindings::CompositeOperator_ClearCompositeOp,
-            CompositeOperator::ColorBurn        => crate::bindings::CompositeOperator_ColorBurnCompositeOp,
-            CompositeOperator::ColorDodge       => crate::bindings::CompositeOperator_ColorDodgeCompositeOp,
-            CompositeOperator::Colorize         => crate::bindings::CompositeOperator_ColorizeCompositeOp,
-            CompositeOperator::CopyBlack        => crate::bindings::CompositeOperator_CopyBlackCompositeOp,
-            CompositeOperator::CopyBlue         => crate::bindings::CompositeOperator_CopyBlueCompositeOp,
-            CompositeOperator::Copy             => crate::bindings::CompositeOperator_CopyCompositeOp,
-            CompositeOperator::CopyCyan         => crate::bindings::CompositeOperator_CopyCyanCompositeOp,
-            CompositeOperator::CopyGreen        => crate::bindings::CompositeOperator_CopyGreenCompositeOp,
-            CompositeOperator::CopyMagenta      => crate::bindings::CompositeOperator_CopyMagentaCompositeOp,
-            CompositeOperator::CopyAlpha        => crate::bindings::CompositeOperator_CopyAlphaCompositeOp,
-            CompositeOperator::CopyRed          => crate::bindings::CompositeOperator_CopyRedCompositeOp,
-            CompositeOperator::CopyYellow       => crate::bindings::CompositeOperator_CopyYellowCompositeOp,
-            CompositeOperator::Darken           => crate::bindings::CompositeOperator_DarkenCompositeOp,
-            CompositeOperator::DarkenIntensity  => crate::bindings::CompositeOperator_DarkenIntensityCompositeOp,
-            CompositeOperator::Difference       => crate::bindings::CompositeOperator_DifferenceCompositeOp,
-            CompositeOperator::Displace         => crate::bindings::CompositeOperator_DisplaceCompositeOp,
-            CompositeOperator::Dissolve         => crate::bindings::CompositeOperator_DissolveCompositeOp,
-            CompositeOperator::Distort          => crate::bindings::CompositeOperator_DistortCompositeOp,
-            CompositeOperator::DivideDst        => crate::bindings::CompositeOperator_DivideDstCompositeOp,
-            CompositeOperator::DivideSrc        => crate::bindings::CompositeOperator_DivideSrcCompositeOp,
-            CompositeOperator::DstAtop          => crate::bindings::CompositeOperator_DstAtopCompositeOp,
-            CompositeOperator::Dst              => crate::bindings::CompositeOperator_DstCompositeOp,
-            CompositeOperator::DstIn            => crate::bindings::CompositeOperator_DstInCompositeOp,
-            CompositeOperator::DstOut           => crate::bindings::CompositeOperator_DstOutCompositeOp,
-            CompositeOperator::DstOver          => crate::bindings::CompositeOperator_DstOverCompositeOp,
-            CompositeOperator::Exclusion        => crate::bindings::CompositeOperator_ExclusionCompositeOp,
-            CompositeOperator::HardLight        => crate::bindings::CompositeOperator_HardLightCompositeOp,
-            CompositeOperator::HardMix          => crate::bindings::CompositeOperator_HardMixCompositeOp,
-            CompositeOperator::Hue              => crate::bindings::CompositeOperator_HueCompositeOp,
-            CompositeOperator::In               => crate::bindings::CompositeOperator_InCompositeOp,
-            CompositeOperator::Intensity        => crate::bindings::CompositeOperator_IntensityCompositeOp,
-            CompositeOperator::Lighten          => crate::bindings::CompositeOperator_LightenCompositeOp,
-            CompositeOperator::LightenIntensity => crate::bindings::CompositeOperator_LightenIntensityCompositeOp,
-            CompositeOperator::LinearBurn       => crate::bindings::CompositeOperator_LinearBurnCompositeOp,
-            CompositeOperator::LinearDodge      => crate::bindings::CompositeOperator_LinearDodgeCompositeOp,
-            CompositeOperator::LinearLight      => crate::bindings::CompositeOperator_LinearLightCompositeOp,
-            CompositeOperator::Luminize         => crate::bindings::CompositeOperator_LuminizeCompositeOp,
-            CompositeOperator::Mathematics      => crate::bindings::CompositeOperator_MathematicsCompositeOp,
-            CompositeOperator::MinusDst         => crate::bindings::CompositeOperator_MinusDstCompositeOp,
-            CompositeOperator::MinusSrc         => crate::bindings::CompositeOperator_MinusSrcCompositeOp,
-            CompositeOperator::Modulate         => crate::bindings::CompositeOperator_ModulateCompositeOp,
-            CompositeOperator::ModulusAdd       => crate::bindings::CompositeOperator_ModulusAddCompositeOp,
-            CompositeOperator::ModulusSubtract  => crate::bindings::CompositeOperator_ModulusSubtractCompositeOp,
-            CompositeOperator::Multiply         => crate::bindings::CompositeOperator_MultiplyCompositeOp,
-            CompositeOperator::No               => crate::bindings::CompositeOperator_NoCompositeOp,
-            CompositeOperator::Out              => crate::bindings::CompositeOperator_OutCompositeOp,
-            CompositeOperator::Over             => crate::bindings::CompositeOperator_OverCompositeOp,
-            CompositeOperator::Overlay          => crate::bindings::CompositeOperator_OverlayCompositeOp,
-            CompositeOperator::PegtopLight      => crate::bindings::CompositeOperator_PegtopLightCompositeOp,
-            CompositeOperator::PinLight         => crate::bindings::CompositeOperator_PinLightCompositeOp,
-            CompositeOperator::Plus             => crate::bindings::CompositeOperator_PlusCompositeOp,
-            CompositeOperator::Replace          => crate::bindings::CompositeOperator_ReplaceCompositeOp,
-            CompositeOperator::Saturate         => crate::bindings::CompositeOperator_SaturateCompositeOp,
-            CompositeOperator::Screen           => crate::bindings::CompositeOperator_ScreenCompositeOp,
-            CompositeOperator::SoftLight        => crate::bindings::CompositeOperator_SoftLightCompositeOp,
-            CompositeOperator::SrcAtop          => crate::bindings::CompositeOperator_SrcAtopCompositeOp,
-            CompositeOperator::Src              => crate::bindings::CompositeOperator_SrcCompositeOp,
-            CompositeOperator::SrcIn            => crate::bindings::CompositeOperator_SrcInCompositeOp,
-            CompositeOperator::SrcOut           => crate::bindings::CompositeOperator_SrcOutCompositeOp,
-            CompositeOperator::SrcOver          => crate::bindings::CompositeOperator_SrcOverCompositeOp,
-            CompositeOperator::Threshold        => crate::bindings::CompositeOperator_ThresholdCompositeOp,
-            CompositeOperator::VividLight       => crate::bindings::CompositeOperator_VividLightCompositeOp,
-            CompositeOperator::Xor              => crate::bindings::CompositeOperator_XorCompositeOp,
-            CompositeOperator::Stereo           => crate::bindings::CompositeOperator_StereoCompositeOp,
-            CompositeOperator::Freeze           => crate::bindings::CompositeOperator_FreezeCompositeOp,
-            CompositeOperator::Interpolate      => crate::bindings::CompositeOperator_InterpolateCompositeOp,
-            CompositeOperator::Negate           => crate::bindings::CompositeOperator_NegateCompositeOp,
-            CompositeOperator::Reflect          => crate::bindings::CompositeOperator_ReflectCompositeOp,
-            CompositeOperator::SoftBurn         => crate::bindings::CompositeOperator_SoftBurnCompositeOp,
-            CompositeOperator::SoftDodge        => crate::bindings::CompositeOperator_SoftDodgeCompositeOp,
-            CompositeOperator::Stamp            => crate::bindings::CompositeOperator_StampCompositeOp,
-            CompositeOperator::RMSE             => crate::bindings::CompositeOperator_RMSECompositeOp,
-            CompositeOperator::SaliencyBlend    => crate::bindings::CompositeOperator_SaliencyBlendCompositeOp,
-            CompositeOperator::SeamlessBlend    => crate::bindings::CompositeOperator_SeamlessBlendCompositeOp,
-        }
-    }
-}
-
-impl From<crate::bindings::CompositeOperator> for CompositeOperator {
-    fn from(value: crate::bindings::CompositeOperator) -> Self {
-        match value {
-             crate::bindings::CompositeOperator_UndefinedCompositeOp        => CompositeOperator::Undefined,
-             crate::bindings::CompositeOperator_AlphaCompositeOp            => CompositeOperator::Alpha,
-             crate::bindings::CompositeOperator_AtopCompositeOp             => CompositeOperator::Atop,
-             crate::bindings::CompositeOperator_BlendCompositeOp            => CompositeOperator::Blend,
-             crate::bindings::CompositeOperator_BlurCompositeOp             => CompositeOperator::Blur,
-             crate::bindings::CompositeOperator_BumpmapCompositeOp          => CompositeOperator::Bumpmap,
-             crate::bindings::CompositeOperator_ChangeMaskCompositeOp       => CompositeOperator::ChangeMask,
-             crate::bindings::CompositeOperator_ClearCompositeOp            => CompositeOperator::Clear,
-             crate::bindings::CompositeOperator_ColorBurnCompositeOp        => CompositeOperator::ColorBurn,
-             crate::bindings::CompositeOperator_ColorDodgeCompositeOp       => CompositeOperator::ColorDodge,
-             crate::bindings::CompositeOperator_ColorizeCompositeOp         => CompositeOperator::Colorize,
-             crate::bindings::CompositeOperator_CopyBlackCompositeOp        => CompositeOperator::CopyBlack,
-             crate::bindings::CompositeOperator_CopyBlueCompositeOp         => CompositeOperator::CopyBlue,
-             crate::bindings::CompositeOperator_CopyCompositeOp             => CompositeOperator::Copy,
-             crate::bindings::CompositeOperator_CopyCyanCompositeOp         => CompositeOperator::CopyCyan,
-             crate::bindings::CompositeOperator_CopyGreenCompositeOp        => CompositeOperator::CopyGreen,
-             crate::bindings::CompositeOperator_CopyMagentaCompositeOp      => CompositeOperator::CopyMagenta,
-             crate::bindings::CompositeOperator_CopyAlphaCompositeOp        => CompositeOperator::CopyAlpha,
-             crate::bindings::CompositeOperator_CopyRedCompositeOp          => CompositeOperator::CopyRed,
-             crate::bindings::CompositeOperator_CopyYellowCompositeOp       => CompositeOperator::CopyYellow,
-             crate::bindings::CompositeOperator_DarkenCompositeOp           => CompositeOperator::Darken,
-             crate::bindings::CompositeOperator_DarkenIntensityCompositeOp  => CompositeOperator::DarkenIntensity,
-             crate::bindings::CompositeOperator_DifferenceCompositeOp       => CompositeOperator::Difference,
-             crate::bindings::CompositeOperator_DisplaceCompositeOp         => CompositeOperator::Displace,
-             crate::bindings::CompositeOperator_DissolveCompositeOp         => CompositeOperator::Dissolve,
-             crate::bindings::CompositeOperator_DistortCompositeOp          => CompositeOperator::Distort,
-             crate::bindings::CompositeOperator_DivideDstCompositeOp        => CompositeOperator::DivideDst,
-             crate::bindings::CompositeOperator_DivideSrcCompositeOp        => CompositeOperator::DivideSrc,
-             crate::bindings::CompositeOperator_DstAtopCompositeOp          => CompositeOperator::DstAtop,
-             crate::bindings::CompositeOperator_DstCompositeOp              => CompositeOperator::Dst,
-             crate::bindings::CompositeOperator_DstInCompositeOp            => CompositeOperator::DstIn,
-             crate::bindings::CompositeOperator_DstOutCompositeOp           => CompositeOperator::DstOut,
-             crate::bindings::CompositeOperator_DstOverCompositeOp          => CompositeOperator::DstOver,
-             crate::bindings::CompositeOperator_ExclusionCompositeOp        => CompositeOperator::Exclusion,
-             crate::bindings::CompositeOperator_HardLightCompositeOp        => CompositeOperator::HardLight,
-             crate::bindings::CompositeOperator_HardMixCompositeOp          => CompositeOperator::HardMix,
-             crate::bindings::CompositeOperator_HueCompositeOp              => CompositeOperator::Hue,
-             crate::bindings::CompositeOperator_InCompositeOp               => CompositeOperator::In,
-             crate::bindings::CompositeOperator_IntensityCompositeOp        => CompositeOperator::Intensity,
-             crate::bindings::CompositeOperator_LightenCompositeOp          => CompositeOperator::Lighten,
-             crate::bindings::CompositeOperator_LightenIntensityCompositeOp => CompositeOperator::LightenIntensity,
-             crate::bindings::CompositeOperator_LinearBurnCompositeOp       => CompositeOperator::LinearBurn,
-             crate::bindings::CompositeOperator_LinearDodgeCompositeOp      => CompositeOperator::LinearDodge,
-             crate::bindings::CompositeOperator_LinearLightCompositeOp      => CompositeOperator::LinearLight,
-             crate::bindings::CompositeOperator_LuminizeCompositeOp         => CompositeOperator::Luminize,
-             crate::bindings::CompositeOperator_MathematicsCompositeOp      => CompositeOperator::Mathematics,
-             crate::bindings::CompositeOperator_MinusDstCompositeOp         => CompositeOperator::MinusDst,
-             crate::bindings::CompositeOperator_MinusSrcCompositeOp         => CompositeOperator::MinusSrc,
-             crate::bindings::CompositeOperator_ModulateCompositeOp         => CompositeOperator::Modulate,
-             crate::bindings::CompositeOperator_ModulusAddCompositeOp       => CompositeOperator::ModulusAdd,
-             crate::bindings::CompositeOperator_ModulusSubtractCompositeOp  => CompositeOperator::ModulusSubtract,
-             crate::bindings::CompositeOperator_MultiplyCompositeOp         => CompositeOperator::Multiply,
-             crate::bindings::CompositeOperator_NoCompositeOp               => CompositeOperator::No,
-             crate::bindings::CompositeOperator_OutCompositeOp              => CompositeOperator::Out,
-             crate::bindings::CompositeOperator_OverCompositeOp             => CompositeOperator::Over,
-             crate::bindings::CompositeOperator_OverlayCompositeOp          => CompositeOperator::Overlay,
-             crate::bindings::CompositeOperator_PegtopLightCompositeOp      => CompositeOperator::PegtopLight,
-             crate::bindings::CompositeOperator_PinLightCompositeOp         => CompositeOperator::PinLight,
-             crate::bindings::CompositeOperator_PlusCompositeOp             => CompositeOperator::Plus,
-             crate::bindings::CompositeOperator_ReplaceCompositeOp          => CompositeOperator::Replace,
-             crate::bindings::CompositeOperator_SaturateCompositeOp         => CompositeOperator::Saturate,
-             crate::bindings::CompositeOperator_ScreenCompositeOp           => CompositeOperator::Screen,
-             crate::bindings::CompositeOperator_SoftLightCompositeOp        => CompositeOperator::SoftLight,
-             crate::bindings::CompositeOperator_SrcAtopCompositeOp          => CompositeOperator::SrcAtop,
-             crate::bindings::CompositeOperator_SrcCompositeOp              => CompositeOperator::Src,
-             crate::bindings::CompositeOperator_SrcInCompositeOp            => CompositeOperator::SrcIn,
-             crate::bindings::CompositeOperator_SrcOutCompositeOp           => CompositeOperator::SrcOut,
-             crate::bindings::CompositeOperator_SrcOverCompositeOp          => CompositeOperator::SrcOver,
-             crate::bindings::CompositeOperator_ThresholdCompositeOp        => CompositeOperator::Threshold,
-             crate::bindings::CompositeOperator_VividLightCompositeOp       => CompositeOperator::VividLight,
-             crate::bindings::CompositeOperator_XorCompositeOp              => CompositeOperator::Xor,
-             crate::bindings::CompositeOperator_StereoCompositeOp           => CompositeOperator::Stereo,
-             crate::bindings::CompositeOperator_FreezeCompositeOp           => CompositeOperator::Freeze,
-             crate::bindings::CompositeOperator_InterpolateCompositeOp      => CompositeOperator::Interpolate,
-             crate::bindings::CompositeOperator_NegateCompositeOp           => CompositeOperator::Negate,
-             crate::bindings::CompositeOperator_ReflectCompositeOp          => CompositeOperator::Reflect,
-             crate::bindings::CompositeOperator_SoftBurnCompositeOp         => CompositeOperator::SoftBurn,
-             crate::bindings::CompositeOperator_SoftDodgeCompositeOp        => CompositeOperator::SoftDodge,
-             crate::bindings::CompositeOperator_StampCompositeOp            => CompositeOperator::Stamp,
-             crate::bindings::CompositeOperator_RMSECompositeOp             => CompositeOperator::RMSE,
-             crate::bindings::CompositeOperator_SaliencyBlendCompositeOp    => CompositeOperator::SaliencyBlend,
-             crate::bindings::CompositeOperator_SeamlessBlendCompositeOp    => CompositeOperator::SeamlessBlend,
-             _ => CompositeOperator::default(),
-        }
-    }
-}

src/wand/magick.rs

@@ -28,7 +28,16 @@ use {size_t, ssize_t};
 
 use crate::result::Result;
 
-use super::{CompositeOperator, DrawingWand, PixelWand};
+use super::{DrawingWand, PixelWand};
+use crate::{
+    ColorspaceType,
+    CompositeOperator,
+    DitherMethod,
+    FilterType,
+    GravityType,
+    MetricType,
+    ResourceType
+};
 
 wand_common!(
     MagickWand,
@@ -42,23 +51,6 @@ wand_common!(
     MagickGetException
 );
 
-/// Resource type to use with [set_resource_limit](MagickWand::set_resource_limit)
-#[derive(Debug, Clone, Copy)]
-pub enum ResourceType {
-    Undefined = bindings::ResourceType_UndefinedResource as isize,
-    Area = bindings::ResourceType_AreaResource as isize,
-    Disk = bindings::ResourceType_DiskResource as isize,
-    File = bindings::ResourceType_FileResource as isize,
-    Height = bindings::ResourceType_HeightResource as isize,
-    Map = bindings::ResourceType_MapResource as isize,
-    Memory = bindings::ResourceType_MemoryResource as isize,
-    Thread = bindings::ResourceType_ThreadResource as isize,
-    Throttle = bindings::ResourceType_ThrottleResource as isize,
-    Time = bindings::ResourceType_TimeResource as isize,
-    Width = bindings::ResourceType_WidthResource as isize,
-    ListLength = bindings::ResourceType_ListLengthResource as isize,
-}
-
 /// MagickWand is a Rustic wrapper to the Rust bindings to ImageMagick.
 ///
 /// Instantiating a `MagickWand` will construct an ImageMagick "wand"
@@ -78,7 +70,7 @@ impl MagickWand {
     pub fn set_resource_limit(resource: ResourceType, limit: u64) -> Result<()> {
         let result = unsafe {
             bindings::SetMagickResourceLimit(
-                resource as bindings::ResourceType,
+                resource.into(),
                 limit as bindings::MagickSizeType,
             )
         };
@@ -218,11 +210,11 @@ impl MagickWand {
     pub fn compare_images(
         &self,
         reference: &MagickWand,
-        metric: bindings::MetricType,
+        metric: MetricType,
     ) -> (f64, Option<MagickWand>) {
         let mut distortion: f64 = 0.0;
         let result = unsafe {
-            bindings::MagickCompareImages(self.wand, reference.wand, metric, &mut distortion)
+            bindings::MagickCompareImages(self.wand, reference.wand, metric.into(), &mut distortion)
         };
         let wand = if result.is_null() {
             None
@@ -280,14 +272,14 @@ impl MagickWand {
         &self,
         reference: &MagickWand,
         composition_operator: CompositeOperator,
-        gravity_type: bindings::GravityType,
+        gravity_type: GravityType,
     ) -> Result<()> {
         let result = unsafe {
             bindings::MagickCompositeImageGravity(
                 self.wand,
                 reference.wand,
                 composition_operator.into(),
-                gravity_type,
+                gravity_type.into(),
             )
         };
         match result {
@@ -790,9 +782,9 @@ impl MagickWand {
 
     /// Resize the image to the specified width and height, using the
     /// specified filter type.
-    pub fn resize_image(&self, width: usize, height: usize, filter: bindings::FilterType) {
+    pub fn resize_image(&self, width: usize, height: usize, filter: FilterType) {
         unsafe {
-            bindings::MagickResizeImage(self.wand, width as size_t, height as size_t, filter);
+            bindings::MagickResizeImage(self.wand, width as size_t, height as size_t, filter.into());
         }
     }
 
@@ -833,10 +825,10 @@ impl MagickWand {
         &self,
         x_resolution: f64,
         y_resolution: f64,
-        filter: bindings::FilterType,
+        filter: FilterType,
     ) {
         unsafe {
-            bindings::MagickResampleImage(self.wand, x_resolution, y_resolution, filter);
+            bindings::MagickResampleImage(self.wand, x_resolution, y_resolution, filter.into());
         }
     }
 
@@ -1102,12 +1094,100 @@ impl MagickWand {
         }
     }
 
-    mutations!(
+    /// Set the image colorspace, transforming (unlike `set_image_colorspace`) image data in
-        /// Set the image colorspace, transforming (unlike `set_image_colorspace`) image data in
+    /// the process.
-        /// the process.
+    pub fn transform_image_colorspace(&self, colorspace: ColorspaceType) -> Result<()> {
-        MagickTransformImageColorspace => transform_image_colorspace(
+        match unsafe { bindings::MagickTransformImageColorspace(self.wand, colorspace.into()) } {
-            colorspace: bindings::ColorspaceType)
+            bindings::MagickBooleanType_MagickTrue => Ok(()),
+            _ => Err(MagickError("failed to transform image colorspace")),
+        }
+    }
 
+    /// Reduce the number of colors in the image.
+    pub fn quantize_image(
+        &self,
+        number_of_colors: size_t,
+        colorspace: ColorspaceType,
+        tree_depth: size_t,
+        dither_method: DitherMethod,
+        measure_error: bool) -> Result<()> {
+        match unsafe { bindings::MagickQuantizeImage(
+                self.wand,
+                number_of_colors,
+                colorspace.into(),
+                tree_depth,
+                dither_method.into(),
+                measure_error.to_magick()) } {
+            bindings::MagickBooleanType_MagickTrue => Ok(()),
+            _ => Err(MagickError("failed to quantize image")),
+        }
+    }
+
+    /// Reduce the number of colors in the images.
+    pub fn quantize_images(
+        &self,
+        number_of_colors: size_t,
+        colorspace: ColorspaceType,
+        tree_depth: size_t,
+        dither_method: DitherMethod,
+        measure_error: bool) -> Result<()> {
+        match unsafe { bindings::MagickQuantizeImages(
+                self.wand,
+                number_of_colors,
+                colorspace.into(),
+                tree_depth,
+                dither_method.into(),
+                measure_error.to_magick()) } {
+            bindings::MagickBooleanType_MagickTrue => Ok(()),
+            _ => Err(MagickError("failed to quantize images")),
+        }
+    }
+
+    pub fn get_colorspace(&self) -> ColorspaceType {
+        return unsafe { bindings::MagickGetColorspace(self.wand).into() };
+    }
+
+    pub fn set_colorspace(&mut self, colorspace: ColorspaceType) -> Result<()> {
+        match unsafe { bindings::MagickSetColorspace(self.wand, colorspace.into()) } {
+            bindings::MagickBooleanType_MagickTrue => Ok(()),
+            _ => Err(MagickError("failed to set colorspace")),
+        }
+    }
+
+    pub fn get_image_colorspace(&self) -> ColorspaceType {
+        return unsafe { bindings::MagickGetImageColorspace(self.wand).into() };
+    }
+
+    pub fn set_image_colorspace(&self, colorspace: ColorspaceType) -> Result<()> {
+        match unsafe { bindings::MagickSetImageColorspace(self.wand, colorspace.into()) } {
+            bindings::MagickBooleanType_MagickTrue => Ok(()),
+            _ => Err(MagickError("failed to set image colorspace")),
+        }
+    }
+
+    pub fn get_gravity(&self) -> GravityType {
+        return unsafe { bindings::MagickGetGravity(self.wand).into() };
+    }
+
+    pub fn set_gravity(&mut self, gravity: GravityType) -> Result<()> {
+        match unsafe { bindings::MagickSetGravity(self.wand, gravity.into()) } {
+            bindings::MagickBooleanType_MagickTrue => Ok(()),
+            _ => Err(MagickError("failed to set gravity")),
+        }
+    }
+
+    pub fn get_image_gravity(&self) -> GravityType {
+        return unsafe { bindings::MagickGetImageGravity(self.wand).into() };
+    }
+
+    pub fn set_image_gravity(&mut self, gravity: GravityType) -> Result<()> {
+        match unsafe { bindings::MagickSetImageGravity(self.wand, gravity.into()) } {
+            bindings::MagickBooleanType_MagickTrue => Ok(()),
+            _ => Err(MagickError("failed to set image gravity")),
+        }
+    }
+
+    mutations!(
         /// Sets the image to the specified alpha level.
         MagickSetImageAlpha => set_image_alpha(alpha: f64)
 
@@ -1121,16 +1201,6 @@ impl MagickWand {
         MagickSetImageAlphaChannel => set_image_alpha_channel(
             alpha_channel: bindings::AlphaChannelOption)
 
-        /// Reduce the number of colors in the image.
-        MagickQuantizeImage => quantize_image(
-            number_of_colors: size_t, colorspace: bindings::ColorspaceType,
-            tree_depth: size_t, dither_method: bindings::DitherMethod, measure_error: bindings::MagickBooleanType)
-
-        /// Reduce the number of colors in the image.
-        MagickQuantizeImages => quantize_images(
-            number_of_colors: size_t, colorspace: bindings::ColorspaceType,
-            tree_depth: size_t, dither_method: bindings::DitherMethod, measure_error: bindings::MagickBooleanType)
-
         /// Discard all but one of any pixel color.
         MagickUniqueImageColors => unique_image_colors()
 
@@ -1155,11 +1225,8 @@ impl MagickWand {
     );
 
     set_get!(
-        get_colorspace,                  set_colorspace,                  MagickGetColorspace,               MagickSetColorspace,              bindings::ColorspaceType
         get_compression,                 set_compression,                 MagickGetCompression,              MagickSetCompression,             bindings::CompressionType
         get_compression_quality,         set_compression_quality,         MagickGetCompressionQuality,       MagickSetCompressionQuality,      size_t
-        get_gravity,                     set_gravity,                     MagickGetGravity,                  MagickSetGravity,                 bindings::GravityType
-        get_image_colorspace,            set_image_colorspace,            MagickGetImageColorspace,          MagickSetImageColorspace,         bindings::ColorspaceType
         get_image_compression,           set_image_compression,           MagickGetImageCompression,         MagickSetImageCompression,        bindings::CompressionType
         get_image_compression_quality,   set_image_compression_quality,   MagickGetImageCompressionQuality,  MagickSetImageCompressionQuality, size_t
         get_image_delay,                 set_image_delay,                 MagickGetImageDelay,               MagickSetImageDelay,              size_t
@@ -1168,7 +1235,6 @@ impl MagickWand {
         get_image_endian,                set_image_endian,                MagickGetImageEndian,              MagickSetImageEndian,             bindings::EndianType
         get_image_fuzz,                  set_image_fuzz,                  MagickGetImageFuzz,                MagickSetImageFuzz,               f64
         get_image_gamma,                 set_image_gamma,                 MagickGetImageGamma,               MagickSetImageGamma,              f64
-        get_image_gravity,               set_image_gravity,               MagickGetImageGravity,             MagickSetImageGravity,            bindings::GravityType
         get_image_interlace_scheme,      set_image_interlace_scheme,      MagickGetImageInterlaceScheme,     MagickSetImageInterlaceScheme,    bindings::InterlaceType
         get_image_interpolate_method,    set_image_interpolate_method,    MagickGetImageInterpolateMethod,   MagickSetImageInterpolateMethod,  bindings::PixelInterpolateMethod
         get_image_iterations,            set_image_iterations,            MagickGetImageIterations,          MagickSetImageIterations,         size_t

src/wand/mod.rs

@@ -15,12 +15,10 @@
  */
 #[macro_use]
 mod macros;
-mod composite_operator;
 mod drawing;
 mod magick;
 mod pixel;
 
-pub use self::composite_operator::CompositeOperator;
 pub use self::drawing::DrawingWand;
-pub use self::magick::{MagickWand, ResourceType};
+pub use self::magick::MagickWand;
 pub use self::pixel::{PixelWand, HSL};

tests/lib.rs

@@ -23,7 +23,7 @@ use std::path::Path;
 use std::sync::Once;
 
 use magick_rust::{bindings, magick_wand_genesis, MagickWand, PixelWand};
-use magick_rust::{MagickError, ToMagick};
+use magick_rust::MagickError;
 
 // Used to make sure MagickWand is initialized exactly once. Note that we
 // do not bother shutting down, we simply exit when the tests are done.
@@ -54,7 +54,7 @@ fn test_resize_image() {
         1 => 1,
         height => height / 2,
     };
-    wand.resize_image(halfwidth, halfheight, bindings::FilterType_LanczosFilter);
+    wand.resize_image(halfwidth, halfheight, magick_rust::FilterType::Lanczos);
     assert_eq!(256, wand.get_image_width());
     assert_eq!(192, wand.get_image_height());
 }
@@ -209,7 +209,7 @@ fn test_compare_images() {
     wand2.auto_orient();
 
     let (distortion, diff) =
-        wand1.compare_images(&wand2, bindings::MetricType_RootMeanSquaredErrorMetric);
+        wand1.compare_images(&wand2, magick_rust::MetricType::RootMeanSquared);
     assert!(distortion < 0.01);
     assert!(diff.is_some());
 }
@@ -250,18 +250,18 @@ fn test_transform_image_colorspace() {
     assert!(wand.read_image("tests/data/IMG_5745.JPG").is_ok());
     assert_eq!(
         wand.get_image_colorspace(),
-        bindings::ColorspaceType_sRGBColorspace
+        magick_rust::ColorspaceType::sRGB
     );
 
     let pixel_color = wand.get_image_pixel_color(10, 10).unwrap();
     assert_ne!(pixel_color.get_hsl().hue, 0.0);
 
     assert!(wand
-        .transform_image_colorspace(bindings::ColorspaceType_GRAYColorspace)
+        .transform_image_colorspace(magick_rust::ColorspaceType::GRAY)
         .is_ok());
     assert_eq!(
         wand.get_image_colorspace(),
-        bindings::ColorspaceType_GRAYColorspace
+        magick_rust::ColorspaceType::GRAY
     );
 
     let pixel_grayscale = wand.get_image_pixel_color(10, 10).unwrap();
@@ -290,10 +290,10 @@ fn test_color_reduction() {
     assert!(wand
         .quantize_image(
             6,
-            bindings::ColorspaceType_RGBColorspace,
+            magick_rust::ColorspaceType::RGB,
             1,
-            bindings::DitherMethod_UndefinedDitherMethod,
+            magick_rust::DitherMethod::Undefined,
-            false.to_magick()
+            false
         )
         .is_ok());
     assert_eq!(6, wand.get_image_colors());
@@ -417,6 +417,48 @@ fn test_auto_gamma() {
     assert!(wand.auto_gamma().is_ok());
 }
 
+#[test]
+fn test_image_compose() {
+    START.call_once(|| {
+        magick_wand_genesis();
+    });
+    let wand = MagickWand::new();
+    wand.new_image(4, 4, &PixelWand::new()).unwrap();
+
+    let operators = [
+        magick_rust::CompositeOperator::Alpha,
+        magick_rust::CompositeOperator::MinusDst,
+        magick_rust::CompositeOperator::Over,
+        magick_rust::CompositeOperator::Xor,
+        magick_rust::CompositeOperator::Bumpmap,
+        magick_rust::CompositeOperator::ChangeMask,
+        magick_rust::CompositeOperator::Clear,
+        magick_rust::CompositeOperator::ColorBurn,
+        magick_rust::CompositeOperator::ColorDodge,
+        magick_rust::CompositeOperator::Colorize,
+        magick_rust::CompositeOperator::CopyBlack,
+        magick_rust::CompositeOperator::CopyBlue,
+        magick_rust::CompositeOperator::Copy,
+        magick_rust::CompositeOperator::CopyCyan,
+        magick_rust::CompositeOperator::CopyGreen,
+        magick_rust::CompositeOperator::CopyMagenta,
+        magick_rust::CompositeOperator::CopyAlpha,
+        magick_rust::CompositeOperator::CopyRed,
+        magick_rust::CompositeOperator::CopyYellow,
+        magick_rust::CompositeOperator::Darken,
+        magick_rust::CompositeOperator::DarkenIntensity,
+        magick_rust::CompositeOperator::Difference,
+        magick_rust::CompositeOperator::Displace,
+        magick_rust::CompositeOperator::Dissolve,
+        magick_rust::CompositeOperator::Distort,
+        magick_rust::CompositeOperator::DivideDst,
+    ];
+    for op in operators.iter() {
+        wand.set_image_compose(*op).unwrap();
+        assert_eq!(*op, wand.get_image_compose());
+    }
+}
+
 #[test]
 fn test_import_export_pixels_roundtrip() {
     START.call_once(|| {