Add resize() methods and an interpolate() method.

src/geometric_transformations.rs

@@ -1,8 +1,11 @@
 //! Geometric transformations of images. This includes rotations, translation, and general
 //! projective transformations.
 
-use crate::definitions::{Clamp, Image};
-use image::{GenericImageView, Pixel};
+use crate::{
+ compose::crop,
+ definitions::{Clamp, Image},
+};
+use image::{math::Rect, GenericImageView, Pixel};
 #[cfg(feature = "rayon")]
 use rayon::prelude::*;
 use std::{cmp, ops::Mul};
@@ -99,7 +102,6 @@ impl Projection {
  /// An anisotropic scaling (sx, sy).
  ///
  /// Note that the `warp` function does not change the size of the input image.
- /// If you want to resize an image then use the `imageops` module in the `image` crate.
  #[rustfmt::skip]
  pub fn scale(sx: f32, sy: f32) -> Projection {
  Projection {
@@ -317,6 +319,199 @@ where
  warp(image, &projection, interpolation, default)
 }
 
+/// Resizes an image to the exact given `new_width` and `new_height`,
+/// ignoring aspect ratio, using the given `interpolation` method.
+///
+/// # Examples
+/// ```
+/// use imageproc::geometric_transformations::{resize_exact, Interpolation};
+/// use imageproc::gray_image;
+///
+/// let image = gray_image!(
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0);
+///
+/// let resized = resize_exact(&image, 2, 3, Interpolation::Bilinear);
+///
+/// assert_eq!(resized, gray_image!(
+/// 0, 0;
+/// 0, 0;
+/// 0, 0));
+/// ```
+pub fn resize_exact<P>(
+ image: &Image<P>,
+ new_width: u32,
+ new_height: u32,
+ interpolation: Interpolation,
+) -> Image<P>
+where
+ P: Pixel,
+ <P as Pixel>::Subpixel: Into<f32> + Clamp<f32>,
+{
+ if new_width == image.width() && new_height == image.height() {
+ return image.clone();
+ }
+
+ let x_ratio: f32 = image.width() as f32 / new_width as f32;
+ let y_ratio: f32 = image.height() as f32 / new_height as f32;
+
+ Image::from_fn(new_width, new_height, |x, y| {
+ interpolate(
+ image,
+ x as f32 * x_ratio,
+ y as f32 * y_ratio,
+ //TODO make this P::default() once the common `Pixel`
+ //types implement default or when `rgb` v0.9 is
+ //implemented https://github.com/image-rs/image/issues/2259
+ *P::from_slice(&vec![
+ <P::Subpixel as image::Primitive>::DEFAULT_MIN_VALUE;
+ usize::from(P::CHANNEL_COUNT)
+ ]),
+ interpolation,
+ )
+ })
+}
+/// Resizes an image to the exact given `new_width` and `new_height`
+/// while maintaining the images aspect ratio by cropping
+/// ignoring aspect ratio, using the given `interpolation` method.
+///
+/// # Examples
+/// ```
+/// use imageproc::geometric_transformations::{resize_crop_to_fill, Interpolation};
+/// use imageproc::gray_image;
+///
+/// let image = gray_image!(
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0);
+///
+/// let resized = resize_crop_to_fill(&image, 2, 3, Interpolation::Bilinear);
+///
+/// assert_eq!(resized, gray_image!(
+/// 0, 0;
+/// 0, 0;
+/// 0, 0));
+/// ```
+pub fn resize_crop_to_fill<P>(
+ image: &Image<P>,
+ new_width: u32,
+ new_height: u32,
+ interpolation: Interpolation,
+) -> Image<P>
+where
+ P: Pixel,
+ <P as Pixel>::Subpixel: Into<f32> + Clamp<f32>,
+{
+ let (intermediate_width, intermediate_height) =
+ resize_dimensions(image.width(), image.height(), new_width, new_height, true);
+
+ let intermediate = resize_exact(
+ image,
+ intermediate_width,
+ intermediate_height,
+ interpolation,
+ );
+
+ let horizontal_ratio = u64::from(intermediate_width) * u64::from(new_height);
+ let vertical_ratio = u64::from(new_width) * u64::from(intermediate_height);
+
+ if vertical_ratio > horizontal_ratio {
+ crop(
+ &intermediate,
+ Rect {
+ x: 0,
+ y: (intermediate_height - new_height) / 2,
+ width: new_width,
+ height: new_height,
+ },
+ )
+ } else {
+ crop(
+ &intermediate,
+ Rect {
+ x: (intermediate_width - new_width) / 2,
+ y: 0,
+ width: new_width,
+ height: new_height,
+ },
+ )
+ }
+}
+/// Resizes an image to the largest dimensions smaller or equal to the
+/// given `max_width` and `max_height`, while maintaining the images
+/// aspect ratio without cropping the image, using the given
+/// interopolation method.`
+///
+/// Importantly the returned image will not necessarily have the same
+/// dimensions as the given `max_width` and `max_height`.
+///
+/// # Examples
+/// ```
+/// use imageproc::geometric_transformations::{resize_max_no_crop, Interpolation};
+/// use imageproc::gray_image;
+///
+/// let image = gray_image!(
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0;
+/// 0, 0, 0, 0);
+///
+/// let resized = resize_max_no_crop(&image, 2, 3, Interpolation::Bilinear);
+///
+/// assert_eq!(resized, gray_image!(
+/// 0, 0;
+/// 0, 0));
+/// ```
+pub fn resize_max_no_crop<P>(
+ image: &Image<P>,
+ max_width: u32,
+ max_height: u32,
+ interpolation: Interpolation,
+) -> Image<P>
+where
+ P: Pixel,
+ <P as Pixel>::Subpixel: Into<f32> + Clamp<f32>,
+{
+ let (new_width, new_height) =
+ resize_dimensions(image.width(), image.height(), max_width, max_height, false);
+
+ resize_exact(image, new_width, new_height, interpolation)
+}
+/// used by [`resize_max_no_crop()`] and [`resize_crop_to_fill()`],
+/// see them for details.
+fn resize_dimensions(width: u32, height: u32, nwidth: u32, nheight: u32, fill: bool) -> (u32, u32) {
+ let wratio = nwidth as f64 / width as f64;
+ let hratio = nheight as f64 / height as f64;
+
+ let ratio = if fill {
+ f64::max(wratio, hratio)
+ } else {
+ f64::min(wratio, hratio)
+ };
+
+ let nw = core::cmp::max((width as f64 * ratio).round() as u64, 1);
+ let nh = core::cmp::max((height as f64 * ratio).round() as u64, 1);
+
+ if nw > u64::from(u32::MAX) {
+ let ratio = u32::MAX as f64 / width as f64;
+ (
+ u32::MAX,
+ core::cmp::max((height as f64 * ratio).round() as u32, 1),
+ )
+ } else if nh > u64::from(u32::MAX) {
+ let ratio = u32::MAX as f64 / height as f64;
+ (
+ core::cmp::max((width as f64 * ratio).round() as u32, 1),
+ u32::MAX,
+ )
+ } else {
+ (nw as u32, nh as u32)
+ }
+}
+
 /// Rotates an image 90 degrees clockwise.
 ///
 /// # Examples
@@ -878,6 +1073,28 @@ pub enum Interpolation {
  /// closest to the pre-image of the output pixel.
  Bicubic,
 }
+/// Returns an interpolated pixel from an image at the given pixel
+/// coordinates using the given `interpolation`.
+///
+/// If the pixel is out of bounds of `image` then the `default` pixel
+/// value is used.
+pub fn interpolate<P>(
+ image: &Image<P>,
+ x: f32,
+ y: f32,
+ default: P,
+ interpolation: Interpolation,
+) -> P
+where
+ P: Pixel,
+ <P as Pixel>::Subpixel: Into<f32> + Clamp<f32>,
+{
+ match interpolation {
+ Interpolation::Nearest => interpolate_nearest(image, x, y, default),
+ Interpolation::Bilinear => interpolate_bilinear(image, x, y, default),
+ Interpolation::Bicubic => interpolate_bicubic(image, x, y, default),
+ }
+}
 
 #[cfg(test)]
 mod tests {