refactor again the counters to get ready for UI

Author: jackyarndley

src/math/perturbation.rs

@@ -12,7 +12,7 @@ use std::sync::Arc;
 pub struct Perturbation {}
 
 impl Perturbation {
-    pub fn iterate_normal(pixel_data: &mut [PixelData], reference: &Reference, pixels_complete: Option<&Arc<RelaxedCounter>>) {
+    pub fn iterate_normal(pixel_data: &mut [PixelData], reference: &Reference, pixels_complete: &Arc<RelaxedCounter>) {
         pixel_data.par_chunks_mut(4)
             .for_each(|pixel_data| {
                 let mut new_pixels_complete = 0;
@@ -92,16 +92,11 @@ impl Perturbation {
                     }
                 }
 
-                match &pixels_complete {
-                    Some(complete) => {
-                        complete.add(new_pixels_complete);
-                    },
-                    _ => {}
-                }
+                pixels_complete.add(new_pixels_complete);
             });
     }
 
-    pub fn iterate_normal_plus_derivative(pixel_data: &mut [PixelData], reference: &Reference, pixels_complete: Option<&Arc<RelaxedCounter>>) {
+    pub fn iterate_normal_plus_derivative(pixel_data: &mut [PixelData], reference: &Reference, pixels_complete: &Arc<RelaxedCounter>) {
         pixel_data.par_chunks_mut(4)
             .for_each(|pixel_data| {
                 let mut new_pixels_complete = 0;
@@ -194,12 +189,7 @@ impl Perturbation {
                     }
                 }
 
-                match &pixels_complete {
-                    Some(complete) => {
-                        complete.add(new_pixels_complete);
-                    },
-                    _ => {}
-                }
+                pixels_complete.add(new_pixels_complete);
             });
     }
 }

src/math/reference.rs

@@ -73,7 +73,7 @@ impl Reference {
     }
 
 
-    pub fn run(&mut self, reference_counter: Option<&Arc<RelaxedCounter>>, reference_maximum_iteration_counter: Option<&Arc<RelaxedCounter>>) {
+    pub fn run(&mut self, reference_counter: &Arc<RelaxedCounter>, reference_maximum_iteration_counter: &Arc<RelaxedCounter>) {
         let z_fixed = to_fixed(&self.z);
         let z_tolerance = self.glitch_tolerance * z_fixed.norm_sqr();
 
@@ -100,26 +100,10 @@ impl Reference {
                 }
             }
 
-            match &reference_counter {
-                Some(complete) => {
-                    complete.inc();
-                },
-                _ => {}
-            }
+            reference_counter.inc();
 
             if !self.step() {
-                match &reference_counter {
-                    Some(complete) => {
-                        // Set the maximum value
-                        match &reference_maximum_iteration_counter {
-                            Some(maximum_iteration_counter) => {
-                                maximum_iteration_counter.add(usize::max_value() - self.maximum_iteration + complete.get() + 1);
-                            },
-                            _ => {}
-                        }
-                    },
-                    _ => {}
-                }
+                reference_maximum_iteration_counter.add(usize::max_value() - self.maximum_iteration + reference_counter.get() + 1);
 
                 break;
             };

src/math/series_approximation.rs

@@ -59,7 +59,7 @@ impl SeriesApproximation {
         }
     }
 
