use crate::bindings;
use crate::error::*;
use crate::utils;
use crate::Result;
use crate::VipsBlob;
use crate::VipsImage;
use crate::VipsInterpolate;
use std::convert::TryInto;
use std::ffi::*;
use std::ptr::null_mut;
const NULL: *const c_void = null_mut();
include!("manual.rs");
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Access {
Random = 0,
Sequential = 1,
SequentialUnbuffered = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Align {
Low = 0,
Centre = 1,
High = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Angle {
D0 = 0,
D90 = 1,
D180 = 2,
D270 = 3,
Last = 4,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Angle45 {
D0 = 0,
D45 = 1,
D90 = 2,
D135 = 3,
D180 = 4,
D225 = 5,
D270 = 6,
D315 = 7,
Last = 8,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum BandFormat {
Notset = -1,
Uchar = 0,
Char = 1,
Ushort = 2,
Short = 3,
Uint = 4,
Int = 5,
Float = 6,
Complex = 7,
Double = 8,
Dpcomplex = 9,
Last = 10,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum BlendMode {
Clear = 0,
Source = 1,
Over = 2,
In = 3,
Out = 4,
Atop = 5,
Dest = 6,
DestOver = 7,
DestIn = 8,
DestOut = 9,
DestAtop = 10,
Xor = 11,
Add = 12,
Saturate = 13,
Multiply = 14,
Screen = 15,
Overlay = 16,
Darken = 17,
Lighten = 18,
ColourDodge = 19,
ColourBurn = 20,
HardLight = 21,
SoftLight = 22,
Difference = 23,
Exclusion = 24,
Last = 25,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Coding {
Error = -1,
None = 0,
Labq = 2,
Rad = 6,
Last = 7,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Combine {
Max = 0,
Sum = 1,
Min = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum CombineMode {
Set = 0,
Add = 1,
Last = 2,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum CompassDirection {
Centre = 0,
North = 1,
East = 2,
South = 3,
West = 4,
NorthEast = 5,
SouthEast = 6,
SouthWest = 7,
NorthWest = 8,
Last = 9,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Direction {
Horizontal = 0,
Vertical = 1,
Last = 2,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Extend {
Black = 0,
Copy = 1,
Repeat = 2,
Mirror = 3,
White = 4,
Background = 5,
Last = 6,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignDzContainer {
F = 0,
Zip = 1,
Szi = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignDzDepth {
Onepixel = 0,
Onetile = 1,
One = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignDzLayout {
Dz = 0,
Zoomify = 1,
Google = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignFlags {
None = 0,
Partial = 1,
Bigendian = 2,
Sequential = 4,
All = 7,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignPngFilter {
None = 8,
Sub = 16,
Up = 32,
Avg = 64,
Paeth = 128,
All = 248,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignTiffCompression {
None = 0,
Jpeg = 1,
Deflate = 2,
Packbit = 3,
Ccittfax4 = 4,
Lzw = 5,
Last = 6,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignTiffPredictor {
None = 1,
Horizontal = 2,
Float = 3,
Last = 4,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignTiffResunit {
Cm = 0,
Inch = 1,
Last = 2,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum ForeignWebpPreset {
Default = 0,
Picture = 1,
Photo = 2,
Drawing = 3,
Icon = 4,
Text = 5,
Last = 6,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Intent {
Perceptual = 0,
Relative = 1,
Saturation = 2,
Absolute = 3,
Last = 4,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Interesting {
None = 0,
Centre = 1,
Entropy = 2,
Attention = 3,
Low = 4,
High = 5,
Last = 6,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Interpretation {
Error = -1,
Multiband = 0,
BW = 1,
Histogram = 10,
Xyz = 12,
Lab = 13,
Cmyk = 15,
Labq = 16,
Rgb = 17,
Cmc = 18,
Lch = 19,
Labs = 21,
Srgb = 22,
Yxy = 23,
Fourier = 24,
Rgb16 = 25,
Grey16 = 26,
Matrix = 27,
Scrgb = 28,
Hsv = 29,
Last = 30,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Kernel {
Nearest = 0,
Linear = 1,
Cubic = 2,
Mitchell = 3,
Lanczos2 = 4,
Lanczos3 = 5,
Last = 6,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationBoolean {
And = 0,
Or = 1,
Eor = 2,
Lshift = 3,
Rshift = 4,
Last = 5,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationComplex {
Polar = 0,
Rect = 1,
Conj = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationComplex2 {
CrossPhase = 0,
Last = 1,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationComplexget {
Real = 0,
Imag = 1,
Last = 2,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationMath {
Sin = 0,
Co = 1,
Tan = 2,
Asin = 3,
Aco = 4,
Atan = 5,
Log = 6,
Log10 = 7,
Exp = 8,
Exp10 = 9,
Last = 10,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationMath2 {
Pow = 0,
Wop = 1,
Last = 2,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationMorphology {
Erode = 0,
Dilate = 1,
Last = 2,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationRelational {
Equal = 0,
Noteq = 1,
Less = 2,
Lesseq = 3,
More = 4,
Moreeq = 5,
Last = 6,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum OperationRound {
Rint = 0,
Ceil = 1,
Floor = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum PCS {
Lab = 0,
Xyz = 1,
Last = 2,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Precision {
Integer = 0,
Float = 1,
Approximate = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum RegionShrink {
Mean = 0,
Median = 1,
Mode = 2,
Last = 3,
}
#[derive(Copy, Clone, Debug, FromPrimitive, ToPrimitive)]
pub enum Size {
Both = 0,
Up = 1,
Down = 2,
Force = 3,
Last = 4,
}
pub fn system(cmd_format: &str) -> Result<()> {
unsafe {
let cmd_format_in: CString = utils::new_c_string(cmd_format)?;
let vips_op_response = bindings::vips_system(cmd_format_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::SystemError)
}
}
#[derive(Clone, Debug)]
pub struct SystemOptions {
pub inp: Vec<VipsImage>,
pub out: VipsImage,
pub log: String,
pub out_format: String,
pub in_format: String,
}
impl std::default::Default for SystemOptions {
fn default() -> Self {
SystemOptions {
inp: Vec::new(),
out: VipsImage::new(),
log: String::new(),
out_format: String::new(),
in_format: String::new(),
}
}
}
pub fn system_with_opts(cmd_format: &str, system_options: &SystemOptions) -> Result<()> {
unsafe {
let cmd_format_in: CString = utils::new_c_string(cmd_format)?;
let inp_wrapper = utils::VipsArrayImageWrapper::from(&system_options.inp[..]);
let inp_in = inp_wrapper.ctx;
let inp_in_name = utils::new_c_string("inp")?;
let out_in: *mut bindings::VipsImage = system_options.out.ctx;
let out_in_name = utils::new_c_string("out")?;
let log_in: CString = utils::new_c_string(&system_options.log)?;
let log_in_name = utils::new_c_string("log")?;
let out_format_in: CString = utils::new_c_string(&system_options.out_format)?;
let out_format_in_name = utils::new_c_string("out-format")?;
let in_format_in: CString = utils::new_c_string(&system_options.in_format)?;
let in_format_in_name = utils::new_c_string("in-format")?;
let vips_op_response = bindings::vips_system(
cmd_format_in.as_ptr(),
inp_in_name.as_ptr(),
inp_in,
out_in_name.as_ptr(),
out_in,
log_in_name.as_ptr(),
log_in.as_ptr(),
out_format_in_name.as_ptr(),
out_format_in.as_ptr(),
in_format_in_name.as_ptr(),
in_format_in.as_ptr(),
NULL,
);
utils::result(vips_op_response, (), Error::SystemError)
}
}
pub fn add(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_add(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::AddError,
)
}
}
pub fn subtract(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_subtract(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SubtractError,
)
}
}
pub fn multiply(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_multiply(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MultiplyError,
)
}
}
pub fn divide(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_divide(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::DivideError,
)
}
}
pub fn relational(
left: &VipsImage,
right: &VipsImage,
relational: OperationRelational,
) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let relational_in: i32 = relational as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_relational(
left_in,
right_in,
&mut out_out,
relational_in.try_into().unwrap(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RelationalError,
)
}
}
pub fn remainder(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_remainder(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RemainderError,
)
}
}
pub fn boolean(
left: &VipsImage,
right: &VipsImage,
boolean: OperationBoolean,
) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let boolean_in: i32 = boolean as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_boolean(
left_in,
right_in,
&mut out_out,
boolean_in.try_into().unwrap(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BooleanError,
)
}
}
pub fn math_2(left: &VipsImage, right: &VipsImage, math_2: OperationMath2) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let math_2_in: i32 = math_2 as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_math2(
left_in,
right_in,
&mut out_out,
math_2_in.try_into().unwrap(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Math2Error,
)
}
}
pub fn complex_2(
left: &VipsImage,
right: &VipsImage,
cmplx: OperationComplex2,
) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let cmplx_in: i32 = cmplx as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_complex2(
left_in,
right_in,
&mut out_out,
cmplx_in.try_into().unwrap(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Complex2Error,
)
}
}
pub fn complexform(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_complexform(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ComplexformError,
)
}
}
pub fn sum(inp: &mut [VipsImage]) -> Result<VipsImage> {
unsafe {
let inp_in: *mut *mut bindings::VipsImage =
inp.iter().map(|v| v.ctx).collect::<Vec<_>>().as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_sum(inp_in, &mut out_out, inp.len() as i32, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SumError,
)
}
}
pub fn invert(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_invert(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::InvertError,
)
}
}
pub fn math(inp: &VipsImage, math: OperationMath) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let math_in: i32 = math as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_math(inp_in, &mut out_out, math_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MathError,
)
}
}
pub fn abs(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_abs(inp_in, &mut out_out, NULL);
utils::result(vips_op_response, VipsImage { ctx: out_out }, Error::AbError)
}
}
pub fn sign(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_sign(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SignError,
)
}
}
pub fn round(inp: &VipsImage, round: OperationRound) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let round_in: i32 = round as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_round(inp_in, &mut out_out, round_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RoundError,
)
}
}
pub fn relational_const(
inp: &VipsImage,
relational: OperationRelational,
c: &mut [f64],
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let relational_in: i32 = relational as i32;
let c_in: *mut f64 = c.as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_relational_const(
inp_in,
&mut out_out,
relational_in.try_into().unwrap(),
c_in,
c.len() as i32,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RelationalConstError,
)
}
}
pub fn remainder_const(inp: &VipsImage, c: &mut [f64]) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let c_in: *mut f64 = c.as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_remainder_const(inp_in, &mut out_out, c_in, c.len() as i32, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RemainderConstError,
)
}
}
pub fn boolean_const(
inp: &VipsImage,
boolean: OperationBoolean,
c: &mut [f64],
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let boolean_in: i32 = boolean as i32;
let c_in: *mut f64 = c.as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_boolean_const(
inp_in,
&mut out_out,
boolean_in.try_into().unwrap(),
c_in,
c.len() as i32,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BooleanConstError,
)
}
}
pub fn math_2_const(inp: &VipsImage, math_2: OperationMath2, c: &mut [f64]) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let math_2_in: i32 = math_2 as i32;
let c_in: *mut f64 = c.as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_math2_const(
inp_in,
&mut out_out,
math_2_in.try_into().unwrap(),
c_in,
c.len() as i32,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Math2ConstError,
)
}
}
pub fn complex(inp: &VipsImage, cmplx: OperationComplex) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let cmplx_in: i32 = cmplx as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_complex(inp_in, &mut out_out, cmplx_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ComplexError,
)
}
}
pub fn complexget(inp: &VipsImage, get: OperationComplexget) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let get_in: i32 = get as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_complexget(inp_in, &mut out_out, get_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ComplexgetError,
)
}
}
pub fn avg(inp: &VipsImage) -> Result<f64> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: f64 = f64::from(0);
let vips_op_response = bindings::vips_avg(inp_in, &mut out_out, NULL);
utils::result(vips_op_response, out_out, Error::AvgError)
}
}
pub fn min(inp: &VipsImage) -> Result<f64> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: f64 = f64::from(0);
let vips_op_response = bindings::vips_min(inp_in, &mut out_out, NULL);
utils::result(vips_op_response, out_out, Error::MinError)
}
}
#[derive(Clone, Debug)]
pub struct MinOptions {
pub x: i32,
pub y: i32,
pub size: i32,
pub out_array: Vec<f64>,
pub x_array: Vec<i32>,
pub y_array: Vec<i32>,
}
impl std::default::Default for MinOptions {
fn default() -> Self {
MinOptions {
x: i32::from(0),
y: i32::from(0),
size: i32::from(10),
out_array: Vec::new(),
x_array: Vec::new(),
y_array: Vec::new(),
}
}
}
pub fn min_with_opts(inp: &VipsImage, min_options: &MinOptions) -> Result<f64> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: f64 = f64::from(0);
let x_in: i32 = min_options.x;
let x_in_name = utils::new_c_string("x")?;
let y_in: i32 = min_options.y;
let y_in_name = utils::new_c_string("y")?;
let size_in: i32 = min_options.size;
let size_in_name = utils::new_c_string("size")?;
let out_array_wrapper = utils::VipsArrayDoubleWrapper::from(&min_options.out_array[..]);
let out_array_in = out_array_wrapper.ctx;
let out_array_in_name = utils::new_c_string("out-array")?;
let x_array_wrapper = utils::VipsArrayIntWrapper::from(&min_options.x_array[..]);
let x_array_in = x_array_wrapper.ctx;
let x_array_in_name = utils::new_c_string("x-array")?;
let y_array_wrapper = utils::VipsArrayIntWrapper::from(&min_options.y_array[..]);
let y_array_in = y_array_wrapper.ctx;
let y_array_in_name = utils::new_c_string("y-array")?;
let vips_op_response = bindings::vips_min(
inp_in,
&mut out_out,
x_in_name.as_ptr(),
x_in,
y_in_name.as_ptr(),
y_in,
size_in_name.as_ptr(),
size_in,
out_array_in_name.as_ptr(),
out_array_in,
x_array_in_name.as_ptr(),
x_array_in,
y_array_in_name.as_ptr(),
y_array_in,
NULL,
);
utils::result(vips_op_response, out_out, Error::MinError)
}
}
pub fn max(inp: &VipsImage) -> Result<f64> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: f64 = f64::from(0);
let vips_op_response = bindings::vips_max(inp_in, &mut out_out, NULL);
utils::result(vips_op_response, out_out, Error::MaxError)
}
}
#[derive(Clone, Debug)]
pub struct MaxOptions {
pub x: i32,
pub y: i32,
pub size: i32,
pub out_array: Vec<f64>,
pub x_array: Vec<i32>,
pub y_array: Vec<i32>,
}
impl std::default::Default for MaxOptions {
fn default() -> Self {
MaxOptions {
x: i32::from(0),
y: i32::from(0),
size: i32::from(10),
out_array: Vec::new(),
x_array: Vec::new(),
y_array: Vec::new(),
}
}
}
pub fn max_with_opts(inp: &VipsImage, max_options: &MaxOptions) -> Result<f64> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: f64 = f64::from(0);
let x_in: i32 = max_options.x;
let x_in_name = utils::new_c_string("x")?;
let y_in: i32 = max_options.y;
let y_in_name = utils::new_c_string("y")?;
let size_in: i32 = max_options.size;
let size_in_name = utils::new_c_string("size")?;
let out_array_wrapper = utils::VipsArrayDoubleWrapper::from(&max_options.out_array[..]);
let out_array_in = out_array_wrapper.ctx;
let out_array_in_name = utils::new_c_string("out-array")?;
let x_array_wrapper = utils::VipsArrayIntWrapper::from(&max_options.x_array[..]);
let x_array_in = x_array_wrapper.ctx;
let x_array_in_name = utils::new_c_string("x-array")?;
let y_array_wrapper = utils::VipsArrayIntWrapper::from(&max_options.y_array[..]);
let y_array_in = y_array_wrapper.ctx;
let y_array_in_name = utils::new_c_string("y-array")?;
let vips_op_response = bindings::vips_max(
inp_in,
&mut out_out,
x_in_name.as_ptr(),
x_in,
y_in_name.as_ptr(),
y_in,
size_in_name.as_ptr(),
size_in,
out_array_in_name.as_ptr(),
out_array_in,
x_array_in_name.as_ptr(),
x_array_in,
y_array_in_name.as_ptr(),
y_array_in,
NULL,
);
utils::result(vips_op_response, out_out, Error::MaxError)
}
}
pub fn deviate(inp: &VipsImage) -> Result<f64> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: f64 = f64::from(0);
let vips_op_response = bindings::vips_deviate(inp_in, &mut out_out, NULL);
utils::result(vips_op_response, out_out, Error::DeviateError)
}
}
pub fn stats(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_stats(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::StatError,
)
}
}
pub fn hist_find(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hist_find(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistFindError,
)
}
}
#[derive(Clone, Debug)]
pub struct HistFindOptions {
pub band: i32,
}
impl std::default::Default for HistFindOptions {
fn default() -> Self {
HistFindOptions {
band: i32::from(-1),
}
}
}
pub fn hist_find_with_opts(
inp: &VipsImage,
hist_find_options: &HistFindOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let band_in: i32 = hist_find_options.band;
let band_in_name = utils::new_c_string("band")?;
let vips_op_response =
bindings::vips_hist_find(inp_in, &mut out_out, band_in_name.as_ptr(), band_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistFindError,
)
}
}
pub fn hist_find_ndim(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hist_find_ndim(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistFindNdimError,
)
}
}
#[derive(Clone, Debug)]
pub struct HistFindNdimOptions {
pub bins: i32,
}
impl std::default::Default for HistFindNdimOptions {
fn default() -> Self {
HistFindNdimOptions {
bins: i32::from(10),
}
}
}
pub fn hist_find_ndim_with_opts(
inp: &VipsImage,
hist_find_ndim_options: &HistFindNdimOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let bins_in: i32 = hist_find_ndim_options.bins;
let bins_in_name = utils::new_c_string("bins")?;
let vips_op_response = bindings::vips_hist_find_ndim(
inp_in,
&mut out_out,
bins_in_name.as_ptr(),
bins_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistFindNdimError,
)
}
}
pub fn hist_find_indexed(inp: &VipsImage, index: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let index_in: *mut bindings::VipsImage = index.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_hist_find_indexed(inp_in, index_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistFindIndexedError,
)
}
}
#[derive(Clone, Debug)]
pub struct HistFindIndexedOptions {
pub combine: Combine,
}
impl std::default::Default for HistFindIndexedOptions {
fn default() -> Self {
HistFindIndexedOptions {
combine: Combine::Sum,
}
}
}
pub fn hist_find_indexed_with_opts(
inp: &VipsImage,
index: &VipsImage,
hist_find_indexed_options: &HistFindIndexedOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let index_in: *mut bindings::VipsImage = index.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let combine_in: i32 = hist_find_indexed_options.combine as i32;
let combine_in_name = utils::new_c_string("combine")?;
let vips_op_response = bindings::vips_hist_find_indexed(
inp_in,
index_in,
&mut out_out,
combine_in_name.as_ptr(),
combine_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistFindIndexedError,
)
}
}
pub fn hough_line(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hough_line(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HoughLineError,
)
}
}
#[derive(Clone, Debug)]
pub struct HoughLineOptions {
pub width: i32,
pub height: i32,
}
impl std::default::Default for HoughLineOptions {
fn default() -> Self {
HoughLineOptions {
width: i32::from(256),
height: i32::from(256),
}
}
}
pub fn hough_line_with_opts(
inp: &VipsImage,
hough_line_options: &HoughLineOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let width_in: i32 = hough_line_options.width;
let width_in_name = utils::new_c_string("width")?;
let height_in: i32 = hough_line_options.height;
let height_in_name = utils::new_c_string("height")?;
let vips_op_response = bindings::vips_hough_line(
inp_in,
&mut out_out,
width_in_name.as_ptr(),
width_in,
height_in_name.as_ptr(),
height_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HoughLineError,
)
}
}
pub fn hough_circle(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hough_circle(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HoughCircleError,
)
}
}
#[derive(Clone, Debug)]
pub struct HoughCircleOptions {
pub scale: i32,
pub min_radius: i32,
pub max_radius: i32,
}
impl std::default::Default for HoughCircleOptions {
fn default() -> Self {
HoughCircleOptions {
scale: i32::from(3),
min_radius: i32::from(10),
max_radius: i32::from(20),
}
}
}
pub fn hough_circle_with_opts(
inp: &VipsImage,
hough_circle_options: &HoughCircleOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let scale_in: i32 = hough_circle_options.scale;
let scale_in_name = utils::new_c_string("scale")?;
let min_radius_in: i32 = hough_circle_options.min_radius;
let min_radius_in_name = utils::new_c_string("min-radius")?;
let max_radius_in: i32 = hough_circle_options.max_radius;
let max_radius_in_name = utils::new_c_string("max-radius")?;
let vips_op_response = bindings::vips_hough_circle(
inp_in,
&mut out_out,
scale_in_name.as_ptr(),
scale_in,
min_radius_in_name.as_ptr(),
min_radius_in,
max_radius_in_name.as_ptr(),
max_radius_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HoughCircleError,
)
}
}
pub fn project(inp: &VipsImage) -> Result<(VipsImage, VipsImage)> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut columns_out: *mut bindings::VipsImage = null_mut();
let mut rows_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_project(inp_in, &mut columns_out, &mut rows_out, NULL);
utils::result(
vips_op_response,
(VipsImage { ctx: columns_out }, VipsImage { ctx: rows_out }),
Error::ProjectError,
)
}
}
pub fn profile(inp: &VipsImage) -> Result<(VipsImage, VipsImage)> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut columns_out: *mut bindings::VipsImage = null_mut();
let mut rows_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_profile(inp_in, &mut columns_out, &mut rows_out, NULL);
utils::result(
vips_op_response,
(VipsImage { ctx: columns_out }, VipsImage { ctx: rows_out }),
Error::ProfileError,
)
}
}
pub fn measure(inp: &VipsImage, h: i32, v: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let h_in: i32 = h;
let v_in: i32 = v;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_measure(inp_in, &mut out_out, h_in, v_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MeasureError,
)
}
}
#[derive(Clone, Debug)]
pub struct MeasureOptions {
pub left: i32,
pub top: i32,
pub width: i32,
pub height: i32,
}
impl std::default::Default for MeasureOptions {
fn default() -> Self {
MeasureOptions {
left: i32::from(0),
top: i32::from(0),
width: i32::from(1),
height: i32::from(1),
}
}
}
pub fn measure_with_opts(
inp: &VipsImage,
h: i32,
v: i32,
measure_options: &MeasureOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let h_in: i32 = h;
let v_in: i32 = v;
let mut out_out: *mut bindings::VipsImage = null_mut();
let left_in: i32 = measure_options.left;
let left_in_name = utils::new_c_string("left")?;
let top_in: i32 = measure_options.top;
let top_in_name = utils::new_c_string("top")?;
let width_in: i32 = measure_options.width;
let width_in_name = utils::new_c_string("width")?;
let height_in: i32 = measure_options.height;
let height_in_name = utils::new_c_string("height")?;
let vips_op_response = bindings::vips_measure(
inp_in,
&mut out_out,
h_in,
v_in,
left_in_name.as_ptr(),
left_in,
top_in_name.as_ptr(),
top_in,
width_in_name.as_ptr(),
width_in,
height_in_name.as_ptr(),
height_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MeasureError,
)
}
}
pub fn find_trim(inp: &VipsImage) -> Result<(i32, i32, i32, i32)> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut left_out: i32 = i32::from(1);
let mut top_out: i32 = i32::from(0);
let mut width_out: i32 = i32::from(1);
let mut height_out: i32 = i32::from(1);
let vips_op_response = bindings::vips_find_trim(
inp_in,
&mut left_out,
&mut top_out,
&mut width_out,
&mut height_out,
NULL,
);
utils::result(
vips_op_response,
(left_out, top_out, width_out, height_out),
Error::FindTrimError,
)
}
}
#[derive(Clone, Debug)]
pub struct FindTrimOptions {
pub threshold: f64,
pub background: Vec<f64>,
}
impl std::default::Default for FindTrimOptions {
fn default() -> Self {
FindTrimOptions {
threshold: f64::from(10),
background: Vec::new(),
}
}
}
pub fn find_trim_with_opts(
inp: &VipsImage,
find_trim_options: &FindTrimOptions,
) -> Result<(i32, i32, i32, i32)> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut left_out: i32 = i32::from(1);
let mut top_out: i32 = i32::from(0);
let mut width_out: i32 = i32::from(1);
let mut height_out: i32 = i32::from(1);
let threshold_in: f64 = find_trim_options.threshold;
let threshold_in_name = utils::new_c_string("threshold")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&find_trim_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_find_trim(
inp_in,
&mut left_out,
&mut top_out,
&mut width_out,
&mut height_out,
threshold_in_name.as_ptr(),
threshold_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
(left_out, top_out, width_out, height_out),
Error::FindTrimError,
)
}
}
pub fn copy(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_copy(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CopyError,
)
}
}
#[derive(Clone, Debug)]
pub struct CopyOptions {
pub width: i32,
pub height: i32,
pub bands: i32,
pub format: BandFormat,
pub coding: Coding,
pub interpretation: Interpretation,
pub xres: f64,
pub yres: f64,
pub xoffset: i32,
pub yoffset: i32,
}
impl std::default::Default for CopyOptions {
fn default() -> Self {
CopyOptions {
width: i32::from(0),
height: i32::from(0),
bands: i32::from(0),
format: BandFormat::Uchar,
coding: Coding::None,
interpretation: Interpretation::Multiband,
xres: f64::from(0),
yres: f64::from(0),
xoffset: i32::from(0),
yoffset: i32::from(0),
}
}
}
pub fn copy_with_opts(inp: &VipsImage, copy_options: &CopyOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let width_in: i32 = copy_options.width;
let width_in_name = utils::new_c_string("width")?;
let height_in: i32 = copy_options.height;
let height_in_name = utils::new_c_string("height")?;
let bands_in: i32 = copy_options.bands;
let bands_in_name = utils::new_c_string("bands")?;
let format_in: i32 = copy_options.format as i32;
let format_in_name = utils::new_c_string("format")?;
let coding_in: i32 = copy_options.coding as i32;
let coding_in_name = utils::new_c_string("coding")?;
let interpretation_in: i32 = copy_options.interpretation as i32;
let interpretation_in_name = utils::new_c_string("interpretation")?;
let xres_in: f64 = copy_options.xres;
let xres_in_name = utils::new_c_string("xres")?;
let yres_in: f64 = copy_options.yres;
let yres_in_name = utils::new_c_string("yres")?;
let xoffset_in: i32 = copy_options.xoffset;
let xoffset_in_name = utils::new_c_string("xoffset")?;
let yoffset_in: i32 = copy_options.yoffset;
let yoffset_in_name = utils::new_c_string("yoffset")?;
let vips_op_response = bindings::vips_copy(
inp_in,
&mut out_out,
width_in_name.as_ptr(),
width_in,
height_in_name.as_ptr(),
height_in,
bands_in_name.as_ptr(),
bands_in,
format_in_name.as_ptr(),
format_in,
coding_in_name.as_ptr(),
coding_in,
interpretation_in_name.as_ptr(),
interpretation_in,
xres_in_name.as_ptr(),
xres_in,
yres_in_name.as_ptr(),
yres_in,
xoffset_in_name.as_ptr(),
xoffset_in,
yoffset_in_name.as_ptr(),
yoffset_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CopyError,
)
}
}
pub fn tilecache(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_tilecache(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TilecacheError,
)
}
}
#[derive(Clone, Debug)]
pub struct TilecacheOptions {
pub tile_width: i32,
pub tile_height: i32,
pub max_tiles: i32,
pub access: Access,
pub threaded: bool,
pub persistent: bool,
}
impl std::default::Default for TilecacheOptions {
fn default() -> Self {
TilecacheOptions {
tile_width: i32::from(128),
tile_height: i32::from(128),
max_tiles: i32::from(1000),
access: Access::Random,
threaded: false,
persistent: false,
}
}
}
pub fn tilecache_with_opts(
inp: &VipsImage,
tilecache_options: &TilecacheOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let tile_width_in: i32 = tilecache_options.tile_width;
let tile_width_in_name = utils::new_c_string("tile-width")?;
let tile_height_in: i32 = tilecache_options.tile_height;
let tile_height_in_name = utils::new_c_string("tile-height")?;
let max_tiles_in: i32 = tilecache_options.max_tiles;
let max_tiles_in_name = utils::new_c_string("max-tiles")?;
let access_in: i32 = tilecache_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let threaded_in: i32 = if tilecache_options.threaded { 1 } else { 0 };
let threaded_in_name = utils::new_c_string("threaded")?;
let persistent_in: i32 = if tilecache_options.persistent { 1 } else { 0 };
let persistent_in_name = utils::new_c_string("persistent")?;
let vips_op_response = bindings::vips_tilecache(
inp_in,
&mut out_out,
tile_width_in_name.as_ptr(),
tile_width_in,
tile_height_in_name.as_ptr(),
tile_height_in,
max_tiles_in_name.as_ptr(),
max_tiles_in,
access_in_name.as_ptr(),
access_in,
threaded_in_name.as_ptr(),
threaded_in,
persistent_in_name.as_ptr(),
persistent_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TilecacheError,
)
}
}
pub fn linecache(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_linecache(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LinecacheError,
)
}
}
#[derive(Clone, Debug)]
pub struct LinecacheOptions {
pub tile_height: i32,
pub access: Access,
pub threaded: bool,
pub persistent: bool,
}
impl std::default::Default for LinecacheOptions {
fn default() -> Self {
LinecacheOptions {
tile_height: i32::from(128),
access: Access::Random,
threaded: false,
persistent: false,
}
}
}
pub fn linecache_with_opts(
inp: &VipsImage,
linecache_options: &LinecacheOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let tile_height_in: i32 = linecache_options.tile_height;
let tile_height_in_name = utils::new_c_string("tile-height")?;
let access_in: i32 = linecache_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let threaded_in: i32 = if linecache_options.threaded { 1 } else { 0 };
let threaded_in_name = utils::new_c_string("threaded")?;
let persistent_in: i32 = if linecache_options.persistent { 1 } else { 0 };
let persistent_in_name = utils::new_c_string("persistent")?;
let vips_op_response = bindings::vips_linecache(
inp_in,
&mut out_out,
tile_height_in_name.as_ptr(),
tile_height_in,
access_in_name.as_ptr(),
access_in,
threaded_in_name.as_ptr(),
threaded_in,
persistent_in_name.as_ptr(),
persistent_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LinecacheError,
)
}
}
pub fn sequential(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_sequential(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SequentialError,
)
}
}
#[derive(Clone, Debug)]
pub struct SequentialOptions {
pub tile_height: i32,
}
impl std::default::Default for SequentialOptions {
fn default() -> Self {
SequentialOptions {
tile_height: i32::from(1),
}
}
}
pub fn sequential_with_opts(
inp: &VipsImage,
sequential_options: &SequentialOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let tile_height_in: i32 = sequential_options.tile_height;
let tile_height_in_name = utils::new_c_string("tile-height")?;
let vips_op_response = bindings::vips_sequential(
inp_in,
&mut out_out,
tile_height_in_name.as_ptr(),
tile_height_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SequentialError,
)
}
}
pub fn cache(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_cache(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CacheError,
)
}
}
#[derive(Clone, Debug)]
pub struct CacheOptions {
pub max_tiles: i32,
pub tile_height: i32,
pub tile_width: i32,
}
impl std::default::Default for CacheOptions {
fn default() -> Self {
CacheOptions {
max_tiles: i32::from(1000),
tile_height: i32::from(128),
tile_width: i32::from(128),
}
}
}
pub fn cache_with_opts(inp: &VipsImage, cache_options: &CacheOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let max_tiles_in: i32 = cache_options.max_tiles;
let max_tiles_in_name = utils::new_c_string("max-tiles")?;
let tile_height_in: i32 = cache_options.tile_height;
let tile_height_in_name = utils::new_c_string("tile-height")?;
let tile_width_in: i32 = cache_options.tile_width;
let tile_width_in_name = utils::new_c_string("tile-width")?;
let vips_op_response = bindings::vips_cache(
inp_in,
&mut out_out,
max_tiles_in_name.as_ptr(),
max_tiles_in,
tile_height_in_name.as_ptr(),
tile_height_in,
tile_width_in_name.as_ptr(),
tile_width_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CacheError,
)
}
}
pub fn embed(inp: &VipsImage, x: i32, y: i32, width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let x_in: i32 = x;
let y_in: i32 = y;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_embed(inp_in, &mut out_out, x_in, y_in, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::EmbedError,
)
}
}
#[derive(Clone, Debug)]
pub struct EmbedOptions {
pub extend: Extend,
pub background: Vec<f64>,
}
impl std::default::Default for EmbedOptions {
fn default() -> Self {
EmbedOptions {
extend: Extend::Black,
background: Vec::new(),
}
}
}
pub fn embed_with_opts(
inp: &VipsImage,
x: i32,
y: i32,
width: i32,
height: i32,
embed_options: &EmbedOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let x_in: i32 = x;
let y_in: i32 = y;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let extend_in: i32 = embed_options.extend as i32;
let extend_in_name = utils::new_c_string("extend")?;
let background_wrapper = utils::VipsArrayDoubleWrapper::from(&embed_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_embed(
inp_in,
&mut out_out,
x_in,
y_in,
width_in,
height_in,
extend_in_name.as_ptr(),
extend_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::EmbedError,
)
}
}
pub fn gravity(
inp: &VipsImage,
direction: CompassDirection,
width: i32,
height: i32,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let direction_in: i32 = direction as i32;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_gravity(
inp_in,
&mut out_out,
direction_in.try_into().unwrap(),
width_in,
height_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GravityError,
)
}
}
#[derive(Clone, Debug)]
pub struct GravityOptions {
pub extend: Extend,
pub background: Vec<f64>,
}
impl std::default::Default for GravityOptions {
fn default() -> Self {
GravityOptions {
extend: Extend::Black,
background: Vec::new(),
}
}
}
pub fn gravity_with_opts(
inp: &VipsImage,
direction: CompassDirection,
width: i32,
height: i32,
gravity_options: &GravityOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let direction_in: i32 = direction as i32;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let extend_in: i32 = gravity_options.extend as i32;
let extend_in_name = utils::new_c_string("extend")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&gravity_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_gravity(
inp_in,
&mut out_out,
direction_in.try_into().unwrap(),
width_in,
height_in,
extend_in_name.as_ptr(),
extend_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GravityError,
)
}
}
pub fn flip(inp: &VipsImage, direction: Direction) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let direction_in: i32 = direction as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_flip(inp_in, &mut out_out, direction_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FlipError,
)
}
}
pub fn insert(main: &VipsImage, sub: &VipsImage, x: i32, y: i32) -> Result<VipsImage> {
unsafe {
let main_in: *mut bindings::VipsImage = main.ctx;
let sub_in: *mut bindings::VipsImage = sub.ctx;
let x_in: i32 = x;
let y_in: i32 = y;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_insert(main_in, sub_in, &mut out_out, x_in, y_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::InsertError,
)
}
}
#[derive(Clone, Debug)]
pub struct InsertOptions {
pub expand: bool,
pub background: Vec<f64>,
}
impl std::default::Default for InsertOptions {
fn default() -> Self {
InsertOptions {
expand: false,
background: Vec::new(),
}
}
}
pub fn insert_with_opts(
main: &VipsImage,
sub: &VipsImage,
x: i32,
y: i32,
insert_options: &InsertOptions,
) -> Result<VipsImage> {
unsafe {
let main_in: *mut bindings::VipsImage = main.ctx;
let sub_in: *mut bindings::VipsImage = sub.ctx;
let x_in: i32 = x;
let y_in: i32 = y;
let mut out_out: *mut bindings::VipsImage = null_mut();
let expand_in: i32 = if insert_options.expand { 1 } else { 0 };
let expand_in_name = utils::new_c_string("expand")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&insert_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_insert(
main_in,
sub_in,
&mut out_out,
x_in,
y_in,
expand_in_name.as_ptr(),
expand_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::InsertError,
)
}
}
pub fn join(in_1: &VipsImage, in_2: &VipsImage, direction: Direction) -> Result<VipsImage> {
unsafe {
let in_1_in: *mut bindings::VipsImage = in_1.ctx;
let in_2_in: *mut bindings::VipsImage = in_2.ctx;
let direction_in: i32 = direction as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_join(
in_1_in,
in_2_in,
&mut out_out,
direction_in.try_into().unwrap(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::JoinError,
)
}
}
#[derive(Clone, Debug)]
pub struct JoinOptions {
pub expand: bool,
pub shim: i32,
pub background: Vec<f64>,
pub align: Align,
}
impl std::default::Default for JoinOptions {
fn default() -> Self {
JoinOptions {
expand: false,
shim: i32::from(0),
background: Vec::new(),
align: Align::Low,
}
}
}
pub fn join_with_opts(
in_1: &VipsImage,
in_2: &VipsImage,
direction: Direction,
join_options: &JoinOptions,
) -> Result<VipsImage> {
unsafe {
let in_1_in: *mut bindings::VipsImage = in_1.ctx;
let in_2_in: *mut bindings::VipsImage = in_2.ctx;
let direction_in: i32 = direction as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let expand_in: i32 = if join_options.expand { 1 } else { 0 };
let expand_in_name = utils::new_c_string("expand")?;
let shim_in: i32 = join_options.shim;
let shim_in_name = utils::new_c_string("shim")?;
let background_wrapper = utils::VipsArrayDoubleWrapper::from(&join_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let align_in: i32 = join_options.align as i32;
let align_in_name = utils::new_c_string("align")?;
let vips_op_response = bindings::vips_join(
in_1_in,
in_2_in,
&mut out_out,
direction_in.try_into().unwrap(),
expand_in_name.as_ptr(),
expand_in,
shim_in_name.as_ptr(),
shim_in,
background_in_name.as_ptr(),
background_in,
align_in_name.as_ptr(),
align_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::JoinError,
)
}
}
pub fn arrayjoin(inp: &mut [VipsImage]) -> Result<VipsImage> {
unsafe {
let inp_in: *mut *mut bindings::VipsImage =
inp.iter().map(|v| v.ctx).collect::<Vec<_>>().as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_arrayjoin(inp_in, &mut out_out, inp.len() as i32, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ArrayjoinError,
)
}
}
#[derive(Clone, Debug)]
pub struct ArrayjoinOptions {
pub across: i32,
pub shim: i32,
pub background: Vec<f64>,
pub halign: Align,
pub valign: Align,
pub hspacing: i32,
pub vspacing: i32,
}
impl std::default::Default for ArrayjoinOptions {
fn default() -> Self {
ArrayjoinOptions {
across: i32::from(1),
shim: i32::from(0),
background: Vec::new(),
halign: Align::Low,
valign: Align::Low,
hspacing: i32::from(1),
vspacing: i32::from(1),
}
}
}
pub fn arrayjoin_with_opts(
inp: &mut [VipsImage],
arrayjoin_options: &ArrayjoinOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut *mut bindings::VipsImage =
inp.iter().map(|v| v.ctx).collect::<Vec<_>>().as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let across_in: i32 = arrayjoin_options.across;
let across_in_name = utils::new_c_string("across")?;
let shim_in: i32 = arrayjoin_options.shim;
let shim_in_name = utils::new_c_string("shim")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&arrayjoin_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let halign_in: i32 = arrayjoin_options.halign as i32;
let halign_in_name = utils::new_c_string("halign")?;
let valign_in: i32 = arrayjoin_options.valign as i32;
let valign_in_name = utils::new_c_string("valign")?;
let hspacing_in: i32 = arrayjoin_options.hspacing;
let hspacing_in_name = utils::new_c_string("hspacing")?;
let vspacing_in: i32 = arrayjoin_options.vspacing;
let vspacing_in_name = utils::new_c_string("vspacing")?;
let vips_op_response = bindings::vips_arrayjoin(
inp_in,
&mut out_out,
inp.len() as i32,
across_in_name.as_ptr(),
across_in,
shim_in_name.as_ptr(),
shim_in,
background_in_name.as_ptr(),
background_in,
halign_in_name.as_ptr(),
halign_in,
valign_in_name.as_ptr(),
valign_in,
hspacing_in_name.as_ptr(),
hspacing_in,
vspacing_in_name.as_ptr(),
vspacing_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ArrayjoinError,
)
}
}
pub fn extract_area(
input: &VipsImage,
left: i32,
top: i32,
width: i32,
height: i32,
) -> Result<VipsImage> {
unsafe {
let input_in: *mut bindings::VipsImage = input.ctx;
let left_in: i32 = left;
let top_in: i32 = top;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_extract_area(
input_in,
&mut out_out,
left_in,
top_in,
width_in,
height_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ExtractAreaError,
)
}
}
pub fn smartcrop(input: &VipsImage, width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let input_in: *mut bindings::VipsImage = input.ctx;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_smartcrop(input_in, &mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SmartcropError,
)
}
}
#[derive(Clone, Debug)]
pub struct SmartcropOptions {
pub interesting: Interesting,
}
impl std::default::Default for SmartcropOptions {
fn default() -> Self {
SmartcropOptions {
interesting: Interesting::Attention,
}
}
}
pub fn smartcrop_with_opts(
input: &VipsImage,
width: i32,
height: i32,
smartcrop_options: &SmartcropOptions,
) -> Result<VipsImage> {
unsafe {
let input_in: *mut bindings::VipsImage = input.ctx;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let interesting_in: i32 = smartcrop_options.interesting as i32;
let interesting_in_name = utils::new_c_string("interesting")?;
let vips_op_response = bindings::vips_smartcrop(
input_in,
&mut out_out,
width_in,
height_in,
interesting_in_name.as_ptr(),
interesting_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SmartcropError,
)
}
}
pub fn extract_band(inp: &VipsImage, band: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let band_in: i32 = band;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_extract_band(inp_in, &mut out_out, band_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ExtractBandError,
)
}
}
#[derive(Clone, Debug)]
pub struct ExtractBandOptions {
pub n: i32,
}
impl std::default::Default for ExtractBandOptions {
fn default() -> Self {
ExtractBandOptions { n: i32::from(1) }
}
}
pub fn extract_band_with_opts(
inp: &VipsImage,
band: i32,
extract_band_options: &ExtractBandOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let band_in: i32 = band;
let mut out_out: *mut bindings::VipsImage = null_mut();
let n_in: i32 = extract_band_options.n;
let n_in_name = utils::new_c_string("n")?;
let vips_op_response = bindings::vips_extract_band(
inp_in,
&mut out_out,
band_in,
n_in_name.as_ptr(),
n_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ExtractBandError,
)
}
}
pub fn bandjoin(inp: &mut [VipsImage]) -> Result<VipsImage> {
unsafe {
let inp_in: *mut *mut bindings::VipsImage =
inp.iter().map(|v| v.ctx).collect::<Vec<_>>().as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_bandjoin(inp_in, &mut out_out, inp.len() as i32, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandjoinError,
)
}
}
pub fn bandjoin_const(inp: &VipsImage, c: &mut [f64]) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let c_in: *mut f64 = c.as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_bandjoin_const(inp_in, &mut out_out, c_in, c.len() as i32, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandjoinConstError,
)
}
}
pub fn bandrank(inp: &mut [VipsImage]) -> Result<VipsImage> {
unsafe {
let inp_in: *mut *mut bindings::VipsImage =
inp.iter().map(|v| v.ctx).collect::<Vec<_>>().as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_bandrank(inp_in, &mut out_out, inp.len() as i32, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandrankError,
)
}
}
#[derive(Clone, Debug)]
pub struct BandrankOptions {
pub index: i32,
}
impl std::default::Default for BandrankOptions {
fn default() -> Self {
BandrankOptions {
index: i32::from(-1),
}
}
}
pub fn bandrank_with_opts(
inp: &mut [VipsImage],
bandrank_options: &BandrankOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut *mut bindings::VipsImage =
inp.iter().map(|v| v.ctx).collect::<Vec<_>>().as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let index_in: i32 = bandrank_options.index;
let index_in_name = utils::new_c_string("index")?;
let vips_op_response = bindings::vips_bandrank(
inp_in,
&mut out_out,
inp.len() as i32,
index_in_name.as_ptr(),
index_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandrankError,
)
}
}
pub fn bandmean(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_bandmean(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandmeanError,
)
}
}
pub fn bandbool(inp: &VipsImage, boolean: OperationBoolean) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let boolean_in: i32 = boolean as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_bandbool(inp_in, &mut out_out, boolean_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandboolError,
)
}
}
pub fn replicate(inp: &VipsImage, across: i32, down: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let across_in: i32 = across;
let down_in: i32 = down;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_replicate(inp_in, &mut out_out, across_in, down_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ReplicateError,
)
}
}
pub fn cast(inp: &VipsImage, format: BandFormat) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let format_in: i32 = format as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_cast(inp_in, &mut out_out, format_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CastError,
)
}
}
#[derive(Clone, Debug)]
pub struct CastOptions {
pub shift: bool,
}
impl std::default::Default for CastOptions {
fn default() -> Self {
CastOptions { shift: false }
}
}
pub fn cast_with_opts(
inp: &VipsImage,
format: BandFormat,
cast_options: &CastOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let format_in: i32 = format as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let shift_in: i32 = if cast_options.shift { 1 } else { 0 };
let shift_in_name = utils::new_c_string("shift")?;
let vips_op_response = bindings::vips_cast(
inp_in,
&mut out_out,
format_in.try_into().unwrap(),
shift_in_name.as_ptr(),
shift_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CastError,
)
}
}
pub fn rot(inp: &VipsImage, angle: Angle) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let angle_in: i32 = angle as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_rot(inp_in, &mut out_out, angle_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RotError,
)
}
}
pub fn rot_45(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_rot45(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Rot45Error,
)
}
}
#[derive(Clone, Debug)]
pub struct Rot45Options {
pub angle: Angle45,
}
impl std::default::Default for Rot45Options {
fn default() -> Self {
Rot45Options {
angle: Angle45::D45,
}
}
}
pub fn rot_45_with_opts(inp: &VipsImage, rot_45_options: &Rot45Options) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let angle_in: i32 = rot_45_options.angle as i32;
let angle_in_name = utils::new_c_string("angle")?;
let vips_op_response =
bindings::vips_rot45(inp_in, &mut out_out, angle_in_name.as_ptr(), angle_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Rot45Error,
)
}
}
pub fn autorot(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_autorot(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::AutorotError,
)
}
}
#[derive(Clone, Debug)]
pub struct AutorotOptions {
pub angle: Angle,
}
impl std::default::Default for AutorotOptions {
fn default() -> Self {
AutorotOptions { angle: Angle::D0 }
}
}
pub fn autorot_with_opts(inp: &VipsImage, autorot_options: &AutorotOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let angle_in: i32 = autorot_options.angle as i32;
let angle_in_name = utils::new_c_string("angle")?;
let vips_op_response =
bindings::vips_autorot(inp_in, &mut out_out, angle_in_name.as_ptr(), angle_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::AutorotError,
)
}
}
pub fn ifthenelse(cond: &VipsImage, in_1: &VipsImage, in_2: &VipsImage) -> Result<VipsImage> {
unsafe {
let cond_in: *mut bindings::VipsImage = cond.ctx;
let in_1_in: *mut bindings::VipsImage = in_1.ctx;
let in_2_in: *mut bindings::VipsImage = in_2.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_ifthenelse(cond_in, in_1_in, in_2_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IfthenelseError,
)
}
}
#[derive(Clone, Debug)]
pub struct IfthenelseOptions {
pub blend: bool,
}
impl std::default::Default for IfthenelseOptions {
fn default() -> Self {
IfthenelseOptions { blend: false }
}
}
pub fn ifthenelse_with_opts(
cond: &VipsImage,
in_1: &VipsImage,
in_2: &VipsImage,
ifthenelse_options: &IfthenelseOptions,
) -> Result<VipsImage> {
unsafe {
let cond_in: *mut bindings::VipsImage = cond.ctx;
let in_1_in: *mut bindings::VipsImage = in_1.ctx;
let in_2_in: *mut bindings::VipsImage = in_2.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let blend_in: i32 = if ifthenelse_options.blend { 1 } else { 0 };
let blend_in_name = utils::new_c_string("blend")?;
let vips_op_response = bindings::vips_ifthenelse(
cond_in,
in_1_in,
in_2_in,
&mut out_out,
blend_in_name.as_ptr(),
blend_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IfthenelseError,
)
}
}
pub fn recomb(inp: &VipsImage, m: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let m_in: *mut bindings::VipsImage = m.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_recomb(inp_in, &mut out_out, m_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RecombError,
)
}
}
pub fn bandfold(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_bandfold(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandfoldError,
)
}
}
#[derive(Clone, Debug)]
pub struct BandfoldOptions {
pub factor: i32,
}
impl std::default::Default for BandfoldOptions {
fn default() -> Self {
BandfoldOptions {
factor: i32::from(0),
}
}
}
pub fn bandfold_with_opts(
inp: &VipsImage,
bandfold_options: &BandfoldOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let factor_in: i32 = bandfold_options.factor;
let factor_in_name = utils::new_c_string("factor")?;
let vips_op_response = bindings::vips_bandfold(
inp_in,
&mut out_out,
factor_in_name.as_ptr(),
factor_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandfoldError,
)
}
}
pub fn bandunfold(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_bandunfold(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandunfoldError,
)
}
}
#[derive(Clone, Debug)]
pub struct BandunfoldOptions {
pub factor: i32,
}
impl std::default::Default for BandunfoldOptions {
fn default() -> Self {
BandunfoldOptions {
factor: i32::from(0),
}
}
}
pub fn bandunfold_with_opts(
inp: &VipsImage,
bandunfold_options: &BandunfoldOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let factor_in: i32 = bandunfold_options.factor;
let factor_in_name = utils::new_c_string("factor")?;
let vips_op_response = bindings::vips_bandunfold(
inp_in,
&mut out_out,
factor_in_name.as_ptr(),
factor_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BandunfoldError,
)
}
}
pub fn flatten(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_flatten(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FlattenError,
)
}
}
#[derive(Clone, Debug)]
pub struct FlattenOptions {
pub background: Vec<f64>,
pub max_alpha: f64,
}
impl std::default::Default for FlattenOptions {
fn default() -> Self {
FlattenOptions {
background: Vec::new(),
max_alpha: f64::from(255),
}
}
}
pub fn flatten_with_opts(inp: &VipsImage, flatten_options: &FlattenOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&flatten_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let max_alpha_in: f64 = flatten_options.max_alpha;
let max_alpha_in_name = utils::new_c_string("max-alpha")?;
let vips_op_response = bindings::vips_flatten(
inp_in,
&mut out_out,
background_in_name.as_ptr(),
background_in,
max_alpha_in_name.as_ptr(),
max_alpha_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FlattenError,
)
}
}
pub fn premultiply(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_premultiply(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PremultiplyError,
)
}
}
#[derive(Clone, Debug)]
pub struct PremultiplyOptions {
pub max_alpha: f64,
}
impl std::default::Default for PremultiplyOptions {
fn default() -> Self {
PremultiplyOptions {
max_alpha: f64::from(255),
}
}
}
pub fn premultiply_with_opts(
inp: &VipsImage,
premultiply_options: &PremultiplyOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let max_alpha_in: f64 = premultiply_options.max_alpha;
let max_alpha_in_name = utils::new_c_string("max-alpha")?;
let vips_op_response = bindings::vips_premultiply(
inp_in,
&mut out_out,
max_alpha_in_name.as_ptr(),
max_alpha_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PremultiplyError,
)
}
}
pub fn unpremultiply(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_unpremultiply(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::UnpremultiplyError,
)
}
}
#[derive(Clone, Debug)]
pub struct UnpremultiplyOptions {
pub max_alpha: f64,
}
impl std::default::Default for UnpremultiplyOptions {
fn default() -> Self {
UnpremultiplyOptions {
max_alpha: f64::from(255),
}
}
}
pub fn unpremultiply_with_opts(
inp: &VipsImage,
unpremultiply_options: &UnpremultiplyOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let max_alpha_in: f64 = unpremultiply_options.max_alpha;
let max_alpha_in_name = utils::new_c_string("max-alpha")?;
let vips_op_response = bindings::vips_unpremultiply(
inp_in,
&mut out_out,
max_alpha_in_name.as_ptr(),
max_alpha_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::UnpremultiplyError,
)
}
}
pub fn grid(inp: &VipsImage, tile_height: i32, across: i32, down: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let tile_height_in: i32 = tile_height;
let across_in: i32 = across;
let down_in: i32 = down;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_grid(
inp_in,
&mut out_out,
tile_height_in,
across_in,
down_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GridError,
)
}
}
pub fn transpose_3d(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_transpose3d(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Transpose3DError,
)
}
}
#[derive(Clone, Debug)]
pub struct Transpose3DOptions {
pub page_height: i32,
}
impl std::default::Default for Transpose3DOptions {
fn default() -> Self {
Transpose3DOptions {
page_height: i32::from(0),
}
}
}
pub fn transpose_3d_with_opts(
inp: &VipsImage,
transpose_3d_options: &Transpose3DOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_height_in: i32 = transpose_3d_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let vips_op_response = bindings::vips_transpose3d(
inp_in,
&mut out_out,
page_height_in_name.as_ptr(),
page_height_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Transpose3DError,
)
}
}
pub fn scale(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_scale(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ScaleError,
)
}
}
#[derive(Clone, Debug)]
pub struct ScaleOptions {
pub exp: f64,
pub log: bool,
}
impl std::default::Default for ScaleOptions {
fn default() -> Self {
ScaleOptions {
exp: f64::from(0.25),
log: false,
}
}
}
pub fn scale_with_opts(inp: &VipsImage, scale_options: &ScaleOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let exp_in: f64 = scale_options.exp;
let exp_in_name = utils::new_c_string("exp")?;
let log_in: i32 = if scale_options.log { 1 } else { 0 };
let log_in_name = utils::new_c_string("log")?;
let vips_op_response = bindings::vips_scale(
inp_in,
&mut out_out,
exp_in_name.as_ptr(),
exp_in,
log_in_name.as_ptr(),
log_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ScaleError,
)
}
}
pub fn wrap(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_wrap(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::WrapError,
)
}
}
#[derive(Clone, Debug)]
pub struct WrapOptions {
pub x: i32,
pub y: i32,
}
impl std::default::Default for WrapOptions {
fn default() -> Self {
WrapOptions {
x: i32::from(0),
y: i32::from(0),
}
}
}
pub fn wrap_with_opts(inp: &VipsImage, wrap_options: &WrapOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let x_in: i32 = wrap_options.x;
let x_in_name = utils::new_c_string("x")?;
let y_in: i32 = wrap_options.y;
let y_in_name = utils::new_c_string("y")?;
let vips_op_response = bindings::vips_wrap(
inp_in,
&mut out_out,
x_in_name.as_ptr(),
x_in,
y_in_name.as_ptr(),
y_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::WrapError,
)
}
}
pub fn zoom(input: &VipsImage, xfac: i32, yfac: i32) -> Result<VipsImage> {
unsafe {
let input_in: *mut bindings::VipsImage = input.ctx;
let xfac_in: i32 = xfac;
let yfac_in: i32 = yfac;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_zoom(input_in, &mut out_out, xfac_in, yfac_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ZoomError,
)
}
}
pub fn subsample(input: &VipsImage, xfac: i32, yfac: i32) -> Result<VipsImage> {
unsafe {
let input_in: *mut bindings::VipsImage = input.ctx;
let xfac_in: i32 = xfac;
let yfac_in: i32 = yfac;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_subsample(input_in, &mut out_out, xfac_in, yfac_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SubsampleError,
)
}
}
#[derive(Clone, Debug)]
pub struct SubsampleOptions {
pub point: bool,
}
impl std::default::Default for SubsampleOptions {
fn default() -> Self {
SubsampleOptions { point: false }
}
}
pub fn subsample_with_opts(
input: &VipsImage,
xfac: i32,
yfac: i32,
subsample_options: &SubsampleOptions,
) -> Result<VipsImage> {
unsafe {
let input_in: *mut bindings::VipsImage = input.ctx;
let xfac_in: i32 = xfac;
let yfac_in: i32 = yfac;
let mut out_out: *mut bindings::VipsImage = null_mut();
let point_in: i32 = if subsample_options.point { 1 } else { 0 };
let point_in_name = utils::new_c_string("point")?;
let vips_op_response = bindings::vips_subsample(
input_in,
&mut out_out,
xfac_in,
yfac_in,
point_in_name.as_ptr(),
point_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SubsampleError,
)
}
}
pub fn msb(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_msb(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MsbError,
)
}
}
#[derive(Clone, Debug)]
pub struct MsbOptions {
pub band: i32,
}
impl std::default::Default for MsbOptions {
fn default() -> Self {
MsbOptions { band: i32::from(0) }
}
}
pub fn msb_with_opts(inp: &VipsImage, msb_options: &MsbOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let band_in: i32 = msb_options.band;
let band_in_name = utils::new_c_string("band")?;
let vips_op_response =
bindings::vips_msb(inp_in, &mut out_out, band_in_name.as_ptr(), band_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MsbError,
)
}
}
pub fn byteswap(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_byteswap(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ByteswapError,
)
}
}
pub fn falsecolour(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_falsecolour(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FalsecolourError,
)
}
}
pub fn gamma(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_gamma(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GammaError,
)
}
}
#[derive(Clone, Debug)]
pub struct GammaOptions {
pub exponent: f64,
}
impl std::default::Default for GammaOptions {
fn default() -> Self {
GammaOptions {
exponent: f64::from(2.4),
}
}
}
pub fn gamma_with_opts(inp: &VipsImage, gamma_options: &GammaOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let exponent_in: f64 = gamma_options.exponent;
let exponent_in_name = utils::new_c_string("exponent")?;
let vips_op_response = bindings::vips_gamma(
inp_in,
&mut out_out,
exponent_in_name.as_ptr(),
exponent_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GammaError,
)
}
}
pub fn composite(inp: &mut [VipsImage], mode: &mut [i32]) -> Result<VipsImage> {
unsafe {
let inp_in: *mut *mut bindings::VipsImage =
inp.iter().map(|v| v.ctx).collect::<Vec<_>>().as_mut_ptr();
let mode_in: *mut i32 = mode.as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_composite(
inp_in,
&mut out_out,
inp.len() as i32,
mode_in,
mode.len() as i32,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CompositeError,
)
}
}
#[derive(Clone, Debug)]
pub struct CompositeOptions {
pub x: Vec<i32>,
pub y: Vec<i32>,
pub compositing_space: Interpretation,
pub premultiplied: bool,
}
impl std::default::Default for CompositeOptions {
fn default() -> Self {
CompositeOptions {
x: Vec::new(),
y: Vec::new(),
compositing_space: Interpretation::Srgb,
premultiplied: false,
}
}
}
pub fn composite_with_opts(
inp: &mut [VipsImage],
mode: &mut [i32],
composite_options: &CompositeOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut *mut bindings::VipsImage =
inp.iter().map(|v| v.ctx).collect::<Vec<_>>().as_mut_ptr();
let mode_in: *mut i32 = mode.as_mut_ptr();
let mut out_out: *mut bindings::VipsImage = null_mut();
let x_wrapper = utils::VipsArrayIntWrapper::from(&composite_options.x[..]);
let x_in = x_wrapper.ctx;
let x_in_name = utils::new_c_string("x")?;
let y_wrapper = utils::VipsArrayIntWrapper::from(&composite_options.y[..]);
let y_in = y_wrapper.ctx;
let y_in_name = utils::new_c_string("y")?;
let compositing_space_in: i32 = composite_options.compositing_space as i32;
let compositing_space_in_name = utils::new_c_string("compositing-space")?;
let premultiplied_in: i32 = if composite_options.premultiplied {
1
} else {
0
};
let premultiplied_in_name = utils::new_c_string("premultiplied")?;
let vips_op_response = bindings::vips_composite(
inp_in,
&mut out_out,
inp.len() as i32,
mode_in,
mode.len() as i32,
x_in_name.as_ptr(),
x_in,
y_in_name.as_ptr(),
y_in,
compositing_space_in_name.as_ptr(),
compositing_space_in,
premultiplied_in_name.as_ptr(),
premultiplied_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CompositeError,
)
}
}
pub fn composite_2(base: &VipsImage, overlay: &VipsImage, mode: BlendMode) -> Result<VipsImage> {
unsafe {
let base_in: *mut bindings::VipsImage = base.ctx;
let overlay_in: *mut bindings::VipsImage = overlay.ctx;
let mode_in: i32 = mode as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_composite2(
base_in,
overlay_in,
&mut out_out,
mode_in.try_into().unwrap(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Composite2Error,
)
}
}
#[derive(Clone, Debug)]
pub struct Composite2Options {
pub x: i32,
pub y: i32,
pub compositing_space: Interpretation,
pub premultiplied: bool,
}
impl std::default::Default for Composite2Options {
fn default() -> Self {
Composite2Options {
x: i32::from(0),
y: i32::from(0),
compositing_space: Interpretation::Srgb,
premultiplied: false,
}
}
}
pub fn composite_2_with_opts(
base: &VipsImage,
overlay: &VipsImage,
mode: BlendMode,
composite_2_options: &Composite2Options,
) -> Result<VipsImage> {
unsafe {
let base_in: *mut bindings::VipsImage = base.ctx;
let overlay_in: *mut bindings::VipsImage = overlay.ctx;
let mode_in: i32 = mode as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let x_in: i32 = composite_2_options.x;
let x_in_name = utils::new_c_string("x")?;
let y_in: i32 = composite_2_options.y;
let y_in_name = utils::new_c_string("y")?;
let compositing_space_in: i32 = composite_2_options.compositing_space as i32;
let compositing_space_in_name = utils::new_c_string("compositing-space")?;
let premultiplied_in: i32 = if composite_2_options.premultiplied {
1
} else {
0
};
let premultiplied_in_name = utils::new_c_string("premultiplied")?;
let vips_op_response = bindings::vips_composite2(
base_in,
overlay_in,
&mut out_out,
mode_in.try_into().unwrap(),
x_in_name.as_ptr(),
x_in,
y_in_name.as_ptr(),
y_in,
compositing_space_in_name.as_ptr(),
compositing_space_in,
premultiplied_in_name.as_ptr(),
premultiplied_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Composite2Error,
)
}
}
pub fn black(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_black(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BlackError,
)
}
}
#[derive(Clone, Debug)]
pub struct BlackOptions {
pub bands: i32,
}
impl std::default::Default for BlackOptions {
fn default() -> Self {
BlackOptions {
bands: i32::from(1),
}
}
}
pub fn black_with_opts(width: i32, height: i32, black_options: &BlackOptions) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let bands_in: i32 = black_options.bands;
let bands_in_name = utils::new_c_string("bands")?;
let vips_op_response = bindings::vips_black(
&mut out_out,
width_in,
height_in,
bands_in_name.as_ptr(),
bands_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BlackError,
)
}
}
pub fn gaussnoise(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_gaussnoise(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GaussnoiseError,
)
}
}
#[derive(Clone, Debug)]
pub struct GaussnoiseOptions {
pub sigma: f64,
pub mean: f64,
}
impl std::default::Default for GaussnoiseOptions {
fn default() -> Self {
GaussnoiseOptions {
sigma: f64::from(30),
mean: f64::from(128),
}
}
}
pub fn gaussnoise_with_opts(
width: i32,
height: i32,
gaussnoise_options: &GaussnoiseOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let sigma_in: f64 = gaussnoise_options.sigma;
let sigma_in_name = utils::new_c_string("sigma")?;
let mean_in: f64 = gaussnoise_options.mean;
let mean_in_name = utils::new_c_string("mean")?;
let vips_op_response = bindings::vips_gaussnoise(
&mut out_out,
width_in,
height_in,
sigma_in_name.as_ptr(),
sigma_in,
mean_in_name.as_ptr(),
mean_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GaussnoiseError,
)
}
}
pub fn text(text: &str) -> Result<VipsImage> {
unsafe {
let text_in: CString = utils::new_c_string(text)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_text(&mut out_out, text_in.as_ptr(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TextError,
)
}
}
#[derive(Clone, Debug)]
pub struct TextOptions {
pub font: String,
pub width: i32,
pub height: i32,
pub align: Align,
pub dpi: i32,
pub justify: bool,
pub autofit_dpi: i32,
pub spacing: i32,
pub fontfile: String,
}
impl std::default::Default for TextOptions {
fn default() -> Self {
TextOptions {
font: String::new(),
width: i32::from(0),
height: i32::from(0),
align: Align::Low,
dpi: i32::from(72),
justify: false,
autofit_dpi: i32::from(72),
spacing: i32::from(0),
fontfile: String::new(),
}
}
}
pub fn text_with_opts(text: &str, text_options: &TextOptions) -> Result<VipsImage> {
unsafe {
let text_in: CString = utils::new_c_string(text)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let font_in: CString = utils::new_c_string(&text_options.font)?;
let font_in_name = utils::new_c_string("font")?;
let width_in: i32 = text_options.width;
let width_in_name = utils::new_c_string("width")?;
let height_in: i32 = text_options.height;
let height_in_name = utils::new_c_string("height")?;
let align_in: i32 = text_options.align as i32;
let align_in_name = utils::new_c_string("align")?;
let dpi_in: i32 = text_options.dpi;
let dpi_in_name = utils::new_c_string("dpi")?;
let justify_in: i32 = if text_options.justify { 1 } else { 0 };
let justify_in_name = utils::new_c_string("justify")?;
let autofit_dpi_in: i32 = text_options.autofit_dpi;
let autofit_dpi_in_name = utils::new_c_string("autofit-dpi")?;
let spacing_in: i32 = text_options.spacing;
let spacing_in_name = utils::new_c_string("spacing")?;
let fontfile_in: CString = utils::new_c_string(&text_options.fontfile)?;
let fontfile_in_name = utils::new_c_string("fontfile")?;
let vips_op_response = bindings::vips_text(
&mut out_out,
text_in.as_ptr(),
font_in_name.as_ptr(),
font_in.as_ptr(),
width_in_name.as_ptr(),
width_in,
height_in_name.as_ptr(),
height_in,
align_in_name.as_ptr(),
align_in,
dpi_in_name.as_ptr(),
dpi_in,
justify_in_name.as_ptr(),
justify_in,
autofit_dpi_in_name.as_ptr(),
autofit_dpi_in,
spacing_in_name.as_ptr(),
spacing_in,
fontfile_in_name.as_ptr(),
fontfile_in.as_ptr(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TextError,
)
}
}
pub fn xyz(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_xyz(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::XyzError,
)
}
}
#[derive(Clone, Debug)]
pub struct XyzOptions {
pub csize: i32,
pub dsize: i32,
pub esize: i32,
}
impl std::default::Default for XyzOptions {
fn default() -> Self {
XyzOptions {
csize: i32::from(1),
dsize: i32::from(1),
esize: i32::from(1),
}
}
}
pub fn xyz_with_opts(width: i32, height: i32, xyz_options: &XyzOptions) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let csize_in: i32 = xyz_options.csize;
let csize_in_name = utils::new_c_string("csize")?;
let dsize_in: i32 = xyz_options.dsize;
let dsize_in_name = utils::new_c_string("dsize")?;
let esize_in: i32 = xyz_options.esize;
let esize_in_name = utils::new_c_string("esize")?;
let vips_op_response = bindings::vips_xyz(
&mut out_out,
width_in,
height_in,
csize_in_name.as_ptr(),
csize_in,
dsize_in_name.as_ptr(),
dsize_in,
esize_in_name.as_ptr(),
esize_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::XyzError,
)
}
}
pub fn gaussmat(sigma: f64, min_ampl: f64) -> Result<VipsImage> {
unsafe {
let sigma_in: f64 = sigma;
let min_ampl_in: f64 = min_ampl;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_gaussmat(&mut out_out, sigma_in, min_ampl_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GaussmatError,
)
}
}
#[derive(Clone, Debug)]
pub struct GaussmatOptions {
pub separable: bool,
pub precision: Precision,
}
impl std::default::Default for GaussmatOptions {
fn default() -> Self {
GaussmatOptions {
separable: false,
precision: Precision::Integer,
}
}
}
pub fn gaussmat_with_opts(
sigma: f64,
min_ampl: f64,
gaussmat_options: &GaussmatOptions,
) -> Result<VipsImage> {
unsafe {
let sigma_in: f64 = sigma;
let min_ampl_in: f64 = min_ampl;
let mut out_out: *mut bindings::VipsImage = null_mut();
let separable_in: i32 = if gaussmat_options.separable { 1 } else { 0 };
let separable_in_name = utils::new_c_string("separable")?;
let precision_in: i32 = gaussmat_options.precision as i32;
let precision_in_name = utils::new_c_string("precision")?;
let vips_op_response = bindings::vips_gaussmat(
&mut out_out,
sigma_in,
min_ampl_in,
separable_in_name.as_ptr(),
separable_in,
precision_in_name.as_ptr(),
precision_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GaussmatError,
)
}
}
pub fn logmat(sigma: f64, min_ampl: f64) -> Result<VipsImage> {
unsafe {
let sigma_in: f64 = sigma;
let min_ampl_in: f64 = min_ampl;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_logmat(&mut out_out, sigma_in, min_ampl_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LogmatError,
)
}
}
#[derive(Clone, Debug)]
pub struct LogmatOptions {
pub separable: bool,
pub precision: Precision,
}
impl std::default::Default for LogmatOptions {
fn default() -> Self {
LogmatOptions {
separable: false,
precision: Precision::Integer,
}
}
}
pub fn logmat_with_opts(
sigma: f64,
min_ampl: f64,
logmat_options: &LogmatOptions,
) -> Result<VipsImage> {
unsafe {
let sigma_in: f64 = sigma;
let min_ampl_in: f64 = min_ampl;
let mut out_out: *mut bindings::VipsImage = null_mut();
let separable_in: i32 = if logmat_options.separable { 1 } else { 0 };
let separable_in_name = utils::new_c_string("separable")?;
let precision_in: i32 = logmat_options.precision as i32;
let precision_in_name = utils::new_c_string("precision")?;
let vips_op_response = bindings::vips_logmat(
&mut out_out,
sigma_in,
min_ampl_in,
separable_in_name.as_ptr(),
separable_in,
precision_in_name.as_ptr(),
precision_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LogmatError,
)
}
}
pub fn eye(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_eye(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::EyeError,
)
}
}
#[derive(Clone, Debug)]
pub struct EyeOptions {
pub uchar: bool,
pub factor: f64,
}
impl std::default::Default for EyeOptions {
fn default() -> Self {
EyeOptions {
uchar: false,
factor: f64::from(0.5),
}
}
}
pub fn eye_with_opts(width: i32, height: i32, eye_options: &EyeOptions) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if eye_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let factor_in: f64 = eye_options.factor;
let factor_in_name = utils::new_c_string("factor")?;
let vips_op_response = bindings::vips_eye(
&mut out_out,
width_in,
height_in,
uchar_in_name.as_ptr(),
uchar_in,
factor_in_name.as_ptr(),
factor_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::EyeError,
)
}
}
pub fn grey(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_grey(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GreyError,
)
}
}
#[derive(Clone, Debug)]
pub struct GreyOptions {
pub uchar: bool,
}
impl std::default::Default for GreyOptions {
fn default() -> Self {
GreyOptions { uchar: false }
}
}
pub fn grey_with_opts(width: i32, height: i32, grey_options: &GreyOptions) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if grey_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let vips_op_response = bindings::vips_grey(
&mut out_out,
width_in,
height_in,
uchar_in_name.as_ptr(),
uchar_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GreyError,
)
}
}
pub fn zone(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_zone(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ZoneError,
)
}
}
#[derive(Clone, Debug)]
pub struct ZoneOptions {
pub uchar: bool,
}
impl std::default::Default for ZoneOptions {
fn default() -> Self {
ZoneOptions { uchar: false }
}
}
pub fn zone_with_opts(width: i32, height: i32, zone_options: &ZoneOptions) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if zone_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let vips_op_response = bindings::vips_zone(
&mut out_out,
width_in,
height_in,
uchar_in_name.as_ptr(),
uchar_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ZoneError,
)
}
}
pub fn sines(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_sines(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SineError,
)
}
}
#[derive(Clone, Debug)]
pub struct SineOptions {
pub uchar: bool,
pub hfreq: f64,
pub vfreq: f64,
}
impl std::default::Default for SineOptions {
fn default() -> Self {
SineOptions {
uchar: false,
hfreq: f64::from(0.5),
vfreq: f64::from(0.5),
}
}
}
pub fn sines_with_opts(width: i32, height: i32, sines_options: &SineOptions) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if sines_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let hfreq_in: f64 = sines_options.hfreq;
let hfreq_in_name = utils::new_c_string("hfreq")?;
let vfreq_in: f64 = sines_options.vfreq;
let vfreq_in_name = utils::new_c_string("vfreq")?;
let vips_op_response = bindings::vips_sines(
&mut out_out,
width_in,
height_in,
uchar_in_name.as_ptr(),
uchar_in,
hfreq_in_name.as_ptr(),
hfreq_in,
vfreq_in_name.as_ptr(),
vfreq_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SineError,
)
}
}
pub fn mask_ideal(width: i32, height: i32, frequency_cutoff: f64) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_in: f64 = frequency_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_mask_ideal(&mut out_out, width_in, height_in, frequency_cutoff_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskIdealError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskIdealOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskIdealOptions {
fn default() -> Self {
MaskIdealOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_ideal_with_opts(
width: i32,
height: i32,
frequency_cutoff: f64,
mask_ideal_options: &MaskIdealOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_in: f64 = frequency_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_ideal_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_ideal_options.nodc { 1 } else { 0 };
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_ideal_options.reject { 1 } else { 0 };
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_ideal_options.optical { 1 } else { 0 };
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_ideal(
&mut out_out,
width_in,
height_in,
frequency_cutoff_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskIdealError,
)
}
}
pub fn mask_ideal_ring(
width: i32,
height: i32,
frequency_cutoff: f64,
ringwidth: f64,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_in: f64 = frequency_cutoff;
let ringwidth_in: f64 = ringwidth;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_ideal_ring(
&mut out_out,
width_in,
height_in,
frequency_cutoff_in,
ringwidth_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskIdealRingError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskIdealRingOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskIdealRingOptions {
fn default() -> Self {
MaskIdealRingOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_ideal_ring_with_opts(
width: i32,
height: i32,
frequency_cutoff: f64,
ringwidth: f64,
mask_ideal_ring_options: &MaskIdealRingOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_in: f64 = frequency_cutoff;
let ringwidth_in: f64 = ringwidth;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_ideal_ring_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_ideal_ring_options.nodc { 1 } else { 0 };
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_ideal_ring_options.reject { 1 } else { 0 };
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_ideal_ring_options.optical {
1
} else {
0
};
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_ideal_ring(
&mut out_out,
width_in,
height_in,
frequency_cutoff_in,
ringwidth_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskIdealRingError,
)
}
}
pub fn mask_ideal_band(
width: i32,
height: i32,
frequency_cutoff_x: f64,
frequency_cutoff_y: f64,
radius: f64,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_x_in: f64 = frequency_cutoff_x;
let frequency_cutoff_y_in: f64 = frequency_cutoff_y;
let radius_in: f64 = radius;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_ideal_band(
&mut out_out,
width_in,
height_in,
frequency_cutoff_x_in,
frequency_cutoff_y_in,
radius_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskIdealBandError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskIdealBandOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskIdealBandOptions {
fn default() -> Self {
MaskIdealBandOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_ideal_band_with_opts(
width: i32,
height: i32,
frequency_cutoff_x: f64,
frequency_cutoff_y: f64,
radius: f64,
mask_ideal_band_options: &MaskIdealBandOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_x_in: f64 = frequency_cutoff_x;
let frequency_cutoff_y_in: f64 = frequency_cutoff_y;
let radius_in: f64 = radius;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_ideal_band_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_ideal_band_options.nodc { 1 } else { 0 };
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_ideal_band_options.reject { 1 } else { 0 };
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_ideal_band_options.optical {
1
} else {
0
};
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_ideal_band(
&mut out_out,
width_in,
height_in,
frequency_cutoff_x_in,
frequency_cutoff_y_in,
radius_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskIdealBandError,
)
}
}
pub fn mask_butterworth(
width: i32,
height: i32,
order: f64,
frequency_cutoff: f64,
amplitude_cutoff: f64,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let order_in: f64 = order;
let frequency_cutoff_in: f64 = frequency_cutoff;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_butterworth(
&mut out_out,
width_in,
height_in,
order_in,
frequency_cutoff_in,
amplitude_cutoff_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskButterworthError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskButterworthOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskButterworthOptions {
fn default() -> Self {
MaskButterworthOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_butterworth_with_opts(
width: i32,
height: i32,
order: f64,
frequency_cutoff: f64,
amplitude_cutoff: f64,
mask_butterworth_options: &MaskButterworthOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let order_in: f64 = order;
let frequency_cutoff_in: f64 = frequency_cutoff;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_butterworth_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_butterworth_options.nodc { 1 } else { 0 };
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_butterworth_options.reject {
1
} else {
0
};
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_butterworth_options.optical {
1
} else {
0
};
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_butterworth(
&mut out_out,
width_in,
height_in,
order_in,
frequency_cutoff_in,
amplitude_cutoff_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskButterworthError,
)
}
}
pub fn mask_butterworth_ring(
width: i32,
height: i32,
order: f64,
frequency_cutoff: f64,
amplitude_cutoff: f64,
ringwidth: f64,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let order_in: f64 = order;
let frequency_cutoff_in: f64 = frequency_cutoff;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let ringwidth_in: f64 = ringwidth;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_butterworth_ring(
&mut out_out,
width_in,
height_in,
order_in,
frequency_cutoff_in,
amplitude_cutoff_in,
ringwidth_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskButterworthRingError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskButterworthRingOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskButterworthRingOptions {
fn default() -> Self {
MaskButterworthRingOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_butterworth_ring_with_opts(
width: i32,
height: i32,
order: f64,
frequency_cutoff: f64,
amplitude_cutoff: f64,
ringwidth: f64,
mask_butterworth_ring_options: &MaskButterworthRingOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let order_in: f64 = order;
let frequency_cutoff_in: f64 = frequency_cutoff;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let ringwidth_in: f64 = ringwidth;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_butterworth_ring_options.uchar {
1
} else {
0
};
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_butterworth_ring_options.nodc {
1
} else {
0
};
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_butterworth_ring_options.reject {
1
} else {
0
};
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_butterworth_ring_options.optical {
1
} else {
0
};
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_butterworth_ring(
&mut out_out,
width_in,
height_in,
order_in,
frequency_cutoff_in,
amplitude_cutoff_in,
ringwidth_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskButterworthRingError,
)
}
}
pub fn mask_butterworth_band(
width: i32,
height: i32,
order: f64,
frequency_cutoff_x: f64,
frequency_cutoff_y: f64,
radius: f64,
amplitude_cutoff: f64,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let order_in: f64 = order;
let frequency_cutoff_x_in: f64 = frequency_cutoff_x;
let frequency_cutoff_y_in: f64 = frequency_cutoff_y;
let radius_in: f64 = radius;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_butterworth_band(
&mut out_out,
width_in,
height_in,
order_in,
frequency_cutoff_x_in,
frequency_cutoff_y_in,
radius_in,
amplitude_cutoff_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskButterworthBandError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskButterworthBandOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskButterworthBandOptions {
fn default() -> Self {
MaskButterworthBandOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_butterworth_band_with_opts(
width: i32,
height: i32,
order: f64,
frequency_cutoff_x: f64,
frequency_cutoff_y: f64,
radius: f64,
amplitude_cutoff: f64,
mask_butterworth_band_options: &MaskButterworthBandOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let order_in: f64 = order;
let frequency_cutoff_x_in: f64 = frequency_cutoff_x;
let frequency_cutoff_y_in: f64 = frequency_cutoff_y;
let radius_in: f64 = radius;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_butterworth_band_options.uchar {
1
} else {
0
};
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_butterworth_band_options.nodc {
1
} else {
0
};
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_butterworth_band_options.reject {
1
} else {
0
};
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_butterworth_band_options.optical {
1
} else {
0
};
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_butterworth_band(
&mut out_out,
width_in,
height_in,
order_in,
frequency_cutoff_x_in,
frequency_cutoff_y_in,
radius_in,
amplitude_cutoff_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskButterworthBandError,
)
}
}
pub fn mask_gaussian(
width: i32,
height: i32,
frequency_cutoff: f64,
amplitude_cutoff: f64,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_in: f64 = frequency_cutoff;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_gaussian(
&mut out_out,
width_in,
height_in,
frequency_cutoff_in,
amplitude_cutoff_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskGaussianError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskGaussianOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskGaussianOptions {
fn default() -> Self {
MaskGaussianOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_gaussian_with_opts(
width: i32,
height: i32,
frequency_cutoff: f64,
amplitude_cutoff: f64,
mask_gaussian_options: &MaskGaussianOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_in: f64 = frequency_cutoff;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_gaussian_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_gaussian_options.nodc { 1 } else { 0 };
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_gaussian_options.reject { 1 } else { 0 };
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_gaussian_options.optical { 1 } else { 0 };
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_gaussian(
&mut out_out,
width_in,
height_in,
frequency_cutoff_in,
amplitude_cutoff_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskGaussianError,
)
}
}
pub fn mask_gaussian_ring(
width: i32,
height: i32,
frequency_cutoff: f64,
amplitude_cutoff: f64,
ringwidth: f64,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_in: f64 = frequency_cutoff;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let ringwidth_in: f64 = ringwidth;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_gaussian_ring(
&mut out_out,
width_in,
height_in,
frequency_cutoff_in,
amplitude_cutoff_in,
ringwidth_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskGaussianRingError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskGaussianRingOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskGaussianRingOptions {
fn default() -> Self {
MaskGaussianRingOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_gaussian_ring_with_opts(
width: i32,
height: i32,
frequency_cutoff: f64,
amplitude_cutoff: f64,
ringwidth: f64,
mask_gaussian_ring_options: &MaskGaussianRingOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_in: f64 = frequency_cutoff;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let ringwidth_in: f64 = ringwidth;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_gaussian_ring_options.uchar {
1
} else {
0
};
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_gaussian_ring_options.nodc {
1
} else {
0
};
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_gaussian_ring_options.reject {
1
} else {
0
};
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_gaussian_ring_options.optical {
1
} else {
0
};
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_gaussian_ring(
&mut out_out,
width_in,
height_in,
frequency_cutoff_in,
amplitude_cutoff_in,
ringwidth_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskGaussianRingError,
)
}
}
pub fn mask_gaussian_band(
width: i32,
height: i32,
frequency_cutoff_x: f64,
frequency_cutoff_y: f64,
radius: f64,
amplitude_cutoff: f64,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_x_in: f64 = frequency_cutoff_x;
let frequency_cutoff_y_in: f64 = frequency_cutoff_y;
let radius_in: f64 = radius;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_gaussian_band(
&mut out_out,
width_in,
height_in,
frequency_cutoff_x_in,
frequency_cutoff_y_in,
radius_in,
amplitude_cutoff_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskGaussianBandError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskGaussianBandOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskGaussianBandOptions {
fn default() -> Self {
MaskGaussianBandOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_gaussian_band_with_opts(
width: i32,
height: i32,
frequency_cutoff_x: f64,
frequency_cutoff_y: f64,
radius: f64,
amplitude_cutoff: f64,
mask_gaussian_band_options: &MaskGaussianBandOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let frequency_cutoff_x_in: f64 = frequency_cutoff_x;
let frequency_cutoff_y_in: f64 = frequency_cutoff_y;
let radius_in: f64 = radius;
let amplitude_cutoff_in: f64 = amplitude_cutoff;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_gaussian_band_options.uchar {
1
} else {
0
};
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_gaussian_band_options.nodc {
1
} else {
0
};
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_gaussian_band_options.reject {
1
} else {
0
};
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_gaussian_band_options.optical {
1
} else {
0
};
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_gaussian_band(
&mut out_out,
width_in,
height_in,
frequency_cutoff_x_in,
frequency_cutoff_y_in,
radius_in,
amplitude_cutoff_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskGaussianBandError,
)
}
}
pub fn mask_fractal(width: i32, height: i32, fractal_dimension: f64) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let fractal_dimension_in: f64 = fractal_dimension;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mask_fractal(
&mut out_out,
width_in,
height_in,
fractal_dimension_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskFractalError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaskFractalOptions {
pub uchar: bool,
pub nodc: bool,
pub reject: bool,
pub optical: bool,
}
impl std::default::Default for MaskFractalOptions {
fn default() -> Self {
MaskFractalOptions {
uchar: false,
nodc: false,
reject: false,
optical: false,
}
}
}
pub fn mask_fractal_with_opts(
width: i32,
height: i32,
fractal_dimension: f64,
mask_fractal_options: &MaskFractalOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let fractal_dimension_in: f64 = fractal_dimension;
let mut out_out: *mut bindings::VipsImage = null_mut();
let uchar_in: i32 = if mask_fractal_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let nodc_in: i32 = if mask_fractal_options.nodc { 1 } else { 0 };
let nodc_in_name = utils::new_c_string("nodc")?;
let reject_in: i32 = if mask_fractal_options.reject { 1 } else { 0 };
let reject_in_name = utils::new_c_string("reject")?;
let optical_in: i32 = if mask_fractal_options.optical { 1 } else { 0 };
let optical_in_name = utils::new_c_string("optical")?;
let vips_op_response = bindings::vips_mask_fractal(
&mut out_out,
width_in,
height_in,
fractal_dimension_in,
uchar_in_name.as_ptr(),
uchar_in,
nodc_in_name.as_ptr(),
nodc_in,
reject_in_name.as_ptr(),
reject_in,
optical_in_name.as_ptr(),
optical_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaskFractalError,
)
}
}
pub fn buildlut(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_buildlut(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::BuildlutError,
)
}
}
pub fn invertlut(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_invertlut(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::InvertlutError,
)
}
}
#[derive(Clone, Debug)]
pub struct InvertlutOptions {
pub size: i32,
}
impl std::default::Default for InvertlutOptions {
fn default() -> Self {
InvertlutOptions {
size: i32::from(256),
}
}
}
pub fn invertlut_with_opts(
inp: &VipsImage,
invertlut_options: &InvertlutOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let size_in: i32 = invertlut_options.size;
let size_in_name = utils::new_c_string("size")?;
let vips_op_response =
bindings::vips_invertlut(inp_in, &mut out_out, size_in_name.as_ptr(), size_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::InvertlutError,
)
}
}
pub fn tonelut() -> Result<VipsImage> {
unsafe {
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_tonelut(&mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TonelutError,
)
}
}
#[derive(Clone, Debug)]
pub struct TonelutOptions {
pub in_max: i32,
pub out_max: i32,
pub lb: f64,
pub lw: f64,
pub ps: f64,
pub pm: f64,
pub ph: f64,
pub s: f64,
pub m: f64,
pub h: f64,
}
impl std::default::Default for TonelutOptions {
fn default() -> Self {
TonelutOptions {
in_max: i32::from(32767),
out_max: i32::from(32767),
lb: f64::from(0),
lw: f64::from(100),
ps: f64::from(0.2),
pm: f64::from(0.5),
ph: f64::from(0.8),
s: f64::from(0),
m: f64::from(0),
h: f64::from(0),
}
}
}
pub fn tonelut_with_opts(tonelut_options: &TonelutOptions) -> Result<VipsImage> {
unsafe {
let mut out_out: *mut bindings::VipsImage = null_mut();
let in_max_in: i32 = tonelut_options.in_max;
let in_max_in_name = utils::new_c_string("in-max")?;
let out_max_in: i32 = tonelut_options.out_max;
let out_max_in_name = utils::new_c_string("out-max")?;
let lb_in: f64 = tonelut_options.lb;
let lb_in_name = utils::new_c_string("Lb")?;
let lw_in: f64 = tonelut_options.lw;
let lw_in_name = utils::new_c_string("Lw")?;
let ps_in: f64 = tonelut_options.ps;
let ps_in_name = utils::new_c_string("Ps")?;
let pm_in: f64 = tonelut_options.pm;
let pm_in_name = utils::new_c_string("Pm")?;
let ph_in: f64 = tonelut_options.ph;
let ph_in_name = utils::new_c_string("Ph")?;
let s_in: f64 = tonelut_options.s;
let s_in_name = utils::new_c_string("S")?;
let m_in: f64 = tonelut_options.m;
let m_in_name = utils::new_c_string("M")?;
let h_in: f64 = tonelut_options.h;
let h_in_name = utils::new_c_string("H")?;
let vips_op_response = bindings::vips_tonelut(
&mut out_out,
in_max_in_name.as_ptr(),
in_max_in,
out_max_in_name.as_ptr(),
out_max_in,
lb_in_name.as_ptr(),
lb_in,
lw_in_name.as_ptr(),
lw_in,
ps_in_name.as_ptr(),
ps_in,
pm_in_name.as_ptr(),
pm_in,
ph_in_name.as_ptr(),
ph_in,
s_in_name.as_ptr(),
s_in,
m_in_name.as_ptr(),
m_in,
h_in_name.as_ptr(),
h_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TonelutError,
)
}
}
pub fn identity() -> Result<VipsImage> {
unsafe {
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_identity(&mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IdentityError,
)
}
}
#[derive(Clone, Debug)]
pub struct IdentityOptions {
pub bands: i32,
pub ushort: bool,
pub size: i32,
}
impl std::default::Default for IdentityOptions {
fn default() -> Self {
IdentityOptions {
bands: i32::from(1),
ushort: false,
size: i32::from(65536),
}
}
}
pub fn identity_with_opts(identity_options: &IdentityOptions) -> Result<VipsImage> {
unsafe {
let mut out_out: *mut bindings::VipsImage = null_mut();
let bands_in: i32 = identity_options.bands;
let bands_in_name = utils::new_c_string("bands")?;
let ushort_in: i32 = if identity_options.ushort { 1 } else { 0 };
let ushort_in_name = utils::new_c_string("ushort")?;
let size_in: i32 = identity_options.size;
let size_in_name = utils::new_c_string("size")?;
let vips_op_response = bindings::vips_identity(
&mut out_out,
bands_in_name.as_ptr(),
bands_in,
ushort_in_name.as_ptr(),
ushort_in,
size_in_name.as_ptr(),
size_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IdentityError,
)
}
}
pub fn fractsurf(width: i32, height: i32, fractal_dimension: f64) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let fractal_dimension_in: f64 = fractal_dimension;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_fractsurf(
&mut out_out,
width_in,
height_in,
fractal_dimension_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FractsurfError,
)
}
}
pub fn worley(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_worley(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::WorleyError,
)
}
}
#[derive(Clone, Debug)]
pub struct WorleyOptions {
pub cell_size: i32,
}
impl std::default::Default for WorleyOptions {
fn default() -> Self {
WorleyOptions {
cell_size: i32::from(256),
}
}
}
pub fn worley_with_opts(
width: i32,
height: i32,
worley_options: &WorleyOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let cell_size_in: i32 = worley_options.cell_size;
let cell_size_in_name = utils::new_c_string("cell-size")?;
let vips_op_response = bindings::vips_worley(
&mut out_out,
width_in,
height_in,
cell_size_in_name.as_ptr(),
cell_size_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::WorleyError,
)
}
}
pub fn perlin(width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_perlin(&mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PerlinError,
)
}
}
#[derive(Clone, Debug)]
pub struct PerlinOptions {
pub cell_size: i32,
pub uchar: bool,
}
impl std::default::Default for PerlinOptions {
fn default() -> Self {
PerlinOptions {
cell_size: i32::from(256),
uchar: false,
}
}
}
pub fn perlin_with_opts(
width: i32,
height: i32,
perlin_options: &PerlinOptions,
) -> Result<VipsImage> {
unsafe {
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let cell_size_in: i32 = perlin_options.cell_size;
let cell_size_in_name = utils::new_c_string("cell-size")?;
let uchar_in: i32 = if perlin_options.uchar { 1 } else { 0 };
let uchar_in_name = utils::new_c_string("uchar")?;
let vips_op_response = bindings::vips_perlin(
&mut out_out,
width_in,
height_in,
cell_size_in_name.as_ptr(),
cell_size_in,
uchar_in_name.as_ptr(),
uchar_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PerlinError,
)
}
}
pub fn csvload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_csvload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CsvloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct CsvloadOptions {
pub skip: i32,
pub lines: i32,
pub whitespace: String,
pub separator: String,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for CsvloadOptions {
fn default() -> Self {
CsvloadOptions {
skip: i32::from(0),
lines: i32::from(0),
whitespace: String::new(),
separator: String::new(),
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn csvload_with_opts(filename: &str, csvload_options: &CsvloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let skip_in: i32 = csvload_options.skip;
let skip_in_name = utils::new_c_string("skip")?;
let lines_in: i32 = csvload_options.lines;
let lines_in_name = utils::new_c_string("lines")?;
let whitespace_in: CString = utils::new_c_string(&csvload_options.whitespace)?;
let whitespace_in_name = utils::new_c_string("whitespace")?;
let separator_in: CString = utils::new_c_string(&csvload_options.separator)?;
let separator_in_name = utils::new_c_string("separator")?;
let flags_in: i32 = csvload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if csvload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = csvload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if csvload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_csvload(
filename_in.as_ptr(),
&mut out_out,
skip_in_name.as_ptr(),
skip_in,
lines_in_name.as_ptr(),
lines_in,
whitespace_in_name.as_ptr(),
whitespace_in.as_ptr(),
separator_in_name.as_ptr(),
separator_in.as_ptr(),
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CsvloadError,
)
}
}
pub fn matrixload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_matrixload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MatrixloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct MatrixloadOptions {
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for MatrixloadOptions {
fn default() -> Self {
MatrixloadOptions {
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn matrixload_with_opts(
filename: &str,
matrixload_options: &MatrixloadOptions,
) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let flags_in: i32 = matrixload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if matrixload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = matrixload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if matrixload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_matrixload(
filename_in.as_ptr(),
&mut out_out,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MatrixloadError,
)
}
}
pub fn rawload(filename: &str, width: i32, height: i32, bands: i32) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let width_in: i32 = width;
let height_in: i32 = height;
let bands_in: i32 = bands;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_rawload(
filename_in.as_ptr(),
&mut out_out,
width_in,
height_in,
bands_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RawloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct RawloadOptions {
pub offset: u64,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for RawloadOptions {
fn default() -> Self {
RawloadOptions {
offset: 0,
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn rawload_with_opts(
filename: &str,
width: i32,
height: i32,
bands: i32,
rawload_options: &RawloadOptions,
) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let width_in: i32 = width;
let height_in: i32 = height;
let bands_in: i32 = bands;
let mut out_out: *mut bindings::VipsImage = null_mut();
let offset_in: u64 = rawload_options.offset;
let offset_in_name = utils::new_c_string("offset")?;
let flags_in: i32 = rawload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if rawload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = rawload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if rawload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_rawload(
filename_in.as_ptr(),
&mut out_out,
width_in,
height_in,
bands_in,
offset_in_name.as_ptr(),
offset_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RawloadError,
)
}
}
pub fn vipsload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_vipsload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::VipsloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct VipsloadOptions {
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for VipsloadOptions {
fn default() -> Self {
VipsloadOptions {
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn vipsload_with_opts(filename: &str, vipsload_options: &VipsloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let flags_in: i32 = vipsload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if vipsload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = vipsload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if vipsload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_vipsload(
filename_in.as_ptr(),
&mut out_out,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::VipsloadError,
)
}
}
pub fn analyzeload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_analyzeload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::AnalyzeloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct AnalyzeloadOptions {
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for AnalyzeloadOptions {
fn default() -> Self {
AnalyzeloadOptions {
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn analyzeload_with_opts(
filename: &str,
analyzeload_options: &AnalyzeloadOptions,
) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let flags_in: i32 = analyzeload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if analyzeload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = analyzeload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if analyzeload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_analyzeload(
filename_in.as_ptr(),
&mut out_out,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::AnalyzeloadError,
)
}
}
pub fn ppmload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_ppmload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PpmloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct PpmloadOptions {
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for PpmloadOptions {
fn default() -> Self {
PpmloadOptions {
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn ppmload_with_opts(filename: &str, ppmload_options: &PpmloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let flags_in: i32 = ppmload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if ppmload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = ppmload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if ppmload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_ppmload(
filename_in.as_ptr(),
&mut out_out,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PpmloadError,
)
}
}
pub fn radload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_radload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RadloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct RadloadOptions {
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for RadloadOptions {
fn default() -> Self {
RadloadOptions {
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn radload_with_opts(filename: &str, radload_options: &RadloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let flags_in: i32 = radload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if radload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = radload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if radload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_radload(
filename_in.as_ptr(),
&mut out_out,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RadloadError,
)
}
}
pub fn svgload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_svgload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SvgloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct SvgloadOptions {
pub dpi: f64,
pub scale: f64,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for SvgloadOptions {
fn default() -> Self {
SvgloadOptions {
dpi: f64::from(72),
scale: f64::from(1),
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn svgload_with_opts(filename: &str, svgload_options: &SvgloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let dpi_in: f64 = svgload_options.dpi;
let dpi_in_name = utils::new_c_string("dpi")?;
let scale_in: f64 = svgload_options.scale;
let scale_in_name = utils::new_c_string("scale")?;
let flags_in: i32 = svgload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if svgload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = svgload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if svgload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_svgload(
filename_in.as_ptr(),
&mut out_out,
dpi_in_name.as_ptr(),
dpi_in,
scale_in_name.as_ptr(),
scale_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SvgloadError,
)
}
}
pub fn svgload_buffer(buffer: &[u8]) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_svgload_buffer(buffer_in, buffer.len() as u64, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SvgloadBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct SvgloadBufferOptions {
pub dpi: f64,
pub scale: f64,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for SvgloadBufferOptions {
fn default() -> Self {
SvgloadBufferOptions {
dpi: f64::from(72),
scale: f64::from(1),
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn svgload_buffer_with_opts(
buffer: &[u8],
svgload_buffer_options: &SvgloadBufferOptions,
) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let dpi_in: f64 = svgload_buffer_options.dpi;
let dpi_in_name = utils::new_c_string("dpi")?;
let scale_in: f64 = svgload_buffer_options.scale;
let scale_in_name = utils::new_c_string("scale")?;
let flags_in: i32 = svgload_buffer_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if svgload_buffer_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = svgload_buffer_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if svgload_buffer_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_svgload_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
dpi_in_name.as_ptr(),
dpi_in,
scale_in_name.as_ptr(),
scale_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SvgloadBufferError,
)
}
}
pub fn gifload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_gifload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GifloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct GifloadOptions {
pub page: i32,
pub n: i32,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for GifloadOptions {
fn default() -> Self {
GifloadOptions {
page: i32::from(0),
n: i32::from(1),
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn gifload_with_opts(filename: &str, gifload_options: &GifloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_in: i32 = gifload_options.page;
let page_in_name = utils::new_c_string("page")?;
let n_in: i32 = gifload_options.n;
let n_in_name = utils::new_c_string("n")?;
let flags_in: i32 = gifload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if gifload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = gifload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if gifload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_gifload(
filename_in.as_ptr(),
&mut out_out,
page_in_name.as_ptr(),
page_in,
n_in_name.as_ptr(),
n_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GifloadError,
)
}
}
pub fn gifload_buffer(buffer: &[u8]) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_gifload_buffer(buffer_in, buffer.len() as u64, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GifloadBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct GifloadBufferOptions {
pub page: i32,
pub n: i32,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for GifloadBufferOptions {
fn default() -> Self {
GifloadBufferOptions {
page: i32::from(0),
n: i32::from(1),
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn gifload_buffer_with_opts(
buffer: &[u8],
gifload_buffer_options: &GifloadBufferOptions,
) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_in: i32 = gifload_buffer_options.page;
let page_in_name = utils::new_c_string("page")?;
let n_in: i32 = gifload_buffer_options.n;
let n_in_name = utils::new_c_string("n")?;
let flags_in: i32 = gifload_buffer_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if gifload_buffer_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = gifload_buffer_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if gifload_buffer_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_gifload_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
page_in_name.as_ptr(),
page_in,
n_in_name.as_ptr(),
n_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GifloadBufferError,
)
}
}
pub fn pngload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_pngload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PngloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct PngloadOptions {
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for PngloadOptions {
fn default() -> Self {
PngloadOptions {
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn pngload_with_opts(filename: &str, pngload_options: &PngloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let flags_in: i32 = pngload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if pngload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = pngload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if pngload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_pngload(
filename_in.as_ptr(),
&mut out_out,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PngloadError,
)
}
}
pub fn pngload_buffer(buffer: &[u8]) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_pngload_buffer(buffer_in, buffer.len() as u64, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PngloadBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct PngloadBufferOptions {
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for PngloadBufferOptions {
fn default() -> Self {
PngloadBufferOptions {
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn pngload_buffer_with_opts(
buffer: &[u8],
pngload_buffer_options: &PngloadBufferOptions,
) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let flags_in: i32 = pngload_buffer_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if pngload_buffer_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = pngload_buffer_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if pngload_buffer_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_pngload_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PngloadBufferError,
)
}
}
pub fn jpegload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_jpegload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::JpegloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct JpegloadOptions {
pub shrink: i32,
pub autorotate: bool,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for JpegloadOptions {
fn default() -> Self {
JpegloadOptions {
shrink: i32::from(1),
autorotate: false,
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn jpegload_with_opts(filename: &str, jpegload_options: &JpegloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let shrink_in: i32 = jpegload_options.shrink;
let shrink_in_name = utils::new_c_string("shrink")?;
let autorotate_in: i32 = if jpegload_options.autorotate { 1 } else { 0 };
let autorotate_in_name = utils::new_c_string("autorotate")?;
let flags_in: i32 = jpegload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if jpegload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = jpegload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if jpegload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_jpegload(
filename_in.as_ptr(),
&mut out_out,
shrink_in_name.as_ptr(),
shrink_in,
autorotate_in_name.as_ptr(),
autorotate_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::JpegloadError,
)
}
}
pub fn jpegload_buffer(buffer: &[u8]) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_jpegload_buffer(buffer_in, buffer.len() as u64, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::JpegloadBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct JpegloadBufferOptions {
pub shrink: i32,
pub autorotate: bool,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for JpegloadBufferOptions {
fn default() -> Self {
JpegloadBufferOptions {
shrink: i32::from(1),
autorotate: false,
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn jpegload_buffer_with_opts(
buffer: &[u8],
jpegload_buffer_options: &JpegloadBufferOptions,
) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let shrink_in: i32 = jpegload_buffer_options.shrink;
let shrink_in_name = utils::new_c_string("shrink")?;
let autorotate_in: i32 = if jpegload_buffer_options.autorotate {
1
} else {
0
};
let autorotate_in_name = utils::new_c_string("autorotate")?;
let flags_in: i32 = jpegload_buffer_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if jpegload_buffer_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = jpegload_buffer_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if jpegload_buffer_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_jpegload_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
shrink_in_name.as_ptr(),
shrink_in,
autorotate_in_name.as_ptr(),
autorotate_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::JpegloadBufferError,
)
}
}
pub fn webpload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_webpload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::WebploadError,
)
}
}
#[derive(Clone, Debug)]
pub struct WebploadOptions {
pub page: i32,
pub n: i32,
pub scale: f64,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for WebploadOptions {
fn default() -> Self {
WebploadOptions {
page: i32::from(0),
n: i32::from(1),
scale: f64::from(1),
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn webpload_with_opts(filename: &str, webpload_options: &WebploadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_in: i32 = webpload_options.page;
let page_in_name = utils::new_c_string("page")?;
let n_in: i32 = webpload_options.n;
let n_in_name = utils::new_c_string("n")?;
let scale_in: f64 = webpload_options.scale;
let scale_in_name = utils::new_c_string("scale")?;
let flags_in: i32 = webpload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if webpload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = webpload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if webpload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_webpload(
filename_in.as_ptr(),
&mut out_out,
page_in_name.as_ptr(),
page_in,
n_in_name.as_ptr(),
n_in,
scale_in_name.as_ptr(),
scale_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::WebploadError,
)
}
}
pub fn webpload_buffer(buffer: &[u8]) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_webpload_buffer(buffer_in, buffer.len() as u64, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::WebploadBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct WebploadBufferOptions {
pub page: i32,
pub n: i32,
pub scale: f64,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for WebploadBufferOptions {
fn default() -> Self {
WebploadBufferOptions {
page: i32::from(0),
n: i32::from(1),
scale: f64::from(1),
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn webpload_buffer_with_opts(
buffer: &[u8],
webpload_buffer_options: &WebploadBufferOptions,
) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_in: i32 = webpload_buffer_options.page;
let page_in_name = utils::new_c_string("page")?;
let n_in: i32 = webpload_buffer_options.n;
let n_in_name = utils::new_c_string("n")?;
let scale_in: f64 = webpload_buffer_options.scale;
let scale_in_name = utils::new_c_string("scale")?;
let flags_in: i32 = webpload_buffer_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if webpload_buffer_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = webpload_buffer_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if webpload_buffer_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_webpload_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
page_in_name.as_ptr(),
page_in,
n_in_name.as_ptr(),
n_in,
scale_in_name.as_ptr(),
scale_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::WebploadBufferError,
)
}
}
pub fn tiffload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_tiffload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TiffloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct TiffloadOptions {
pub page: i32,
pub n: i32,
pub autorotate: bool,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for TiffloadOptions {
fn default() -> Self {
TiffloadOptions {
page: i32::from(0),
n: i32::from(1),
autorotate: false,
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn tiffload_with_opts(filename: &str, tiffload_options: &TiffloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_in: i32 = tiffload_options.page;
let page_in_name = utils::new_c_string("page")?;
let n_in: i32 = tiffload_options.n;
let n_in_name = utils::new_c_string("n")?;
let autorotate_in: i32 = if tiffload_options.autorotate { 1 } else { 0 };
let autorotate_in_name = utils::new_c_string("autorotate")?;
let flags_in: i32 = tiffload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if tiffload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = tiffload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if tiffload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_tiffload(
filename_in.as_ptr(),
&mut out_out,
page_in_name.as_ptr(),
page_in,
n_in_name.as_ptr(),
n_in,
autorotate_in_name.as_ptr(),
autorotate_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TiffloadError,
)
}
}
pub fn tiffload_buffer(buffer: &[u8]) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_tiffload_buffer(buffer_in, buffer.len() as u64, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TiffloadBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct TiffloadBufferOptions {
pub page: i32,
pub n: i32,
pub autorotate: bool,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for TiffloadBufferOptions {
fn default() -> Self {
TiffloadBufferOptions {
page: i32::from(0),
n: i32::from(1),
autorotate: false,
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn tiffload_buffer_with_opts(
buffer: &[u8],
tiffload_buffer_options: &TiffloadBufferOptions,
) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_in: i32 = tiffload_buffer_options.page;
let page_in_name = utils::new_c_string("page")?;
let n_in: i32 = tiffload_buffer_options.n;
let n_in_name = utils::new_c_string("n")?;
let autorotate_in: i32 = if tiffload_buffer_options.autorotate {
1
} else {
0
};
let autorotate_in_name = utils::new_c_string("autorotate")?;
let flags_in: i32 = tiffload_buffer_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if tiffload_buffer_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = tiffload_buffer_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if tiffload_buffer_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_tiffload_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
page_in_name.as_ptr(),
page_in,
n_in_name.as_ptr(),
n_in,
autorotate_in_name.as_ptr(),
autorotate_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::TiffloadBufferError,
)
}
}
pub fn heifload(filename: &str) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_heifload(filename_in.as_ptr(), &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HeifloadError,
)
}
}
#[derive(Clone, Debug)]
pub struct HeifloadOptions {
pub page: i32,
pub n: i32,
pub thumbnail: bool,
pub autorotate: bool,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for HeifloadOptions {
fn default() -> Self {
HeifloadOptions {
page: i32::from(0),
n: i32::from(1),
thumbnail: false,
autorotate: false,
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn heifload_with_opts(filename: &str, heifload_options: &HeifloadOptions) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_in: i32 = heifload_options.page;
let page_in_name = utils::new_c_string("page")?;
let n_in: i32 = heifload_options.n;
let n_in_name = utils::new_c_string("n")?;
let thumbnail_in: i32 = if heifload_options.thumbnail { 1 } else { 0 };
let thumbnail_in_name = utils::new_c_string("thumbnail")?;
let autorotate_in: i32 = if heifload_options.autorotate { 1 } else { 0 };
let autorotate_in_name = utils::new_c_string("autorotate")?;
let flags_in: i32 = heifload_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if heifload_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = heifload_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if heifload_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_heifload(
filename_in.as_ptr(),
&mut out_out,
page_in_name.as_ptr(),
page_in,
n_in_name.as_ptr(),
n_in,
thumbnail_in_name.as_ptr(),
thumbnail_in,
autorotate_in_name.as_ptr(),
autorotate_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HeifloadError,
)
}
}
pub fn heifload_buffer(buffer: &[u8]) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_heifload_buffer(buffer_in, buffer.len() as u64, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HeifloadBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct HeifloadBufferOptions {
pub page: i32,
pub n: i32,
pub thumbnail: bool,
pub autorotate: bool,
pub flags: ForeignFlags,
pub memory: bool,
pub access: Access,
pub fail: bool,
}
impl std::default::Default for HeifloadBufferOptions {
fn default() -> Self {
HeifloadBufferOptions {
page: i32::from(0),
n: i32::from(1),
thumbnail: false,
autorotate: false,
flags: ForeignFlags::None,
memory: false,
access: Access::Random,
fail: false,
}
}
}
pub fn heifload_buffer_with_opts(
buffer: &[u8],
heifload_buffer_options: &HeifloadBufferOptions,
) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let mut out_out: *mut bindings::VipsImage = null_mut();
let page_in: i32 = heifload_buffer_options.page;
let page_in_name = utils::new_c_string("page")?;
let n_in: i32 = heifload_buffer_options.n;
let n_in_name = utils::new_c_string("n")?;
let thumbnail_in: i32 = if heifload_buffer_options.thumbnail {
1
} else {
0
};
let thumbnail_in_name = utils::new_c_string("thumbnail")?;
let autorotate_in: i32 = if heifload_buffer_options.autorotate {
1
} else {
0
};
let autorotate_in_name = utils::new_c_string("autorotate")?;
let flags_in: i32 = heifload_buffer_options.flags as i32;
let flags_in_name = utils::new_c_string("flags")?;
let memory_in: i32 = if heifload_buffer_options.memory { 1 } else { 0 };
let memory_in_name = utils::new_c_string("memory")?;
let access_in: i32 = heifload_buffer_options.access as i32;
let access_in_name = utils::new_c_string("access")?;
let fail_in: i32 = if heifload_buffer_options.fail { 1 } else { 0 };
let fail_in_name = utils::new_c_string("fail")?;
let vips_op_response = bindings::vips_heifload_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
page_in_name.as_ptr(),
page_in,
n_in_name.as_ptr(),
n_in,
thumbnail_in_name.as_ptr(),
thumbnail_in,
autorotate_in_name.as_ptr(),
autorotate_in,
flags_in_name.as_ptr(),
flags_in,
memory_in_name.as_ptr(),
memory_in,
access_in_name.as_ptr(),
access_in,
fail_in_name.as_ptr(),
fail_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HeifloadBufferError,
)
}
}
pub fn csvsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_csvsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::CsvsaveError)
}
}
#[derive(Clone, Debug)]
pub struct CsvsaveOptions {
pub page_height: i32,
pub separator: String,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for CsvsaveOptions {
fn default() -> Self {
CsvsaveOptions {
page_height: i32::from(0),
separator: String::new(),
strip: false,
background: Vec::new(),
}
}
}
pub fn csvsave_with_opts(
inp: &VipsImage,
filename: &str,
csvsave_options: &CsvsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = csvsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let separator_in: CString = utils::new_c_string(&csvsave_options.separator)?;
let separator_in_name = utils::new_c_string("separator")?;
let strip_in: i32 = if csvsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&csvsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_csvsave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
separator_in_name.as_ptr(),
separator_in.as_ptr(),
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::CsvsaveError)
}
}
pub fn matrixsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_matrixsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::MatrixsaveError)
}
}
#[derive(Clone, Debug)]
pub struct MatrixsaveOptions {
pub page_height: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for MatrixsaveOptions {
fn default() -> Self {
MatrixsaveOptions {
page_height: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn matrixsave_with_opts(
inp: &VipsImage,
filename: &str,
matrixsave_options: &MatrixsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = matrixsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let strip_in: i32 = if matrixsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&matrixsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_matrixsave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::MatrixsaveError)
}
}
pub fn matrixprint(inp: &VipsImage) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let vips_op_response = bindings::vips_matrixprint(inp_in, NULL);
utils::result(vips_op_response, (), Error::MatrixprintError)
}
}
#[derive(Clone, Debug)]
pub struct MatrixprintOptions {
pub page_height: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for MatrixprintOptions {
fn default() -> Self {
MatrixprintOptions {
page_height: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn matrixprint_with_opts(
inp: &VipsImage,
matrixprint_options: &MatrixprintOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let page_height_in: i32 = matrixprint_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let strip_in: i32 = if matrixprint_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&matrixprint_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_matrixprint(
inp_in,
page_height_in_name.as_ptr(),
page_height_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::MatrixprintError)
}
}
pub fn rawsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_rawsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::RawsaveError)
}
}
#[derive(Clone, Debug)]
pub struct RawsaveOptions {
pub page_height: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for RawsaveOptions {
fn default() -> Self {
RawsaveOptions {
page_height: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn rawsave_with_opts(
inp: &VipsImage,
filename: &str,
rawsave_options: &RawsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = rawsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let strip_in: i32 = if rawsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&rawsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_rawsave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::RawsaveError)
}
}
pub fn rawsave_fd(inp: &VipsImage, fd: i32) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let fd_in: i32 = fd;
let vips_op_response = bindings::vips_rawsave_fd(inp_in, fd_in, NULL);
utils::result(vips_op_response, (), Error::RawsaveFdError)
}
}
#[derive(Clone, Debug)]
pub struct RawsaveFdOptions {
pub page_height: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for RawsaveFdOptions {
fn default() -> Self {
RawsaveFdOptions {
page_height: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn rawsave_fd_with_opts(
inp: &VipsImage,
fd: i32,
rawsave_fd_options: &RawsaveFdOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let fd_in: i32 = fd;
let page_height_in: i32 = rawsave_fd_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let strip_in: i32 = if rawsave_fd_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&rawsave_fd_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_rawsave_fd(
inp_in,
fd_in,
page_height_in_name.as_ptr(),
page_height_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::RawsaveFdError)
}
}
pub fn vipssave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_vipssave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::VipssaveError)
}
}
#[derive(Clone, Debug)]
pub struct VipssaveOptions {
pub page_height: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for VipssaveOptions {
fn default() -> Self {
VipssaveOptions {
page_height: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn vipssave_with_opts(
inp: &VipsImage,
filename: &str,
vipssave_options: &VipssaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = vipssave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let strip_in: i32 = if vipssave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&vipssave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_vipssave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::VipssaveError)
}
}
pub fn ppmsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_ppmsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::PpmsaveError)
}
}
#[derive(Clone, Debug)]
pub struct PpmsaveOptions {
pub page_height: i32,
pub ascii: bool,
pub squash: bool,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for PpmsaveOptions {
fn default() -> Self {
PpmsaveOptions {
page_height: i32::from(0),
ascii: false,
squash: false,
strip: false,
background: Vec::new(),
}
}
}
pub fn ppmsave_with_opts(
inp: &VipsImage,
filename: &str,
ppmsave_options: &PpmsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = ppmsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let ascii_in: i32 = if ppmsave_options.ascii { 1 } else { 0 };
let ascii_in_name = utils::new_c_string("ascii")?;
let squash_in: i32 = if ppmsave_options.squash { 1 } else { 0 };
let squash_in_name = utils::new_c_string("squash")?;
let strip_in: i32 = if ppmsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&ppmsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_ppmsave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
ascii_in_name.as_ptr(),
ascii_in,
squash_in_name.as_ptr(),
squash_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::PpmsaveError)
}
}
pub fn radsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_radsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::RadsaveError)
}
}
#[derive(Clone, Debug)]
pub struct RadsaveOptions {
pub page_height: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for RadsaveOptions {
fn default() -> Self {
RadsaveOptions {
page_height: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn radsave_with_opts(
inp: &VipsImage,
filename: &str,
radsave_options: &RadsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = radsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let strip_in: i32 = if radsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&radsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_radsave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::RadsaveError)
}
}
pub fn radsave_buffer(inp: &VipsImage) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let vips_op_response =
bindings::vips_radsave_buffer(inp_in, &mut buffer_out, &mut buffer_buf_size, NULL);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::RadsaveBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct RadsaveBufferOptions {
pub page_height: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for RadsaveBufferOptions {
fn default() -> Self {
RadsaveBufferOptions {
page_height: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn radsave_buffer_with_opts(
inp: &VipsImage,
radsave_buffer_options: &RadsaveBufferOptions,
) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let page_height_in: i32 = radsave_buffer_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let strip_in: i32 = if radsave_buffer_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&radsave_buffer_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_radsave_buffer(
inp_in,
&mut buffer_out,
&mut buffer_buf_size,
page_height_in_name.as_ptr(),
page_height_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::RadsaveBufferError,
)
}
}
pub fn dzsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_dzsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::DzsaveError)
}
}
#[derive(Clone, Debug)]
pub struct DzsaveOptions {
pub basename: String,
pub layout: ForeignDzLayout,
pub page_height: i32,
pub suffix: String,
pub overlap: i32,
pub tile_size: i32,
pub centre: bool,
pub depth: ForeignDzDepth,
pub angle: Angle,
pub container: ForeignDzContainer,
pub properties: bool,
pub compression: i32,
pub region_shrink: RegionShrink,
pub skip_blanks: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for DzsaveOptions {
fn default() -> Self {
DzsaveOptions {
basename: String::new(),
layout: ForeignDzLayout::Dz,
page_height: i32::from(0),
suffix: String::new(),
overlap: i32::from(1),
tile_size: i32::from(254),
centre: false,
depth: ForeignDzDepth::Onepixel,
angle: Angle::D0,
container: ForeignDzContainer::F,
properties: false,
compression: i32::from(0),
region_shrink: RegionShrink::Mean,
skip_blanks: i32::from(-1),
strip: false,
background: Vec::new(),
}
}
}
pub fn dzsave_with_opts(
inp: &VipsImage,
filename: &str,
dzsave_options: &DzsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let basename_in: CString = utils::new_c_string(&dzsave_options.basename)?;
let basename_in_name = utils::new_c_string("basename")?;
let layout_in: i32 = dzsave_options.layout as i32;
let layout_in_name = utils::new_c_string("layout")?;
let page_height_in: i32 = dzsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let suffix_in: CString = utils::new_c_string(&dzsave_options.suffix)?;
let suffix_in_name = utils::new_c_string("suffix")?;
let overlap_in: i32 = dzsave_options.overlap;
let overlap_in_name = utils::new_c_string("overlap")?;
let tile_size_in: i32 = dzsave_options.tile_size;
let tile_size_in_name = utils::new_c_string("tile-size")?;
let centre_in: i32 = if dzsave_options.centre { 1 } else { 0 };
let centre_in_name = utils::new_c_string("centre")?;
let depth_in: i32 = dzsave_options.depth as i32;
let depth_in_name = utils::new_c_string("depth")?;
let angle_in: i32 = dzsave_options.angle as i32;
let angle_in_name = utils::new_c_string("angle")?;
let container_in: i32 = dzsave_options.container as i32;
let container_in_name = utils::new_c_string("container")?;
let properties_in: i32 = if dzsave_options.properties { 1 } else { 0 };
let properties_in_name = utils::new_c_string("properties")?;
let compression_in: i32 = dzsave_options.compression;
let compression_in_name = utils::new_c_string("compression")?;
let region_shrink_in: i32 = dzsave_options.region_shrink as i32;
let region_shrink_in_name = utils::new_c_string("region-shrink")?;
let skip_blanks_in: i32 = dzsave_options.skip_blanks;
let skip_blanks_in_name = utils::new_c_string("skip-blanks")?;
let strip_in: i32 = if dzsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&dzsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_dzsave(
inp_in,
filename_in.as_ptr(),
basename_in_name.as_ptr(),
basename_in.as_ptr(),
layout_in_name.as_ptr(),
layout_in,
page_height_in_name.as_ptr(),
page_height_in,
suffix_in_name.as_ptr(),
suffix_in.as_ptr(),
overlap_in_name.as_ptr(),
overlap_in,
tile_size_in_name.as_ptr(),
tile_size_in,
centre_in_name.as_ptr(),
centre_in,
depth_in_name.as_ptr(),
depth_in,
angle_in_name.as_ptr(),
angle_in,
container_in_name.as_ptr(),
container_in,
properties_in_name.as_ptr(),
properties_in,
compression_in_name.as_ptr(),
compression_in,
region_shrink_in_name.as_ptr(),
region_shrink_in,
skip_blanks_in_name.as_ptr(),
skip_blanks_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::DzsaveError)
}
}
pub fn pngsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_pngsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::PngsaveError)
}
}
#[derive(Clone, Debug)]
pub struct PngsaveOptions {
pub compression: i32,
pub interlace: bool,
pub page_height: i32,
pub profile: String,
pub filter: ForeignPngFilter,
pub palette: bool,
pub colours: i32,
pub q: i32,
pub dither: f64,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for PngsaveOptions {
fn default() -> Self {
PngsaveOptions {
compression: i32::from(6),
interlace: false,
page_height: i32::from(0),
profile: String::from("sRGB"),
filter: ForeignPngFilter::All,
palette: false,
colours: i32::from(256),
q: i32::from(100),
dither: f64::from(1),
strip: false,
background: Vec::new(),
}
}
}
pub fn pngsave_with_opts(
inp: &VipsImage,
filename: &str,
pngsave_options: &PngsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let compression_in: i32 = pngsave_options.compression;
let compression_in_name = utils::new_c_string("compression")?;
let interlace_in: i32 = if pngsave_options.interlace { 1 } else { 0 };
let interlace_in_name = utils::new_c_string("interlace")?;
let page_height_in: i32 = pngsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let profile_in: CString = utils::new_c_string(&pngsave_options.profile)?;
let profile_in_name = utils::new_c_string("profile")?;
let filter_in: i32 = pngsave_options.filter as i32;
let filter_in_name = utils::new_c_string("filter")?;
let palette_in: i32 = if pngsave_options.palette { 1 } else { 0 };
let palette_in_name = utils::new_c_string("palette")?;
let colours_in: i32 = pngsave_options.colours;
let colours_in_name = utils::new_c_string("colours")?;
let q_in: i32 = pngsave_options.q;
let q_in_name = utils::new_c_string("Q")?;
let dither_in: f64 = pngsave_options.dither;
let dither_in_name = utils::new_c_string("dither")?;
let strip_in: i32 = if pngsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&pngsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_pngsave(
inp_in,
filename_in.as_ptr(),
compression_in_name.as_ptr(),
compression_in,
interlace_in_name.as_ptr(),
interlace_in,
page_height_in_name.as_ptr(),
page_height_in,
profile_in_name.as_ptr(),
profile_in.as_ptr(),
filter_in_name.as_ptr(),
filter_in,
palette_in_name.as_ptr(),
palette_in,
colours_in_name.as_ptr(),
colours_in,
q_in_name.as_ptr(),
q_in,
dither_in_name.as_ptr(),
dither_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::PngsaveError)
}
}
pub fn pngsave_buffer(inp: &VipsImage) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let vips_op_response =
bindings::vips_pngsave_buffer(inp_in, &mut buffer_out, &mut buffer_buf_size, NULL);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::PngsaveBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct PngsaveBufferOptions {
pub compression: i32,
pub interlace: bool,
pub page_height: i32,
pub profile: String,
pub filter: ForeignPngFilter,
pub palette: bool,
pub colours: i32,
pub q: i32,
pub dither: f64,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for PngsaveBufferOptions {
fn default() -> Self {
PngsaveBufferOptions {
compression: i32::from(6),
interlace: false,
page_height: i32::from(0),
profile: String::from("sRGB"),
filter: ForeignPngFilter::All,
palette: false,
colours: i32::from(256),
q: i32::from(100),
dither: f64::from(1),
strip: false,
background: Vec::new(),
}
}
}
pub fn pngsave_buffer_with_opts(
inp: &VipsImage,
pngsave_buffer_options: &PngsaveBufferOptions,
) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let compression_in: i32 = pngsave_buffer_options.compression;
let compression_in_name = utils::new_c_string("compression")?;
let interlace_in: i32 = if pngsave_buffer_options.interlace {
1
} else {
0
};
let interlace_in_name = utils::new_c_string("interlace")?;
let page_height_in: i32 = pngsave_buffer_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let profile_in: CString = utils::new_c_string(&pngsave_buffer_options.profile)?;
let profile_in_name = utils::new_c_string("profile")?;
let filter_in: i32 = pngsave_buffer_options.filter as i32;
let filter_in_name = utils::new_c_string("filter")?;
let palette_in: i32 = if pngsave_buffer_options.palette { 1 } else { 0 };
let palette_in_name = utils::new_c_string("palette")?;
let colours_in: i32 = pngsave_buffer_options.colours;
let colours_in_name = utils::new_c_string("colours")?;
let q_in: i32 = pngsave_buffer_options.q;
let q_in_name = utils::new_c_string("Q")?;
let dither_in: f64 = pngsave_buffer_options.dither;
let dither_in_name = utils::new_c_string("dither")?;
let strip_in: i32 = if pngsave_buffer_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&pngsave_buffer_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_pngsave_buffer(
inp_in,
&mut buffer_out,
&mut buffer_buf_size,
compression_in_name.as_ptr(),
compression_in,
interlace_in_name.as_ptr(),
interlace_in,
page_height_in_name.as_ptr(),
page_height_in,
profile_in_name.as_ptr(),
profile_in.as_ptr(),
filter_in_name.as_ptr(),
filter_in,
palette_in_name.as_ptr(),
palette_in,
colours_in_name.as_ptr(),
colours_in,
q_in_name.as_ptr(),
q_in,
dither_in_name.as_ptr(),
dither_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::PngsaveBufferError,
)
}
}
pub fn jpegsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_jpegsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::JpegsaveError)
}
}
#[derive(Clone, Debug)]
pub struct JpegsaveOptions {
pub page_height: i32,
pub q: i32,
pub profile: String,
pub optimize_coding: bool,
pub interlace: bool,
pub no_subsample: bool,
pub trellis_quant: bool,
pub overshoot_deringing: bool,
pub optimize_scans: bool,
pub quant_table: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for JpegsaveOptions {
fn default() -> Self {
JpegsaveOptions {
page_height: i32::from(0),
q: i32::from(75),
profile: String::from("sRGB"),
optimize_coding: false,
interlace: false,
no_subsample: false,
trellis_quant: false,
overshoot_deringing: false,
optimize_scans: false,
quant_table: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn jpegsave_with_opts(
inp: &VipsImage,
filename: &str,
jpegsave_options: &JpegsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = jpegsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let q_in: i32 = jpegsave_options.q;
let q_in_name = utils::new_c_string("Q")?;
let profile_in: CString = utils::new_c_string(&jpegsave_options.profile)?;
let profile_in_name = utils::new_c_string("profile")?;
let optimize_coding_in: i32 = if jpegsave_options.optimize_coding {
1
} else {
0
};
let optimize_coding_in_name = utils::new_c_string("optimize-coding")?;
let interlace_in: i32 = if jpegsave_options.interlace { 1 } else { 0 };
let interlace_in_name = utils::new_c_string("interlace")?;
let no_subsample_in: i32 = if jpegsave_options.no_subsample { 1 } else { 0 };
let no_subsample_in_name = utils::new_c_string("no-subsample")?;
let trellis_quant_in: i32 = if jpegsave_options.trellis_quant { 1 } else { 0 };
let trellis_quant_in_name = utils::new_c_string("trellis-quant")?;
let overshoot_deringing_in: i32 = if jpegsave_options.overshoot_deringing {
1
} else {
0
};
let overshoot_deringing_in_name = utils::new_c_string("overshoot-deringing")?;
let optimize_scans_in: i32 = if jpegsave_options.optimize_scans {
1
} else {
0
};
let optimize_scans_in_name = utils::new_c_string("optimize-scans")?;
let quant_table_in: i32 = jpegsave_options.quant_table;
let quant_table_in_name = utils::new_c_string("quant-table")?;
let strip_in: i32 = if jpegsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&jpegsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_jpegsave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
q_in_name.as_ptr(),
q_in,
profile_in_name.as_ptr(),
profile_in.as_ptr(),
optimize_coding_in_name.as_ptr(),
optimize_coding_in,
interlace_in_name.as_ptr(),
interlace_in,
no_subsample_in_name.as_ptr(),
no_subsample_in,
trellis_quant_in_name.as_ptr(),
trellis_quant_in,
overshoot_deringing_in_name.as_ptr(),
overshoot_deringing_in,
optimize_scans_in_name.as_ptr(),
optimize_scans_in,
quant_table_in_name.as_ptr(),
quant_table_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::JpegsaveError)
}
}
pub fn jpegsave_buffer(inp: &VipsImage) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let vips_op_response =
bindings::vips_jpegsave_buffer(inp_in, &mut buffer_out, &mut buffer_buf_size, NULL);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::JpegsaveBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct JpegsaveBufferOptions {
pub page_height: i32,
pub q: i32,
pub profile: String,
pub optimize_coding: bool,
pub interlace: bool,
pub no_subsample: bool,
pub trellis_quant: bool,
pub overshoot_deringing: bool,
pub optimize_scans: bool,
pub quant_table: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for JpegsaveBufferOptions {
fn default() -> Self {
JpegsaveBufferOptions {
page_height: i32::from(0),
q: i32::from(75),
profile: String::from("sRGB"),
optimize_coding: false,
interlace: false,
no_subsample: false,
trellis_quant: false,
overshoot_deringing: false,
optimize_scans: false,
quant_table: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn jpegsave_buffer_with_opts(
inp: &VipsImage,
jpegsave_buffer_options: &JpegsaveBufferOptions,
) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let page_height_in: i32 = jpegsave_buffer_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let q_in: i32 = jpegsave_buffer_options.q;
let q_in_name = utils::new_c_string("Q")?;
let profile_in: CString = utils::new_c_string(&jpegsave_buffer_options.profile)?;
let profile_in_name = utils::new_c_string("profile")?;
let optimize_coding_in: i32 = if jpegsave_buffer_options.optimize_coding {
1
} else {
0
};
let optimize_coding_in_name = utils::new_c_string("optimize-coding")?;
let interlace_in: i32 = if jpegsave_buffer_options.interlace {
1
} else {
0
};
let interlace_in_name = utils::new_c_string("interlace")?;
let no_subsample_in: i32 = if jpegsave_buffer_options.no_subsample {
1
} else {
0
};
let no_subsample_in_name = utils::new_c_string("no-subsample")?;
let trellis_quant_in: i32 = if jpegsave_buffer_options.trellis_quant {
1
} else {
0
};
let trellis_quant_in_name = utils::new_c_string("trellis-quant")?;
let overshoot_deringing_in: i32 = if jpegsave_buffer_options.overshoot_deringing {
1
} else {
0
};
let overshoot_deringing_in_name = utils::new_c_string("overshoot-deringing")?;
let optimize_scans_in: i32 = if jpegsave_buffer_options.optimize_scans {
1
} else {
0
};
let optimize_scans_in_name = utils::new_c_string("optimize-scans")?;
let quant_table_in: i32 = jpegsave_buffer_options.quant_table;
let quant_table_in_name = utils::new_c_string("quant-table")?;
let strip_in: i32 = if jpegsave_buffer_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&jpegsave_buffer_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_jpegsave_buffer(
inp_in,
&mut buffer_out,
&mut buffer_buf_size,
page_height_in_name.as_ptr(),
page_height_in,
q_in_name.as_ptr(),
q_in,
profile_in_name.as_ptr(),
profile_in.as_ptr(),
optimize_coding_in_name.as_ptr(),
optimize_coding_in,
interlace_in_name.as_ptr(),
interlace_in,
no_subsample_in_name.as_ptr(),
no_subsample_in,
trellis_quant_in_name.as_ptr(),
trellis_quant_in,
overshoot_deringing_in_name.as_ptr(),
overshoot_deringing_in,
optimize_scans_in_name.as_ptr(),
optimize_scans_in,
quant_table_in_name.as_ptr(),
quant_table_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::JpegsaveBufferError,
)
}
}
pub fn jpegsave_mime(inp: &VipsImage) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let vips_op_response = bindings::vips_jpegsave_mime(inp_in, NULL);
utils::result(vips_op_response, (), Error::JpegsaveMimeError)
}
}
#[derive(Clone, Debug)]
pub struct JpegsaveMimeOptions {
pub page_height: i32,
pub q: i32,
pub profile: String,
pub optimize_coding: bool,
pub interlace: bool,
pub no_subsample: bool,
pub trellis_quant: bool,
pub overshoot_deringing: bool,
pub optimize_scans: bool,
pub quant_table: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for JpegsaveMimeOptions {
fn default() -> Self {
JpegsaveMimeOptions {
page_height: i32::from(0),
q: i32::from(75),
profile: String::from("sRGB"),
optimize_coding: false,
interlace: false,
no_subsample: false,
trellis_quant: false,
overshoot_deringing: false,
optimize_scans: false,
quant_table: i32::from(0),
strip: false,
background: Vec::new(),
}
}
}
pub fn jpegsave_mime_with_opts(
inp: &VipsImage,
jpegsave_mime_options: &JpegsaveMimeOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let page_height_in: i32 = jpegsave_mime_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let q_in: i32 = jpegsave_mime_options.q;
let q_in_name = utils::new_c_string("Q")?;
let profile_in: CString = utils::new_c_string(&jpegsave_mime_options.profile)?;
let profile_in_name = utils::new_c_string("profile")?;
let optimize_coding_in: i32 = if jpegsave_mime_options.optimize_coding {
1
} else {
0
};
let optimize_coding_in_name = utils::new_c_string("optimize-coding")?;
let interlace_in: i32 = if jpegsave_mime_options.interlace {
1
} else {
0
};
let interlace_in_name = utils::new_c_string("interlace")?;
let no_subsample_in: i32 = if jpegsave_mime_options.no_subsample {
1
} else {
0
};
let no_subsample_in_name = utils::new_c_string("no-subsample")?;
let trellis_quant_in: i32 = if jpegsave_mime_options.trellis_quant {
1
} else {
0
};
let trellis_quant_in_name = utils::new_c_string("trellis-quant")?;
let overshoot_deringing_in: i32 = if jpegsave_mime_options.overshoot_deringing {
1
} else {
0
};
let overshoot_deringing_in_name = utils::new_c_string("overshoot-deringing")?;
let optimize_scans_in: i32 = if jpegsave_mime_options.optimize_scans {
1
} else {
0
};
let optimize_scans_in_name = utils::new_c_string("optimize-scans")?;
let quant_table_in: i32 = jpegsave_mime_options.quant_table;
let quant_table_in_name = utils::new_c_string("quant-table")?;
let strip_in: i32 = if jpegsave_mime_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&jpegsave_mime_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_jpegsave_mime(
inp_in,
page_height_in_name.as_ptr(),
page_height_in,
q_in_name.as_ptr(),
q_in,
profile_in_name.as_ptr(),
profile_in.as_ptr(),
optimize_coding_in_name.as_ptr(),
optimize_coding_in,
interlace_in_name.as_ptr(),
interlace_in,
no_subsample_in_name.as_ptr(),
no_subsample_in,
trellis_quant_in_name.as_ptr(),
trellis_quant_in,
overshoot_deringing_in_name.as_ptr(),
overshoot_deringing_in,
optimize_scans_in_name.as_ptr(),
optimize_scans_in,
quant_table_in_name.as_ptr(),
quant_table_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::JpegsaveMimeError)
}
}
pub fn webpsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_webpsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::WebpsaveError)
}
}
#[derive(Clone, Debug)]
pub struct WebpsaveOptions {
pub page_height: i32,
pub q: i32,
pub lossless: bool,
pub preset: ForeignWebpPreset,
pub smart_subsample: bool,
pub near_lossless: bool,
pub alpha_q: i32,
pub min_size: bool,
pub kmin: i32,
pub kmax: i32,
pub reduction_effort: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for WebpsaveOptions {
fn default() -> Self {
WebpsaveOptions {
page_height: i32::from(0),
q: i32::from(75),
lossless: false,
preset: ForeignWebpPreset::Default,
smart_subsample: false,
near_lossless: false,
alpha_q: i32::from(100),
min_size: false,
kmin: i32::from(2147483646),
kmax: i32::from(2147483647),
reduction_effort: i32::from(4),
strip: false,
background: Vec::new(),
}
}
}
pub fn webpsave_with_opts(
inp: &VipsImage,
filename: &str,
webpsave_options: &WebpsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = webpsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let q_in: i32 = webpsave_options.q;
let q_in_name = utils::new_c_string("Q")?;
let lossless_in: i32 = if webpsave_options.lossless { 1 } else { 0 };
let lossless_in_name = utils::new_c_string("lossless")?;
let preset_in: i32 = webpsave_options.preset as i32;
let preset_in_name = utils::new_c_string("preset")?;
let smart_subsample_in: i32 = if webpsave_options.smart_subsample {
1
} else {
0
};
let smart_subsample_in_name = utils::new_c_string("smart-subsample")?;
let near_lossless_in: i32 = if webpsave_options.near_lossless { 1 } else { 0 };
let near_lossless_in_name = utils::new_c_string("near-lossless")?;
let alpha_q_in: i32 = webpsave_options.alpha_q;
let alpha_q_in_name = utils::new_c_string("alpha-q")?;
let min_size_in: i32 = if webpsave_options.min_size { 1 } else { 0 };
let min_size_in_name = utils::new_c_string("min-size")?;
let kmin_in: i32 = webpsave_options.kmin;
let kmin_in_name = utils::new_c_string("kmin")?;
let kmax_in: i32 = webpsave_options.kmax;
let kmax_in_name = utils::new_c_string("kmax")?;
let reduction_effort_in: i32 = webpsave_options.reduction_effort;
let reduction_effort_in_name = utils::new_c_string("reduction-effort")?;
let strip_in: i32 = if webpsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&webpsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_webpsave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
q_in_name.as_ptr(),
q_in,
lossless_in_name.as_ptr(),
lossless_in,
preset_in_name.as_ptr(),
preset_in,
smart_subsample_in_name.as_ptr(),
smart_subsample_in,
near_lossless_in_name.as_ptr(),
near_lossless_in,
alpha_q_in_name.as_ptr(),
alpha_q_in,
min_size_in_name.as_ptr(),
min_size_in,
kmin_in_name.as_ptr(),
kmin_in,
kmax_in_name.as_ptr(),
kmax_in,
reduction_effort_in_name.as_ptr(),
reduction_effort_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::WebpsaveError)
}
}
pub fn webpsave_buffer(inp: &VipsImage) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let vips_op_response =
bindings::vips_webpsave_buffer(inp_in, &mut buffer_out, &mut buffer_buf_size, NULL);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::WebpsaveBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct WebpsaveBufferOptions {
pub page_height: i32,
pub q: i32,
pub lossless: bool,
pub preset: ForeignWebpPreset,
pub smart_subsample: bool,
pub near_lossless: bool,
pub alpha_q: i32,
pub min_size: bool,
pub kmin: i32,
pub kmax: i32,
pub reduction_effort: i32,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for WebpsaveBufferOptions {
fn default() -> Self {
WebpsaveBufferOptions {
page_height: i32::from(0),
q: i32::from(75),
lossless: false,
preset: ForeignWebpPreset::Default,
smart_subsample: false,
near_lossless: false,
alpha_q: i32::from(100),
min_size: false,
kmin: i32::from(2147483646),
kmax: i32::from(2147483647),
reduction_effort: i32::from(4),
strip: false,
background: Vec::new(),
}
}
}
pub fn webpsave_buffer_with_opts(
inp: &VipsImage,
webpsave_buffer_options: &WebpsaveBufferOptions,
) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let page_height_in: i32 = webpsave_buffer_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let q_in: i32 = webpsave_buffer_options.q;
let q_in_name = utils::new_c_string("Q")?;
let lossless_in: i32 = if webpsave_buffer_options.lossless {
1
} else {
0
};
let lossless_in_name = utils::new_c_string("lossless")?;
let preset_in: i32 = webpsave_buffer_options.preset as i32;
let preset_in_name = utils::new_c_string("preset")?;
let smart_subsample_in: i32 = if webpsave_buffer_options.smart_subsample {
1
} else {
0
};
let smart_subsample_in_name = utils::new_c_string("smart-subsample")?;
let near_lossless_in: i32 = if webpsave_buffer_options.near_lossless {
1
} else {
0
};
let near_lossless_in_name = utils::new_c_string("near-lossless")?;
let alpha_q_in: i32 = webpsave_buffer_options.alpha_q;
let alpha_q_in_name = utils::new_c_string("alpha-q")?;
let min_size_in: i32 = if webpsave_buffer_options.min_size {
1
} else {
0
};
let min_size_in_name = utils::new_c_string("min-size")?;
let kmin_in: i32 = webpsave_buffer_options.kmin;
let kmin_in_name = utils::new_c_string("kmin")?;
let kmax_in: i32 = webpsave_buffer_options.kmax;
let kmax_in_name = utils::new_c_string("kmax")?;
let reduction_effort_in: i32 = webpsave_buffer_options.reduction_effort;
let reduction_effort_in_name = utils::new_c_string("reduction-effort")?;
let strip_in: i32 = if webpsave_buffer_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&webpsave_buffer_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_webpsave_buffer(
inp_in,
&mut buffer_out,
&mut buffer_buf_size,
page_height_in_name.as_ptr(),
page_height_in,
q_in_name.as_ptr(),
q_in,
lossless_in_name.as_ptr(),
lossless_in,
preset_in_name.as_ptr(),
preset_in,
smart_subsample_in_name.as_ptr(),
smart_subsample_in,
near_lossless_in_name.as_ptr(),
near_lossless_in,
alpha_q_in_name.as_ptr(),
alpha_q_in,
min_size_in_name.as_ptr(),
min_size_in,
kmin_in_name.as_ptr(),
kmin_in,
kmax_in_name.as_ptr(),
kmax_in,
reduction_effort_in_name.as_ptr(),
reduction_effort_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::WebpsaveBufferError,
)
}
}
pub fn tiffsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_tiffsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::TiffsaveError)
}
}
#[derive(Clone, Debug)]
pub struct TiffsaveOptions {
pub compression: ForeignTiffCompression,
pub q: i32,
pub predictor: ForeignTiffPredictor,
pub page_height: i32,
pub profile: String,
pub tile: bool,
pub tile_width: i32,
pub tile_height: i32,
pub pyramid: bool,
pub miniswhite: bool,
pub squash: bool,
pub resunit: ForeignTiffResunit,
pub xres: f64,
pub yres: f64,
pub bigtiff: bool,
pub properties: bool,
pub region_shrink: RegionShrink,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for TiffsaveOptions {
fn default() -> Self {
TiffsaveOptions {
compression: ForeignTiffCompression::None,
q: i32::from(75),
predictor: ForeignTiffPredictor::Horizontal,
page_height: i32::from(0),
profile: String::from("sRGB"),
tile: false,
tile_width: i32::from(128),
tile_height: i32::from(128),
pyramid: false,
miniswhite: false,
squash: false,
resunit: ForeignTiffResunit::Cm,
xres: f64::from(1),
yres: f64::from(1),
bigtiff: false,
properties: false,
region_shrink: RegionShrink::Mean,
strip: false,
background: Vec::new(),
}
}
}
pub fn tiffsave_with_opts(
inp: &VipsImage,
filename: &str,
tiffsave_options: &TiffsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let compression_in: i32 = tiffsave_options.compression as i32;
let compression_in_name = utils::new_c_string("compression")?;
let q_in: i32 = tiffsave_options.q;
let q_in_name = utils::new_c_string("Q")?;
let predictor_in: i32 = tiffsave_options.predictor as i32;
let predictor_in_name = utils::new_c_string("predictor")?;
let page_height_in: i32 = tiffsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let profile_in: CString = utils::new_c_string(&tiffsave_options.profile)?;
let profile_in_name = utils::new_c_string("profile")?;
let tile_in: i32 = if tiffsave_options.tile { 1 } else { 0 };
let tile_in_name = utils::new_c_string("tile")?;
let tile_width_in: i32 = tiffsave_options.tile_width;
let tile_width_in_name = utils::new_c_string("tile-width")?;
let tile_height_in: i32 = tiffsave_options.tile_height;
let tile_height_in_name = utils::new_c_string("tile-height")?;
let pyramid_in: i32 = if tiffsave_options.pyramid { 1 } else { 0 };
let pyramid_in_name = utils::new_c_string("pyramid")?;
let miniswhite_in: i32 = if tiffsave_options.miniswhite { 1 } else { 0 };
let miniswhite_in_name = utils::new_c_string("miniswhite")?;
let squash_in: i32 = if tiffsave_options.squash { 1 } else { 0 };
let squash_in_name = utils::new_c_string("squash")?;
let resunit_in: i32 = tiffsave_options.resunit as i32;
let resunit_in_name = utils::new_c_string("resunit")?;
let xres_in: f64 = tiffsave_options.xres;
let xres_in_name = utils::new_c_string("xres")?;
let yres_in: f64 = tiffsave_options.yres;
let yres_in_name = utils::new_c_string("yres")?;
let bigtiff_in: i32 = if tiffsave_options.bigtiff { 1 } else { 0 };
let bigtiff_in_name = utils::new_c_string("bigtiff")?;
let properties_in: i32 = if tiffsave_options.properties { 1 } else { 0 };
let properties_in_name = utils::new_c_string("properties")?;
let region_shrink_in: i32 = tiffsave_options.region_shrink as i32;
let region_shrink_in_name = utils::new_c_string("region-shrink")?;
let strip_in: i32 = if tiffsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&tiffsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_tiffsave(
inp_in,
filename_in.as_ptr(),
compression_in_name.as_ptr(),
compression_in,
q_in_name.as_ptr(),
q_in,
predictor_in_name.as_ptr(),
predictor_in,
page_height_in_name.as_ptr(),
page_height_in,
profile_in_name.as_ptr(),
profile_in.as_ptr(),
tile_in_name.as_ptr(),
tile_in,
tile_width_in_name.as_ptr(),
tile_width_in,
tile_height_in_name.as_ptr(),
tile_height_in,
pyramid_in_name.as_ptr(),
pyramid_in,
miniswhite_in_name.as_ptr(),
miniswhite_in,
squash_in_name.as_ptr(),
squash_in,
resunit_in_name.as_ptr(),
resunit_in,
xres_in_name.as_ptr(),
xres_in,
yres_in_name.as_ptr(),
yres_in,
bigtiff_in_name.as_ptr(),
bigtiff_in,
properties_in_name.as_ptr(),
properties_in,
region_shrink_in_name.as_ptr(),
region_shrink_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::TiffsaveError)
}
}
pub fn tiffsave_buffer(inp: &VipsImage) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let vips_op_response =
bindings::vips_tiffsave_buffer(inp_in, &mut buffer_out, &mut buffer_buf_size, NULL);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::TiffsaveBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct TiffsaveBufferOptions {
pub compression: ForeignTiffCompression,
pub q: i32,
pub predictor: ForeignTiffPredictor,
pub page_height: i32,
pub profile: String,
pub tile: bool,
pub tile_width: i32,
pub tile_height: i32,
pub pyramid: bool,
pub miniswhite: bool,
pub squash: bool,
pub resunit: ForeignTiffResunit,
pub xres: f64,
pub yres: f64,
pub bigtiff: bool,
pub properties: bool,
pub region_shrink: RegionShrink,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for TiffsaveBufferOptions {
fn default() -> Self {
TiffsaveBufferOptions {
compression: ForeignTiffCompression::None,
q: i32::from(75),
predictor: ForeignTiffPredictor::Horizontal,
page_height: i32::from(0),
profile: String::from("sRGB"),
tile: false,
tile_width: i32::from(128),
tile_height: i32::from(128),
pyramid: false,
miniswhite: false,
squash: false,
resunit: ForeignTiffResunit::Cm,
xres: f64::from(1),
yres: f64::from(1),
bigtiff: false,
properties: false,
region_shrink: RegionShrink::Mean,
strip: false,
background: Vec::new(),
}
}
}
pub fn tiffsave_buffer_with_opts(
inp: &VipsImage,
tiffsave_buffer_options: &TiffsaveBufferOptions,
) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let compression_in: i32 = tiffsave_buffer_options.compression as i32;
let compression_in_name = utils::new_c_string("compression")?;
let q_in: i32 = tiffsave_buffer_options.q;
let q_in_name = utils::new_c_string("Q")?;
let predictor_in: i32 = tiffsave_buffer_options.predictor as i32;
let predictor_in_name = utils::new_c_string("predictor")?;
let page_height_in: i32 = tiffsave_buffer_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let profile_in: CString = utils::new_c_string(&tiffsave_buffer_options.profile)?;
let profile_in_name = utils::new_c_string("profile")?;
let tile_in: i32 = if tiffsave_buffer_options.tile { 1 } else { 0 };
let tile_in_name = utils::new_c_string("tile")?;
let tile_width_in: i32 = tiffsave_buffer_options.tile_width;
let tile_width_in_name = utils::new_c_string("tile-width")?;
let tile_height_in: i32 = tiffsave_buffer_options.tile_height;
let tile_height_in_name = utils::new_c_string("tile-height")?;
let pyramid_in: i32 = if tiffsave_buffer_options.pyramid {
1
} else {
0
};
let pyramid_in_name = utils::new_c_string("pyramid")?;
let miniswhite_in: i32 = if tiffsave_buffer_options.miniswhite {
1
} else {
0
};
let miniswhite_in_name = utils::new_c_string("miniswhite")?;
let squash_in: i32 = if tiffsave_buffer_options.squash { 1 } else { 0 };
let squash_in_name = utils::new_c_string("squash")?;
let resunit_in: i32 = tiffsave_buffer_options.resunit as i32;
let resunit_in_name = utils::new_c_string("resunit")?;
let xres_in: f64 = tiffsave_buffer_options.xres;
let xres_in_name = utils::new_c_string("xres")?;
let yres_in: f64 = tiffsave_buffer_options.yres;
let yres_in_name = utils::new_c_string("yres")?;
let bigtiff_in: i32 = if tiffsave_buffer_options.bigtiff {
1
} else {
0
};
let bigtiff_in_name = utils::new_c_string("bigtiff")?;
let properties_in: i32 = if tiffsave_buffer_options.properties {
1
} else {
0
};
let properties_in_name = utils::new_c_string("properties")?;
let region_shrink_in: i32 = tiffsave_buffer_options.region_shrink as i32;
let region_shrink_in_name = utils::new_c_string("region-shrink")?;
let strip_in: i32 = if tiffsave_buffer_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&tiffsave_buffer_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_tiffsave_buffer(
inp_in,
&mut buffer_out,
&mut buffer_buf_size,
compression_in_name.as_ptr(),
compression_in,
q_in_name.as_ptr(),
q_in,
predictor_in_name.as_ptr(),
predictor_in,
page_height_in_name.as_ptr(),
page_height_in,
profile_in_name.as_ptr(),
profile_in.as_ptr(),
tile_in_name.as_ptr(),
tile_in,
tile_width_in_name.as_ptr(),
tile_width_in,
tile_height_in_name.as_ptr(),
tile_height_in,
pyramid_in_name.as_ptr(),
pyramid_in,
miniswhite_in_name.as_ptr(),
miniswhite_in,
squash_in_name.as_ptr(),
squash_in,
resunit_in_name.as_ptr(),
resunit_in,
xres_in_name.as_ptr(),
xres_in,
yres_in_name.as_ptr(),
yres_in,
bigtiff_in_name.as_ptr(),
bigtiff_in,
properties_in_name.as_ptr(),
properties_in,
region_shrink_in_name.as_ptr(),
region_shrink_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::TiffsaveBufferError,
)
}
}
pub fn heifsave(inp: &VipsImage, filename: &str) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let vips_op_response = bindings::vips_heifsave(inp_in, filename_in.as_ptr(), NULL);
utils::result(vips_op_response, (), Error::HeifsaveError)
}
}
#[derive(Clone, Debug)]
pub struct HeifsaveOptions {
pub page_height: i32,
pub q: i32,
pub lossless: bool,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for HeifsaveOptions {
fn default() -> Self {
HeifsaveOptions {
page_height: i32::from(0),
q: i32::from(50),
lossless: false,
strip: false,
background: Vec::new(),
}
}
}
pub fn heifsave_with_opts(
inp: &VipsImage,
filename: &str,
heifsave_options: &HeifsaveOptions,
) -> Result<()> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let filename_in: CString = utils::new_c_string(filename)?;
let page_height_in: i32 = heifsave_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let q_in: i32 = heifsave_options.q;
let q_in_name = utils::new_c_string("Q")?;
let lossless_in: i32 = if heifsave_options.lossless { 1 } else { 0 };
let lossless_in_name = utils::new_c_string("lossless")?;
let strip_in: i32 = if heifsave_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&heifsave_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_heifsave(
inp_in,
filename_in.as_ptr(),
page_height_in_name.as_ptr(),
page_height_in,
q_in_name.as_ptr(),
q_in,
lossless_in_name.as_ptr(),
lossless_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(vips_op_response, (), Error::HeifsaveError)
}
}
pub fn heifsave_buffer(inp: &VipsImage) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let vips_op_response =
bindings::vips_heifsave_buffer(inp_in, &mut buffer_out, &mut buffer_buf_size, NULL);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::HeifsaveBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct HeifsaveBufferOptions {
pub page_height: i32,
pub q: i32,
pub lossless: bool,
pub strip: bool,
pub background: Vec<f64>,
}
impl std::default::Default for HeifsaveBufferOptions {
fn default() -> Self {
HeifsaveBufferOptions {
page_height: i32::from(0),
q: i32::from(50),
lossless: false,
strip: false,
background: Vec::new(),
}
}
}
pub fn heifsave_buffer_with_opts(
inp: &VipsImage,
heifsave_buffer_options: &HeifsaveBufferOptions,
) -> Result<Vec<u8>> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut buffer_buf_size: u64 = 0;
let mut buffer_out: *mut c_void = null_mut();
let page_height_in: i32 = heifsave_buffer_options.page_height;
let page_height_in_name = utils::new_c_string("page-height")?;
let q_in: i32 = heifsave_buffer_options.q;
let q_in_name = utils::new_c_string("Q")?;
let lossless_in: i32 = if heifsave_buffer_options.lossless {
1
} else {
0
};
let lossless_in_name = utils::new_c_string("lossless")?;
let strip_in: i32 = if heifsave_buffer_options.strip { 1 } else { 0 };
let strip_in_name = utils::new_c_string("strip")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&heifsave_buffer_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let vips_op_response = bindings::vips_heifsave_buffer(
inp_in,
&mut buffer_out,
&mut buffer_buf_size,
page_height_in_name.as_ptr(),
page_height_in,
q_in_name.as_ptr(),
q_in,
lossless_in_name.as_ptr(),
lossless_in,
strip_in_name.as_ptr(),
strip_in,
background_in_name.as_ptr(),
background_in,
NULL,
);
utils::result(
vips_op_response,
utils::new_byte_array(buffer_out, buffer_buf_size),
Error::HeifsaveBufferError,
)
}
}
pub fn thumbnail(filename: &str, width: i32) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let width_in: i32 = width;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_thumbnail(filename_in.as_ptr(), &mut out_out, width_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ThumbnailError,
)
}
}
#[derive(Clone, Debug)]
pub struct ThumbnailOptions {
pub height: i32,
pub size: Size,
pub no_rotate: bool,
pub crop: Interesting,
pub linear: bool,
pub import_profile: String,
pub export_profile: String,
pub intent: Intent,
}
impl std::default::Default for ThumbnailOptions {
fn default() -> Self {
ThumbnailOptions {
height: i32::from(1),
size: Size::Both,
no_rotate: false,
crop: Interesting::None,
linear: false,
import_profile: String::new(),
export_profile: String::new(),
intent: Intent::Relative,
}
}
}
pub fn thumbnail_with_opts(
filename: &str,
width: i32,
thumbnail_options: &ThumbnailOptions,
) -> Result<VipsImage> {
unsafe {
let filename_in: CString = utils::new_c_string(filename)?;
let width_in: i32 = width;
let mut out_out: *mut bindings::VipsImage = null_mut();
let height_in: i32 = thumbnail_options.height;
let height_in_name = utils::new_c_string("height")?;
let size_in: i32 = thumbnail_options.size as i32;
let size_in_name = utils::new_c_string("size")?;
let no_rotate_in: i32 = if thumbnail_options.no_rotate { 1 } else { 0 };
let no_rotate_in_name = utils::new_c_string("no-rotate")?;
let crop_in: i32 = thumbnail_options.crop as i32;
let crop_in_name = utils::new_c_string("crop")?;
let linear_in: i32 = if thumbnail_options.linear { 1 } else { 0 };
let linear_in_name = utils::new_c_string("linear")?;
let import_profile_in: CString = utils::new_c_string(&thumbnail_options.import_profile)?;
let import_profile_in_name = utils::new_c_string("import-profile")?;
let export_profile_in: CString = utils::new_c_string(&thumbnail_options.export_profile)?;
let export_profile_in_name = utils::new_c_string("export-profile")?;
let intent_in: i32 = thumbnail_options.intent as i32;
let intent_in_name = utils::new_c_string("intent")?;
let vips_op_response = bindings::vips_thumbnail(
filename_in.as_ptr(),
&mut out_out,
width_in,
height_in_name.as_ptr(),
height_in,
size_in_name.as_ptr(),
size_in,
no_rotate_in_name.as_ptr(),
no_rotate_in,
crop_in_name.as_ptr(),
crop_in,
linear_in_name.as_ptr(),
linear_in,
import_profile_in_name.as_ptr(),
import_profile_in.as_ptr(),
export_profile_in_name.as_ptr(),
export_profile_in.as_ptr(),
intent_in_name.as_ptr(),
intent_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ThumbnailError,
)
}
}
pub fn thumbnail_buffer(buffer: &[u8], width: i32) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let width_in: i32 = width;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_thumbnail_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
width_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ThumbnailBufferError,
)
}
}
#[derive(Clone, Debug)]
pub struct ThumbnailBufferOptions {
pub option_string: String,
pub height: i32,
pub size: Size,
pub no_rotate: bool,
pub crop: Interesting,
pub linear: bool,
pub import_profile: String,
pub export_profile: String,
pub intent: Intent,
}
impl std::default::Default for ThumbnailBufferOptions {
fn default() -> Self {
ThumbnailBufferOptions {
option_string: String::new(),
height: i32::from(1),
size: Size::Both,
no_rotate: false,
crop: Interesting::None,
linear: false,
import_profile: String::new(),
export_profile: String::new(),
intent: Intent::Relative,
}
}
}
pub fn thumbnail_buffer_with_opts(
buffer: &[u8],
width: i32,
thumbnail_buffer_options: &ThumbnailBufferOptions,
) -> Result<VipsImage> {
unsafe {
let buffer_in: *mut c_void = buffer.as_ptr() as *mut c_void;
let width_in: i32 = width;
let mut out_out: *mut bindings::VipsImage = null_mut();
let option_string_in: CString =
utils::new_c_string(&thumbnail_buffer_options.option_string)?;
let option_string_in_name = utils::new_c_string("option-string")?;
let height_in: i32 = thumbnail_buffer_options.height;
let height_in_name = utils::new_c_string("height")?;
let size_in: i32 = thumbnail_buffer_options.size as i32;
let size_in_name = utils::new_c_string("size")?;
let no_rotate_in: i32 = if thumbnail_buffer_options.no_rotate {
1
} else {
0
};
let no_rotate_in_name = utils::new_c_string("no-rotate")?;
let crop_in: i32 = thumbnail_buffer_options.crop as i32;
let crop_in_name = utils::new_c_string("crop")?;
let linear_in: i32 = if thumbnail_buffer_options.linear {
1
} else {
0
};
let linear_in_name = utils::new_c_string("linear")?;
let import_profile_in: CString =
utils::new_c_string(&thumbnail_buffer_options.import_profile)?;
let import_profile_in_name = utils::new_c_string("import-profile")?;
let export_profile_in: CString =
utils::new_c_string(&thumbnail_buffer_options.export_profile)?;
let export_profile_in_name = utils::new_c_string("export-profile")?;
let intent_in: i32 = thumbnail_buffer_options.intent as i32;
let intent_in_name = utils::new_c_string("intent")?;
let vips_op_response = bindings::vips_thumbnail_buffer(
buffer_in,
buffer.len() as u64,
&mut out_out,
width_in,
option_string_in_name.as_ptr(),
option_string_in.as_ptr(),
height_in_name.as_ptr(),
height_in,
size_in_name.as_ptr(),
size_in,
no_rotate_in_name.as_ptr(),
no_rotate_in,
crop_in_name.as_ptr(),
crop_in,
linear_in_name.as_ptr(),
linear_in,
import_profile_in_name.as_ptr(),
import_profile_in.as_ptr(),
export_profile_in_name.as_ptr(),
export_profile_in.as_ptr(),
intent_in_name.as_ptr(),
intent_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ThumbnailBufferError,
)
}
}
pub fn thumbnail_image(inp: &VipsImage, width: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let width_in: i32 = width;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_thumbnail_image(inp_in, &mut out_out, width_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ThumbnailImageError,
)
}
}
#[derive(Clone, Debug)]
pub struct ThumbnailImageOptions {
pub height: i32,
pub size: Size,
pub no_rotate: bool,
pub crop: Interesting,
pub linear: bool,
pub import_profile: String,
pub export_profile: String,
pub intent: Intent,
}
impl std::default::Default for ThumbnailImageOptions {
fn default() -> Self {
ThumbnailImageOptions {
height: i32::from(1),
size: Size::Both,
no_rotate: false,
crop: Interesting::None,
linear: false,
import_profile: String::new(),
export_profile: String::new(),
intent: Intent::Relative,
}
}
}
pub fn thumbnail_image_with_opts(
inp: &VipsImage,
width: i32,
thumbnail_image_options: &ThumbnailImageOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let width_in: i32 = width;
let mut out_out: *mut bindings::VipsImage = null_mut();
let height_in: i32 = thumbnail_image_options.height;
let height_in_name = utils::new_c_string("height")?;
let size_in: i32 = thumbnail_image_options.size as i32;
let size_in_name = utils::new_c_string("size")?;
let no_rotate_in: i32 = if thumbnail_image_options.no_rotate {
1
} else {
0
};
let no_rotate_in_name = utils::new_c_string("no-rotate")?;
let crop_in: i32 = thumbnail_image_options.crop as i32;
let crop_in_name = utils::new_c_string("crop")?;
let linear_in: i32 = if thumbnail_image_options.linear { 1 } else { 0 };
let linear_in_name = utils::new_c_string("linear")?;
let import_profile_in: CString =
utils::new_c_string(&thumbnail_image_options.import_profile)?;
let import_profile_in_name = utils::new_c_string("import-profile")?;
let export_profile_in: CString =
utils::new_c_string(&thumbnail_image_options.export_profile)?;
let export_profile_in_name = utils::new_c_string("export-profile")?;
let intent_in: i32 = thumbnail_image_options.intent as i32;
let intent_in_name = utils::new_c_string("intent")?;
let vips_op_response = bindings::vips_thumbnail_image(
inp_in,
&mut out_out,
width_in,
height_in_name.as_ptr(),
height_in,
size_in_name.as_ptr(),
size_in,
no_rotate_in_name.as_ptr(),
no_rotate_in,
crop_in_name.as_ptr(),
crop_in,
linear_in_name.as_ptr(),
linear_in,
import_profile_in_name.as_ptr(),
import_profile_in.as_ptr(),
export_profile_in_name.as_ptr(),
export_profile_in.as_ptr(),
intent_in_name.as_ptr(),
intent_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ThumbnailImageError,
)
}
}
pub fn mapim(inp: &VipsImage, index: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let index_in: *mut bindings::VipsImage = index.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mapim(inp_in, &mut out_out, index_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MapimError,
)
}
}
#[derive(Clone, Debug)]
pub struct MapimOptions {
pub interpolate: VipsInterpolate,
}
impl std::default::Default for MapimOptions {
fn default() -> Self {
MapimOptions {
interpolate: VipsInterpolate::new(),
}
}
}
pub fn mapim_with_opts(
inp: &VipsImage,
index: &VipsImage,
mapim_options: &MapimOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let index_in: *mut bindings::VipsImage = index.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let interpolate_in: *mut bindings::VipsInterpolate = mapim_options.interpolate.ctx;
let interpolate_in_name = utils::new_c_string("interpolate")?;
let vips_op_response = bindings::vips_mapim(
inp_in,
&mut out_out,
index_in,
interpolate_in_name.as_ptr(),
interpolate_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MapimError,
)
}
}
pub fn shrink(inp: &VipsImage, hshrink: f64, vshrink: f64) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let hshrink_in: f64 = hshrink;
let vshrink_in: f64 = vshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_shrink(inp_in, &mut out_out, hshrink_in, vshrink_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ShrinkError,
)
}
}
pub fn shrinkh(inp: &VipsImage, hshrink: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let hshrink_in: i32 = hshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_shrinkh(inp_in, &mut out_out, hshrink_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ShrinkhError,
)
}
}
pub fn shrinkv(inp: &VipsImage, vshrink: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let vshrink_in: i32 = vshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_shrinkv(inp_in, &mut out_out, vshrink_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ShrinkvError,
)
}
}
pub fn reduceh(inp: &VipsImage, hshrink: f64) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let hshrink_in: f64 = hshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_reduceh(inp_in, &mut out_out, hshrink_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ReducehError,
)
}
}
#[derive(Clone, Debug)]
pub struct ReducehOptions {
pub kernel: Kernel,
pub centre: bool,
}
impl std::default::Default for ReducehOptions {
fn default() -> Self {
ReducehOptions {
kernel: Kernel::Lanczos3,
centre: false,
}
}
}
pub fn reduceh_with_opts(
inp: &VipsImage,
hshrink: f64,
reduceh_options: &ReducehOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let hshrink_in: f64 = hshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let kernel_in: i32 = reduceh_options.kernel as i32;
let kernel_in_name = utils::new_c_string("kernel")?;
let centre_in: i32 = if reduceh_options.centre { 1 } else { 0 };
let centre_in_name = utils::new_c_string("centre")?;
let vips_op_response = bindings::vips_reduceh(
inp_in,
&mut out_out,
hshrink_in,
kernel_in_name.as_ptr(),
kernel_in,
centre_in_name.as_ptr(),
centre_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ReducehError,
)
}
}
pub fn reducev(inp: &VipsImage, vshrink: f64) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let vshrink_in: f64 = vshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_reducev(inp_in, &mut out_out, vshrink_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ReducevError,
)
}
}
#[derive(Clone, Debug)]
pub struct ReducevOptions {
pub kernel: Kernel,
pub centre: bool,
}
impl std::default::Default for ReducevOptions {
fn default() -> Self {
ReducevOptions {
kernel: Kernel::Lanczos3,
centre: false,
}
}
}
pub fn reducev_with_opts(
inp: &VipsImage,
vshrink: f64,
reducev_options: &ReducevOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let vshrink_in: f64 = vshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let kernel_in: i32 = reducev_options.kernel as i32;
let kernel_in_name = utils::new_c_string("kernel")?;
let centre_in: i32 = if reducev_options.centre { 1 } else { 0 };
let centre_in_name = utils::new_c_string("centre")?;
let vips_op_response = bindings::vips_reducev(
inp_in,
&mut out_out,
vshrink_in,
kernel_in_name.as_ptr(),
kernel_in,
centre_in_name.as_ptr(),
centre_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ReducevError,
)
}
}
pub fn reduce(inp: &VipsImage, hshrink: f64, vshrink: f64) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let hshrink_in: f64 = hshrink;
let vshrink_in: f64 = vshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_reduce(inp_in, &mut out_out, hshrink_in, vshrink_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ReduceError,
)
}
}
#[derive(Clone, Debug)]
pub struct ReduceOptions {
pub kernel: Kernel,
pub centre: bool,
}
impl std::default::Default for ReduceOptions {
fn default() -> Self {
ReduceOptions {
kernel: Kernel::Lanczos3,
centre: false,
}
}
}
pub fn reduce_with_opts(
inp: &VipsImage,
hshrink: f64,
vshrink: f64,
reduce_options: &ReduceOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let hshrink_in: f64 = hshrink;
let vshrink_in: f64 = vshrink;
let mut out_out: *mut bindings::VipsImage = null_mut();
let kernel_in: i32 = reduce_options.kernel as i32;
let kernel_in_name = utils::new_c_string("kernel")?;
let centre_in: i32 = if reduce_options.centre { 1 } else { 0 };
let centre_in_name = utils::new_c_string("centre")?;
let vips_op_response = bindings::vips_reduce(
inp_in,
&mut out_out,
hshrink_in,
vshrink_in,
kernel_in_name.as_ptr(),
kernel_in,
centre_in_name.as_ptr(),
centre_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ReduceError,
)
}
}
pub fn quadratic(inp: &VipsImage, coeff: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let coeff_in: *mut bindings::VipsImage = coeff.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_quadratic(inp_in, &mut out_out, coeff_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::QuadraticError,
)
}
}
#[derive(Clone, Debug)]
pub struct QuadraticOptions {
pub interpolate: VipsInterpolate,
}
impl std::default::Default for QuadraticOptions {
fn default() -> Self {
QuadraticOptions {
interpolate: VipsInterpolate::new(),
}
}
}
pub fn quadratic_with_opts(
inp: &VipsImage,
coeff: &VipsImage,
quadratic_options: &QuadraticOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let coeff_in: *mut bindings::VipsImage = coeff.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let interpolate_in: *mut bindings::VipsInterpolate = quadratic_options.interpolate.ctx;
let interpolate_in_name = utils::new_c_string("interpolate")?;
let vips_op_response = bindings::vips_quadratic(
inp_in,
&mut out_out,
coeff_in,
interpolate_in_name.as_ptr(),
interpolate_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::QuadraticError,
)
}
}
pub fn affine(inp: &VipsImage, a: f64, b: f64, c: f64, d: f64) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let a_in: f64 = a;
let b_in: f64 = b;
let c_in: f64 = c;
let d_in: f64 = d;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_affine(inp_in, &mut out_out, a_in, b_in, c_in, d_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::AffineError,
)
}
}
#[derive(Clone, Debug)]
pub struct AffineOptions {
pub interpolate: VipsInterpolate,
pub oarea: Vec<i32>,
pub odx: f64,
pub ody: f64,
pub idx: f64,
pub idy: f64,
pub background: Vec<f64>,
pub extend: Extend,
}
impl std::default::Default for AffineOptions {
fn default() -> Self {
AffineOptions {
interpolate: VipsInterpolate::new(),
oarea: Vec::new(),
odx: f64::from(0),
ody: f64::from(0),
idx: f64::from(0),
idy: f64::from(0),
background: Vec::new(),
extend: Extend::Background,
}
}
}
pub fn affine_with_opts(
inp: &VipsImage,
a: f64,
b: f64,
c: f64,
d: f64,
affine_options: &AffineOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let a_in: f64 = a;
let b_in: f64 = b;
let c_in: f64 = c;
let d_in: f64 = d;
let mut out_out: *mut bindings::VipsImage = null_mut();
let interpolate_in: *mut bindings::VipsInterpolate = affine_options.interpolate.ctx;
let interpolate_in_name = utils::new_c_string("interpolate")?;
let oarea_wrapper = utils::VipsArrayIntWrapper::from(&affine_options.oarea[..]);
let oarea_in = oarea_wrapper.ctx;
let oarea_in_name = utils::new_c_string("oarea")?;
let odx_in: f64 = affine_options.odx;
let odx_in_name = utils::new_c_string("odx")?;
let ody_in: f64 = affine_options.ody;
let ody_in_name = utils::new_c_string("ody")?;
let idx_in: f64 = affine_options.idx;
let idx_in_name = utils::new_c_string("idx")?;
let idy_in: f64 = affine_options.idy;
let idy_in_name = utils::new_c_string("idy")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&affine_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let extend_in: i32 = affine_options.extend as i32;
let extend_in_name = utils::new_c_string("extend")?;
let vips_op_response = bindings::vips_affine(
inp_in,
&mut out_out,
a_in,
b_in,
c_in,
d_in,
interpolate_in_name.as_ptr(),
interpolate_in,
oarea_in_name.as_ptr(),
oarea_in,
odx_in_name.as_ptr(),
odx_in,
ody_in_name.as_ptr(),
ody_in,
idx_in_name.as_ptr(),
idx_in,
idy_in_name.as_ptr(),
idy_in,
background_in_name.as_ptr(),
background_in,
extend_in_name.as_ptr(),
extend_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::AffineError,
)
}
}
pub fn similarity(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_similarity(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SimilarityError,
)
}
}
#[derive(Clone, Debug)]
pub struct SimilarityOptions {
pub scale: f64,
pub angle: f64,
pub interpolate: VipsInterpolate,
pub background: Vec<f64>,
pub odx: f64,
pub ody: f64,
pub idx: f64,
pub idy: f64,
}
impl std::default::Default for SimilarityOptions {
fn default() -> Self {
SimilarityOptions {
scale: f64::from(1),
angle: f64::from(0),
interpolate: VipsInterpolate::new(),
background: Vec::new(),
odx: f64::from(0),
ody: f64::from(0),
idx: f64::from(0),
idy: f64::from(0),
}
}
}
pub fn similarity_with_opts(
inp: &VipsImage,
similarity_options: &SimilarityOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let scale_in: f64 = similarity_options.scale;
let scale_in_name = utils::new_c_string("scale")?;
let angle_in: f64 = similarity_options.angle;
let angle_in_name = utils::new_c_string("angle")?;
let interpolate_in: *mut bindings::VipsInterpolate = similarity_options.interpolate.ctx;
let interpolate_in_name = utils::new_c_string("interpolate")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&similarity_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let odx_in: f64 = similarity_options.odx;
let odx_in_name = utils::new_c_string("odx")?;
let ody_in: f64 = similarity_options.ody;
let ody_in_name = utils::new_c_string("ody")?;
let idx_in: f64 = similarity_options.idx;
let idx_in_name = utils::new_c_string("idx")?;
let idy_in: f64 = similarity_options.idy;
let idy_in_name = utils::new_c_string("idy")?;
let vips_op_response = bindings::vips_similarity(
inp_in,
&mut out_out,
scale_in_name.as_ptr(),
scale_in,
angle_in_name.as_ptr(),
angle_in,
interpolate_in_name.as_ptr(),
interpolate_in,
background_in_name.as_ptr(),
background_in,
odx_in_name.as_ptr(),
odx_in,
ody_in_name.as_ptr(),
ody_in,
idx_in_name.as_ptr(),
idx_in,
idy_in_name.as_ptr(),
idy_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SimilarityError,
)
}
}
pub fn rotate(inp: &VipsImage, angle: f64) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let angle_in: f64 = angle;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_rotate(inp_in, &mut out_out, angle_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RotateError,
)
}
}
#[derive(Clone, Debug)]
pub struct RotateOptions {
pub interpolate: VipsInterpolate,
pub background: Vec<f64>,
pub odx: f64,
pub ody: f64,
pub idx: f64,
pub idy: f64,
}
impl std::default::Default for RotateOptions {
fn default() -> Self {
RotateOptions {
interpolate: VipsInterpolate::new(),
background: Vec::new(),
odx: f64::from(0),
ody: f64::from(0),
idx: f64::from(0),
idy: f64::from(0),
}
}
}
pub fn rotate_with_opts(
inp: &VipsImage,
angle: f64,
rotate_options: &RotateOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let angle_in: f64 = angle;
let mut out_out: *mut bindings::VipsImage = null_mut();
let interpolate_in: *mut bindings::VipsInterpolate = rotate_options.interpolate.ctx;
let interpolate_in_name = utils::new_c_string("interpolate")?;
let background_wrapper =
utils::VipsArrayDoubleWrapper::from(&rotate_options.background[..]);
let background_in = background_wrapper.ctx;
let background_in_name = utils::new_c_string("background")?;
let odx_in: f64 = rotate_options.odx;
let odx_in_name = utils::new_c_string("odx")?;
let ody_in: f64 = rotate_options.ody;
let ody_in_name = utils::new_c_string("ody")?;
let idx_in: f64 = rotate_options.idx;
let idx_in_name = utils::new_c_string("idx")?;
let idy_in: f64 = rotate_options.idy;
let idy_in_name = utils::new_c_string("idy")?;
let vips_op_response = bindings::vips_rotate(
inp_in,
&mut out_out,
angle_in,
interpolate_in_name.as_ptr(),
interpolate_in,
background_in_name.as_ptr(),
background_in,
odx_in_name.as_ptr(),
odx_in,
ody_in_name.as_ptr(),
ody_in,
idx_in_name.as_ptr(),
idx_in,
idy_in_name.as_ptr(),
idy_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RotateError,
)
}
}
pub fn resize(inp: &VipsImage, scale: f64) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let scale_in: f64 = scale;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_resize(inp_in, &mut out_out, scale_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ResizeError,
)
}
}
#[derive(Clone, Debug)]
pub struct ResizeOptions {
pub kernel: Kernel,
pub vscale: f64,
}
impl std::default::Default for ResizeOptions {
fn default() -> Self {
ResizeOptions {
kernel: Kernel::Lanczos3,
vscale: f64::from(0),
}
}
}
pub fn resize_with_opts(
inp: &VipsImage,
scale: f64,
resize_options: &ResizeOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let scale_in: f64 = scale;
let mut out_out: *mut bindings::VipsImage = null_mut();
let kernel_in: i32 = resize_options.kernel as i32;
let kernel_in_name = utils::new_c_string("kernel")?;
let vscale_in: f64 = resize_options.vscale;
let vscale_in_name = utils::new_c_string("vscale")?;
let vips_op_response = bindings::vips_resize(
inp_in,
&mut out_out,
scale_in,
kernel_in_name.as_ptr(),
kernel_in,
vscale_in_name.as_ptr(),
vscale_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ResizeError,
)
}
}
pub fn colourspace(inp: &VipsImage, space: Interpretation) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let space_in: i32 = space as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_colourspace(inp_in, &mut out_out, space_in.try_into().unwrap(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ColourspaceError,
)
}
}
#[derive(Clone, Debug)]
pub struct ColourspaceOptions {
pub source_space: Interpretation,
}
impl std::default::Default for ColourspaceOptions {
fn default() -> Self {
ColourspaceOptions {
source_space: Interpretation::Srgb,
}
}
}
pub fn colourspace_with_opts(
inp: &VipsImage,
space: Interpretation,
colourspace_options: &ColourspaceOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let space_in: i32 = space as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let source_space_in: i32 = colourspace_options.source_space as i32;
let source_space_in_name = utils::new_c_string("source-space")?;
let vips_op_response = bindings::vips_colourspace(
inp_in,
&mut out_out,
space_in.try_into().unwrap(),
source_space_in_name.as_ptr(),
source_space_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ColourspaceError,
)
}
}
pub fn lab_2xyz(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_Lab2XYZ(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Lab2XyzError,
)
}
}
#[derive(Clone, Debug)]
pub struct Lab2XyzOptions {
pub temp: Vec<f64>,
}
impl std::default::Default for Lab2XyzOptions {
fn default() -> Self {
Lab2XyzOptions { temp: Vec::new() }
}
}
pub fn lab_2xyz_with_opts(inp: &VipsImage, lab_2xyz_options: &Lab2XyzOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let temp_wrapper = utils::VipsArrayDoubleWrapper::from(&lab_2xyz_options.temp[..]);
let temp_in = temp_wrapper.ctx;
let temp_in_name = utils::new_c_string("temp")?;
let vips_op_response =
bindings::vips_Lab2XYZ(inp_in, &mut out_out, temp_in_name.as_ptr(), temp_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Lab2XyzError,
)
}
}
pub fn xyz2_lab(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_XYZ2Lab(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Xyz2LabError,
)
}
}
#[derive(Clone, Debug)]
pub struct Xyz2LabOptions {
pub temp: Vec<f64>,
}
impl std::default::Default for Xyz2LabOptions {
fn default() -> Self {
Xyz2LabOptions { temp: Vec::new() }
}
}
pub fn xyz2_lab_with_opts(
inp: &VipsImage,
xyz_2_lab_options: &Xyz2LabOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let temp_wrapper = utils::VipsArrayDoubleWrapper::from(&xyz_2_lab_options.temp[..]);
let temp_in = temp_wrapper.ctx;
let temp_in_name = utils::new_c_string("temp")?;
let vips_op_response =
bindings::vips_XYZ2Lab(inp_in, &mut out_out, temp_in_name.as_ptr(), temp_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Xyz2LabError,
)
}
}
pub fn lab_2l_ch(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_Lab2LCh(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Lab2LChError,
)
}
}
pub fn l_ch_2_lab(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_LCh2Lab(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LCh2LabError,
)
}
}
pub fn l_ch_2cmc(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_LCh2CMC(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LCh2CmcError,
)
}
}
pub fn cmc2l_ch(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_CMC2LCh(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Cmc2LChError,
)
}
}
pub fn xyz2_yxy(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_XYZ2Yxy(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Xyz2YxyError,
)
}
}
pub fn yxy_2xyz(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_Yxy2XYZ(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Yxy2XyzError,
)
}
}
pub fn sc_rgb2xyz(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_scRGB2XYZ(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ScRgb2XyzError,
)
}
}
pub fn xyz_2sc_rgb(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_XYZ2scRGB(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Xyz2ScRgbError,
)
}
}
pub fn lab_q2_lab(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_LabQ2Lab(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LabQ2LabError,
)
}
}
pub fn lab_2_lab_q(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_Lab2LabQ(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Lab2LabQError,
)
}
}
pub fn lab_q2_lab_s(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_LabQ2LabS(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LabQ2LabSError,
)
}
}
pub fn lab_s2_lab_q(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_LabS2LabQ(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LabS2LabQError,
)
}
}
pub fn lab_s2_lab(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_LabS2Lab(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LabS2LabError,
)
}
}
pub fn lab_2_lab_s(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_Lab2LabS(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Lab2LabSError,
)
}
}
pub fn rad_2float(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_rad2float(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Rad2FloatError,
)
}
}
pub fn float_2rad(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_float2rad(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Float2RadError,
)
}
}
pub fn lab_q_2s_rgb(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_LabQ2sRGB(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::LabQ2SRgbError,
)
}
}
pub fn s_rgb2hsv(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_sRGB2HSV(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SRgb2HsvError,
)
}
}
pub fn hsv_2s_rgb(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_HSV2sRGB(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Hsv2SRgbError,
)
}
}
pub fn icc_import(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_icc_import(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IccImportError,
)
}
}
#[derive(Clone, Debug)]
pub struct IccImportOptions {
pub pcs: PCS,
pub intent: Intent,
pub embedded: bool,
pub input_profile: String,
}
impl std::default::Default for IccImportOptions {
fn default() -> Self {
IccImportOptions {
pcs: PCS::Lab,
intent: Intent::Relative,
embedded: false,
input_profile: String::new(),
}
}
}
pub fn icc_import_with_opts(
inp: &VipsImage,
icc_import_options: &IccImportOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let pcs_in: i32 = icc_import_options.pcs as i32;
let pcs_in_name = utils::new_c_string("pcs")?;
let intent_in: i32 = icc_import_options.intent as i32;
let intent_in_name = utils::new_c_string("intent")?;
let embedded_in: i32 = if icc_import_options.embedded { 1 } else { 0 };
let embedded_in_name = utils::new_c_string("embedded")?;
let input_profile_in: CString = utils::new_c_string(&icc_import_options.input_profile)?;
let input_profile_in_name = utils::new_c_string("input-profile")?;
let vips_op_response = bindings::vips_icc_import(
inp_in,
&mut out_out,
pcs_in_name.as_ptr(),
pcs_in,
intent_in_name.as_ptr(),
intent_in,
embedded_in_name.as_ptr(),
embedded_in,
input_profile_in_name.as_ptr(),
input_profile_in.as_ptr(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IccImportError,
)
}
}
pub fn icc_export(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_icc_export(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IccExportError,
)
}
}
#[derive(Clone, Debug)]
pub struct IccExportOptions {
pub pcs: PCS,
pub intent: Intent,
pub output_profile: String,
pub depth: i32,
}
impl std::default::Default for IccExportOptions {
fn default() -> Self {
IccExportOptions {
pcs: PCS::Lab,
intent: Intent::Relative,
output_profile: String::new(),
depth: i32::from(8),
}
}
}
pub fn icc_export_with_opts(
inp: &VipsImage,
icc_export_options: &IccExportOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let pcs_in: i32 = icc_export_options.pcs as i32;
let pcs_in_name = utils::new_c_string("pcs")?;
let intent_in: i32 = icc_export_options.intent as i32;
let intent_in_name = utils::new_c_string("intent")?;
let output_profile_in: CString = utils::new_c_string(&icc_export_options.output_profile)?;
let output_profile_in_name = utils::new_c_string("output-profile")?;
let depth_in: i32 = icc_export_options.depth;
let depth_in_name = utils::new_c_string("depth")?;
let vips_op_response = bindings::vips_icc_export(
inp_in,
&mut out_out,
pcs_in_name.as_ptr(),
pcs_in,
intent_in_name.as_ptr(),
intent_in,
output_profile_in_name.as_ptr(),
output_profile_in.as_ptr(),
depth_in_name.as_ptr(),
depth_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IccExportError,
)
}
}
pub fn icc_transform(inp: &VipsImage, output_profile: &str) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let output_profile_in: CString = utils::new_c_string(output_profile)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_icc_transform(inp_in, &mut out_out, output_profile_in.as_ptr(), NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IccTransformError,
)
}
}
#[derive(Clone, Debug)]
pub struct IccTransformOptions {
pub pcs: PCS,
pub intent: Intent,
pub embedded: bool,
pub input_profile: String,
pub depth: i32,
}
impl std::default::Default for IccTransformOptions {
fn default() -> Self {
IccTransformOptions {
pcs: PCS::Lab,
intent: Intent::Relative,
embedded: false,
input_profile: String::new(),
depth: i32::from(8),
}
}
}
pub fn icc_transform_with_opts(
inp: &VipsImage,
output_profile: &str,
icc_transform_options: &IccTransformOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let output_profile_in: CString = utils::new_c_string(output_profile)?;
let mut out_out: *mut bindings::VipsImage = null_mut();
let pcs_in: i32 = icc_transform_options.pcs as i32;
let pcs_in_name = utils::new_c_string("pcs")?;
let intent_in: i32 = icc_transform_options.intent as i32;
let intent_in_name = utils::new_c_string("intent")?;
let embedded_in: i32 = if icc_transform_options.embedded { 1 } else { 0 };
let embedded_in_name = utils::new_c_string("embedded")?;
let input_profile_in: CString = utils::new_c_string(&icc_transform_options.input_profile)?;
let input_profile_in_name = utils::new_c_string("input-profile")?;
let depth_in: i32 = icc_transform_options.depth;
let depth_in_name = utils::new_c_string("depth")?;
let vips_op_response = bindings::vips_icc_transform(
inp_in,
&mut out_out,
output_profile_in.as_ptr(),
pcs_in_name.as_ptr(),
pcs_in,
intent_in_name.as_ptr(),
intent_in,
embedded_in_name.as_ptr(),
embedded_in,
input_profile_in_name.as_ptr(),
input_profile_in.as_ptr(),
depth_in_name.as_ptr(),
depth_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::IccTransformError,
)
}
}
pub fn d_e76(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_dE76(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::DE76Error,
)
}
}
pub fn d_e00(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_dE00(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::DE00Error,
)
}
}
pub fn d_ecmc(left: &VipsImage, right: &VipsImage) -> Result<VipsImage> {
unsafe {
let left_in: *mut bindings::VipsImage = left.ctx;
let right_in: *mut bindings::VipsImage = right.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_dECMC(left_in, right_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::DEcmcError,
)
}
}
pub fn s_rgb_2sc_rgb(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_sRGB2scRGB(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SRgb2ScRgbError,
)
}
}
pub fn sc_rgb2bw(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_scRGB2BW(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ScRgb2BwError,
)
}
}
#[derive(Clone, Debug)]
pub struct ScRgb2BwOptions {
pub depth: i32,
}
impl std::default::Default for ScRgb2BwOptions {
fn default() -> Self {
ScRgb2BwOptions {
depth: i32::from(8),
}
}
}
pub fn sc_rgb2bw_with_opts(
inp: &VipsImage,
sc_rgb_2bw_options: &ScRgb2BwOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let depth_in: i32 = sc_rgb_2bw_options.depth;
let depth_in_name = utils::new_c_string("depth")?;
let vips_op_response =
bindings::vips_scRGB2BW(inp_in, &mut out_out, depth_in_name.as_ptr(), depth_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ScRgb2BwError,
)
}
}
pub fn sc_rgb_2s_rgb(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_scRGB2sRGB(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ScRgb2SRgbError,
)
}
}
#[derive(Clone, Debug)]
pub struct ScRgb2SRgbOptions {
pub depth: i32,
}
impl std::default::Default for ScRgb2SRgbOptions {
fn default() -> Self {
ScRgb2SRgbOptions {
depth: i32::from(8),
}
}
}
pub fn sc_rgb_2s_rgb_with_opts(
inp: &VipsImage,
sc_rgb_2s_rgb_options: &ScRgb2SRgbOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let depth_in: i32 = sc_rgb_2s_rgb_options.depth;
let depth_in_name = utils::new_c_string("depth")?;
let vips_op_response =
bindings::vips_scRGB2sRGB(inp_in, &mut out_out, depth_in_name.as_ptr(), depth_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ScRgb2SRgbError,
)
}
}
pub fn cmyk2xyz(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_CMYK2XYZ(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Cmyk2XyzError,
)
}
}
pub fn xyz2cmyk(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_XYZ2CMYK(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Xyz2CmykError,
)
}
}
pub fn profile_load(name: &str) -> Result<Vec<u8>> {
unsafe {
let name_in: CString = utils::new_c_string(name)?;
let mut profile_out: *mut bindings::VipsBlob = null_mut();
let vips_op_response =
bindings::vips_profile_load(name_in.as_ptr(), &mut profile_out, NULL);
utils::result(
vips_op_response,
VipsBlob { ctx: profile_out }.into(),
Error::ProfileLoadError,
)
}
}
pub fn maplut(inp: &VipsImage, lut: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let lut_in: *mut bindings::VipsImage = lut.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_maplut(inp_in, &mut out_out, lut_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaplutError,
)
}
}
#[derive(Clone, Debug)]
pub struct MaplutOptions {
pub band: i32,
}
impl std::default::Default for MaplutOptions {
fn default() -> Self {
MaplutOptions {
band: i32::from(-1),
}
}
}
pub fn maplut_with_opts(
inp: &VipsImage,
lut: &VipsImage,
maplut_options: &MaplutOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let lut_in: *mut bindings::VipsImage = lut.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let band_in: i32 = maplut_options.band;
let band_in_name = utils::new_c_string("band")?;
let vips_op_response = bindings::vips_maplut(
inp_in,
&mut out_out,
lut_in,
band_in_name.as_ptr(),
band_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MaplutError,
)
}
}
pub fn percent(inp: &VipsImage, percent: f64) -> Result<i32> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let percent_in: f64 = percent;
let mut threshold_out: i32 = i32::from(0);
let vips_op_response = bindings::vips_percent(inp_in, percent_in, &mut threshold_out, NULL);
utils::result(vips_op_response, threshold_out, Error::PercentError)
}
}
pub fn stdif(inp: &VipsImage, width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_stdif(inp_in, &mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::StdifError,
)
}
}
#[derive(Clone, Debug)]
pub struct StdifOptions {
pub s_0: f64,
pub b: f64,
pub m_0: f64,
pub a: f64,
}
impl std::default::Default for StdifOptions {
fn default() -> Self {
StdifOptions {
s_0: f64::from(50),
b: f64::from(0.5),
m_0: f64::from(128),
a: f64::from(0.5),
}
}
}
pub fn stdif_with_opts(
inp: &VipsImage,
width: i32,
height: i32,
stdif_options: &StdifOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let s_0_in: f64 = stdif_options.s_0;
let s_0_in_name = utils::new_c_string("s0")?;
let b_in: f64 = stdif_options.b;
let b_in_name = utils::new_c_string("b")?;
let m_0_in: f64 = stdif_options.m_0;
let m_0_in_name = utils::new_c_string("m0")?;
let a_in: f64 = stdif_options.a;
let a_in_name = utils::new_c_string("a")?;
let vips_op_response = bindings::vips_stdif(
inp_in,
&mut out_out,
width_in,
height_in,
s_0_in_name.as_ptr(),
s_0_in,
b_in_name.as_ptr(),
b_in,
m_0_in_name.as_ptr(),
m_0_in,
a_in_name.as_ptr(),
a_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::StdifError,
)
}
}
pub fn hist_cum(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hist_cum(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistCumError,
)
}
}
pub fn hist_match(inp: &VipsImage, refp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let refp_in: *mut bindings::VipsImage = refp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hist_match(inp_in, refp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistMatchError,
)
}
}
pub fn hist_norm(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hist_norm(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistNormError,
)
}
}
pub fn hist_equal(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hist_equal(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistEqualError,
)
}
}
#[derive(Clone, Debug)]
pub struct HistEqualOptions {
pub band: i32,
}
impl std::default::Default for HistEqualOptions {
fn default() -> Self {
HistEqualOptions {
band: i32::from(-1),
}
}
}
pub fn hist_equal_with_opts(
inp: &VipsImage,
hist_equal_options: &HistEqualOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let band_in: i32 = hist_equal_options.band;
let band_in_name = utils::new_c_string("band")?;
let vips_op_response =
bindings::vips_hist_equal(inp_in, &mut out_out, band_in_name.as_ptr(), band_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistEqualError,
)
}
}
pub fn hist_plot(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_hist_plot(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistPlotError,
)
}
}
pub fn hist_local(inp: &VipsImage, width: i32, height: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_hist_local(inp_in, &mut out_out, width_in, height_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistLocalError,
)
}
}
#[derive(Clone, Debug)]
pub struct HistLocalOptions {
pub max_slope: i32,
}
impl std::default::Default for HistLocalOptions {
fn default() -> Self {
HistLocalOptions {
max_slope: i32::from(0),
}
}
}
pub fn hist_local_with_opts(
inp: &VipsImage,
width: i32,
height: i32,
hist_local_options: &HistLocalOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let width_in: i32 = width;
let height_in: i32 = height;
let mut out_out: *mut bindings::VipsImage = null_mut();
let max_slope_in: i32 = hist_local_options.max_slope;
let max_slope_in_name = utils::new_c_string("max-slope")?;
let vips_op_response = bindings::vips_hist_local(
inp_in,
&mut out_out,
width_in,
height_in,
max_slope_in_name.as_ptr(),
max_slope_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::HistLocalError,
)
}
}
pub fn hist_ismonotonic(inp: &VipsImage) -> Result<bool> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut monotonic_out: i32 = 0;
let vips_op_response = bindings::vips_hist_ismonotonic(inp_in, &mut monotonic_out, NULL);
utils::result(
vips_op_response,
monotonic_out != 0,
Error::HistIsmonotonicError,
)
}
}
pub fn hist_entropy(inp: &VipsImage) -> Result<f64> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: f64 = f64::from(0);
let vips_op_response = bindings::vips_hist_entropy(inp_in, &mut out_out, NULL);
utils::result(vips_op_response, out_out, Error::HistEntropyError)
}
}
pub fn conv(inp: &VipsImage, mask: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_conv(inp_in, &mut out_out, mask_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvError,
)
}
}
#[derive(Clone, Debug)]
pub struct ConvOptions {
pub precision: Precision,
pub layers: i32,
pub cluster: i32,
}
impl std::default::Default for ConvOptions {
fn default() -> Self {
ConvOptions {
precision: Precision::Float,
layers: i32::from(5),
cluster: i32::from(1),
}
}
}
pub fn conv_with_opts(
inp: &VipsImage,
mask: &VipsImage,
conv_options: &ConvOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let precision_in: i32 = conv_options.precision as i32;
let precision_in_name = utils::new_c_string("precision")?;
let layers_in: i32 = conv_options.layers;
let layers_in_name = utils::new_c_string("layers")?;
let cluster_in: i32 = conv_options.cluster;
let cluster_in_name = utils::new_c_string("cluster")?;
let vips_op_response = bindings::vips_conv(
inp_in,
&mut out_out,
mask_in,
precision_in_name.as_ptr(),
precision_in,
layers_in_name.as_ptr(),
layers_in,
cluster_in_name.as_ptr(),
cluster_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvError,
)
}
}
pub fn conva(inp: &VipsImage, mask: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_conva(inp_in, &mut out_out, mask_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvaError,
)
}
}
#[derive(Clone, Debug)]
pub struct ConvaOptions {
pub layers: i32,
pub cluster: i32,
}
impl std::default::Default for ConvaOptions {
fn default() -> Self {
ConvaOptions {
layers: i32::from(5),
cluster: i32::from(1),
}
}
}
pub fn conva_with_opts(
inp: &VipsImage,
mask: &VipsImage,
conva_options: &ConvaOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let layers_in: i32 = conva_options.layers;
let layers_in_name = utils::new_c_string("layers")?;
let cluster_in: i32 = conva_options.cluster;
let cluster_in_name = utils::new_c_string("cluster")?;
let vips_op_response = bindings::vips_conva(
inp_in,
&mut out_out,
mask_in,
layers_in_name.as_ptr(),
layers_in,
cluster_in_name.as_ptr(),
cluster_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvaError,
)
}
}
pub fn convf(inp: &VipsImage, mask: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_convf(inp_in, &mut out_out, mask_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvfError,
)
}
}
pub fn convi(inp: &VipsImage, mask: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_convi(inp_in, &mut out_out, mask_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConviError,
)
}
}
pub fn compass(inp: &VipsImage, mask: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_compass(inp_in, &mut out_out, mask_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CompassError,
)
}
}
#[derive(Clone, Debug)]
pub struct CompassOptions {
pub times: i32,
pub angle: Angle45,
pub combine: Combine,
pub precision: Precision,
pub layers: i32,
pub cluster: i32,
}
impl std::default::Default for CompassOptions {
fn default() -> Self {
CompassOptions {
times: i32::from(2),
angle: Angle45::D90,
combine: Combine::Max,
precision: Precision::Float,
layers: i32::from(5),
cluster: i32::from(1),
}
}
}
pub fn compass_with_opts(
inp: &VipsImage,
mask: &VipsImage,
compass_options: &CompassOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let times_in: i32 = compass_options.times;
let times_in_name = utils::new_c_string("times")?;
let angle_in: i32 = compass_options.angle as i32;
let angle_in_name = utils::new_c_string("angle")?;
let combine_in: i32 = compass_options.combine as i32;
let combine_in_name = utils::new_c_string("combine")?;
let precision_in: i32 = compass_options.precision as i32;
let precision_in_name = utils::new_c_string("precision")?;
let layers_in: i32 = compass_options.layers;
let layers_in_name = utils::new_c_string("layers")?;
let cluster_in: i32 = compass_options.cluster;
let cluster_in_name = utils::new_c_string("cluster")?;
let vips_op_response = bindings::vips_compass(
inp_in,
&mut out_out,
mask_in,
times_in_name.as_ptr(),
times_in,
angle_in_name.as_ptr(),
angle_in,
combine_in_name.as_ptr(),
combine_in,
precision_in_name.as_ptr(),
precision_in,
layers_in_name.as_ptr(),
layers_in,
cluster_in_name.as_ptr(),
cluster_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CompassError,
)
}
}
pub fn convsep(inp: &VipsImage, mask: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_convsep(inp_in, &mut out_out, mask_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvsepError,
)
}
}
#[derive(Clone, Debug)]
pub struct ConvsepOptions {
pub precision: Precision,
pub layers: i32,
pub cluster: i32,
}
impl std::default::Default for ConvsepOptions {
fn default() -> Self {
ConvsepOptions {
precision: Precision::Float,
layers: i32::from(5),
cluster: i32::from(1),
}
}
}
pub fn convsep_with_opts(
inp: &VipsImage,
mask: &VipsImage,
convsep_options: &ConvsepOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let precision_in: i32 = convsep_options.precision as i32;
let precision_in_name = utils::new_c_string("precision")?;
let layers_in: i32 = convsep_options.layers;
let layers_in_name = utils::new_c_string("layers")?;
let cluster_in: i32 = convsep_options.cluster;
let cluster_in_name = utils::new_c_string("cluster")?;
let vips_op_response = bindings::vips_convsep(
inp_in,
&mut out_out,
mask_in,
precision_in_name.as_ptr(),
precision_in,
layers_in_name.as_ptr(),
layers_in,
cluster_in_name.as_ptr(),
cluster_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvsepError,
)
}
}
pub fn convasep(inp: &VipsImage, mask: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_convasep(inp_in, &mut out_out, mask_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvasepError,
)
}
}
#[derive(Clone, Debug)]
pub struct ConvasepOptions {
pub layers: i32,
}
impl std::default::Default for ConvasepOptions {
fn default() -> Self {
ConvasepOptions {
layers: i32::from(5),
}
}
}
pub fn convasep_with_opts(
inp: &VipsImage,
mask: &VipsImage,
convasep_options: &ConvasepOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let layers_in: i32 = convasep_options.layers;
let layers_in_name = utils::new_c_string("layers")?;
let vips_op_response = bindings::vips_convasep(
inp_in,
&mut out_out,
mask_in,
layers_in_name.as_ptr(),
layers_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::ConvasepError,
)
}
}
pub fn fastcor(inp: &VipsImage, refp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let refp_in: *mut bindings::VipsImage = refp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_fastcor(inp_in, refp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FastcorError,
)
}
}
pub fn spcor(inp: &VipsImage, refp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let refp_in: *mut bindings::VipsImage = refp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_spcor(inp_in, refp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SpcorError,
)
}
}
pub fn sharpen(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_sharpen(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SharpenError,
)
}
}
#[derive(Clone, Debug)]
pub struct SharpenOptions {
pub sigma: f64,
pub x_1: f64,
pub y_2: f64,
pub y_3: f64,
pub m_1: f64,
pub m_2: f64,
}
impl std::default::Default for SharpenOptions {
fn default() -> Self {
SharpenOptions {
sigma: f64::from(0.5),
x_1: f64::from(2),
y_2: f64::from(10),
y_3: f64::from(20),
m_1: f64::from(0),
m_2: f64::from(3),
}
}
}
pub fn sharpen_with_opts(inp: &VipsImage, sharpen_options: &SharpenOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let sigma_in: f64 = sharpen_options.sigma;
let sigma_in_name = utils::new_c_string("sigma")?;
let x_1_in: f64 = sharpen_options.x_1;
let x_1_in_name = utils::new_c_string("x1")?;
let y_2_in: f64 = sharpen_options.y_2;
let y_2_in_name = utils::new_c_string("y2")?;
let y_3_in: f64 = sharpen_options.y_3;
let y_3_in_name = utils::new_c_string("y3")?;
let m_1_in: f64 = sharpen_options.m_1;
let m_1_in_name = utils::new_c_string("m1")?;
let m_2_in: f64 = sharpen_options.m_2;
let m_2_in_name = utils::new_c_string("m2")?;
let vips_op_response = bindings::vips_sharpen(
inp_in,
&mut out_out,
sigma_in_name.as_ptr(),
sigma_in,
x_1_in_name.as_ptr(),
x_1_in,
y_2_in_name.as_ptr(),
y_2_in,
y_3_in_name.as_ptr(),
y_3_in,
m_1_in_name.as_ptr(),
m_1_in,
m_2_in_name.as_ptr(),
m_2_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SharpenError,
)
}
}
pub fn gaussblur(inp: &VipsImage, sigma: f64) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let sigma_in: f64 = sigma;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_gaussblur(inp_in, &mut out_out, sigma_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GaussblurError,
)
}
}
#[derive(Clone, Debug)]
pub struct GaussblurOptions {
pub min_ampl: f64,
pub precision: Precision,
}
impl std::default::Default for GaussblurOptions {
fn default() -> Self {
GaussblurOptions {
min_ampl: f64::from(0.2),
precision: Precision::Integer,
}
}
}
pub fn gaussblur_with_opts(
inp: &VipsImage,
sigma: f64,
gaussblur_options: &GaussblurOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let sigma_in: f64 = sigma;
let mut out_out: *mut bindings::VipsImage = null_mut();
let min_ampl_in: f64 = gaussblur_options.min_ampl;
let min_ampl_in_name = utils::new_c_string("min-ampl")?;
let precision_in: i32 = gaussblur_options.precision as i32;
let precision_in_name = utils::new_c_string("precision")?;
let vips_op_response = bindings::vips_gaussblur(
inp_in,
&mut out_out,
sigma_in,
min_ampl_in_name.as_ptr(),
min_ampl_in,
precision_in_name.as_ptr(),
precision_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GaussblurError,
)
}
}
pub fn canny(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_canny(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CannyError,
)
}
}
#[derive(Clone, Debug)]
pub struct CannyOptions {
pub sigma: f64,
pub precision: Precision,
}
impl std::default::Default for CannyOptions {
fn default() -> Self {
CannyOptions {
sigma: f64::from(1.4),
precision: Precision::Float,
}
}
}
pub fn canny_with_opts(inp: &VipsImage, canny_options: &CannyOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let sigma_in: f64 = canny_options.sigma;
let sigma_in_name = utils::new_c_string("sigma")?;
let precision_in: i32 = canny_options.precision as i32;
let precision_in_name = utils::new_c_string("precision")?;
let vips_op_response = bindings::vips_canny(
inp_in,
&mut out_out,
sigma_in_name.as_ptr(),
sigma_in,
precision_in_name.as_ptr(),
precision_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::CannyError,
)
}
}
pub fn sobel(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_sobel(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SobelError,
)
}
}
pub fn fwfft(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_fwfft(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FwfftError,
)
}
}
pub fn invfft(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_invfft(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::InvfftError,
)
}
}
#[derive(Clone, Debug)]
pub struct InvfftOptions {
pub real: bool,
}
impl std::default::Default for InvfftOptions {
fn default() -> Self {
InvfftOptions { real: false }
}
}
pub fn invfft_with_opts(inp: &VipsImage, invfft_options: &InvfftOptions) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let real_in: i32 = if invfft_options.real { 1 } else { 0 };
let real_in_name = utils::new_c_string("real")?;
let vips_op_response =
bindings::vips_invfft(inp_in, &mut out_out, real_in_name.as_ptr(), real_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::InvfftError,
)
}
}
pub fn freqmult(inp: &VipsImage, mask: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_freqmult(inp_in, mask_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FreqmultError,
)
}
}
pub fn spectrum(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_spectrum(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::SpectrumError,
)
}
}
pub fn phasecor(inp: &VipsImage, in_2: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let in_2_in: *mut bindings::VipsImage = in_2.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_phasecor(inp_in, in_2_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::PhasecorError,
)
}
}
pub fn morph(inp: &VipsImage, mask: &VipsImage, morph: OperationMorphology) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mask_in: *mut bindings::VipsImage = mask.ctx;
let morph_in: i32 = morph as i32;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_morph(
inp_in,
&mut out_out,
mask_in,
morph_in.try_into().unwrap(),
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MorphError,
)
}
}
pub fn rank(inp: &VipsImage, width: i32, height: i32, index: i32) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let width_in: i32 = width;
let height_in: i32 = height;
let index_in: i32 = index;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response =
bindings::vips_rank(inp_in, &mut out_out, width_in, height_in, index_in, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::RankError,
)
}
}
pub fn countlines(inp: &VipsImage, direction: Direction) -> Result<f64> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let direction_in: i32 = direction as i32;
let mut nolines_out: f64 = f64::from(0);
let vips_op_response = bindings::vips_countlines(
inp_in,
&mut nolines_out,
direction_in.try_into().unwrap(),
NULL,
);
utils::result(vips_op_response, nolines_out, Error::CountlineError)
}
}
pub fn labelregions(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut mask_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_labelregions(inp_in, &mut mask_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: mask_out },
Error::LabelregionError,
)
}
}
#[derive(Clone, Debug)]
pub struct LabelregionOptions {
pub segments: i32,
}
impl std::default::Default for LabelregionOptions {
fn default() -> Self {
LabelregionOptions {
segments: i32::from(0),
}
}
}
pub fn labelregions_with_opts(
inp: &VipsImage,
labelregions_options: &LabelregionOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut mask_out: *mut bindings::VipsImage = null_mut();
let segments_in: i32 = labelregions_options.segments;
let segments_in_name = utils::new_c_string("segments")?;
let vips_op_response = bindings::vips_labelregions(
inp_in,
&mut mask_out,
segments_in_name.as_ptr(),
segments_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: mask_out },
Error::LabelregionError,
)
}
}
pub fn fill_nearest(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_fill_nearest(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FillNearestError,
)
}
}
#[derive(Clone, Debug)]
pub struct FillNearestOptions {
pub distance: VipsImage,
}
impl std::default::Default for FillNearestOptions {
fn default() -> Self {
FillNearestOptions {
distance: VipsImage::new(),
}
}
}
pub fn fill_nearest_with_opts(
inp: &VipsImage,
fill_nearest_options: &FillNearestOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let distance_in: *mut bindings::VipsImage = fill_nearest_options.distance.ctx;
let distance_in_name = utils::new_c_string("distance")?;
let vips_op_response = bindings::vips_fill_nearest(
inp_in,
&mut out_out,
distance_in_name.as_ptr(),
distance_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::FillNearestError,
)
}
}
pub fn draw_rect(
image: &VipsImage,
ink: &mut [f64],
left: i32,
top: i32,
width: i32,
height: i32,
) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let ink_in: *mut f64 = ink.as_mut_ptr();
let left_in: i32 = left;
let top_in: i32 = top;
let width_in: i32 = width;
let height_in: i32 = height;
let vips_op_response = bindings::vips_draw_rect(
image_in,
ink_in,
ink.len() as i32,
left_in,
top_in,
width_in,
height_in,
NULL,
);
utils::result(vips_op_response, (), Error::DrawRectError)
}
}
#[derive(Clone, Debug)]
pub struct DrawRectOptions {
pub fill: bool,
}
impl std::default::Default for DrawRectOptions {
fn default() -> Self {
DrawRectOptions { fill: false }
}
}
pub fn draw_rect_with_opts(
image: &VipsImage,
ink: &mut [f64],
left: i32,
top: i32,
width: i32,
height: i32,
draw_rect_options: &DrawRectOptions,
) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let ink_in: *mut f64 = ink.as_mut_ptr();
let left_in: i32 = left;
let top_in: i32 = top;
let width_in: i32 = width;
let height_in: i32 = height;
let fill_in: i32 = if draw_rect_options.fill { 1 } else { 0 };
let fill_in_name = utils::new_c_string("fill")?;
let vips_op_response = bindings::vips_draw_rect(
image_in,
ink_in,
ink.len() as i32,
left_in,
top_in,
width_in,
height_in,
fill_in_name.as_ptr(),
fill_in,
NULL,
);
utils::result(vips_op_response, (), Error::DrawRectError)
}
}
pub fn draw_mask(
image: &VipsImage,
ink: &mut [f64],
mask: &VipsImage,
x: i32,
y: i32,
) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let ink_in: *mut f64 = ink.as_mut_ptr();
let mask_in: *mut bindings::VipsImage = mask.ctx;
let x_in: i32 = x;
let y_in: i32 = y;
let vips_op_response = bindings::vips_draw_mask(
image_in,
ink_in,
ink.len() as i32,
mask_in,
x_in,
y_in,
NULL,
);
utils::result(vips_op_response, (), Error::DrawMaskError)
}
}
pub fn draw_line(
image: &VipsImage,
ink: &mut [f64],
x_1: i32,
y_1: i32,
x_2: i32,
y_2: i32,
) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let ink_in: *mut f64 = ink.as_mut_ptr();
let x_1_in: i32 = x_1;
let y_1_in: i32 = y_1;
let x_2_in: i32 = x_2;
let y_2_in: i32 = y_2;
let vips_op_response = bindings::vips_draw_line(
image_in,
ink_in,
ink.len() as i32,
x_1_in,
y_1_in,
x_2_in,
y_2_in,
NULL,
);
utils::result(vips_op_response, (), Error::DrawLineError)
}
}
pub fn draw_circle(
image: &VipsImage,
ink: &mut [f64],
cx: i32,
cy: i32,
radius: i32,
) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let ink_in: *mut f64 = ink.as_mut_ptr();
let cx_in: i32 = cx;
let cy_in: i32 = cy;
let radius_in: i32 = radius;
let vips_op_response = bindings::vips_draw_circle(
image_in,
ink_in,
ink.len() as i32,
cx_in,
cy_in,
radius_in,
NULL,
);
utils::result(vips_op_response, (), Error::DrawCircleError)
}
}
#[derive(Clone, Debug)]
pub struct DrawCircleOptions {
pub fill: bool,
}
impl std::default::Default for DrawCircleOptions {
fn default() -> Self {
DrawCircleOptions { fill: false }
}
}
pub fn draw_circle_with_opts(
image: &VipsImage,
ink: &mut [f64],
cx: i32,
cy: i32,
radius: i32,
draw_circle_options: &DrawCircleOptions,
) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let ink_in: *mut f64 = ink.as_mut_ptr();
let cx_in: i32 = cx;
let cy_in: i32 = cy;
let radius_in: i32 = radius;
let fill_in: i32 = if draw_circle_options.fill { 1 } else { 0 };
let fill_in_name = utils::new_c_string("fill")?;
let vips_op_response = bindings::vips_draw_circle(
image_in,
ink_in,
ink.len() as i32,
cx_in,
cy_in,
radius_in,
fill_in_name.as_ptr(),
fill_in,
NULL,
);
utils::result(vips_op_response, (), Error::DrawCircleError)
}
}
pub fn draw_flood(image: &VipsImage, ink: &mut [f64], x: i32, y: i32) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let ink_in: *mut f64 = ink.as_mut_ptr();
let x_in: i32 = x;
let y_in: i32 = y;
let vips_op_response =
bindings::vips_draw_flood(image_in, ink_in, ink.len() as i32, x_in, y_in, NULL);
utils::result(vips_op_response, (), Error::DrawFloodError)
}
}
#[derive(Clone, Debug)]
pub struct DrawFloodOptions {
pub test: VipsImage,
pub equal: bool,
pub left: i32,
pub top: i32,
pub width: i32,
pub height: i32,
}
impl std::default::Default for DrawFloodOptions {
fn default() -> Self {
DrawFloodOptions {
test: VipsImage::new(),
equal: false,
left: i32::from(0),
top: i32::from(0),
width: i32::from(0),
height: i32::from(0),
}
}
}
pub fn draw_flood_with_opts(
image: &VipsImage,
ink: &mut [f64],
x: i32,
y: i32,
draw_flood_options: &DrawFloodOptions,
) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let ink_in: *mut f64 = ink.as_mut_ptr();
let x_in: i32 = x;
let y_in: i32 = y;
let test_in: *mut bindings::VipsImage = draw_flood_options.test.ctx;
let test_in_name = utils::new_c_string("test")?;
let equal_in: i32 = if draw_flood_options.equal { 1 } else { 0 };
let equal_in_name = utils::new_c_string("equal")?;
let left_in: i32 = draw_flood_options.left;
let left_in_name = utils::new_c_string("left")?;
let top_in: i32 = draw_flood_options.top;
let top_in_name = utils::new_c_string("top")?;
let width_in: i32 = draw_flood_options.width;
let width_in_name = utils::new_c_string("width")?;
let height_in: i32 = draw_flood_options.height;
let height_in_name = utils::new_c_string("height")?;
let vips_op_response = bindings::vips_draw_flood(
image_in,
ink_in,
ink.len() as i32,
x_in,
y_in,
test_in_name.as_ptr(),
test_in,
equal_in_name.as_ptr(),
equal_in,
left_in_name.as_ptr(),
left_in,
top_in_name.as_ptr(),
top_in,
width_in_name.as_ptr(),
width_in,
height_in_name.as_ptr(),
height_in,
NULL,
);
utils::result(vips_op_response, (), Error::DrawFloodError)
}
}
pub fn draw_image(image: &VipsImage, sub: &VipsImage, x: i32, y: i32) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let sub_in: *mut bindings::VipsImage = sub.ctx;
let x_in: i32 = x;
let y_in: i32 = y;
let vips_op_response = bindings::vips_draw_image(image_in, sub_in, x_in, y_in, NULL);
utils::result(vips_op_response, (), Error::DrawImageError)
}
}
#[derive(Clone, Debug)]
pub struct DrawImageOptions {
pub mode: CombineMode,
}
impl std::default::Default for DrawImageOptions {
fn default() -> Self {
DrawImageOptions {
mode: CombineMode::Set,
}
}
}
pub fn draw_image_with_opts(
image: &VipsImage,
sub: &VipsImage,
x: i32,
y: i32,
draw_image_options: &DrawImageOptions,
) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let sub_in: *mut bindings::VipsImage = sub.ctx;
let x_in: i32 = x;
let y_in: i32 = y;
let mode_in: i32 = draw_image_options.mode as i32;
let mode_in_name = utils::new_c_string("mode")?;
let vips_op_response = bindings::vips_draw_image(
image_in,
sub_in,
x_in,
y_in,
mode_in_name.as_ptr(),
mode_in,
NULL,
);
utils::result(vips_op_response, (), Error::DrawImageError)
}
}
pub fn draw_smudge(image: &VipsImage, left: i32, top: i32, width: i32, height: i32) -> Result<()> {
unsafe {
let image_in: *mut bindings::VipsImage = image.ctx;
let left_in: i32 = left;
let top_in: i32 = top;
let width_in: i32 = width;
let height_in: i32 = height;
let vips_op_response =
bindings::vips_draw_smudge(image_in, left_in, top_in, width_in, height_in, NULL);
utils::result(vips_op_response, (), Error::DrawSmudgeError)
}
}
pub fn merge(
refp: &VipsImage,
sec: &VipsImage,
direction: Direction,
dx: i32,
dy: i32,
) -> Result<VipsImage> {
unsafe {
let refp_in: *mut bindings::VipsImage = refp.ctx;
let sec_in: *mut bindings::VipsImage = sec.ctx;
let direction_in: i32 = direction as i32;
let dx_in: i32 = dx;
let dy_in: i32 = dy;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_merge(
refp_in,
sec_in,
&mut out_out,
direction_in.try_into().unwrap(),
dx_in,
dy_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MergeError,
)
}
}
#[derive(Clone, Debug)]
pub struct MergeOptions {
pub mblend: i32,
}
impl std::default::Default for MergeOptions {
fn default() -> Self {
MergeOptions {
mblend: i32::from(10),
}
}
}
pub fn merge_with_opts(
refp: &VipsImage,
sec: &VipsImage,
direction: Direction,
dx: i32,
dy: i32,
merge_options: &MergeOptions,
) -> Result<VipsImage> {
unsafe {
let refp_in: *mut bindings::VipsImage = refp.ctx;
let sec_in: *mut bindings::VipsImage = sec.ctx;
let direction_in: i32 = direction as i32;
let dx_in: i32 = dx;
let dy_in: i32 = dy;
let mut out_out: *mut bindings::VipsImage = null_mut();
let mblend_in: i32 = merge_options.mblend;
let mblend_in_name = utils::new_c_string("mblend")?;
let vips_op_response = bindings::vips_merge(
refp_in,
sec_in,
&mut out_out,
direction_in.try_into().unwrap(),
dx_in,
dy_in,
mblend_in_name.as_ptr(),
mblend_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MergeError,
)
}
}
pub fn mosaic(
refp: &VipsImage,
sec: &VipsImage,
direction: Direction,
xref: i32,
yref: i32,
xsec: i32,
ysec: i32,
) -> Result<VipsImage> {
unsafe {
let refp_in: *mut bindings::VipsImage = refp.ctx;
let sec_in: *mut bindings::VipsImage = sec.ctx;
let direction_in: i32 = direction as i32;
let xref_in: i32 = xref;
let yref_in: i32 = yref;
let xsec_in: i32 = xsec;
let ysec_in: i32 = ysec;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mosaic(
refp_in,
sec_in,
&mut out_out,
direction_in.try_into().unwrap(),
xref_in,
yref_in,
xsec_in,
ysec_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MosaicError,
)
}
}
#[derive(Clone, Debug)]
pub struct MosaicOptions {
pub hwindow: i32,
pub harea: i32,
pub mblend: i32,
pub bandno: i32,
pub dx_0: i32,
pub dy_0: i32,
pub scale_1: f64,
pub angle_1: f64,
pub dy_1: f64,
pub dx_1: f64,
}
impl std::default::Default for MosaicOptions {
fn default() -> Self {
MosaicOptions {
hwindow: i32::from(5),
harea: i32::from(15),
mblend: i32::from(10),
bandno: i32::from(0),
dx_0: i32::from(0),
dy_0: i32::from(0),
scale_1: f64::from(1),
angle_1: f64::from(0),
dy_1: f64::from(0),
dx_1: f64::from(0),
}
}
}
pub fn mosaic_with_opts(
refp: &VipsImage,
sec: &VipsImage,
direction: Direction,
xref: i32,
yref: i32,
xsec: i32,
ysec: i32,
mosaic_options: &MosaicOptions,
) -> Result<VipsImage> {
unsafe {
let refp_in: *mut bindings::VipsImage = refp.ctx;
let sec_in: *mut bindings::VipsImage = sec.ctx;
let direction_in: i32 = direction as i32;
let xref_in: i32 = xref;
let yref_in: i32 = yref;
let xsec_in: i32 = xsec;
let ysec_in: i32 = ysec;
let mut out_out: *mut bindings::VipsImage = null_mut();
let hwindow_in: i32 = mosaic_options.hwindow;
let hwindow_in_name = utils::new_c_string("hwindow")?;
let harea_in: i32 = mosaic_options.harea;
let harea_in_name = utils::new_c_string("harea")?;
let mblend_in: i32 = mosaic_options.mblend;
let mblend_in_name = utils::new_c_string("mblend")?;
let bandno_in: i32 = mosaic_options.bandno;
let bandno_in_name = utils::new_c_string("bandno")?;
let dx_0_in: i32 = mosaic_options.dx_0;
let dx_0_in_name = utils::new_c_string("dx0")?;
let dy_0_in: i32 = mosaic_options.dy_0;
let dy_0_in_name = utils::new_c_string("dy0")?;
let scale_1_in: f64 = mosaic_options.scale_1;
let scale_1_in_name = utils::new_c_string("scale1")?;
let angle_1_in: f64 = mosaic_options.angle_1;
let angle_1_in_name = utils::new_c_string("angle1")?;
let dy_1_in: f64 = mosaic_options.dy_1;
let dy_1_in_name = utils::new_c_string("dy1")?;
let dx_1_in: f64 = mosaic_options.dx_1;
let dx_1_in_name = utils::new_c_string("dx1")?;
let vips_op_response = bindings::vips_mosaic(
refp_in,
sec_in,
&mut out_out,
direction_in.try_into().unwrap(),
xref_in,
yref_in,
xsec_in,
ysec_in,
hwindow_in_name.as_ptr(),
hwindow_in,
harea_in_name.as_ptr(),
harea_in,
mblend_in_name.as_ptr(),
mblend_in,
bandno_in_name.as_ptr(),
bandno_in,
dx_0_in_name.as_ptr(),
dx_0_in,
dy_0_in_name.as_ptr(),
dy_0_in,
scale_1_in_name.as_ptr(),
scale_1_in,
angle_1_in_name.as_ptr(),
angle_1_in,
dy_1_in_name.as_ptr(),
dy_1_in,
dx_1_in_name.as_ptr(),
dx_1_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MosaicError,
)
}
}
pub fn mosaic_1(
refp: &VipsImage,
sec: &VipsImage,
direction: Direction,
xr_1: i32,
yr_1: i32,
xs_1: i32,
ys_1: i32,
xr_2: i32,
yr_2: i32,
xs_2: i32,
ys_2: i32,
) -> Result<VipsImage> {
unsafe {
let refp_in: *mut bindings::VipsImage = refp.ctx;
let sec_in: *mut bindings::VipsImage = sec.ctx;
let direction_in: i32 = direction as i32;
let xr_1_in: i32 = xr_1;
let yr_1_in: i32 = yr_1;
let xs_1_in: i32 = xs_1;
let ys_1_in: i32 = ys_1;
let xr_2_in: i32 = xr_2;
let yr_2_in: i32 = yr_2;
let xs_2_in: i32 = xs_2;
let ys_2_in: i32 = ys_2;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_mosaic1(
refp_in,
sec_in,
&mut out_out,
direction_in.try_into().unwrap(),
xr_1_in,
yr_1_in,
xs_1_in,
ys_1_in,
xr_2_in,
yr_2_in,
xs_2_in,
ys_2_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Mosaic1Error,
)
}
}
#[derive(Clone, Debug)]
pub struct Mosaic1Options {
pub hwindow: i32,
pub harea: i32,
pub search: bool,
pub interpolate: VipsInterpolate,
pub mblend: i32,
pub bandno: i32,
}
impl std::default::Default for Mosaic1Options {
fn default() -> Self {
Mosaic1Options {
hwindow: i32::from(5),
harea: i32::from(15),
search: false,
interpolate: VipsInterpolate::new(),
mblend: i32::from(10),
bandno: i32::from(0),
}
}
}
pub fn mosaic_1_with_opts(
refp: &VipsImage,
sec: &VipsImage,
direction: Direction,
xr_1: i32,
yr_1: i32,
xs_1: i32,
ys_1: i32,
xr_2: i32,
yr_2: i32,
xs_2: i32,
ys_2: i32,
mosaic_1_options: &Mosaic1Options,
) -> Result<VipsImage> {
unsafe {
let refp_in: *mut bindings::VipsImage = refp.ctx;
let sec_in: *mut bindings::VipsImage = sec.ctx;
let direction_in: i32 = direction as i32;
let xr_1_in: i32 = xr_1;
let yr_1_in: i32 = yr_1;
let xs_1_in: i32 = xs_1;
let ys_1_in: i32 = ys_1;
let xr_2_in: i32 = xr_2;
let yr_2_in: i32 = yr_2;
let xs_2_in: i32 = xs_2;
let ys_2_in: i32 = ys_2;
let mut out_out: *mut bindings::VipsImage = null_mut();
let hwindow_in: i32 = mosaic_1_options.hwindow;
let hwindow_in_name = utils::new_c_string("hwindow")?;
let harea_in: i32 = mosaic_1_options.harea;
let harea_in_name = utils::new_c_string("harea")?;
let search_in: i32 = if mosaic_1_options.search { 1 } else { 0 };
let search_in_name = utils::new_c_string("search")?;
let interpolate_in: *mut bindings::VipsInterpolate = mosaic_1_options.interpolate.ctx;
let interpolate_in_name = utils::new_c_string("interpolate")?;
let mblend_in: i32 = mosaic_1_options.mblend;
let mblend_in_name = utils::new_c_string("mblend")?;
let bandno_in: i32 = mosaic_1_options.bandno;
let bandno_in_name = utils::new_c_string("bandno")?;
let vips_op_response = bindings::vips_mosaic1(
refp_in,
sec_in,
&mut out_out,
direction_in.try_into().unwrap(),
xr_1_in,
yr_1_in,
xs_1_in,
ys_1_in,
xr_2_in,
yr_2_in,
xs_2_in,
ys_2_in,
hwindow_in_name.as_ptr(),
hwindow_in,
harea_in_name.as_ptr(),
harea_in,
search_in_name.as_ptr(),
search_in,
interpolate_in_name.as_ptr(),
interpolate_in,
mblend_in_name.as_ptr(),
mblend_in,
bandno_in_name.as_ptr(),
bandno_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::Mosaic1Error,
)
}
}
pub fn matches(
refp: &VipsImage,
sec: &VipsImage,
xr_1: i32,
yr_1: i32,
xs_1: i32,
ys_1: i32,
xr_2: i32,
yr_2: i32,
xs_2: i32,
ys_2: i32,
) -> Result<VipsImage> {
unsafe {
let refp_in: *mut bindings::VipsImage = refp.ctx;
let sec_in: *mut bindings::VipsImage = sec.ctx;
let xr_1_in: i32 = xr_1;
let yr_1_in: i32 = yr_1;
let xs_1_in: i32 = xs_1;
let ys_1_in: i32 = ys_1;
let xr_2_in: i32 = xr_2;
let yr_2_in: i32 = yr_2;
let xs_2_in: i32 = xs_2;
let ys_2_in: i32 = ys_2;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_match(
refp_in,
sec_in,
&mut out_out,
xr_1_in,
yr_1_in,
xs_1_in,
ys_1_in,
xr_2_in,
yr_2_in,
xs_2_in,
ys_2_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MatchError,
)
}
}
#[derive(Clone, Debug)]
pub struct MatchOptions {
pub hwindow: i32,
pub harea: i32,
pub search: bool,
pub interpolate: VipsInterpolate,
}
impl std::default::Default for MatchOptions {
fn default() -> Self {
MatchOptions {
hwindow: i32::from(1),
harea: i32::from(1),
search: false,
interpolate: VipsInterpolate::new(),
}
}
}
pub fn matches_with_opts(
refp: &VipsImage,
sec: &VipsImage,
xr_1: i32,
yr_1: i32,
xs_1: i32,
ys_1: i32,
xr_2: i32,
yr_2: i32,
xs_2: i32,
ys_2: i32,
matches_options: &MatchOptions,
) -> Result<VipsImage> {
unsafe {
let refp_in: *mut bindings::VipsImage = refp.ctx;
let sec_in: *mut bindings::VipsImage = sec.ctx;
let xr_1_in: i32 = xr_1;
let yr_1_in: i32 = yr_1;
let xs_1_in: i32 = xs_1;
let ys_1_in: i32 = ys_1;
let xr_2_in: i32 = xr_2;
let yr_2_in: i32 = yr_2;
let xs_2_in: i32 = xs_2;
let ys_2_in: i32 = ys_2;
let mut out_out: *mut bindings::VipsImage = null_mut();
let hwindow_in: i32 = matches_options.hwindow;
let hwindow_in_name = utils::new_c_string("hwindow")?;
let harea_in: i32 = matches_options.harea;
let harea_in_name = utils::new_c_string("harea")?;
let search_in: i32 = if matches_options.search { 1 } else { 0 };
let search_in_name = utils::new_c_string("search")?;
let interpolate_in: *mut bindings::VipsInterpolate = matches_options.interpolate.ctx;
let interpolate_in_name = utils::new_c_string("interpolate")?;
let vips_op_response = bindings::vips_match(
refp_in,
sec_in,
&mut out_out,
xr_1_in,
yr_1_in,
xs_1_in,
ys_1_in,
xr_2_in,
yr_2_in,
xs_2_in,
ys_2_in,
hwindow_in_name.as_ptr(),
hwindow_in,
harea_in_name.as_ptr(),
harea_in,
search_in_name.as_ptr(),
search_in,
interpolate_in_name.as_ptr(),
interpolate_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::MatchError,
)
}
}
pub fn globalbalance(inp: &VipsImage) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let vips_op_response = bindings::vips_globalbalance(inp_in, &mut out_out, NULL);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GlobalbalanceError,
)
}
}
#[derive(Clone, Debug)]
pub struct GlobalbalanceOptions {
pub gamma: f64,
pub int_output: bool,
}
impl std::default::Default for GlobalbalanceOptions {
fn default() -> Self {
GlobalbalanceOptions {
gamma: f64::from(1.6),
int_output: false,
}
}
}
pub fn globalbalance_with_opts(
inp: &VipsImage,
globalbalance_options: &GlobalbalanceOptions,
) -> Result<VipsImage> {
unsafe {
let inp_in: *mut bindings::VipsImage = inp.ctx;
let mut out_out: *mut bindings::VipsImage = null_mut();
let gamma_in: f64 = globalbalance_options.gamma;
let gamma_in_name = utils::new_c_string("gamma")?;
let int_output_in: i32 = if globalbalance_options.int_output {
1
} else {
0
};
let int_output_in_name = utils::new_c_string("int-output")?;
let vips_op_response = bindings::vips_globalbalance(
inp_in,
&mut out_out,
gamma_in_name.as_ptr(),
gamma_in,
int_output_in_name.as_ptr(),
int_output_in,
NULL,
);
utils::result(
vips_op_response,
VipsImage { ctx: out_out },
Error::GlobalbalanceError,
)
}
}