Move iterations/samples parameter away from apply method.

Author: jschlumpp

src/bin/cli.rs

@@ -50,23 +50,23 @@ fn main() {
 
 
     let pointgen = Box::new(RandomPointGenerator::new());
-    let mut filter = Geometrify::new(pointgen);
-
-
-    let outputbuf = filter.apply(
-        sourcebuf,
+    let mut filter = Geometrify::new(
+        pointgen,
         matches
             .value_of("iterations")
             .unwrap_or("100")
-            .parse::<i32>()
+            .parse::<u32>()
             .expect("invalid iterations parameter"),
         matches
             .value_of("samples")
             .unwrap_or("50")
-            .parse::<i32>()
+            .parse::<u32>()
             .expect("invalid samples parameter"),
     );
 
+
+    let outputbuf = filter.apply(sourcebuf);
+
     outputbuf
         .save(&Path::new(matches.value_of("OUTPUT").expect("expected output file")))
         .expect("Can't save image");

src/lib.rs

@@ -150,11 +150,25 @@ impl PointGenerator for RandomPointGenerator {
 
 pub struct Geometrify {
     point_gen: Box<RandomPointGenerator>,
+    iterations: u32,
+    samples: u32,
 }
 
 impl Geometrify {
-    pub fn new(point_gen: Box<RandomPointGenerator>) -> Geometrify {
-        Geometrify { point_gen: point_gen }
+    pub fn new(point_gen: Box<RandomPointGenerator>, iterations: u32, samples: u32) -> Geometrify {
+        Geometrify {
+            point_gen: point_gen,
+            iterations: iterations,
+            samples: samples,
+        }
+    }
+
+    pub fn set_iterations(&mut self, iterations: u32) {
+        self.iterations = iterations
+    }
+
+    pub fn set_samples(&mut self, samples: u32) {
+        self.samples = samples
     }
 
     fn calculate_color(image: &RgbaImage, primitive: &Primitive) -> Rgba<u8> {
@@ -321,20 +335,16 @@ impl Geometrify {
         result
     }
 
-    pub fn apply(&mut self,
-                 image: RgbaImage,
-                 number_of_iterations: i32,
-                 number_of_samples: i32)
-                 -> RgbaImage {
-        let mut progress = ProgressBar::new(number_of_iterations as u64);
+    pub fn apply(&mut self, image: RgbaImage) -> RgbaImage {
+        let mut progress = ProgressBar::new(self.iterations as u64);
         progress.format("|#--|");
 
         let mut destination = RgbaImage::new(image.width(), image.height());
 
-        for _ in 0..number_of_iterations {
+        for _ in 0..self.iterations {
             let difference_lut = Geometrify::calculate_difference_lut(&image, &destination);
 
-            let primitives = (0..number_of_samples)
+            let primitives = (0..self.samples)
                 .map(|_| self.generate_primitive(image.width(), image.height()))
                 .map(
                     |mut p| {