-    pub fn generate_approximation(&mut self, center_reference: &Reference, series_approximation_counter: Option<&Arc<RelaxedCounter>>) {
+    pub fn generate_approximation(&mut self, center_reference: &Reference, series_approximation_counter: &Arc<RelaxedCounter>) {
         // Reset the coefficients
         self.coefficients = vec![vec![ComplexExtended::new2(0.0, 0.0, 0); self.order as usize + 1]; 1];
 
@@ -101,12 +101,7 @@ impl SeriesApproximation {
 
             previous_coefficients = next_coefficients.clone();
 
-            match &series_approximation_counter {
-                Some(complete) => {
-                    complete.inc();
-                },
-                _ => {}
-            }
+            series_approximation_counter.inc();
 
             // only every 100th iteration (101, 201 etc)
             // This is 0, 100, 200 -> 1, 101, 201
@@ -127,7 +122,7 @@ impl SeriesApproximation {
         image_width: usize,
         image_height: usize,
         center_reference: &Reference,
-        series_validation_counter: Option<&Arc<RelaxedCounter>>) {
+        series_validation_counter: &Arc<RelaxedCounter>) {
         // Delete the previous probes and calculate new ones
         self.probe_start = Vec::new();
         self.approximation_probes = Vec::new();
@@ -213,12 +208,7 @@ impl SeriesApproximation {
             first_valid_iterations += 1;
         }
 
-        match &series_validation_counter {
-            Some(complete) => {
-                complete.inc();
-            },
-            _ => {}
-        }
+        series_validation_counter.inc();
 
         self.min_valid_iteration = first_valid_iterations;
 
@@ -339,12 +329,7 @@ impl SeriesApproximation {
             }
         }
 
-        match &series_validation_counter {
-            Some(complete) => {
-                complete.inc();
-            },
-            _ => {}
-        }
+        series_validation_counter.inc();
 
         self.valid_iterations = valid_iterations;
 

src/renderer.rs

@@ -1,4 +1,4 @@
-use crate::util::{data_export::*, ComplexFixed, ComplexArbitrary, PixelData, complex_extended::ComplexExtended, float_extended::FloatExtended, string_to_extended, extended_to_string_short, extended_to_string_long, get_approximation_terms, get_delta_top_left, generate_default_palette};
+use crate::util::{data_export::*, ComplexFixed, ComplexArbitrary, PixelData, complex_extended::ComplexExtended, float_extended::FloatExtended, string_to_extended, extended_to_string_short, extended_to_string_long, get_approximation_terms, get_delta_top_left, generate_default_palette, ProgressCounters};
 use crate::math::{SeriesApproximation, Perturbation, Reference};
 
 use std::time::{Duration, Instant};
@@ -15,7 +15,7 @@ use std::thread;
 use std::sync::Arc;
 use std::sync::mpsc;
 
-use atomic_counter::{AtomicCounter, RelaxedCounter};
+use atomic_counter::AtomicCounter;
 
 
 pub struct FractalRenderer {
@@ -39,6 +39,7 @@ pub struct FractalRenderer {
     jitter: bool,
     experimental: bool,
     show_output: bool,
+    pub progress: ProgressCounters,
     pub render_time: u128,
 }
 
@@ -154,6 +155,7 @@ impl FractalRenderer {
             jitter,
             experimental,
             show_output,
+            progress: ProgressCounters::new(maximum_iteration),
             render_time: 0
         }
     }
@@ -203,43 +205,13 @@ impl FractalRenderer {
         let frame_time = Instant::now();
         let approximation_time = Instant::now();
 
-        let reference_complete = Arc::new(RelaxedCounter::new(0));
-        let series_approximation_complete = Arc::new(RelaxedCounter::new(0));
-        let series_validaton_complete = Arc::new(RelaxedCounter::new(0));
-
-        let reference_counter = if self.show_output {
-            Some(&reference_complete)
-        } else {
-            None
-        };
-
-        let series_approximation_counter = if self.show_output {
-            Some(&series_approximation_complete)
-        } else {
-            None
-        };
-
-        let series_validation_counter = if self.show_output {
-            Some(&series_validaton_complete)
-        } else {
-            None
-        };
-
         let (tx, rx) = mpsc::channel();
 
-        let reference_maximum_iteration = Arc::new(RelaxedCounter::new(self.maximum_iteration));
-
-        let reference_maximum_iteration_counter = if self.show_output {
-            Some(&reference_maximum_iteration)
-        } else {
-            None
-        };
-
         if self.show_output {
-            let thread_counter_1 = Arc::clone(&reference_complete);
-            let thread_counter_2 = Arc::clone(&series_approximation_complete);
-            let thread_counter_3 = Arc::clone(&reference_maximum_iteration);
-            let thread_counter_4 = Arc::clone(&series_validaton_complete);
+            let thread_counter_1 = self.progress.reference.clone();
+            let thread_counter_2 = self.progress.series_approximation.clone();
+            let thread_counter_3 = self.progress.reference_maximum.clone();
+            let thread_counter_4 = self.progress.series_validation.clone();
             print!("|               ");
 
             thread::spawn(move || {
@@ -269,9 +241,9 @@ impl FractalRenderer {
         };
 
         if frame_index == 0 {
-            self.center_reference.run(reference_counter, reference_maximum_iteration_counter);
+            self.center_reference.run(&self.progress.reference, &self.progress.reference_maximum);
             self.series_approximation.maximum_iteration = self.center_reference.current_iteration;
-            self.series_approximation.generate_approximation(&self.center_reference, series_approximation_counter);
+            self.series_approximation.generate_approximation(&self.center_reference, &self.progress.series_approximation);
         } else {
             // If the image width/height changes intraframe (GUI) we need to regenerate some things
             if self.data_export.image_width != self.image_width || self.data_export.image_height != self.image_height {
@@ -286,7 +258,7 @@ impl FractalRenderer {
             // Check to see if the series approximation order has changed intraframe
             if self.series_approximation.order != (self.series_approximation.coefficients[0].len() - 1) {
                 // println!("order was: {}, is now: {}", (self.series_approximation.coefficients[0].len() - 1), self.series_approximation.order);
-                self.series_approximation.generate_approximation(&self.center_reference, series_approximation_counter);
+                self.series_approximation.generate_approximation(&self.center_reference, &self.progress.series_approximation);
             }
         }
 
@@ -316,7 +288,7 @@ impl FractalRenderer {
             self.image_width,
             self.image_height,
             &self.center_reference,
-            series_validation_counter);
+            &self.progress.series_validation);
 
         self.data_export.maximum_iteration = self.maximum_iteration;
 
@@ -415,20 +387,12 @@ impl FractalRenderer {
 
         let iteration_time = Instant::now();
 
-        let pixels_complete = Arc::new(RelaxedCounter::new(0));
-        
-        let counter = if self.show_output {
-            Some(&pixels_complete)
-        } else {
-            None
-        };
-
         let total_pixels = self.render_indices.len() as f64;
 
         let (tx, rx) = mpsc::channel();
 
         if self.show_output {
-            let thread_counter = Arc::clone(&pixels_complete);
+            let thread_counter = Arc::clone(&self.progress.iteration);
             print!("|               ");
 
             thread::spawn(move || {
@@ -449,9 +413,9 @@ impl FractalRenderer {
 
         // This one has no offset because it is not a glitch resolving reference
         if self.analytic_derivative {
-            Perturbation::iterate_normal_plus_derivative(&mut pixel_data, &self.center_reference, counter);
+            Perturbation::iterate_normal_plus_derivative(&mut pixel_data, &self.center_reference, &self.progress.iteration);
         } else {
-            Perturbation::iterate_normal(&mut pixel_data, &self.center_reference, counter);
+            Perturbation::iterate_normal(&mut pixel_data, &self.center_reference, &self.progress.iteration);
         };
 
         tx.send(()).unwrap();
@@ -477,7 +441,7 @@ impl FractalRenderer {
         let (tx, rx) = mpsc::channel();
 
         if self.show_output {
-            let thread_counter = Arc::clone(&pixels_complete);
+            let thread_counter = Arc::clone(&self.progress.iteration);
             print!("|               ");
 
             thread::spawn(move || {
@@ -504,7 +468,7 @@ impl FractalRenderer {
             let mut glitch_reference = self.series_approximation.get_reference(glitch_reference_pixel.delta_centre, &self.center_reference);
 
             correction_references += 1;
-            glitch_reference.run(None, None);
+            glitch_reference.run(&self.progress.reference, &self.progress.reference_maximum);
 
             let delta_current_reference = self.series_approximation.evaluate(glitch_reference_pixel.delta_centre, glitch_reference.start_iteration);
 
@@ -528,9 +492,9 @@ impl FractalRenderer {
             }
 
             if self.analytic_derivative {
-                Perturbation::iterate_normal_plus_derivative(&mut pixel_data, &glitch_reference, counter);
+                Perturbation::iterate_normal_plus_derivative(&mut pixel_data, &glitch_reference, &self.progress.iteration);
             } else {
-                Perturbation::iterate_normal(&mut pixel_data, &glitch_reference, counter);
+                Perturbation::iterate_normal(&mut pixel_data, &glitch_reference, &self.progress.iteration);
             };
 
             self.data_export.export_pixels(&pixel_data, &glitch_reference, delta_pixel_extended);
@@ -557,6 +521,8 @@ impl FractalRenderer {
 
         self.render_time = frame_time.elapsed().as_millis();
 
+        self.progress.reset(self.maximum_iteration);
+
         if self.show_output {
             print!("| {:<15}", saving_time.elapsed().as_millis());
             println!("| {:<15}| {:<15}", frame_time.elapsed().as_millis(), self.start_render_time.elapsed().as_millis());
@@ -590,7 +556,7 @@ impl FractalRenderer {
                     // Overwrite the series approximation order
                     self.series_approximation.order = 8;
                     self.series_approximation.maximum_iteration = self.center_reference.current_iteration;
-                    self.series_approximation.generate_approximation(&self.center_reference, None);
+                    self.series_approximation.generate_approximation(&self.center_reference, &self.progress.series_approximation);
                 }
 
                 // Logic in here to automatically adjust the maximum number of iterations
@@ -608,10 +574,10 @@ impl FractalRenderer {
             } else {
                 if self.series_approximation.min_valid_iteration < 1000 && self.series_approximation.order > 16 {
                     self.series_approximation.order = 16;
-                    self.series_approximation.generate_approximation(&self.center_reference, None);
+                    self.series_approximation.generate_approximation(&self.center_reference, &self.progress.series_approximation);
                 } else if self.series_approximation.min_valid_iteration < 10000 && self.series_approximation.order > 32 {
                     self.series_approximation.order = 32;
-                    self.series_approximation.generate_approximation(&self.center_reference, None);
+                    self.series_approximation.generate_approximation(&self.center_reference, &self.progress.series_approximation);
                 }
             }
 

src/util/mod.rs

@@ -5,10 +5,12 @@ pub mod data_export;
 pub mod float_extended;
 pub mod complex_extended;
 pub mod recolour_exr;
+pub mod progress;
 
 pub use complex_extended::ComplexExtended;
 pub use float_extended::FloatExtended;
 pub use recolour_exr::RecolourEXR;
+pub use progress::ProgressCounters;
 
 pub type ComplexFixed<T> = num_complex::Complex<T>;
 pub type ComplexArbitrary = rug::Complex;

src/util/progress.rs

@@ -0,0 +1,31 @@
+use atomic_counter::RelaxedCounter;
+
+use std::sync::Arc;
+
+pub struct ProgressCounters {
+    pub reference: Arc<RelaxedCounter>,
+    pub reference_maximum: Arc<RelaxedCounter>,
+    pub series_approximation: Arc<RelaxedCounter>,
+    pub series_validation: Arc<RelaxedCounter>,
+    pub iteration: Arc<RelaxedCounter>
+}
+
+impl ProgressCounters {
+    pub fn new(maximum_iteration: usize) -> ProgressCounters {
+        ProgressCounters {
+            reference: Arc::new(RelaxedCounter::new(0)),
+            reference_maximum: Arc::new(RelaxedCounter::new(maximum_iteration)),
+            series_approximation: Arc::new(RelaxedCounter::new(0)),
+            series_validation: Arc::new(RelaxedCounter::new(0)),
+            iteration: Arc::new(RelaxedCounter::new(0)),
+        }
+    }
+
+    pub fn reset(&mut self, maximum_iteration: usize) {
+        self.reference = Arc::new(RelaxedCounter::new(0));
+        self.reference_maximum = Arc::new(RelaxedCounter::new(maximum_iteration));
+        self.series_approximation = Arc::new(RelaxedCounter::new(0));
+        self.series_validation = Arc::new(RelaxedCounter::new(0));
+        self.iteration = Arc::new(RelaxedCounter::new(0));
+    }
+}