use crate::image::{BorderMode, ImageFormat, InterpolationMode, NormalizationParams};
use crate::{Image, Matrix, Result};
impl Image {
pub fn resize(
&self,
target_width: u32,
target_height: u32,
interpolation: InterpolationMode,
) -> Result<Self> {
crate::image::resize(self, target_width, target_height, interpolation)
}
pub fn crop(&self, x: u32, y: u32, width: u32, height: u32) -> Result<Self> {
crate::image::crop(self, x, y, width, height)
}
pub fn flip(&self, horizontal: bool, vertical: bool) -> Result<Self> {
crate::image::flip(self, horizontal, vertical)
}
pub fn rotate(&self, degrees: u32) -> Result<Self> {
crate::image::rotate(self, degrees)
}
pub fn pad(
&self,
left: u32,
right: u32,
top: u32,
bottom: u32,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::pad(self, left, right, top, bottom, border, border_value)
}
pub fn center_crop(&self, width: u32, height: u32) -> Result<Self> {
crate::image::center_crop(self, width, height)
}
pub fn remap(
&self,
map: &Matrix,
interpolation: InterpolationMode,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::remap(self, map, interpolation, border, border_value)
}
pub fn warp_affine(
&self,
transform: &Matrix,
width: u32,
height: u32,
interpolation: InterpolationMode,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::warp_affine(
self,
transform,
width,
height,
interpolation,
border,
border_value,
)
}
pub fn warp_perspective(
&self,
transform: &Matrix,
width: u32,
height: u32,
interpolation: InterpolationMode,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::warp_perspective(
self,
transform,
width,
height,
interpolation,
border,
border_value,
)
}
pub fn threshold_binary(&self, threshold: f32, max_value: f32) -> Result<Self> {
crate::image::threshold_binary(self, threshold, max_value)
}
pub fn threshold_binary_inv(&self, threshold: f32, max_value: f32) -> Result<Self> {
crate::image::threshold_binary_inv(self, threshold, max_value)
}
pub fn threshold_truncate(&self, threshold: f32) -> Result<Self> {
crate::image::threshold_truncate(self, threshold)
}
pub fn threshold_to_zero(&self, threshold: f32) -> Result<Self> {
crate::image::threshold_to_zero(self, threshold)
}
pub fn threshold_to_zero_inv(&self, threshold: f32) -> Result<Self> {
crate::image::threshold_to_zero_inv(self, threshold)
}
pub fn in_range(&self, low: f32, high: f32, true_value: f32) -> Result<Self> {
crate::image::in_range(self, low, high, true_value)
}
pub fn clamp(&self, low: f32, high: f32) -> Result<Self> {
crate::image::clamp(self, low, high)
}
pub fn invert(&self, max_value: f32) -> Result<Self> {
crate::image::invert(self, max_value)
}
pub fn brightness_contrast(&self, brightness: f32, contrast: f32) -> Result<Self> {
crate::image::brightness_contrast(self, brightness, contrast)
}
pub fn gamma_contrast(&self, gamma: f32, gain: f32) -> Result<Self> {
crate::image::gamma_contrast(self, gamma, gain)
}
pub fn solarize(&self, threshold: f32, max_value: f32) -> Result<Self> {
crate::image::solarize(self, threshold, max_value)
}
pub fn posterize(&self, levels: u32, low: f32, high: f32) -> Result<Self> {
crate::image::posterize(self, levels, low, high)
}
pub fn grayscale(&self) -> Result<Self> {
crate::image::grayscale(self)
}
pub fn alpha_blend(&self, right: &Image, alpha: f32) -> Result<Self> {
crate::image::alpha_blend(self, right, alpha)
}
pub fn composite(&self, right: &Image, mask: &Image) -> Result<Self> {
crate::image::composite(self, right, mask)
}
pub fn erase(&self, x: u32, y: u32, width: u32, height: u32, value: f32) -> Result<Self> {
crate::image::erase(self, x, y, width, height, value)
}
pub fn color_twist(&self, transform: &Matrix) -> Result<Self> {
crate::image::color_twist(self, transform)
}
pub fn channel_reorder(&self, order: [u32; 4], output_format: ImageFormat) -> Result<Self> {
crate::image::channel_reorder(self, order, output_format)
}
pub fn gaussian_noise(&self, mean: f32, stddev: f32, seed: u64) -> Result<Self> {
crate::image::gaussian_noise(self, mean, stddev, seed)
}
pub fn salt_pepper_noise(
&self,
probability: f32,
salt_value: f32,
pepper_value: f32,
seed: u64,
) -> Result<Self> {
crate::image::salt_pepper_noise(self, probability, salt_value, pepper_value, seed)
}
pub fn convolve_2d(
&self,
kernel: &Matrix,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::convolve_2d(self, kernel, border, border_value)
}
pub fn separable_convolve_2d(
&self,
kernel_x: &Matrix,
kernel_y: &Matrix,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::separable_convolve_2d(self, kernel_x, kernel_y, border, border_value)
}
pub fn average_blur(&self, width: u32, height: u32, border: BorderMode) -> Result<Self> {
crate::image::average_blur(self, width, height, border)
}
pub fn sobel(&self, dx: u32, dy: u32, border: BorderMode) -> Result<Self> {
crate::image::sobel(self, dx, dy, border)
}
pub fn scharr(&self, dx: u32, dy: u32, border: BorderMode) -> Result<Self> {
crate::image::scharr(self, dx, dy, border)
}
pub fn laplacian(&self, border: BorderMode) -> Result<Self> {
crate::image::laplacian(self, border)
}
pub fn erode(
&self,
width: u32,
height: u32,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::erode(self, width, height, border, border_value)
}
pub fn dilate(
&self,
width: u32,
height: u32,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::dilate(self, width, height, border, border_value)
}
pub fn morphology_open(
&self,
width: u32,
height: u32,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::morphology_open(self, width, height, border, border_value)
}
pub fn morphology_close(
&self,
width: u32,
height: u32,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::morphology_close(self, width, height, border, border_value)
}
pub fn morphology_gradient(
&self,
width: u32,
height: u32,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::morphology_gradient(self, width, height, border, border_value)
}
pub fn gaussian_blur(&self, sigma: f32, kernel_size: u32) -> Result<Self> {
crate::image::gaussian_blur(self, sigma, kernel_size)
}
pub fn sharpen(&self, amount: f32, border: BorderMode) -> Result<Self> {
crate::image::sharpen(self, amount, border)
}
pub fn median_blur(&self, kernel_size: u32, border: BorderMode) -> Result<Self> {
crate::image::median_blur(self, kernel_size, border)
}
pub fn bilateral_filter(
&self,
kernel_size: u32,
sigma_color: f32,
sigma_space: f32,
border: BorderMode,
) -> Result<Self> {
crate::image::bilateral_filter(self, kernel_size, sigma_color, sigma_space, border)
}
pub fn unsharp_mask(&self, sigma: f32, amount: f32, kernel_size: u32) -> Result<Self> {
crate::image::unsharp_mask(self, sigma, amount, kernel_size)
}
pub fn morphology_top_hat(
&self,
width: u32,
height: u32,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::morphology_top_hat(self, width, height, border, border_value)
}
pub fn morphology_black_hat(
&self,
width: u32,
height: u32,
border: BorderMode,
border_value: f32,
) -> Result<Self> {
crate::image::morphology_black_hat(self, width, height, border, border_value)
}
pub fn adaptive_threshold_mean(
&self,
kernel_size: u32,
c: f32,
max_value: f32,
border: BorderMode,
) -> Result<Self> {
crate::image::adaptive_threshold_mean(self, kernel_size, c, max_value, border)
}
pub fn adaptive_threshold_gaussian(
&self,
kernel_size: u32,
c: f32,
max_value: f32,
sigma: f32,
border: BorderMode,
) -> Result<Self> {
crate::image::adaptive_threshold_gaussian(self, kernel_size, c, max_value, sigma, border)
}
pub fn normalize(&self, parameters: NormalizationParams) -> Result<Self> {
crate::image::normalize(self, parameters)
}
pub fn convert_color(&self, destination_format: crate::ImageFormat) -> Result<Self> {
crate::image::convert_color(self, destination_format)
}
pub fn resize_normalize(
&self,
width: u32,
height: u32,
parameters: NormalizationParams,
) -> Result<Self> {
crate::image::resize_normalize(self, width, height, parameters)
}
pub fn segmentation_overlay(&self, mask: &Matrix, palette: &Matrix, alpha: f32) -> Result<Self> {
crate::image::segmentation_overlay(self, mask, palette, alpha)
}
}
const _: fn(&Image, u32, u32, InterpolationMode) -> Result<Image> = crate::image::resize;
const _: fn(&Image, u32, u32, InterpolationMode) -> Result<Image> = Image::resize;
const _: fn(&Image, u32, u32, u32, u32) -> Result<Image> = crate::image::crop;
const _: fn(&Image, u32, u32, u32, u32) -> Result<Image> = Image::crop;
const _: fn(&Image, bool, bool) -> Result<Image> = crate::image::flip;
const _: fn(&Image, bool, bool) -> Result<Image> = Image::flip;
const _: fn(&Image, u32) -> Result<Image> = crate::image::rotate;
const _: fn(&Image, u32) -> Result<Image> = Image::rotate;
const _: fn(&Image, u32, u32, u32, u32, BorderMode, f32) -> Result<Image> = crate::image::pad;
const _: fn(&Image, u32, u32, u32, u32, BorderMode, f32) -> Result<Image> = Image::pad;
const _: fn(&Image, u32, u32) -> Result<Image> = crate::image::center_crop;
const _: fn(&Image, u32, u32) -> Result<Image> = Image::center_crop;
const _: fn(&Image, &Matrix, InterpolationMode, BorderMode, f32) -> Result<Image> =
crate::image::remap;
const _: fn(&Image, &Matrix, InterpolationMode, BorderMode, f32) -> Result<Image> = Image::remap;
const _: fn(&Image, &Matrix, u32, u32, InterpolationMode, BorderMode, f32) -> Result<Image> =
crate::image::warp_affine;
const _: fn(&Image, &Matrix, u32, u32, InterpolationMode, BorderMode, f32) -> Result<Image> =
Image::warp_affine;
const _: fn(&Image, &Matrix, u32, u32, InterpolationMode, BorderMode, f32) -> Result<Image> =
crate::image::warp_perspective;
const _: fn(&Image, &Matrix, u32, u32, InterpolationMode, BorderMode, f32) -> Result<Image> =
Image::warp_perspective;
const _: fn(&Image, f32, f32) -> Result<Image> = crate::image::threshold_binary;
const _: fn(&Image, f32, f32) -> Result<Image> = Image::threshold_binary;
const _: fn(&Image, f32, f32) -> Result<Image> = crate::image::threshold_binary_inv;
const _: fn(&Image, f32, f32) -> Result<Image> = Image::threshold_binary_inv;
const _: fn(&Image, f32) -> Result<Image> = crate::image::threshold_truncate;
const _: fn(&Image, f32) -> Result<Image> = Image::threshold_truncate;
const _: fn(&Image, f32) -> Result<Image> = crate::image::threshold_to_zero;
const _: fn(&Image, f32) -> Result<Image> = Image::threshold_to_zero;
const _: fn(&Image, f32) -> Result<Image> = crate::image::threshold_to_zero_inv;
const _: fn(&Image, f32) -> Result<Image> = Image::threshold_to_zero_inv;
const _: fn(&Image, f32, f32, f32) -> Result<Image> = crate::image::in_range;
const _: fn(&Image, f32, f32, f32) -> Result<Image> = Image::in_range;
const _: fn(&Image, f32, f32) -> Result<Image> = crate::image::clamp;
const _: fn(&Image, f32, f32) -> Result<Image> = Image::clamp;
const _: fn(&Image, f32) -> Result<Image> = crate::image::invert;
const _: fn(&Image, f32) -> Result<Image> = Image::invert;
const _: fn(&Image, f32, f32) -> Result<Image> = crate::image::brightness_contrast;
const _: fn(&Image, f32, f32) -> Result<Image> = Image::brightness_contrast;
const _: fn(&Image, f32, f32) -> Result<Image> = crate::image::gamma_contrast;
const _: fn(&Image, f32, f32) -> Result<Image> = Image::gamma_contrast;
const _: fn(&Image, f32, f32) -> Result<Image> = crate::image::solarize;
const _: fn(&Image, f32, f32) -> Result<Image> = Image::solarize;
const _: fn(&Image, u32, f32, f32) -> Result<Image> = crate::image::posterize;
const _: fn(&Image, u32, f32, f32) -> Result<Image> = Image::posterize;
const _: fn(&Image) -> Result<Image> = crate::image::grayscale;
const _: fn(&Image) -> Result<Image> = Image::grayscale;
const _: fn(&Image, &Image, f32) -> Result<Image> = crate::image::alpha_blend;
const _: fn(&Image, &Image, f32) -> Result<Image> = Image::alpha_blend;
const _: fn(&Image, &Image, &Image) -> Result<Image> = crate::image::composite;
const _: fn(&Image, &Image, &Image) -> Result<Image> = Image::composite;
const _: fn(&Image, u32, u32, u32, u32, f32) -> Result<Image> = crate::image::erase;
const _: fn(&Image, u32, u32, u32, u32, f32) -> Result<Image> = Image::erase;
const _: fn(&Image, &Matrix) -> Result<Image> = crate::image::color_twist;
const _: fn(&Image, &Matrix) -> Result<Image> = Image::color_twist;
const _: fn(&Image, [u32; 4], ImageFormat) -> Result<Image> = crate::image::channel_reorder;
const _: fn(&Image, [u32; 4], ImageFormat) -> Result<Image> = Image::channel_reorder;
const _: fn(&Image, f32, f32, u64) -> Result<Image> = crate::image::gaussian_noise;
const _: fn(&Image, f32, f32, u64) -> Result<Image> = Image::gaussian_noise;
const _: fn(&Image, f32, f32, f32, u64) -> Result<Image> = crate::image::salt_pepper_noise;
const _: fn(&Image, f32, f32, f32, u64) -> Result<Image> = Image::salt_pepper_noise;
const _: fn(&Image, &Matrix, BorderMode, f32) -> Result<Image> = crate::image::convolve_2d;
const _: fn(&Image, &Matrix, BorderMode, f32) -> Result<Image> = Image::convolve_2d;
const _: fn(&Image, &Matrix, &Matrix, BorderMode, f32) -> Result<Image> =
crate::image::separable_convolve_2d;
const _: fn(&Image, &Matrix, &Matrix, BorderMode, f32) -> Result<Image> =
Image::separable_convolve_2d;
const _: fn(&Image, u32, u32, BorderMode) -> Result<Image> = crate::image::average_blur;
const _: fn(&Image, u32, u32, BorderMode) -> Result<Image> = Image::average_blur;
const _: fn(&Image, u32, u32, BorderMode) -> Result<Image> = crate::image::sobel;
const _: fn(&Image, u32, u32, BorderMode) -> Result<Image> = Image::sobel;
const _: fn(&Image, u32, u32, BorderMode) -> Result<Image> = crate::image::scharr;
const _: fn(&Image, u32, u32, BorderMode) -> Result<Image> = Image::scharr;
const _: fn(&Image, BorderMode) -> Result<Image> = crate::image::laplacian;
const _: fn(&Image, BorderMode) -> Result<Image> = Image::laplacian;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = crate::image::erode;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = Image::erode;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = crate::image::dilate;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = Image::dilate;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = crate::image::morphology_open;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = Image::morphology_open;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = crate::image::morphology_close;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = Image::morphology_close;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = crate::image::morphology_gradient;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = Image::morphology_gradient;
const _: fn(&Image, f32, u32) -> Result<Image> = crate::image::gaussian_blur;
const _: fn(&Image, f32, u32) -> Result<Image> = Image::gaussian_blur;
const _: fn(&Image, f32, BorderMode) -> Result<Image> = crate::image::sharpen;
const _: fn(&Image, f32, BorderMode) -> Result<Image> = Image::sharpen;
const _: fn(&Image, u32, BorderMode) -> Result<Image> = crate::image::median_blur;
const _: fn(&Image, u32, BorderMode) -> Result<Image> = Image::median_blur;
const _: fn(&Image, u32, f32, f32, BorderMode) -> Result<Image> = crate::image::bilateral_filter;
const _: fn(&Image, u32, f32, f32, BorderMode) -> Result<Image> = Image::bilateral_filter;
const _: fn(&Image, f32, f32, u32) -> Result<Image> = crate::image::unsharp_mask;
const _: fn(&Image, f32, f32, u32) -> Result<Image> = Image::unsharp_mask;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = crate::image::morphology_top_hat;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = Image::morphology_top_hat;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> =
crate::image::morphology_black_hat;
const _: fn(&Image, u32, u32, BorderMode, f32) -> Result<Image> = Image::morphology_black_hat;
const _: fn(&Image, u32, f32, f32, BorderMode) -> Result<Image> =
crate::image::adaptive_threshold_mean;
const _: fn(&Image, u32, f32, f32, BorderMode) -> Result<Image> = Image::adaptive_threshold_mean;
const _: fn(&Image, u32, f32, f32, f32, BorderMode) -> Result<Image> =
crate::image::adaptive_threshold_gaussian;
const _: fn(&Image, u32, f32, f32, f32, BorderMode) -> Result<Image> =
Image::adaptive_threshold_gaussian;
const _: fn(&Image, NormalizationParams) -> Result<Image> = crate::image::normalize;
const _: fn(&Image, NormalizationParams) -> Result<Image> = Image::normalize;
const _: fn(&Image, crate::ImageFormat) -> Result<Image> = crate::image::convert_color;
const _: fn(&Image, crate::ImageFormat) -> Result<Image> = Image::convert_color;
const _: fn(&Image, u32, u32, NormalizationParams) -> Result<Image> =
crate::image::resize_normalize;
const _: fn(&Image, u32, u32, NormalizationParams) -> Result<Image> = Image::resize_normalize;
const _: fn(&Image, &Matrix, &Matrix, f32) -> Result<Image> = crate::image::segmentation_overlay;
const _: fn(&Image, &Matrix, &Matrix, f32) -> Result<Image> = Image::segmentation_overlay;