added working central part deletion

Author: jackyarndley

default.toml

@@ -1,7 +1,7 @@
 image_width = 1920
 image_height = 1080
-frames = 9999
+frames = 100
 export = "colour"
 rotate = 0
 glitch_tolerance = 0.000001
-approximation_order = "32"
+zoom_scale = 2.0

segments.txt

@@ -1,79 +1,2 @@
-file 'segment_00000078.mp4'
-file 'segment_00000077.mp4'
-file 'segment_00000076.mp4'
-file 'segment_00000075.mp4'
-file 'segment_00000074.mp4'
-file 'segment_00000073.mp4'
-file 'segment_00000072.mp4'
-file 'segment_00000071.mp4'
-file 'segment_00000070.mp4'
-file 'segment_00000069.mp4'
-file 'segment_00000068.mp4'
-file 'segment_00000067.mp4'
-file 'segment_00000066.mp4'
-file 'segment_00000065.mp4'
-file 'segment_00000064.mp4'
-file 'segment_00000063.mp4'
-file 'segment_00000062.mp4'
-file 'segment_00000061.mp4'
-file 'segment_00000060.mp4'
-file 'segment_00000059.mp4'
-file 'segment_00000058.mp4'
-file 'segment_00000057.mp4'
-file 'segment_00000056.mp4'
-file 'segment_00000055.mp4'
-file 'segment_00000054.mp4'
-file 'segment_00000053.mp4'
-file 'segment_00000052.mp4'
-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'

src/renderer.rs

@@ -78,15 +78,15 @@ impl FractalRenderer {
         }
     }
 
