invert and brightness

README.md

@@ -14,7 +14,9 @@ returning a new one. The allowed operators are:
 * `R{Num}` the red color component defined by `Num` (i.e. `R255` is the same as `R`)
 * `G{Num}` the green color component defined by `Num` (i.e. `G255` is the same as `G`)
 * `B{Num}` the blue color component defined by `Num` (i.e. `B255` is the same as `B`)
-* 
+* `i` inverts the color component
+* `b{Num}` the brightness of the color component defined by `Num` (i.e. `b255` is the same as `b`)
+
 ###  Ported from go-glitch
 * `+` plus
 * `-` minus

src/eval.rs

@@ -1,4 +1,4 @@
-use image::{DynamicImage, GenericImageView, Rgba};
+use image::{DynamicImage, GenericImageView, Pixel, Rgba};
 use rand::{Rng, RngCore};
 use std::collections::HashMap;
 
@@ -283,6 +283,37 @@ pub fn eval(
                 _ => return Err(format!("Unexpected token: {:?}", token)),
             },
 
+            Token::Brightness(brightness) => {
+                let pixel = input.get_pixel(x, y);
+                let r = pixel[0];
+                let g = pixel[1];
+                let b = pixel[2];
+
+
+                if brightness != 0 {
+                    let r = (f64::from(r) * brightness as f64).round() as u8;
+                    let g = (f64::from(g) * brightness as f64).round() as u8;
+                    let b = (f64::from(b) * brightness as f64).round() as u8;
+                    stack.push(RgbSum::new(r, g, b));
+                    continue;
+                } else {
+                    // get default brightness
+                    stack.push(RgbSum::new(r, g, b));
+                }
+            }
+
+            Token::Invert => {
+                let pixel = input.get_pixel(x, y);
+                let mut new_rgba = Rgba([pixel[0], pixel[1], pixel[2], pixel[3]]);
+                new_rgba.invert();
+
+                let r = new_rgba[0];
+                let g = new_rgba[1];
+                let b = new_rgba[2];
+
+                stack.push(RgbSum::new(r, g, b));
+            }
+
             Token::Char(c) => match c {
                 'c' => stack.push(RgbSum::new(r, g, b)),
                 'Y' => {

src/parser.rs

@@ -9,6 +9,7 @@ pub enum Token {
     Num(u8),
     Random(u8),
     RGBColor((char, u8)),
+    Brightness(u8),
     Add,
     Sub,
     Mul,
@@ -26,6 +27,7 @@ pub enum Token {
     LeftParen,
     RightParen,
     Char(char),
+    Invert,
 }
 
 pub trait DisplayStyle {
@@ -55,6 +57,8 @@ impl DisplayStyle for Token {
             Self::Weight => Style::new().fg(Color::BrightYellow),
             Self::Random(_) => Style::new().fg(Color::BrightBlue),
             Self::RGBColor(_) => Style::new().fg(Color::BrightBlue),
+            Self::Brightness(_) => Style::new().fg(Color::BrightBlue),
+            Self::Invert => Style::new().fg(Color::BrightBlue),
         }
     }
 }
@@ -163,6 +167,12 @@ impl std::fmt::Display for Token {
             }
             Self::RGBColor((part, val)) => {
                 content = Some(format!("RGB Color - {part}: {val}").leak());
+            },
+            Self::Brightness(val) => {
+                content = Some(format!("Brightness - {val}").leak());
+            },
+            Self::Invert => {
+                content = Some("Invert");
             }
             _ => {}
         }
@@ -265,6 +275,30 @@ pub fn shunting_yard(input: &str) -> Result<Vec<Token>, String> {
                 };
                 output_queue.push_back(Token::RGBColor((part, value)));
             }
+            'b' => {
+                push_number_buffer(&mut number_buffer, &mut output_queue, current_position)?;
+                let mut value_str = String::new();
+                while let Some(&next_char) = chars_iter.peek() {
+                    if next_char.is_ascii_digit() {
+                        value_str.push(chars_iter.next().unwrap());
+                        current_position += 1;
+                    } else {
+                        break;
+                    }
+                }
+                let value = if value_str.is_empty() {
+                    255
+                } else {
+                    value_str.parse::<u8>().map_err(|_| {
+                        format!("Invalid value specified at position {}", current_position)
+                    })?
+                };
+                output_queue.push_back(Token::Brightness(value));
+            }
+            'i' => {
+                // this is just invert
+                output_queue.push_back(Token::Invert);
+            }
             c if char_to_token(c).is_some() => {
                 push_number_buffer(&mut number_buffer, &mut output_queue, current_position)?;
                 if let Some(token) = char_to_token(c) {