Struct Scaler 

pub struct Scaler {
    pub workload_strategy: WorkloadStrategy,
    /* private fields */
}

Represents base scaling structure

Fields

workload_strategy: WorkloadStrategy

Implementations

impl Scaler

pub fn new(filter: ResamplingFunction) -> Self

Creates new Scaler instance with corresponding filter

Creates default crate::Scaler with corresponding filter and default ThreadingPolicy::Single

pub fn set_workload_strategy(&mut self, workload_strategy: WorkloadStrategy)

Sets preferred workload strategy

This is hint only, it may change something, or may not.

impl Scaler

pub fn resize_ar30( &self, src_image: &ImageStore<'_, u8, 4>, dst_image: &mut ImageStoreMut<'_, u8, 4>, order: Ar30ByteOrder, ) -> Result<(), PicScaleError>

Resizes RGBA2101010 image

This method ignores alpha scaling.

Arguments

src_image - source AR30 image dst_image - destination AR30 image new_size - New image size

pub fn resize_ra30( &self, src_image: &ImageStore<'_, u8, 4>, dst_image: &mut ImageStoreMut<'_, u8, 4>, order: Ar30ByteOrder, ) -> Result<(), PicScaleError>

Resizes RGBA1010102 image

This method ignores alpha scaling.

Arguments

src_image - source RA30 image dst_image - destination RA30 image

impl Scaler

Implements f16 type support

pub fn resize_rgba_f16<'a>( &'a self, store: &ImageStore<'a, f16, 4>, into: &mut ImageStoreMut<'a, f16, 4>, premultiply_alpha: bool, ) -> Result<(), PicScaleError>

Available on crate feature nightly_f16 only.

Performs rescaling for RGBA f16

Scales RGBA high bit-depth interleaved image in f16 type. Channel order does not matter. To handle alpha pre-multiplication alpha channel expected to be at last position.

Arguments

store - original image store into - target image store premultiply_alpha - flag if it should handle alpha or not

Example

#[no_build]

 use pic_scale::{ImageStore, ImageStoreMut, ResamplingFunction, Scaler};
 let mut scaler = Scaler::new(ResamplingFunction::Bilinear);
 let src_store = ImageStore::alloc(100, 100);
 let mut dst_store = ImageStoreMut::<f16, 4>::alloc_with_depth(50, 50, 10);
 scaler.resize_rgba_f16(&src_store, &mut dst_store, false).unwrap();

pub fn resize_rgb_f16<'a>( &'a self, store: &ImageStore<'a, f16, 3>, into: &mut ImageStoreMut<'a, f16, 3>, ) -> Result<(), PicScaleError>

Available on crate feature nightly_f16 only.

Performs rescaling for RGB f16

Scales RGB high bit-depth interleaved image in f16 type. Channel order does not matter.

Arguments

store - original image store into - target image store

Example

#[no_build]

 use pic_scale::{ImageStore, ImageStoreMut, ResamplingFunction, Scaler};
 let mut scaler = Scaler::new(ResamplingFunction::Bilinear);
 let src_store = ImageStore::alloc(100, 100);
 let mut dst_store = ImageStoreMut::<f16, 3>::alloc_with_depth(50, 50, 10);
 scaler.resize_rgb_f16(&src_store, &mut dst_store).unwrap();

pub fn resize_cbcr_f16<'a>( &'a self, store: &ImageStore<'a, f16, 2>, into: &mut ImageStoreMut<'a, f16, 2>, ) -> Result<(), PicScaleError>

Available on crate feature nightly_f16 only.

Performs rescaling for CbCr f16

Scales CbCr high bit-depth interleaved image in f16 type, optionally it could handle LumaAlpha images also Channel order does not matter.

Arguments

store - original image store into - target image store

Example

#[no_build]

 use pic_scale::{ImageStore, ImageStoreMut, ResamplingFunction, Scaler};
 let mut scaler = Scaler::new(ResamplingFunction::Bilinear);
 let src_store = ImageStore::alloc(100, 100);
 let mut dst_store = ImageStoreMut::<f16, 2>::alloc_with_depth(50, 50, 10);
 scaler.resize_cbcr_f16(&src_store, &mut dst_store).unwrap();

pub fn resize_plane_f16<'a>( &'a self, store: &ImageStore<'a, f16, 1>, into: &mut ImageStoreMut<'a, f16, 1>, ) -> Result<(), PicScaleError>

Available on crate feature nightly_f16 only.

Performs rescaling for Planar image f16

Scales planar high bit-depth image in f16 type, optionally it could handle LumaAlpha images also Channel order does not matter.

Arguments

store - original image store into - target image store

Example

#[no_build]

 use pic_scale::{ImageStore, ImageStoreMut, ResamplingFunction, Scaler};
 let mut scaler = Scaler::new(ResamplingFunction::Bilinear);
 let src_store = ImageStore::alloc(100, 100);
 let mut dst_store = ImageStoreMut::<f16, 1>::alloc_with_depth(50, 50, 10);
 scaler.resize_plane_f16(&src_store, &mut dst_store).unwrap();

Trait Implementations

impl Clone for Scaler

fn clone(&self) -> Scaler

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Scaler

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Scaling for Scaler

fn set_threading_policy(&mut self, threading_policy: ThreadingPolicy)

Sets threading policy

fn resize_plane<'a>( &'a self, store: &ImageStore<'a, u8, 1>, into: &mut ImageStoreMut<'a, u8, 1>, ) -> Result<(), PicScaleError>

Performs rescaling for planar image

fn resize_cbcr8<'a>( &'a self, store: &ImageStore<'a, u8, 2>, into: &mut ImageStoreMut<'a, u8, 2>, ) -> Result<(), PicScaleError>

