use crate::{sys, Error, ImageBuf, Result, Roi};
pub use sys::imagebufalgo::CompareSummary;
pub use sys::imagebufalgo::RangeCheckCounts;
const ALL_THREADS: i32 = 0;
fn region(roi: Option<Roi>) -> sys::imageio::ROI {
roi.map_or_else(sys::imageio::roi_default, Roi::to_sys)
}
fn region_in(roi: Option<Roi>, dst: &ImageBuf) -> Result<sys::imageio::ROI> {
if let Some(roi) = roi {
let channels = roi.channels();
let available = dst.channel_count();
if dst.is_initialized() {
if channels.start >= available {
return Err(Error::InvalidRoi(format!(
"the region starts at channel {} and the destination has {available}",
channels.start
)));
}
} else if channels.start != 0 {
return Err(Error::InvalidRoi(format!(
"the region starts at channel {}; a destination that is not allocated yet is built from the region itself, so the region must begin at channel zero",
channels.start
)));
}
}
Ok(region(roi))
}
fn finish(dst: &mut ImageBuf, operation: &'static str, succeeded: bool) -> Result<()> {
if succeeded {
Ok(())
} else {
Err(Error::operation(operation, dst.take_error()))
}
}
pub fn zero(dst: &mut ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded =
unsafe { sys::imagebufalgo::imagebufalgo_zero(dst.inner_mut(), &roi, ALL_THREADS) };
finish(dst, "zero", succeeded)
}
pub fn fill(dst: &mut ImageBuf, values: &[f32], roi: Option<Roi>) -> Result<()> {
if values.is_empty() {
return Err(Error::InvalidImageSpec(
"fill needs at least one channel value".to_owned(),
));
}
let roi = region_in(roi, dst)?;
let succeeded =
unsafe { sys::imagebufalgo::imagebufalgo_fill(dst.inner_mut(), values, &roi, ALL_THREADS) };
finish(dst, "fill", succeeded)
}
macro_rules! binary_operation {
($name:ident, $constant_name:ident, $images:path, $constants:path, $label:literal) => {
#[doc = concat!("Compute `a ", $label, " b` into `dst`.")]
pub fn $name(
dst: &mut ImageBuf,
a: &ImageBuf,
b: &ImageBuf,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded =
unsafe { $images(dst.inner_mut(), a.inner(), b.inner(), &roi, ALL_THREADS) };
finish(dst, $label, succeeded)
}
#[doc = concat!("Compute `a ", $label, " values` into `dst`, one value per channel.")]
pub fn $constant_name(
dst: &mut ImageBuf,
a: &ImageBuf,
values: &[f32],
roi: Option<Roi>,
) -> Result<()> {
if values.is_empty() {
return Err(Error::InvalidImageSpec(
"this operation needs at least one channel value".to_owned(),
));
}
let roi = region_in(roi, dst)?;
let succeeded =
unsafe { $constants(dst.inner_mut(), a.inner(), values, &roi, ALL_THREADS) };
finish(dst, $label, succeeded)
}
};
}
binary_operation!(
add,
add_constant,
sys::imagebufalgo::imagebufalgo_add_images,
sys::imagebufalgo::imagebufalgo_add_constant,
"add"
);
binary_operation!(
sub,
sub_constant,
sys::imagebufalgo::imagebufalgo_sub_images,
sys::imagebufalgo::imagebufalgo_sub_constant,
"subtract"
);
binary_operation!(
mul,
mul_constant,
sys::imagebufalgo::imagebufalgo_mul_images,
sys::imagebufalgo::imagebufalgo_mul_constant,
"multiply"
);
binary_operation!(
div,
div_constant,
sys::imagebufalgo::imagebufalgo_div_images,
sys::imagebufalgo::imagebufalgo_div_constant,
"divide"
);
pub fn fill_gradient(
dst: &mut ImageBuf,
top: &[f32],
bottom: &[f32],
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_fill_vertical(
dst.inner_mut(),
top,
bottom,
&roi,
ALL_THREADS,
)
};
finish(dst, "fill gradient", succeeded)
}
pub fn fill_corners(
dst: &mut ImageBuf,
top_left: &[f32],
top_right: &[f32],
bottom_left: &[f32],
bottom_right: &[f32],
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_fill_corners(
dst.inner_mut(),
top_left,
top_right,
bottom_left,
bottom_right,
&roi,
ALL_THREADS,
)
};
finish(dst, "fill corners", succeeded)
}
pub fn checker(
dst: &mut ImageBuf,
size: [u32; 3],
color1: &[f32],
color2: &[f32],
offset: [i32; 3],
roi: Option<Roi>,
) -> Result<()> {
let dimension = |name: &'static str, value: u32| {
i32::try_from(value)
.map_err(|_| Error::InvalidImageSpec(format!("checker {name} exceeds i32::MAX")))
};
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_checker(
dst.inner_mut(),
dimension("width", size[0])?,
dimension("height", size[1])?,
dimension("depth", size[2])?,
color1,
color2,
offset[0],
offset[1],
offset[2],
&roi,
ALL_THREADS,
)
};
finish(dst, "checker", succeeded)
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Noise {
Gaussian {
mean: f32,
standard_deviation: f32,
},
Uniform {
min: f32,
max: f32,
},
Blue {
min: f32,
max: f32,
},
Salt {
value: f32,
portion: f32,
},
}
impl Noise {
fn parts(self) -> (&'static str, f32, f32) {
match self {
Self::Gaussian {
mean,
standard_deviation,
} => ("gaussian", mean, standard_deviation),
Self::Uniform { min, max } => ("uniform", min, max),
Self::Blue { min, max } => ("blue", min, max),
Self::Salt { value, portion } => ("salt", value, portion),
}
}
}
pub fn noise(
dst: &mut ImageBuf,
kind: Noise,
mono: bool,
seed: i32,
roi: Option<Roi>,
) -> Result<()> {
let (name, a, b) = kind.parts();
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_noise(
dst.inner_mut(),
name,
a,
b,
mono,
seed,
&roi,
ALL_THREADS,
)
};
finish(dst, "noise", succeeded)
}
pub fn render_point(
dst: &mut ImageBuf,
x: i32,
y: i32,
color: &[f32],
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_render_point(
dst.inner_mut(),
x,
y,
color,
&roi,
ALL_THREADS,
)
};
finish(dst, "render point", succeeded)
}
pub fn render_line(
dst: &mut ImageBuf,
from: [i32; 2],
to: [i32; 2],
color: &[f32],
skip_first_point: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_render_line(
dst.inner_mut(),
from[0],
from[1],
to[0],
to[1],
color,
skip_first_point,
&roi,
ALL_THREADS,
)
};
finish(dst, "render line", succeeded)
}
pub fn render_box(
dst: &mut ImageBuf,
corner: [i32; 2],
opposite: [i32; 2],
color: &[f32],
fill: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_render_box(
dst.inner_mut(),
corner[0],
corner[1],
opposite[0],
opposite[1],
color,
fill,
&roi,
ALL_THREADS,
)
};
finish(dst, "render box", succeeded)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub enum TextAlignX {
#[default]
Left,
Right,
Center,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub enum TextAlignY {
#[default]
Baseline,
Top,
Bottom,
Center,
}
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub struct TextOptions<'a> {
pub size: u32,
pub font: &'a str,
pub color: &'a [f32],
pub align_x: TextAlignX,
pub align_y: TextAlignY,
pub shadow: u32,
}
impl Default for TextOptions<'_> {
fn default() -> Self {
Self {
size: 16,
font: "",
color: &[1.0],
align_x: TextAlignX::default(),
align_y: TextAlignY::default(),
shadow: 0,
}
}
}
pub fn render_text(
dst: &mut ImageBuf,
position: [i32; 2],
text: &str,
options: &TextOptions<'_>,
roi: Option<Roi>,
) -> Result<()> {
let (size, shadow) = text_metrics(options.size, options.shadow)?;
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_render_text(
dst.inner_mut(),
position[0],
position[1],
text,
size,
options.font,
options.color,
options.align_x as i32,
options.align_y as i32,
shadow,
&roi,
ALL_THREADS,
)
};
finish(dst, "render text", succeeded)
}
pub fn text_size(text: &str, size: u32, font: &str) -> Result<Roi> {
let (size, _) = text_metrics(size, 0)?;
let measured = unsafe { sys::imagebufalgo::imagebufalgo_text_size(text, size, font) };
Roi::from_sys_optional(measured)?.ok_or_else(|| {
Error::operation(
"text size",
"nothing could be measured; the text may be empty, or the font \
missing, and OpenImageIO does not say which"
.to_owned(),
)
})
}
fn text_metrics(size: u32, shadow: u32) -> Result<(i32, i32)> {
let size = i32::try_from(size)
.map_err(|_| Error::InvalidImageSpec("font size exceeds i32::MAX".to_owned()))?;
if size < 1 {
return Err(Error::InvalidImageSpec(
"the font size must be at least 1".to_owned(),
));
}
let shadow = i32::try_from(shadow)
.map_err(|_| Error::InvalidImageSpec("shadow width exceeds i32::MAX".to_owned()))?;
Ok((size, shadow))
}
pub fn flatten(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_flatten(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "flatten", succeeded)
}
pub fn deepen(dst: &mut ImageBuf, src: &ImageBuf, z_value: f32, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_deepen(
dst.inner_mut(),
src.inner(),
z_value,
&roi,
ALL_THREADS,
)
};
finish(dst, "deepen", succeeded)
}
pub fn deep_merge(
dst: &mut ImageBuf,
a: &ImageBuf,
b: &ImageBuf,
occlusion_cull: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_deep_merge(
dst.inner_mut(),
a.inner(),
b.inner(),
occlusion_cull,
&roi,
ALL_THREADS,
)
};
finish(dst, "deep merge", succeeded)
}
pub fn deep_holdout(
dst: &mut ImageBuf,
src: &ImageBuf,
holdout: &ImageBuf,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_deep_holdout(
dst.inner_mut(),
src.inner(),
holdout.inner(),
&roi,
ALL_THREADS,
)
};
finish(dst, "deep holdout", succeeded)
}
pub fn make_kernel(name: &str, width: f32, height: f32, normalize: bool) -> Result<ImageBuf> {
let mut kernel = ImageBuf::empty()?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_make_kernel(
kernel.inner_mut(),
name,
width,
height,
1.0,
normalize,
)
};
if succeeded {
Ok(kernel)
} else {
Err(Error::operation("make kernel", kernel.take_error()))
}
}
pub fn convolve(
dst: &mut ImageBuf,
src: &ImageBuf,
kernel: &ImageBuf,
normalize: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_convolve(
dst.inner_mut(),
src.inner(),
kernel.inner(),
normalize,
&roi,
ALL_THREADS,
)
};
finish(dst, "convolve", succeeded)
}
pub fn laplacian(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_laplacian(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "laplacian", succeeded)
}
pub fn unsharp_mask(
dst: &mut ImageBuf,
src: &ImageBuf,
kernel: &str,
width: f32,
contrast: f32,
threshold: f32,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_unsharp_mask(
dst.inner_mut(),
src.inner(),
kernel,
width,
contrast,
threshold,
&roi,
ALL_THREADS,
)
};
finish(dst, "unsharp mask", succeeded)
}
pub fn median_filter(
dst: &mut ImageBuf,
src: &ImageBuf,
width: u32,
height: Option<u32>,
roi: Option<Roi>,
) -> Result<()> {
let (width, height) = window("median filter", width, height)?;
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_median_filter(
dst.inner_mut(),
src.inner(),
width,
height,
&roi,
ALL_THREADS,
)
};
finish(dst, "median filter", succeeded)
}
pub fn dilate(
dst: &mut ImageBuf,
src: &ImageBuf,
width: u32,
height: Option<u32>,
roi: Option<Roi>,
) -> Result<()> {
let (width, height) = window("dilate", width, height)?;
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_dilate(
dst.inner_mut(),
src.inner(),
width,
height,
&roi,
ALL_THREADS,
)
};
finish(dst, "dilate", succeeded)
}
pub fn erode(
dst: &mut ImageBuf,
src: &ImageBuf,
width: u32,
height: Option<u32>,
roi: Option<Roi>,
) -> Result<()> {
let (width, height) = window("erode", width, height)?;
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_erode(
dst.inner_mut(),
src.inner(),
width,
height,
&roi,
ALL_THREADS,
)
};
finish(dst, "erode", succeeded)
}
fn window(operation: &str, width: u32, height: Option<u32>) -> Result<(i32, i32)> {
let to_i32 = |value: u32| {
i32::try_from(value)
.map_err(|_| Error::InvalidImageSpec(format!("{operation} window exceeds i32::MAX")))
};
Ok((
to_i32(width)?,
height.map(to_i32).transpose()?.unwrap_or(-1),
))
}
pub fn fft(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_fft(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "fft", succeeded)
}
pub fn ifft(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_ifft(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "ifft", succeeded)
}
pub fn polar_to_complex(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_polar_to_complex(
dst.inner_mut(),
src.inner(),
&roi,
ALL_THREADS,
)
};
finish(dst, "polar to complex", succeeded)
}
pub fn complex_to_polar(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_complex_to_polar(
dst.inner_mut(),
src.inner(),
&roi,
ALL_THREADS,
)
};
finish(dst, "complex to polar", succeeded)
}
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub struct OcioOptions<'a> {
pub unpremult: bool,
pub inverse: bool,
pub context_key: &'a str,
pub context_value: &'a str,
}
impl Default for OcioOptions<'_> {
fn default() -> Self {
Self {
unpremult: true,
inverse: false,
context_key: "",
context_value: "",
}
}
}
pub fn color_matrix_transform(
dst: &mut ImageBuf,
src: &ImageBuf,
matrix: &[f32; 16],
unpremult: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_colormatrixtransform(
dst.inner_mut(),
src.inner(),
matrix,
unpremult,
&roi,
ALL_THREADS,
)
};
finish(dst, "colour matrix transform", succeeded)
}
pub fn ocio_look(
dst: &mut ImageBuf,
src: &ImageBuf,
looks: &str,
from_space: Option<&str>,
to_space: Option<&str>,
options: &OcioOptions<'_>,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_ociolook(
dst.inner_mut(),
src.inner(),
looks,
from_space.unwrap_or_default(),
to_space.unwrap_or_default(),
options.unpremult,
options.inverse,
options.context_key,
options.context_value,
&roi,
ALL_THREADS,
)
};
finish(dst, "OpenColorIO look", succeeded)
}
#[allow(clippy::too_many_arguments)]
pub fn ocio_display(
dst: &mut ImageBuf,
src: &ImageBuf,
display: &str,
view: &str,
from_space: Option<&str>,
looks: &str,
options: &OcioOptions<'_>,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_ociodisplay(
dst.inner_mut(),
src.inner(),
display,
view,
from_space.unwrap_or_default(),
looks,
options.unpremult,
options.inverse,
options.context_key,
options.context_value,
&roi,
ALL_THREADS,
)
};
finish(dst, "OpenColorIO display", succeeded)
}
pub fn ocio_file_transform(
dst: &mut ImageBuf,
src: &ImageBuf,
transform_path: &std::path::Path,
options: &OcioOptions<'_>,
roi: Option<Roi>,
) -> Result<()> {
let name = crate::path_to_utf8(transform_path)?;
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_ociofiletransform(
dst.inner_mut(),
src.inner(),
name,
options.unpremult,
options.inverse,
&roi,
ALL_THREADS,
)
};
finish(dst, "OpenColorIO file transform", succeeded)
}
pub fn ocio_named_transform(
dst: &mut ImageBuf,
src: &ImageBuf,
name: &str,
options: &OcioOptions<'_>,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_ocionamedtransform(
dst.inner_mut(),
src.inner(),
name,
options.unpremult,
options.inverse,
options.context_key,
options.context_value,
&roi,
ALL_THREADS,
)
};
finish(dst, "OpenColorIO named transform", succeeded)
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct PixelStats {
pub min: Vec<f32>,
pub max: Vec<f32>,
pub average: Vec<f32>,
pub standard_deviation: Vec<f32>,
pub nan_count: Vec<u64>,
pub infinite_count: Vec<u64>,
pub finite_count: Vec<u64>,
}
pub fn pixel_stats(src: &ImageBuf, roi: Option<Roi>) -> Result<PixelStats> {
let roi = region_in(roi, src)?;
let stats =
unsafe { sys::imagebufalgo::imagebufalgo_pixel_stats(src.inner(), &roi, ALL_THREADS) };
if !stats.ok {
return Err(Error::operation("pixel statistics", stats.error));
}
Ok(PixelStats {
min: stats.min,
max: stats.max,
average: stats.average,
standard_deviation: stats.standard_deviation,
nan_count: stats.nan_count,
infinite_count: stats.infinite_count,
finite_count: stats.finite_count,
})
}
pub fn histogram(
src: &ImageBuf,
channel: u32,
bins: u32,
range: std::ops::Range<f32>,
ignore_empty: bool,
roi: Option<Roi>,
) -> Result<Vec<u64>> {
let channel = i32::try_from(channel)
.map_err(|_| Error::InvalidImageSpec("channel exceeds i32::MAX".to_owned()))?;
let bins = i32::try_from(bins)
.map_err(|_| Error::InvalidImageSpec("bin count exceeds i32::MAX".to_owned()))?;
let roi = region_in(roi, src)?;
let mut message = String::new();
let counts = unsafe {
sys::imagebufalgo::imagebufalgo_histogram(
src.inner(),
channel,
bins,
range.start,
range.end,
ignore_empty,
&roi,
ALL_THREADS,
&mut message,
)
};
if counts.is_empty() {
return Err(Error::operation("histogram", message));
}
Ok(counts.into_iter().collect())
}
pub fn constant_color(
src: &ImageBuf,
threshold: f32,
roi: Option<Roi>,
) -> Result<Option<Vec<f32>>> {
let channels = src.spec()?.channel_count() as usize;
let mut color = vec![0.0_f32; channels];
let roi = region_in(roi, src)?;
let mut message = String::new();
let constant = unsafe {
sys::imagebufalgo::imagebufalgo_is_constant_color(
src.inner(),
threshold,
&mut color,
&roi,
ALL_THREADS,
&mut message,
)
};
if constant {
return Ok(Some(color));
}
if message.is_empty() {
Ok(None)
} else {
Err(Error::operation("constant colour", message))
}
}
pub fn is_constant_channel(
src: &ImageBuf,
channel: u32,
value: f32,
threshold: f32,
roi: Option<Roi>,
) -> Result<bool> {
let channel = i32::try_from(channel)
.map_err(|_| Error::InvalidImageSpec("channel exceeds i32::MAX".to_owned()))?;
let roi = region_in(roi, src)?;
let mut message = String::new();
let constant = unsafe {
sys::imagebufalgo::imagebufalgo_is_constant_channel(
src.inner(),
channel,
value,
threshold,
&roi,
ALL_THREADS,
&mut message,
)
};
if !constant && !message.is_empty() {
return Err(Error::operation("constant channel", message));
}
Ok(constant)
}
pub fn is_monochrome(src: &ImageBuf, threshold: f32, roi: Option<Roi>) -> Result<bool> {
let roi = region_in(roi, src)?;
let mut message = String::new();
let monochrome = unsafe {
sys::imagebufalgo::imagebufalgo_is_monochrome(
src.inner(),
threshold,
&roi,
ALL_THREADS,
&mut message,
)
};
if !monochrome && !message.is_empty() {
return Err(Error::operation("monochrome test", message));
}
Ok(monochrome)
}
pub fn nonzero_region(src: &ImageBuf, roi: Option<Roi>) -> Result<Option<Roi>> {
let roi = region_in(roi, src)?;
let mut message = String::new();
let found = unsafe {
sys::imagebufalgo::imagebufalgo_nonzero_region(src.inner(), &roi, ALL_THREADS, &mut message)
};
if !message.is_empty() {
return Err(Error::operation("nonzero region", message));
}
Roi::from_sys_optional(found)
}
pub fn pixel_hash_sha1(src: &ImageBuf, extra_info: &str, roi: Option<Roi>) -> Result<String> {
let roi = region_in(roi, src)?;
let mut message = String::new();
let digest = unsafe {
sys::imagebufalgo::imagebufalgo_pixel_hash_sha1(
src.inner(),
extra_info,
&roi,
ALL_THREADS,
&mut message,
)
};
if digest.is_empty() {
return Err(Error::operation("pixel hash", message));
}
Ok(digest)
}
pub fn rotate_90(dst: &mut ImageBuf, src: &ImageBuf, src_roi: Option<Roi>) -> Result<()> {
let roi = region(src_roi);
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_rotate90(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "rotate 90", succeeded)
}
pub fn rotate_180(dst: &mut ImageBuf, src: &ImageBuf, src_roi: Option<Roi>) -> Result<()> {
let roi = region(src_roi);
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_rotate180(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "rotate 180", succeeded)
}
pub fn rotate_270(dst: &mut ImageBuf, src: &ImageBuf, src_roi: Option<Roi>) -> Result<()> {
let roi = region(src_roi);
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_rotate270(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "rotate 270", succeeded)
}
pub fn reorient(dst: &mut ImageBuf, src: &ImageBuf) -> Result<()> {
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_reorient(dst.inner_mut(), src.inner(), ALL_THREADS)
};
finish(dst, "reorient", succeeded)
}
#[derive(Debug, Clone, Copy, Default)]
#[non_exhaustive]
pub struct WarpOptions<'a> {
pub filter: Option<&'a str>,
pub filter_width: Option<f32>,
pub wrap: Option<&'a str>,
pub edge_clamp: bool,
pub recompute_region: bool,
}
pub fn rotate(
dst: &mut ImageBuf,
src: &ImageBuf,
angle: f32,
center: Option<[f32; 2]>,
options: &WarpOptions<'_>,
roi: Option<Roi>,
) -> Result<()> {
if options.wrap.is_some() || options.edge_clamp {
return Err(Error::InvalidImageSpec(
"rotate always leaves black outside the source; use warp with a rotation matrix to choose a wrap mode or edge clamping"
.to_owned(),
));
}
let roi = region_in(roi, dst)?;
let [center_x, center_y] = center.unwrap_or([0.0, 0.0]);
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_rotate(
dst.inner_mut(),
src.inner(),
angle,
center.is_some(),
center_x,
center_y,
options.filter.unwrap_or_default(),
options.filter_width.unwrap_or(0.0),
options.recompute_region,
&roi,
ALL_THREADS,
)
};
finish(dst, "rotate", succeeded)
}
pub fn warp(
dst: &mut ImageBuf,
src: &ImageBuf,
matrix: &[f32; 9],
options: &WarpOptions<'_>,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_warp(
dst.inner_mut(),
src.inner(),
matrix,
options.filter.unwrap_or_default(),
options.filter_width.unwrap_or(0.0),
options.wrap.unwrap_or_default(),
options.edge_clamp,
options.recompute_region,
&roi,
ALL_THREADS,
)
};
finish(dst, "warp", succeeded)
}
pub fn st_warp(
dst: &mut ImageBuf,
src: &ImageBuf,
coordinates: &ImageBuf,
channels: [u32; 2],
flip: [bool; 2],
options: &WarpOptions<'_>,
roi: Option<Roi>,
) -> Result<()> {
let index = |name: &'static str, value: u32| {
i32::try_from(value)
.map_err(|_| Error::InvalidImageSpec(format!("{name} exceeds i32::MAX")))
};
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_st_warp(
dst.inner_mut(),
src.inner(),
coordinates.inner(),
options.filter.unwrap_or_default(),
options.filter_width.unwrap_or(0.0),
index("s channel", channels[0])?,
index("t channel", channels[1])?,
flip[0],
flip[1],
&roi,
ALL_THREADS,
)
};
finish(dst, "st_warp", succeeded)
}
#[derive(Debug, Clone, Copy)]
pub enum Operand<'a> {
Image(&'a ImageBuf),
Constant(&'a [f32]),
}
pub fn mad(
dst: &mut ImageBuf,
a: &ImageBuf,
b: Operand<'_>,
c: Operand<'_>,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = match (b, c) {
(Operand::Image(b), Operand::Image(c)) => unsafe {
sys::imagebufalgo::imagebufalgo_mad_iii(
dst.inner_mut(),
a.inner(),
b.inner(),
c.inner(),
&roi,
ALL_THREADS,
)
},
(Operand::Image(b), Operand::Constant(c)) => unsafe {
sys::imagebufalgo::imagebufalgo_mad_iic(
dst.inner_mut(),
a.inner(),
b.inner(),
c,
&roi,
ALL_THREADS,
)
},
(Operand::Constant(b), Operand::Image(c)) => unsafe {
sys::imagebufalgo::imagebufalgo_mad_ici(
dst.inner_mut(),
a.inner(),
b,
c.inner(),
&roi,
ALL_THREADS,
)
},
(Operand::Constant(b), Operand::Constant(c)) => unsafe {
sys::imagebufalgo::imagebufalgo_mad_icc(
dst.inner_mut(),
a.inner(),
b,
c,
&roi,
ALL_THREADS,
)
},
};
finish(dst, "multiply and add", succeeded)
}
pub fn invert(dst: &mut ImageBuf, a: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_invert(dst.inner_mut(), a.inner(), &roi, ALL_THREADS)
};
finish(dst, "invert", succeeded)
}
pub fn pow(dst: &mut ImageBuf, a: &ImageBuf, exponents: &[f32], roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_pow(
dst.inner_mut(),
a.inner(),
exponents,
&roi,
ALL_THREADS,
)
};
finish(dst, "power", succeeded)
}
pub fn clamp(
dst: &mut ImageBuf,
src: &ImageBuf,
min: &[f32],
max: &[f32],
clamp_alpha_to_unit: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_clamp(
dst.inner_mut(),
src.inner(),
min,
max,
clamp_alpha_to_unit,
&roi,
ALL_THREADS,
)
};
finish(dst, "clamp", succeeded)
}
pub fn min(dst: &mut ImageBuf, a: &ImageBuf, b: Operand<'_>, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = match b {
Operand::Image(b) => unsafe {
sys::imagebufalgo::imagebufalgo_min_images(
dst.inner_mut(),
a.inner(),
b.inner(),
&roi,
ALL_THREADS,
)
},
Operand::Constant(values) => unsafe {
sys::imagebufalgo::imagebufalgo_min_constant(
dst.inner_mut(),
a.inner(),
values,
&roi,
ALL_THREADS,
)
},
};
finish(dst, "minimum", succeeded)
}
pub fn max(dst: &mut ImageBuf, a: &ImageBuf, b: Operand<'_>, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = match b {
Operand::Image(b) => unsafe {
sys::imagebufalgo::imagebufalgo_max_images(
dst.inner_mut(),
a.inner(),
b.inner(),
&roi,
ALL_THREADS,
)
},
Operand::Constant(values) => unsafe {
sys::imagebufalgo::imagebufalgo_max_constant(
dst.inner_mut(),
a.inner(),
values,
&roi,
ALL_THREADS,
)
},
};
finish(dst, "maximum", succeeded)
}
#[derive(Debug, Clone, Copy, Default)]
#[non_exhaustive]
pub struct ContrastRemap<'a> {
pub black: &'a [f32],
pub white: &'a [f32],
pub min: &'a [f32],
pub max: &'a [f32],
pub sigmoid_contrast: &'a [f32],
pub sigmoid_threshold: &'a [f32],
}
pub fn contrast_remap(
dst: &mut ImageBuf,
src: &ImageBuf,
remap: &ContrastRemap<'_>,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_contrast_remap(
dst.inner_mut(),
src.inner(),
remap.black,
remap.white,
remap.min,
remap.max,
remap.sigmoid_contrast,
remap.sigmoid_threshold,
&roi,
ALL_THREADS,
)
};
finish(dst, "contrast remap", succeeded)
}
pub fn saturate(
dst: &mut ImageBuf,
src: &ImageBuf,
scale: f32,
first_channel: u32,
roi: Option<Roi>,
) -> Result<()> {
let first_channel = i32::try_from(first_channel)
.map_err(|_| Error::InvalidImageSpec("first channel exceeds i32::MAX".to_owned()))?;
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_saturate(
dst.inner_mut(),
src.inner(),
scale,
first_channel,
&roi,
ALL_THREADS,
)
};
finish(dst, "saturate", succeeded)
}
pub fn paste(
dst: &mut ImageBuf,
position: [i32; 3],
first_channel: i32,
src: &ImageBuf,
src_roi: Option<Roi>,
) -> Result<()> {
let src_roi = region(src_roi);
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_paste(
dst.inner_mut(),
position[0],
position[1],
position[2],
first_channel,
src.inner(),
&src_roi,
ALL_THREADS,
)
};
finish(dst, "paste", succeeded)
}
pub fn cut(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_cut(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "cut", succeeded)
}
pub fn abs(dst: &mut ImageBuf, a: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_abs(dst.inner_mut(), a.inner(), &roi, ALL_THREADS)
};
finish(dst, "absolute value", succeeded)
}
pub fn absdiff(dst: &mut ImageBuf, a: &ImageBuf, b: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_absdiff_images(
dst.inner_mut(),
a.inner(),
b.inner(),
&roi,
ALL_THREADS,
)
};
finish(dst, "absolute difference", succeeded)
}
pub fn copy(
dst: &mut ImageBuf,
src: &ImageBuf,
convert_to: Option<crate::PixelFormat>,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let convert = convert_to.unwrap_or(crate::PixelFormat::Other).to_sys();
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_copy(
dst.inner_mut(),
src.inner(),
convert,
&roi,
ALL_THREADS,
)
};
finish(dst, "copy", succeeded)
}
pub fn crop(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_crop(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "crop", succeeded)
}
pub fn flip(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_flip(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "flip", succeeded)
}
pub fn circular_shift(
dst: &mut ImageBuf,
src: &ImageBuf,
shift: [i32; 3],
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let mut message = String::new();
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_circular_shift(
dst.inner_mut(),
src.inner(),
shift[0],
shift[1],
shift[2],
&roi,
ALL_THREADS,
&mut message,
)
};
if succeeded {
Ok(())
} else {
Err(Error::operation("circular_shift", message))
}
}
pub fn flop(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_flop(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "flop", succeeded)
}
pub fn transpose(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_transpose(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "transpose", succeeded)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub enum FitMode {
#[default]
Letterbox,
Width,
Height,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ChannelSource {
Channel(u32),
Constant(f32),
}
pub fn resize(
dst: &mut ImageBuf,
src: &ImageBuf,
filter_name: Option<&str>,
filter_width: Option<f32>,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_resize(
dst.inner_mut(),
src.inner(),
filter_name.unwrap_or(""),
filter_width.unwrap_or(0.0),
&roi,
ALL_THREADS,
)
};
finish(dst, "resize", succeeded)
}
pub fn fit(
dst: &mut ImageBuf,
src: &ImageBuf,
filter_name: Option<&str>,
filter_width: Option<f32>,
mode: FitMode,
exact: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_fit(
dst.inner_mut(),
src.inner(),
filter_name.unwrap_or(""),
filter_width.unwrap_or(0.0),
mode.name(),
exact,
&roi,
ALL_THREADS,
)
};
finish(dst, "fit", succeeded)
}
pub fn resample(
dst: &mut ImageBuf,
src: &ImageBuf,
interpolate: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_resample(
dst.inner_mut(),
src.inner(),
interpolate,
&roi,
ALL_THREADS,
)
};
finish(dst, "resample", succeeded)
}
pub fn over(dst: &mut ImageBuf, a: &ImageBuf, b: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_over(
dst.inner_mut(),
a.inner(),
b.inner(),
&roi,
ALL_THREADS,
)
};
finish(dst, "over", succeeded)
}
pub fn premult(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_premult(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "premultiply", succeeded)
}
pub fn unpremult(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_unpremult(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "unpremultiply", succeeded)
}
pub fn repremult(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_repremult(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "re-premultiply", succeeded)
}
pub fn zover(
dst: &mut ImageBuf,
a: &ImageBuf,
b: &ImageBuf,
z_zero_is_infinity: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_zover(
dst.inner_mut(),
a.inner(),
b.inner(),
z_zero_is_infinity,
&roi,
ALL_THREADS,
)
};
finish(dst, "zover", succeeded)
}
pub fn scale(dst: &mut ImageBuf, a: &ImageBuf, b: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_scale(
dst.inner_mut(),
a.inner(),
b.inner(),
&roi,
ALL_THREADS,
)
};
finish(dst, "scale", succeeded)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum NonFiniteFix {
None,
Black,
Box3,
Error,
}
impl NonFiniteFix {
fn to_sys(self) -> i32 {
match self {
Self::None => 0,
Self::Black => 1,
Self::Box3 => 2,
Self::Error => 100,
}
}
}
pub fn fix_non_finite(
dst: &mut ImageBuf,
src: &ImageBuf,
mode: NonFiniteFix,
roi: Option<Roi>,
) -> Result<u64> {
let roi = region_in(roi, dst)?;
let mut pixels_fixed = 0_i64;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_fix_non_finite(
dst.inner_mut(),
src.inner(),
mode.to_sys(),
&mut pixels_fixed,
&roi,
ALL_THREADS,
)
};
finish(dst, "fix non-finite", succeeded)?;
Ok(pixels_fixed.max(0) as u64)
}
pub fn rangecompress(
dst: &mut ImageBuf,
src: &ImageBuf,
use_luma: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_rangecompress(
dst.inner_mut(),
src.inner(),
use_luma,
&roi,
ALL_THREADS,
)
};
finish(dst, "rangecompress", succeeded)
}
pub fn rangeexpand(
dst: &mut ImageBuf,
src: &ImageBuf,
use_luma: bool,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_rangeexpand(
dst.inner_mut(),
src.inner(),
use_luma,
&roi,
ALL_THREADS,
)
};
finish(dst, "rangeexpand", succeeded)
}
pub fn channel_sum(
dst: &mut ImageBuf,
src: &ImageBuf,
weights: &[f32],
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_channel_sum(
dst.inner_mut(),
src.inner(),
weights,
&roi,
ALL_THREADS,
)
};
finish(dst, "channel sum", succeeded)
}
pub fn channel_append(dst: &mut ImageBuf, a: &ImageBuf, b: &ImageBuf) -> Result<()> {
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_channel_append(
dst.inner_mut(),
a.inner(),
b.inner(),
ALL_THREADS,
)
};
finish(dst, "channel append", succeeded)
}
pub fn maxchan(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_maxchan(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "maxchan", succeeded)
}
pub fn minchan(dst: &mut ImageBuf, src: &ImageBuf, roi: Option<Roi>) -> Result<()> {
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_minchan(dst.inner_mut(), src.inner(), &roi, ALL_THREADS)
};
finish(dst, "minchan", succeeded)
}
pub fn channels(
dst: &mut ImageBuf,
src: &ImageBuf,
sources: &[ChannelSource],
names: Option<&[&str]>,
) -> Result<()> {
if sources.is_empty() {
return Err(Error::InvalidImageSpec(
"a channel layout needs at least one channel".to_owned(),
));
}
if let Some(names) = names {
if names.len() != sources.len() {
return Err(Error::InvalidImageSpec(format!(
"expected {} channel names, got {}",
sources.len(),
names.len()
)));
}
}
let mut order = Vec::with_capacity(sources.len());
let mut values = Vec::with_capacity(sources.len());
for source in sources {
match *source {
ChannelSource::Channel(index) => {
order.push(i32::try_from(index).map_err(|_| {
Error::InvalidImageSpec("channel index exceeds i32::MAX".to_owned())
})?);
values.push(0.0);
}
ChannelSource::Constant(value) => {
order.push(-1);
values.push(value);
}
}
}
let names: Vec<String> = names
.unwrap_or(&[])
.iter()
.map(|name| (*name).to_owned())
.collect();
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_channels(
dst.inner_mut(),
src.inner(),
order.len() as i32,
&order,
&values,
&names,
false,
ALL_THREADS,
)
};
finish(dst, "channel layout", succeeded)
}
pub fn color_convert(
dst: &mut ImageBuf,
src: &ImageBuf,
from_space: &str,
to_space: &str,
unpremult: bool,
roi: Option<Roi>,
) -> Result<()> {
if from_space.is_empty() || to_space.is_empty() {
return Err(Error::InvalidImageSpec(
"a colour conversion needs both a source and a destination space".to_owned(),
));
}
let roi = region_in(roi, dst)?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_colorconvert(
dst.inner_mut(),
src.inner(),
from_space,
to_space,
unpremult,
&roi,
ALL_THREADS,
)
};
finish(dst, "colour convert", succeeded)
}
pub fn compare(
a: &ImageBuf,
b: &ImageBuf,
fail_threshold: f32,
warn_threshold: f32,
roi: Option<Roi>,
) -> Result<CompareSummary> {
compare_with_relative(a, b, fail_threshold, warn_threshold, 0.0, 0.0, roi)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum MosaicPattern {
Bayer,
XTrans,
}
pub fn demosaic(
dst: &mut ImageBuf,
src: &ImageBuf,
pattern: MosaicPattern,
algorithm: &str,
layout: &str,
white_balance: Option<&[f32]>,
) -> Result<()> {
if let Some(balance) = white_balance {
if balance.len() != 3 && balance.len() != 4 {
return Err(Error::InvalidRoi(format!(
"white balance is [r, g, b] or [r, g1, b, g2], got {} values",
balance.len()
)));
}
}
let mut error = String::new();
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_demosaic(
dst.inner_mut(),
src.inner(),
pattern.name(),
algorithm,
layout,
white_balance.unwrap_or(&[]),
ALL_THREADS,
&mut error,
)
};
if succeeded {
Ok(())
} else {
Err(Error::operation("demosaic", error))
}
}
pub fn normalize(
dst: &mut ImageBuf,
src: &ImageBuf,
in_center: f32,
out_center: f32,
scale: f32,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let mut message = String::new();
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_normalize(
dst.inner_mut(),
src.inner(),
in_center,
out_center,
scale,
&roi,
ALL_THREADS,
&mut message,
)
};
if succeeded {
Ok(())
} else {
Err(Error::operation("normalize", message))
}
}
pub fn fillholes_pushpull(dst: &mut ImageBuf, src: &ImageBuf) -> Result<()> {
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_fillholes_pushpull(
dst.inner_mut(),
src.inner(),
ALL_THREADS,
)
};
finish(dst, "fillholes", succeeded)
}
pub fn color_range_check(
src: &ImageBuf,
low: &[f32],
high: &[f32],
roi: Option<Roi>,
) -> Result<RangeCheckCounts> {
let roi = region_in(roi, src)?;
let mut counts = RangeCheckCounts {
low: 0,
high: 0,
in_range: 0,
};
let mut message = String::new();
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_color_range_check(
src.inner(),
low,
high,
&mut counts,
&roi,
ALL_THREADS,
&mut message,
)
};
if succeeded {
Ok(counts)
} else {
Err(Error::operation("color range check", message))
}
}
pub fn color_map(
dst: &mut ImageBuf,
src: &ImageBuf,
source_channel: Option<u32>,
knot_count: u32,
channels: u32,
knots: &[f32],
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let source_channel = match source_channel {
None => -1,
Some(index) => i32::try_from(index)
.map_err(|_| Error::InvalidRoi("source channel exceeds i32::MAX".to_owned()))?,
};
let knot_count = i32::try_from(knot_count)
.map_err(|_| Error::InvalidRoi("knot count exceeds i32::MAX".to_owned()))?;
let channels = i32::try_from(channels)
.map_err(|_| Error::InvalidRoi("channel count exceeds i32::MAX".to_owned()))?;
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_color_map(
dst.inner_mut(),
src.inner(),
source_channel,
knot_count,
channels,
knots,
&roi,
ALL_THREADS,
)
};
finish(dst, "color map", succeeded)
}
pub fn color_map_named(
dst: &mut ImageBuf,
src: &ImageBuf,
source_channel: Option<u32>,
map_name: &str,
roi: Option<Roi>,
) -> Result<()> {
let roi = region_in(roi, dst)?;
let source_channel = match source_channel {
None => -1,
Some(index) => i32::try_from(index)
.map_err(|_| Error::InvalidRoi("source channel exceeds i32::MAX".to_owned()))?,
};
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_color_map_named(
dst.inner_mut(),
src.inner(),
source_channel,
map_name,
&roi,
ALL_THREADS,
)
};
finish(dst, "color map", succeeded)
}
pub fn compare_with_relative(
a: &ImageBuf,
b: &ImageBuf,
fail_threshold: f32,
warn_threshold: f32,
fail_relative: f32,
warn_relative: f32,
roi: Option<Roi>,
) -> Result<CompareSummary> {
let roi = region_in(roi, a)?;
let mut message = String::new();
let summary = unsafe {
sys::imagebufalgo::imagebufalgo_compare(
a.inner(),
b.inner(),
fail_threshold,
warn_threshold,
fail_relative,
warn_relative,
&roi,
ALL_THREADS,
&mut message,
)
};
if message.is_empty() {
Ok(summary)
} else {
Err(Error::operation("compare", message))
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
#[non_exhaustive]
pub struct YeeComparison {
pub failures: u64,
pub max_error: f64,
pub max_position: [i32; 2],
}
impl YeeComparison {
pub fn perceptually_equal(&self) -> bool {
self.failures == 0
}
}
pub fn compare_yee(
a: &ImageBuf,
b: &ImageBuf,
luminance: f32,
fov: f32,
roi: Option<Roi>,
) -> Result<YeeComparison> {
const OPERATION: &str = "compare_yee";
if !(luminance.is_finite() && luminance > 0.0) {
return Err(Error::operation(
OPERATION,
format!("the adaptation luminance must be positive and finite, got {luminance}"),
));
}
if !(fov.is_finite() && fov > 0.0 && fov < 180.0) {
return Err(Error::operation(
OPERATION,
format!("the field of view must be between 0 and 180 degrees, got {fov}"),
));
}
let roi = region_in(roi, a)?;
let mut message = String::new();
let summary = unsafe {
sys::imagebufalgo::imagebufalgo_compare_yee(
a.inner(),
b.inner(),
luminance,
fov,
&roi,
ALL_THREADS,
&mut message,
)
};
if message.is_empty() {
Ok(YeeComparison {
failures: summary.failures,
max_error: summary.max_error,
max_position: [summary.max_x, summary.max_y],
})
} else {
Err(Error::operation(OPERATION, message))
}
}
pub fn color_count(
src: &ImageBuf,
colors: &[f32],
eps: &[f32],
roi: Option<Roi>,
) -> Result<Vec<u64>> {
const OPERATION: &str = "color_count";
let channels = src.channel_count() as usize;
if channels == 0 {
return Err(Error::operation(
OPERATION,
"the image has no channels to match against".to_owned(),
));
}
if colors.is_empty() || !colors.len().is_multiple_of(channels) {
return Err(Error::operation(
OPERATION,
format!(
"the colors array holds {} values, which is not a whole number \
of {channels}-channel colors",
colors.len()
),
));
}
let mut counts = vec![0_u64; colors.len() / channels];
let roi = region_in(roi, src)?;
let mut message = String::new();
let succeeded = unsafe {
sys::imagebufalgo::imagebufalgo_color_count(
src.inner(),
&mut counts,
colors,
eps,
&roi,
ALL_THREADS,
&mut message,
)
};
if succeeded {
Ok(counts)
} else {
Err(Error::operation(OPERATION, message))
}
}
enum_names!("horizontal text alignment", TextAlignX {
Left => "left",
Right => "right",
Center => "center",
});
enum_names!("vertical text alignment", TextAlignY {
Baseline => "baseline",
Top => "top",
Bottom => "bottom",
Center => "center",
});
enum_names!("fit mode", FitMode {
Letterbox => "letterbox",
Width => "width",
Height => "height",
});
enum_names!("non-finite fix", NonFiniteFix {
None => "none",
Black => "black",
Box3 => "box3",
Error => "error",
});
enum_names!("mosaic pattern", MosaicPattern {
Bayer => "bayer",
XTrans => "xtrans",
});
impl<'a> TextOptions<'a> {
#[must_use]
pub fn with_size(mut self, size: u32) -> Self {
self.size = size;
self
}
#[must_use]
pub fn with_font(mut self, font: &'a str) -> Self {
self.font = font;
self
}
#[must_use]
pub fn with_color(mut self, color: &'a [f32]) -> Self {
self.color = color;
self
}
#[must_use]
pub fn with_align_x(mut self, align_x: TextAlignX) -> Self {
self.align_x = align_x;
self
}
#[must_use]
pub fn with_align_y(mut self, align_y: TextAlignY) -> Self {
self.align_y = align_y;
self
}
#[must_use]
pub fn with_shadow(mut self, shadow: u32) -> Self {
self.shadow = shadow;
self
}
}
impl<'a> OcioOptions<'a> {
#[must_use]
pub fn with_unpremult(mut self, unpremult: bool) -> Self {
self.unpremult = unpremult;
self
}
#[must_use]
pub fn with_inverse(mut self, inverse: bool) -> Self {
self.inverse = inverse;
self
}
#[must_use]
pub fn with_context_key(mut self, context_key: &'a str) -> Self {
self.context_key = context_key;
self
}
#[must_use]
pub fn with_context_value(mut self, context_value: &'a str) -> Self {
self.context_value = context_value;
self
}
}
impl<'a> WarpOptions<'a> {
#[must_use]
pub fn with_filter(mut self, filter: Option<&'a str>) -> Self {
self.filter = filter;
self
}
#[must_use]
pub fn with_filter_width(mut self, filter_width: Option<f32>) -> Self {
self.filter_width = filter_width;
self
}
#[must_use]
pub fn with_wrap(mut self, wrap: Option<&'a str>) -> Self {
self.wrap = wrap;
self
}
#[must_use]
pub fn with_edge_clamp(mut self, edge_clamp: bool) -> Self {
self.edge_clamp = edge_clamp;
self
}
#[must_use]
pub fn with_recompute_region(mut self, recompute_region: bool) -> Self {
self.recompute_region = recompute_region;
self
}
}
impl<'a> ContrastRemap<'a> {
#[must_use]
pub fn with_black(mut self, black: &'a [f32]) -> Self {
self.black = black;
self
}
#[must_use]
pub fn with_white(mut self, white: &'a [f32]) -> Self {
self.white = white;
self
}
#[must_use]
pub fn with_min(mut self, min: &'a [f32]) -> Self {
self.min = min;
self
}
#[must_use]
pub fn with_max(mut self, max: &'a [f32]) -> Self {
self.max = max;
self
}
#[must_use]
pub fn with_sigmoid_contrast(mut self, sigmoid_contrast: &'a [f32]) -> Self {
self.sigmoid_contrast = sigmoid_contrast;
self
}
#[must_use]
pub fn with_sigmoid_threshold(mut self, sigmoid_threshold: &'a [f32]) -> Self {
self.sigmoid_threshold = sigmoid_threshold;
self
}
}