added probe sampling option and automatically reduce series approximation terms when below certain zoom level

Author: jackyarndley

default.toml

@@ -1,9 +1,9 @@
-image_width = 1920
-image_height = 1080
-frames = 1
+image_width = 1000
+image_height = 1000
+frames = 999
 export = "colour"
 glitch_tolerance = 0.001
 zoom_scale = 2.0
 auto_adjust_iterations = true
-approximation_order = 16
+approximation_order = 32
 frame_offset = 0

locations/threads_colour.toml

@@ -1,4 +1,5 @@
 real = "-1.47414176240993896848662071528158693194984033295350953280086668957218887059547144798782958583693228230313082538417736408312283756916583038548770140907148842507795182301203312327678867411139743734088820831422587016737770172651132123623347543560592366451320269312832570538759109480956462838749508907791843703924365245276567942898938125705618894029328612293147151908041951365498962465718017136637923540348122292958335790053092495783869799482899842041593944847198560523459306518247398734178583094840989359335916427349271969694638813455484795519139180535389178899499218726674005407958574308338167164971091115429523451479626131276956228048957227740597867681604973361307242906518836130901630810235591139999999999999999999"
 imag = "1.837028624819189477865631515035097395323927302572629030865933104000355714583818892052507681177756076074900340375874325858424795164505875785998449146862924507042300051932135130891413370393327740037629084197582966724720858559206941967648864807892583328760554952794324657809197148266317196316651597885791947076110274629246850125745470256068262793065499915106947670845209696879646797896797942904780372999446765698282800418563469062689909330151614815763561772821921612271912492631000218876452296900861545848888915227426092699498959036990046882718777435775562966053647880616647866656164419540502287729221470963175939777275863084020159079375481684880087569411323863960416637609668567855099418820244664E-94"
-zoom = "8.6e630"
+#zoom = "8.6e630"
+zoom = "1e20"
 iterations = 1544151

src/math/series_approximation.rs

