added further output and set up the correct way to specify zoom out

Author: jackyarndley

default.toml

@@ -1,2 +1,3 @@
 image_width = 1000
-image_height = 1000
+image_height = 1000
+frames = 1

src/bin/main.rs

@@ -1,4 +1,3 @@
-use std::time::Instant;
 use rust_fractal::renderer::FractalRenderer;
 use clap::{crate_version, crate_name, crate_authors, crate_description, App, Arg};
 use config::{Config, File};
@@ -40,10 +39,6 @@ fn main() {
     };
 
     let mut renderer = FractalRenderer::new(settings);
-
-    let time = Instant::now();
-
-    renderer.render("output/output".to_owned());
-    // renderer.render_sequence(2.0);
-    println!("{:<14}{:>6} ms", "TOTAL", time.elapsed().as_millis());
+    // renderer.render("output/output".to_owned());
+    renderer.render();
 }

src/math/perturbation.rs

@@ -7,7 +7,7 @@ pub struct Perturbation {}
 
 impl Perturbation {
     pub fn iterate(pixel_data: &mut Vec<PixelData>, reference: &Reference, reference_current_iteration: usize) {
-        pixel_data.par_chunks_mut(64)
+        pixel_data.par_chunks_mut(8)
             .for_each(|pixel_data| {
                 for pixel in pixel_data {
                     let mut scaled_iterations = 0;

src/math/reference.rs

@@ -37,8 +37,7 @@ impl Reference {
 
         // This is if we need to use the extended precision for the reference
         if z_fixed.re.abs() < 1e-300 && z_fixed.im.abs() < 1e-300 {
-        // if true {
-            println!("found slow at: {}", self.current_iteration);
+            // println!("found slow at: {}", self.current_iteration);
             let mut temp = to_extended(&self.z);
             temp.reduce();
             self.data.push(

src/math/series_approximation.rs

@@ -1,4 +1,4 @@
-use crate::util::{ComplexArbitrary, to_extended, to_fixed};
+use crate::util::{ComplexArbitrary, to_extended};
 use crate::util::complex_extended::ComplexExtended;
 use crate::math::reference::Reference;
 use rug::Float;
@@ -10,6 +10,7 @@ pub struct SeriesApproximation {
     maximum_iteration: usize,
     delta_pixel_square: FloatExtended,
     z: ComplexArbitrary,
+    z_prev: ComplexArbitrary,
     c: ComplexArbitrary,
     pub order: usize,
     coefficients: Vec<ComplexExtended>,
@@ -34,6 +35,7 @@ impl SeriesApproximation {
             maximum_iteration,
             delta_pixel_square,
             z: c.clone(),
+            z_prev: c.clone(),
             c,
             order,
             coefficients: coefficients.clone(),
@@ -65,16 +67,10 @@ impl SeriesApproximation {
 
         // Can be changed later into a better loop - this function could also return some more information
         while self.current_iteration < self.maximum_iteration {
-            let test = self.z.clone();
+            self.z_prev = self.z.clone();
             self.z.square_mut();
             self.z += &self.c;
 
-            let z_fixed = to_fixed(&self.z);
-
-            if z_fixed.re.abs() < 1e-300 && z_fixed.im.abs() < 1e-300 {
-                println!("found slow at: {}", self.current_iteration);
-            }
-
             self.next_coefficients[0] = to_extended(&self.z);
             self.next_coefficients[1] = self.coefficients[0] * self.coefficients[1] * 2.0 + add_value;
             self.next_coefficients[0].reduce();
@@ -129,7 +125,7 @@ impl SeriesApproximation {
 
                 // Check that the error over the derivative is less than the pixel spacing
                 if relative_error / derivative > self.delta_pixel_square {
-                    self.z = test.clone();
+                    self.z = self.z_prev.clone();
                     return;
                 }
             }

src/renderer.rs

@@ -1,5 +1,5 @@
 use crate::util::{data_export::*, ComplexFixed, ComplexArbitrary, PixelData, complex_extended::ComplexExtended, float_extended::FloatExtended, string_to_extended, extended_to_string};
-use crate::math::{SeriesApproximation, Perturbation};
+use crate::math::{SeriesApproximation, Perturbation, Reference};
 
 use std::time::Instant;
 use std::cmp::{min, max};
@@ -18,18 +18,27 @@ pub struct FractalRenderer {
     approximation_order: usize,
     glitch_tolerance: f64,
     data_export: DataExport,
+    start_render_time: Instant,
+    remaining_frames: usize,
+    zoom_scale_factor: f64,
+    center_reference: Reference,
 }
 
 impl FractalRenderer {
     pub fn new(settings: Config) -> Self {
-        let image_width = settings.get_int("image_width").unwrap() as usize;
-        let image_height = settings.get_int("image_height").unwrap() as usize;
-        let maximum_iteration = settings.get_int("iterations").unwrap() as usize;
-        let initial_zoom = settings.get_str("zoom").unwrap();
-        let center_real = settings.get_str("real").unwrap();
-        let center_imag = settings.get_str("imag").unwrap();
-        let approximation_order = 8;
-        let glitch_tolerance = 0.01;
+        // Print out the status information
+        println!("{:<6}| {:<14}| {:<14}| {:<14}| {:<14}| {:<14}| {:<14}| {:<14}| {:<14}| {:<14}| {:<14}", "Frame", "Zoom", "Approx [ms]", "Skipped [it]", "Reference [ms]", "Packing [ms]", "Iteration [ms]", "Colouring [ms]", "Correct [ms]", "Saving [ms]", "TOTAL [ms]");
+
+        let image_width = settings.get_int("image_width").unwrap_or(1000) as usize;
+        let image_height = settings.get_int("image_height").unwrap_or(1000) as usize;
+        let maximum_iteration = settings.get_int("iterations").unwrap_or(1000) as usize;
+        let initial_zoom = settings.get_str("zoom").unwrap_or("1E0".to_string());
+        let center_real = settings.get_str("real").unwrap_or("-0.75".to_string());
+        let center_imag = settings.get_str("imag").unwrap_or("0.0".to_string());
+        let approximation_order = settings.get_int("approximation_order").unwrap_or(0) as usize;
+        let glitch_tolerance = settings.get_float("glitch_tolerance").unwrap_or(0.01);
+        let remaining_frames = settings.get_int("frames").unwrap_or(1) as usize;
+        let zoom_scale_factor = settings.get_float("zoom_scale").unwrap_or(2.0);
         let display_glitches = false;
 
         let aspect = image_width as f64 / image_height as f64;
@@ -56,23 +65,42 @@ impl FractalRenderer {
             image_height,
             aspect,
             zoom,
-            center_location,
+            center_location: center_location.clone(),
             maximum_iteration,
             approximation_order: auto_approximation,
             glitch_tolerance,
-            data_export: DataExport::new(image_width, image_height, display_glitches, DataType::BOTH)
+            data_export: DataExport::new(image_width, image_height, display_glitches, DataType::BOTH),
+            start_render_time: Instant::now(),
+            remaining_frames,
+            zoom_scale_factor,
+            center_reference: Reference::new(center_location.clone(), center_location, 1, maximum_iteration)
         }
     }
 
-    pub fn render(&mut self, filename: String) {
+    pub fn render_frame(&mut self, index: usize, filename: String) {
+        print!("{:<6}", index);
+        let frame_time = Instant::now();
+
+        // If we are on the first frame
+        // if index == 0 {
+        //     self.center_reference.run();
+        //     println!("{}", self.center_reference.current_iteration);
+        // }
+
+
+
+
+
+
+
         let delta_pixel =  (-2.0 * (4.0 / self.image_height as f64 - 2.0) / self.zoom.mantissa) / self.image_height as f64;
 
         // this should be the delta relative to the image, without the big zoom factor applied.
         let delta_top_left = ComplexFixed::new((4.0 / self.image_width as f64 - 2.0) / self.zoom.mantissa * self.aspect as f64, (4.0 / self.image_height as f64 - 2.0) / self.zoom.mantissa);
 
         let time = Instant::now();
 
-        println!("{:<7}{:>16}", "Zoom", extended_to_string(self.zoom));
+        print!("| {:<14}", extended_to_string(self.zoom));
 
         let delta_pixel_extended = FloatExtended::new(delta_pixel, -self.zoom.exponent);
 
@@ -88,15 +116,15 @@ impl FractalRenderer {
 
         series_approximation.run();
 
-        println!("{:<14}{:>6} ms", "Approximation", time.elapsed().as_millis());
-        println!("{:<10}{:>13} (order {})", "Skipped", series_approximation.current_iteration, series_approximation.order);
+        print!("| {:<14}", time.elapsed().as_millis());
+        print!("| {:<14}", series_approximation.current_iteration);
 
         let time = Instant::now();
 
         let mut reference = series_approximation.get_reference(ComplexExtended::new2(0.0, 0.0, 0));
         reference.run();
 
-        println!("{:<14}{:>6} ms (precision {}, iterations {})", "Reference", time.elapsed().as_millis(), self.center_location.prec().0, reference.current_iteration);
+        print!("| {:<14}", time.elapsed().as_millis());
 
         let time = Instant::now();
 
@@ -122,15 +150,15 @@ impl FractalRenderer {
                 }
             }).collect::<Vec<PixelData>>();
 
-        println!("{:<14}{:>6} ms", "Packing", time.elapsed().as_millis());
+        print!("| {:<14}", time.elapsed().as_millis());
 
         let time = Instant::now();
         Perturbation::iterate(&mut pixel_data, &reference, reference.current_iteration);
-        println!("{:<14}{:>6} ms", "Iteration", time.elapsed().as_millis());
+        print!("| {:<14}", time.elapsed().as_millis());
 
         let time = Instant::now();
         self.data_export.export_pixels(&pixel_data, self.maximum_iteration, &reference);
-        println!("{:<14}{:>6} ms", "Coloring", time.elapsed().as_millis());
+        print!("| {:<14}", time.elapsed().as_millis());
 
         let time = Instant::now();
 
@@ -173,20 +201,21 @@ impl FractalRenderer {
             });
         }
 
-        println!("{:<14}{:>6} ms (remaining {})", "Fixing", time.elapsed().as_millis(), pixel_data.len());
+        print!("| {:<14}", time.elapsed().as_millis());
 
         let time = Instant::now();
         self.data_export.save(&filename);
-        println!("{:<14}{:>6} ms", "Saving", time.elapsed().as_millis());
-        return;
+        print!("| {:<14}", time.elapsed().as_millis());
+        println!("| {:<8} {:<8}", frame_time.elapsed().as_millis(), self.start_render_time.elapsed().as_millis());
     }
 
-    pub fn render_sequence(&mut self, scale_factor: f64) {
+    pub fn render(&mut self) {
         let mut count = 0;
-        while self.zoom.to_float() > 0.5 {
-            self.render(format!("output/keyframe_{:08}", count));
-            self.zoom.mantissa /= scale_factor;
+        while self.remaining_frames > 0 && self.zoom.to_float() > 0.5 {
+            self.render_frame(count, format!("output/keyframe_{:08}", count));
+            self.zoom.mantissa /= self.zoom_scale_factor;
             self.zoom.reduce();
+            self.remaining_frames -= 1;
             count += 1;
         }
     }