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

Merge pull request #119 from 5ohue/master

Browse Source 
Create "types" module
This commit is contained in:
Nathan Fiedler
2024-05-10 15:12:26 -07:00
committed by GitHub
parent b359d72087 64bd81acd2
commit 3cfdd76c9d
13 changed files with 542 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/lib.rs
View File

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

75
src/types/colorspace_type.rs Normal file
View File

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

117
src/types/composite_operator.rs Normal file
View File

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

22
src/types/dither_method.rs Normal file
View File

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

45
src/types/filter_type.rs Normal file
View File

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

49
src/types/gravity_type.rs Normal file
View File

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

29
src/types/metric_type.rs Normal file
View File

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

15
src/types/mod.rs Normal file
View File

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

24
src/types/resource_type.rs Normal file
View File

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

265
src/wand/composite_operator.rs
View File

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

158
src/wand/magick.rs
View File

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

4
src/wand/mod.rs
View File

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

60
tests/lib.rs
View File

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