added option to disable series approximation

Author: jackyarndley

default.toml

@@ -19,7 +19,8 @@ data_storage_interval = 100
 
 valid_iteration_probe_multiplier = 0.01
 
-experimental = true  
+series_approximation_tiled = true
+series_approximation_enabled = true
 
 coloring_type = "iteration"
 

src/math/series_approximation.rs

@@ -12,6 +12,7 @@ pub struct SeriesApproximation {
     pub maximum_iteration: usize,
     pub delta_pixel_square: FloatExtended,
     pub order: usize,
+    pub generated_order: usize,
     pub coefficients: Vec<Vec<ComplexExtended>>,
     probe_start: Vec<ComplexExtended>,
     approximation_probes: Vec<Vec<ComplexExtended>>,
@@ -21,7 +22,8 @@ pub struct SeriesApproximation {
     pub valid_iterations: Vec<usize>,
     pub valid_interpolation: Vec<usize>,
     pub probe_sampling: usize,
-    pub experimental: bool,
+    pub tiled: bool,
+    pub enabled: bool,
     pub valid_iteration_probe_multiplier: f32,
     pub data_storage_interval: usize,
     pub fractal_type: FractalType
@@ -32,7 +34,8 @@ impl SeriesApproximation {
         maximum_iteration: usize, 
         delta_pixel_square: FloatExtended, 
         probe_sampling: usize, 
-        experimental: bool, 
+        tiled: bool, 
+        enabled: bool,
         valid_iteration_probe_multiplier: f32,
         data_storage_interval: usize,
         fractal_type: FractalType) -> Self {
@@ -42,6 +45,7 @@ impl SeriesApproximation {
             maximum_iteration,
             delta_pixel_square,
             order,
+            generated_order: 0,
             coefficients: Vec::new(),
             probe_start: Vec::new(),
             approximation_probes: Vec::new(),
@@ -51,14 +55,20 @@ impl SeriesApproximation {
             valid_iterations: Vec::new(),
             valid_interpolation: Vec::new(),
             probe_sampling,
-            experimental,
+            tiled,
+            enabled,
             valid_iteration_probe_multiplier,
             data_storage_interval,
             fractal_type
         }
     }
 
     pub fn generate_approximation(&mut self, center_reference: &Reference, series_approximation_counter: &Arc<AtomicUsize>, stop_flag: &Arc<AtomicBool>) {
+        if !self.enabled {
+            series_approximation_counter.store(1, Ordering::SeqCst);
+            return;
+        }
+
         series_approximation_counter.store(0, Ordering::SeqCst);
 
         // Reset the coefficients
@@ -116,6 +126,9 @@ impl SeriesApproximation {
 
             // self.coefficients.push(next_coefficients);
         }
+
+        // TODO maybe need something here to say series approximation was complete
+        self.generated_order = self.order;
     }
 
     pub fn check_approximation(&mut self, 
@@ -128,6 +141,15 @@ impl SeriesApproximation {
         image_height: usize,
         center_reference: &Reference,
         series_validation_counter: &Arc<AtomicUsize>) {
+
+        if !self.enabled {
+            self.min_valid_iteration = 1;
+            self.max_valid_iteration = 1;
+            
+            series_validation_counter.store(2, Ordering::SeqCst);
+            return;
+        }
+
         series_validation_counter.store(0, Ordering::SeqCst);
 
         // Delete the previous probes and calculate new ones
@@ -396,9 +418,8 @@ impl SeriesApproximation {
                 self.valid_interpolation.push(min_interpolation);
             }
         }
-
 
-        self.max_valid_iteration = if self.experimental {
+        self.max_valid_iteration = if self.tiled {
             *self.valid_interpolation.iter().max().unwrap()
         } else {
             self.min_valid_iteration
@@ -422,7 +443,7 @@ impl SeriesApproximation {
         //     print!("\x08]\n");
         // }
 
-        if !self.experimental {
+        if !self.tiled {
             self.valid_interpolation = vec![self.min_valid_iteration; (self.probe_sampling - 1) * (self.probe_sampling - 1)];
         }
     }

src/renderer.rs

@@ -42,7 +42,6 @@ pub struct FractalRenderer {
     pub pixel_data_type: DataType,
     pub jitter: bool,
     pub jitter_factor: f64,
-    pub experimental: bool,
     show_output: bool,
     pub progress: ProgressCounters,
     pub render_time: u128,
@@ -68,8 +67,11 @@ impl FractalRenderer {
         let frame_offset = settings.get_int("frame_offset").unwrap_or(0) as usize;
         let zoom_scale_factor = settings.get_float("zoom_scale").unwrap_or(2.0);
         let display_glitches = settings.get_bool("display_glitches").unwrap_or(false);
+
         let auto_adjust_iterations = settings.get_bool("auto_adjust_iterations").unwrap_or(true);
-        let experimental = settings.get_bool("experimental").unwrap_or(false);
+        let series_approximation_tiled = settings.get_bool("series_approximation_tiled").unwrap_or(true);
+        let series_approximation_enabled = settings.get_bool("series_approximation_enabled").unwrap_or(true);
+
         let probe_sampling = settings.get_int("probe_sampling").unwrap_or(3) as usize;
         let remove_centre = settings.get_bool("remove_centre").unwrap_or(false);
 
@@ -176,7 +178,8 @@ impl FractalRenderer {
             maximum_iteration, 
             FloatExtended::new(0.0, 0), 
             probe_sampling,
-            experimental,
+            series_approximation_tiled,
+            series_approximation_enabled,
             valid_iteration_probe_multiplier,
             data_storage_interval,
             fractal_type);
@@ -237,7 +240,6 @@ impl FractalRenderer {
             pixel_data_type,
             jitter,
             jitter_factor,
-            experimental,
             show_output,
             progress: ProgressCounters::new(maximum_iteration),
             render_time: 0,
@@ -302,7 +304,7 @@ impl FractalRenderer {
                 tx.send(()).unwrap();
                 return;
             };
-
+            
             self.series_approximation.maximum_iteration = self.center_reference.current_iteration;
             self.series_approximation.generate_approximation(&self.center_reference, &self.progress.series_approximation, &stop_flag);
         } else {
@@ -322,7 +324,7 @@ impl FractalRenderer {
             drop(export);
 
             // Check to see if the series approximation order has changed intraframe
-            if self.series_approximation.order != (self.series_approximation.coefficients[0].len() - 1) {
+            if self.series_approximation.enabled && self.series_approximation.order != self.series_approximation.generated_order {
                 self.series_approximation.min_valid_iteration = 1;
                 self.series_approximation.generate_approximation(&self.center_reference, &self.progress.series_approximation, &stop_flag);
             }
@@ -360,13 +362,12 @@ impl FractalRenderer {
             -self.zoom.exponent, 
             cos_rotate, 
             sin_rotate, 
-            delta_pixel,
+            delta_pixel, 
             self.image_width,
             self.image_height,
             &self.center_reference,
             &self.progress.series_validation);
 
-        // -1 because we already know that 1 iteration can be skipped (take z = c)
         self.progress.min_series_approximation.store(self.series_approximation.min_valid_iteration, Ordering::SeqCst);
         self.progress.max_series_approximation.store(self.series_approximation.max_valid_iteration, Ordering::SeqCst);
 
@@ -402,8 +403,8 @@ impl FractalRenderer {
                 let mut i = (index % self.image_width) as f64;
                 let mut j = (index / self.image_width) as f64;
 
-                let chosen_iteration = if self.fractal_type == FractalType::Mandelbrot2 {
-                    if self.experimental {
+                let chosen_iteration = if self.series_approximation.enabled {
+                    if self.series_approximation.tiled {
                         let test1 = (i * sampling_resolution_width).floor() as usize;
                         let test2 = (j * sampling_resolution_height).floor() as usize;
 
@@ -809,7 +810,10 @@ impl FractalRenderer {
         self.zoom_scale_factor = settings.get_float("zoom_scale").unwrap_or(2.0);
         self.data_export.lock().display_glitches = settings.get_bool("display_glitches").unwrap_or(false);
         self.auto_adjust_iterations = settings.get_bool("auto_adjust_iterations").unwrap_or(true);
-        self.experimental = settings.get_bool("experimental").unwrap_or(false);
+
+        let series_approximation_tiled = settings.get_bool("series_approximation_tiled").unwrap_or(true);
+        let series_approximation_enabled = settings.get_bool("series_approximation_enabled").unwrap_or(true);
+
         let probe_sampling = settings.get_int("probe_sampling").unwrap_or(3) as usize;
         self.remove_centre = settings.get_bool("remove_centre").unwrap_or(true);
 
@@ -878,7 +882,8 @@ impl FractalRenderer {
             self.maximum_iteration, 
             FloatExtended::new(0.0, 0), 
             probe_sampling,
-            self.experimental,
+            series_approximation_tiled,
+            series_approximation_enabled,
             valid_iteration_probe_multiplier,
             data_storage_interval,
             self.fractal_type);