Rust library for fast image resizing with using of SIMD instructions.
Supported pixel formats and available optimisations:
| Format | Description | Native Rust | SSE4.1 | AVX2 | Neon |
|:------:|:--------------------------------------------------------------|:-----------:|:------:|:----:|:----:|
| U8 | One u8 component per pixel (e.g. L) | + | + | + | - |
| U8x2 | Two u8 components per pixel (e.g. LA) | + | + | + | - |
| U8x3 | Three u8 components per pixel (e.g. RGB) | + | + | + | - |
| U8x4 | Four u8 components per pixel (e.g. RGBA, RGBx, CMYK) | + | + | + | + |
| U16 | One u16 components per pixel (e.g. L16) | + | + | + | - |
| U16x2 | Two u16 components per pixel (e.g. LA16) | + | + | + | - |
| U16x3 | Three u16 components per pixel (e.g. RGB16) | + | + | + | - |
| U16x4 | Four u16 components per pixel (e.g. RGBA16, RGBx16, CMYK16) | + | + | + | + |
| I32 | One i32 component per pixel | + | - | - | - |
| F32 | One f32 component per pixel | + | - | - | - |
Resizer from this crate does not convert image into linear colorspace during resize process. 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 and convert back a color space of result image. Read more about resizing with respect to color space.
This crate provides the
PixelComponentMapper
structure that allows you to create colorspace converters for images
whose pixels based on u8 and u16 components.
In addition, the crate contains functions create_gamma_22_mapper()
and create_srgb_mapper() to create instance of PixelComponentMapper
that converts images from sRGB or gamma 2.2 into linear colorspace and back.
Rust libraries used to compare of resizing speed:
Pipeline:
src_image => resize => dst_image
| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 21.19 | 83.63 | 143.36 | 204.99 | | resize | - | 45.90 | 90.65 | 134.75 | | fir rust | 0.28 | 38.73 | 75.43 | 111.71 | | fir sse4.1 | 0.28 | 9.35 | 13.63 | 19.20 | | fir avx2 | 0.28 | 7.36 | 9.52 | 13.66 |
Pipeline:
src_image => multiply by alpha => resize => divide by alpha => dst_image
image crate does not support multiplying and dividing by alpha channel.| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | resize | - | 65.62 | 129.84 | 193.56 | | fir rust | 0.19 | 37.38 | 53.83 | 76.69 | | fir sse4.1 | 0.19 | 13.02 | 17.18 | 22.33 | | fir avx2 | 0.19 | 9.56 | 12.04 | 16.27 |
Pipeline:
src_image => resize => dst_image
| | Nearest | Bilinear | CatmullRom | Lanczos3 | |------------|:-------:|:--------:|:----------:|:--------:| | image | 17.56 | 49.20 | 77.55 | 106.07 | | resize | - | 17.71 | 36.82 | 62.15 | | fir rust | 0.15 | 13.36 | 14.81 | 22.22 | | fir sse4.1 | 0.15 | 4.51 | 5.08 | 7.61 | | fir avx2 | 0.15 | 6.00 | 4.77 | 7.46 |
```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();
// Multiple RGB channels of source image by alpha channel
// (not required for the Nearest algorithm)
let alpha_mul_div = fr::MulDiv::default();
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::DynamicImageView, 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); } } ```