Deleted vendor folder

1 files changed, 0 insertions, 410 deletions

diff --git a/vendor/image/src/imageops/affine.rs b/vendor/image/src/imageops/affine.rs
deleted file mode 100644
index 548381c..0000000
--- a/vendor/image/src/imageops/affine.rs
+++ /dev/null
@@ -1,410 +0,0 @@
-//! Functions for performing affine transformations.
-
-use crate::error::{ImageError, ParameterError, ParameterErrorKind};
-use crate::image::{GenericImage, GenericImageView};
-use crate::traits::Pixel;
-use crate::ImageBuffer;
-
-/// Rotate an image 90 degrees clockwise.
-pub fn rotate90<I: GenericImageView>(
-    image: &I,
-) -> ImageBuffer<I::Pixel, Vec<<I::Pixel as Pixel>::Subpixel>>
-where
-    I::Pixel: 'static,
-{
-    let (width, height) = image.dimensions();
-    let mut out = ImageBuffer::new(height, width);
-    let _ = rotate90_in(image, &mut out);
-    out
-}
-
-/// Rotate an image 180 degrees clockwise.
-pub fn rotate180<I: GenericImageView>(
-    image: &I,
-) -> ImageBuffer<I::Pixel, Vec<<I::Pixel as Pixel>::Subpixel>>
-where
-    I::Pixel: 'static,
-{
-    let (width, height) = image.dimensions();
-    let mut out = ImageBuffer::new(width, height);
-    let _ = rotate180_in(image, &mut out);
-    out
-}
-
-/// Rotate an image 270 degrees clockwise.
-pub fn rotate270<I: GenericImageView>(
-    image: &I,
-) -> ImageBuffer<I::Pixel, Vec<<I::Pixel as Pixel>::Subpixel>>
-where
-    I::Pixel: 'static,
-{
-    let (width, height) = image.dimensions();
-    let mut out = ImageBuffer::new(height, width);
-    let _ = rotate270_in(image, &mut out);
-    out
-}
-
-/// Rotate an image 90 degrees clockwise and put the result into the destination [`ImageBuffer`].
-pub fn rotate90_in<I, Container>(
-    image: &I,
-    destination: &mut ImageBuffer<I::Pixel, Container>,
-) -> crate::ImageResult<()>
-where
-    I: GenericImageView,
-    I::Pixel: 'static,
-    Container: std::ops::DerefMut<Target = [<I::Pixel as Pixel>::Subpixel]>,
-{
-    let ((w0, h0), (w1, h1)) = (image.dimensions(), destination.dimensions());
-    if w0 != h1 || h0 != w1 {
-        return Err(ImageError::Parameter(ParameterError::from_kind(
-            ParameterErrorKind::DimensionMismatch,
-        )));
-    }
-
-    for y in 0..h0 {
-        for x in 0..w0 {
-            let p = image.get_pixel(x, y);
-            destination.put_pixel(h0 - y - 1, x, p);
-        }
-    }
-    Ok(())
-}
-
-/// Rotate an image 180 degrees clockwise and put the result into the destination [`ImageBuffer`].
-pub fn rotate180_in<I, Container>(
-    image: &I,
-    destination: &mut ImageBuffer<I::Pixel, Container>,
-) -> crate::ImageResult<()>
-where
-    I: GenericImageView,
-    I::Pixel: 'static,
-    Container: std::ops::DerefMut<Target = [<I::Pixel as Pixel>::Subpixel]>,
-{
-    let ((w0, h0), (w1, h1)) = (image.dimensions(), destination.dimensions());
-    if w0 != w1 || h0 != h1 {
-        return Err(ImageError::Parameter(ParameterError::from_kind(
-            ParameterErrorKind::DimensionMismatch,
-        )));
-    }
-
-    for y in 0..h0 {
-        for x in 0..w0 {
-            let p = image.get_pixel(x, y);
-            destination.put_pixel(w0 - x - 1, h0 - y - 1, p);
-        }
-    }
-    Ok(())
-}
-
-/// Rotate an image 270 degrees clockwise and put the result into the destination [`ImageBuffer`].
-pub fn rotate270_in<I, Container>(
-    image: &I,
-    destination: &mut ImageBuffer<I::Pixel, Container>,
-) -> crate::ImageResult<()>
-where
-    I: GenericImageView,
-    I::Pixel: 'static,
-    Container: std::ops::DerefMut<Target = [<I::Pixel as Pixel>::Subpixel]>,
-{
-    let ((w0, h0), (w1, h1)) = (image.dimensions(), destination.dimensions());
-    if w0 != h1 || h0 != w1 {
-        return Err(ImageError::Parameter(ParameterError::from_kind(
-            ParameterErrorKind::DimensionMismatch,
-        )));
-    }
-
-    for y in 0..h0 {
-        for x in 0..w0 {
-            let p = image.get_pixel(x, y);
-            destination.put_pixel(y, w0 - x - 1, p);
-        }
-    }
-    Ok(())
-}
-
-/// Flip an image horizontally
-pub fn flip_horizontal<I: GenericImageView>(
-    image: &I,
-) -> ImageBuffer<I::Pixel, Vec<<I::Pixel as Pixel>::Subpixel>>
-where
-    I::Pixel: 'static,
-{
-    let (width, height) = image.dimensions();
-    let mut out = ImageBuffer::new(width, height);
-    let _ = flip_horizontal_in(image, &mut out);
-    out
-}
-
-/// Flip an image vertically
-pub fn flip_vertical<I: GenericImageView>(
-    image: &I,
-) -> ImageBuffer<I::Pixel, Vec<<I::Pixel as Pixel>::Subpixel>>
-where
-    I::Pixel: 'static,
-{
-    let (width, height) = image.dimensions();
-    let mut out = ImageBuffer::new(width, height);
-    let _ = flip_vertical_in(image, &mut out);
-    out
-}
-
-/// Flip an image horizontally and put the result into the destination [`ImageBuffer`].
-pub fn flip_horizontal_in<I, Container>(
-    image: &I,
-    destination: &mut ImageBuffer<I::Pixel, Container>,
-) -> crate::ImageResult<()>
-where
-    I: GenericImageView,
-    I::Pixel: 'static,
-    Container: std::ops::DerefMut<Target = [<I::Pixel as Pixel>::Subpixel]>,
-{
-    let ((w0, h0), (w1, h1)) = (image.dimensions(), destination.dimensions());
-    if w0 != w1 || h0 != h1 {
-        return Err(ImageError::Parameter(ParameterError::from_kind(
-            ParameterErrorKind::DimensionMismatch,
-        )));
-    }
-
-    for y in 0..h0 {
-        for x in 0..w0 {
-            let p = image.get_pixel(x, y);
-            destination.put_pixel(w0 - x - 1, y, p);
-        }
-    }
-    Ok(())
-}
-
-/// Flip an image vertically and put the result into the destination [`ImageBuffer`].
-pub fn flip_vertical_in<I, Container>(
-    image: &I,
-    destination: &mut ImageBuffer<I::Pixel, Container>,
-) -> crate::ImageResult<()>
-where
-    I: GenericImageView,
-    I::Pixel: 'static,
-    Container: std::ops::DerefMut<Target = [<I::Pixel as Pixel>::Subpixel]>,
-{
-    let ((w0, h0), (w1, h1)) = (image.dimensions(), destination.dimensions());
-    if w0 != w1 || h0 != h1 {
-        return Err(ImageError::Parameter(ParameterError::from_kind(
-            ParameterErrorKind::DimensionMismatch,
-        )));
-    }
-
-    for y in 0..h0 {
-        for x in 0..w0 {
-            let p = image.get_pixel(x, y);
-            destination.put_pixel(x, h0 - 1 - y, p);
-        }
-    }
-    Ok(())
-}
-
-/// Rotate an image 180 degrees clockwise in place.
-pub fn rotate180_in_place<I: GenericImage>(image: &mut I) {
-    let (width, height) = image.dimensions();
-
-    for y in 0..height / 2 {
-        for x in 0..width {
-            let p = image.get_pixel(x, y);
-
-            let x2 = width - x - 1;
-            let y2 = height - y - 1;
-
-            let p2 = image.get_pixel(x2, y2);
-            image.put_pixel(x, y, p2);
-            image.put_pixel(x2, y2, p);
-        }
-    }
-
-    if height % 2 != 0 {
-        let middle = height / 2;
-
-        for x in 0..width / 2 {
-            let p = image.get_pixel(x, middle);
-            let x2 = width - x - 1;
-
-            let p2 = image.get_pixel(x2, middle);
-            image.put_pixel(x, middle, p2);
-            image.put_pixel(x2, middle, p);
-        }
-    }
-}
-
-/// Flip an image horizontally in place.
-pub fn flip_horizontal_in_place<I: GenericImage>(image: &mut I) {
-    let (width, height) = image.dimensions();
-
-    for y in 0..height {
-        for x in 0..width / 2 {
-            let x2 = width - x - 1;
-            let p2 = image.get_pixel(x2, y);
-            let p = image.get_pixel(x, y);
-            image.put_pixel(x2, y, p);
-            image.put_pixel(x, y, p2);
-        }
-    }
-}
-
-/// Flip an image vertically in place.
-pub fn flip_vertical_in_place<I: GenericImage>(image: &mut I) {
-    let (width, height) = image.dimensions();
-
-    for y in 0..height / 2 {
-        for x in 0..width {
-            let y2 = height - y - 1;
-            let p2 = image.get_pixel(x, y2);
-            let p = image.get_pixel(x, y);
-            image.put_pixel(x, y2, p);
-            image.put_pixel(x, y, p2);
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::{
-        flip_horizontal, flip_horizontal_in_place, flip_vertical, flip_vertical_in_place,
-        rotate180, rotate180_in_place, rotate270, rotate90,
-    };
-    use crate::image::GenericImage;
-    use crate::traits::Pixel;
-    use crate::{GrayImage, ImageBuffer};
-
-    macro_rules! assert_pixels_eq {
-        ($actual:expr, $expected:expr) => {{
-            let actual_dim = $actual.dimensions();
-            let expected_dim = $expected.dimensions();
-
-            if actual_dim != expected_dim {
-                panic!(
-                    "dimensions do not match. \
-                     actual: {:?}, expected: {:?}",
-                    actual_dim, expected_dim
-                )
-            }
-
-            let diffs = pixel_diffs($actual, $expected);
-
-            if !diffs.is_empty() {
-                let mut err = "".to_string();
-
-                let diff_messages = diffs
-                    .iter()
-                    .take(5)
-                    .map(|d| format!("\nactual: {:?}, expected {:?} ", d.0, d.1))
-                    .collect::<Vec<_>>()
-                    .join("");
-
-                err.push_str(&diff_messages);
-                panic!("pixels do not match. {:?}", err)
-            }
-        }};
-    }
-
-    #[test]
-    fn test_rotate90() {
-        let image: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![00u8, 01u8, 02u8, 10u8, 11u8, 12u8]).unwrap();
-
-        let expected: GrayImage =
-            ImageBuffer::from_raw(2, 3, vec![10u8, 00u8, 11u8, 01u8, 12u8, 02u8]).unwrap();
-
-        assert_pixels_eq!(&rotate90(&image), &expected);
-    }
-
-    #[test]
-    fn test_rotate180() {
-        let image: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![00u8, 01u8, 02u8, 10u8, 11u8, 12u8]).unwrap();
-
-        let expected: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![12u8, 11u8, 10u8, 02u8, 01u8, 00u8]).unwrap();
-
-        assert_pixels_eq!(&rotate180(&image), &expected);
-    }
-
-    #[test]
-    fn test_rotate270() {
-        let image: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![00u8, 01u8, 02u8, 10u8, 11u8, 12u8]).unwrap();
-
-        let expected: GrayImage =
-            ImageBuffer::from_raw(2, 3, vec![02u8, 12u8, 01u8, 11u8, 00u8, 10u8]).unwrap();
-
-        assert_pixels_eq!(&rotate270(&image), &expected);
-    }
-
-    #[test]
-    fn test_rotate180_in_place() {
-        let mut image: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![00u8, 01u8, 02u8, 10u8, 11u8, 12u8]).unwrap();
-
-        let expected: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![12u8, 11u8, 10u8, 02u8, 01u8, 00u8]).unwrap();
-
-        rotate180_in_place(&mut image);
-
-        assert_pixels_eq!(&image, &expected);
-    }
-
-    #[test]
-    fn test_flip_horizontal() {
-        let image: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![00u8, 01u8, 02u8, 10u8, 11u8, 12u8]).unwrap();
-
-        let expected: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![02u8, 01u8, 00u8, 12u8, 11u8, 10u8]).unwrap();
-
-        assert_pixels_eq!(&flip_horizontal(&image), &expected);
-    }
-
-    #[test]
-    fn test_flip_vertical() {
-        let image: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![00u8, 01u8, 02u8, 10u8, 11u8, 12u8]).unwrap();
-
-        let expected: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![10u8, 11u8, 12u8, 00u8, 01u8, 02u8]).unwrap();
-
-        assert_pixels_eq!(&flip_vertical(&image), &expected);
-    }
-
-    #[test]
-    fn test_flip_horizontal_in_place() {
-        let mut image: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![00u8, 01u8, 02u8, 10u8, 11u8, 12u8]).unwrap();
-
-        let expected: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![02u8, 01u8, 00u8, 12u8, 11u8, 10u8]).unwrap();
-
-        flip_horizontal_in_place(&mut image);
-
-        assert_pixels_eq!(&image, &expected);
-    }
-
-    #[test]
-    fn test_flip_vertical_in_place() {
-        let mut image: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![00u8, 01u8, 02u8, 10u8, 11u8, 12u8]).unwrap();
-
-        let expected: GrayImage =
-            ImageBuffer::from_raw(3, 2, vec![10u8, 11u8, 12u8, 00u8, 01u8, 02u8]).unwrap();
-
-        flip_vertical_in_place(&mut image);
-
-        assert_pixels_eq!(&image, &expected);
-    }
-
-    fn pixel_diffs<I, J, P>(left: &I, right: &J) -> Vec<((u32, u32, P), (u32, u32, P))>
-    where
-        I: GenericImage<Pixel = P>,
-        J: GenericImage<Pixel = P>,
-        P: Pixel + Eq,
-    {
-        left.pixels()
-            .zip(right.pixels())
-            .filter(|&(p, q)| p != q)
-            .collect::<Vec<_>>()
-    }
-}