Move progress reporting into separate trait.

Author: jschlumpp

src/bin/cli.rs

@@ -7,15 +7,51 @@
 extern crate geometrify;
 extern crate image;
 extern crate clap;
-
+extern crate pbr;
 
 use clap::{Arg, App, AppSettings};
 
-use geometrify::{RandomPointGenerator, Filter};
+use geometrify::{ProgressReporter, RandomPointGenerator, Filter};
 use geometrify::geometrify::Geometrify;
 
 use image::open;
 use std::path::Path;
+use std::io::Stdout;
+
+use pbr::ProgressBar;
+
+struct PbrProgressReporter {
+    bar: Option<ProgressBar<Stdout>>,
+}
+
+impl PbrProgressReporter {
+    fn new() -> PbrProgressReporter {
+        PbrProgressReporter {
+            bar: None,
+        }
+    }
+}
+
+impl ProgressReporter for PbrProgressReporter {
+    fn init(&mut self, steps: u64) {
+        let mut progress = ProgressBar::new(steps);
+        progress.format("|#--|");
+        self.bar = Some(progress);
+    }
+
+    fn step(&mut self) {
+        let ref mut bar = self.bar.as_mut().expect("ProgressReporter was not initialized");
+        bar.inc();
+    }
+
+    fn finish(&mut self) {
+        {
+            let ref mut bar = self.bar.as_mut().expect("ProgressReporter was not initialized");
+            bar.finish();
+        }
+        self.bar = None;
+    }
+}
 
 fn main() {
     let matches = App::new("Geometrify Filter")
@@ -72,8 +108,8 @@ fn main() {
             .expect("invalid samples parameter"),
     );
 
-
-    let outputbuf = filter.apply(&sourcebuf);
+    let mut progress = PbrProgressReporter::new();
+    let outputbuf = filter.apply(&sourcebuf, &mut progress);
 
     outputbuf
         .save(&Path::new(matches.value_of("OUTPUT").expect("expected output file")))

src/bin/web.rs

@@ -8,12 +8,43 @@
 #![plugin(rocket_codegen)]
 
 extern crate rocket;
+extern crate geometrify;
+extern crate image;
+
+use rocket::Data;
+
+use std::io::Read;
+
+use geometrify::{Filter, RandomPointGenerator};
+use geometrify::geometrify::Geometrify;
 
 #[get("/")]
 fn index() -> &'static str {
     "Hello world!"
 }
 
+#[post("/geometrify", format="image/png", data = "<data>")]
+fn geometrify_process(data: Data) -> &'static str {
+    let mut buf = vec!();
+    data.open().read_to_end(&mut buf).expect("Can't read into memory");
+    let image = image::load_from_memory(&buf).expect("Can't load image").to_rgba();
+    drop(buf);
+
+    let pointgen = Box::new(RandomPointGenerator::new());
+    let mut filter = Geometrify::new(
+        pointgen,
+        4,
+        6,
+    );
+
+    let out = filter.apply(&image);
+
+    "ok"
+}
+
 fn main() {
-    rocket::ignite().mount("/", routes![index]).launch();
-}
+    rocket::ignite().mount("/", routes![
+        index,
+        geometrify_process
+    ]).launch();
+}

src/geometrify.rs

@@ -4,11 +4,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-use super::{Point, BoundingBox, PointGenerator, Filter};
+use super::{Point, BoundingBox, PointGenerator, Filter, ProgressReporter};
 use image::{Rgba, RgbaImage, Pixel};
 
-use pbr::ProgressBar;
-
 use rayon::prelude::*;
 
 trait Primitive {
@@ -296,9 +294,8 @@ impl Geometrify {
 }
 
 impl Filter for Geometrify {
-    fn apply(&mut self, image: &RgbaImage) -> RgbaImage {
-        let mut progress = ProgressBar::new(self.iterations as u64);
-        progress.format("|#--|");
+    fn apply(&mut self, image: &RgbaImage, progress: &mut ProgressReporter) -> RgbaImage {
+        progress.init(self.iterations as u64);
 
         let mut destination = RgbaImage::new(image.width(), image.height());
 
@@ -335,9 +332,9 @@ impl Filter for Geometrify {
                 &mut destination,
                 &min_primitive.expect("no fitting triangle found").0,
             );
-            progress.inc();
+            progress.step();
         }
-        progress.finish_print("done");
+        progress.finish();
 
         destination
     }

src/lib.rs

@@ -7,7 +7,6 @@
 extern crate image;
 extern crate rand;
 extern crate rayon;
-extern crate pbr;
 
 pub mod geometrify;
 
@@ -62,8 +61,28 @@ impl PointGenerator for RandomPointGenerator {
     }
 }
 
+pub trait ProgressReporter {
+    fn init(&mut self, count: u64);
+    fn step(&mut self);
+    fn finish(&mut self);
+}
+
+pub struct SilentProgressReporter;
+
+impl ProgressReporter {
+    pub fn new() -> SilentProgressReporter {
+        SilentProgressReporter { }
+    }
+}
+
+impl ProgressReporter for SilentProgressReporter {
+    fn init(&mut self, _: u64) { }
+    fn step(&mut self) { }
+    fn finish(&mut self) { }
+}
+
 pub trait Filter {
-    fn apply(&mut self, image: &RgbaImage) -> RgbaImage;
+    fn apply(&mut self, image: &RgbaImage, progress: &mut ProgressReporter) -> RgbaImage;
 }
 
 #[cfg(test)]