rimage 0.12.3

Optimize images natively with best-in-class codecs
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

#![allow(unused_imports)]

use clap::{Arg, ArgAction, ArgGroup, Command, arg, value_parser};
use indoc::indoc;

#[cfg(feature = "resize")]
pub use resize::{ResizeFilter, ResizeValue};

#[cfg(feature = "resize")]
mod resize;

impl Preprocessors for Command {
    #[cfg(any(feature = "resize", feature = "quantization"))]
    fn preprocessors(self) -> Self {
        self.group(
                ArgGroup::new("preprocessors")
                    .args([
                        #[cfg(feature = "resize")]
                        "resize",
                        #[cfg(feature = "quantization")]
                         "quantization",
                    ])
                    .multiple(true)
            )
            .next_help_heading("Preprocessors")
            .args([
                #[cfg(feature = "resize")]
                arg!(--resize <RESIZE> "Resize the image(s) according to the specified criteria.")
                    .long_help(indoc! {r#"Resize the image(s) according to the specified criteria.

                    Possible values:
                    - @1.5:    Enlarge image size by this multiplier
                    - 150%:    Adjust image size by this percentage
                    - 100x100: Resize image to Width×Height
                    - 100w:    Adjust image dimensions while maintaining the aspect ratio based on the width
                    - 100h:    Adjust image dimensions while maintaining the aspect ratio based on the height"#})
                    .value_parser(value_parser!(ResizeValue))
                    .action(ArgAction::Append),

                #[cfg(feature = "resize")]
                arg!(--downscale "Downscale the image(s) when resizing.")
                    .long_help(indoc! {r#"Downscale the image(s) when resizing.

                    This is useful when you want to reduce the size of the image when it is larger than the specified size.
                    It is recommended to use this option with --resize"#})
                    .default_value("true")
                    .action(ArgAction::SetTrue)
                    .requires("resize")
                    .overrides_with("no-downscale"),
                #[cfg(feature = "resize")]
                arg!(--"no-downscale" "Disable downscaling when resizing.")
                    .long_help(indoc! {r#"Disable downscaling when resizing.

                    This is useful when you don't want to reduce the size of the image when it is larger than the specified size.
                    It is recommended to use this option with --resize"#})
                    .action(ArgAction::SetTrue)
                    .requires("resize"),

                #[cfg(feature = "resize")]
                arg!(--upscale "Upscale the image(s) when resizing.")
                    .long_help(indoc! {r#"Upscale the image(s) when resizing.

                    This is useful when you want to reduce the size of the image when it is larger than the specified size.
                    It is recommended to use this option with --resize"#})
                    .default_value("true")
                    .action(ArgAction::SetTrue)
                    .requires("resize")
                    .overrides_with("no-upscale"),
                #[cfg(feature = "resize")]
                arg!(--"no-upscale" "Disable upscaling when resizing.")
                    .long_help(indoc! {r#"Disable upscaling when resizing.

                    This is useful when you don't want to reduce the size of the image when it is larger than the specified size.
                    It is recommended to use this option with --resize"#})
                    .action(ArgAction::SetTrue)
                    .requires("resize"),

                #[cfg(feature = "resize")]
                arg!(--filter <FILTER> "Filter that used when resizing an image.")
                    .value_parser(value_parser!(ResizeFilter))
                    .default_value("lanczos3")
                    .requires("resize"),

                #[cfg(feature = "quantization")]
                arg!(--quantization [QUALITY] "Enables quantization with optional quality.")
                    .long_help(indoc! {r#"Enables quantization with optional quality in percentage.

                    If quality is not provided, default 75 is used"#})
                    .value_parser(value_parser!(u8).range(1..=100))
                    .action(ArgAction::Append)
                    .default_missing_value("75"),

                #[cfg(feature = "quantization")]
                arg!(--dithering [QUALITY] "Enables dithering with optional quality.")
                    .long_help(indoc! {r#"Enables dithering with optional quality in percentage.

                    Used with --quantization flag.
                    If quality is not provided, default 75 is used."#})
                    .value_parser(value_parser!(u8).range(1..=100))
                    .default_missing_value("75")
                    .requires("quantization"),

                position_sensitive_flag(arg!(--premultiply "Premultiply alpha before operation"))
                    .action(ArgAction::Append)
            ])
    }
}

fn position_sensitive_flag(arg: Arg) -> Arg {
    // Flags don't track the position of each occurrence, so we need to emulate flags with
    // value-less options to get the same result
    arg.num_args(0)
        .value_parser(value_parser!(bool))
        .default_missing_value("true")
        .default_value("false")
}

pub trait Preprocessors {
    fn preprocessors(self) -> Self;
}