Fixed warnings.

Author: jschlumpp

src/lib.rs

@@ -43,7 +43,7 @@ struct Triangle {
     c: Point,
     color: Option<Rgba<u8>>,
 
-    spanDiv: Option<f32>,
+    span_div: Option<f32>,
 }
 
 impl Triangle {
@@ -53,36 +53,36 @@ impl Triangle {
             b: b,
             c: c,
             color: None,
-            spanDiv: None,
+            span_div: None,
         }
     }
 
-    fn spanDivSave(&mut self) {
-        self.spanDiv = Some(self.spanDiv());
+    fn span_div_save(&mut self) {
+        self.span_div = Some(self.span_div());
     }
 
-    fn spanDiv(&self) -> f32 {
-        match self.spanDiv {
+    fn span_div(&self) -> f32 {
+        match self.span_div {
             Some(div) => div,
             None => {
-                let spanA = Point { x: self.b.x - self.a.x, y: self.b.y - self.a.y };
-                let spanB = Point { x: self.c.x - self.a.x, y: self.c.y - self.a.y };
+                let span_a = Point { x: self.b.x - self.a.x, y: self.b.y - self.a.y };
+                let span_b = Point { x: self.c.x - self.a.x, y: self.c.y - self.a.y };
 
-                1.0 / spanA.cross_product(spanB) as f32
+                1.0 / span_a.cross_product(span_b) as f32
             }
         }
     }
 }
 
 impl Primitive for Triangle {
     fn is_inside_primitive(&self, p: Point) -> bool {
-        let spanA = Point { x: self.b.x - self.a.x, y: self.b.y - self.a.y };
-        let spanB = Point { x: self.c.x - self.a.x, y: self.c.y - self.a.y };
+        let span_a = Point { x: self.b.x - self.a.x, y: self.b.y - self.a.y };
+        let span_b = Point { x: self.c.x - self.a.x, y: self.c.y - self.a.y };
 
         let q = Point { x: p.x - self.a.x, y: p.y - self.a.y };
 
-        let s = q.cross_product(spanB) as f32 * self.spanDiv();
-        let t = spanA.cross_product(q) as f32 * self.spanDiv();
+        let s = q.cross_product(span_b) as f32 * self.span_div();
+        let t = span_a.cross_product(q) as f32 * self.span_div();
 
         (s >= 0.0) && (t >= 0.0) && ((s + t) <= 1.0)
     }
@@ -189,13 +189,13 @@ impl Geometrify {
         //     for x in 0..image.width() {
                 let p = Point {x: x as i32, y: y as i32};
                 if primitive.is_inside_primitive(p) {
-                    *image.get_pixel_mut(x as u32, y as u32) = Geometrify::mixColor(primitive.get_color().expect("color of triangle not set"), *image.get_pixel(x as u32, y as u32));
+                    *image.get_pixel_mut(x as u32, y as u32) = Geometrify::mix_color(primitive.get_color().expect("color of triangle not set"), *image.get_pixel(x as u32, y as u32));
                 }
             }
         }
     }
 
-    fn mixColor(first: Rgba<u8>, second: Rgba<u8>) -> Rgba<u8> {
+    fn mix_color(first: Rgba<u8>, second: Rgba<u8>) -> Rgba<u8> {
         let (r1, g1, b1, a1) = first.channels4();
         let (r2, g2, b2, a2) = second.channels4();
 
@@ -241,16 +241,16 @@ impl Geometrify {
 
         for y in bb.top_left.y..bb.bottom_right.y {
             for x in bb.top_left.x..bb.bottom_right.x {
-                let originalRgb = original.get_pixel(x as u32, y as u32);
-                let resultRgb = if (bb.top_left.x as u32 <= x as u32) && (x as u32 <= bb.bottom_right.x as u32)
+                let original_rgb = original.get_pixel(x as u32, y as u32);
+                let result_rgb = if (bb.top_left.x as u32 <= x as u32) && (x as u32 <= bb.bottom_right.x as u32)
                     && (bb.top_left.y as u32 <= y as u32) && (y as u32 <= bb.bottom_right.y as u32)
                     && (primitive.is_inside_primitive(Point { x: x as i32, y: y as i32 })) {
-                        Geometrify::mixColor(*current.get_pixel(x as u32, y as u32), primitive.get_color().expect("triangle color not "))
+                        Geometrify::mix_color(*current.get_pixel(x as u32, y as u32), primitive.get_color().expect("triangle color not "))
                     } else {
                         *current.get_pixel(x as u32, y as u32)
                     };
 
-                d += Geometrify::difference(*originalRgb, resultRgb) as u64;
+                d += Geometrify::difference(*original_rgb, result_rgb) as u64;
             }
         }
 
@@ -280,32 +280,32 @@ impl Geometrify {
         result
     }
 
-    pub fn apply(&mut self, image: RgbaImage, numberOfIterations: i32, numberOfSamples: i32) -> RgbaImage {
-        let mut progress = ProgressBar::new(numberOfIterations as u64);
+    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);
         progress.format("|#--|");
 
         let mut destination = RgbaImage::new(image.width(), image.height());
 
-        for _ in 0..numberOfIterations {
+        for _ in 0..number_of_iterations {
             let difference_lut = Geometrify::calculate_difference_lut(&image, &destination);
 
-            let primitives = (0..numberOfSamples)
+            let primitives = (0..number_of_samples)
                 .map(|_| {
                     self.generate_primitive()
                 })
                 .map(|mut p| {
-                    p.spanDivSave();
+                    p.span_div_save();
                     p
                 }).collect::<Vec<Triangle>>();
-            let minPrimitive = primitives.par_iter()
+            let min_primitive = primitives.par_iter()
                 .map(|primitive| {
                     let mut prim = *primitive;
                     prim.color = Some(Geometrify::calculate_color(&image, &prim));
                     (prim, Geometrify::calculate_difference(&image, &destination, &difference_lut, &prim))
                 })
                 .min_by_key(|tup| tup.1);
 
-            Geometrify::add_to_image(&mut destination, &minPrimitive.expect("no fitting triangle found").0);
+            Geometrify::add_to_image(&mut destination, &min_primitive.expect("no fitting triangle found").0);
             progress.inc();
         }
         progress.finish_print("done");