added auto iteration which doesn't work for some images

Author: jackyarndley

Cargo.lock

@@ -14,6 +14,7 @@ exr = "^0.8.0"
 smallvec = "^1.4.2"
 clap = "3.0.0-beta.1"
 config = "0.9"
+half = "^1.6.0"
 
 [dependencies.rug]
 version = "1.10"
@@ -22,6 +23,6 @@ features = ["float", "complex"]
 
 #Additional commands that can improve performance (maybe by around 5-10%)
 [profile.release]
-#lto = "fat"
-#codegen-units = 1
+lto = "fat"
+codegen-units = 1
 #debug = true

Cargo.toml

@@ -8,7 +8,7 @@
 from PIL import Image
 
 frames_between_keyframes = 30
-maximum_keyframe_number = 15
+maximum_keyframe_number = 1040
 zoom_scale = 1.4
 
 # log1.1 of 2 is 7.27
@@ -49,10 +49,14 @@
 for i in range(0, maximum_keyframe_number):
     # Creates 10 second segments
     if (i * frames_between_keyframes) % 600 == 0 and i != 0:
+        # Add current_framebuffer frames
         for frame in reversed(framebuffer):
             writer.append_data(frame)
+        
         segment += 1
+
         framebuffer = []
+
         # Writer for adding frames to the video
         writer = imageio.get_writer(f"segment_{segment:08}.mp4", **kargs)
         segment_names.append(f"segment_{segment:08}.mp4")
@@ -78,28 +82,28 @@
         temp3 = scaled_width - temp1
         temp4 = scaled_height - temp2
 
-        next_frame = scaled_keyframe.crop((temp1, temp2, temp3, temp4)).resize((width, height), resample=Image.HAMMING)
+        next_frame = scaled_keyframe.crop((temp1, temp2, temp3, temp4)).resize((width, height), resample=Image.LANCZOS)
 
         framebuffer.append(np.array(next_frame))
-        print(f"{i * frames_between_keyframes + j + 1}/{maximum_keyframe_number * frames_between_keyframes + 1} {time.time() - t0:.2f}s")
+
+        elapsed = time.time() - t0
+        print(f"{i * frames_between_keyframes + j + 1}/{maximum_keyframe_number * frames_between_keyframes + 1} {elapsed:.2f}s {((i * frames_between_keyframes + j + 1)/elapsed):.2f} fps")
 
     previous_keyframe = scaled_keyframe.resize((width, height), resample=Image.LANCZOS)
 
 
 framebuffer.append(np.array(previous_keyframe))
 
-print(f"{maximum_keyframe_number * frames_between_keyframes + 1}/{maximum_keyframe_number * frames_between_keyframes + 1} {time.time() - t0:.2f}s")
-
 for frame in reversed(framebuffer):
     writer.append_data(frame)
 
-# Command to split up into 
-# ffmpeg -i invid.mp4 -threads 3 -vcodec copy -f segment -segment_time 2 cam_out_h264%04d.mp4
-
 with open('segments.txt', 'w') as f:
     for segment in reversed(segment_names):
         f.write(f"file '{segment}'\n")
 
 writer.close()
 
+elapsed = time.time() - t0
+print(f"{maximum_keyframe_number * frames_between_keyframes + 1}/{maximum_keyframe_number * frames_between_keyframes + 1} {elapsed:.2f}s {((maximum_keyframe_number * frames_between_keyframes + 1)/elapsed):.2f} fps")
+
 os.system("ffmpeg -y -f concat -safe 0 -i segments.txt -c copy output.mp4")

assemble_video.py

@@ -1,7 +1,7 @@
 image_width = 1920
 image_height = 1080
-frames = 400
-export = "raw"
+frames = 9999
+export = "colour"
 rotate = 0
 glitch_tolerance = 0.000001
-zoom_scale = 1.4
+zoom_scale = 2.0

default.toml

