seoxi/magick-rust
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: run cargo fmt on everything

Browse Source
This commit is contained in:
Nathan Fiedler
2024-05-25 10:50:27 -07:00
parent 320cfb6e62
commit aedcfcd8f7
42 changed files with 637 additions and 777 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/lib.rs
View File

@ -37,13 +37,13 @@ use libc::size_t;
pub use conversions::ToMagick; pub use conversions::ToMagick;
pub use result::MagickError; pub use result::MagickError;
use result::Result; use result::Result;
pub use wand::*;
pub use types::*; pub use types::*;
pub use wand::*;
mod conversions; mod conversions;
mod result; mod result;
mod wand;
mod types; mod types;
mod wand;
include!(concat!(env!("OUT_DIR"), "/bindings.rs")); include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
/// This function must be called before any other ImageMagick operations /// This function must be called before any other ImageMagick operations
@ -73,7 +73,9 @@ pub fn magick_query_fonts(pattern: &str) -> Result<Vec<String>> {
let ptr = let ptr =
unsafe { bindings::MagickQueryFonts(c_string.as_ptr(), &mut number_fonts as *mut size_t) }; unsafe { bindings::MagickQueryFonts(c_string.as_ptr(), &mut number_fonts as *mut size_t) };
if ptr.is_null() { if ptr.is_null() {
Err(MagickError("null ptr returned by magick_query_fonts".to_string())) Err(MagickError(
"null ptr returned by magick_query_fonts".to_string(),
))
} else { } else {
let mut v = Vec::new(); let mut v = Vec::new();
let c_str_ptr_slice = unsafe { ::std::slice::from_raw_parts(ptr, number_fonts as usize) }; let c_str_ptr_slice = unsafe { ::std::slice::from_raw_parts(ptr, number_fonts as usize) };

6
src/types/align_type.rs
View File

@ -4,9 +4,9 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum AlignType { pub enum AlignType {
Undefined = bindings::AlignType_UndefinedAlign, Undefined = bindings::AlignType_UndefinedAlign,
Left = bindings::AlignType_LeftAlign, Left = bindings::AlignType_LeftAlign,
Center = bindings::AlignType_CenterAlign, Center = bindings::AlignType_CenterAlign,
Right = bindings::AlignType_RightAlign, Right = bindings::AlignType_RightAlign,
} }
impl Default for AlignType { impl Default for AlignType {

32
src/types/alpha_channel_option.rs
View File

@ -3,23 +3,23 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum AlphaChannelOption { pub enum AlphaChannelOption {
Undefined = bindings::AlphaChannelOption_UndefinedAlphaChannel, Undefined = bindings::AlphaChannelOption_UndefinedAlphaChannel,
Activate = bindings::AlphaChannelOption_ActivateAlphaChannel, Activate = bindings::AlphaChannelOption_ActivateAlphaChannel,
Associate = bindings::AlphaChannelOption_AssociateAlphaChannel, Associate = bindings::AlphaChannelOption_AssociateAlphaChannel,
Background = bindings::AlphaChannelOption_BackgroundAlphaChannel, Background = bindings::AlphaChannelOption_BackgroundAlphaChannel,
Copy = bindings::AlphaChannelOption_CopyAlphaChannel, Copy = bindings::AlphaChannelOption_CopyAlphaChannel,
Deactivate = bindings::AlphaChannelOption_DeactivateAlphaChannel, Deactivate = bindings::AlphaChannelOption_DeactivateAlphaChannel,
Discrete = bindings::AlphaChannelOption_DiscreteAlphaChannel, Discrete = bindings::AlphaChannelOption_DiscreteAlphaChannel,
Disassociate = bindings::AlphaChannelOption_DisassociateAlphaChannel, Disassociate = bindings::AlphaChannelOption_DisassociateAlphaChannel,
Extract = bindings::AlphaChannelOption_ExtractAlphaChannel, Extract = bindings::AlphaChannelOption_ExtractAlphaChannel,
Off = bindings::AlphaChannelOption_OffAlphaChannel, Off = bindings::AlphaChannelOption_OffAlphaChannel,
On = bindings::AlphaChannelOption_OnAlphaChannel, On = bindings::AlphaChannelOption_OnAlphaChannel,
Opaque = bindings::AlphaChannelOption_OpaqueAlphaChannel, Opaque = bindings::AlphaChannelOption_OpaqueAlphaChannel,
Remove = bindings::AlphaChannelOption_RemoveAlphaChannel, Remove = bindings::AlphaChannelOption_RemoveAlphaChannel,
Set = bindings::AlphaChannelOption_SetAlphaChannel, Set = bindings::AlphaChannelOption_SetAlphaChannel,
Shape = bindings::AlphaChannelOption_ShapeAlphaChannel, Shape = bindings::AlphaChannelOption_ShapeAlphaChannel,
Transparent = bindings::AlphaChannelOption_TransparentAlphaChannel, Transparent = bindings::AlphaChannelOption_TransparentAlphaChannel,
OffIfOpaque = bindings::AlphaChannelOption_OffIfOpaqueAlphaChannel, OffIfOpaque = bindings::AlphaChannelOption_OffIfOpaqueAlphaChannel,
} }
impl Default for AlphaChannelOption { impl Default for AlphaChannelOption {

6
src/types/auto_threshold_method.rs
View File

@ -4,9 +4,9 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum AutoThresholdMethod { pub enum AutoThresholdMethod {
Undefined = bindings::AutoThresholdMethod_UndefinedThresholdMethod, Undefined = bindings::AutoThresholdMethod_UndefinedThresholdMethod,
Kapur = bindings::AutoThresholdMethod_KapurThresholdMethod, Kapur = bindings::AutoThresholdMethod_KapurThresholdMethod,
OTSU = bindings::AutoThresholdMethod_OTSUThresholdMethod, OTSU = bindings::AutoThresholdMethod_OTSUThresholdMethod,
Triangle = bindings::AutoThresholdMethod_TriangleThresholdMethod, Triangle = bindings::AutoThresholdMethod_TriangleThresholdMethod,
} }
impl Default for AutoThresholdMethod { impl Default for AutoThresholdMethod {

84
src/types/channel_type.rs
View File

@ -39,32 +39,32 @@ impl Default for ChannelType {
impl From<ChannelType> for bindings::ChannelType { impl From<ChannelType> for bindings::ChannelType {
fn from(value: ChannelType) -> Self { fn from(value: ChannelType) -> Self {
match value { match value {
ChannelType::Undefined => { bindings::ChannelType_UndefinedChannel }, ChannelType::Undefined => bindings::ChannelType_UndefinedChannel,
ChannelType::RedChannel => { bindings::ChannelType_RedChannel }, ChannelType::RedChannel => bindings::ChannelType_RedChannel,
ChannelType::GrayChannel => { bindings::ChannelType_GrayChannel }, ChannelType::GrayChannel => bindings::ChannelType_GrayChannel,
ChannelType::CyanChannel => { bindings::ChannelType_CyanChannel }, ChannelType::CyanChannel => bindings::ChannelType_CyanChannel,
ChannelType::LChannel => { bindings::ChannelType_LChannel }, ChannelType::LChannel => bindings::ChannelType_LChannel,
ChannelType::GreenChannel => { bindings::ChannelType_GreenChannel }, ChannelType::GreenChannel => bindings::ChannelType_GreenChannel,
ChannelType::MagentaChannel => { bindings::ChannelType_MagentaChannel }, ChannelType::MagentaChannel => bindings::ChannelType_MagentaChannel,
ChannelType::aChannel => { bindings::ChannelType_aChannel }, ChannelType::aChannel => bindings::ChannelType_aChannel,
ChannelType::BlueChannel => { bindings::ChannelType_BlueChannel }, ChannelType::BlueChannel => bindings::ChannelType_BlueChannel,
ChannelType::bChannel => { bindings::ChannelType_bChannel }, ChannelType::bChannel => bindings::ChannelType_bChannel,
ChannelType::YellowChannel => { bindings::ChannelType_YellowChannel }, ChannelType::YellowChannel => bindings::ChannelType_YellowChannel,
ChannelType::BlackChannel => { bindings::ChannelType_BlackChannel }, ChannelType::BlackChannel => bindings::ChannelType_BlackChannel,
ChannelType::AlphaChannel => { bindings::ChannelType_AlphaChannel }, ChannelType::AlphaChannel => bindings::ChannelType_AlphaChannel,
ChannelType::OpacityChannel => { bindings::ChannelType_OpacityChannel }, ChannelType::OpacityChannel => bindings::ChannelType_OpacityChannel,
ChannelType::IndexChannel => { bindings::ChannelType_IndexChannel }, ChannelType::IndexChannel => bindings::ChannelType_IndexChannel,
ChannelType::ReadMaskChannel => { bindings::ChannelType_ReadMaskChannel }, ChannelType::ReadMaskChannel => bindings::ChannelType_ReadMaskChannel,
ChannelType::WriteMaskChannel => { bindings::ChannelType_WriteMaskChannel }, ChannelType::WriteMaskChannel => bindings::ChannelType_WriteMaskChannel,
ChannelType::MetaChannel => { bindings::ChannelType_MetaChannel }, ChannelType::MetaChannel => bindings::ChannelType_MetaChannel,
ChannelType::CompositeMaskChannel => { bindings::ChannelType_CompositeMaskChannel }, ChannelType::CompositeMaskChannel => bindings::ChannelType_CompositeMaskChannel,
ChannelType::CompositeChannels => { bindings::ChannelType_CompositeChannels }, ChannelType::CompositeChannels => bindings::ChannelType_CompositeChannels,
ChannelType::AllChannels => { bindings::ChannelType_AllChannels }, ChannelType::AllChannels => bindings::ChannelType_AllChannels,
ChannelType::TrueAlphaChannel => { bindings::ChannelType_TrueAlphaChannel }, ChannelType::TrueAlphaChannel => bindings::ChannelType_TrueAlphaChannel,
ChannelType::RGBChannels => { bindings::ChannelType_RGBChannels }, ChannelType::RGBChannels => bindings::ChannelType_RGBChannels,
ChannelType::GrayChannels => { bindings::ChannelType_GrayChannels }, ChannelType::GrayChannels => bindings::ChannelType_GrayChannels,
ChannelType::SyncChannels => { bindings::ChannelType_SyncChannels }, ChannelType::SyncChannels => bindings::ChannelType_SyncChannels,
ChannelType::DefaultChannels => { bindings::ChannelType_DefaultChannels }, ChannelType::DefaultChannels => bindings::ChannelType_DefaultChannels,
} }
} }
} }
@ -73,33 +73,33 @@ impl From<bindings::ChannelType> for ChannelType {
fn from(value: bindings::ChannelType) -> Self { fn from(value: bindings::ChannelType) -> Self {
// Unreachable match arms commented out // Unreachable match arms commented out
match value { match value {
bindings::ChannelType_UndefinedChannel => { ChannelType::Undefined }, bindings::ChannelType_UndefinedChannel => ChannelType::Undefined,
bindings::ChannelType_RedChannel => { ChannelType::RedChannel }, bindings::ChannelType_RedChannel => ChannelType::RedChannel,
// bindings::ChannelType_GrayChannel => { ChannelType::GrayChannel }, // bindings::ChannelType_GrayChannel => { ChannelType::GrayChannel },
// bindings::ChannelType_CyanChannel => { ChannelType::CyanChannel }, // bindings::ChannelType_CyanChannel => { ChannelType::CyanChannel },
// bindings::ChannelType_LChannel => { ChannelType::LChannel }, // bindings::ChannelType_LChannel => { ChannelType::LChannel },
bindings::ChannelType_GreenChannel => { ChannelType::GreenChannel }, bindings::ChannelType_GreenChannel => ChannelType::GreenChannel,
// bindings::ChannelType_MagentaChannel => { ChannelType::MagentaChannel }, // bindings::ChannelType_MagentaChannel => { ChannelType::MagentaChannel },
// bindings::ChannelType_aChannel => { ChannelType::aChannel }, // bindings::ChannelType_aChannel => { ChannelType::aChannel },
bindings::ChannelType_BlueChannel => { ChannelType::BlueChannel }, bindings::ChannelType_BlueChannel => ChannelType::BlueChannel,
// bindings::ChannelType_bChannel => { ChannelType::bChannel }, // bindings::ChannelType_bChannel => { ChannelType::bChannel },
// bindings::ChannelType_YellowChannel => { ChannelType::YellowChannel }, // bindings::ChannelType_YellowChannel => { ChannelType::YellowChannel },
bindings::ChannelType_BlackChannel => { ChannelType::BlackChannel }, bindings::ChannelType_BlackChannel => ChannelType::BlackChannel,
bindings::ChannelType_AlphaChannel => { ChannelType::AlphaChannel }, bindings::ChannelType_AlphaChannel => ChannelType::AlphaChannel,
// bindings::ChannelType_OpacityChannel => { ChannelType::OpacityChannel }, // bindings::ChannelType_OpacityChannel => { ChannelType::OpacityChannel },
bindings::ChannelType_IndexChannel => { ChannelType::IndexChannel }, bindings::ChannelType_IndexChannel => ChannelType::IndexChannel,
bindings::ChannelType_ReadMaskChannel => { ChannelType::ReadMaskChannel }, bindings::ChannelType_ReadMaskChannel => ChannelType::ReadMaskChannel,
bindings::ChannelType_WriteMaskChannel => { ChannelType::WriteMaskChannel }, bindings::ChannelType_WriteMaskChannel => ChannelType::WriteMaskChannel,
bindings::ChannelType_MetaChannel => { ChannelType::MetaChannel }, bindings::ChannelType_MetaChannel => ChannelType::MetaChannel,
bindings::ChannelType_CompositeMaskChannel => { ChannelType::CompositeMaskChannel }, bindings::ChannelType_CompositeMaskChannel => ChannelType::CompositeMaskChannel,
bindings::ChannelType_CompositeChannels => { ChannelType::CompositeChannels }, bindings::ChannelType_CompositeChannels => ChannelType::CompositeChannels,
bindings::ChannelType_AllChannels => { ChannelType::AllChannels }, bindings::ChannelType_AllChannels => ChannelType::AllChannels,
// bindings::ChannelType_TrueAlphaChannel => { ChannelType::TrueAlphaChannel }, // bindings::ChannelType_TrueAlphaChannel => { ChannelType::TrueAlphaChannel },
// bindings::ChannelType_RGBChannels => { ChannelType::RGBChannels }, // bindings::ChannelType_RGBChannels => { ChannelType::RGBChannels },
bindings::ChannelType_GrayChannels => { ChannelType::GrayChannels }, bindings::ChannelType_GrayChannels => ChannelType::GrayChannels,
bindings::ChannelType_SyncChannels => { ChannelType::SyncChannels }, bindings::ChannelType_SyncChannels => ChannelType::SyncChannels,
// bindings::ChannelType_DefaultChannels => { ChannelType::DefaultChannels }, // bindings::ChannelType_DefaultChannels => { ChannelType::DefaultChannels },
_ => { ChannelType::Undefined }, _ => ChannelType::Undefined,
} }
} }
} }

6
src/types/clip_path_units.rs
View File

@ -3,9 +3,9 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum ClipPathUnits { pub enum ClipPathUnits {
Undefined = bindings::ClipPathUnits_UndefinedPathUnits, Undefined = bindings::ClipPathUnits_UndefinedPathUnits,
UserSpace = bindings::ClipPathUnits_UserSpace, UserSpace = bindings::ClipPathUnits_UserSpace,
UserSpaceOnUse = bindings::ClipPathUnits_UserSpaceOnUse, UserSpaceOnUse = bindings::ClipPathUnits_UserSpaceOnUse,
ObjectBoundingBox = bindings::ClipPathUnits_ObjectBoundingBox, ObjectBoundingBox = bindings::ClipPathUnits_ObjectBoundingBox,
} }

74
src/types/colorspace_type.rs
View File

@ -3,46 +3,46 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum ColorspaceType { pub enum ColorspaceType {
Undefined = bindings::ColorspaceType_UndefinedColorspace, Undefined = bindings::ColorspaceType_UndefinedColorspace,
CMY = bindings::ColorspaceType_CMYColorspace, CMY = bindings::ColorspaceType_CMYColorspace,
CMYK = bindings::ColorspaceType_CMYKColorspace, CMYK = bindings::ColorspaceType_CMYKColorspace,
GRAY = bindings::ColorspaceType_GRAYColorspace, GRAY = bindings::ColorspaceType_GRAYColorspace,
HCL = bindings::ColorspaceType_HCLColorspace, HCL = bindings::ColorspaceType_HCLColorspace,
HCLp = bindings::ColorspaceType_HCLpColorspace, HCLp = bindings::ColorspaceType_HCLpColorspace,
HSB = bindings::ColorspaceType_HSBColorspace, HSB = bindings::ColorspaceType_HSBColorspace,
HSI = bindings::ColorspaceType_HSIColorspace, HSI = bindings::ColorspaceType_HSIColorspace,
HSL = bindings::ColorspaceType_HSLColorspace, HSL = bindings::ColorspaceType_HSLColorspace,
HSV = bindings::ColorspaceType_HSVColorspace, HSV = bindings::ColorspaceType_HSVColorspace,
HWB = bindings::ColorspaceType_HWBColorspace, HWB = bindings::ColorspaceType_HWBColorspace,
Lab = bindings::ColorspaceType_LabColorspace, Lab = bindings::ColorspaceType_LabColorspace,
LCH = bindings::ColorspaceType_LCHColorspace, LCH = bindings::ColorspaceType_LCHColorspace,
LCHab = bindings::ColorspaceType_LCHabColorspace, LCHab = bindings::ColorspaceType_LCHabColorspace,
LCHuv = bindings::ColorspaceType_LCHuvColorspace, LCHuv = bindings::ColorspaceType_LCHuvColorspace,
Log = bindings::ColorspaceType_LogColorspace, Log = bindings::ColorspaceType_LogColorspace,
LMS = bindings::ColorspaceType_LMSColorspace, LMS = bindings::ColorspaceType_LMSColorspace,
Luv = bindings::ColorspaceType_LuvColorspace, Luv = bindings::ColorspaceType_LuvColorspace,
OHTA = bindings::ColorspaceType_OHTAColorspace, OHTA = bindings::ColorspaceType_OHTAColorspace,
Rec601YCbCr = bindings::ColorspaceType_Rec601YCbCrColorspace, Rec601YCbCr = bindings::ColorspaceType_Rec601YCbCrColorspace,
Rec709YCbCr = bindings::ColorspaceType_Rec709YCbCrColorspace, Rec709YCbCr = bindings::ColorspaceType_Rec709YCbCrColorspace,
RGB = bindings::ColorspaceType_RGBColorspace, RGB = bindings::ColorspaceType_RGBColorspace,
scRGB = bindings::ColorspaceType_scRGBColorspace, scRGB = bindings::ColorspaceType_scRGBColorspace,
sRGB = bindings::ColorspaceType_sRGBColorspace, sRGB = bindings::ColorspaceType_sRGBColorspace,
Transparent = bindings::ColorspaceType_TransparentColorspace, Transparent = bindings::ColorspaceType_TransparentColorspace,
xyY = bindings::ColorspaceType_xyYColorspace, xyY = bindings::ColorspaceType_xyYColorspace,
XYZ = bindings::ColorspaceType_XYZColorspace, XYZ = bindings::ColorspaceType_XYZColorspace,
YCbCr = bindings::ColorspaceType_YCbCrColorspace, YCbCr = bindings::ColorspaceType_YCbCrColorspace,
YCC = bindings::ColorspaceType_YCCColorspace, YCC = bindings::ColorspaceType_YCCColorspace,
YDbDr = bindings::ColorspaceType_YDbDrColorspace, YDbDr = bindings::ColorspaceType_YDbDrColorspace,
YIQ = bindings::ColorspaceType_YIQColorspace, YIQ = bindings::ColorspaceType_YIQColorspace,
YPbPr = bindings::ColorspaceType_YPbPrColorspace, YPbPr = bindings::ColorspaceType_YPbPrColorspace,
YUV = bindings::ColorspaceType_YUVColorspace, YUV = bindings::ColorspaceType_YUVColorspace,
LinearGRAY = bindings::ColorspaceType_LinearGRAYColorspace, LinearGRAY = bindings::ColorspaceType_LinearGRAYColorspace,
Jzazbz = bindings::ColorspaceType_JzazbzColorspace, Jzazbz = bindings::ColorspaceType_JzazbzColorspace,
DisplayP3 = bindings::ColorspaceType_DisplayP3Colorspace, DisplayP3 = bindings::ColorspaceType_DisplayP3Colorspace,
Adobe98 = bindings::ColorspaceType_Adobe98Colorspace, Adobe98 = bindings::ColorspaceType_Adobe98Colorspace,
ProPhoto = bindings::ColorspaceType_ProPhotoColorspace, ProPhoto = bindings::ColorspaceType_ProPhotoColorspace,
Oklab = bindings::ColorspaceType_OklabColorspace, Oklab = bindings::ColorspaceType_OklabColorspace,
Oklch = bindings::ColorspaceType_OklchColorspace, Oklch = bindings::ColorspaceType_OklchColorspace,
} }
impl Default for ColorspaceType { impl Default for ColorspaceType {

162
src/types/composite_operator.rs
View File

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

56
src/types/compression_type.rs
View File

@ -3,35 +3,35 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum CompressionType { pub enum CompressionType {
Undefined = bindings::CompressionType_UndefinedCompression, Undefined = bindings::CompressionType_UndefinedCompression,
B44A = bindings::CompressionType_B44ACompression, B44A = bindings::CompressionType_B44ACompression,
B44 = bindings::CompressionType_B44Compression, B44 = bindings::CompressionType_B44Compression,
BZip = bindings::CompressionType_BZipCompression, BZip = bindings::CompressionType_BZipCompression,
DXT1 = bindings::CompressionType_DXT1Compression, DXT1 = bindings::CompressionType_DXT1Compression,
DXT3 = bindings::CompressionType_DXT3Compression, DXT3 = bindings::CompressionType_DXT3Compression,
DXT5 = bindings::CompressionType_DXT5Compression, DXT5 = bindings::CompressionType_DXT5Compression,
Fax = bindings::CompressionType_FaxCompression, Fax = bindings::CompressionType_FaxCompression,
Group4 = bindings::CompressionType_Group4Compression, Group4 = bindings::CompressionType_Group4Compression,
JBIG1 = bindings::CompressionType_JBIG1Compression, JBIG1 = bindings::CompressionType_JBIG1Compression,
JBIG2 = bindings::CompressionType_JBIG2Compression, JBIG2 = bindings::CompressionType_JBIG2Compression,
JPEG2000 = bindings::CompressionType_JPEG2000Compression, JPEG2000 = bindings::CompressionType_JPEG2000Compression,
JPEG = bindings::CompressionType_JPEGCompression, JPEG = bindings::CompressionType_JPEGCompression,
LosslessJPEG = bindings::CompressionType_LosslessJPEGCompression, LosslessJPEG = bindings::CompressionType_LosslessJPEGCompression,
LZMA = bindings::CompressionType_LZMACompression, LZMA = bindings::CompressionType_LZMACompression,
LZW = bindings::CompressionType_LZWCompression, LZW = bindings::CompressionType_LZWCompression,
No = bindings::CompressionType_NoCompression, No = bindings::CompressionType_NoCompression,
Piz = bindings::CompressionType_PizCompression, Piz = bindings::CompressionType_PizCompression,
Pxr24 = bindings::CompressionType_Pxr24Compression, Pxr24 = bindings::CompressionType_Pxr24Compression,
RLE = bindings::CompressionType_RLECompression, RLE = bindings::CompressionType_RLECompression,
Zip = bindings::CompressionType_ZipCompression, Zip = bindings::CompressionType_ZipCompression,
ZipS = bindings::CompressionType_ZipSCompression, ZipS = bindings::CompressionType_ZipSCompression,
Zstd = bindings::CompressionType_ZstdCompression, Zstd = bindings::CompressionType_ZstdCompression,
WebP = bindings::CompressionType_WebPCompression, WebP = bindings::CompressionType_WebPCompression,
DWAA = bindings::CompressionType_DWAACompression, DWAA = bindings::CompressionType_DWAACompression,
DWAB = bindings::CompressionType_DWABCompression, DWAB = bindings::CompressionType_DWABCompression,
BC7 = bindings::CompressionType_BC7Compression, BC7 = bindings::CompressionType_BC7Compression,
BC5 = bindings::CompressionType_BC5Compression, BC5 = bindings::CompressionType_BC5Compression,
LERC = bindings::CompressionType_LERCCompression, LERC = bindings::CompressionType_LERCCompression,
} }
impl Default for CompressionType { impl Default for CompressionType {

8
src/types/decoration_type.rs
View File

@ -3,10 +3,10 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum DecorationType { pub enum DecorationType {
Undefined = bindings::DecorationType_UndefinedDecoration, Undefined = bindings::DecorationType_UndefinedDecoration,
No = bindings::DecorationType_NoDecoration, No = bindings::DecorationType_NoDecoration,
Underline = bindings::DecorationType_UnderlineDecoration, Underline = bindings::DecorationType_UnderlineDecoration,
Overline = bindings::DecorationType_OverlineDecoration, Overline = bindings::DecorationType_OverlineDecoration,
LineThrough = bindings::DecorationType_LineThroughDecoration, LineThrough = bindings::DecorationType_LineThroughDecoration,
} }

2
src/types/direction_type.rs
View File

@ -3,7 +3,7 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum DirectionType { pub enum DirectionType {
Undefined = bindings::DirectionType_UndefinedDirection, Undefined = bindings::DirectionType_UndefinedDirection,
RightToLeft = bindings::DirectionType_RightToLeftDirection, RightToLeft = bindings::DirectionType_RightToLeftDirection,
LeftToRight = bindings::DirectionType_LeftToRightDirection, LeftToRight = bindings::DirectionType_LeftToRightDirection,
TopToBottom = bindings::DirectionType_TopToBottomDirection, TopToBottom = bindings::DirectionType_TopToBottomDirection,

8
src/types/dispose_type.rs
View File

@ -7,10 +7,10 @@ pub enum DisposeType {
* Identical to `Undefined` * Identical to `Undefined`
*/ */
// Unrecognized = bindings::DisposeType_UnrecognizedDispose, // Unrecognized = bindings::DisposeType_UnrecognizedDispose,
Undefined = bindings::DisposeType_UndefinedDispose, Undefined = bindings::DisposeType_UndefinedDispose,
None = bindings::DisposeType_NoneDispose, None = bindings::DisposeType_NoneDispose,
Background = bindings::DisposeType_BackgroundDispose, Background = bindings::DisposeType_BackgroundDispose,
Previous = bindings::DisposeType_PreviousDispose, Previous = bindings::DisposeType_PreviousDispose,
} }
impl Default for DisposeType { impl Default for DisposeType {

6
src/types/dither_method.rs
View File

@ -3,9 +3,9 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum DitherMethod { pub enum DitherMethod {
Undefined = bindings::DitherMethod_UndefinedDitherMethod, Undefined = bindings::DitherMethod_UndefinedDitherMethod,
No = bindings::DitherMethod_NoDitherMethod, No = bindings::DitherMethod_NoDitherMethod,
Riemersma = bindings::DitherMethod_RiemersmaDitherMethod, Riemersma = bindings::DitherMethod_RiemersmaDitherMethod,
FloydSteinberg = bindings::DitherMethod_FloydSteinbergDitherMethod, FloydSteinberg = bindings::DitherMethod_FloydSteinbergDitherMethod,
} }

4
src/types/endian_type.rs
View File

@ -4,8 +4,8 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum EndianType { pub enum EndianType {
Undefined = bindings::EndianType_UndefinedEndian, Undefined = bindings::EndianType_UndefinedEndian,
LSB = bindings::EndianType_LSBEndian, LSB = bindings::EndianType_LSBEndian,
MSB = bindings::EndianType_MSBEndian, MSB = bindings::EndianType_MSBEndian,
} }
impl Default for EndianType { impl Default for EndianType {

4
src/types/fill_rule.rs
View File

@ -4,8 +4,8 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum FillRule { pub enum FillRule {
Undefined = bindings::FillRule_UndefinedRule, Undefined = bindings::FillRule_UndefinedRule,
EvenOdd = bindings::FillRule_EvenOddRule, EvenOdd = bindings::FillRule_EvenOddRule,
NonZero = bindings::FillRule_NonZeroRule, NonZero = bindings::FillRule_NonZeroRule,
} }
impl Default for FillRule { impl Default for FillRule {

60
src/types/filter_type.rs
View File

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

10
src/types/gravity_type.rs
View File

@ -9,13 +9,13 @@ pub enum GravityType {
*/ */
// Forget = bindings::GravityType_ForgetGravity, // Forget = bindings::GravityType_ForgetGravity,
NorthWest = bindings::GravityType_NorthWestGravity, NorthWest = bindings::GravityType_NorthWestGravity,
North = bindings::GravityType_NorthGravity, North = bindings::GravityType_NorthGravity,
NorthEast = bindings::GravityType_NorthEastGravity, NorthEast = bindings::GravityType_NorthEastGravity,
West = bindings::GravityType_WestGravity, West = bindings::GravityType_WestGravity,
Center = bindings::GravityType_CenterGravity, Center = bindings::GravityType_CenterGravity,
East = bindings::GravityType_EastGravity, East = bindings::GravityType_EastGravity,
SouthWest = bindings::GravityType_SouthWestGravity, SouthWest = bindings::GravityType_SouthWestGravity,
South = bindings::GravityType_SouthGravity, South = bindings::GravityType_SouthGravity,
SouthEast = bindings::GravityType_SouthEastGravity, SouthEast = bindings::GravityType_SouthEastGravity,
} }

2
src/types/image.rs
View File

@ -11,7 +11,7 @@ impl Image<'_> {
pub unsafe fn new(img: *mut bindings::Image) -> Self { pub unsafe fn new(img: *mut bindings::Image) -> Self {
Image { Image {
image: img, image: img,
phantom_data: PhantomData phantom_data: PhantomData,
} }
} }

22
src/types/image_type.rs
View File

@ -3,18 +3,18 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum ImageType { pub enum ImageType {
Undefined = bindings::ImageType_UndefinedType, Undefined = bindings::ImageType_UndefinedType,
Bilevel = bindings::ImageType_BilevelType, Bilevel = bindings::ImageType_BilevelType,
Grayscale = bindings::ImageType_GrayscaleType, Grayscale = bindings::ImageType_GrayscaleType,
GrayscaleAlpha = bindings::ImageType_GrayscaleAlphaType, GrayscaleAlpha = bindings::ImageType_GrayscaleAlphaType,
Palette = bindings::ImageType_PaletteType, Palette = bindings::ImageType_PaletteType,
PaletteAlpha = bindings::ImageType_PaletteAlphaType, PaletteAlpha = bindings::ImageType_PaletteAlphaType,
TrueColor = bindings::ImageType_TrueColorType, TrueColor = bindings::ImageType_TrueColorType,
TrueColorAlpha = bindings::ImageType_TrueColorAlphaType, TrueColorAlpha = bindings::ImageType_TrueColorAlphaType,
ColorSeparation = bindings::ImageType_ColorSeparationType, ColorSeparation = bindings::ImageType_ColorSeparationType,
ColorSeparationAlpha = bindings::ImageType_ColorSeparationAlphaType, ColorSeparationAlpha = bindings::ImageType_ColorSeparationAlphaType,
Optimize = bindings::ImageType_OptimizeType, Optimize = bindings::ImageType_OptimizeType,
PaletteBilevelAlpha = bindings::ImageType_PaletteBilevelAlphaType, PaletteBilevelAlpha = bindings::ImageType_PaletteBilevelAlphaType,
} }
impl Default for ImageType { impl Default for ImageType {

12
src/types/interlace_type.rs
View File

@ -4,13 +4,13 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum InterlaceType { pub enum InterlaceType {
Undefined = bindings::InterlaceType_UndefinedInterlace, Undefined = bindings::InterlaceType_UndefinedInterlace,
No = bindings::InterlaceType_NoInterlace, No = bindings::InterlaceType_NoInterlace,
Line = bindings::InterlaceType_LineInterlace, Line = bindings::InterlaceType_LineInterlace,
Plane = bindings::InterlaceType_PlaneInterlace, Plane = bindings::InterlaceType_PlaneInterlace,
Partition = bindings::InterlaceType_PartitionInterlace, Partition = bindings::InterlaceType_PartitionInterlace,
GIF = bindings::InterlaceType_GIFInterlace, GIF = bindings::InterlaceType_GIFInterlace,
JPEG = bindings::InterlaceType_JPEGInterlace, JPEG = bindings::InterlaceType_JPEGInterlace,
PNG = bindings::InterlaceType_PNGInterlace, PNG = bindings::InterlaceType_PNGInterlace,
} }
impl Default for InterlaceType { impl Default for InterlaceType {

206
src/types/kernel.rs
View File

@ -1,49 +1,49 @@
use std::ffi::CString; use std::ffi::CString;
use crate::bindings; use crate::bindings;
use crate::{Result, MagickError}; use crate::{MagickError, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum KernelInfoType { pub enum KernelInfoType {
Undefined = bindings::KernelInfoType_UndefinedKernel, Undefined = bindings::KernelInfoType_UndefinedKernel,
Unity = bindings::KernelInfoType_UnityKernel, Unity = bindings::KernelInfoType_UnityKernel,
Gaussian = bindings::KernelInfoType_GaussianKernel, Gaussian = bindings::KernelInfoType_GaussianKernel,
DoG = bindings::KernelInfoType_DoGKernel, DoG = bindings::KernelInfoType_DoGKernel,
LoG = bindings::KernelInfoType_LoGKernel, LoG = bindings::KernelInfoType_LoGKernel,
Blur = bindings::KernelInfoType_BlurKernel, Blur = bindings::KernelInfoType_BlurKernel,
Comet = bindings::KernelInfoType_CometKernel, Comet = bindings::KernelInfoType_CometKernel,
Binomial = bindings::KernelInfoType_BinomialKernel, Binomial = bindings::KernelInfoType_BinomialKernel,
Laplacian = bindings::KernelInfoType_LaplacianKernel, Laplacian = bindings::KernelInfoType_LaplacianKernel,
Sobel = bindings::KernelInfoType_SobelKernel, Sobel = bindings::KernelInfoType_SobelKernel,
FreiChen = bindings::KernelInfoType_FreiChenKernel, FreiChen = bindings::KernelInfoType_FreiChenKernel,
Roberts = bindings::KernelInfoType_RobertsKernel, Roberts = bindings::KernelInfoType_RobertsKernel,
Prewitt = bindings::KernelInfoType_PrewittKernel, Prewitt = bindings::KernelInfoType_PrewittKernel,
Compass = bindings::KernelInfoType_CompassKernel, Compass = bindings::KernelInfoType_CompassKernel,
Kirsch = bindings::KernelInfoType_KirschKernel, Kirsch = bindings::KernelInfoType_KirschKernel,
Diamond = bindings::KernelInfoType_DiamondKernel, Diamond = bindings::KernelInfoType_DiamondKernel,
Square = bindings::KernelInfoType_SquareKernel, Square = bindings::KernelInfoType_SquareKernel,
Rectangle = bindings::KernelInfoType_RectangleKernel, Rectangle = bindings::KernelInfoType_RectangleKernel,
Octagon = bindings::KernelInfoType_OctagonKernel, Octagon = bindings::KernelInfoType_OctagonKernel,
Disk = bindings::KernelInfoType_DiskKernel, Disk = bindings::KernelInfoType_DiskKernel,
Plus = bindings::KernelInfoType_PlusKernel, Plus = bindings::KernelInfoType_PlusKernel,
Cross = bindings::KernelInfoType_CrossKernel, Cross = bindings::KernelInfoType_CrossKernel,
Ring = bindings::KernelInfoType_RingKernel, Ring = bindings::KernelInfoType_RingKernel,
Peaks = bindings::KernelInfoType_PeaksKernel, Peaks = bindings::KernelInfoType_PeaksKernel,
Edges = bindings::KernelInfoType_EdgesKernel, Edges = bindings::KernelInfoType_EdgesKernel,
Corners = bindings::KernelInfoType_CornersKernel, Corners = bindings::KernelInfoType_CornersKernel,
Diagonals = bindings::KernelInfoType_DiagonalsKernel, Diagonals = bindings::KernelInfoType_DiagonalsKernel,
LineEnds = bindings::KernelInfoType_LineEndsKernel, LineEnds = bindings::KernelInfoType_LineEndsKernel,
LineJunctions = bindings::KernelInfoType_LineJunctionsKernel, LineJunctions = bindings::KernelInfoType_LineJunctionsKernel,
Ridges = bindings::KernelInfoType_RidgesKernel, Ridges = bindings::KernelInfoType_RidgesKernel,
ConvexHull = bindings::KernelInfoType_ConvexHullKernel, ConvexHull = bindings::KernelInfoType_ConvexHullKernel,
ThinSE = bindings::KernelInfoType_ThinSEKernel, ThinSE = bindings::KernelInfoType_ThinSEKernel,
Skeleton = bindings::KernelInfoType_SkeletonKernel, Skeleton = bindings::KernelInfoType_SkeletonKernel,
Chebyshev = bindings::KernelInfoType_ChebyshevKernel, Chebyshev = bindings::KernelInfoType_ChebyshevKernel,
Manhattan = bindings::KernelInfoType_ManhattanKernel, Manhattan = bindings::KernelInfoType_ManhattanKernel,
Octagonal = bindings::KernelInfoType_OctagonalKernel, Octagonal = bindings::KernelInfoType_OctagonalKernel,
Euclidean = bindings::KernelInfoType_EuclideanKernel, Euclidean = bindings::KernelInfoType_EuclideanKernel,
UserDefined = bindings::KernelInfoType_UserDefinedKernel, UserDefined = bindings::KernelInfoType_UserDefinedKernel,
} }
impl Default for KernelInfoType { impl Default for KernelInfoType {
@ -58,35 +58,32 @@ impl From<KernelInfoType> for bindings::KernelInfoType {
} }
} }
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum MorphologyMethod { pub enum MorphologyMethod {
Undefined = bindings::MorphologyMethod_UndefinedMorphology, Undefined = bindings::MorphologyMethod_UndefinedMorphology,
Convolve = bindings::MorphologyMethod_ConvolveMorphology, Convolve = bindings::MorphologyMethod_ConvolveMorphology,
Correlate = bindings::MorphologyMethod_CorrelateMorphology, Correlate = bindings::MorphologyMethod_CorrelateMorphology,
Erode = bindings::MorphologyMethod_ErodeMorphology, Erode = bindings::MorphologyMethod_ErodeMorphology,
Dilate = bindings::MorphologyMethod_DilateMorphology, Dilate = bindings::MorphologyMethod_DilateMorphology,
ErodeIntensity = bindings::MorphologyMethod_ErodeIntensityMorphology, ErodeIntensity = bindings::MorphologyMethod_ErodeIntensityMorphology,
DilateIntensity = bindings::MorphologyMethod_DilateIntensityMorphology, DilateIntensity = bindings::MorphologyMethod_DilateIntensityMorphology,
IterativeDistance = bindings::MorphologyMethod_IterativeDistanceMorphology, IterativeDistance = bindings::MorphologyMethod_IterativeDistanceMorphology,
Open = bindings::MorphologyMethod_OpenMorphology, Open = bindings::MorphologyMethod_OpenMorphology,
Close = bindings::MorphologyMethod_CloseMorphology, Close = bindings::MorphologyMethod_CloseMorphology,
OpenIntensity = bindings::MorphologyMethod_OpenIntensityMorphology, OpenIntensity = bindings::MorphologyMethod_OpenIntensityMorphology,
CloseIntensity = bindings::MorphologyMethod_CloseIntensityMorphology, CloseIntensity = bindings::MorphologyMethod_CloseIntensityMorphology,
Smooth = bindings::MorphologyMethod_SmoothMorphology, Smooth = bindings::MorphologyMethod_SmoothMorphology,
EdgeIn = bindings::MorphologyMethod_EdgeInMorphology, EdgeIn = bindings::MorphologyMethod_EdgeInMorphology,
EdgeOut = bindings::MorphologyMethod_EdgeOutMorphology, EdgeOut = bindings::MorphologyMethod_EdgeOutMorphology,
Edge = bindings::MorphologyMethod_EdgeMorphology, Edge = bindings::MorphologyMethod_EdgeMorphology,
TopHat = bindings::MorphologyMethod_TopHatMorphology, TopHat = bindings::MorphologyMethod_TopHatMorphology,
BottomHat = bindings::MorphologyMethod_BottomHatMorphology, BottomHat = bindings::MorphologyMethod_BottomHatMorphology,
HitAndMiss = bindings::MorphologyMethod_HitAndMissMorphology, HitAndMiss = bindings::MorphologyMethod_HitAndMissMorphology,
Thinning = bindings::MorphologyMethod_ThinningMorphology, Thinning = bindings::MorphologyMethod_ThinningMorphology,
Thicken = bindings::MorphologyMethod_ThickenMorphology, Thicken = bindings::MorphologyMethod_ThickenMorphology,
Distance = bindings::MorphologyMethod_DistanceMorphology, Distance = bindings::MorphologyMethod_DistanceMorphology,
Voronoi = bindings::MorphologyMethod_VoronoiMorphology, Voronoi = bindings::MorphologyMethod_VoronoiMorphology,
} }
impl Default for MorphologyMethod { impl Default for MorphologyMethod {
@ -101,9 +98,6 @@ impl From<MorphologyMethod> for bindings::KernelInfoType {
} }
} }
/// Builder, that creates instances of [KernelInfo](self::KernelInfo) /// Builder, that creates instances of [KernelInfo](self::KernelInfo)
/// ///
/// # Examples /// # Examples
@ -197,28 +191,25 @@ impl KernelBuilder {
} }
pub fn build(&self) -> Result<KernelInfo> { pub fn build(&self) -> Result<KernelInfo> {
let size = self.size.ok_or(MagickError("no kernel size given".to_string()))?; let size = self
let values = self.values.as_ref().ok_or(MagickError("no kernel values given".to_string()))?; .size
.ok_or(MagickError("no kernel size given".to_string()))?;
let values = self
.values
.as_ref()
.ok_or(MagickError("no kernel values given".to_string()))?;
if values.len() != size.0 * size.1 { if values.len() != size.0 * size.1 {
return Err(MagickError("kernel size doesn't match kernel values size".to_string())); return Err(MagickError(
"kernel size doesn't match kernel values size".to_string(),
));
} }
// Create kernel string // Create kernel string
let mut kernel_string = if let Some(center) = self.center { let mut kernel_string = if let Some(center) = self.center {
format!( format!("{}x{}+{}+{}:", size.0, size.1, center.0, center.1)
"{}x{}+{}+{}:",
size.0,
size.1,
center.0,
center.1
)
} else { } else {
format!( format!("{}x{}:", size.0, size.1,)
"{}x{}:",
size.0,
size.1,
)
}; };
// Add values // Add values
@ -233,12 +224,8 @@ impl KernelBuilder {
let c_kernel_string = CString::new(kernel_string).expect("CString::new() has failed"); let c_kernel_string = CString::new(kernel_string).expect("CString::new() has failed");
// Create kernel info // Create kernel info
let kernel_info = unsafe { let kernel_info =
bindings::AcquireKernelInfo( unsafe { bindings::AcquireKernelInfo(c_kernel_string.as_ptr(), std::ptr::null_mut()) };
c_kernel_string.as_ptr(),
std::ptr::null_mut()
)
};
if kernel_info.is_null() { if kernel_info.is_null() {
return Err(MagickError("failed to acquire kernel info".to_string())); return Err(MagickError("failed to acquire kernel info".to_string()));
@ -260,20 +247,22 @@ impl KernelBuilder {
} }
pub fn build_builtin(&self) -> Result<KernelInfo> { pub fn build_builtin(&self) -> Result<KernelInfo> {
let info_type = self.info_type.ok_or(MagickError("no info type given".to_string()))?; let info_type = self
let mut geom_info = self.geom_info.ok_or(MagickError("no geometry info given".to_string()))?; .info_type
.ok_or(MagickError("no info type given".to_string()))?;
let mut geom_info = self
.geom_info
.ok_or(MagickError("no geometry info given".to_string()))?;
// Create kernel info // Create kernel info
let kernel_info = unsafe { let kernel_info = unsafe {
bindings::AcquireKernelBuiltIn( bindings::AcquireKernelBuiltIn(info_type.into(), &mut geom_info, std::ptr::null_mut())
info_type.into(),
&mut geom_info,
std::ptr::null_mut()
)
}; };
if kernel_info.is_null() { if kernel_info.is_null() {
return Err(MagickError("failed to acquire builtin kernel info".to_string())); return Err(MagickError(
"failed to acquire builtin kernel info".to_string(),
));
} }
Ok(KernelInfo::new(kernel_info)) Ok(KernelInfo::new(kernel_info))
@ -286,20 +275,12 @@ pub struct KernelInfo {
impl KernelInfo { impl KernelInfo {
fn new(kernel_info: *mut bindings::KernelInfo) -> KernelInfo { fn new(kernel_info: *mut bindings::KernelInfo) -> KernelInfo {
return KernelInfo { return KernelInfo { kernel_info };
kernel_info
};
} }
/// The values within the kernel is scaled directly using given scaling factor without change. /// The values within the kernel is scaled directly using given scaling factor without change.
pub fn scale(&mut self, factor: f64) { pub fn scale(&mut self, factor: f64) {
unsafe { unsafe { bindings::ScaleKernelInfo(self.kernel_info, factor, 0) }
bindings::ScaleKernelInfo(
self.kernel_info,
factor,
0
)
}
} }
/// Kernel normalization is designed to ensure that any use of the kernel scaling factor with /// Kernel normalization is designed to ensure that any use of the kernel scaling factor with
@ -323,7 +304,7 @@ impl KernelInfo {
bindings::ScaleKernelInfo( bindings::ScaleKernelInfo(
self.kernel_info, self.kernel_info,
1.0, 1.0,
bindings::GeometryFlags_NormalizeValue bindings::GeometryFlags_NormalizeValue,
) )
} }
} }
@ -337,7 +318,7 @@ impl KernelInfo {
bindings::ScaleKernelInfo( bindings::ScaleKernelInfo(
self.kernel_info, self.kernel_info,
1.0, 1.0,
bindings::GeometryFlags_CorrelateNormalizeValue bindings::GeometryFlags_CorrelateNormalizeValue,
) )
} }
} }
@ -350,12 +331,7 @@ impl KernelInfo {
/// The resulting effect is to convert the defined kernels into blended soft-blurs, unsharp /// The resulting effect is to convert the defined kernels into blended soft-blurs, unsharp
/// kernels or into sharpening kernels. /// kernels or into sharpening kernels.
pub fn unity_add(&mut self, scale: f64) { pub fn unity_add(&mut self, scale: f64) {
unsafe { unsafe { bindings::UnityAddKernelInfo(self.kernel_info, scale) }
bindings::UnityAddKernelInfo(
self.kernel_info,
scale
)
}
} }
pub unsafe fn get_ptr(&self) -> *mut bindings::KernelInfo { pub unsafe fn get_ptr(&self) -> *mut bindings::KernelInfo {
@ -371,9 +347,7 @@ impl Drop for KernelInfo {
impl Clone for KernelInfo { impl Clone for KernelInfo {
fn clone(&self) -> Self { fn clone(&self) -> Self {
let kernel_info = unsafe { let kernel_info = unsafe { bindings::CloneKernelInfo(self.kernel_info) };
bindings::CloneKernelInfo(self.kernel_info)
};
if kernel_info.is_null() { if kernel_info.is_null() {
panic!("failed to clone kernel info"); panic!("failed to clone kernel info");

32
src/types/layer_method.rs
View File

@ -3,23 +3,23 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum LayerMethod { pub enum LayerMethod {
Undefined = bindings::LayerMethod_UndefinedLayer, Undefined = bindings::LayerMethod_UndefinedLayer,
Coalesce = bindings::LayerMethod_CoalesceLayer, Coalesce = bindings::LayerMethod_CoalesceLayer,
CompareAny = bindings::LayerMethod_CompareAnyLayer, CompareAny = bindings::LayerMethod_CompareAnyLayer,
CompareClear = bindings::LayerMethod_CompareClearLayer, CompareClear = bindings::LayerMethod_CompareClearLayer,
CompareOverlay = bindings::LayerMethod_CompareOverlayLayer, CompareOverlay = bindings::LayerMethod_CompareOverlayLayer,
Dispose = bindings::LayerMethod_DisposeLayer, Dispose = bindings::LayerMethod_DisposeLayer,
Optimize = bindings::LayerMethod_OptimizeLayer, Optimize = bindings::LayerMethod_OptimizeLayer,
OptimizeImage = bindings::LayerMethod_OptimizeImageLayer, OptimizeImage = bindings::LayerMethod_OptimizeImageLayer,
OptimizePlus = bindings::LayerMethod_OptimizePlusLayer, OptimizePlus = bindings::LayerMethod_OptimizePlusLayer,
OptimizeTrans = bindings::LayerMethod_OptimizeTransLayer, OptimizeTrans = bindings::LayerMethod_OptimizeTransLayer,
RemoveDups = bindings::LayerMethod_RemoveDupsLayer, RemoveDups = bindings::LayerMethod_RemoveDupsLayer,
RemoveZero = bindings::LayerMethod_RemoveZeroLayer, RemoveZero = bindings::LayerMethod_RemoveZeroLayer,
Composite = bindings::LayerMethod_CompositeLayer, Composite = bindings::LayerMethod_CompositeLayer,
Merge = bindings::LayerMethod_MergeLayer, Merge = bindings::LayerMethod_MergeLayer,
Flatten = bindings::LayerMethod_FlattenLayer, Flatten = bindings::LayerMethod_FlattenLayer,
Mosaic = bindings::LayerMethod_MosaicLayer, Mosaic = bindings::LayerMethod_MosaicLayer,
TrimBounds = bindings::LayerMethod_TrimBoundsLayer, TrimBounds = bindings::LayerMethod_TrimBoundsLayer,
} }
impl Default for LayerMethod { impl Default for LayerMethod {

6
src/types/line_cap.rs
View File

@ -4,9 +4,9 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum LineCap { pub enum LineCap {
Undefined = bindings::LineCap_UndefinedCap, Undefined = bindings::LineCap_UndefinedCap,
Butt = bindings::LineCap_ButtCap, Butt = bindings::LineCap_ButtCap,
Round = bindings::LineCap_RoundCap, Round = bindings::LineCap_RoundCap,
Square = bindings::LineCap_SquareCap, Square = bindings::LineCap_SquareCap,
} }
impl Default for LineCap { impl Default for LineCap {

6
src/types/line_join.rs
View File

@ -4,9 +4,9 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum LineJoin { pub enum LineJoin {
Undefined = bindings::LineJoin_UndefinedJoin, Undefined = bindings::LineJoin_UndefinedJoin,
Miter = bindings::LineJoin_MiterJoin, Miter = bindings::LineJoin_MiterJoin,
Round = bindings::LineJoin_RoundJoin, Round = bindings::LineJoin_RoundJoin,
Bevel = bindings::LineJoin_BevelJoin, Bevel = bindings::LineJoin_BevelJoin,
} }
impl Default for LineJoin { impl Default for LineJoin {

66
src/types/magick_evaluate_operator.rs
View File

@ -3,40 +3,40 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum MagickEvaluateOperator { pub enum MagickEvaluateOperator {
Undefined = bindings::MagickEvaluateOperator_UndefinedEvaluateOperator, Undefined = bindings::MagickEvaluateOperator_UndefinedEvaluateOperator,
Abs = bindings::MagickEvaluateOperator_AbsEvaluateOperator, Abs = bindings::MagickEvaluateOperator_AbsEvaluateOperator,
Add = bindings::MagickEvaluateOperator_AddEvaluateOperator, Add = bindings::MagickEvaluateOperator_AddEvaluateOperator,
AddModulus = bindings::MagickEvaluateOperator_AddModulusEvaluateOperator, AddModulus = bindings::MagickEvaluateOperator_AddModulusEvaluateOperator,
And = bindings::MagickEvaluateOperator_AndEvaluateOperator, And = bindings::MagickEvaluateOperator_AndEvaluateOperator,
Cosine = bindings::MagickEvaluateOperator_CosineEvaluateOperator, Cosine = bindings::MagickEvaluateOperator_CosineEvaluateOperator,
Divide = bindings::MagickEvaluateOperator_DivideEvaluateOperator, Divide = bindings::MagickEvaluateOperator_DivideEvaluateOperator,
Exponential = bindings::MagickEvaluateOperator_ExponentialEvaluateOperator, Exponential = bindings::MagickEvaluateOperator_ExponentialEvaluateOperator,
GaussianNoise = bindings::MagickEvaluateOperator_GaussianNoiseEvaluateOperator, GaussianNoise = bindings::MagickEvaluateOperator_GaussianNoiseEvaluateOperator,
ImpulseNoise = bindings::MagickEvaluateOperator_ImpulseNoiseEvaluateOperator, ImpulseNoise = bindings::MagickEvaluateOperator_ImpulseNoiseEvaluateOperator,
LaplacianNoise = bindings::MagickEvaluateOperator_LaplacianNoiseEvaluateOperator, LaplacianNoise = bindings::MagickEvaluateOperator_LaplacianNoiseEvaluateOperator,
LeftShift = bindings::MagickEvaluateOperator_LeftShiftEvaluateOperator, LeftShift = bindings::MagickEvaluateOperator_LeftShiftEvaluateOperator,
Log = bindings::MagickEvaluateOperator_LogEvaluateOperator, Log = bindings::MagickEvaluateOperator_LogEvaluateOperator,
Max = bindings::MagickEvaluateOperator_MaxEvaluateOperator, Max = bindings::MagickEvaluateOperator_MaxEvaluateOperator,
Mean = bindings::MagickEvaluateOperator_MeanEvaluateOperator, Mean = bindings::MagickEvaluateOperator_MeanEvaluateOperator,
Median = bindings::MagickEvaluateOperator_MedianEvaluateOperator, Median = bindings::MagickEvaluateOperator_MedianEvaluateOperator,
Min = bindings::MagickEvaluateOperator_MinEvaluateOperator, Min = bindings::MagickEvaluateOperator_MinEvaluateOperator,
MultiplicativeNoise = bindings::MagickEvaluateOperator_MultiplicativeNoiseEvaluateOperator, MultiplicativeNoise = bindings::MagickEvaluateOperator_MultiplicativeNoiseEvaluateOperator,
Multiply = bindings::MagickEvaluateOperator_MultiplyEvaluateOperator, Multiply = bindings::MagickEvaluateOperator_MultiplyEvaluateOperator,
Or = bindings::MagickEvaluateOperator_OrEvaluateOperator, Or = bindings::MagickEvaluateOperator_OrEvaluateOperator,
PoissonNoise = bindings::MagickEvaluateOperator_PoissonNoiseEvaluateOperator, PoissonNoise = bindings::MagickEvaluateOperator_PoissonNoiseEvaluateOperator,
Pow = bindings::MagickEvaluateOperator_PowEvaluateOperator, Pow = bindings::MagickEvaluateOperator_PowEvaluateOperator,
RightShift = bindings::MagickEvaluateOperator_RightShiftEvaluateOperator, RightShift = bindings::MagickEvaluateOperator_RightShiftEvaluateOperator,
RootMeanSquare = bindings::MagickEvaluateOperator_RootMeanSquareEvaluateOperator, RootMeanSquare = bindings::MagickEvaluateOperator_RootMeanSquareEvaluateOperator,
Set = bindings::MagickEvaluateOperator_SetEvaluateOperator, Set = bindings::MagickEvaluateOperator_SetEvaluateOperator,
Sine = bindings::MagickEvaluateOperator_SineEvaluateOperator, Sine = bindings::MagickEvaluateOperator_SineEvaluateOperator,
Subtract = bindings::MagickEvaluateOperator_SubtractEvaluateOperator, Subtract = bindings::MagickEvaluateOperator_SubtractEvaluateOperator,
Sum = bindings::MagickEvaluateOperator_SumEvaluateOperator, Sum = bindings::MagickEvaluateOperator_SumEvaluateOperator,
ThresholdBlack = bindings::MagickEvaluateOperator_ThresholdBlackEvaluateOperator, ThresholdBlack = bindings::MagickEvaluateOperator_ThresholdBlackEvaluateOperator,
Threshold = bindings::MagickEvaluateOperator_ThresholdEvaluateOperator, Threshold = bindings::MagickEvaluateOperator_ThresholdEvaluateOperator,
ThresholdWhite = bindings::MagickEvaluateOperator_ThresholdWhiteEvaluateOperator, ThresholdWhite = bindings::MagickEvaluateOperator_ThresholdWhiteEvaluateOperator,
UniformNoise = bindings::MagickEvaluateOperator_UniformNoiseEvaluateOperator, UniformNoise = bindings::MagickEvaluateOperator_UniformNoiseEvaluateOperator,
Xor = bindings::MagickEvaluateOperator_XorEvaluateOperator, Xor = bindings::MagickEvaluateOperator_XorEvaluateOperator,
InverseLog = bindings::MagickEvaluateOperator_InverseLogEvaluateOperator, InverseLog = bindings::MagickEvaluateOperator_InverseLogEvaluateOperator,
} }
impl Default for MagickEvaluateOperator { impl Default for MagickEvaluateOperator {

8
src/types/magick_function.rs
View File

@ -3,11 +3,11 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum MagickFunction { pub enum MagickFunction {
Undefined = bindings::MagickFunction_UndefinedFunction, Undefined = bindings::MagickFunction_UndefinedFunction,
Arcsin = bindings::MagickFunction_ArcsinFunction, Arcsin = bindings::MagickFunction_ArcsinFunction,
Arctan = bindings::MagickFunction_ArctanFunction, Arctan = bindings::MagickFunction_ArctanFunction,
Polynomial = bindings::MagickFunction_PolynomialFunction, Polynomial = bindings::MagickFunction_PolynomialFunction,
Sinusoid = bindings::MagickFunction_SinusoidFunction, Sinusoid = bindings::MagickFunction_SinusoidFunction,
} }
impl Default for MagickFunction { impl Default for MagickFunction {

27
src/types/metric_type.rs
View File

@ -1,19 +1,20 @@
use crate::bindings; use crate::bindings;
pub enum MetricType { pub enum MetricType {
Undefined = bindings::MetricType_UndefinedErrorMetric as isize, Undefined = bindings::MetricType_UndefinedErrorMetric as isize,
Absolute = bindings::MetricType_AbsoluteErrorMetric as isize, Absolute = bindings::MetricType_AbsoluteErrorMetric as isize,
Fuzz = bindings::MetricType_FuzzErrorMetric as isize, Fuzz = bindings::MetricType_FuzzErrorMetric as isize,
MeanAbsolute = bindings::MetricType_MeanAbsoluteErrorMetric as isize, MeanAbsolute = bindings::MetricType_MeanAbsoluteErrorMetric as isize,
MeanErrorPerPixel = bindings::MetricType_MeanErrorPerPixelErrorMetric as isize, MeanErrorPerPixel = bindings::MetricType_MeanErrorPerPixelErrorMetric as isize,
MeanSquared = bindings::MetricType_MeanSquaredErrorMetric as isize, MeanSquared = bindings::MetricType_MeanSquaredErrorMetric as isize,
NormalizedCrossCorrelation = bindings::MetricType_NormalizedCrossCorrelationErrorMetric as isize, NormalizedCrossCorrelation =
PeakAbsolute = bindings::MetricType_PeakAbsoluteErrorMetric as isize, bindings::MetricType_NormalizedCrossCorrelationErrorMetric as isize,
PeakSignalToNoiseRatio = bindings::MetricType_PeakSignalToNoiseRatioErrorMetric as isize, PeakAbsolute = bindings::MetricType_PeakAbsoluteErrorMetric as isize,
PerceptualHash = bindings::MetricType_PerceptualHashErrorMetric as isize, PeakSignalToNoiseRatio = bindings::MetricType_PeakSignalToNoiseRatioErrorMetric as isize,
RootMeanSquared = bindings::MetricType_RootMeanSquaredErrorMetric as isize, PerceptualHash = bindings::MetricType_PerceptualHashErrorMetric as isize,
StructuralSimilarity = bindings::MetricType_StructuralSimilarityErrorMetric as isize, RootMeanSquared = bindings::MetricType_RootMeanSquaredErrorMetric as isize,
StructuralDissimilarity = bindings::MetricType_StructuralDissimilarityErrorMetric as isize, StructuralSimilarity = bindings::MetricType_StructuralSimilarityErrorMetric as isize,
StructuralDissimilarity = bindings::MetricType_StructuralDissimilarityErrorMetric as isize,
} }
impl Default for MetricType { impl Default for MetricType {

14
src/types/orientation_type.rs
View File

@ -3,15 +3,15 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum OrientationType { pub enum OrientationType {
Undefined = bindings::OrientationType_UndefinedOrientation, Undefined = bindings::OrientationType_UndefinedOrientation,
TopLeft = bindings::OrientationType_TopLeftOrientation, TopLeft = bindings::OrientationType_TopLeftOrientation,
TopRight = bindings::OrientationType_TopRightOrientation, TopRight = bindings::OrientationType_TopRightOrientation,
BottomRight = bindings::OrientationType_BottomRightOrientation, BottomRight = bindings::OrientationType_BottomRightOrientation,
BottomLeft = bindings::OrientationType_BottomLeftOrientation, BottomLeft = bindings::OrientationType_BottomLeftOrientation,
LeftTop = bindings::OrientationType_LeftTopOrientation, LeftTop = bindings::OrientationType_LeftTopOrientation,
RightTop = bindings::OrientationType_RightTopOrientation, RightTop = bindings::OrientationType_RightTopOrientation,
RightBottom = bindings::OrientationType_RightBottomOrientation, RightBottom = bindings::OrientationType_RightBottomOrientation,
LeftBottom = bindings::OrientationType_LeftBottomOrientation, LeftBottom = bindings::OrientationType_LeftBottomOrientation,
} }
impl Default for OrientationType { impl Default for OrientationType {

22
src/types/pixel_interpolate_method.rs
View File

@ -3,18 +3,18 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum PixelInterpolateMethod { pub enum PixelInterpolateMethod {
Undefined = bindings::PixelInterpolateMethod_UndefinedInterpolatePixel, Undefined = bindings::PixelInterpolateMethod_UndefinedInterpolatePixel,
Average = bindings::PixelInterpolateMethod_AverageInterpolatePixel, Average = bindings::PixelInterpolateMethod_AverageInterpolatePixel,
Average9 = bindings::PixelInterpolateMethod_Average9InterpolatePixel, Average9 = bindings::PixelInterpolateMethod_Average9InterpolatePixel,
Average16 = bindings::PixelInterpolateMethod_Average16InterpolatePixel, Average16 = bindings::PixelInterpolateMethod_Average16InterpolatePixel,
Background = bindings::PixelInterpolateMethod_BackgroundInterpolatePixel, Background = bindings::PixelInterpolateMethod_BackgroundInterpolatePixel,
Bilinear = bindings::PixelInterpolateMethod_BilinearInterpolatePixel, Bilinear = bindings::PixelInterpolateMethod_BilinearInterpolatePixel,
Blend = bindings::PixelInterpolateMethod_BlendInterpolatePixel, Blend = bindings::PixelInterpolateMethod_BlendInterpolatePixel,
Catrom = bindings::PixelInterpolateMethod_CatromInterpolatePixel, Catrom = bindings::PixelInterpolateMethod_CatromInterpolatePixel,
Integer = bindings::PixelInterpolateMethod_IntegerInterpolatePixel, Integer = bindings::PixelInterpolateMethod_IntegerInterpolatePixel,
Mesh = bindings::PixelInterpolateMethod_MeshInterpolatePixel, Mesh = bindings::PixelInterpolateMethod_MeshInterpolatePixel,
Nearest = bindings::PixelInterpolateMethod_NearestInterpolatePixel, Nearest = bindings::PixelInterpolateMethod_NearestInterpolatePixel,
Spline = bindings::PixelInterpolateMethod_SplineInterpolatePixel, Spline = bindings::PixelInterpolateMethod_SplineInterpolatePixel,
} }
impl Default for PixelInterpolateMethod { impl Default for PixelInterpolateMethod {

4
src/types/pixel_mask.rs
View File

@ -4,8 +4,8 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum PixelMask { pub enum PixelMask {
Undefined = bindings::PixelMask_UndefinedPixelMask, Undefined = bindings::PixelMask_UndefinedPixelMask,
Read = bindings::PixelMask_ReadPixelMask, Read = bindings::PixelMask_ReadPixelMask,
Write = bindings::PixelMask_WritePixelMask, Write = bindings::PixelMask_WritePixelMask,
Composite = bindings::PixelMask_CompositePixelMask, Composite = bindings::PixelMask_CompositePixelMask,
} }

6
src/types/rendering_intent.rs
View File

@ -3,11 +3,11 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum RenderingIntent { pub enum RenderingIntent {
Undefined = bindings::RenderingIntent_UndefinedIntent, Undefined = bindings::RenderingIntent_UndefinedIntent,
Saturation = bindings::RenderingIntent_SaturationIntent, Saturation = bindings::RenderingIntent_SaturationIntent,
Perceptual = bindings::RenderingIntent_PerceptualIntent, Perceptual = bindings::RenderingIntent_PerceptualIntent,
Absolute = bindings::RenderingIntent_AbsoluteIntent, Absolute = bindings::RenderingIntent_AbsoluteIntent,
Relative = bindings::RenderingIntent_RelativeIntent, Relative = bindings::RenderingIntent_RelativeIntent,
} }
impl Default for RenderingIntent { impl Default for RenderingIntent {

4
src/types/resolution_type.rs
View File

@ -3,8 +3,8 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum ResolutionType { pub enum ResolutionType {
Undefined = bindings::ResolutionType_UndefinedResolution, Undefined = bindings::ResolutionType_UndefinedResolution,
PixelsPerInch = bindings::ResolutionType_PixelsPerInchResolution, PixelsPerInch = bindings::ResolutionType_PixelsPerInchResolution,
PixelsPerCentimeter = bindings::ResolutionType_PixelsPerCentimeterResolution, PixelsPerCentimeter = bindings::ResolutionType_PixelsPerCentimeterResolution,
} }

22
src/types/resource_type.rs
View File

@ -3,17 +3,17 @@ use crate::bindings;
/// Resource type to use with [set_resource_limit](crate::MagickWand::set_resource_limit) /// Resource type to use with [set_resource_limit](crate::MagickWand::set_resource_limit)
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ResourceType { pub enum ResourceType {
Undefined = bindings::ResourceType_UndefinedResource as isize, Undefined = bindings::ResourceType_UndefinedResource as isize,
Area = bindings::ResourceType_AreaResource as isize, Area = bindings::ResourceType_AreaResource as isize,
Disk = bindings::ResourceType_DiskResource as isize, Disk = bindings::ResourceType_DiskResource as isize,
File = bindings::ResourceType_FileResource as isize, File = bindings::ResourceType_FileResource as isize,
Height = bindings::ResourceType_HeightResource as isize, Height = bindings::ResourceType_HeightResource as isize,
Map = bindings::ResourceType_MapResource as isize, Map = bindings::ResourceType_MapResource as isize,
Memory = bindings::ResourceType_MemoryResource as isize, Memory = bindings::ResourceType_MemoryResource as isize,
Thread = bindings::ResourceType_ThreadResource as isize, Thread = bindings::ResourceType_ThreadResource as isize,
Throttle = bindings::ResourceType_ThrottleResource as isize, Throttle = bindings::ResourceType_ThrottleResource as isize,
Time = bindings::ResourceType_TimeResource as isize, Time = bindings::ResourceType_TimeResource as isize,
Width = bindings::ResourceType_WidthResource as isize, Width = bindings::ResourceType_WidthResource as isize,
ListLength = bindings::ResourceType_ListLengthResource as isize, ListLength = bindings::ResourceType_ListLengthResource as isize,
} }

20
src/types/statistic_type.rs
View File

@ -3,17 +3,17 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum StatisticType { pub enum StatisticType {
Undefined = bindings::StatisticType_UndefinedStatistic, Undefined = bindings::StatisticType_UndefinedStatistic,
Gradient = bindings::StatisticType_GradientStatistic, Gradient = bindings::StatisticType_GradientStatistic,
Maximum = bindings::StatisticType_MaximumStatistic, Maximum = bindings::StatisticType_MaximumStatistic,
Mean = bindings::StatisticType_MeanStatistic, Mean = bindings::StatisticType_MeanStatistic,
Median = bindings::StatisticType_MedianStatistic, Median = bindings::StatisticType_MedianStatistic,
Minimum = bindings::StatisticType_MinimumStatistic, Minimum = bindings::StatisticType_MinimumStatistic,
Mode = bindings::StatisticType_ModeStatistic, Mode = bindings::StatisticType_ModeStatistic,
Nonpeak = bindings::StatisticType_NonpeakStatistic, Nonpeak = bindings::StatisticType_NonpeakStatistic,
RootMeanSquare = bindings::StatisticType_RootMeanSquareStatistic, RootMeanSquare = bindings::StatisticType_RootMeanSquareStatistic,
StandardDeviation = bindings::StatisticType_StandardDeviationStatistic, StandardDeviation = bindings::StatisticType_StandardDeviationStatistic,
Contrast = bindings::StatisticType_ContrastStatistic, Contrast = bindings::StatisticType_ContrastStatistic,
} }
impl Default for StatisticType { impl Default for StatisticType {

18
src/types/stretch_type.rs
View File

@ -3,17 +3,17 @@ use crate::bindings;
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)] #[repr(u32)]
pub enum StretchType { pub enum StretchType {
Undefined = bindings::StretchType_UndefinedStretch, Undefined = bindings::StretchType_UndefinedStretch,
Normal = bindings::StretchType_NormalStretch, Normal = bindings::StretchType_NormalStretch,
UltraCondensed = bindings::StretchType_UltraCondensedStretch, UltraCondensed = bindings::StretchType_UltraCondensedStretch,
ExtraCondensed = bindings::StretchType_ExtraCondensedStretch, ExtraCondensed = bindings::StretchType_ExtraCondensedStretch,
Condensed = bindings::StretchType_CondensedStretch, Condensed = bindings::StretchType_CondensedStretch,
SemiCondensed = bindings::StretchType_SemiCondensedStretch, SemiCondensed = bindings::StretchType_SemiCondensedStretch,
SemiExpanded = bindings::StretchType_SemiExpandedStretch, SemiExpanded = bindings::StretchType_SemiExpandedStretch,
Expanded = bindings::StretchType_ExpandedStretch, Expanded = bindings::StretchType_ExpandedStretch,
ExtraExpanded = bindings::StretchType_ExtraExpandedStretch, ExtraExpanded = bindings::StretchType_ExtraExpandedStretch,
UltraExpanded = bindings::StretchType_UltraExpandedStretch, UltraExpanded = bindings::StretchType_UltraExpandedStretch,
Any = bindings::StretchType_AnyStretch, Any = bindings::StretchType_AnyStretch,
} }
impl Default for StretchType { impl Default for StretchType {

10
src/types/style_type.rs
View File

@ -4,11 +4,11 @@ use crate::bindings;
#[repr(u32)] #[repr(u32)]
pub enum StyleType { pub enum StyleType {
Undefined = bindings::StyleType_UndefinedStyle, Undefined = bindings::StyleType_UndefinedStyle,
Normal = bindings::StyleType_NormalStyle, Normal = bindings::StyleType_NormalStyle,
Italic = bindings::StyleType_ItalicStyle, Italic = bindings::StyleType_ItalicStyle,
Oblique = bindings::StyleType_ObliqueStyle, Oblique = bindings::StyleType_ObliqueStyle,
Any = bindings::StyleType_AnyStyle, Any = bindings::StyleType_AnyStyle,
Bold = bindings::StyleType_BoldStyle, Bold = bindings::StyleType_BoldStyle,
} }
impl Default for StyleType { impl Default for StyleType {

12
src/wand/drawing.rs
View File

@ -21,16 +21,8 @@ use bindings;
use crate::result::MagickError; use crate::result::MagickError;
use crate::result::Result; use crate::result::Result;
use crate::{ use crate::{
AlignType, AlignType, ClipPathUnits, DecorationType, DirectionType, FillRule, GravityType, LineCap,
ClipPathUnits, LineJoin, StretchType, StyleType,
DecorationType,
DirectionType,
FillRule,
GravityType,
LineCap,
LineJoin,
StretchType,
StyleType,
}; };
wand_common!( wand_common!(

32
src/wand/macros.rs
View File

@ -40,11 +40,9 @@ macro_rules! wand_common {
pub fn clear_exception(&mut self) -> Result<()> { pub fn clear_exception(&mut self) -> Result<()> {
match unsafe { ::bindings::$clear_exc(self.wand) } { match unsafe { ::bindings::$clear_exc(self.wand) } {
::bindings::MagickBooleanType_MagickTrue => Ok(()), ::bindings::MagickBooleanType_MagickTrue => Ok(()),
_ => Err(MagickError(concat!( _ => Err(MagickError(
"failed to clear", concat!("failed to clear", stringify!($wand), "exception").to_string(),
stringify!($wand), )),
"exception"
).to_string())),
} }
} }
@ -58,17 +56,14 @@ macro_rules! wand_common {
let ptr = unsafe { ::bindings::$get_exc(self.wand, &mut severity as *mut _) }; let ptr = unsafe { ::bindings::$get_exc(self.wand, &mut severity as *mut _) };
if ptr.is_null() { if ptr.is_null() {
Err(MagickError(concat!( Err(MagickError(
"null ptr returned by", concat!("null ptr returned by", stringify!($wand), "get_exception")
stringify!($wand), .to_string(),
"get_exception" ))
).to_string()))
} else { } else {
let c_str = unsafe { CStr::from_ptr(ptr) }; let c_str = unsafe { CStr::from_ptr(ptr) };
let exception = c_str.to_string_lossy().into_owned(); let exception = c_str.to_string_lossy().into_owned();
unsafe { unsafe { ::bindings::RelinquishMagickMemory(ptr as *mut ::libc::c_void) };
::bindings::RelinquishMagickMemory(ptr as *mut ::libc::c_void)
};
Ok((exception, severity)) Ok((exception, severity))
} }
} }
@ -76,7 +71,9 @@ macro_rules! wand_common {
pub fn is_wand(&self) -> Result<()> { pub fn is_wand(&self) -> Result<()> {
match unsafe { ::bindings::$is_wand(self.wand) } { match unsafe { ::bindings::$is_wand(self.wand) } {
::bindings::MagickBooleanType_MagickTrue => Ok(()), ::bindings::MagickBooleanType_MagickTrue => Ok(()),
_ => Err(MagickError(concat!(stringify!($wand), " not a wand").to_string())), _ => Err(MagickError(
concat!(stringify!($wand), " not a wand").to_string(),
)),
} }
} }
} }
@ -159,10 +156,9 @@ macro_rules! string_get {
pub fn $get(&self) -> Result<String> { pub fn $get(&self) -> Result<String> {
let ptr = unsafe { ::bindings::$c_get(self.wand) }; let ptr = unsafe { ::bindings::$c_get(self.wand) };
if ptr.is_null() { if ptr.is_null() {
Err(MagickError(concat!( Err(MagickError(
"null ptr returned by ", concat!("null ptr returned by ", stringify!($get)).to_string(),
stringify!($get) ))
).to_string()))
} else { } else {
let c_str = unsafe { ::std::ffi::CStr::from_ptr(ptr) }; let c_str = unsafe { ::std::ffi::CStr::from_ptr(ptr) };
let result: String = c_str.to_string_lossy().into_owned(); let result: String = c_str.to_string_lossy().into_owned();

304
src/wand/magick.rs
View File

@ -26,38 +26,16 @@ use result::MagickError;
#[cfg(not(target_os = "freebsd"))] #[cfg(not(target_os = "freebsd"))]
use size_t; use size_t;
use super::{MagickFalse, MagickTrue};
use crate::result::Result; use crate::result::Result;
use super::{MagickTrue, MagickFalse};
use super::{DrawingWand, PixelWand}; use super::{DrawingWand, PixelWand};
use crate::{ use crate::{
AlphaChannelOption, AlphaChannelOption, AutoThresholdMethod, ChannelType, ColorspaceType, CompositeOperator,
AutoThresholdMethod, CompressionType, DisposeType, DitherMethod, EndianType, FilterType, GravityType, Image,
ChannelType, ImageType, InterlaceType, KernelInfo, LayerMethod, MagickEvaluateOperator, MagickFunction,
ColorspaceType, MetricType, MorphologyMethod, OrientationType, PixelInterpolateMethod, PixelMask,
CompositeOperator, RenderingIntent, ResolutionType, ResourceType, StatisticType,
CompressionType,
DisposeType,
DitherMethod,
EndianType,
FilterType,
GravityType,
Image,
ImageType,
InterlaceType,
KernelInfo,
LayerMethod,
MagickEvaluateOperator,
MagickFunction,
MetricType,
MorphologyMethod,
OrientationType,
PixelInterpolateMethod,
PixelMask,
RenderingIntent,
ResolutionType,
ResourceType,
StatisticType,
}; };
wand_common!( wand_common!(
@ -83,19 +61,21 @@ impl MagickWand {
/// ///
/// * `img`: the image. /// * `img`: the image.
pub fn new_from_image(img: &Image<'_>) -> Result<MagickWand> { pub fn new_from_image(img: &Image<'_>) -> Result<MagickWand> {
let result = unsafe { let result = unsafe { bindings::NewMagickWandFromImage(img.get_ptr()) };
bindings::NewMagickWandFromImage(img.get_ptr())
};
return if result.is_null() { return if result.is_null() {
Err(MagickError("failed to create magick wand from image".to_string())) Err(MagickError(
"failed to create magick wand from image".to_string(),
))
} else { } else {
Ok(MagickWand { wand: result }) Ok(MagickWand { wand: result })
} };
} }
pub fn new_image(&self, columns: usize, rows: usize, background: &PixelWand) -> Result<()> { pub fn new_image(&self, columns: usize, rows: usize, background: &PixelWand) -> Result<()> {
match unsafe { bindings::MagickNewImage(self.wand, columns.into(), rows.into(), background.wand) } { match unsafe {
bindings::MagickNewImage(self.wand, columns.into(), rows.into(), background.wand)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -105,10 +85,7 @@ impl MagickWand {
#[cfg(any(target_os = "linux", target_os = "macos"))] #[cfg(any(target_os = "linux", target_os = "macos"))]
pub fn set_resource_limit(resource: ResourceType, limit: u64) -> Result<()> { pub fn set_resource_limit(resource: ResourceType, limit: u64) -> Result<()> {
let result = unsafe { let result = unsafe {
bindings::SetMagickResourceLimit( bindings::SetMagickResourceLimit(resource.into(), limit as bindings::MagickSizeType)
resource.into(),
limit as bindings::MagickSizeType,
)
}; };
match result { match result {
MagickTrue => Ok(()), MagickTrue => Ok(()),
@ -261,9 +238,7 @@ impl MagickWand {
/// MosaicLayer: Start with the virtual canvas of the first image, enlarging left and right /// MosaicLayer: Start with the virtual canvas of the first image, enlarging left and right
/// edges to contain all images. Images with negative offsets will be clipped. /// edges to contain all images. Images with negative offsets will be clipped.
pub fn merge_image_layers(&self, method: LayerMethod) -> Result<MagickWand> { pub fn merge_image_layers(&self, method: LayerMethod) -> Result<MagickWand> {
let result = unsafe { let result = unsafe { bindings::MagickMergeImageLayers(self.wand, method.into()) };
bindings::MagickMergeImageLayers(self.wand, method.into())
};
if result.is_null() { if result.is_null() {
return Err(MagickError("failed to merge image layers".to_string())); return Err(MagickError("failed to merge image layers".to_string()));
} }
@ -357,11 +332,7 @@ impl MagickWand {
} }
// Replaces colors in the image from a color lookup table. // Replaces colors in the image from a color lookup table.
pub fn clut_image( pub fn clut_image(&self, clut_wand: &MagickWand, method: PixelInterpolateMethod) -> Result<()> {
&self,
clut_wand: &MagickWand,
method: PixelInterpolateMethod,
) -> Result<()> {
let result = unsafe { bindings::MagickClutImage(self.wand, clut_wand.wand, method.into()) }; let result = unsafe { bindings::MagickClutImage(self.wand, clut_wand.wand, method.into()) };
match result { match result {
MagickTrue => Ok(()), MagickTrue => Ok(()),
@ -378,7 +349,8 @@ impl MagickWand {
} }
pub fn fx(&mut self, expression: &str) -> Result<MagickWand> { pub fn fx(&mut self, expression: &str) -> Result<MagickWand> {
let c_expression = CString::new(expression).map_err(|_| "expression string contains null byte")?; let c_expression =
CString::new(expression).map_err(|_| "expression string contains null byte")?;
let wand = unsafe { bindings::MagickFxImage(self.wand, c_expression.as_ptr()) }; let wand = unsafe { bindings::MagickFxImage(self.wand, c_expression.as_ptr()) };
if wand.is_null() { if wand.is_null() {
Err(MagickError("failed to fx the image".to_string())) Err(MagickError("failed to fx the image".to_string()))
@ -411,7 +383,9 @@ impl MagickWand {
16 => Ok(65535.0f64), 16 => Ok(65535.0f64),
32 => Ok(4294967295.0f64), 32 => Ok(4294967295.0f64),
64 => Ok(18446744073709551615.0f64), 64 => Ok(18446744073709551615.0f64),
_ => Err(MagickError("Quantum depth must be one of 8, 16, 32 or 64".to_string())), _ => Err(MagickError(
"Quantum depth must be one of 8, 16, 32 or 64".to_string(),
)),
} }
} }
@ -456,14 +430,8 @@ impl MagickWand {
//MagickNormalizeImage enhances the contrast of a color image by adjusting the pixels color //MagickNormalizeImage enhances the contrast of a color image by adjusting the pixels color
//to span the entire range of colors available //to span the entire range of colors available
pub fn normalize_image( pub fn normalize_image(&self) -> Result<()> {
&self, let result = unsafe { bindings::MagickNormalizeImage(self.wand) };
) -> Result<()> {
let result = unsafe {
bindings::MagickNormalizeImage(
self.wand,
)
};
match result { match result {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
@ -473,18 +441,12 @@ impl MagickWand {
//MagickOrderedDitherImage performs an ordered dither based on a number of pre-defined //MagickOrderedDitherImage performs an ordered dither based on a number of pre-defined
//dithering threshold maps, but over multiple intensity levels, which can be different for //dithering threshold maps, but over multiple intensity levels, which can be different for
//different channels, according to the input arguments. //different channels, according to the input arguments.
pub fn ordered_dither_image( pub fn ordered_dither_image(&self, threshold_map: &str) -> Result<()> {
&self, let c_threshold_map =
threshold_map: &str, CString::new(threshold_map).map_err(|_| "threshold_map string contains null byte")?;
) -> Result<()> {
let c_threshold_map = CString::new(threshold_map).map_err(|_| "threshold_map string contains null byte")?;
let result = unsafe { let result =
bindings::MagickOrderedDitherImage( unsafe { bindings::MagickOrderedDitherImage(self.wand, c_threshold_map.as_ptr()) };
self.wand,
c_threshold_map.as_ptr(),
)
};
match result { match result {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
@ -576,9 +538,7 @@ impl MagickWand {
} }
pub fn negate_image(&self) -> Result<()> { pub fn negate_image(&self) -> Result<()> {
let result = unsafe { let result = unsafe { bindings::MagickNegateImage(self.wand, MagickTrue) };
bindings::MagickNegateImage(self.wand, MagickTrue)
};
match result { match result {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
@ -625,7 +585,7 @@ impl MagickWand {
self.wand, self.wand,
statistic_type.into(), statistic_type.into(),
width.into(), width.into(),
height.into() height.into(),
) )
} { } {
MagickTrue => Ok(()), MagickTrue => Ok(()),
@ -687,12 +647,11 @@ impl MagickWand {
/// Reset the Wand page canvas and position. /// Reset the Wand page canvas and position.
pub fn reset_image_page(&self, page_geometry: &str) -> Result<()> { pub fn reset_image_page(&self, page_geometry: &str) -> Result<()> {
let c_page_geometry = CString::new(page_geometry).map_err(|_| "page_geometry contains null byte")?; let c_page_geometry =
match unsafe { CString::new(page_geometry).map_err(|_| "page_geometry contains null byte")?;
bindings::MagickResetImagePage(self.wand, c_page_geometry.as_ptr()) match unsafe { bindings::MagickResetImagePage(self.wand, c_page_geometry.as_ptr()) } {
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)) _ => Err(MagickError(self.get_exception()?.0)),
} }
} }
@ -700,20 +659,18 @@ impl MagickWand {
/// ///
/// * `artifact`: the artifact. /// * `artifact`: the artifact.
pub fn get_image_artifact(&self, artifact: &str) -> Result<String> { pub fn get_image_artifact(&self, artifact: &str) -> Result<String> {
let c_artifact = CString::new(artifact).map_err(|_| "artifact string contains null byte")?; let c_artifact =
CString::new(artifact).map_err(|_| "artifact string contains null byte")?;
let c_value = unsafe { let c_value = unsafe { bindings::MagickGetImageArtifact(self.wand, c_artifact.as_ptr()) };
bindings::MagickGetImageArtifact(
self.wand,
c_artifact.as_ptr()
)
};
if c_value.is_null() { if c_value.is_null() {
return Err(MagickError(format!("missing artifact: {}", artifact))); return Err(MagickError(format!("missing artifact: {}", artifact)));
} }
// convert (and copy) the C string to a Rust string // convert (and copy) the C string to a Rust string
let value = unsafe { CStr::from_ptr(c_value) }.to_string_lossy().into_owned(); let value = unsafe { CStr::from_ptr(c_value) }
.to_string_lossy()
.into_owned();
unsafe { unsafe {
bindings::MagickRelinquishMemory(c_value as *mut c_void); bindings::MagickRelinquishMemory(c_value as *mut c_void);
@ -723,15 +680,12 @@ impl MagickWand {
} }
pub fn get_image_artifacts(&self, pattern: &str) -> Result<Vec<String>> { pub fn get_image_artifacts(&self, pattern: &str) -> Result<Vec<String>> {
let c_pattern = CString::new(pattern).map_err(|_| MagickError("artifact string contains null byte".to_string()))?; let c_pattern = CString::new(pattern)
.map_err(|_| MagickError("artifact string contains null byte".to_string()))?;
let mut num_of_artifacts: size_t = 0; let mut num_of_artifacts: size_t = 0;
let c_values = unsafe { let c_values = unsafe {
bindings::MagickGetImageArtifacts( bindings::MagickGetImageArtifacts(self.wand, c_pattern.as_ptr(), &mut num_of_artifacts)
self.wand,
c_pattern.as_ptr(),
&mut num_of_artifacts
)
}; };
if c_values.is_null() { if c_values.is_null() {
@ -782,20 +736,13 @@ impl MagickWand {
/// Ok(()) /// Ok(())
/// } /// }
/// ``` /// ```
pub fn set_image_artifact( pub fn set_image_artifact(&mut self, artifact: &str, value: &str) -> Result<()> {
&mut self, let c_artifact =
artifact: &str, CString::new(artifact).map_err(|_| "artifact string contains null byte")?;
value: &str
) -> Result<()> {
let c_artifact = CString::new(artifact).map_err(|_| "artifact string contains null byte")?;
let c_value = CString::new(value).map_err(|_| "value string contains null byte")?; let c_value = CString::new(value).map_err(|_| "value string contains null byte")?;
let result = unsafe { let result = unsafe {
bindings::MagickSetImageArtifact( bindings::MagickSetImageArtifact(self.wand, c_artifact.as_ptr(), c_value.as_ptr())
self.wand,
c_artifact.as_ptr(),
c_value.as_ptr()
)
}; };
match result { match result {
@ -808,14 +755,10 @@ impl MagickWand {
/// ///
/// * `artifact`: the artifact. /// * `artifact`: the artifact.
pub fn delete_image_artifact(&mut self, artifact: &str) -> Result<()> { pub fn delete_image_artifact(&mut self, artifact: &str) -> Result<()> {
let c_artifact = CString::new(artifact).map_err(|_| "artifact string contains null byte")?; let c_artifact =
CString::new(artifact).map_err(|_| "artifact string contains null byte")?;
match unsafe { match unsafe { bindings::MagickDeleteImageArtifact(self.wand, c_artifact.as_ptr()) } {
bindings::MagickDeleteImageArtifact(
self.wand,
c_artifact.as_ptr()
)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(format!("missing artifact: {}", artifact))), _ => Err(MagickError(format!("missing artifact: {}", artifact))),
} }
@ -831,7 +774,9 @@ impl MagickWand {
} }
// convert (and copy) the C string to a Rust string // convert (and copy) the C string to a Rust string
let value = unsafe { CStr::from_ptr(c_value) }.to_string_lossy().into_owned(); let value = unsafe { CStr::from_ptr(c_value) }
.to_string_lossy()
.into_owned();
unsafe { unsafe {
bindings::MagickRelinquishMemory(c_value as *mut c_void); bindings::MagickRelinquishMemory(c_value as *mut c_void);
@ -841,15 +786,12 @@ impl MagickWand {
} }
pub fn get_image_properties(&self, pattern: &str) -> Result<Vec<String>> { pub fn get_image_properties(&self, pattern: &str) -> Result<Vec<String>> {
let c_pattern = CString::new(pattern).map_err(|_| MagickError("artifact string contains null byte".to_string()))?; let c_pattern = CString::new(pattern)
.map_err(|_| MagickError("artifact string contains null byte".to_string()))?;
let mut num_of_artifacts: size_t = 0; let mut num_of_artifacts: size_t = 0;
let c_values = unsafe { let c_values = unsafe {
bindings::MagickGetImageProperties( bindings::MagickGetImageProperties(self.wand, c_pattern.as_ptr(), &mut num_of_artifacts)
self.wand,
c_pattern.as_ptr(),
&mut num_of_artifacts
)
}; };
if c_values.is_null() { if c_values.is_null() {
@ -886,9 +828,7 @@ impl MagickWand {
pub fn get_image_pixel_color(&self, x: isize, y: isize) -> Option<PixelWand> { pub fn get_image_pixel_color(&self, x: isize, y: isize) -> Option<PixelWand> {
let pw = PixelWand::new(); let pw = PixelWand::new();
match unsafe { match unsafe { bindings::MagickGetImagePixelColor(self.wand, x, y, pw.wand) } {
bindings::MagickGetImagePixelColor(self.wand, x, y, pw.wand)
} {
MagickTrue => Some(pw), MagickTrue => Some(pw),
_ => None, _ => None,
} }
@ -972,9 +912,7 @@ impl MagickWand {
/// Sets the image resolution /// Sets the image resolution
pub fn set_image_resolution(&self, x_resolution: f64, y_resolution: f64) -> Result<()> { pub fn set_image_resolution(&self, x_resolution: f64, y_resolution: f64) -> Result<()> {
match unsafe { match unsafe { bindings::MagickSetImageResolution(self.wand, x_resolution, y_resolution) } {
bindings::MagickSetImageResolution(self.wand, x_resolution, y_resolution)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -982,9 +920,7 @@ impl MagickWand {
/// Sets the wand resolution /// Sets the wand resolution
pub fn set_resolution(&self, x_resolution: f64, y_resolution: f64) -> Result<()> { pub fn set_resolution(&self, x_resolution: f64, y_resolution: f64) -> Result<()> {
match unsafe { match unsafe { bindings::MagickSetResolution(self.wand, x_resolution, y_resolution) } {
bindings::MagickSetResolution(self.wand, x_resolution, y_resolution)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -1085,7 +1021,8 @@ impl MagickWand {
&self, &self,
width_scale: f64, width_scale: f64,
height_scale: f64, height_scale: f64,
filter: FilterType) -> Result<()> { filter: FilterType,
) -> Result<()> {
if width_scale < 0.0 { if width_scale < 0.0 {
return Err(MagickError("negative width scale given".to_string())); return Err(MagickError("negative width scale given".to_string()));
} }
@ -1106,9 +1043,7 @@ impl MagickWand {
/// 'thumbnail' optimizations which remove a lot of image meta-data with the goal /// 'thumbnail' optimizations which remove a lot of image meta-data with the goal
/// of producing small low cost images suited for display on the web. /// of producing small low cost images suited for display on the web.
pub fn thumbnail_image(&self, width: usize, height: usize) -> Result<()> { pub fn thumbnail_image(&self, width: usize, height: usize) -> Result<()> {
match unsafe { match unsafe { bindings::MagickThumbnailImage(self.wand, width.into(), height.into()) } {
bindings::MagickThumbnailImage(self.wand, width.into(), height.into())
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -1218,9 +1153,7 @@ impl MagickWand {
/// ///
/// Returns `true` if successful or `false` if an error occurred. /// Returns `true` if successful or `false` if an error occurred.
pub fn auto_orient(&self) -> bool { pub fn auto_orient(&self) -> bool {
unsafe { unsafe { bindings::MagickAutoOrientImage(self.wand) == MagickTrue }
bindings::MagickAutoOrientImage(self.wand) == MagickTrue
}
} }
/// Write the current image to the provided path. /// Write the current image to the provided path.
@ -1309,28 +1242,16 @@ impl MagickWand {
/// ///
/// * `pixel_mask`: type of mask, Read or Write. /// * `pixel_mask`: type of mask, Read or Write.
/// * `clip_mask`: the clip_mask wand. /// * `clip_mask`: the clip_mask wand.
pub fn set_image_mask( pub fn set_image_mask(&mut self, pixel_mask: PixelMask, clip_mask: &MagickWand) -> Result<()> {
&mut self, match unsafe { bindings::MagickSetImageMask(self.wand, pixel_mask.into(), clip_mask.wand) }
pixel_mask: PixelMask, {
clip_mask: &MagickWand
) -> Result<()> {
match unsafe {
bindings::MagickSetImageMask(
self.wand,
pixel_mask.into(),
clip_mask.wand
)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
} }
/// Set image channel mask /// Set image channel mask
pub fn set_image_channel_mask( pub fn set_image_channel_mask(&mut self, option: ChannelType) -> ChannelType {
&mut self,
option: ChannelType,
) -> ChannelType {
unsafe { bindings::MagickSetImageChannelMask(self.wand, option.into()).into() } unsafe { bindings::MagickSetImageChannelMask(self.wand, option.into()).into() }
} }
@ -1365,9 +1286,7 @@ impl MagickWand {
/// Simulate an image shadow /// Simulate an image shadow
pub fn shadow_image(&self, alpha: f64, sigma: f64, x: isize, y: isize) -> Result<()> { pub fn shadow_image(&self, alpha: f64, sigma: f64, x: isize, y: isize) -> Result<()> {
match unsafe { match unsafe { bindings::MagickShadowImage(self.wand, alpha, sigma, x, y) } {
bindings::MagickShadowImage(self.wand, alpha, sigma, x, y)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -1471,14 +1390,18 @@ impl MagickWand {
colorspace: ColorspaceType, colorspace: ColorspaceType,
tree_depth: usize, tree_depth: usize,
dither_method: DitherMethod, dither_method: DitherMethod,
measure_error: bool) -> Result<()> { measure_error: bool,
match unsafe { bindings::MagickQuantizeImage( ) -> Result<()> {
match unsafe {
bindings::MagickQuantizeImage(
self.wand, self.wand,
number_of_colors.into(), number_of_colors.into(),
colorspace.into(), colorspace.into(),
tree_depth.into(), tree_depth.into(),
dither_method.into(), dither_method.into(),
measure_error.to_magick()) } { measure_error.to_magick(),
)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -1491,14 +1414,18 @@ impl MagickWand {
colorspace: ColorspaceType, colorspace: ColorspaceType,
tree_depth: usize, tree_depth: usize,
dither_method: DitherMethod, dither_method: DitherMethod,
measure_error: bool) -> Result<()> { measure_error: bool,
match unsafe { bindings::MagickQuantizeImages( ) -> Result<()> {
match unsafe {
bindings::MagickQuantizeImages(
self.wand, self.wand,
number_of_colors.into(), number_of_colors.into(),
colorspace.into(), colorspace.into(),
tree_depth.into(), tree_depth.into(),
dither_method.into(), dither_method.into(),
measure_error.to_magick()) } { measure_error.to_magick(),
)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -1529,19 +1456,10 @@ impl MagickWand {
/// Ok(()) /// Ok(())
/// } /// }
/// ``` /// ```
pub fn function_image( pub fn function_image(&self, function: MagickFunction, args: &[f64]) -> Result<()> {
&self,
function: MagickFunction,
args: &[f64]
) -> Result<()> {
let num_of_args: size_t = args.len().into(); let num_of_args: size_t = args.len().into();
match unsafe { match unsafe {
bindings::MagickFunctionImage( bindings::MagickFunctionImage(self.wand, function.into(), num_of_args, args.as_ptr())
self.wand,
function.into(),
num_of_args,
args.as_ptr()
)
} { } {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
@ -1557,13 +1475,7 @@ impl MagickWand {
return Err(MagickError("no constant coefficient given".to_string())); return Err(MagickError("no constant coefficient given".to_string()));
} }
let num_of_terms: size_t = (terms.len() >> 1).into(); let num_of_terms: size_t = (terms.len() >> 1).into();
match unsafe { match unsafe { bindings::MagickPolynomialImage(self.wand, num_of_terms, terms.as_ptr()) } {
bindings::MagickPolynomialImage(
self.wand,
num_of_terms,
terms.as_ptr()
)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -1573,12 +1485,7 @@ impl MagickWand {
/// ///
/// * `kernel_info`: An array of doubles representing the convolution kernel. /// * `kernel_info`: An array of doubles representing the convolution kernel.
pub fn convolve_image(&self, kernel_info: &KernelInfo) -> Result<()> { pub fn convolve_image(&self, kernel_info: &KernelInfo) -> Result<()> {
match unsafe { match unsafe { bindings::MagickConvolveImage(self.wand, kernel_info.get_ptr()) } {
bindings::MagickConvolveImage(
self.wand,
kernel_info.get_ptr()
)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -1593,14 +1500,14 @@ impl MagickWand {
&self, &self,
morphology_method: MorphologyMethod, morphology_method: MorphologyMethod,
iterations: isize, iterations: isize,
kernel_info: &KernelInfo kernel_info: &KernelInfo,
) -> Result<()> { ) -> Result<()> {
match unsafe { match unsafe {
bindings::MagickMorphologyImage( bindings::MagickMorphologyImage(
self.wand, self.wand,
morphology_method.into(), morphology_method.into(),
iterations.into(), iterations.into(),
kernel_info.get_ptr() kernel_info.get_ptr(),
) )
} { } {
MagickTrue => Ok(()), MagickTrue => Ok(()),
@ -1617,12 +1524,7 @@ impl MagickWand {
/// ///
/// * `color_matrix`: the color matrix. /// * `color_matrix`: the color matrix.
pub fn color_matrix_image(&self, color_matrix: &KernelInfo) -> Result<()> { pub fn color_matrix_image(&self, color_matrix: &KernelInfo) -> Result<()> {
match unsafe { match unsafe { bindings::MagickColorMatrixImage(self.wand, color_matrix.get_ptr()) } {
bindings::MagickColorMatrixImage(
self.wand,
color_matrix.get_ptr()
)
} {
MagickTrue => Ok(()), MagickTrue => Ok(()),
_ => Err(MagickError(self.get_exception()?.0)), _ => Err(MagickError(self.get_exception()?.0)),
} }
@ -1640,19 +1542,15 @@ impl MagickWand {
/// ///
/// * `expression`: the expression. /// * `expression`: the expression.
pub fn channel_fx_image(&self, expression: &str) -> Result<MagickWand> { pub fn channel_fx_image(&self, expression: &str) -> Result<MagickWand> {
let c_expression = CString::new(expression).map_err(|_| "artifact string contains null byte")?; let c_expression =
CString::new(expression).map_err(|_| "artifact string contains null byte")?;
let result = unsafe { let result = unsafe { bindings::MagickChannelFxImage(self.wand, c_expression.as_ptr()) };
bindings::MagickChannelFxImage(
self.wand,
c_expression.as_ptr()
)
};
return if result.is_null() { return if result.is_null() {
Err(MagickError(self.get_exception()?.0)) Err(MagickError(self.get_exception()?.0))
} else { } else {
Ok(MagickWand{ wand: result }) Ok(MagickWand { wand: result })
}; };
} }
@ -1662,28 +1560,24 @@ impl MagickWand {
/// ///
/// * `colorspace`: the colorspace. /// * `colorspace`: the colorspace.
pub fn combine_images(&self, colorspace: ColorspaceType) -> Result<MagickWand> { pub fn combine_images(&self, colorspace: ColorspaceType) -> Result<MagickWand> {
let result = unsafe { let result = unsafe { bindings::MagickCombineImages(self.wand, colorspace.into()) };
bindings::MagickCombineImages(self.wand, colorspace.into())
};
return if result.is_null() { return if result.is_null() {
Err(MagickError(self.get_exception()?.0)) Err(MagickError(self.get_exception()?.0))
} else { } else {
Ok(MagickWand{ wand: result }) Ok(MagickWand { wand: result })
} };
} }
/// Returns the current image from the magick wand. /// Returns the current image from the magick wand.
pub fn get_image<'wand>(&'wand self) -> Result<Image<'wand>> { pub fn get_image<'wand>(&'wand self) -> Result<Image<'wand>> {
let result = unsafe { let result = unsafe { bindings::GetImageFromMagickWand(self.wand) };
bindings::GetImageFromMagickWand(self.wand)
};
return if result.is_null() { return if result.is_null() {
Err(MagickError(self.get_exception()?.0)) Err(MagickError(self.get_exception()?.0))
} else { } else {
unsafe { Ok(Image::new(result)) } unsafe { Ok(Image::new(result)) }
} };
} }
mutations!( mutations!(

2
src/wand/mod.rs
View File

@ -23,5 +23,5 @@ pub use self::drawing::DrawingWand;
pub use self::magick::MagickWand; pub use self::magick::MagickWand;
pub use self::pixel::{PixelWand, HSL}; pub use self::pixel::{PixelWand, HSL};
use bindings::MagickBooleanType_MagickTrue as MagickTrue;
use bindings::MagickBooleanType_MagickFalse as MagickFalse; use bindings::MagickBooleanType_MagickFalse as MagickFalse;
use bindings::MagickBooleanType_MagickTrue as MagickTrue;

2
src/wand/pixel.rs
View File

@ -19,8 +19,8 @@ use std::fmt;
use bindings; use bindings;
use result::MagickError; use result::MagickError;
use crate::result::Result;
use super::MagickTrue; use super::MagickTrue;
use crate::result::Result;
#[derive(Default, Debug)] #[derive(Default, Debug)]
pub struct HSL { pub struct HSL {

19
tests/lib.rs
View File

@ -22,8 +22,8 @@ use std::io::Read;
use std::path::Path; use std::path::Path;
use std::sync::Once; use std::sync::Once;
use magick_rust::{magick_wand_genesis, MagickWand, PixelWand};
use magick_rust::MagickError; use magick_rust::MagickError;
use magick_rust::{magick_wand_genesis, MagickWand, PixelWand};
// Used to make sure MagickWand is initialized exactly once. Note that we // 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. // do not bother shutting down, we simply exit when the tests are done.
@ -54,7 +54,9 @@ fn test_resize_image() {
1 => 1, 1 => 1,
height => height / 2, height => height / 2,
}; };
assert!(wand.resize_image(halfwidth, halfheight, magick_rust::FilterType::Lanczos).is_ok()); assert!(wand
.resize_image(halfwidth, halfheight, magick_rust::FilterType::Lanczos)
.is_ok());
assert_eq!(256, wand.get_image_width()); assert_eq!(256, wand.get_image_width());
assert_eq!(192, wand.get_image_height()); assert_eq!(192, wand.get_image_height());
} }
@ -171,7 +173,10 @@ fn test_get_image_property() {
// retrieve a property that does not exist // retrieve a property that does not exist
let missing_value = wand.get_image_property("exif:Foobar"); let missing_value = wand.get_image_property("exif:Foobar");
assert!(missing_value.is_err()); assert!(missing_value.is_err());
assert_eq!(MagickError("missing property: exif:Foobar".to_string()), missing_value.unwrap_err()); assert_eq!(
MagickError("missing property: exif:Foobar".to_string()),
missing_value.unwrap_err()
);
} }
#[test] #[test]
@ -208,8 +213,7 @@ fn test_compare_images() {
assert!(wand2.read_image("tests/data/IMG_5745_rotl.JPG").is_ok()); assert!(wand2.read_image("tests/data/IMG_5745_rotl.JPG").is_ok());
wand2.auto_orient(); wand2.auto_orient();
let (distortion, diff) = let (distortion, diff) = wand1.compare_images(&wand2, magick_rust::MetricType::RootMeanSquared);
wand1.compare_images(&wand2, magick_rust::MetricType::RootMeanSquared);
assert!(distortion < 0.01); assert!(distortion < 0.01);
assert!(diff.is_some()); assert!(diff.is_some());
} }
@ -362,10 +366,7 @@ fn test_clut_image() {
assert!(gradient.read_image("gradient:black-yellow").is_ok()); assert!(gradient.read_image("gradient:black-yellow").is_ok());
assert!(wand assert!(wand
.clut_image( .clut_image(&gradient, magick_rust::PixelInterpolateMethod::Bilinear)
&gradient,
magick_rust::PixelInterpolateMethod::Bilinear
)
.is_ok()); .is_ok());
} }