Performs rescaling for CbCr8 ( or 2 interleaved channels )

fn resize_gray_alpha<'a>( &'a self, store: &ImageStore<'a, u8, 2>, into: &mut ImageStoreMut<'a, u8, 2>, premultiply_alpha: bool, ) -> Result<(), PicScaleError>

Performs rescaling for Gray Alpha ( or 2 interleaved channels with aloha )

fn resize_rgb<'a>( &'a self, store: &ImageStore<'a, u8, 3>, into: &mut ImageStoreMut<'a, u8, 3>, ) -> Result<(), PicScaleError>

Performs rescaling for RGB, channel order does not matter

fn resize_rgba<'a>( &'a self, store: &ImageStore<'a, u8, 4>, into: &mut ImageStoreMut<'a, u8, 4>, premultiply_alpha: bool, ) -> Result<(), PicScaleError>

Performs rescaling for RGBA

impl ScalingF32 for Scaler

fn resize_plane_f32<'a>( &'a self, store: &ImageStore<'a, f32, 1>, into: &mut ImageStoreMut<'a, f32, 1>, ) -> Result<(), PicScaleError>

Performs rescaling planar f32 image

fn resize_cbcr_f32<'a>( &'a self, store: &ImageStore<'a, f32, 2>, into: &mut ImageStoreMut<'a, f32, 2>, ) -> Result<(), PicScaleError>

Performs rescaling for CbCr f32 image

fn resize_gray_alpha_f32<'a>( &'a self, store: &ImageStore<'a, f32, 2>, into: &mut ImageStoreMut<'a, f32, 2>, premultiply_alpha: bool, ) -> Result<(), PicScaleError>

Performs rescaling for Gray Alpha f32 image

fn resize_rgb_f32<'a>( &'a self, store: &ImageStore<'a, f32, 3>, into: &mut ImageStoreMut<'a, f32, 3>, ) -> Result<(), PicScaleError>

Performs rescaling for RGB f32

fn resize_rgba_f32<'a>( &'a self, store: &ImageStore<'a, f32, 4>, into: &mut ImageStoreMut<'a, f32, 4>, premultiply_alpha: bool, ) -> Result<(), PicScaleError>

Performs rescaling for RGBA f32

impl ScalingU16 for Scaler

fn resize_rgb_u16<'a>( &'a self, store: &ImageStore<'a, u16, 3>, into: &mut ImageStoreMut<'a, u16, 3>, ) -> Result<(), PicScaleError>

Performs rescaling for RGB

Scales RGB high bit-depth image stored in u16 type. To perform scaling image bit-depth should be set in target image, source image expects to have the same one. Channel order does not matter.

Arguments

store - original image store into - target image store

Panics

Method panics if bit-depth < 1 or bit-depth > 16

Example

#[no_build]

 use pic_scale::{ImageStore, ImageStoreMut, ResamplingFunction, Scaler, ScalingU16};
 let mut scaler = Scaler::new(ResamplingFunction::Bilinear);
 let src_store = ImageStore::alloc(100, 100);
 let mut dst_store = ImageStoreMut::<u16, 3>::alloc_with_depth(50, 50, 10);
 scaler.resize_rgb_u16(&src_store, &mut dst_store).unwrap();

fn resize_rgba_u16<'a>( &'a self, store: &ImageStore<'a, u16, 4>, into: &mut ImageStoreMut<'a, u16, 4>, premultiply_alpha: bool, ) -> Result<(), PicScaleError>

Resizes u16 image

Arguments

store - original image store into - target image store premultiply_alpha - flags is alpha is premultiplied

Panics

Method panics if bit -depth < 1 or bit-depth > 16

Example

#[no_build]

 use pic_scale::{ImageStore, ImageStoreMut, ResamplingFunction, Scaler, ScalingU16};
 let mut scaler = Scaler::new(ResamplingFunction::Bilinear);
 let src_store = ImageStore::alloc(100, 100);
 let mut dst_store = ImageStoreMut::<u16, 4>::alloc_with_depth(50, 50, 10);
 scaler.resize_rgba_u16(&src_store, &mut dst_store, true).unwrap();

fn resize_plane_u16<'a>( &'a self, store: &ImageStore<'a, u16, 1>, into: &mut ImageStoreMut<'a, u16, 1>, ) -> Result<(), PicScaleError>

Performs rescaling for Planar u16

Scales planar high bit-depth image stored in u16 type. To perform scaling image bit-depth should be set in target image, source image expects to have the same one.

Arguments

store - original image store into - target image store

Panic

Method panics if bit-depth < 1 or bit-depth > 16

Example

#[no_build]

 use pic_scale::{ImageStore, ImageStoreMut, ResamplingFunction, Scaler, ScalingU16};
 let mut scaler = Scaler::new(ResamplingFunction::Lanczos3);
 let src_store = ImageStore::alloc(100, 100);
 let mut dst_store = ImageStoreMut::<u16, 1>::alloc_with_depth(50, 50, 10);
 scaler.resize_plane_u16(&src_store, &mut dst_store).unwrap();

fn resize_cbcr_u16<'a>( &'a self, store: &ImageStore<'a, u16, 2>, into: &mut ImageStoreMut<'a, u16, 2>, ) -> Result<(), PicScaleError>

Performs rescaling for CbCr16

fn resize_gray_alpha16<'a>( &'a self, store: &ImageStore<'a, u16, 2>, into: &mut ImageStoreMut<'a, u16, 2>, premultiply_alpha: bool, ) -> Result<(), PicScaleError>

Performs rescaling for Gray Alpha high bit-depth ( or 2 interleaved channels with aloha )

impl Copy for Scaler