feat(cli): added base preprocessors

Cargo.toml

@@ -19,5 +19,6 @@ codegen-units = 1
 opt-level = "z"
 
 [dependencies]
+anyhow = "1.0.80"
 clap = { version = "4.5.1", features = ["cargo", "string"] }
 indoc = "2.0.4"

src/cli.rs

@@ -3,10 +3,10 @@ use std::path::PathBuf;
 use clap::{arg, command, value_parser, Command};
 use indoc::indoc;
 
-use crate::utils::threads;
+use crate::{preprocessors::preprocessors, utils::threads};
 
 pub fn cli() -> Command {
- command!()
+ let cmd = command!()
  .arg_required_else_help(true)
  .arg(
  arg!([FILES] ... "Input file(s) to process")
@@ -51,7 +51,9 @@ pub fn cli() -> Command {
  Usage of multiple threads can speed up the execution of tasks, especially on multi-core processors.
  By default, the number of available threads is utilized"})
  .value_parser(value_parser!(u8).range(1..=threads::num_threads() as i64)),
- )
+ );
+
+ preprocessors(cmd)
 }
 
 #[cfg(test)]

src/main.rs

@@ -1,6 +1,7 @@
 use cli::cli;
 
 mod cli;
+mod preprocessors;
 mod utils;
 
 fn main() {

src/preprocessors/mod.rs

@@ -0,0 +1,48 @@
+use clap::{arg, value_parser, ArgGroup, Command};
+use indoc::indoc;
+
+use resize::ResizeValue;
+
+use crate::preprocessors::resize::ResizeFilter;
+
+mod resize;
+
+pub fn preprocessors(cmd: Command) -> Command {
+ cmd.group(ArgGroup::new("preprocessors").multiple(true))
+ .next_help_heading("Preprocessors")
+ .arg(
+ arg!(--resize <RESIZE> "Resize the image(s) according to the specified criteria")
+ .long_help(indoc! {"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 these dimensions
+ - 200x_: Adjust image dimensions while maintaining the aspect ratio based on the specified dimension"})
+ .value_parser(value_parser!(ResizeValue)),
+ )
+ .arg(
+ arg!(--filter <FILTER> "Filter that used when resizing an image")
+ .value_parser(value_parser!(ResizeFilter))
+ .default_value("lanczos3")
+ .requires("resize"),
+ )
+ .arg(
+ arg!(--quantization [QUALITY] "Enables quantization with optional quality")
+ .long_help(indoc! {"Enables quantization with optional quality
+
+ If quality is not provided default 75% quality is used"})
+ .value_parser(value_parser!(u8).range(1..=100))
+ .default_missing_value("75")
+ )
+ .arg(
+ arg!(--dithering [QUALITY] "Enables dithering with optional quality")
+ .long_help(indoc! {"Enables dithering with optional quality
+
+ Used with --quantization flag.
+ If quality is not provided default 75% quality is used"})
+ .value_parser(value_parser!(u8).range(1..=100))
+ .default_missing_value("75")
+ .requires("quantization")
+ )
+}

src/preprocessors/resize/filter.rs

@@ -0,0 +1,58 @@
+use anyhow::anyhow;
+use clap::{builder::PossibleValue, ValueEnum};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ResizeFilter {
+ Box,
+ Bilinear,
+ Hamming,
+ CatmullRom,
+ Mitchell,
+ Lanczos3,
+}
+
+impl ValueEnum for ResizeFilter {
+ fn value_variants<'a>() -> &'a [Self] {
+ &[
+ ResizeFilter::Box,
+ ResizeFilter::Bilinear,
+ ResizeFilter::Hamming,
+ ResizeFilter::CatmullRom,
+ ResizeFilter::Mitchell,
+ ResizeFilter::Lanczos3,
+ ]
+ }
+
+ fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
+ Some(match self {
+ ResizeFilter::Box => PossibleValue::new("box").help("Each pixel contributes equally to destination. For upscaling, like Nearest."),
+ ResizeFilter::Bilinear => PossibleValue::new("bilinear").help("Uses linear interpolation among contributing pixels for output"),
+ ResizeFilter::Hamming => PossibleValue::new("hamming").help("Provides quality akin to bicubic for downscaling, sharper than Bilinear, but not optimal for upscaling"),
+ ResizeFilter::CatmullRom => PossibleValue::new("catmull-rom").help("Employs cubic interpolation for output pixel calculation"),
+ ResizeFilter::Mitchell => PossibleValue::new("mitchell").help("Utilizes cubic interpolation for output pixel calculation"),
+ ResizeFilter::Lanczos3 => PossibleValue::new("lanczos3").help("Applies high-quality Lanczos filter for output pixel calculation"),
+ })
+ }
+}
+
+impl std::fmt::Display for ResizeFilter {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ self.to_possible_value()
+ .expect("no values are skipped")
+ .get_name()
+ .fmt(f)
+ }
+}
+
+impl std::str::FromStr for ResizeFilter {
+ type Err = anyhow::Error;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ for variant in Self::value_variants() {
+ if variant.to_possible_value().unwrap().matches(s, false) {
+ return Ok(*variant);
+ }
+ }
+ Err(anyhow!("invalid variant: {s}"))
+ }
+}

src/preprocessors/resize/mod.rs

@@ -0,0 +1,5 @@
+mod filter;
+mod value;
+
+pub use filter::ResizeFilter;
+pub use value::ResizeValue;

src/preprocessors/resize/value.rs

@@ -0,0 +1,156 @@
+use anyhow::anyhow;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ResizeValue {
+ Multiplier(f32),
+ Percentage(f32),
+ Dimensions(Option<u32>, Option<u32>),
+}
+
+impl std::fmt::Display for ResizeValue {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ ResizeValue::Multiplier(multiplier) => f.write_fmt(format_args!("@{multiplier}")),
+ ResizeValue::Percentage(percentage) => f.write_fmt(format_args!("{percentage}%")),
+ ResizeValue::Dimensions(Some(width), Some(height)) => {
+ f.write_fmt(format_args!("{width}x{height}"))
+ }
+ ResizeValue::Dimensions(Some(width), None) => f.write_fmt(format_args!("{width}x_")),
+ ResizeValue::Dimensions(None, Some(height)) => f.write_fmt(format_args!("_x{height}")),
+ ResizeValue::Dimensions(None, None) => f.write_fmt(format_args!("base")),
+ }
+ }
+}
+
+impl std::str::FromStr for ResizeValue {
+ type Err = anyhow::Error;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ match s {
+ s if s.starts_with('@') => Ok(Self::Multiplier(s[1..].parse()?)),
+ s if s.ends_with('%') => Ok(Self::Percentage(s[..s.len() - 1].parse()?)),
+ s if s.contains('x') => {
+ let dimensions: Vec<&str> = s.split('x').collect();
+ if dimensions.len() > 2 {
+ return Err(anyhow!("There is more that 2 dimensions"));
+ }
+
+ let width = if dimensions[0] == "_" {
+ None
+ } else {
+ Some(dimensions[0].parse::<u32>()?)
+ };
+
+ let height = if dimensions[1] == "_" {
+ None
+ } else {
+ Some(dimensions[1].parse::<u32>()?)
+ };
+
+ Ok(Self::Dimensions(width, height))
+ }
+ _ => Err(anyhow!("Invalid resize value")),
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn display() {
+ assert_eq!(ResizeValue::Multiplier(2.).to_string(), "@2");
+ assert_eq!(ResizeValue::Multiplier(1.5).to_string(), "@1.5");
+
+ assert_eq!(ResizeValue::Percentage(200.).to_string(), "200%");
+ assert_eq!(ResizeValue::Percentage(150.).to_string(), "150%");
+
+ assert_eq!(
+ ResizeValue::Dimensions(Some(200), Some(200)).to_string(),
+ "200x200"
+ );
+ assert_eq!(
+ ResizeValue::Dimensions(Some(150), Some(150)).to_string(),
+ "150x150"
+ );
+
+ assert_eq!(
+ ResizeValue::Dimensions(None, Some(200)).to_string(),
+ "_x200"
+ );
+ assert_eq!(
+ ResizeValue::Dimensions(None, Some(150)).to_string(),
+ "_x150"
+ );
+
+ assert_eq!(
+ ResizeValue::Dimensions(Some(200), None).to_string(),
+ "200x_"
+ );
+ assert_eq!(
+ ResizeValue::Dimensions(Some(150), None).to_string(),
+ "150x_"
+ );
+
+ assert_eq!(ResizeValue::Dimensions(None, None).to_string(), "base");
+ }
+
+ #[test]
+ fn from_str() {
+ assert_eq!(
+ "@2".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Multiplier(2.)
+ );
+
+ assert_eq!(
+ "@1.5".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Multiplier(1.5)
+ );
+
+ assert_eq!(
+ "200%".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Percentage(200.)
+ );
+
+ assert_eq!(
+ "150%".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Percentage(150.)
+ );
+
+ assert_eq!(
+ "200x200".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Dimensions(Some(200), Some(200))
+ );
+
+ assert_eq!(
+ "150x150".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Dimensions(Some(150), Some(150))
+ );
+
+ assert_eq!(
+ "200x_".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Dimensions(Some(200), None)
+ );
+
+ assert_eq!(
+ "150x_".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Dimensions(Some(150), None)
+ );
+
+ assert_eq!(
+ "_x200".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Dimensions(None, Some(200))
+ );
+
+ assert_eq!(
+ "_x150".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Dimensions(None, Some(150))
+ );
+
+ assert_eq!(
+ "_x_".parse::<ResizeValue>().unwrap(),
+ ResizeValue::Dimensions(None, None)
+ );
+ }
+}