Add swap transformation

src/main.rs

@@ -43,6 +43,8 @@ struct Args {
     char_pattern: Vec<PatternEnum>,
     #[clap(long)]
     char_invert: Option<bool>,
+    #[clap(long)]
+    char_swap: Option<bool>,
     #[clap(long, value_enum)]
     colors: Vec<PalletEnum>,
     #[clap(long, value_enum)]
@@ -51,6 +53,8 @@ struct Args {
     color_shift: Option<bool>,
     #[clap(long)]
     color_invert: Option<bool>,
+    #[clap(long)]
+    color_swap: Option<bool>,
 }
 
 #[derive(ValueEnum, Clone)]
@@ -94,15 +98,26 @@ struct PatternConfig<'a> {
     patterns: &'a Vec<PatternEnum>,
     shift: Option<bool>,
     invert: Option<bool>,
+    swap: Option<bool>,
 }
 
 impl Args {
     fn char_config(&self) -> PatternConfig {
-        PatternConfig::new(&self.char_pattern, Some(true), self.char_invert)
+        PatternConfig::new(
+            &self.char_pattern,
+            Some(true),
+            self.char_invert,
+            self.char_swap,
+        )
     }
 
     fn color_config(&self) -> PatternConfig {
-        PatternConfig::new(&self.color_pattern, self.color_shift, self.color_invert)
+        PatternConfig::new(
+            &self.color_pattern,
+            self.color_shift,
+            self.color_invert,
+            self.color_swap,
+        )
     }
 
     fn pallet(&self, rand: &mut impl Rng) -> Vec<Color> {
@@ -161,6 +176,9 @@ impl<'a> PatternConfig<'a> {
         if self.invert.unwrap_or(rand.gen()) {
             pattern = Box::new(InvertFactory::new(pattern))
         }
+        if self.swap.unwrap_or(rand.gen()) {
+            pattern = Box::new(SwapFactory::new(pattern))
+        }
         pattern
     }
 }

src/transform/mod.rs

@@ -1,5 +1,7 @@
 mod invert;
 mod shift;
+mod swap;
 
 pub use invert::*;
 pub use shift::*;
+pub use swap::*;

src/transform/swap.rs

@@ -0,0 +1,27 @@
+use crate::pattern::*;
+use crate::Vector;
+
+#[derive(derive_more::Constructor)]
+pub struct SwapFactory {
+    child: Box<dyn PatternFactory>,
+}
+
+#[derive(derive_more::Constructor)]
+pub struct Swap {
+    child: Box<dyn Pattern>,
+}
+
+impl PatternFactory for SwapFactory {
+    fn create(&self, config: &Config) -> Box<dyn Pattern> {
+        let mut copy = config.clone();
+        copy.size = config.size.swap();
+
+        Box::new(Swap::new(self.child.create(&copy)))
+    }
+}
+
+impl Pattern for Swap {
+    fn sample(&self, pos: Vector) -> f32 {
+        self.child.sample(pos.swap())
+    }
+}

src/vec.rs

@@ -32,6 +32,10 @@ impl Vector {
     pub fn angle(&self) -> f32 {
         self.y.atan2(self.x)
     }
+
+    pub fn swap(&self) -> Vector {
+        Self::new(self.y, self.x)
+    }
 }
 
 #[cfg(test)]
@@ -70,4 +74,9 @@ mod test {
     fn angle() {
         assert_abs_diff_eq!(-1.5, Vector::new(2.0, -20.0).angle(), epsilon = 0.1);
     }
+
+    #[test]
+    fn swap() {
+        assert_eq!(Vector::new(7.0, 2.0), Vector::new(2.0, 7.0).swap());
+    }
 }