Add --flips-and-rotates flag

cli/src/main.rs

@@ -5,7 +5,8 @@ use structopt::StructOpt;
 
 use std::path::PathBuf;
 use texture_synthesis::{
-    image::ImageOutputFormat as ImgFmt, Dims, Error, Example, ImageSource, SampleMethod, Session,
+    image::ImageOutputFormat as ImgFmt, load_dynamic_image, Dims, Error, Example, ImageSource,
+    SampleMethod, Session,
 };
 
 fn parse_size(input: &str) -> Result<Dims, std::num::ParseIntError> {
@@ -60,6 +61,20 @@ struct TransferStyle {
     guide: PathBuf,
 }
 
+#[derive(StructOpt)]
+#[structopt(rename_all = "kebab-case")]
+struct FlipsAndRotates {
+    /// A target guidance map
+    #[structopt(long, parse(from_os_str))]
+    target_guide: Option<PathBuf>,
+    /// Path(s) to guide maps for the example output.
+    #[structopt(long = "guides", parse(from_os_str))]
+    example_guides: Vec<PathBuf>,
+    /// Path(s) to example images used to synthesize a new image
+    #[structopt(parse(from_os_str))]
+    examples: Vec<PathBuf>,
+}
+
 #[derive(StructOpt)]
 enum Subcommand {
     /// Transfers the style from an example onto a target guide
@@ -68,6 +83,10 @@ enum Subcommand {
     /// Generates a new image from 1 or more examples
     #[structopt(name = "generate")]
     Generate(Generate),
+    /// Generates a new image from 1 or more examples, extended with their
+    /// flipped and rotated versions
+    #[structopt(name = "flips-and-rotates")]
+    FlipsAndRotates(FlipsAndRotates),
 }
 
 #[derive(StructOpt)]
@@ -215,6 +234,32 @@ fn real_main() -> Result<(), Error> {
 
             (examples, gen.target_guide.as_ref())
         }
+        Subcommand::FlipsAndRotates(fr) => {
+            let mut examples: Vec<_> = fr.examples.iter().map(Example::new).collect();
+            if !fr.example_guides.is_empty() {
+                for (ex, guide) in examples.iter_mut().zip(fr.example_guides.iter()) {
+                    ex.with_guide(guide);
+                }
+            }
+
+            let mut transformed_examples: Vec<_> = vec![];
+            for example_path in &fr.examples {
+                let base_image = load_dynamic_image(example_path.into())?;
+                let mut new_examples: Vec<_> = vec![
+                    Example::new(base_image.fliph()),
+                    Example::new(base_image.rotate90()),
+                    Example::new(base_image.fliph().rotate90()),
+                    Example::new(base_image.rotate180()),
+                    Example::new(base_image.fliph().rotate180()),
+                    Example::new(base_image.rotate270()),
+                    Example::new(base_image.fliph().rotate270()),
+                ];
+                transformed_examples.append(&mut new_examples);
+            }
+            examples.append(&mut transformed_examples);
+
+            (examples, fr.target_guide.as_ref())
+        }
         Subcommand::TransferStyle(ts) => (vec![Example::new(&ts.style)], Some(&ts.guide)),
     };
 

lib/src/lib.rs

@@ -54,6 +54,7 @@ use std::path::Path;
 mod unsync;
 
 pub use image;
+pub use utils::load_dynamic_image;
 pub use utils::ImageSource;
 
 pub use errors::Error;

lib/src/utils.rs

@@ -29,16 +29,19 @@ where
     }
 }
 
-pub(crate) fn load_image(
-    src: ImageSource<'_>,
-    resize: Option<Dims>,
-) -> Result<image::RgbaImage, Error> {
-    let img = match src {
+pub fn load_dynamic_image(src: ImageSource<'_>) -> Result<image::DynamicImage, image::ImageError> {
+    match src {
         ImageSource::Memory(data) => image::load_from_memory(data),
         ImageSource::Path(path) => image::open(path),
         ImageSource::Image(img) => Ok(img),
-    }?;
+    }
+}
 
+pub(crate) fn load_image(
+    src: ImageSource<'_>,
+    resize: Option<Dims>,
+) -> Result<image::RgbaImage, Error> {
+    let img = load_dynamic_image(src)?;
     Ok(match resize {
         None => img.to_rgba(),
         Some(ref size) => {