mirror of
https://github.com/waveplate/img2irc.git
synced 2025-04-04 20:08:24 +00:00
Compare commits
12 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
3577cf95a2 | ||
|
|
148f809623 | ||
|
|
ed8866abe2 | ||
|
|
fb61052438 | ||
|
|
2dfac15db6 | ||
|
|
f146a613e6 | ||
|
|
7cadbf8aad | ||
|
|
bb0ba0e990 | ||
|
|
34f2a1ef13 | ||
|
|
703000e68a | ||
|
|
492079af6c | ||
|
|
4c1d23f365 |
@ -1,3 +0,0 @@
|
||||
[target.x86_64-unknown-linux-musl]
|
||||
linker = "musl-gcc"
|
||||
|
||||
13
Cargo.toml
13
Cargo.toml
@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "img2irc-rs"
|
||||
version = "1.0.6"
|
||||
version = "1.1.0"
|
||||
authors = ["waveplate"]
|
||||
github = "https://github.com/waveplate/img2irc"
|
||||
repository = "https://github.com/waveplate/img2irc"
|
||||
@ -15,16 +15,21 @@ codegen-units = 1
|
||||
opt-level = "z"
|
||||
strip = true # Automatically strip symbols from the binary.
|
||||
|
||||
[target.x86_64-unknown-linux-musl]
|
||||
linker = "musl-gcc"
|
||||
|
||||
[[bin]]
|
||||
name = "img2irc"
|
||||
path = "src/main.rs"
|
||||
|
||||
[dependencies]
|
||||
tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros"] }
|
||||
reqwest = { version = "0.11.14", default-features = false, features = ["rustls-tls"] }
|
||||
reqwest = "0.11.14"
|
||||
photon-rs = { version = "0.3.2", default-features = false, git = "https://github.com/silvia-odwyer/photon", rev = "3b72d357848cd76be9363e87ad0cd02a19b988d2" }
|
||||
#photon-rs = "0.3.2"
|
||||
clap = { version = "4.2.0", features = ["cargo", "derive"] }
|
||||
url = "2.3.1"
|
||||
atty = "0.2.14"
|
||||
|
||||
[build-dependencies]
|
||||
cc = "1.0"
|
||||
[target.'cfg(target_env = "musl")'.dependencies]
|
||||
openssl = { version = "0.10", features = ["vendored"] }
|
||||
|
||||
155
README.md
155
README.md
@ -1,13 +1,9 @@
|
||||
# img2irc (1.0.6)
|
||||
|
||||
# img2irc (1.1.0)
|
||||
|
||||
img2irc is a utility which converts images to half or quarterblock irc/ansi art, with a lot of post-processing filters
|
||||
|
||||
|
||||
|
||||
*halfblock* means that each row will contain two rows worth of pixels, effectively doubling the vertical resolution
|
||||
|
||||
*quarterblock* (experimental) means that each row will contain two rows worth of pixels, and each column will contain two columns worth of pixels, quadrupling the resolution
|
||||
|
||||
the `irc` mode has 99 colours, the `ansi` mode has 256, `ansi24` has 16777216
|
||||
*img2irc* is a premiere command-line utility which converts images to irc/ansi art, with a lot of post-processing filters
|
||||
|
||||
# how to install
|
||||
|
||||
@ -16,18 +12,18 @@ the `irc` mode has 99 colours, the `ansi` mode has 256, `ansi24` has 16777216
|
||||
statically linked with musl, works on all x86_64 linux platforms
|
||||
|
||||
cd /tmp
|
||||
wget https://github.com/waveplate/img2irc/releases/download/v1.0.4/img2irc-1.0.4-linux-x86_64.tar.gz
|
||||
sudo tar -xzf img2irc-1.0.4-linux-x86_64.tar.gz -C /usr/local/bin --strip-components=1 img2irc-1.0.4/img2irc
|
||||
rm -rf img2irc-1.0.4-linux-x86_64.tar.gz
|
||||
wget https://github.com/waveplate/img2irc/releases/download/v1.1.0/img2irc-1.1.0-linux-x86_64.tar.gz
|
||||
sudo tar -xzf img2irc-1.1.0-linux-x86_64.tar.gz -C /usr/local/bin --strip-components=1 img2irc-1.1.0/img2irc
|
||||
rm -rf img2irc-1.1.0-linux-x86_64.tar.gz
|
||||
|
||||
|
||||
- ### install with `yay` (arch linux)
|
||||
|
||||
>[!NOTE]
|
||||
>if you like this project, i would appreciate you giving it a vote on the [aur](https://aur.archlinux.org/packages/img2irc)!
|
||||
|
||||
yay -S img2irc
|
||||
|
||||
> [!NOTE]
|
||||
> if you like this project, i would appreciate you giving it a vote on the [aur](https://aur.archlinux.org/packages/img2irc)!
|
||||
|
||||
- ### install with `cargo`
|
||||
|
||||
cargo install img2irc-rs
|
||||
@ -38,46 +34,91 @@ the `irc` mode has 99 colours, the `ansi` mode has 256, `ansi24` has 16777216
|
||||
|
||||
`img2irc <URL or PATH> [OPTIONS]`
|
||||
|
||||
| option | description | default value |
|
||||
| ------ | ----------- | ------------- |
|
||||
| `<IMAGE>` | image url or file path | none |
|
||||
| `--irc` | irc render type | true |
|
||||
| `--ansi` | 8-bit ansi render type | false |
|
||||
| `--ansi24` | 24-bit ansi render type | false |
|
||||
| `--qb` | use quarterblocks (experimental) | false |
|
||||
| `-w, --width <WIDTH>` | output image width in columns | 50 |
|
||||
| `-b, --brightness=<BRIGHTNESS>` | adjust brightness (-255 to 255) | 0 |
|
||||
| `-c, --contrast=<CONTRAST>` | adjust contrast (-255 to 255) | 0 |
|
||||
| `-s, --saturation=<SATURATION>` | adjust saturation (-255 to 255) | 0 |
|
||||
| `-H, --hue <HUE>` | rotate hue (0 to 360) | 0 |
|
||||
| `-g, --gamma <GAMMA>` | adjust gamma (0 to 255) | 0 |
|
||||
| `--dither <DITHER>` | dithering (1 to 8) | 0 |
|
||||
| `--pixelize <PIXELIZE>` | pixelize pixel size | 0 |
|
||||
| `--gaussian-blur <GAUSSIAN_BLUR>` | gaussian blur radius | 0 |
|
||||
| `--oil <OIL>` | oil ("[RADIUS],[INTENSITY]") | |
|
||||
| `--grayscale` | converts image to black and white |
|
||||
| `--nograyscale` | exclude grayscale colours from the palette |
|
||||
| `--halftone` | made up of small dots creating a continuous-tone illusion |
|
||||
| `--sepia` | brownish, aged appearance like old photographs |
|
||||
| `--normalize` | adjusts brightness and contrast for better image quality |
|
||||
| `--noise` | random variations in brightness and color like film grain |
|
||||
| `--emboss` | gives a raised, 3d appearance |
|
||||
| `--box-blur` | smoothed appearance like frosted glass |
|
||||
| `--identity` | no modifications, unchanged image |
|
||||
| `--laplace` | enhances edges and boundaries in an image |
|
||||
| `--noise-reduction` | reduces noise for a cleaner, clearer image |
|
||||
| `--sharpen` | increases clarity and definition, making edges and details more distinct |
|
||||
| `--cali` | cool blue tone with increased contrast |
|
||||
| `--dramatic` | high contrast and vivid colors for a dramatic effect |
|
||||
| `--firenze` | warm, earthy tones reminiscent of tuscan landscapes |
|
||||
| `--golden` | warm, golden glow like sunset light |
|
||||
| `--lix` | high-contrast black and white appearance with increased sharpness |
|
||||
| `--lofi` | low-fidelity, retro appearance like old photographs or film |
|
||||
| `--neue` | clean, modern appearance with neutral colors and simple design |
|
||||
| `--obsidian` | dark, monochromatic appearance with black and gray shades |
|
||||
| `--pastel-pink` | soft, delicate pink tint like pastel colors |
|
||||
| `--ryo` | bright, high-contrast appearance with vivid colors and sharp details |
|
||||
| `--invert` | colors are inverted, opposite on the color wheel |
|
||||
| `--frosted-glass` | blurred, frosted appearance as if viewed through semi-transparent surface |
|
||||
| `--solarize` | strange, otherworldly appearance with inverted colors and surreal atmosphere |
|
||||
| `--edge-detection` | highlights edges and boundaries in an image |
|
||||
| option | description | default value |
|
||||
|----------------------------------------|---------------------------------------------------------------|---------------|
|
||||
| image | image url or file path | required |
|
||||
| -w, --width | output image width in columns | auto |
|
||||
| -h, --height | output image height in rows | auto |
|
||||
| --scale | scaling factors (x:y, e.g., "2:2") | none |
|
||||
| --aspect | final aspect ratio (x:y, e.g., "2:1") | none |
|
||||
| --crop | crop image ("x1,y1,x2,y2") | none |
|
||||
| --filter | sampling filter | nearest |
|
||||
| --rotate | rotate degrees | 0 |
|
||||
| --fliph | flip horizontal | false |
|
||||
| --flipv | flip vertical | false |
|
||||
|
||||
### colours rendering options (select one)
|
||||
|
||||
`irc` mode has 99 colours, (6.62-bit)
|
||||
|
||||
`ansi` mode has 256 colours (8-bit)
|
||||
|
||||
`ansi24` has 16777216 colours (24-bit)
|
||||
|
||||
| option | description |
|
||||
|----------------------------------------|---------------------------------------------------------------|
|
||||
| --irc | use irc99 colours |
|
||||
| --ansi | use 8-bit ansi colours |
|
||||
| --ansi24 | use 24-bit ansi colours |
|
||||
|
||||
### pixel rendering options (select one)
|
||||
|
||||
`halfblock` mode increases the vertical resolution, doubling the total resolution for a given size
|
||||
|
||||
`quarterblock` mode increases both the vertical and horizontal resolution by twofold, quadrupling the total resolution for a given size
|
||||
|
||||
`braille` mode uses 2x4 dot patterns to represent pixels, increasing resolution eightfold
|
||||
|
||||
| option | description |
|
||||
|----------------------------------------|---------------------------------------------------------------|
|
||||
| --braille | use braille pixels |
|
||||
| --hb, --halfblock | use halfblock pixels |
|
||||
| --qb, --quarterblock | use quarterblocks pixels |
|
||||
|
||||
### image processing options
|
||||
|
||||
| option | description | default value |
|
||||
|----------------------------------------|---------------------------------------------------------------|---------------|
|
||||
| -b, --brightness | adjust brightness (0 = no change) | 0.0 |
|
||||
| -c, --contrast | adjust contrast (0 = no change) | 0.0 |
|
||||
| -g, --gamma | adjust gamma (0 to 255) | 0.0 |
|
||||
| -s, --saturation | adjust saturation (0 = no change) | 0.0 |
|
||||
| -u, --hue | rotate hue (0 to 360) | 0.0 |
|
||||
| -i, --invert | colors are inverted, opposite on the color wheel | false |
|
||||
| -d, --dither | dithering (1 to 8) | 0 |
|
||||
| -B, --luma-brightness | adjust luma brightness (braille only) | 0.0 |
|
||||
| -C, --luma-contrast | adjust luma contrast (braille only) | 0.0 |
|
||||
| -G, --luma-gamma | adjust luma gamma (braille only) | 0.0 |
|
||||
| -S, --luma-saturation | adjust luma saturation (braille only) | 0.0 |
|
||||
| -I, --luma-invert | luminance is inverted (braille only) | false |
|
||||
| --colorspace | colourspace (hsl, hsv, hsluv, lch) | hsv |
|
||||
| --grayscale | converts image to black and white | false |
|
||||
| --nograyscale | exclude grayscale colours from the palette | false |
|
||||
| --pixelize | pixelize pixel size | 0 |
|
||||
| --boxblur | simple average of all the neighboring pixels surrounding one | false |
|
||||
| --gaussianblur | gaussian blur radius | 0 |
|
||||
| --oil | oil filter ("[radius],[intensity]") | none |
|
||||
| --halftone | made up of small dots creating a continuous-tone illusion | false |
|
||||
| --sepia | brownish, aged appearance like old photographs | false |
|
||||
| --normalize | adjusts brightness and contrast for better image quality | false |
|
||||
| --noise | random variations in brightness and color like film grain | false |
|
||||
| --emboss | gives a raised, 3d appearance | false |
|
||||
| --identity | no modifications, unchanged image | false |
|
||||
| --laplace | enhances edges and boundaries in an image | false |
|
||||
| --denoise | reduces noise for a cleaner, clearer image | false |
|
||||
| --sharpen | increases clarity and definition, making edges and details more distinct | false |
|
||||
| --cali | cool blue tone with increased contrast | false |
|
||||
| --dramatic | high contrast and vivid colors for a dramatic effect | false |
|
||||
| --firenze | warm, earthy tones reminiscent of tuscan landscapes | false |
|
||||
| --golden | warm, golden glow like sunset light | false |
|
||||
| --lix | high-contrast black and white appearance with increased sharpness | false |
|
||||
| --lofi | low-fidelity, retro appearance like old photographs or film | false |
|
||||
| --neue | clean, modern appearance with neutral colors and simple design | false |
|
||||
| --obsidian | dark, monochromatic appearance with black and gray shades | false |
|
||||
| --pastelpink | soft, delicate pink tint like pastel colors | false |
|
||||
| --ryo | bright, high-contrast appearance with vivid colors and sharp details | false |
|
||||
| --frostedglass | blurred, frosted appearance as if viewed through semi-transparent surface | false |
|
||||
| --solarize | strange, otherworldly appearance with inverted colors and surreal atmosphere | false |
|
||||
| --edgedetection | highlights edges and boundaries in an image | false |
|
||||
|
||||
|
||||
|
||||
275
src/args.rs
275
src/args.rs
@ -1,173 +1,300 @@
|
||||
use clap::Parser;
|
||||
|
||||
#[derive(Parser, Debug)]
|
||||
#[derive(clap::ValueEnum, Clone, Debug)]
|
||||
pub enum SamplingFilter {
|
||||
Nearest,
|
||||
Triangle,
|
||||
CatmullRom,
|
||||
Gaussian,
|
||||
Lanczos3,
|
||||
}
|
||||
|
||||
#[derive(clap::ValueEnum, Clone, Debug)]
|
||||
pub enum ColourSpace {
|
||||
HSL,
|
||||
HSV,
|
||||
HSLUV,
|
||||
LCH,
|
||||
}
|
||||
|
||||
#[derive(Parser, Clone, Debug)]
|
||||
#[command(author, version, about, long_about = None)]
|
||||
pub struct Args {
|
||||
/// image url or file path
|
||||
#[arg(index = 1)]
|
||||
pub image: String,
|
||||
|
||||
/// irc
|
||||
/// output image width in columns
|
||||
#[arg(short, long)]
|
||||
pub width: Option<u32>,
|
||||
|
||||
/// output image height in rows
|
||||
#[arg(short, long)]
|
||||
pub height: Option<u32>,
|
||||
|
||||
/// scaling factors (x:y, e.g., "2:2")
|
||||
#[arg(long, value_parser = parse_xy_pair)]
|
||||
pub scale: Option<(f32, f32)>,
|
||||
|
||||
/// final aspect ratio (x:y, e.g., "2:1")
|
||||
#[arg(long, value_parser = parse_xy_pair)]
|
||||
pub aspect: Option<(f32, f32)>,
|
||||
|
||||
/// crop image (x1,y1,x2,y2)
|
||||
#[arg(long, value_parser = parse_crop_coordinates)]
|
||||
pub crop: Option<(u32, u32, u32, u32)>,
|
||||
|
||||
/// sampling filter
|
||||
#[arg(long, value_enum, default_value_t = SamplingFilter::Nearest)]
|
||||
pub filter: SamplingFilter,
|
||||
|
||||
/// rotate degrees
|
||||
#[arg(long, default_value_t = 0)]
|
||||
pub rotate: i32,
|
||||
|
||||
/// flip horizontal
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub fliph: bool,
|
||||
|
||||
/// flip vertical
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub flipv: bool,
|
||||
|
||||
/// use IRC99 colours
|
||||
#[arg(long, default_value_t = false, group = "colour", required_unless_present_any = ["ansi", "ansi24"])]
|
||||
pub irc: bool,
|
||||
|
||||
/// 8-bit ansi
|
||||
#[arg(long, default_value_t = false)]
|
||||
/// use 8-bit ANSI colours
|
||||
#[arg(long, default_value_t = false, group = "colour", required_unless_present_any = ["irc", "ansi24"])]
|
||||
pub ansi: bool,
|
||||
|
||||
/// 24-bit ansi
|
||||
#[arg(long, default_value_t = false)]
|
||||
/// use 24-bit ANSI colours
|
||||
#[arg(long, default_value_t = false, group = "colour", required_unless_present_any = ["irc", "ansi"])]
|
||||
pub ansi24: bool,
|
||||
|
||||
/// quarterblock
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub qb: bool,
|
||||
/// use braille pixels
|
||||
#[arg(long, default_value_t = false, group = "pixel")]
|
||||
pub braille: bool,
|
||||
|
||||
/// image width to resize to
|
||||
#[arg(short, long, default_value_t = 50)]
|
||||
pub width: u32,
|
||||
/// use halfblock pixels
|
||||
#[arg(long, alias = "halfblock", default_value_t = true, group = "pixel")]
|
||||
pub hb: bool,
|
||||
|
||||
/// brightness (-255 to 255)
|
||||
#[arg(short, long, require_equals = true, default_value_t = 0.0)]
|
||||
/// use quarterblocks pixels
|
||||
#[arg(long, alias = "quarterblock", default_value_t = false, group = "pixel")]
|
||||
pub qb: bool,
|
||||
|
||||
/// adjust brightness (0 = no change)
|
||||
#[arg(short = 'b', long, default_value_t = 0.0, allow_hyphen_values = true)]
|
||||
pub brightness: f32,
|
||||
|
||||
/// contrast (-255 to 255)
|
||||
#[arg(short, long, require_equals = true, default_value_t = 0.0)]
|
||||
/// adjust contrast (0 = no change)
|
||||
#[arg(short = 'c', long, default_value_t = 0.0, allow_hyphen_values = true)]
|
||||
pub contrast: f32,
|
||||
|
||||
/// saturation (-255 to 255)
|
||||
#[arg(short, long, require_equals = true, default_value_t = 0.0)]
|
||||
pub saturation: f32,
|
||||
|
||||
/// hue (0 to 360)
|
||||
#[arg(short = 'H', long, default_value_t = 0.0)]
|
||||
pub hue: f32,
|
||||
|
||||
/// gamma (0 to 255)
|
||||
#[arg(short, long, default_value_t = 0.0)]
|
||||
/// adjust gamma (0 to 255)
|
||||
#[arg(short = 'g', long, default_value_t = 0.0, allow_hyphen_values = true)]
|
||||
pub gamma: f32,
|
||||
|
||||
/// dither (1 to 8)
|
||||
#[arg(long, default_value_t = 0)]
|
||||
/// adjust saturation (0 = no change)
|
||||
#[arg(short = 's', long, default_value_t = 0.0, allow_hyphen_values = true)]
|
||||
pub saturation: f32,
|
||||
|
||||
/// rotate hue (0 to 360)
|
||||
#[arg(short = 'u', long, default_value_t = 0.0)]
|
||||
pub hue: f32,
|
||||
|
||||
/// colors are inverted, opposite on the color wheel
|
||||
#[arg(short = 'i', long, default_value_t = false)]
|
||||
pub invert: bool,
|
||||
|
||||
/// dithering (1 to 8)
|
||||
#[arg(long, short = 'd', long, default_value_t = 0)]
|
||||
pub dither: u32,
|
||||
|
||||
/// pixelize size
|
||||
/// adjust luma brightness (braille only)
|
||||
#[arg(short = 'B', long, default_value_t = 0.0, allow_hyphen_values = true, requires = "braille")]
|
||||
pub luma_brightness: f32,
|
||||
|
||||
/// adjust luma contrast (braille only)
|
||||
#[arg(short = 'C', long, default_value_t = 0.0, allow_hyphen_values = true, requires = "braille")]
|
||||
pub luma_contrast: f32,
|
||||
|
||||
/// adjust luma gamma (braille only)
|
||||
#[arg(short = 'G', long, default_value_t = 0.0, allow_hyphen_values = true, requires = "braille")]
|
||||
pub luma_gamma: f32,
|
||||
|
||||
/// adjust luma saturation (braille only)
|
||||
#[arg(short = 'S', long, default_value_t = 0.0, allow_hyphen_values = true, requires = "braille")]
|
||||
pub luma_saturation: f32,
|
||||
|
||||
/// luminance is inverted
|
||||
#[arg(short = 'I', long, default_value_t = false, requires = "braille")]
|
||||
pub luma_invert: bool,
|
||||
|
||||
/// colour space
|
||||
#[arg(long, value_enum, default_value_t = ColourSpace::HSV)]
|
||||
pub colorspace: ColourSpace,
|
||||
|
||||
/// converts image to black and white
|
||||
#[arg(long, default_value_t = false, group = "grayscale_opts")]
|
||||
pub grayscale: bool,
|
||||
|
||||
/// exclude grayscale colours from the palette
|
||||
#[arg(long, default_value_t = false, group = "grayscale_opts")]
|
||||
pub nograyscale: bool,
|
||||
|
||||
/// pixelize pixel size
|
||||
#[arg(long, default_value_t = 0)]
|
||||
pub pixelize: i32,
|
||||
|
||||
/// simple average of all the neighboring pixels surrounding a given pixel
|
||||
#[arg(long="boxblur", default_value_t = false)]
|
||||
pub box_blur: bool,
|
||||
|
||||
/// gaussian blur radius
|
||||
#[arg(long, default_value_t = 0)]
|
||||
#[arg(long="gaussianblur", default_value_t = 0)]
|
||||
pub gaussian_blur: i32,
|
||||
|
||||
/// oil ("<radius>,<intensity>")
|
||||
/// oil filter ("[radius],[intensity]")
|
||||
#[arg(long)]
|
||||
pub oil: Option<String>,
|
||||
|
||||
/// grayscale
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub grayscale: bool,
|
||||
|
||||
/// no grayscale
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub nograyscale: bool,
|
||||
|
||||
/// halftone
|
||||
/// made up of small dots creating a continuous-tone illusion
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub halftone: bool,
|
||||
|
||||
/// sepia
|
||||
/// brownish, aged appearance like old photographs
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub sepia: bool,
|
||||
|
||||
/// normalize
|
||||
/// adjusts brightness and contrast for better image quality
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub normalize: bool,
|
||||
|
||||
/// noise
|
||||
/// random variations in brightness and color like film grain
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub noise: bool,
|
||||
|
||||
/// emboss
|
||||
/// gives a raised, 3d appearance
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub emboss: bool,
|
||||
|
||||
/// box_blur
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub box_blur: bool,
|
||||
|
||||
/// identity
|
||||
/// no modifications, unchanged image
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub identity: bool,
|
||||
|
||||
/// laplace
|
||||
/// enhances edges and boundaries in an image
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub laplace: bool,
|
||||
|
||||
/// noise reduction
|
||||
#[arg(long, default_value_t = false)]
|
||||
/// reduces noise for a cleaner, clearer image
|
||||
#[arg(long="denoise", default_value_t = false)]
|
||||
pub noise_reduction: bool,
|
||||
|
||||
/// sharpen
|
||||
/// increases clarity and definition, making edges and details more distinct
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub sharpen: bool,
|
||||
|
||||
/// cali
|
||||
/// cool blue tone with increased contrast
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub cali: bool,
|
||||
|
||||
/// dramatic
|
||||
/// high contrast and vivid colors for a dramatic effect
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub dramatic: bool,
|
||||
|
||||
/// firenze
|
||||
/// warm, earthy tones reminiscent of tuscan landscapes
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub firenze: bool,
|
||||
|
||||
/// golden
|
||||
/// warm, golden glow like sunset light
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub golden: bool,
|
||||
|
||||
/// lix
|
||||
/// high-contrast black and white appearance with increased sharpness
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub lix: bool,
|
||||
|
||||
/// lofi
|
||||
/// low-fidelity, retro appearance like old photographs or film
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub lofi: bool,
|
||||
|
||||
/// neue
|
||||
/// clean, modern appearance with neutral colors and simple design
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub neue: bool,
|
||||
|
||||
/// obsidian
|
||||
/// dark, monochromatic appearance with black and gray shades
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub obsidian: bool,
|
||||
|
||||
/// pastel_pink
|
||||
#[arg(long, default_value_t = false)]
|
||||
/// soft, delicate pink tint like pastel colors
|
||||
#[arg(long="pastelpink", default_value_t = false)]
|
||||
pub pastel_pink: bool,
|
||||
|
||||
/// ryo
|
||||
/// bright, high-contrast appearance with vivid colors and sharp details
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub ryo: bool,
|
||||
|
||||
/// invert
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub invert: bool,
|
||||
|
||||
/// frosted glass
|
||||
#[arg(long, default_value_t = false)]
|
||||
/// blurred, frosted appearance as if viewed through semi-transparent surface
|
||||
#[arg(long="frostedglass", default_value_t = false)]
|
||||
pub frosted_glass: bool,
|
||||
|
||||
/// solarize
|
||||
/// strange, otherworldly appearance with inverted colors and surreal atmosphere
|
||||
#[arg(long, default_value_t = false)]
|
||||
pub solarize: bool,
|
||||
|
||||
/// edge detection
|
||||
#[arg(long, default_value_t = false)]
|
||||
/// highlights edges and boundaries in an image
|
||||
#[arg(long="edgedetection", default_value_t = false)]
|
||||
pub edge_detection: bool,
|
||||
}
|
||||
|
||||
pub fn parse_args() -> Args {
|
||||
Args::parse()
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_xy_pair(s: &str) -> Result<(f32, f32), String> {
|
||||
let parts: Vec<&str> = s.split(':').collect();
|
||||
if parts.len() != 2 {
|
||||
return Err(format!(
|
||||
"Invalid format. Expected 'value1:value2', got '{}'",
|
||||
s
|
||||
));
|
||||
}
|
||||
|
||||
let first = parts[0].parse::<f32>().map_err(|e| {
|
||||
format!(
|
||||
"Failed to parse the first value ('{}') as f32: {}",
|
||||
parts[0], e
|
||||
)
|
||||
})?;
|
||||
let second = parts[1].parse::<f32>().map_err(|e| {
|
||||
format!(
|
||||
"Failed to parse the second value ('{}') as f32: {}",
|
||||
parts[1], e
|
||||
)
|
||||
})?;
|
||||
|
||||
if first <= 0.0 || second <= 0.0 {
|
||||
return Err("Both values must be positive numbers.".to_string());
|
||||
}
|
||||
|
||||
Ok((first, second))
|
||||
}
|
||||
|
||||
fn parse_crop_coordinates(s: &str) -> Result<(u32, u32, u32, u32), String> {
|
||||
let coords: Vec<&str> = s.split(',').collect();
|
||||
if coords.len() != 4 {
|
||||
return Err(format!(
|
||||
"Invalid crop format '{}'. Expected 'x1,y1,x2,y2' (e.g., '50,50,200,200').",
|
||||
s
|
||||
));
|
||||
}
|
||||
|
||||
let x1 = coords[0].parse::<u32>().map_err(|_| format!("Invalid x1 value '{}'.", coords[0]))?;
|
||||
let y1 = coords[1].parse::<u32>().map_err(|_| format!("Invalid y1 value '{}'.", coords[1]))?;
|
||||
let x2 = coords[2].parse::<u32>().map_err(|_| format!("Invalid x2 value '{}'.", coords[2]))?;
|
||||
let y2 = coords[3].parse::<u32>().map_err(|_| format!("Invalid y2 value '{}'.", coords[3]))?;
|
||||
|
||||
Ok((x1, y1, x2, y2))
|
||||
}
|
||||
|
||||
853
src/draw.rs
853
src/draw.rs
@ -1,45 +1,45 @@
|
||||
use crate::args;
|
||||
use crate::palette::{RGB99, RGB88, ANSI232, ANSI256, nearest_hex_color};
|
||||
use photon_rs::PhotonImage;
|
||||
use std::collections::HashMap;
|
||||
|
||||
// █ full
|
||||
const FULL: &str = "\u{2588}";
|
||||
|
||||
// ▄ down
|
||||
const UP: &str = "\u{2580}";
|
||||
|
||||
// ▀ up
|
||||
const DOWN: &str = "\u{2584}";
|
||||
static QUARTER_BLOCKS: [&str; 16] = [
|
||||
" ", // 0b0000
|
||||
"\u{2597}", // ▗ Quadrant lower right
|
||||
"\u{2596}", // ▖ Quadrant lower left
|
||||
"\u{2584}", // ▄ Lower half block
|
||||
"\u{259D}", // ▝ Quadrant upper right
|
||||
"\u{2590}", // ▐ Right half block
|
||||
"\u{259E}", // ▞ Quadrant upper right and lower left
|
||||
"\u{259F}", // ▟ Quadrant upper right, lower left, lower right
|
||||
"\u{2598}", // ▘ Quadrant upper left
|
||||
"\u{259A}", // ▚ Quadrant upper left and lower right
|
||||
"\u{258C}", // ▌ Left half block
|
||||
"\u{2599}", // ▙ Quadrant upper left, lower left, lower right
|
||||
"\u{2580}", // ▀ Upper half block
|
||||
"\u{259C}", // ▜ Quadrant upper left, upper right, lower right
|
||||
"\u{259B}", // ▛ Quadrant upper left, upper right, lower left
|
||||
"\u{2588}", // █ Full block
|
||||
];
|
||||
|
||||
// ▌ left
|
||||
const LEFT: &str = "\u{258C}";
|
||||
|
||||
// ▐ right
|
||||
const RIGHT: &str = "\u{2590}";
|
||||
|
||||
// ▞ diag_right
|
||||
const DIAG_RIGHT: &str = "\u{259E}";
|
||||
|
||||
// ▚ diag_left
|
||||
const DIAG_LEFT: &str = "\u{259A}";
|
||||
|
||||
// ▙ down_left (2596 prev)
|
||||
const DOWN_LEFT: &str = "\u{2599}";
|
||||
|
||||
// ▟ down_right
|
||||
const DOWN_RIGHT: &str = "\u{259F}";
|
||||
|
||||
// ▛ top_left
|
||||
const UP_LEFT: &str = "\u{259B}";
|
||||
|
||||
// ▜ top_right
|
||||
const UP_RIGHT: &str = "\u{259C}";
|
||||
const POSITIONS: [(usize, usize, u32); 8] = [
|
||||
(0, 0, 0x01), // dot 1
|
||||
(0, 1, 0x02), // dot 2
|
||||
(0, 2, 0x04), // dot 3
|
||||
(1, 0, 0x08), // dot 4
|
||||
(1, 1, 0x10), // dot 5
|
||||
(1, 2, 0x20), // dot 6
|
||||
(0, 3, 0x40), // dot 7
|
||||
(1, 3, 0x80), // dot 8
|
||||
];
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct AnsiImage {
|
||||
pub image: PhotonImage,
|
||||
pub bitmap: Vec<Vec<u32>>,
|
||||
pub halfblock: Vec<Vec<AnsiPixelPair>>,
|
||||
pub quarterblock: Vec<Vec<AnsiPixelQuad>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
@ -57,6 +57,14 @@ pub struct AnsiPixel {
|
||||
pub irc88: u8,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct AnsiPixelQuad {
|
||||
pub top_left: AnsiPixel,
|
||||
pub top_right: AnsiPixel,
|
||||
pub bottom_left: AnsiPixel,
|
||||
pub bottom_right: AnsiPixel,
|
||||
}
|
||||
|
||||
impl AnsiPixel {
|
||||
pub fn new(pixel: &u32) -> AnsiPixel {
|
||||
let irc = nearest_hex_color(*pixel, RGB99.to_vec());
|
||||
@ -65,17 +73,18 @@ impl AnsiPixel {
|
||||
let ansi232 = nearest_hex_color(*pixel, ANSI232.to_vec());
|
||||
AnsiPixel {
|
||||
orig: *pixel,
|
||||
ansi: ansi,
|
||||
ansi232: ansi232,
|
||||
irc: irc,
|
||||
irc88: irc88,
|
||||
ansi,
|
||||
ansi232,
|
||||
irc,
|
||||
irc88,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl AnsiImage {
|
||||
pub fn new(image: PhotonImage) -> AnsiImage {
|
||||
let mut bitmap = image.get_raw_pixels()
|
||||
let mut bitmap = image
|
||||
.get_raw_pixels()
|
||||
.chunks(4)
|
||||
.map(|x| make_rgb_u32(x.to_vec()))
|
||||
.collect::<Vec<u32>>()
|
||||
@ -87,12 +96,19 @@ impl AnsiImage {
|
||||
bitmap.push(vec![0; image.get_width() as usize]);
|
||||
}
|
||||
|
||||
for row in &mut bitmap {
|
||||
if row.len() % 2 != 0 {
|
||||
row.push(0);
|
||||
}
|
||||
}
|
||||
|
||||
let halfblock = halfblock_bitmap(&bitmap);
|
||||
|
||||
return AnsiImage {
|
||||
image: image,
|
||||
bitmap: bitmap,
|
||||
halfblock: halfblock,
|
||||
let quarterblock = quarterblock_bitmap(&bitmap);
|
||||
|
||||
AnsiImage {
|
||||
bitmap,
|
||||
halfblock,
|
||||
quarterblock,
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -102,39 +118,72 @@ pub fn make_rgb_u8(rgb: u32) -> [u8; 3] {
|
||||
let g = (rgb >> 8) as u8;
|
||||
let b = rgb as u8;
|
||||
|
||||
return [r, g, b]
|
||||
[r, g, b]
|
||||
}
|
||||
|
||||
pub fn make_rgb_u32(rgb: Vec<u8>) -> u32 {
|
||||
let r = *rgb.get(0).unwrap() as u32;
|
||||
let g = *rgb.get(1).unwrap() as u32;
|
||||
let b = *rgb.get(2).unwrap() as u32;
|
||||
let r = rgb[0] as u32;
|
||||
let g = rgb[1] as u32;
|
||||
let b = rgb[2] as u32;
|
||||
|
||||
let rgb = (r << 16) + (g << 8) + b;
|
||||
(r << 16) + (g << 8) + b
|
||||
}
|
||||
|
||||
return rgb
|
||||
pub fn quarterblock_bitmap(bitmap: &Vec<Vec<u32>>) -> Vec<Vec<AnsiPixelQuad>> {
|
||||
let ansi_bitmap = bitmap
|
||||
.iter()
|
||||
.map(|x| x.iter().map(|y| AnsiPixel::new(y)).collect::<Vec<AnsiPixel>>())
|
||||
.collect::<Vec<Vec<AnsiPixel>>>();
|
||||
|
||||
let mut ansi_canvas: Vec<Vec<AnsiPixelQuad>> = Vec::new();
|
||||
|
||||
for two_rows in ansi_bitmap.chunks(2) {
|
||||
let top_row = &two_rows[0];
|
||||
let bottom_row = &two_rows[1];
|
||||
|
||||
let mut ansi_row: Vec<AnsiPixelQuad> = Vec::new();
|
||||
|
||||
for i in (0..top_row.len()).step_by(2) {
|
||||
let default_pixel = AnsiPixel::new(&0);
|
||||
let top_left_pixel = top_row.get(i).unwrap_or(&default_pixel);
|
||||
let top_right_pixel = top_row.get(i + 1).unwrap_or(&default_pixel);
|
||||
let bottom_left_pixel = bottom_row.get(i).unwrap_or(&default_pixel);
|
||||
let bottom_right_pixel = bottom_row.get(i + 1).unwrap_or(&default_pixel);
|
||||
|
||||
let pixel_quad = AnsiPixelQuad {
|
||||
top_left: *top_left_pixel,
|
||||
top_right: *top_right_pixel,
|
||||
bottom_left: *bottom_left_pixel,
|
||||
bottom_right: *bottom_right_pixel,
|
||||
};
|
||||
|
||||
ansi_row.push(pixel_quad);
|
||||
}
|
||||
|
||||
ansi_canvas.push(ansi_row);
|
||||
}
|
||||
|
||||
ansi_canvas
|
||||
}
|
||||
|
||||
pub fn halfblock_bitmap(bitmap: &Vec<Vec<u32>>) -> Vec<Vec<AnsiPixelPair>> {
|
||||
let ansi_bitmap = bitmap
|
||||
.iter()
|
||||
.map(|x| {
|
||||
x.iter().map(|y| AnsiPixel::new(y)).collect::<Vec<AnsiPixel>>()
|
||||
})
|
||||
.collect::<Vec<Vec<AnsiPixel>>>();
|
||||
.iter()
|
||||
.map(|x| x.iter().map(|y| AnsiPixel::new(y)).collect::<Vec<AnsiPixel>>())
|
||||
.collect::<Vec<Vec<AnsiPixel>>>();
|
||||
|
||||
let mut ansi_canvas: Vec<Vec<AnsiPixelPair>> = Vec::new();
|
||||
|
||||
for two_rows in ansi_bitmap.chunks(2) {
|
||||
let rows = two_rows.to_vec();
|
||||
let top_row = rows.get(0).unwrap();
|
||||
let bottom_row = rows.get(1).unwrap();
|
||||
let top_row = &two_rows[0];
|
||||
let bottom_row = &two_rows[1];
|
||||
|
||||
let mut ansi_row: Vec<AnsiPixelPair> = Vec::new();
|
||||
|
||||
for i in 0..bitmap.get(0).unwrap().len() {
|
||||
let top_pixel = top_row.get(i as usize).unwrap();
|
||||
let bottom_pixel = bottom_row.get(i as usize).unwrap();
|
||||
for i in 0..top_row.len() {
|
||||
let default_pixel = AnsiPixel::new(&0);
|
||||
let top_pixel = top_row.get(i).unwrap_or(&default_pixel);
|
||||
let bottom_pixel = bottom_row.get(i).unwrap_or(&default_pixel);
|
||||
|
||||
let pixel_pair = AnsiPixelPair {
|
||||
top: *top_pixel,
|
||||
@ -150,231 +199,591 @@ pub fn halfblock_bitmap(bitmap: &Vec<Vec<u32>>) -> Vec<Vec<AnsiPixelPair>> {
|
||||
ansi_canvas
|
||||
}
|
||||
|
||||
fn get_qb_char(pixel_pairs: &[AnsiPixelPair]) -> &str {
|
||||
let (pair0_top, pair0_bottom) = (&pixel_pairs[0].top.irc, &pixel_pairs[0].bottom.irc);
|
||||
let (pair1_top, pair1_bottom) = (&pixel_pairs[1].top.irc, &pixel_pairs[1].bottom.irc);
|
||||
|
||||
let ups_equal = pair0_top == pair1_top;
|
||||
let downs_equal = pair0_bottom == pair1_bottom;
|
||||
let lefts_equal = pair0_top == pair0_bottom;
|
||||
let rights_equal = pair1_top == pair1_bottom;
|
||||
let left_diag = pair0_top == pair1_bottom;
|
||||
let right_diag = pair1_top == pair0_bottom;
|
||||
|
||||
match (ups_equal, downs_equal, lefts_equal, rights_equal, left_diag, right_diag) {
|
||||
(true, _, true, true, _, _) => FULL,
|
||||
(true, _, true, _, _, _) => UP_LEFT,
|
||||
(true, _, _, true, _, _) => UP_RIGHT,
|
||||
(true, _, _, _, _, _) => UP,
|
||||
(_, true, true, _, _, _) => DOWN_LEFT,
|
||||
(_, true, _, true, _, _) => DOWN_RIGHT,
|
||||
(_, true, _, _, _, _) => DOWN,
|
||||
(_, _, true, false, _, _) => LEFT,
|
||||
(_, _, false, true, _, _) => RIGHT,
|
||||
(_, _, _, _, true, _) => DIAG_LEFT,
|
||||
(_, _, _, _, _, true) => DIAG_RIGHT,
|
||||
_ => UP,
|
||||
fn get_qb_char<T: PartialEq>(pixels: &[T; 4], fg_color: &T) -> &'static str {
|
||||
let mut pattern = 0;
|
||||
if pixels[2] == *fg_color {
|
||||
pattern |= 1 << 0; // bit 0 (bottom-left)
|
||||
}
|
||||
if pixels[3] == *fg_color {
|
||||
pattern |= 1 << 1; // bit 1 (bottom-right)
|
||||
}
|
||||
if pixels[0] == *fg_color {
|
||||
pattern |= 1 << 2; // bit 2 (top-left)
|
||||
}
|
||||
if pixels[1] == *fg_color {
|
||||
pattern |= 1 << 3; // bit 3 (top-right)
|
||||
}
|
||||
QUARTER_BLOCKS[pattern as usize]
|
||||
}
|
||||
|
||||
pub fn ansi_draw_24bit(image: AnsiImage) -> String {
|
||||
pub fn irc_draw_qb(image: &AnsiImage, args: &args::Args) -> String {
|
||||
let mut out: String = String::new();
|
||||
for (y, row) in image.halfblock.iter().enumerate() {
|
||||
for (y, row) in image.quarterblock.iter().enumerate() {
|
||||
let mut last_fg: u8 = 255;
|
||||
let mut last_bg: u8 = 255;
|
||||
for (x, pixel_quad) in row.iter().enumerate() {
|
||||
|
||||
let c0 = if args.nograyscale {
|
||||
pixel_quad.top_right.irc88
|
||||
} else {
|
||||
pixel_quad.top_right.irc
|
||||
};
|
||||
let c1 = if args.nograyscale {
|
||||
pixel_quad.top_left.irc88
|
||||
} else {
|
||||
pixel_quad.top_left.irc
|
||||
};
|
||||
|
||||
let c2 = if args.nograyscale {
|
||||
pixel_quad.bottom_right.irc88
|
||||
} else {
|
||||
pixel_quad.bottom_right.irc
|
||||
};
|
||||
|
||||
let c3 = if args.nograyscale {
|
||||
pixel_quad.bottom_left.irc88
|
||||
} else {
|
||||
pixel_quad.bottom_left.irc
|
||||
};
|
||||
|
||||
let mut color_counts = HashMap::new();
|
||||
for &color in &[c0, c1, c2, c3] {
|
||||
*color_counts.entry(color).or_insert(0) += 1;
|
||||
}
|
||||
|
||||
let bg_color = *color_counts
|
||||
.iter()
|
||||
.max_by_key(|entry| entry.1)
|
||||
.map(|(color, _)| color)
|
||||
.unwrap_or(&0);
|
||||
let fg_color = *color_counts
|
||||
.iter()
|
||||
.filter(|&(color, _)| color != &bg_color)
|
||||
.map(|(color, _)| color)
|
||||
.next()
|
||||
.unwrap_or(&bg_color);
|
||||
|
||||
let pixels = [c0, c1, c2, c3];
|
||||
let char = get_qb_char(&pixels, &fg_color);
|
||||
|
||||
if x == 0 || fg_color != last_fg || bg_color != last_bg {
|
||||
if fg_color == bg_color {
|
||||
out.push_str(&format!("\x03{}{}", fg_color, char));
|
||||
} else {
|
||||
out.push_str(&format!("\x03{},{}{}", fg_color, bg_color, char));
|
||||
}
|
||||
} else {
|
||||
out.push_str(&char);
|
||||
}
|
||||
|
||||
last_fg = fg_color;
|
||||
last_bg = bg_color;
|
||||
}
|
||||
|
||||
out.push_str("\x0f");
|
||||
|
||||
if y != image.quarterblock.len() - 1 {
|
||||
out.push_str("\n");
|
||||
}
|
||||
}
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
pub fn ansi_draw_24bit_qb(image: &AnsiImage) -> String {
|
||||
let mut out: String = String::new();
|
||||
for row in &image.quarterblock {
|
||||
for pixel_quad in row.iter() {
|
||||
|
||||
let c0_rgb = make_rgb_u8(pixel_quad.top_right.orig);
|
||||
let c1_rgb = make_rgb_u8(pixel_quad.top_left.orig);
|
||||
let c2_rgb = make_rgb_u8(pixel_quad.bottom_right.orig);
|
||||
let c3_rgb = make_rgb_u8(pixel_quad.bottom_left.orig);
|
||||
|
||||
let mut color_counts = HashMap::new();
|
||||
for &rgb in &[c0_rgb, c1_rgb, c2_rgb, c3_rgb] {
|
||||
*color_counts.entry(rgb).or_insert(0) += 1;
|
||||
}
|
||||
|
||||
let bg_color = *color_counts
|
||||
.iter()
|
||||
.max_by_key(|entry| entry.1)
|
||||
.map(|(rgb, _)| rgb)
|
||||
.unwrap_or(&[0, 0, 0]);
|
||||
let fg_color = *color_counts
|
||||
.iter()
|
||||
.filter(|&(rgb, _)| rgb != &bg_color)
|
||||
.map(|(rgb, _)| rgb)
|
||||
.next()
|
||||
.unwrap_or(&bg_color);
|
||||
|
||||
let pixels = [c0_rgb, c1_rgb, c2_rgb, c3_rgb];
|
||||
let char = get_qb_char(&pixels, &fg_color);
|
||||
|
||||
out.push_str(&format!(
|
||||
"\x1b[38;2;{};{};{}m\x1b[48;2;{};{};{}m{}",
|
||||
fg_color[0],
|
||||
fg_color[1],
|
||||
fg_color[2],
|
||||
bg_color[0],
|
||||
bg_color[1],
|
||||
bg_color[2],
|
||||
char
|
||||
));
|
||||
}
|
||||
out.push_str("\x1b[0m\n");
|
||||
}
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
pub fn ansi_draw_8bit_qb(image: &AnsiImage, args: &args::Args) -> String {
|
||||
let mut out: String = String::new();
|
||||
for row in &image.quarterblock {
|
||||
for pixel_quad in row.iter() {
|
||||
|
||||
let c0 = if args.nograyscale {
|
||||
pixel_quad.top_right.ansi232
|
||||
} else {
|
||||
pixel_quad.top_right.ansi
|
||||
};
|
||||
let c1 = if args.nograyscale {
|
||||
pixel_quad.top_left.ansi232
|
||||
} else {
|
||||
pixel_quad.top_left.ansi
|
||||
};
|
||||
let c2 = if args.nograyscale {
|
||||
pixel_quad.bottom_right.ansi232
|
||||
} else {
|
||||
pixel_quad.bottom_right.ansi
|
||||
};
|
||||
let c3 = if args.nograyscale {
|
||||
pixel_quad.bottom_left.ansi232
|
||||
} else {
|
||||
pixel_quad.bottom_left.ansi
|
||||
};
|
||||
|
||||
let mut color_counts = HashMap::new();
|
||||
for &color in &[c0, c1, c2, c3] {
|
||||
*color_counts.entry(color).or_insert(0) += 1;
|
||||
}
|
||||
|
||||
let bg_color = *color_counts
|
||||
.iter()
|
||||
.max_by_key(|entry| entry.1)
|
||||
.map(|(color, _)| color)
|
||||
.unwrap_or(&0);
|
||||
let fg_color = *color_counts
|
||||
.iter()
|
||||
.filter(|&(color, _)| color != &bg_color)
|
||||
.map(|(color, _)| color)
|
||||
.next()
|
||||
.unwrap_or(&bg_color);
|
||||
|
||||
let pixels = [c0, c1, c2, c3];
|
||||
let char = get_qb_char(&pixels, &fg_color);
|
||||
|
||||
out.push_str(&format!(
|
||||
"\x1b[38;5;{}m\x1b[48;5;{}m{}",
|
||||
fg_color,
|
||||
bg_color,
|
||||
char
|
||||
));
|
||||
}
|
||||
out.push_str("\x1b[0m\n");
|
||||
}
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
pub fn ansi_draw_24bit(image: &AnsiImage) -> String {
|
||||
let mut out: String = String::new();
|
||||
for row in &image.halfblock {
|
||||
for pixel_pair in row.iter() {
|
||||
let fg = make_rgb_u8(pixel_pair.top.orig)
|
||||
.to_vec()
|
||||
.iter()
|
||||
.map(|x| x.to_string())
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
|
||||
let bg = make_rgb_u8(pixel_pair.bottom.orig)
|
||||
.to_vec()
|
||||
.iter()
|
||||
.map(|x| x.to_string())
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
out.push_str(format!("\x1b[38;2;{}m\x1b[48;2;{}m{}", fg.join(";"), bg.join(";"), UP).as_str());
|
||||
}
|
||||
out.push_str("\x1b[0m");
|
||||
|
||||
if y != image.halfblock.len() - 1 {
|
||||
out.push_str("\n");
|
||||
out.push_str(
|
||||
format!(
|
||||
"\x1b[38;2;{}m\x1b[48;2;{}m{}",
|
||||
fg.join(";"),
|
||||
bg.join(";"),
|
||||
UP
|
||||
)
|
||||
.as_str(),
|
||||
);
|
||||
}
|
||||
out.push_str("\x1b[0m\n");
|
||||
}
|
||||
return out
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
pub fn ansi_draw_24bit_qb(image: AnsiImage) -> String {
|
||||
pub fn ansi_draw_8bit(image: &AnsiImage, args: &args::Args) -> String {
|
||||
let mut out: String = String::new();
|
||||
for (y, row) in image.halfblock.iter().enumerate() {
|
||||
for pixel_pairs in row.chunks(2) {
|
||||
let fg = make_rgb_u8(pixel_pairs[0].top.orig)
|
||||
.to_vec()
|
||||
.iter()
|
||||
.map(|x| x.to_string())
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
let bg = make_rgb_u8(pixel_pairs[0].bottom.orig)
|
||||
.to_vec()
|
||||
.iter()
|
||||
.map(|x| x.to_string())
|
||||
.collect::<Vec<String>>();
|
||||
|
||||
let char = match y {
|
||||
_ if y == image.halfblock.len() - 1 => UP,
|
||||
_ => get_qb_char(pixel_pairs),
|
||||
};
|
||||
|
||||
out.push_str(format!("\x1b[38;2;{}m\x1b[48;2;{}m{}", fg.join(";"), bg.join(";"), char).as_str());
|
||||
}
|
||||
out.push_str("\x1b[0m");
|
||||
|
||||
if y != image.halfblock.len() - 1 {
|
||||
out.push_str("\n");
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
pub fn ansi_draw_8bit(image: AnsiImage, args: &args::Args) -> String {
|
||||
let mut out: String = String::new();
|
||||
for (y, row) in image.halfblock.iter().enumerate() {
|
||||
for row in &image.halfblock {
|
||||
for pixel_pair in row.iter() {
|
||||
|
||||
let fg = match args.nograyscale {
|
||||
true => pixel_pair.top.ansi232,
|
||||
false => pixel_pair.top.ansi,
|
||||
|
||||
let fg = if args.nograyscale {
|
||||
pixel_pair.top.ansi232
|
||||
} else {
|
||||
pixel_pair.top.ansi
|
||||
};
|
||||
|
||||
let bg = match args.nograyscale {
|
||||
true => pixel_pair.bottom.ansi232,
|
||||
false => pixel_pair.bottom.ansi,
|
||||
let bg = if args.nograyscale {
|
||||
pixel_pair.bottom.ansi232
|
||||
} else {
|
||||
pixel_pair.bottom.ansi
|
||||
};
|
||||
|
||||
out.push_str(format!("\x1b[38;5;{}m\x1b[48;5;{}m{}", fg, bg, UP).as_str());
|
||||
}
|
||||
out.push_str("\x1b[0m");
|
||||
|
||||
if y != image.halfblock.len() - 1 {
|
||||
out.push_str("\n");
|
||||
}
|
||||
out.push_str("\x1b[0m\n");
|
||||
}
|
||||
return out
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
pub fn ansi_draw_8bit_qb(image: AnsiImage, args: &args::Args) -> String {
|
||||
pub fn irc_draw(image: &AnsiImage, args: &args::Args) -> String {
|
||||
let mut out: String = String::new();
|
||||
for (y, row) in image.halfblock.iter().enumerate() {
|
||||
for pixel_pairs in row.chunks(2) {
|
||||
let fg = match args.nograyscale {
|
||||
true => pixel_pairs[0].top.ansi232,
|
||||
false => pixel_pairs[0].top.ansi,
|
||||
};
|
||||
|
||||
let bg = match args.nograyscale {
|
||||
true => pixel_pairs[0].bottom.ansi232,
|
||||
false => pixel_pairs[0].bottom.ansi,
|
||||
};
|
||||
|
||||
let char = match y {
|
||||
_ if y == image.halfblock.len() - 1 => UP,
|
||||
_ => get_qb_char(pixel_pairs),
|
||||
};
|
||||
|
||||
out.push_str(format!("\x1b[38;5;{}m\x1b[48;5;{}m{}", fg, bg, char).as_str());
|
||||
}
|
||||
out.push_str("\x1b[0m");
|
||||
|
||||
if y != image.halfblock.len() - 1 {
|
||||
out.push_str("\n");
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
pub fn irc_draw(image: AnsiImage, args: &args::Args) -> String {
|
||||
let mut out: String = String::new();
|
||||
for (y, row) in image.halfblock.iter().enumerate() {
|
||||
let mut last_fg: u8 = 0;
|
||||
let mut last_bg: u8 = 0;
|
||||
for row in &image.halfblock {
|
||||
let mut last_fg: u8 = 255;
|
||||
let mut last_bg: u8 = 255;
|
||||
for (x, pixel_pair) in row.iter().enumerate() {
|
||||
let fg = match args.nograyscale {
|
||||
true => pixel_pair.top.irc88,
|
||||
false => pixel_pair.top.irc,
|
||||
|
||||
let fg = if args.nograyscale {
|
||||
pixel_pair.top.irc88
|
||||
} else {
|
||||
pixel_pair.top.irc
|
||||
};
|
||||
|
||||
let bg = match args.nograyscale {
|
||||
true => pixel_pair.bottom.irc88,
|
||||
false => pixel_pair.bottom.irc,
|
||||
let bg = if args.nograyscale {
|
||||
pixel_pair.bottom.irc88
|
||||
} else {
|
||||
pixel_pair.bottom.irc
|
||||
};
|
||||
|
||||
if x != 0 {
|
||||
if fg == last_fg && bg == last_bg {
|
||||
out.push_str(&format!("{}", UP));
|
||||
} else if bg == last_bg {
|
||||
if x == 0 || fg != last_fg || bg != last_bg {
|
||||
if last_bg == bg {
|
||||
out.push_str(&format!("\x03{}{}", fg, UP));
|
||||
} else {
|
||||
out.push_str(&format!("\x03{},{}{}", fg, bg, UP));
|
||||
}
|
||||
} else {
|
||||
out.push_str(&format!("\x03{},{}{}", fg, bg, UP));
|
||||
out.push_str(&UP);
|
||||
}
|
||||
|
||||
last_fg = fg;
|
||||
last_bg = bg;
|
||||
}
|
||||
|
||||
out.push_str("\x0f");
|
||||
|
||||
if y != image.halfblock.len() - 1 {
|
||||
out.push_str("\n");
|
||||
}
|
||||
out.push_str("\x0f\n");
|
||||
}
|
||||
return out
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
pub fn irc_draw_qb(image: AnsiImage, args: &args::Args) -> String {
|
||||
pub fn luma(rgb: &[u8; 3]) -> u8 {
|
||||
let r = rgb[0] as u16;
|
||||
let g = rgb[1] as u16;
|
||||
let b = rgb[2] as u16;
|
||||
((0.299 * r as f32 + 0.587 * g as f32 + 0.114 * b as f32).round()) as u8
|
||||
}
|
||||
|
||||
pub fn ansi_draw_braille_24bit(image_luma: &AnsiImage, image_chroma: &AnsiImage) -> String {
|
||||
let mut out: String = String::new();
|
||||
for (y, row) in image.halfblock.iter().enumerate() {
|
||||
let mut last_fg: u8 = 0;
|
||||
let mut last_bg: u8 = 0;
|
||||
for (x, pixel_pairs) in row.chunks(2).enumerate() {
|
||||
let fg = match args.nograyscale {
|
||||
true => pixel_pairs[0].top.irc88,
|
||||
false => pixel_pairs[0].top.irc,
|
||||
};
|
||||
let bitmap_luma = &image_luma.bitmap;
|
||||
let bitmap_chroma = &image_chroma.bitmap;
|
||||
let height = bitmap_luma.len();
|
||||
let width = bitmap_luma[0].len();
|
||||
|
||||
let bg = match args.nograyscale {
|
||||
true => pixel_pairs[0].bottom.irc88,
|
||||
false => pixel_pairs[0].bottom.irc,
|
||||
};
|
||||
let mut error_matrix = vec![vec![0.0; width]; height];
|
||||
|
||||
let mut min_luma = 255u32;
|
||||
let mut max_luma = 0u32;
|
||||
for row in bitmap_luma.iter() {
|
||||
for &pixel in row.iter() {
|
||||
let l = luma(&make_rgb_u8(pixel)) as u32;
|
||||
min_luma = min_luma.min(l);
|
||||
max_luma = max_luma.max(l);
|
||||
}
|
||||
}
|
||||
|
||||
let char = match y {
|
||||
_ if y == image.halfblock.len() - 1 => UP,
|
||||
_ => get_qb_char(pixel_pairs),
|
||||
};
|
||||
let luma_range = max_luma.saturating_sub(min_luma).max(1);
|
||||
|
||||
if x == 0 {
|
||||
out.push_str(&format!("\x03{},{}{}", fg, bg, char));
|
||||
} else {
|
||||
if fg == last_fg && bg == last_bg {
|
||||
out.push_str(&format!("{}", char));
|
||||
} else if bg == last_bg {
|
||||
out.push_str(&format!("\x03{}{}", fg, char));
|
||||
} else {
|
||||
out.push_str(&format!("\x03{},{}{}", fg, bg, char));
|
||||
let scaled_threshold = min_luma + (luma_range / 2);
|
||||
|
||||
for y in (0..height).step_by(4) {
|
||||
let mut last_fg = [0u8; 3];
|
||||
let mut first = true;
|
||||
for x in (0..width).step_by(2) {
|
||||
let mut braille_char = 0x2800;
|
||||
let mut color_counts: HashMap<[u8; 3], u32> = HashMap::new();
|
||||
|
||||
for &(dx, dy, bit) in &POSITIONS {
|
||||
let current_y = y + dy;
|
||||
let current_x = x + dx;
|
||||
if current_y < height && current_x < width {
|
||||
let original_pixel = bitmap_luma[current_y][current_x];
|
||||
let rgb = make_rgb_u8(original_pixel);
|
||||
let current_luma = luma(&rgb) as f64;
|
||||
|
||||
let mut pixel_luma = current_luma + error_matrix[current_y][current_x];
|
||||
pixel_luma = pixel_luma.clamp(0.0, 255.0);
|
||||
|
||||
let new_pixel = if pixel_luma > scaled_threshold as f64 {
|
||||
255.0
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
|
||||
let error = pixel_luma - new_pixel;
|
||||
|
||||
if new_pixel == 255.0 {
|
||||
braille_char |= bit;
|
||||
|
||||
let px_chroma = bitmap_chroma[current_y][current_x];
|
||||
let rgb_chroma = make_rgb_u8(px_chroma);
|
||||
*color_counts.entry(rgb_chroma).or_insert(0) += 1;
|
||||
}
|
||||
|
||||
if current_x + 1 < width {
|
||||
error_matrix[current_y][current_x + 1] += error * 7.0 / 16.0;
|
||||
}
|
||||
if current_y + 1 < height {
|
||||
if current_x > 0 {
|
||||
error_matrix[current_y + 1][current_x - 1] += error * 3.0 / 16.0;
|
||||
}
|
||||
error_matrix[current_y + 1][current_x] += error * 5.0 / 16.0;
|
||||
if current_x + 1 < width {
|
||||
error_matrix[current_y + 1][current_x + 1] += error * 1.0 / 16.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
last_fg = fg;
|
||||
last_bg = bg;
|
||||
let fg_color = color_counts
|
||||
.iter()
|
||||
.max_by_key(|entry| entry.1)
|
||||
.map(|(color, _)| *color)
|
||||
.unwrap_or([0, 0, 0]);
|
||||
let braille_char = char::from_u32(braille_char).unwrap_or(' ');
|
||||
|
||||
if first || last_fg != fg_color {
|
||||
out.push_str(&format!(
|
||||
"\x1b[38;2;{};{};{}m{}",
|
||||
fg_color[0], fg_color[1], fg_color[2], braille_char
|
||||
));
|
||||
} else {
|
||||
out.push(braille_char);
|
||||
}
|
||||
last_fg = fg_color;
|
||||
first = false;
|
||||
}
|
||||
out.push_str("\x1b[0m\n");
|
||||
}
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
out.push_str("\x0f");
|
||||
|
||||
if y != image.halfblock.len() - 1 {
|
||||
out.push_str("\n");
|
||||
pub fn ansi_draw_braille_8bit(
|
||||
image_luma: &AnsiImage,
|
||||
image_chroma: &AnsiImage,
|
||||
args: &args::Args,
|
||||
) -> String {
|
||||
let mut out: String = String::new();
|
||||
let bitmap_luma = &image_luma.bitmap;
|
||||
let bitmap_chroma = &image_chroma.bitmap;
|
||||
let height = bitmap_luma.len();
|
||||
let width = bitmap_luma[0].len();
|
||||
|
||||
let mut error_matrix = vec![vec![0.0; width]; height];
|
||||
|
||||
let mut min_luma = 255u32;
|
||||
let mut max_luma = 0u32;
|
||||
for row in bitmap_luma.iter() {
|
||||
for &pixel in row.iter() {
|
||||
let l = luma(&make_rgb_u8(pixel)) as u32;
|
||||
min_luma = min_luma.min(l);
|
||||
max_luma = max_luma.max(l);
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
let luma_range = max_luma.saturating_sub(min_luma).max(1);
|
||||
|
||||
let scaled_threshold = min_luma + (luma_range / 2);
|
||||
|
||||
for y in (0..height).step_by(4) {
|
||||
let mut last_fg = 255u8; // Initialize with a default color
|
||||
let mut first = true;
|
||||
for x in (0..width).step_by(2) {
|
||||
let mut braille_char = 0x2800; // Base Unicode braille character
|
||||
let mut color_counts: HashMap<u8, usize> = HashMap::new(); // Color counting
|
||||
|
||||
for &(dx, dy, bit) in &POSITIONS {
|
||||
let current_y = y + dy;
|
||||
let current_x = x + dx;
|
||||
if current_y < height && current_x < width {
|
||||
let original_pixel = bitmap_luma[current_y][current_x];
|
||||
let rgb = make_rgb_u8(original_pixel);
|
||||
let current_luma = luma(&rgb) as f64;
|
||||
|
||||
let mut pixel_luma = current_luma + error_matrix[current_y][current_x];
|
||||
pixel_luma = pixel_luma.clamp(0.0, 255.0);
|
||||
|
||||
let new_pixel = if pixel_luma > scaled_threshold as f64 {
|
||||
255.0
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
|
||||
let error = pixel_luma - new_pixel;
|
||||
|
||||
if new_pixel == 255.0 {
|
||||
braille_char |= bit;
|
||||
|
||||
let px_chroma = bitmap_chroma[current_y][current_x];
|
||||
let color = if args.nograyscale {
|
||||
nearest_hex_color(px_chroma, ANSI232.to_vec())
|
||||
} else {
|
||||
nearest_hex_color(px_chroma, ANSI256.to_vec())
|
||||
};
|
||||
*color_counts.entry(color).or_insert(0) += 1;
|
||||
}
|
||||
|
||||
if current_x + 1 < width {
|
||||
error_matrix[current_y][current_x + 1] += error * 7.0 / 16.0;
|
||||
}
|
||||
if current_y + 1 < height {
|
||||
if current_x > 0 {
|
||||
error_matrix[current_y + 1][current_x - 1] += error * 3.0 / 16.0;
|
||||
}
|
||||
error_matrix[current_y + 1][current_x] += error * 5.0 / 16.0;
|
||||
if current_x + 1 < width {
|
||||
error_matrix[current_y + 1][current_x + 1] += error * 1.0 / 16.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let fg_color = *color_counts
|
||||
.iter()
|
||||
.max_by_key(|entry| entry.1)
|
||||
.map(|(color, _)| color)
|
||||
.unwrap_or(&last_fg); // Default to last_fg if no colors are counted
|
||||
|
||||
let braille_char = char::from_u32(braille_char).unwrap_or(' ');
|
||||
|
||||
if first || last_fg != fg_color {
|
||||
out.push_str(&format!("\x1b[38;5;{}m{}", fg_color, braille_char));
|
||||
} else {
|
||||
out.push(braille_char);
|
||||
}
|
||||
last_fg = fg_color;
|
||||
first = false;
|
||||
}
|
||||
out.push_str("\x1b[0m\n"); // Reset colors and move to the next line
|
||||
}
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
pub fn irc_draw_braille(image_luma: &AnsiImage, image_chroma: &AnsiImage, args: &args::Args) -> String {
|
||||
let mut out: String = String::new();
|
||||
let bitmap_luma = &image_luma.bitmap;
|
||||
let bitmap_chroma = &image_chroma.bitmap;
|
||||
let height = bitmap_luma.len();
|
||||
let width = bitmap_luma[0].len();
|
||||
|
||||
let mut error_matrix = vec![vec![0.0; width]; height];
|
||||
|
||||
let mut min_luma = 255u32;
|
||||
let mut max_luma = 0u32;
|
||||
|
||||
for row in bitmap_luma.iter() {
|
||||
for &pixel in row.iter() {
|
||||
let l = luma(&make_rgb_u8(pixel)) as u32;
|
||||
min_luma = min_luma.min(l);
|
||||
max_luma = max_luma.max(l);
|
||||
}
|
||||
}
|
||||
|
||||
let luma_range = max_luma.saturating_sub(min_luma).max(1);
|
||||
|
||||
let scaled_threshold = min_luma + (luma_range / 2);
|
||||
|
||||
for y in (0..height).step_by(4) {
|
||||
let mut last_fg = 255u8;
|
||||
let mut first = true;
|
||||
for x in (0..width).step_by(2) {
|
||||
let mut braille_char = 0x2800;
|
||||
let mut color_counts = HashMap::new();
|
||||
|
||||
for &(dx, dy, bit) in &POSITIONS {
|
||||
let current_y = y + dy;
|
||||
let current_x = x + dx;
|
||||
if current_y < height && current_x < width {
|
||||
let original_pixel = bitmap_luma[current_y][current_x];
|
||||
let rgb = make_rgb_u8(original_pixel);
|
||||
let current_luma = luma(&rgb) as f64;
|
||||
|
||||
let mut pixel_luma = current_luma + error_matrix[current_y][current_x];
|
||||
pixel_luma = pixel_luma.clamp(0.0, 255.0);
|
||||
|
||||
let new_pixel = if pixel_luma > scaled_threshold as f64 {
|
||||
255.0
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
|
||||
let error = pixel_luma - new_pixel;
|
||||
|
||||
if new_pixel == 255.0 {
|
||||
braille_char |= bit;
|
||||
|
||||
let px_chroma = bitmap_chroma[current_y][current_x];
|
||||
let color = if args.nograyscale {
|
||||
nearest_hex_color(px_chroma, RGB88.to_vec())
|
||||
} else {
|
||||
nearest_hex_color(px_chroma, RGB99.to_vec())
|
||||
};
|
||||
*color_counts.entry(color).or_insert(0) += 1;
|
||||
}
|
||||
|
||||
if current_x + 1 < width {
|
||||
error_matrix[current_y][current_x + 1] += error * 7.0 / 16.0;
|
||||
}
|
||||
if current_y + 1 < height {
|
||||
if current_x > 0 {
|
||||
error_matrix[current_y + 1][current_x - 1] += error * 3.0 / 16.0;
|
||||
}
|
||||
error_matrix[current_y + 1][current_x] += error * 5.0 / 16.0;
|
||||
if current_x + 1 < width {
|
||||
error_matrix[current_y + 1][current_x + 1] += error * 1.0 / 16.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let fg_color = *color_counts
|
||||
.iter()
|
||||
.max_by_key(|entry| entry.1)
|
||||
.map(|(color, _)| color)
|
||||
.unwrap_or(&last_fg);
|
||||
|
||||
let braille_char = char::from_u32(braille_char).unwrap_or(' ');
|
||||
|
||||
if first || fg_color != last_fg {
|
||||
out.push_str(&format!("\x03{}{}", fg_color, braille_char));
|
||||
} else {
|
||||
out.push(braille_char);
|
||||
}
|
||||
last_fg = fg_color;
|
||||
first = false;
|
||||
}
|
||||
out.push_str("\x0f\n");
|
||||
}
|
||||
out.trim_end().to_string()
|
||||
}
|
||||
|
||||
218
src/effects.rs
218
src/effects.rs
@ -1,213 +1,238 @@
|
||||
use crate::args;
|
||||
use photon_rs::{colour_spaces};
|
||||
use photon_rs::{channels, conv, effects, filters, monochrome, noise};
|
||||
use photon_rs::transform::{resize, SamplingFilter};
|
||||
use photon_rs::{colour_spaces, channels, conv, effects, filters, monochrome, noise};
|
||||
use photon_rs::transform::{SamplingFilter, resize, crop, rotate, flipv, fliph};
|
||||
use photon_rs::PhotonImage;
|
||||
|
||||
fn calculate_dimensions(args: &args::Args, image: &PhotonImage) -> (u32, u32) {
|
||||
let original_width = image.get_width() as f32;
|
||||
let original_height = image.get_height() as f32;
|
||||
let original_aspect = original_width / original_height;
|
||||
|
||||
let base_width;
|
||||
let base_height;
|
||||
|
||||
let aspect_ratio = if let Some(aspect) = args.aspect {
|
||||
aspect.0 / aspect.1
|
||||
} else {
|
||||
original_aspect
|
||||
};
|
||||
|
||||
if args.width.is_none() && args.height.is_none() {
|
||||
base_width = original_width;
|
||||
base_height = original_height;
|
||||
} else if args.width.is_none() {
|
||||
let provided_height = args.height.unwrap();
|
||||
base_height = provided_height as f32;
|
||||
base_width = base_height * aspect_ratio;
|
||||
} else if args.height.is_none() {
|
||||
let provided_width = args.width.unwrap();
|
||||
base_width = provided_width as f32;
|
||||
base_height = base_width / aspect_ratio;
|
||||
} else {
|
||||
base_width = args.width.unwrap() as f32;
|
||||
base_height = args.height.unwrap() as f32;
|
||||
}
|
||||
|
||||
let (scaled_width, scaled_height) = if let Some(scale) = args.scale {
|
||||
(base_width * scale.0, base_height * scale.1)
|
||||
} else {
|
||||
(base_width, base_height)
|
||||
};
|
||||
|
||||
// Step 4: Round the scaled dimensions to the nearest integer and ensure a minimum size of 1.
|
||||
let final_width = scaled_width.round().max(1.0) as u32;
|
||||
let final_height = scaled_height.round().max(1.0) as u32;
|
||||
|
||||
(final_width, final_height)
|
||||
}
|
||||
|
||||
pub fn apply_effects(
|
||||
args: &args::Args,
|
||||
mut photon_image: PhotonImage,
|
||||
) -> PhotonImage {
|
||||
let (width, height) = calculate_dimensions(args, &photon_image);
|
||||
|
||||
if args.rotate != 0 {
|
||||
photon_image = rotate(&photon_image, args.rotate as i32);
|
||||
}
|
||||
|
||||
// Resize to width
|
||||
let height =
|
||||
(args.width as f32 / photon_image.get_width() as f32 * photon_image.get_height() as f32) as u32;
|
||||
if args.fliph {
|
||||
fliph(&mut photon_image);
|
||||
}
|
||||
|
||||
let width = match args.qb {
|
||||
true => args.width * 2,
|
||||
_ => args.width,
|
||||
if args.flipv {
|
||||
flipv(&mut photon_image);
|
||||
}
|
||||
|
||||
photon_image = resize(&photon_image, width, height, match args.filter {
|
||||
args::SamplingFilter::Nearest => SamplingFilter::Nearest,
|
||||
args::SamplingFilter::Triangle => SamplingFilter::Triangle,
|
||||
args::SamplingFilter::CatmullRom => SamplingFilter::CatmullRom,
|
||||
args::SamplingFilter::Gaussian => SamplingFilter::Gaussian,
|
||||
args::SamplingFilter::Lanczos3 => SamplingFilter::Lanczos3,
|
||||
});
|
||||
|
||||
type ColourFunc = fn(&mut PhotonImage, &str, f32);
|
||||
|
||||
let colour_func: ColourFunc = match args.colorspace {
|
||||
args::ColourSpace::HSL => colour_spaces::hsl,
|
||||
args::ColourSpace::HSV => colour_spaces::hsv,
|
||||
args::ColourSpace::HSLUV => colour_spaces::hsluv,
|
||||
args::ColourSpace::LCH => colour_spaces::lch,
|
||||
};
|
||||
|
||||
photon_image = match args.qb {
|
||||
true => resize(&photon_image, width, height, SamplingFilter::Lanczos3),
|
||||
_ => resize(&mut photon_image, width, height, SamplingFilter::Lanczos3),
|
||||
};
|
||||
if args.dither > 0 {
|
||||
effects::dither(&mut photon_image, args.dither);
|
||||
}
|
||||
|
||||
// Adjust brightness
|
||||
match args.brightness {
|
||||
x if x > 0.0 => {
|
||||
colour_spaces::hsv(&mut photon_image, "brighten", args.brightness/255.0);
|
||||
colour_func(&mut photon_image, "lighten", args.brightness / 100.0);
|
||||
}
|
||||
x if x < 0.0 => {
|
||||
colour_spaces::hsv(&mut photon_image, "darken", args.brightness.abs()/255.0);
|
||||
colour_func(&mut photon_image, "darken", args.brightness.abs() / 100.0);
|
||||
},
|
||||
_ => {}
|
||||
}
|
||||
|
||||
// Adjust hue
|
||||
if args.hue > 0.0 {
|
||||
colour_spaces::hsv(&mut photon_image, "shift_hue", args.hue/360.0);
|
||||
}
|
||||
|
||||
// Adjust contrast
|
||||
if args.contrast != 0.0 {
|
||||
effects::adjust_contrast(&mut photon_image, args.contrast);
|
||||
}
|
||||
|
||||
// Adjust saturation
|
||||
match args.saturation {
|
||||
x if x > 0.0 => {
|
||||
colour_spaces::hsv(&mut photon_image, "saturate", args.saturation/255.0);
|
||||
colour_func(&mut photon_image, "saturate", args.saturation/100.0);
|
||||
}
|
||||
x if x < 0.0 => {
|
||||
colour_spaces::hsv(&mut photon_image, "desaturate", args.saturation.abs()/255.0);
|
||||
colour_func(&mut photon_image, "desaturate", args.saturation.abs()/100.0);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
// Adjust gamma
|
||||
if args.contrast != 0.0 {
|
||||
effects::adjust_contrast(&mut photon_image, args.contrast);
|
||||
}
|
||||
|
||||
if args.hue > 0.0 {
|
||||
colour_func(&mut photon_image, "shift_hue", args.hue/360.0);
|
||||
}
|
||||
|
||||
if args.gamma != 0.0 {
|
||||
let gamma_value = 1.0 - args.gamma/255.0;
|
||||
colour_spaces::gamma_correction(&mut photon_image, gamma_value, gamma_value, gamma_value);
|
||||
}
|
||||
|
||||
// Adjust dither
|
||||
if args.dither > 0 {
|
||||
effects::dither(&mut photon_image, args.dither);
|
||||
if args.crop.is_some() {
|
||||
let crop_args = args.crop.unwrap();
|
||||
photon_image = crop(&mut photon_image, crop_args.0, crop_args.1, crop_args.2, crop_args.3);
|
||||
}
|
||||
|
||||
// Adjust gaussian_blur
|
||||
if args.gaussian_blur > 0 {
|
||||
conv::gaussian_blur(&mut photon_image, args.gaussian_blur);
|
||||
}
|
||||
|
||||
// Adjust pixelize
|
||||
if args.pixelize > 0 {
|
||||
effects::pixelize(&mut photon_image, args.pixelize);
|
||||
}
|
||||
|
||||
// Adjust halftone
|
||||
if args.halftone {
|
||||
effects::halftone(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust invert
|
||||
if args.invert {
|
||||
channels::invert(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust sepia
|
||||
if args.sepia {
|
||||
monochrome::sepia(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust solarize
|
||||
if args.solarize {
|
||||
effects::solarize(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust normalize
|
||||
if args.normalize {
|
||||
effects::normalize(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust noise
|
||||
if args.noise {
|
||||
noise::add_noise_rand(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust sharpen
|
||||
if args.sharpen {
|
||||
conv::sharpen(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust edge_detection
|
||||
if args.edge_detection {
|
||||
|
||||
conv::edge_detection(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust emboss
|
||||
if args.emboss {
|
||||
conv::emboss(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust frosted_glass
|
||||
if args.frosted_glass {
|
||||
effects::frosted_glass(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust box_blur
|
||||
if args.box_blur {
|
||||
conv::box_blur(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust grayscale
|
||||
if args.grayscale {
|
||||
monochrome::grayscale(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust identity
|
||||
if args.identity {
|
||||
conv::identity(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust laplace
|
||||
if args.laplace {
|
||||
conv::laplace(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust cali
|
||||
if args.cali {
|
||||
filters::cali(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust dramatic
|
||||
if args.dramatic {
|
||||
filters::dramatic(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust firenze
|
||||
if args.firenze {
|
||||
filters::firenze(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust golden
|
||||
if args.golden {
|
||||
filters::golden(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust lix
|
||||
if args.lix {
|
||||
filters::lix(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust lofi
|
||||
if args.lofi {
|
||||
filters::lofi(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust neue
|
||||
if args.neue {
|
||||
filters::neue(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust obsidian
|
||||
if args.obsidian {
|
||||
filters::obsidian(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust pastel_pink
|
||||
if args.pastel_pink {
|
||||
filters::pastel_pink(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust ryo
|
||||
if args.ryo {
|
||||
filters::ryo(&mut photon_image);
|
||||
}
|
||||
|
||||
// Adjust oil
|
||||
match &args.oil {
|
||||
Some(oil) => {
|
||||
// split oil at comma
|
||||
let vals: Vec<&str> = oil.split(",").collect();
|
||||
|
||||
// check if args.oil has 2 values
|
||||
if vals.len() == 2 {
|
||||
// convert oil values to i32 and f64
|
||||
let radius: i32 = vals.get(0).unwrap().parse::<i32>().unwrap();
|
||||
let intensity: f64 = vals.get(1).unwrap().parse::<f64>().unwrap();
|
||||
|
||||
effects::oil(&mut photon_image, radius, intensity);
|
||||
}
|
||||
}
|
||||
@ -216,3 +241,64 @@ pub fn apply_effects(
|
||||
|
||||
photon_image
|
||||
}
|
||||
|
||||
pub fn apply_luma_effects(args: &args::Args, mut photon_image: PhotonImage) -> PhotonImage {
|
||||
let (width, height) = calculate_dimensions(args, &photon_image);
|
||||
|
||||
if args.rotate != 0 {
|
||||
photon_image = rotate(&photon_image, args.rotate);
|
||||
}
|
||||
|
||||
if args.fliph {
|
||||
fliph(&mut photon_image);
|
||||
}
|
||||
|
||||
if args.flipv {
|
||||
flipv(&mut photon_image);
|
||||
}
|
||||
|
||||
photon_image = resize(&photon_image, width, height, match args.filter {
|
||||
args::SamplingFilter::Nearest => SamplingFilter::Nearest,
|
||||
args::SamplingFilter::Triangle => SamplingFilter::Triangle,
|
||||
args::SamplingFilter::CatmullRom => SamplingFilter::CatmullRom,
|
||||
args::SamplingFilter::Gaussian => SamplingFilter::Gaussian,
|
||||
args::SamplingFilter::Lanczos3 => SamplingFilter::Lanczos3,
|
||||
});
|
||||
|
||||
type ColourFunc = fn(&mut PhotonImage, &str, f32);
|
||||
|
||||
let colour_func: ColourFunc = match args.colorspace {
|
||||
args::ColourSpace::HSL => colour_spaces::hsl,
|
||||
args::ColourSpace::HSV => colour_spaces::hsv,
|
||||
args::ColourSpace::HSLUV => colour_spaces::hsluv,
|
||||
args::ColourSpace::LCH => colour_spaces::lch,
|
||||
};
|
||||
|
||||
|
||||
if args.luma_invert {
|
||||
channels::invert(&mut photon_image);
|
||||
}
|
||||
|
||||
if args.luma_contrast != 0.0 {
|
||||
effects::adjust_contrast(&mut photon_image, args.luma_contrast);
|
||||
}
|
||||
|
||||
if args.luma_gamma != 0.0 {
|
||||
let gamma_value = 1.0 - args.luma_gamma/255.0;
|
||||
colour_spaces::gamma_correction(&mut photon_image, gamma_value, gamma_value, gamma_value);
|
||||
}
|
||||
|
||||
if args.luma_brightness > 0.0 {
|
||||
colour_func(&mut photon_image, "lighten", args.luma_brightness/100.0);
|
||||
} else if args.luma_brightness < 0.0 {
|
||||
colour_func(&mut photon_image, "darken", args.luma_brightness.abs()/100.0);
|
||||
}
|
||||
|
||||
if args.luma_saturation < 0.0 {
|
||||
colour_func(&mut photon_image, "saturate", args.luma_saturation.abs()/100.0);
|
||||
} else if args.luma_saturation > 0.0 {
|
||||
colour_func(&mut photon_image, "desaturate", args.luma_saturation/100.0);
|
||||
}
|
||||
|
||||
photon_image
|
||||
}
|
||||
|
||||
39
src/main.rs
39
src/main.rs
@ -5,36 +5,37 @@ mod effects;
|
||||
|
||||
use reqwest;
|
||||
use url::Url;
|
||||
|
||||
use photon_rs::PhotonImage;
|
||||
use std::{error::Error, io::Cursor, process::exit};
|
||||
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
let args = args::parse_args();
|
||||
|
||||
match load_image_from_url_or_path(args.image.as_str()).await {
|
||||
Ok(mut image) => {
|
||||
image = effects::apply_effects(
|
||||
&args,
|
||||
image,
|
||||
);
|
||||
Ok(image) => {
|
||||
let image_luma = effects::apply_luma_effects(&args, image.clone());
|
||||
let image_chroma = effects::apply_effects(&args, image.clone());
|
||||
|
||||
let canvas = draw::AnsiImage::new(image);
|
||||
let canvas_luma = draw::AnsiImage::new(image_luma.clone());
|
||||
let canvas_chroma = draw::AnsiImage::new(image_chroma.clone());
|
||||
|
||||
match (args.irc, args.ansi, args.ansi24, args.qb) {
|
||||
(true, _, _, true) => println!("{}", draw::irc_draw_qb(canvas, &args).as_str()),
|
||||
(true, _, _, false) => println!("{}", draw::irc_draw(canvas, &args).as_str()),
|
||||
(_, true, _, true) => println!("{}", draw::ansi_draw_8bit_qb(canvas, &args).as_str()),
|
||||
(_, true, _, false) => println!("{}", draw::ansi_draw_8bit(canvas, &args).as_str()),
|
||||
(_, _, true, true) => println!("{}", draw::ansi_draw_24bit_qb(canvas).as_str()),
|
||||
(_, _, true, false) => println!("{}", draw::ansi_draw_24bit(canvas).as_str()),
|
||||
(_, _, _, true) => println!("{}", draw::irc_draw_qb(canvas, &args).as_str()),
|
||||
_ => println!("{}", draw::irc_draw(canvas, &args).as_str()),
|
||||
match (args.irc, args.ansi, args.ansi24, args.qb, args.braille) {
|
||||
(true, _, _, true, false) => println!("{}", draw::irc_draw_qb(&canvas_chroma, &args)),
|
||||
(true, _, _, false, false) => println!("{}", draw::irc_draw(&canvas_chroma, &args)),
|
||||
(true, _, _, _, true) => println!("{}", draw::irc_draw_braille(&canvas_luma, &canvas_chroma, &args)),
|
||||
(_, true, _, true, false) => println!("{}", draw::ansi_draw_8bit_qb(&canvas_chroma, &args)),
|
||||
(_, true, _, false, false) => println!("{}", draw::ansi_draw_8bit(&canvas_chroma, &args)),
|
||||
(_, true, _, _, true) => println!("{}", draw::ansi_draw_braille_8bit(&canvas_luma, &canvas_chroma, &args)),
|
||||
(_, _, true, true, false) => println!("{}", draw::ansi_draw_24bit_qb(&canvas_chroma)),
|
||||
(_, _, true, false, false) => println!("{}", draw::ansi_draw_24bit(&canvas_chroma)),
|
||||
(_, _, true, _, true) => println!("{}", draw::ansi_draw_braille_24bit(&canvas_luma, &canvas_chroma)),
|
||||
(_, _, _, true, false) => println!("{}", draw::irc_draw_qb(&canvas_chroma, &args)),
|
||||
(_, _, _, _, true) => println!("{}", draw::irc_draw_braille(&canvas_luma, &canvas_chroma, &args)),
|
||||
_ => println!("{}", draw::irc_draw(&canvas_chroma, &args)),
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Err(e) => {
|
||||
eprintln!("Error: {}", e);
|
||||
exit(1);
|
||||
@ -47,7 +48,6 @@ async fn load_image_from_url_or_path(image: &str) -> Result<PhotonImage, Box<dyn
|
||||
Ok(url) => {
|
||||
let response = reqwest::get(url).await?;
|
||||
let bytes = response.bytes().await?;
|
||||
|
||||
let image_data = Cursor::new(bytes);
|
||||
match photon_rs::native::open_image_from_bytes(image_data.into_inner().as_ref()) {
|
||||
Ok(image) => Ok(image),
|
||||
@ -62,4 +62,3 @@ async fn load_image_from_url_or_path(image: &str) -> Result<PhotonImage, Box<dyn
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user