diff --git a/src/imageops/colorops.rs b/src/imageops/colorops.rs index 4441f92d28..c00995fe7d 100644 --- a/src/imageops/colorops.rs +++ b/src/imageops/colorops.rs @@ -5,8 +5,6 @@ use std::f64::consts::PI; use crate::color::{Luma, Rgba}; use crate::image::{GenericImage, GenericImageView}; -#[allow(deprecated)] -use crate::math::nq; use crate::traits::{Pixel, Primitive}; use crate::utils::clamp; use crate::ImageBuffer; @@ -394,31 +392,6 @@ impl ColorMap for BiLevel { } } -#[allow(deprecated)] -impl ColorMap for nq::NeuQuant { - type Color = Rgba; - - #[inline(always)] - fn index_of(&self, color: &Rgba) -> usize { - self.index_of(color.channels()) - } - - #[inline(always)] - fn lookup(&self, idx: usize) -> Option { - self.lookup(idx).map(|p| p.into()) - } - - /// Indicate NeuQuant implements `lookup`. - fn has_lookup(&self) -> bool { - true - } - - #[inline(always)] - fn map_color(&self, color: &mut Rgba) { - self.map_pixel(color.channels_mut()) - } -} - impl ColorMap for color_quant::NeuQuant { type Color = Rgba; diff --git a/src/math/mod.rs b/src/math/mod.rs index 7aae232638..0acd5a6811 100644 --- a/src/math/mod.rs +++ b/src/math/mod.rs @@ -1,7 +1,6 @@ //! Mathematical helper functions and types. -pub mod nq; -pub mod utils; +mod utils; mod rect; pub use self::rect::Rect; -pub(crate) use self::utils::resize_dimensions; +pub(super) use utils::resize_dimensions; diff --git a/src/math/nq.rs b/src/math/nq.rs deleted file mode 100644 index d30ff64567..0000000000 --- a/src/math/nq.rs +++ /dev/null @@ -1,116 +0,0 @@ -//! NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. -//! See "Kohonen neural networks for optimal colour quantization" -//! in "Network: Computation in Neural Systems" Vol. 5 (1994) pp 351-367. -//! for a discussion of the algorithm. -//! See also - -/* NeuQuant Neural-Net Quantization Algorithm - * ------------------------------------------ - * - * Copyright (c) 1994 Anthony Dekker - * - * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. - * See "Kohonen neural networks for optimal colour quantization" - * in "Network: Computation in Neural Systems" Vol. 5 (1994) pp 351-367. - * for a discussion of the algorithm. - * See also https://scientificgems.wordpress.com/stuff/neuquant-fast-high-quality-image-quantization/ - * - * Any party obtaining a copy of these files from the author, directly or - * indirectly, is granted, free of charge, a full and unrestricted irrevocable, - * world-wide, paid up, royalty-free, nonexclusive right and license to deal - * in this software and documentation files (the "Software"), including without - * limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons who receive - * copies from any such party to do so, with the only requirement being - * that this copyright notice remain intact. - * - * - * Incorporated bugfixes and alpha channel handling from pngnq - * http://pngnq.sourceforge.net - * - */ - -/// Neural network color quantizer -/// -/// # Examples -/// ``` -/// use image::imageops::colorops::{index_colors, ColorMap}; -/// use image::math::nq::NeuQuant; -/// use image::{ImageBuffer, Rgba, RgbaImage}; -/// -/// // Create simple color image with RGBA pixels. -/// let (w, h) = (2, 2); -/// let red: Rgba = [255, 0, 0, 255].into(); -/// let green: Rgba = [0, 255, 0, 255].into(); -/// let blue: Rgba = [0, 0, 255, 255].into(); -/// let white: Rgba = [255, 255, 255, 255].into(); -/// let mut color_image = RgbaImage::new(w, h); -/// color_image.put_pixel(0, 0, red); -/// color_image.put_pixel(1, 0, green); -/// color_image.put_pixel(0, 1, blue); -/// color_image.put_pixel(1, 1, white); -/// -/// // Create a `NeuQuant` colormap that will build an approximate color palette that best matches -/// // the original image. -/// // Note, the NeuQuant algorithm is only designed to work with 6-8 bit output, so `colors` -/// // should be a power of 2 in the range [64, 256]. -/// let pixels = color_image.clone().into_raw(); -/// let cmap = NeuQuant::new(1, 256, &pixels); -/// // Map the original image through the color map to create an indexed image stored in a -/// // `GrayImage`. -/// let palletized = index_colors(&color_image, &cmap); -/// // Map indexed image back `RgbaImage`. Note the NeuQuant algorithm creates an approximation of -/// // the original colors, so even in this simple example the output is not pixel equivalent to -/// // the original. -/// let mapped = ImageBuffer::from_fn(w, h, |x, y| -> Rgba { -/// let p = palletized.get_pixel(x, y); -/// cmap.lookup(p.0[0] as usize) -/// .expect("indexed color out-of-range") -/// .into() -/// }); -/// ``` -#[deprecated(note = "Use the `color_quant` crate instead")] -pub struct NeuQuant { - inner: color_quant::NeuQuant, -} - -/// The implementation only calls the corresponding inner `color_quant` methods. -/// -/// These exist purely to keep a type separate from [`color_quant::NeuQuant`] and the interface -/// stable for this major version. The type will be changed to a pure re-export in the next -/// version or might be removed. -/// -/// [`color_quant::NeuQuant`]: https://docs.rs/color_quant/1.1.0/color_quant/struct.NeuQuant.html -#[allow(deprecated)] -#[allow(missing_docs)] -impl NeuQuant { - pub fn new(samplefac: i32, colors: usize, pixels: &[u8]) -> Self { - color_quant::NeuQuant::new(samplefac, colors, pixels).into() - } - pub fn init(&mut self, pixels: &[u8]) { - self.inner.init(pixels) - } - pub fn map_pixel(&self, pixel: &mut [u8]) { - self.inner.map_pixel(pixel) - } - pub fn index_of(&self, pixel: &[u8]) -> usize { - self.inner.index_of(pixel) - } - pub fn lookup(&self, idx: usize) -> Option<[u8; 4]> { - self.inner.lookup(idx) - } -} - -#[allow(deprecated)] -impl From for NeuQuant { - fn from(inner: color_quant::NeuQuant) -> Self { - NeuQuant { inner } - } -} - -#[allow(deprecated)] -impl From for color_quant::NeuQuant { - fn from(this: NeuQuant) -> Self { - this.inner - } -} diff --git a/src/math/utils.rs b/src/math/utils.rs index f0fd65ec3a..6f02aa8ca3 100644 --- a/src/math/utils.rs +++ b/src/math/utils.rs @@ -1,29 +1,3 @@ -//! Shared mathematical utility functions. - -/// Cut value to be inside given range -/// -/// ``` -/// use image::math::utils; -/// -/// assert_eq!(utils::clamp(-5, 0, 10), 0); -/// assert_eq!(utils::clamp( 6, 0, 10), 6); -/// assert_eq!(utils::clamp(15, 0, 10), 10); -/// ``` -#[inline] -#[deprecated] -pub fn clamp(a: N, min: N, max: N) -> N -where - N: PartialOrd, -{ - if a < min { - return min; - } - if a > max { - return max; - } - a -} - /// Calculates the width and height an image should be resized to. /// This preserves aspect ratio, and based on the `fill` parameter /// will either fill the dimensions to fit inside the smaller constraint @@ -31,7 +5,13 @@ where /// aspect ratio), or will shrink so that both dimensions are /// completely contained with in the given `width` and `height`, /// with empty space on one axis. -pub(crate) fn resize_dimensions(width: u32, height: u32, nwidth: u32, nheight: u32, fill: bool) -> (u32, u32) { +pub(crate) fn resize_dimensions( + width: u32, + height: u32, + nwidth: u32, + nheight: u32, + fill: bool, +) -> (u32, u32) { let ratio = u64::from(width) * u64::from(nheight); let nratio = u64::from(nwidth) * u64::from(height);