added additional option for changing the glitch tolerance in pauldelbrots criterion

Author: jackyarndley

high_experimental.toml

@@ -1,12 +1,12 @@
-image_width = 1920
-image_height = 1080
+image_width = 8192
+image_height = 8192
 rotate = 0
 approximation_order = 64
-glitch_tolerance = 0.001
+glitch_percentage = 0.001
 frames = 1
 frame_offset = 0
 zoom_scale = 2.0
-display_glitches = false
+display_glitches = true
 auto_adjust_iterations = true
 probe_sampling = 12
 remove_centre = false
@@ -16,4 +16,5 @@ export = "png"
 experimental = true 
 high_precision_data_interval = 100
 valid_iteration_frame_multiplier = 0.75
-valid_iteration_probe_multiplier = 0.98
+valid_iteration_probe_multiplier = 0.98
+glitch_tolerance = 1.25e-6

locations/glitch_test2.toml

@@ -0,0 +1,4 @@
+real = "-1.7685304554715107439359975226423287998937254896566074423088827415719065562223946222490318219590860313620613389226996388e+00"
+imag = "5.9445386042946892550190097831583153039526746987365071641624831873576346016435037438597231970921541448697901394734283301e-03"
+zoom = "5.9680811401822433E112"
+iterations = 250000

locations/peanuts.toml

@@ -0,0 +1,4 @@
+real = "-1.94027658588345321091739528561871158285329803755715228746270703125"
+imag = "-0.00015063432290237573328275931307447270339596507504722367456943365"
+zoom = "1.36112946768E39"
+iterations = 9450

src/math/reference.rs

@@ -11,7 +11,8 @@ pub struct Reference {
     // This is for every 100th iteration, when we do glitch correction the new references will be spawed from these values
     // Storing every iteration is memory intensive.
     pub high_precision_data_interval: usize,
-    pub high_precision_data: Vec<ComplexArbitrary>
+    pub high_precision_data: Vec<ComplexArbitrary>,
+    pub glitch_tolerance: f64,
 }
 
 #[derive(Clone)]