@@ -16,10 +16,11 @@ pub struct SeriesApproximation {
     pub delta_top_left: ComplexExtended,
     pub valid_coefficients: Vec<ComplexExtended>,
     pub valid_iteration: usize,
+    pub probe_sampling: usize,
 }
 
 impl SeriesApproximation {
-    pub fn new_central(c: &ComplexArbitrary, order: usize, maximum_iteration: usize, delta_pixel_square: FloatExtended, delta_top_left: ComplexExtended) -> Self {
+    pub fn new_central(c: &ComplexArbitrary, order: usize, maximum_iteration: usize, delta_pixel_square: FloatExtended, delta_top_left: ComplexExtended, probe_sampling: usize) -> Self {
         let mut coefficients = vec![vec![ComplexExtended::new2(0.0, 0.0, 0); order as usize + 1]; 1];
 
         coefficients[0][0] = to_extended(&c);
@@ -37,10 +38,17 @@ impl SeriesApproximation {
             delta_top_left,
             valid_coefficients: Vec::new(),
             valid_iteration: 1,
+            probe_sampling,
         }
     }
 
     pub fn generate_approximation(&mut self, center_reference: &Reference) {
+        // Reset the coefficients
+        self.coefficients = vec![vec![ComplexExtended::new2(0.0, 0.0, 0); self.order as usize + 1]; 1];
+
+        self.coefficients[0][0] = to_extended(&center_reference.c);
+        self.coefficients[0][1] = ComplexExtended::new2(1.0, 0.0, 0);
+
         let add_value = ComplexExtended::new2(1.0, 0.0, 0);
 
         // Can be changed later into a better loop - this function could also return some more information
@@ -82,15 +90,13 @@ impl SeriesApproximation {
         self.approximation_probes = Vec::new();
         self.approximation_probes_derivative = Vec::new();
 
-        let probe_sampling = 3;
-
-        for i in 0..probe_sampling {
-            for j in 0..probe_sampling {
-                if probe_sampling % 2 == 1 && (i == probe_sampling / 2 && j == probe_sampling / 2) {
+        for i in 0..self.probe_sampling {
+            for j in 0..self.probe_sampling {
+                if self.probe_sampling % 2 == 1 && (i == self.probe_sampling / 2 && j == self.probe_sampling / 2) {
                     continue;
                 } else {
-                    let real = (1.0 - 2.0 * (i as f64 / (probe_sampling as f64 - 1.0))) * self.delta_top_left.mantissa.re;
-                    let imag = (1.0 - 2.0 * (j as f64 / (probe_sampling as f64 - 1.0))) * self.delta_top_left.mantissa.im;
+                    let real = (1.0 - 2.0 * (i as f64 / (self.probe_sampling as f64 - 1.0))) * self.delta_top_left.mantissa.re;
+                    let imag = (1.0 - 2.0 * (j as f64 / (self.probe_sampling as f64 - 1.0))) * self.delta_top_left.mantissa.im;
 
                     self.add_probe(ComplexExtended::new2(real, imag, self.delta_top_left.exponent));
                 }

src/renderer.rs

@@ -43,6 +43,7 @@ impl FractalRenderer {
         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(false);
+        let probe_sampling = settings.get_int("probe_sampling").unwrap_or(3) as usize;
         let data_type = match settings.get_str("export").unwrap_or(String::from("COLOUR")).to_ascii_uppercase().as_ref() {
             "RAW" => DataType::RAW,
             "COLOUR" => DataType::COLOUR,
@@ -65,7 +66,8 @@ impl FractalRenderer {
             auto_approximation, 
             maximum_iteration, 
             FloatExtended::new(0.0, 0), 
-            ComplexExtended::new2(0.0, 0.0, 0));
+            ComplexExtended::new2(0.0, 0.0, 0),
+            probe_sampling);
         let render_indices = (0..(image_width * image_height)).collect::<Vec<usize>>();
 
         FractalRenderer {
@@ -94,7 +96,6 @@ impl FractalRenderer {
         let frame_time = Instant::now();
         let approximation_time = Instant::now();
 
-        // If we are on the first frame we need to run the central reference calculation
         if frame_index == 0 {
             self.center_reference.run();
             self.series_approximation.maximum_iteration = self.center_reference.current_iteration;
@@ -116,6 +117,7 @@ impl FractalRenderer {
 
         print!("| {:<15}", approximation_time.elapsed().as_millis());
         print!("| {:<15}", self.series_approximation.valid_iteration);
+        print!("| {:<6}", self.series_approximation.order);
         print!("| {:<15}", self.maximum_iteration);
         std::io::stdout().flush().unwrap();
 
@@ -226,17 +228,30 @@ impl FractalRenderer {
 
     pub fn render(&mut self) {
         // Print out the status information
-        println!("{:<6}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}", "Frame", "Zoom", "Approx [ms]", "Skipped [it]", "Maximum [it]", "Packing [ms]", "Iteration [ms]", "Correct [ms]", "Saving [ms]", "Frame [ms]", "TOTAL [ms]");
+        println!("{:<6}| {:<15}| {:<15}| {:<15}| {:<6}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}", "Frame", "Zoom", "Approx [ms]", "Skipped [it]", "Order", "Maximum [it]", "Packing [ms]", "Iteration [ms]", "Correct [ms]", "Saving [ms]", "Frame [ms]", "TOTAL [ms]");
 
         let mut count = 0;
 
         while self.remaining_frames > 0 && self.zoom.to_float() > 0.5 {
-            self.render_frame(count, format!("output/{:08}_{}", count + self.frame_offset, extended_to_string_short(self.zoom)));
+            self.render_frame(count, 
+                format!("output/{:08}_{}", count + self.frame_offset, 
+                extended_to_string_short(self.zoom)));
+
             self.zoom.mantissa /= self.zoom_scale_factor;
             self.zoom.reduce();
 
-            if self.auto_adjust_iterations {
-                if self.zoom.to_float() < 1e10 && self.maximum_iteration > 10000 {
+            if self.zoom.to_float() < 1e10 {
+                // SA has some problems with precision with lots of terms at lot zoom levels
+                if self.series_approximation.order > 3 {
+                    // Overwrite the series approximation order
+                    self.series_approximation.order = 3;
+                    self.series_approximation.maximum_iteration = self.center_reference.current_iteration;
+                    self.series_approximation.generate_approximation(&self.center_reference);
+                }
+
+                // Logic in here to automatically adjust the maximum number of iterations
+                // This is done arbitrarily and could be done in a config file if required
+                if self.auto_adjust_iterations && self.maximum_iteration > 10000 {
                     let new_iteration_value = 10000;
 
                     if self.center_reference.current_iteration >= 10000 {