image-provider 0.1.2

Axum-based image resizer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use clap::Parser;
use derive_builder::Builder;
use fast_image_resize::{FilterType, ResizeAlg};
use serde::Deserialize;

#[derive(Debug, Clone, Deserialize, Parser, Builder)]
#[builder(pattern = "owned")]
pub struct ResizeConfig {
    /// Filter type to use for resizing
    /// `lanczos3`  
    /// `gaussian`  
    /// `catmull-rom`  
    /// `hamming`  
    /// `mitchell`  
    /// `bilinear`  
    /// `box`  
    #[clap(name = "resize-images-filter-type", long, default_value = "lanczos3")]
    pub filter_type: String,

    /// Resize algorithm to use
    /// `super-sampling8x`  
    /// `super-sampling4x`  
    /// `super-sampling2x`  
    /// `convolution`  
    /// `interpolation`  
    /// `nearest`  
    /// (nearest will ignore filter_type)
    #[clap(
        name = "resize-images-algorithm",
        long,
        default_value = "interpolation"
    )]
    pub algorithm: String,

    /// Maximum cached images in memory
    #[clap(name = "resize-images-cache-size", long, default_value_t = 200)]
    pub cache_size: usize,
}

impl ResizeConfig {
    pub fn builder() -> ResizeConfigBuilder {
        ResizeConfigBuilder {
            filter_type: Some("lanczos3".into()),
            algorithm: Some("interpolation".into()),
            cache_size: Some(200),
        }
    }

    pub fn resize_algorithm(&self) -> ResizeAlg {
        let filter_type = match self.filter_type.as_str() {
            "lanczos3" => FilterType::Lanczos3,
            "gaussian" => FilterType::Gaussian,
            "catmull-rom" => FilterType::CatmullRom,
            "hamming" => FilterType::Hamming,
            "mitchell" => FilterType::Mitchell,
            "bilinear" => FilterType::Bilinear,
            "box" => FilterType::Box,
            _ => panic!("Unsupported filter type"),
        };

        match self.algorithm.as_str() {
            "super-sampling8x" => ResizeAlg::SuperSampling(filter_type, 8),
            "super-sampling4x" => ResizeAlg::SuperSampling(filter_type, 4),
            "super-sampling2x" => ResizeAlg::SuperSampling(filter_type, 2),
            "interpolation" => ResizeAlg::Interpolation(filter_type),
            "convolution" => ResizeAlg::Convolution(filter_type),
            "nearest" => ResizeAlg::Nearest,
            _ => panic!("Unsupported resize algorithm"),
        }
    }
}