@@ -1 +1,52 @@
+file 'segment_00000051.mp4'
+file 'segment_00000050.mp4'
+file 'segment_00000049.mp4'
+file 'segment_00000048.mp4'
+file 'segment_00000047.mp4'
+file 'segment_00000046.mp4'
+file 'segment_00000045.mp4'
+file 'segment_00000044.mp4'
+file 'segment_00000043.mp4'
+file 'segment_00000042.mp4'
+file 'segment_00000041.mp4'
+file 'segment_00000040.mp4'
+file 'segment_00000039.mp4'
+file 'segment_00000038.mp4'
+file 'segment_00000037.mp4'
+file 'segment_00000036.mp4'
+file 'segment_00000035.mp4'
+file 'segment_00000034.mp4'
+file 'segment_00000033.mp4'
+file 'segment_00000032.mp4'
+file 'segment_00000031.mp4'
+file 'segment_00000030.mp4'
+file 'segment_00000029.mp4'
+file 'segment_00000028.mp4'
+file 'segment_00000027.mp4'
+file 'segment_00000026.mp4'
+file 'segment_00000025.mp4'
+file 'segment_00000024.mp4'
+file 'segment_00000023.mp4'
+file 'segment_00000022.mp4'
+file 'segment_00000021.mp4'
+file 'segment_00000020.mp4'
+file 'segment_00000019.mp4'
+file 'segment_00000018.mp4'
+file 'segment_00000017.mp4'
+file 'segment_00000016.mp4'
+file 'segment_00000015.mp4'
+file 'segment_00000014.mp4'
+file 'segment_00000013.mp4'
+file 'segment_00000012.mp4'
+file 'segment_00000011.mp4'
+file 'segment_00000010.mp4'
+file 'segment_00000009.mp4'
+file 'segment_00000008.mp4'
+file 'segment_00000007.mp4'
+file 'segment_00000006.mp4'
+file 'segment_00000005.mp4'
+file 'segment_00000004.mp4'
+file 'segment_00000003.mp4'
+file 'segment_00000002.mp4'
+file 'segment_00000001.mp4'
 file 'segment_00000000.mp4'

segments.txt

