Merge pull request #37 from rust-fractal/development

Development

Author: jackyarndley

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rust_fractal"
-version = "0.13.0"
+version = "0.14.0"
 authors = ["jackyarndley <34801340+jackyarndley@users.noreply.github.com>"]
 description = "Fast, efficient mandelbrot set renderer."
 edition = "2018"
@@ -15,6 +15,8 @@ smallvec = "^1.4.2"
 clap = "^3.0.0-beta.1"
 config = "^0.9"
 half = "^1.6.0"
+atomic-counter = "^1.0.1"
+color_space = "^0.5.3"
 
 [dependencies.rug]
 version = "1.10"
@@ -27,3 +29,4 @@ lto = "fat"
 codegen-units = 1
 #debug = true
 opt-level=3
+#incremental = true

Cargo.toml

@@ -6,10 +6,10 @@ glitch_percentage = 0.001
 frames = 1
 frame_offset = 0
 zoom_scale = 2.0
-display_glitches = false
+display_glitches = true
 auto_adjust_iterations = true
 remove_centre = false
-export = "exr"
+export = "png"
 
 glitch_tolerance = 1.4e-6
 
@@ -22,5 +22,5 @@ valid_iteration_probe_multiplier = 0.01
 
 experimental = true  
 
-analytic_derivative = true
+analytic_derivative = false
 jitter = false

high.toml

@@ -0,0 +1,5 @@
+real = "-0.749999987350877481864108888020013802837969258626230419972587823828734338471228477079750588709551510361714463695461745528645748607681279674273355384334270208362211787387351792878073779449767292692440"
+imag = "0.001000038688236832013124581230049849132759425863378894883003211011278068229551274712347955044740933397589760194545872789087012331273586364914484522575986336846199522726507205442204060303594956029930"
+zoom = "9.099999999999616E191"
+iterations = 5000000
+rotate = 0

locations/dragon_detail.toml

@@ -5,12 +5,22 @@ use crate::math::reference::Reference;
 
 use crate::util::ComplexExtended;
 
