Enum ImageDownscaleMode 

#[non_exhaustive]
pub enum ImageDownscaleMode {
    Fit(Size2D<Px, Px>),
    Fill(Size2D<Px, Px>),
    MipMap {
        min_size: Size2D<Px, Px>,
        max_size: Size2D<Px, Px>,
    },
    Entries(Vec<ImageDownscaleMode>),
}

Defines how an image is downscaled after decoding.

The image aspect ratio is preserved in all modes. The image is never upscaled. If the image container contains reduced alternative the nearest to the requested size is used as source.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Fit(Size2D<Px, Px>)

Image is downscaled so that both dimensions fit inside the size.

Fill(Size2D<Px, Px>)

Image is downscaled so that at least one dimension fits inside the size. The image is not clipped.

MipMap

Generate synthetic ImageEntryKind::Reduced entries each half the size of the image until the sample that is nearest min_size and greater or equal to it. If the image container already has alternates that are equal to or near a mip size that size is used instead.

Fields

min_size: Size2D<Px, Px>

Minimum sample size.

max_size: Size2D<Px, Px>

Maximum Fill size.

Entries(Vec<ImageDownscaleMode>)

Generate multiple synthetic ImageEntryKind::Reduced entries. The entry sizes are sorted by largest first, if the image full size already fits in the largest downscale requested the full image is returned and any downscale actually smaller becomes a synthetic entry. If the image is larger than all requested sizes it is downscaled as well.

Implementations

impl ImageDownscaleMode

pub fn mip_map() -> ImageDownscaleMode

Default mipmap min/max when the objective of the mipmap is optimizing dynamically resizing massive images.

pub fn with_entry( self, other: impl Into<ImageDownscaleMode>, ) -> ImageDownscaleMode

Append entry downscale request.

pub fn sizes( &self, page_size: Size2D<Px, Px>, reduced_sizes: &[Size2D<Px, Px>], ) -> (Option<Size2D<Px, Px>>, Vec<Size2D<Px, Px>>)

Get downscale sizes that need to be generated.

The page_size is the image full size, the reduced_sizes are sizes of reduced alternates that are already provided by the image container.

Returns the downscale for the image full size, if needed and a list of reduced entries that must be synthesized, sorted largest to smallest.

Trait Implementations

impl Clone for ImageDownscaleMode

fn clone(&self) -> ImageDownscaleMode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ImageDownscaleMode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ImageDownscaleMode

fn deserialize<__D>( __deserializer: __D, ) -> Result<ImageDownscaleMode, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Px> for ImageDownscaleMode

fn from(fit: Px) -> ImageDownscaleMode

Fit splat

impl From<Size2D<Px, Px>> for ImageDownscaleMode

fn from(fit: Size2D<Px, Px>) -> ImageDownscaleMode

Fit

impl Hash for ImageDownscaleMode

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoVar<ImageDownscaleMode> for Px

fn into_var(self) -> Var<ImageDownscaleMode>

impl IntoVar<ImageDownscaleMode> for Size2D<Px, Px>

fn into_var(self) -> Var<ImageDownscaleMode>

impl IntoVar<Option<ImageDownscaleMode>> for ImageDownscaleMode

fn into_var(self) -> Var<Option<ImageDownscaleMode>>

impl PartialEq for ImageDownscaleMode

fn eq(&self, other: &ImageDownscaleMode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ImageDownscaleMode

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ImageDownscaleMode

impl IntoValue<ImageDownscaleMode> for Px

impl IntoValue<ImageDownscaleMode> for Size2D<Px, Px>

impl IntoValue<Option<ImageDownscaleMode>> for ImageDownscaleMode

impl StructuralPartialEq for ImageDownscaleMode