@@ -14,6 +14,7 @@ pub struct FractalRenderer {
     image_height: usize,
     rotate: f64,
     zoom: FloatExtended,
+    auto_adjust_iterations: bool,
     maximum_iteration: usize,
     glitch_tolerance: f64,
     data_export: DataExport,
@@ -38,14 +39,15 @@ impl FractalRenderer {
         let glitch_tolerance = settings.get_float("glitch_tolerance").unwrap_or(0.01);
         let remaining_frames = settings.get_int("frames").unwrap_or(1) 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 data_type = match settings.get_str("export").unwrap_or(String::from("COLOUR")).to_ascii_uppercase().as_ref() {
             "RAW" => DataType::RAW,
             "COLOUR" => DataType::COLOUR,
             "KFB" => DataType::KFB,
             "BOTH" => DataType::BOTH,
             _ => DataType::COLOUR
         };
-        let display_glitches = false;
 
         let zoom = string_to_extended(&initial_zoom);
         let delta_pixel =  (-2.0 * (4.0 / image_height as f64 - 2.0) / zoom) / image_height as f64;
@@ -69,6 +71,7 @@ impl FractalRenderer {
             image_height,
             rotate,
             zoom,
+            auto_adjust_iterations,
             maximum_iteration,
             glitch_tolerance,
             data_export: DataExport::new(image_width, image_height, display_glitches, data_type),
@@ -110,6 +113,7 @@ impl FractalRenderer {
 
         print!("| {:<15}", approximation_time.elapsed().as_millis());
         print!("| {:<15}", self.series_approximation.valid_iteration);
+        print!("| {:<15}", self.maximum_iteration);
         std::io::stdout().flush().unwrap();
 
         let packing_time = Instant::now();
@@ -135,10 +139,8 @@ impl FractalRenderer {
             })
         }
 
-        let render_indices = &self.render_indices;
-
-        let mut pixel_data = render_indices.into_par_iter()
-            .filter_map(|index| {
+        let mut pixel_data = (&self.render_indices).into_par_iter()
+            .map(|index| {
                 let i = index % self.image_width;
                 let j = index / self.image_width;
 
@@ -151,7 +153,7 @@ impl FractalRenderer {
                 let point_delta = ComplexExtended::new(element, -self.zoom.exponent);
                 let new_delta = self.series_approximation.evaluate(point_delta, None);
 
-                Some(PixelData {
+                PixelData {
                     image_x: i,
                     image_y: j,
                     iteration: self.series_approximation.valid_iteration,
@@ -161,7 +163,7 @@ impl FractalRenderer {
                     derivative_current: ComplexFixed::new(1.0, 0.0),
                     glitched: false,
                     escaped: false
-                })
+                }
             }).collect::<Vec<PixelData>>();
 
         print!("| {:<15}", packing_time.elapsed().as_millis());
@@ -220,13 +222,28 @@ impl FractalRenderer {
 
     pub fn render(&mut self) {
         // Print out the status information
-        println!("{:<6}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}| {:<15}", "Frame", "Zoom", "Approx [ms]", "Skipped [it]", "Packing [ms]", "Iteration [ms]", "Correct [ms]", "Saving [ms]", "Frame [ms]", "TOTAL [ms]");
+        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]");
 
         let mut count = 0;
         while self.remaining_frames > 0 && self.zoom.to_float() > 0.5 {
             self.render_frame(count, format!("output/{:08}_{}", count, extended_to_string(self.zoom)));
             self.zoom.mantissa /= self.zoom_scale_factor;
             self.zoom.reduce();
+
+            if self.auto_adjust_iterations {
+                // test
+                let mut temp = self.data_export.iterations.clone();
+                temp.sort();
+
+                // let new_iteration_value = *(&self.data_export.iterations).into_iter().max().unwrap() as usize;
+                // Set to value of 0.1%
+                let value = 0.999 * temp.len() as f64;
+                let new_iteration_value = temp[value as usize] as usize;
+                self.center_reference.maximum_iteration = new_iteration_value;
+                self.center_reference.current_iteration = new_iteration_value;
+                self.maximum_iteration = new_iteration_value;
+            }
+            
             self.remaining_frames -= 1;
             count += 1;
         }

src/renderer.rs

@@ -6,6 +6,7 @@ use std::fs::File;
 use std::slice;
 
 use exr::prelude::simple_image;
+use half::f16;
 
 pub enum DataType {
     COLOUR,
@@ -20,7 +21,8 @@ pub struct DataExport {
     pub rgb: Vec<u8>,
     palette: Vec<(u8, u8, u8)>,
     pub iterations: Vec<u32>,
-    pub smooth: Vec<f32>,
+    pub smooth_f16: Vec<f16>,
+    pub smooth_f32: Vec<f32>,
     pub display_glitches: bool,
     data_type: DataType,
 }
@@ -34,20 +36,35 @@ impl DataExport {
                     image_height,
                     rgb: vec![0u8; image_width * image_height * 3],
                     palette: DataExport::generate_colour_palette(),
-                    iterations: Vec::new(),
-                    smooth: Vec::new(),
+                    iterations: vec![0u32; image_width * image_height],
+                    smooth_f16: Vec::new(),
+                    smooth_f32: Vec::new(),
+                    display_glitches,
+                    data_type
+                }
+            },
+            DataType::RAW => {
+                DataExport {
+                    image_width,
+                    image_height,
+                    rgb: Vec::new(),
+                    palette: Vec::new(),
+                    iterations: vec![0u32; image_width * image_height],
+                    smooth_f16: vec![f16::ZERO; image_width * image_height],
+                    smooth_f32: Vec::new(),
                     display_glitches,
                     data_type
                 }
             },
-            DataType::RAW | DataType::KFB => {
+            DataType::KFB => {
                 DataExport {
                     image_width,
                     image_height,
                     rgb: Vec::new(),
                     palette: Vec::new(),
                     iterations: vec![0u32; image_width * image_height],
-                    smooth: vec![0.0f32; image_width * image_height],
+                    smooth_f16: Vec::new(),
+                    smooth_f32: vec![0.0f32; image_width * image_height],
                     display_glitches,
                     data_type
                 }
@@ -59,7 +76,8 @@ impl DataExport {
                     rgb: vec![0u8; image_width * image_height * 3],
                     palette: DataExport::generate_colour_palette(),
                     iterations: vec![0u32; image_width * image_height],
-                    smooth: vec![0.0f32; image_width * image_height],
+                    smooth_f16: vec![f16::ZERO; image_width * image_height],
+                    smooth_f32: Vec::new(),
                     display_glitches,
                     data_type
                 }
@@ -102,6 +120,8 @@ impl DataExport {
                         self.rgb[k + 1] = colour.1;
                         self.rgb[k + 2] = colour.2;
                     };
+
+                    self.iterations[k / 3] = pixel.iteration as u32;
                 }
             },
             DataType::RAW => {
@@ -117,7 +137,7 @@ impl DataExport {
                     };
 
                     let z_norm = (reference.reference_data[pixel.iteration - reference.start_iteration].z_fixed + pixel.delta_current.mantissa).norm_sqr() as f32;
-                    self.smooth[k] = 1.0 - (z_norm.ln() / escape_radius_ln).log2();
+                    self.smooth_f16[k] = f16::from_f32(1.0 - (z_norm.ln() / escape_radius_ln).log2());
                 }
             },
             DataType::KFB => {
@@ -133,7 +153,7 @@ impl DataExport {
                     };
 
                     let z_norm = (reference.reference_data[pixel.iteration - reference.start_iteration].z_fixed + pixel.delta_current.mantissa).norm_sqr() as f32;
-                    self.smooth[k] = 1.0 - (z_norm.ln() / escape_radius_ln).log2();
+                    self.smooth_f32[k] = 1.0 - (z_norm.ln() / escape_radius_ln).log2();
                 }
             },
             DataType::BOTH => {
@@ -168,7 +188,7 @@ impl DataExport {
                         self.rgb[k + 1] = colour.1;
                         self.rgb[k + 2] = colour.2;
                         self.iterations[k / 3] = pixel.iteration as u32;
-                        self.smooth[k / 3] = smooth
+                        self.smooth_f16[k / 3] = f16::from_f32(smooth)
                     };
                 }
             }
@@ -204,7 +224,7 @@ impl DataExport {
 
     fn save_raw(&mut self, filename: &str) {
         let iterations = simple_image::Channel::non_color_data(simple_image::Text::from("N").unwrap(), simple_image::Samples::U32(self.iterations.clone()));
-        let smooth = simple_image::Channel::non_color_data(simple_image::Text::from("NF").unwrap(), simple_image::Samples::F32(self.smooth.clone()));
+        let smooth = simple_image::Channel::non_color_data(simple_image::Text::from("NF").unwrap(), simple_image::Samples::F16(self.smooth_f16.clone()));
 
         let layer = simple_image::Layer::new(simple_image::Text::from("fractal_data").unwrap(), (self.image_width, self.image_height), smallvec::smallvec![iterations, smooth])
             .with_compression(simple_image::Compression::PXR24)
@@ -252,7 +272,7 @@ impl DataExport {
         }).unwrap();
 
         file.write_all(unsafe {
-            slice::from_raw_parts(self.smooth.as_ptr() as *const u8, self.iterations.len() * 4)
+            slice::from_raw_parts(self.smooth_f32.as_ptr() as *const u8, self.iterations.len() * 4)
         }).unwrap();
 
     }
@@ -310,14 +330,18 @@ impl DataExport {
             DataType::COLOUR => {
                 self.rgb = vec![0u8; self.image_width * self.image_height * 3];
             }
-            DataType::RAW | DataType::KFB => {
+            DataType::RAW => {
                 self.iterations = vec![0xFFFFFFFF; self.image_width * self.image_height];
-                self.smooth = vec![0.0f32; self.image_width * self.image_height];
-            }
+                self.smooth_f16 = vec![f16::ZERO; self.image_width * self.image_height];
+            },
+            DataType::KFB => {
+                self.iterations = vec![0xFFFFFFFF; self.image_width * self.image_height];
+                self.smooth_f32 = vec![0.0f32; self.image_width * self.image_height];
+            },
             DataType::BOTH => {
                 self.rgb = vec![0u8; self.image_width * self.image_height * 3];
                 self.iterations = vec![0xFFFFFFFF; self.image_width * self.image_height];
-                self.smooth = vec![0.0f32; self.image_width * self.image_height];
+                self.smooth_f16 = vec![f16::ZERO; self.image_width * self.image_height];
             }
         }
     }