+use atomic_counter::{AtomicCounter, RelaxedCounter};
+
+use std::sync::Arc;
+
 pub struct Perturbation {}
 
 impl Perturbation {
-    pub fn iterate_normal(pixel_data: &mut [PixelData], reference: &Reference) {
+    pub fn iterate_normal(pixel_data: &mut [PixelData], reference: &Reference, pixels_complete: &Arc<RelaxedCounter>, stop_flag: &Arc<RelaxedCounter>) {
         pixel_data.par_chunks_mut(4)
             .for_each(|pixel_data| {
+                if stop_flag.get() >= 1 {
+                    return;
+                }
+
+                let mut new_pixels_complete = 0;
+
                 for pixel in pixel_data {
                     let mut scaled_iterations = 0;
                     let mut scaled_scale_factor_1 = 1.0f64.ldexp(pixel.delta_current.exponent);
@@ -41,6 +51,7 @@ impl Perturbation {
                                 pixel.escaped = true;
                                 pixel.delta_current.mantissa = pixel.delta_current.to_float();
                                 pixel.delta_current.exponent = 0;
+                                new_pixels_complete += 1;
                                 break;
                             }
                         }
@@ -81,14 +92,23 @@ impl Perturbation {
 
                     if !pixel.escaped && !pixel.glitched {
                         pixel.iteration = reference.current_iteration;
+                        new_pixels_complete += 1;
                     }
                 }
+
+                pixels_complete.add(new_pixels_complete);
             });
     }
 
-    pub fn iterate_normal_plus_derivative(pixel_data: &mut [PixelData], reference: &Reference) {
+    pub fn iterate_normal_plus_derivative(pixel_data: &mut [PixelData], reference: &Reference, pixels_complete: &Arc<RelaxedCounter>, stop_flag: &Arc<RelaxedCounter>) {
         pixel_data.par_chunks_mut(4)
             .for_each(|pixel_data| {
+                if stop_flag.get() >= 1 {
+                    return;
+                }
+
+                let mut new_pixels_complete = 0;
+
                 for pixel in pixel_data {
                     let mut scaled_iterations = 0;
                     let mut scaled_scale_factor_1 = 1.0f64.ldexp(pixel.delta_current.exponent);
@@ -120,6 +140,7 @@ impl Perturbation {
                                 pixel.escaped = true;
                                 pixel.delta_current.mantissa = pixel.delta_current.to_float();
                                 pixel.delta_current.exponent = 0;
+                                new_pixels_complete += 1;
                                 break;
                             }
                         }
@@ -172,8 +193,11 @@ impl Perturbation {
 
                     if !pixel.escaped && !pixel.glitched {
                         pixel.iteration = reference.current_iteration;
+                        new_pixels_complete += 1;
                     }
                 }
+
+                pixels_complete.add(new_pixels_complete);
             });
     }
 }

src/math/perturbation.rs

@@ -1,5 +1,9 @@
 use crate::util::{ComplexArbitrary, ComplexFixed, ComplexExtended, FloatExtended, to_fixed, to_extended};
 
+use atomic_counter::{AtomicCounter, RelaxedCounter};
+
+use std::sync::Arc;
+
 #[derive(Clone)]
 pub struct Reference {
     pub start_iteration: usize,
@@ -69,7 +73,7 @@ impl Reference {
     }
 
 
-    pub fn run(&mut self) {
+    pub fn run(&mut self, reference_counter: &Arc<RelaxedCounter>, reference_maximum_iteration_counter: &Arc<RelaxedCounter>, stop_flag: &Arc<RelaxedCounter>) {
         let z_fixed = to_fixed(&self.z);
         let z_tolerance = self.glitch_tolerance * z_fixed.norm_sqr();
 
@@ -96,7 +100,15 @@ impl Reference {
                 }
             }
 
+            if stop_flag.get() >= 1 {
+                return
+            };
+
+            reference_counter.inc();
+
             if !self.step() {
+                reference_maximum_iteration_counter.add(usize::max_value() - self.maximum_iteration + reference_counter.get() + 1);
+
                 break;
             };
         }

src/math/reference.rs

@@ -7,6 +7,10 @@ use rayon::prelude::*;
 
 use std::cmp::max;
 
+use atomic_counter::{AtomicCounter, RelaxedCounter};
+
+use std::sync::Arc;
+
 pub struct SeriesApproximation {
     pub maximum_iteration: usize,
     pub delta_pixel_square: FloatExtended,
@@ -16,6 +20,7 @@ pub struct SeriesApproximation {
     approximation_probes: Vec<Vec<ComplexExtended>>,
     approximation_probes_derivative: Vec<Vec<ComplexExtended>>,
     pub min_valid_iteration: usize,
+    pub max_valid_iteration: usize,
     pub valid_iterations: Vec<usize>,
     pub valid_interpolation: Vec<usize>,
     pub probe_sampling: usize,
@@ -45,6 +50,7 @@ impl SeriesApproximation {
             approximation_probes: Vec::new(),
             approximation_probes_derivative: Vec::new(),
             min_valid_iteration: 1,
+            max_valid_iteration: 1,
             valid_iterations: Vec::new(),
             valid_interpolation: Vec::new(),
             probe_sampling,
@@ -55,7 +61,7 @@ impl SeriesApproximation {
         }
     }
 
-    pub fn generate_approximation(&mut self, center_reference: &Reference) {
+    pub fn generate_approximation(&mut self, center_reference: &Reference, series_approximation_counter: &Arc<RelaxedCounter>, stop_flag: &Arc<RelaxedCounter>) {
         // Reset the coefficients
         self.coefficients = vec![vec![ComplexExtended::new2(0.0, 0.0, 0); self.order as usize + 1]; 1];
 
@@ -66,11 +72,14 @@ impl SeriesApproximation {
         let add_value = ComplexExtended::new2(1.0, 0.0, 0);
 
         let mut previous_coefficients = self.coefficients[0].clone();
+        let mut next_coefficients = vec![ComplexExtended::new2(0.0, 0.0, 0); self.order as usize + 1];
 
         // Can be changed later into a better loop - this function could also return some more information
         // Go through all remaining iterations
         for i in 1..self.maximum_iteration {
-            let mut next_coefficients = vec![ComplexExtended::new2(0.0, 0.0, 0); self.order as usize + 1];
+            if stop_flag.get() >= 1 {
+                return
+            };
 
             // This is checking if the approximation can step forward so takes the next iteration
             next_coefficients[0] = center_reference.reference_data[i].z_extended;
@@ -98,11 +107,12 @@ impl SeriesApproximation {
 
             previous_coefficients = next_coefficients.clone();
 
-
+            series_approximation_counter.inc();
+            
             // only every 100th iteration (101, 201 etc)
             // This is 0, 100, 200 -> 1, 101, 201
             if i % self.data_storage_interval == 0 {
-                self.coefficients.push(next_coefficients);
+                self.coefficients.push(next_coefficients.clone());
             }
 
             // self.coefficients.push(next_coefficients);
@@ -117,7 +127,8 @@ impl SeriesApproximation {
         delta_pixel: f64,
         image_width: usize,
         image_height: usize,
-        center_reference: &Reference) {
+        center_reference: &Reference,
+        series_validation_counter: &Arc<RelaxedCounter>) {
         // Delete the previous probes and calculate new ones
         self.probe_start = Vec::new();
         self.approximation_probes = Vec::new();
@@ -203,6 +214,8 @@ impl SeriesApproximation {
             first_valid_iterations += 1;
         }
 
+        series_validation_counter.inc();
+
         self.min_valid_iteration = first_valid_iterations;
 
         // println!("{}", self.min_valid_iteration);
@@ -260,6 +273,8 @@ impl SeriesApproximation {
                                     derivative_probe += next_coefficients[k] * self.approximation_probes_derivative[i][k - 1];
                                 };
 
+                                probe.reduce();
+
                                 let relative_error = (probe - series_probe).norm_square();
                                 let mut derivative = derivative_probe.norm_square();
 
@@ -269,10 +284,14 @@ impl SeriesApproximation {
                                     derivative.exponent = 0;
                                 }
 
+                                // println!("checking at: {}", *probe_iteration_level);
+                                // println!("relative error: {} derivative: {} delta_square: {}", relative_error, derivative, self.delta_pixel_square);
+                                // println!("probe: {} series_probe: {}", probe, series_probe);
+
                                 // The first element is reduced, the second might need to be reduced a little more
                                 // Check that the error over the derivative is less than the pixel spacing
-                                if relative_error / derivative > self.delta_pixel_square {
-                                    // println!("{} ", *probe_iteration_level);
+                                if relative_error / derivative > self.delta_pixel_square || relative_error.exponent > 0 {
+                                    // println!("exceeded at: {} ", *probe_iteration_level);
 
                                     if *probe_iteration_level <= (current_probe_check_value + self.data_storage_interval + 1) {
                                         *probe_iteration_level = next_probe_check_value;
@@ -322,6 +341,8 @@ impl SeriesApproximation {
             }
         }
 
+        series_validation_counter.inc();
+
         self.valid_iterations = valid_iterations;
 
         // Also, here we do the interpolation and set up the array
@@ -341,7 +362,20 @@ impl SeriesApproximation {
             }
         }
 
-        // println!("{:?}", self.valid_interpolation);
+        self.max_valid_iteration = self.valid_interpolation.iter().max().unwrap().clone();
+
+        // println!("series approximation valid interpolation buffer:");
+        // let temp_size = self.probe_sampling - 1;
+        // for i in 0..temp_size {
+        //     let test = &self.valid_interpolation[(i * temp_size)..((i + 1) * temp_size)];
+        //     print!("[");
+
+        //     for element in test {
+        //         print!("{:>8},", element);
+        //     }
+
+        //     print!("\x08]\n");
+        // }
 
         if !self.experimental {
             self.valid_interpolation = vec![self.min_valid_iteration; (self.probe_sampling - 1) * (self.probe_sampling - 1)];