@@ -23,7 +24,7 @@ pub struct ReferenceIteration {
 }
 
 impl Reference {
-    pub fn new(z: ComplexArbitrary, c: ComplexArbitrary, current_iteration: usize, maximum_iteration: usize, high_precision_data_interval: usize) -> Reference {
+    pub fn new(z: ComplexArbitrary, c: ComplexArbitrary, current_iteration: usize, maximum_iteration: usize, high_precision_data_interval: usize, glitch_tolerance: f64) -> Reference {
         Reference {
             start_iteration: current_iteration,
             current_iteration,
@@ -32,7 +33,8 @@ impl Reference {
             c,
             reference_data: Vec::with_capacity(1000),
             high_precision_data_interval,
-            high_precision_data: Vec::with_capacity(1000)
+            high_precision_data: Vec::with_capacity(1000),
+            glitch_tolerance
         }
     }
 
@@ -42,7 +44,7 @@ impl Reference {
         self.current_iteration += 1;
 
         let z_fixed = to_fixed(&self.z);
-        let z_tolerance = 1e-6 * z_fixed.norm_sqr();
+        let z_tolerance = self.glitch_tolerance * z_fixed.norm_sqr();
 
         let mut z_extended = to_extended(&self.z);
         z_extended.reduce();
@@ -67,7 +69,7 @@ impl Reference {
 
     pub fn run(&mut self) {
         let z_fixed = to_fixed(&self.z);
-        let z_tolerance = 1e-6 * z_fixed.norm_sqr();
+        let z_tolerance = self.glitch_tolerance * z_fixed.norm_sqr();
 
         let mut z_extended = to_extended(&self.z);
         z_extended.reduce();

src/math/series_approximation.rs

@@ -112,15 +112,10 @@ impl SeriesApproximation {
 
         for i in 0..self.probe_sampling {
             for j in 0..self.probe_sampling {
-                // possible improvement is to remove the probes in the centre of the image which are blacked out
-                // 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 / (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));
-                // }
+                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));
             }
         }
 
@@ -353,7 +348,7 @@ impl SeriesApproximation {
         *reference_z.mut_real() += &temp2 * &temp;
         *reference_z.mut_imag() += &temp3 * &temp;
 
-        Reference::new(reference_z, reference_c, iteration_reference, center_reference.maximum_iteration, self.high_precision_data_interval)
+        Reference::new(reference_z, reference_c, iteration_reference, center_reference.maximum_iteration, self.high_precision_data_interval, center_reference.glitch_tolerance)
     }
 
     pub fn evaluate(&self, point_delta: ComplexExtended, iteration: usize) -> ComplexExtended {

src/renderer.rs

@@ -16,7 +16,7 @@ pub struct FractalRenderer {
     zoom: FloatExtended,
     auto_adjust_iterations: bool,
     maximum_iteration: usize,
-    glitch_tolerance: f64,
+    glitch_percentage: f64,
     data_export: DataExport,
     start_render_time: Instant,
     remaining_frames: usize,
@@ -39,7 +39,7 @@ impl FractalRenderer {
         let center_real = settings.get_str("real").unwrap_or(String::from("-0.75"));
         let center_imag = settings.get_str("imag").unwrap_or(String::from("0.0"));
         let approximation_order = settings.get_int("approximation_order").unwrap_or(0) as usize;
-        let glitch_tolerance = settings.get_float("glitch_tolerance").unwrap_or(0.001);
+        let glitch_percentage = settings.get_float("glitch_percentage").unwrap_or(0.001);
         let remaining_frames = settings.get_int("frames").unwrap_or(1) as usize;
         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);
@@ -51,6 +51,7 @@ impl FractalRenderer {
         let iteration_division = settings.get_float("iteration_division").unwrap_or(0.1) as f32;
         let valid_iteration_frame_multiplier = settings.get_float("valid_iteration_frame_multiplier").unwrap_or(0.75) as f32;
         let valid_iteration_probe_multiplier = settings.get_float("valid_iteration_probe_multiplier").unwrap_or(0.98) as f32;
+        let glitch_tolerance = settings.get_float("glitch_tolerance").unwrap_or(1e-6) as f64;
         let high_precision_data_interval = settings.get_int("high_precision_data_interval").unwrap_or(100) as usize;
 
         let data_type = match settings.get_str("export").unwrap_or(String::from("COLOUR")).to_ascii_uppercase().as_ref() {
@@ -93,7 +94,8 @@ impl FractalRenderer {
             center_location.clone(), 
             1, 
             maximum_iteration, 
-            high_precision_data_interval);
+            high_precision_data_interval,
+            glitch_tolerance);
 
         let series_approximation = SeriesApproximation::new_central(&center_location, 
             auto_approximation, 
@@ -121,7 +123,7 @@ impl FractalRenderer {
             zoom,
             auto_adjust_iterations,
             maximum_iteration,
-            glitch_tolerance,
+            glitch_percentage,
             data_export: DataExport::new(image_width, image_height, display_glitches, data_type, palette, iteration_division),
             start_render_time: Instant::now(),
             remaining_frames,
@@ -240,10 +242,12 @@ impl FractalRenderer {
                     iteration: chosen_iteration,
                     delta_centre: point_delta,
                     delta_reference: point_delta,
-                    delta_current: new_delta,
+                    delta_current: new_delta.clone(),
                     derivative_current: ComplexFixed::new(1.0, 0.0),
                     glitched: false,
-                    escaped: false
+                    escaped: false,
+                    series_approximation_delta: new_delta,
+                    series_approximation_iteration: chosen_iteration
                 }
             }).collect::<Vec<PixelData>>();
 
@@ -260,19 +264,24 @@ impl FractalRenderer {
         std::io::stdout().flush().unwrap();
 
         let correction_time = Instant::now();
+        let mut correction_references = 1;
 
         // Remove all non-glitched points from the remaining points
         pixel_data.retain(|packet| {
             packet.glitched
         });
 
-        while pixel_data.len() as f64 > 0.01 * self.glitch_tolerance * (self.image_width * self.image_height) as f64 {
+        while pixel_data.len() as f64 > 0.01 * self.glitch_percentage * (self.image_width * self.image_height) as f64 {
             // delta_c is the difference from the next reference from the previous one
+
             let glitch_reference_pixel = pixel_data.choose(&mut rand::thread_rng()).unwrap().clone();
 
             let mut glitch_reference = self.series_approximation.get_reference(glitch_reference_pixel.delta_centre, &self.center_reference);
+
+            correction_references += 1;
             glitch_reference.run();
 
+
             let delta_current_reference = self.series_approximation.evaluate(glitch_reference_pixel.delta_centre, glitch_reference.start_iteration);
 
             pixel_data.par_iter_mut()
@@ -281,7 +290,8 @@ impl FractalRenderer {
                     pixel.glitched = false;
                     pixel.delta_current = self.series_approximation.evaluate( pixel.delta_centre, glitch_reference.start_iteration) - delta_current_reference;
                     pixel.delta_reference = pixel.delta_centre - glitch_reference_pixel.delta_centre;
-                });
+            });
+            
 
             Perturbation::iterate(&mut pixel_data, &glitch_reference);
             self.data_export.export_pixels(&pixel_data, self.maximum_iteration, &glitch_reference);
@@ -292,6 +302,7 @@ impl FractalRenderer {
             });
         }
 
+        print!("| {:<6}", correction_references);
         print!("| {:<15}", correction_time.elapsed().as_millis());
         std::io::stdout().flush().unwrap();
 
@@ -304,7 +315,7 @@ impl FractalRenderer {
 
     pub fn render(&mut self) {
         // Print out the status information
-        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]");
+        println!("{:<6}| {:<15}| {:<15}| {:<15}| {:<6}| {:<15}| {:<15}| {:<15}| {:<6}| {:<15}| {:<15}| {:<15}| {:<15}", "Frame", "Zoom", "Approx [ms]", "Skipped [it]", "Order", "Maximum [it]", "Packing [ms]", "Iteration [ms]", "Ref", "Correct [ms]", "Saving [ms]", "Frame [ms]", "TOTAL [ms]");
 
         let mut count = 0;
 

src/util/mod.rs

@@ -163,4 +163,6 @@ pub struct PixelData {
     pub derivative_current: ComplexFixed<f64>,
     pub glitched: bool,
     pub escaped: bool,
+    pub series_approximation_delta: ComplexExtended,
+    pub series_approximation_iteration: usize
 }