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.
Supported pixel formats and available optimisations:
U8 - one u8 component per pixel:
U8x2 - two u8 components per pixel (e.g. LA):
U8x3 - three u8 components per pixel (e.g. RGB):
U8x4 - four u8 components per pixel (RGBA, RGBx, CMYK and other):
U16x3 - three u16 components per pixel (e.g. RGB):
I32 - one i32 component per pixel:
F32 - one f32 component per pixel:
Environment:
rustflags = ["-C", "llvm-args=-x86-branches-within-32B-boundaries"]Other Rust libraries used to compare of resizing speed:
Resize algorithms:
Pipeline:
src_image => resize => dst_image
| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 20.31 | 77.37 | 136.35 | 183.63 | | resize | - | 45.60 | 87.53 | 129.12 | | fir rust | 0.26 | 42.40 | 78.29 | 115.52 | | fir sse4.1 | 0.26 | 26.11 | 39.54 | 53.26 | | fir avx2 | 0.26 | 6.93 | 8.74 | 12.62 |
Pipeline:
src_image => multiply by alpha => resize => divide by alpha => dst_image
| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 20.43 | 78.27 | 131.97 | 185.15 | | resize | - | 53.60 | 102.31 | 152.19 | | fir rust | 0.17 | 33.25 | 46.95 | 67.66 | | fir sse4.1 | 0.17 | 12.06 | 15.78 | 20.67 | | fir avx2 | 0.17 | 9.32 | 11.55 | 15.32 |
Pipeline:
src_image => resize => dst_image
| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 16.95 | 47.55 | 74.95 | 102.03 | | resize | - | 16.25 | 32.60 | 55.48 | | fir rust | 0.14 | 13.00 | 14.72 | 21.98 | | fir sse4.1 | 0.14 | 11.02 | 11.07 | 16.60 | | fir avx2 | 0.14 | 6.06 | 4.40 | 7.37 |
Pipeline:
src_image => multiply by alpha => resize => divide by alpha => dst_image
resize crate does not support this pixel format.| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 18.84 | 63.52 | 109.12 | 147.87 | | fir rust | 0.15 | 23.03 | 28.14 | 39.05 | | fir sse4.1 | 0.15 | 18.68 | 20.35 | 27.82 | | fir avx2 | 0.15 | 10.31 | 11.68 | 14.19 |
Pipeline:
src_image => resize => dst_image
| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 20.11 | 73.28 | 124.70 | 173.92 | | resize | - | 47.19 | 89.87 | 132.28 | | fir rust | 0.31 | 39.41 | 69.07 | 96.50 | | fir sse4.1 | 0.31 | 22.21 | 35.84 | 50.60 | | fir avx2 | 0.31 | 19.19 | 28.58 | 34.11 |
```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();
} ```
```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(), ); } ```
```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); } } ```