fastimageresize

Rust library for fast image resizing with using of SIMD instructions.

Note: This library does not support converting image color spaces. If it is important for you to resize images with a non-linear color space (e.g. sRGB) correctly, then you need to convert it to a linear color space before resizing. Read more about resizing with respect to color space.

CHANGELOG

Supported pixel formats and available optimisations:

| Format | Description | Native Rust | SSE4.1 | AVX2 | |:------:|:-----------------------------------------------------------|:-----------:|:-------:|:----:| | U8 | One u8 component per pixel (e.g. L) | + | partial | + | | U8x2 | Two u8 components per pixel (e.g. LA) | + | + | + | | U8x3 | Three u8 components per pixel (e.g. RGB) | + | partial | + | | U8x4 | Four u8 components per pixel (e.g. RGBA, RGBx, CMYK) | + | + | + | | U16 | One u16 components per pixel (e.g. L16) | + | + | + | | U16x3 | Three u16 components per pixel (e.g. RGB16) | + | + | + | | I32 | One i32 component per pixel | + | - | - | | F32 | One f32 component per pixel | + | - | - |

Benchmarks

Environment:

CPU: AMD Ryzen 9 5950X
RAM: DDR4 3800 MHz
Ubuntu 22.04 (linux 5.15.0)
Rust 1.61.0
fastimageresize = "0.9.3"
glassbench = "0.3.1"
rustflags = ["-C", "llvm-args=-x86-branches-within-32B-boundaries"]

Other Rust libraries used to compare of resizing speed:

image = "0.24.2" (https://crates.io/crates/image)
resize = "0.7.2" (https://crates.io/crates/resize)

Resize algorithms:

Nearest
Convolution with Bilinear filter
Convolution with CatmullRom filter
Convolution with Lanczos3 filter

Resize RGB8 image (U8x3) 4928x3279 => 852x567

Pipeline:

src_image => resize => dst_image

Source image nasa-4928x3279.png
Numbers in table is mean duration of image resizing in milliseconds.

| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 18.25 | 79.66 | 138.48 | 189.00 | | resize | - | 50.41 | 97.00 | 142.89 | | fir rust | 0.26 | 37.79 | 64.21 | 93.78 | | fir sse4.1 | 0.26 | 26.07 | 39.62 | 53.22 | | fir avx2 | 0.26 | 6.95 | 8.87 | 12.68 |

Resize RGBA8 image (U8x4) 4928x3279 => 852x567

Pipeline:

src_image => multiply by alpha => resize => divide by alpha => dst_image

Source image nasa-4928x3279-rgba.png
Numbers in table is mean duration of image resizing in milliseconds.

| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 18.32 | 75.46 | 128.47 | 181.34 | | resize | - | 49.26 | 94.38 | 138.48 | | fir rust | 0.17 | 33.67 | 47.63 | 67.37 | | fir sse4.1 | 0.17 | 12.21 | 15.89 | 20.61 | | fir avx2 | 0.17 | 9.18 | 11.46 | 15.26 |

Resize grayscale image (U8) 4928x3279 => 852x567

Pipeline:

src_image => resize => dst_image

Source image nasa-4928x3279.png has converted into grayscale image with one byte per pixel.
Numbers in table is mean duration of image resizing in milliseconds.

| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 15.05 | 44.65 | 70.26 | 95.61 | | resize | - | 16.88 | 32.98 | 56.31 | | fir rust | 0.14 | 13.21 | 14.98 | 21.86 | | fir sse4.1 | 0.14 | 11.22 | 11.23 | 16.46 | | fir avx2 | 0.14 | 6.03 | 4.41 | 7.37 |

Resize grayscale image with alpha channel (U8x2) 4928x3279 => 852x567

Pipeline:

src_image => multiply by alpha => resize => divide by alpha => dst_image

Source image nasa-4928x3279-rgba.png has converted into grayscale image with alpha channel (two bytes per pixel).
Numbers in table is mean duration of image resizing in milliseconds.
The resize crate does not support this pixel format.

| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 16.41 | 61.23 | 111.31 | 149.96 | | fir rust | 0.15 | 23.67 | 27.94 | 38.91 | | fir sse4.1 | 0.15 | 11.66 | 13.33 | 16.44 | | fir avx2 | 0.15 | 10.33 | 11.43 | 14.12 |

Resize RGB16 image (U16x3) 4928x3279 => 852x567

Pipeline:

src_image => resize => dst_image

Source image nasa-4928x3279.png has converted into RGB16 image.
Numbers in table is mean duration of image resizing in milliseconds.

| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 17.54 | 72.24 | 126.80 | 176.03 | | resize | - | 52.51 | 100.40 | 147.31 | | fir rust | 0.31 | 39.56 | 65.65 | 92.90 | | fir sse4.1 | 0.31 | 22.14 | 35.69 | 50.40 | | fir avx2 | 0.31 | 19.12 | 28.25 | 33.86 |

Resize grayscale image with 16 bits per pixel (U16) 4928x3279 => 852x567

Pipeline:

src_image => resize => dst_image

Source image nasa-4928x3279.png has converted into grayscale image with two bytes per pixel.
Numbers in table is mean duration of image resizing in milliseconds.

| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 15.18 | 44.51 | 70.23 | 96.64 | | resize | - | 15.41 | 30.13 | 52.52 | | fir rust | 0.16 | 16.96 | 25.51 | 34.87 | | fir sse4.1 | 0.16 | 7.36 | 11.96 | 17.40 | | fir avx2 | 0.16 | 15.33 | 10.47 | 16.89 |

Examples

Resize RGBA8 image

```rust use std::io::BufWriter; use std::num::NonZeroU32;

use image::codecs::png::PngEncoder; use image::io::Reader as ImageReader; use image::{ColorType, ImageEncoder};

use fastimageresize as fr;

fn main() { // Read source image from file let img = ImageReader::open("./data/nasa-4928x3279.png") .unwrap() .decode() .unwrap(); let width = NonZeroU32::new(img.width()).unwrap(); let height = NonZeroU32::new(img.height()).unwrap(); let mut srcimage = fr::Image::fromvecu8( width, height, img.torgba8().into_raw(), fr::PixelType::U8x4, ) .unwrap();

// Create MulDiv instance
let alpha_mul_div = fr::MulDiv::default();
// Multiple RGB channels of source image by alpha channel 
// (not required for the Nearest algorithm) 
alpha_mul_div
    .multiply_alpha_inplace(&mut src_image.view_mut())
    .unwrap();

// Create container for data of destination image
let dst_width = NonZeroU32::new(1024).unwrap();
let dst_height = NonZeroU32::new(768).unwrap();
let mut dst_image = fr::Image::new(
    dst_width,
    dst_height,
    src_image.pixel_type(),
);

// Get mutable view of destination image data
let mut dst_view = dst_image.view_mut();

// Create Resizer instance and resize source image
// into buffer of destination image
let mut resizer = fr::Resizer::new(
    fr::ResizeAlg::Convolution(fr::FilterType::Lanczos3),
);
resizer.resize(&src_image.view(), &mut dst_view).unwrap();

// Divide RGB channels of destination image by alpha
alpha_mul_div.divide_alpha_inplace(&mut dst_view).unwrap();

// Write destination image as PNG-file
let mut result_buf = BufWriter::new(Vec::new());
PngEncoder::new(&mut result_buf)
    .write_image(
        dst_image.buffer(),
        dst_width.get(),
        dst_height.get(),
        ColorType::Rgba8,
    )
    .unwrap();

} ```

Resize with cropping

```rust use std::io::BufWriter; use std::num::NonZeroU32;

use image::codecs::png::PngEncoder; use image::io::Reader as ImageReader; use image::{ColorType, GenericImageView};

use fastimageresize as fr;

fn resizeimagewithcropping( mut srcview: fr::ImageView, dstwidth: NonZeroU32, dstheight: NonZeroU32 ) -> fr::Image { // Set cropping parameters srcview.setcropboxtofitdstsize(dstwidth, dst_height, None);

// Create container for data of destination image
let mut dst_image = fr::Image::new(
    dst_width,
    dst_height,
    src_view.pixel_type(),
);
// Get mutable view of destination image data
let mut dst_view = dst_image.view_mut();

// Create Resizer instance and resize source image
// into buffer of destination image
let mut resizer = fr::Resizer::new(
    fr::ResizeAlg::Convolution(fr::FilterType::Lanczos3)
);
resizer.resize(&src_view, &mut dst_view).unwrap();

dst_image

}

fn main() { let img = ImageReader::open("./data/nasa-4928x3279.png") .unwrap() .decode() .unwrap(); let width = NonZeroU32::new(img.width()).unwrap(); let height = NonZeroU32::new(img.height()).unwrap(); let srcimage = fr::Image::fromvecu8( width, height, img.torgb8().intoraw(), fr::PixelType::U8x3, ).unwrap(); resizeimagewithcropping( src_image.view(), NonZeroU32::new(1024).unwrap(), NonZeroU32::new(768).unwrap(), ); } ```

Change CPU extensions used by resizer

```rust, ignore use fastimageresize as fr;

fn main() { let mut resizer = fr::Resizer::new( fr::ResizeAlg::Convolution(fr::FilterType::Lanczos3), ); unsafe { resizer.setcpuextensions(fr::CpuExtensions::Sse4_1); } } ```