Implemented sequence rendering

src/main.rs

@@ -4,10 +4,9 @@ extern crate num_complex;
 use image::{RgbImage, ImageBuffer, Rgb};
 use std::fmt::Error;
 use num_complex::Complex;
-use uuid::Uuid;
-use std::ops::Add;
+use indicatif::ProgressBar;
 
-const THRESHHOLD: f64 = 200.0;
+const THRESHHOLD: f64 = 200_i32.pow(2) as f64;
 
 fn calculate_color(number: Complex<f64>, iterations: u32) -> Result<Rgb<u8>, Error> {
     let mut z: Complex<f64> = Complex::new(0.0, 0.0);
@@ -18,7 +17,7 @@ fn calculate_color(number: Complex<f64>, iterations: u32) -> Result<Rgb<u8>, Err
 
         if cycle.contains(&z) { return Ok(Rgb::from([0, 0, 0])); }
 
-        if z.norm() > THRESHHOLD {
+        if z.norm_sqr() > THRESHHOLD {
             return Ok(map_num_to_color(i, iterations));
         }
 
@@ -32,21 +31,28 @@ fn map_num_to_color(i: u32, maximum: u32) -> Rgb<u8> {
     let frac: f32 = (i as f32 / maximum as f32) * 255.0 * 3.0;
 
     let r: u8;
-    if frac / 3.0 >= 255.0 {
-        r = 255
-    } else { r = (frac as i32 % 255) as u8 }
-
     let g: u8;
-    if frac / 3.0 >= 255.0 * 2.0 {
-        g = 255
-    } else { g = (frac as i32 % 255) as u8 }
-
     let b: u8;
-    if frac / 3.0 >= 255.0 * 3.0 {
-        b = 255
-    } else { b = (frac as i32 % 255) as u8 }
 
-    Rgb::from([r, g, b])
+    if frac < 255.0 {
+        r = frac.ceil() as u8;
+        g = 0;
+        b = 0;
+    } else if frac >= 255.0 && frac < 255.0 * 2.0 {
+        r = 255;
+        g = (frac as i32 % 255) as u8;
+        b = 0;
+    } else if frac >= 255.0 * 2.0 && frac < 255.0 * 3.0 {
+        r = 255;
+        g = 255;
+        b = (frac as i32 % 255) as u8;
+    } else {
+        r = 255;
+        g = 255;
+        b = 255;
+    }
+
+    Rgb::from([b, g, r])
 }
 
 fn generate_mandelbrot(width: u32,
@@ -59,8 +65,10 @@ fn generate_mandelbrot(width: u32,
     let section_width: f64 = (upper_left.re - lower_right.re).abs();
     let section_height: f64 = (upper_left.im - lower_right.im).abs();
 
+    let bar = ProgressBar::new(width as u64);
+
     for x in 0..width {
-        println!("Col: {}", x);
+        bar.inc(1);
         for y in 0..height {
             let x_offset: f64 = (x as f64 / width as f64) * section_width;
             let y_offset: f64 = (y as f64 / width as f64) * section_height;
@@ -68,25 +76,61 @@ fn generate_mandelbrot(width: u32,
             let color = calculate_color(
                 Complex::new(upper_left.re + x_offset, upper_left.im + y_offset),
                 iterations).unwrap();
-
             out_image.put_pixel(x, y, color);
         }
     }
-
+    bar.finish_with_message("Rendered frame.");
     Ok(out_image)
 }
 
+fn render_around_point(image_size: u32,
+                       iterations: u32,
+                       window_size: f64,
+                       pivot_point: Complex<f64>) -> Result<RgbImage, Error> {
+    let upper_left: Complex<f64> = Complex::new(pivot_point.re - window_size / 2.0,
+                                                pivot_point.im - window_size / 2.0);
+
+    let lower_right: Complex<f64> = Complex::new(pivot_point.re + window_size / 2.0,
+                                                 pivot_point.im + window_size / 2.0);
+
+    generate_mandelbrot(image_size,
+                        image_size,
+                        iterations,
+                        upper_left,
+                        lower_right)
+}
+
+fn render_sequence(num_frames: u32,
+                   image_size: u32,
+                   iterations: u32,
+                   initial_size: f64,
+                   zoom_point: Complex<f64>,
+                   scale_factor: f32,
+                   path: String) {
+    let mut scale = initial_size;
+
+    for frame in 0..num_frames {
+        let fractal: RgbImage = render_around_point(image_size,
+                                                    iterations,
+                                                    scale,
+                                                    zoom_point)
+            .unwrap();
+
+        scale *= (1.0 - scale_factor) as f64;
+
+        let filename: String = path.clone() + "frame_" + &*frame.to_string() + ".png";
+        fractal.save(filename).unwrap();
+        println!("Rendered frame {}", frame);
+    }
+}
 
 fn main() {
-    let fractal: RgbImage = generate_mandelbrot(4096,
-                                                4096,
-                                                100,
-                                                Complex::new(-0.7, -0.7),
-                                                Complex::new(-0.4, -0.4))
-        .unwrap();
-
-    let filename: String = String::from("mandelbrot_")
-        .add(&Uuid::new_v4().to_string()) + ".png";
-
-    fractal.save(filename).unwrap();
+    render_sequence(10,
+                    500,
+                    200,
+                    1.0,
+                    Complex::new(-0.5, -0.5),
+                    1.0 / 10.0,
+                    "./out/".parse().unwrap(),
+    )
 }