-    pub fn render_frame(&mut self, index: usize, filename: String) {
-        print!("{:<6}", index);
+    pub fn render_frame(&mut self, frame_index: usize, filename: String) {
+        print!("{:<6}", frame_index);
         print!("| {:<15}", extended_to_string(self.zoom));
         std::io::stdout().flush().unwrap();
         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 index == 0 {
+        if frame_index == 0 {
             self.center_reference.run();
             self.series_approximation.maximum_iteration = self.center_reference.current_iteration;
             self.series_approximation.generate_approximation(&self.center_reference);
@@ -111,29 +111,45 @@ impl FractalRenderer {
 
         let packing_time = Instant::now();
 
+        if frame_index == 1 {
+            // This will remove the central pixels
+            self.data_export.clear_buffers();
+        }
+
+        // This could be optimised
         let mut pixel_data = (0..(self.image_width * self.image_height)).into_par_iter()
-            .map(|index| {
+            .filter_map(|index| {
                 let i = index % self.image_width;
                 let j = index / self.image_width;
-                // This could be changed to account for rotation, and jittering if needed
-                let element = ComplexFixed::new(
-                    i as f64 * delta_pixel * cos_rotate - j as f64 * delta_pixel * sin_rotate + delta_top_left.re, 
-                    i as f64 * delta_pixel * sin_rotate + j as f64 * delta_pixel * cos_rotate + delta_top_left.im
-                );
-                
-                let point_delta = ComplexExtended::new(element, -self.zoom.exponent);
-                let new_delta = self.series_approximation.evaluate(point_delta, None);
-
-                PixelData {
-                    image_x: i,
-                    image_y: j,
-                    iteration: self.series_approximation.valid_iteration,
-                    delta_centre: point_delta,
-                    delta_reference: point_delta,
-                    delta_current: new_delta,
-                    derivative_current: ComplexFixed::new(1.0, 0.0),
-                    glitched: false,
-                    escaped: false
+
+                // Add one to avoid rescaling artifacts
+                let val1 = (self.image_width as f64 * (0.5 - 0.5 / self.zoom_scale_factor)).ceil() as usize;
+                let val2 = (self.image_height as f64 * (0.5 - 0.5 / self.zoom_scale_factor)).ceil() as usize;
+
+                // Check if the pixel has already been covered in an earlier keyframe
+                if frame_index >= 1 && i > val1 && i < self.image_width - val1 && j > val2 && j < self.image_height - val2 {
+                    None
+                } else {
+                    // This could be changed to account for jittering if needed
+                    let element = ComplexFixed::new(
+                        i as f64 * delta_pixel * cos_rotate - j as f64 * delta_pixel * sin_rotate + delta_top_left.re, 
+                        i as f64 * delta_pixel * sin_rotate + j as f64 * delta_pixel * cos_rotate + delta_top_left.im
+                    );
+
+                    let point_delta = ComplexExtended::new(element, -self.zoom.exponent);
+                    let new_delta = self.series_approximation.evaluate(point_delta, None);
+
+                    Some(PixelData {
+                        image_x: i,
+                        image_y: j,
+                        iteration: self.series_approximation.valid_iteration,
+                        delta_centre: point_delta,
+                        delta_reference: point_delta,
+                        delta_current: new_delta,
+                        derivative_current: ComplexFixed::new(1.0, 0.0),
+                        glitched: false,
+                        escaped: false
+                    })
                 }
             }).collect::<Vec<PixelData>>();
 

src/util/data_export.rs

@@ -17,10 +17,10 @@ pub enum DataType {
 pub struct DataExport {
     image_width: usize,
     image_height: usize,
-    rgb: Vec<u8>,
+    pub rgb: Vec<u8>,
     palette: Vec<(u8, u8, u8)>,
-    iterations: Vec<u32>,
-    smooth: Vec<f32>,
+    pub iterations: Vec<u32>,
+    pub smooth: Vec<f32>,
     pub display_glitches: bool,
     data_type: DataType,
 }
@@ -68,6 +68,8 @@ impl DataExport {
     }
 
     pub fn export_pixels(&mut self, pixel_data: &[PixelData], maximum_iteration: usize, reference: &Reference) {
+        let escape_radius_ln = 1e16f32.ln();
+
         match self.data_type {
             DataType::COLOUR => {
                 for pixel in pixel_data {
@@ -79,6 +81,8 @@ impl DataExport {
                             self.rgb[k + 1] = 0;
                             self.rgb[k + 2] = 0;
                         } else {
+                            // Pixel is glitched so the smooth won't do much
+
                             let colour = self.palette[10 * pixel.iteration % 1024];
                             self.rgb[k] = colour.0;
                             self.rgb[k + 1] = colour.1;
@@ -89,16 +93,18 @@ impl DataExport {
                         self.rgb[k + 1] = 0;
                         self.rgb[k + 2] = 0;
                     } else {
-                        let colour = self.palette[10 * pixel.iteration % 1024];
+                        let z_norm = (reference.reference_data[pixel.iteration - reference.start_iteration].z_fixed + pixel.delta_current.mantissa).norm_sqr() as f32;
+
+                        let smooth = 1.0 - (z_norm.ln() / escape_radius_ln).log2();
+
+                        let colour = self.palette[(10.0 * (pixel.iteration as f32 + smooth)) as usize % 1024];
                         self.rgb[k] = colour.0;
                         self.rgb[k + 1] = colour.1;
                         self.rgb[k + 2] = colour.2;
                     };
                 }
             },
             DataType::RAW => {
-                let escape_radius_ln = 1e16f32.ln();
-
                 for pixel in pixel_data {
                     let k = pixel.image_y * self.image_width + pixel.image_x;
 
@@ -115,8 +121,6 @@ impl DataExport {
                 }
             },
             DataType::KFB => {
-                let escape_radius_ln = 1e16f32.ln();
-
                 for pixel in pixel_data {
                     let k = pixel.image_x * self.image_height + pixel.image_y;
 
@@ -133,8 +137,6 @@ impl DataExport {
                 }
             },
             DataType::BOTH => {
-                let escape_radius_ln = 1e16f32.ln();
-
                 for pixel in pixel_data {
                     let k = (pixel.image_y * self.image_width + pixel.image_x) * 3;
 
@@ -157,15 +159,17 @@ impl DataExport {
                         self.rgb[k + 2] = 0;
                         self.iterations[k / 3] = 0xFFFFFFFF;
                     } else {
-                        let colour = self.palette[10 * pixel.iteration % 1024];
+                        let z_norm = (reference.reference_data[pixel.iteration - reference.start_iteration].z_fixed + pixel.delta_current.mantissa).norm_sqr() as f32;
+
+                        let smooth = 1.0 - (z_norm.ln() / escape_radius_ln).log2();
+
+                        let colour = self.palette[(10.0 * (pixel.iteration as f32 + smooth)) as usize % 1024];
                         self.rgb[k] = colour.0;
                         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
                     };
-
-                    let z_norm = (reference.reference_data[pixel.iteration - reference.start_iteration].z_fixed + pixel.delta_current.mantissa).norm_sqr() as f32;
-                    self.smooth[k / 3] = 1.0 - (z_norm.ln() / escape_radius_ln).log2();
                 }
             }
         }
@@ -190,7 +194,12 @@ impl DataExport {
     }
 
     fn save_colour(&mut self, filename: &str) {
-        image::save_buffer(filename.to_owned() + ".png", &self.rgb, self.image_width as u32, self.image_height as u32, image::ColorType::Rgb8).unwrap();
+        image::save_buffer(
+            filename.to_owned() + ".png", 
+            &self.rgb, 
+            self.image_width as u32, 
+            self.image_height as u32, 
+            image::ColorType::Rgb8).unwrap();
     }
 
     fn save_raw(&mut self, filename: &str) {
@@ -295,4 +304,21 @@ impl DataExport {
 
         colours
     }
+
+    pub fn clear_buffers(&mut self) {
+        match self.data_type {
+            DataType::COLOUR => {
+                self.rgb = vec![0u8; self.image_width * self.image_height * 3];
+            }
+            DataType::RAW | DataType::KFB => {
+                self.iterations = vec![0u32; self.image_width * self.image_height];
+                self.smooth = 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![0u32; self.image_width * self.image_height];
+                self.smooth = vec![0.0f32; self.image_width * self.image_height];
+            }
+        }
+    }
 }

test2.py

@@ -2,12 +2,17 @@
 import numpy as np
 import time
 import os
+import math
 
 from PIL import Image
 
-frames_between_keyframes = 60
-maximum_keyframe_number = 783
-zoom_scale = 2
+frames_between_keyframes = 8
+maximum_keyframe_number = 99
+zoom_scale = 1.1
+
+# log1.1 of 2 is 7.27
+# 60 / that is 8.25, so lets take 8 frames per keyframe
+
 
 # Arguments for ffmpeg
 kargs = {
@@ -31,8 +36,12 @@
 previous_keyframe = Image.open(f"output/output_00000000.png")
 
 (width, height) = (previous_keyframe.width, previous_keyframe.height)
-(scaled_width, scaled_height) = (zoom_scale * width, zoom_scale * height)
-placement_box = (scaled_width//4, scaled_height//4, scaled_width//4 * 3, scaled_height//4 * 3)
+(scaled_width, scaled_height) = (int(zoom_scale * width), int(zoom_scale * height))
+
+val1 = (scaled_width - width) // 2
+val2 = (scaled_height - height) // 2
+
+placement_box = (val1, val2, val1 + width, val2 + height)
 
 for i in range(0, maximum_keyframe_number):
     # Creates 10 second segments
@@ -47,15 +56,21 @@
 
     next_keyframe = Image.open(f"output/output_{i + 1:08}.png")
 
-    scaled_keyframe = next_keyframe.resize((scaled_width, scaled_height), resample=Image.LANCZOS)
+    scaled_keyframe = next_keyframe.resize((scaled_width, scaled_height), resample=Image.NEAREST)
 
     scaled_keyframe.paste(previous_keyframe, placement_box)
 
+    current_scale = zoom_scale
+    factor = 10**(math.log10(zoom_scale) / frames_between_keyframes)
+
     for j in range(0, frames_between_keyframes):
-        zoom = zoom_scale**(1.0 - j / frames_between_keyframes)
+        # zoom = 1.0 + (2**(1.0 - j / frames_between_keyframes) - 1.0) * (zoom_scale - 1.0)
+        # zoom = zoom_scale**(1.0 - j / frames_between_keyframes)
+        # zoom = zoom_scale**((1.0 - j / frames_between_keyframes))
+        current_scale /= factor
 
-        temp1 = (1.0 - 1.0 / zoom) * width
-        temp2 = (1.0 - 1.0 / zoom) * height
+        temp1 = (1.0 - 1.0 / current_scale) * (scaled_width // 2)
+        temp2 = (1.0 - 1.0 / current_scale) * (scaled_height // 2)
         temp3 = scaled_width - temp1
         temp4 = scaled_height - temp2