rust-fractal / rust-fractal-core Goto Github PK

Mandelbrot fractal visualizer featuring perturbation based iteration methods, series approximation and multithreading.

License: GNU General Public License v3.0

Rust 96.57% Python 2.59% Shell 0.84%

perturbation series-approximation mandelbrot fractal-rendering

rust-fractal-core's Introduction

rust-fractal-core

A mandelbrot fractal renderer implementing both perturbation and series approximation. A reference point is iterated at high-precision, arbitrary precision and differences from this are calculated in machine precision. This allows for a large reduction in computation required to render and image, especially at high zoom levels. This generator features:

Perturbation based iteration with glitch detection.
Glitch correction through automatic reference movement and recalculation.
Series approximation calculation to skip (and approximate) large amounts of perturbation iterations.
Probe based method to determine series approximation skip.
Multithreading of core loops through rayon.
Configurable location and rendering options.
Multiple save formats including PNG, EXR and KFR.
Utilises scaling and mantissa-exponent based extended precision to allow for arbitrary zoom, whilst maintaining good performance. Verified to be working at depths exceeding E50000. Theoretically, this is only limited by MPFR's precision.

Compiling

You need to be able to compile the 'rug' crate which requires a rust GNU toolchain. A nightly toolchain is also required. Look in the documentation for rug for more information on how to do this. Once all required dependencies have been installed, build the crate with:

cargo build --release

Usage

Information on the flags which can be passed to the rendered can be found with the command rust-fractal --help. The renderer takes .toml files as input. There are two seperate files which can be defined to render an image, the options file and the location file. Settings in these files can be changed in order to change the output of the program. By default, there are 3 options files provided, which are:

low.toml: low quality settings for fast rendering and preview.
default.toml: settings that are used by default if no config file is provided.
high.toml: higher quality settings for final rendering.

Location files contain information on the specific location to be rendered, including the location, zoom level and rotation. Some examples of these files are stored in the ./locations directory. A typical call to the renderer would then look like:

Linux: rust-fractal -o default.toml locations/flake.toml
Windows: rust-fractal.exe -o default.toml locations/flake.toml

Output images are placed in the ./output folder.

Acknowledgements

claude (blog, Kalles Fraktaler 2+)
pauldelbrot (glitch detection, nanoscope)
knighty (superMB)

rust-fractal-core's People

Contributors

Stargazers

Watchers

Forkers

genysys quake

rust-fractal-core's Issues

Improve support for different palette colours.

The current palette algorithm is hardcoded and therefore a new system should be implemented to allow for custom user defined palettes.

Series approximation optimization

The current algorithm checks the approximation every iteration. It would be possible to check only once every 100 iterations and back step when the approximation is no longer valid.

Updated descriptions for Mac OS

Cargo does not successfully build on current Mac OS (Ventura 13.0).
I have found the workaround:

Here is my Cargo.toml (remember to remove the .txt in the filename). In particular rug and gmp-mpfr-sys need to have updated versions to build successfully.

Usage hint:

Once cargo build --release finishes, in the git repo folder (where Cargo.toml lives), remember to mkdir output (otherwise program will panic and quit) and then try running ./target/release/main -o default.toml locations/flake.toml

Cargo.toml.txt

Use series approximation to skip iterations.

Series approximation methods allow for a dramatic speedup particularly on deep zoom levels. In order for them to be implemented there will need to be a floatexp class containing a floating point number as well as an integer exponent.

Revise the mantexp library.

Currently, the mantexp library is not very good. This will need to be revised into a full extended float library, with optimizations for complex numbers.

One such optimization is that a complex number can be represented with a common exponent, provided the real and imaginary parts are close enough to each other. This will simplify and optimize the current code.

Series approximation improvements

If a root is found in the series approximation, it may be better to shift the main reference to the root which will reduce the amount of glitches that need correcting in the image.
It may be better to place the series approximation probe points on or near found roots as to reduce overskipping and reduce the amount of probes required.

Make reference iteration and series approximation separate
Glitch correction requires the current z value in high precision, at the series approximation limit. This can use a lot of memory. A better option might be to only store every thousandth iteration of the reference in high precision, and iterate from here for each glitch reference.

Error compiling

error[E0557]: feature has been removed
  --> ~/.cargo/registry/src/github.com-1ecc6299db9ec823/lock_api-0.4.2/src/lib.rs:91:42
   |
91 | #![cfg_attr(feature = "nightly", feature(const_fn))]
   |                                          ^^^^^^^^ feature has been removed
   |
   = note: split into finer-grained feature gates