josecelano / mandelbrot-orbits-rust Goto Github PK

View Code? Open in Web Editor NEW

1.0 3.0 0.0 4.84 MB

Plotting Mandelbrot Set periods using Rust language.

License: MIT License

Rust 98.42% Shell 1.58%

fractal fractals mandelbrot mandelbrot-renderer mandelbrot-set orbits period rust

mandelbrot-orbits-rust's Introduction

Mandelbrot Orbits

This is a small project to learn Rust.

It generates an image of the Mandelbrot Set where each pixel color represents the period of the complex point if the point belongs to the Set.

More info about Mandelbrot Set Periods.

You can render it in greyscale.

Or the colorized version.

With a different color depending on the period.

Requirements

cargo: ^1.62.1.
rustc: ^1.62.1.

Use

git clone [email protected]:josecelano/mandelbrot-orbits-rust.git
cargo run ./output/mandelbrot_2048x2048.png 2048x2048 -2.0,2.00 2.0,-2.0

Development

Execute MegaLinter locally:

./bin/ml.sh

Run tests:

cargo test

More info for developers.

Math

You can find an explanation here.

And I'm trying to find and write a more formal explanation of the math behind the algorithm.

$./docs/images/math.png$

Execution time

16384x16384px
4,7MB
72m57,099s

32768x32768px
15MB
268m23,032s

Credits

Jeremy Rifkin pointed me to the solution. I have copied/pasted part of his code to detect the period.
Jim Blandy, Programming Rust Book's Author.
Jason Orendorff, Programming Rust Book's Author.

License

MIT.

mandelbrot-orbits-rust's People

Contributors

Stargazers

Watchers

mandelbrot-orbits-rust's Issues

Re-use calculation for composition

The escape_time function calculates some interactions (255 right now):

fn escape_time(c: Complex<f64>, limit: usize) -> Option<usize> {
    let mut z = Complex { re: 0.0, im: 0.0 };
    for i in 0..limit {
        if z.norm_sqr() > 4.0 {
            return Some(i);
        }
        z = z * z + c;
    }

    None
}

But the is_period_p starts again from z = 0.

fn is_period_p(z: Complex<f64>,c: Complex<f64>, n: usize) -> bool {
    let max_period = 40;

    let mut result = z.clone();

    for _iter in 0..max_period {

        let lambda = lambda(result, c, n);
        let lambda_abs = lambda.abs();

        if lambda_abs >= 1. {
            return false;
        }

        result = phi(result, c);
    }

    true
}

as you can see in the render function:

fn render(pixels: &mut [u8],
          bounds: (usize, usize),
          upper_left: Complex<f64>,
          lower_right: Complex<f64>)
{
    assert!(pixels.len() == bounds.0 * bounds.1);

    for row in 0..bounds.1 {
        for column in 0..bounds.0 {

            // ...

            pixels[row * bounds.0 + column] =
                match escape_time(point, iteration_limit) {
                    None => {
                        // Mandelbrot Set point
                        // Calculate period
                        let z0 = Complex { re: 0.0, im: 0.0 };
                        let period = calculate_period(z0, point);

                        // ...

                        color
                    },
                    // Not a Mandelbrot Set point. Grayscale depending on the escape time
                    Some(count) => iteration_limit as u8 - count as u8,
                };
        }
    }
}

Consider returning zn from escape_time instead of starting from z0.

Enable `dependabot`

Add file: .github/dependabot.yml

version: 2
updates:
  - package-ecosystem: "cargo" # See documentation for possible values
    directory: "/" # Location of package manifests
    schedule:
      interval: "weekly

Add tests for math function

We could add more tests for these functions:

phi
phi_n
lambda
is_period_p

Using known values.

If we do not know any value, we can run @jeremy-rifkin 's implementation to generate some values.

Remove darker pixels?

At the edge, some pixels are darker than they should. That's because the period is not calculated well, probably because the interactions are insufficient.

If we want to improve the artistic result without increasing the number of iterations. We can apply the direct formulas to detect periods 1 and 2 and adjust the colour.

Change color map: color depending on the period

I want to generate an image like this:

Where the colour of the pixel depends on the point period.

@jeremy-rifkin has already implemented it in C++, so I can try to port his code to Rust.

Use threads to improve the performace

In the book I'm following, there is an improvement by using threads:

https://github.com/ProgrammingRust/mandelbrot/tree/bands

There are different alternatives.

I would implement this once the image is generated correctly, or at least we merge this PR.

Workflow with e2e test

We can add a new workflow to generate a sample image. The workflow could:

Accept the same input parameters as the console app when you run it manually.
Generate an artefact and upload it so you can download the resulting image.

Use Newton's method to approximate the root

It seems Newton's method can be used to calculate the value we need for the lambda function. What I call "Za". It seems to be much faster.

https://math.stackexchange.com/a/4503144/1082376

I think that value is a root of the nth composition that is the computation of n iteration of z²+c.

This could be an alternative implementation. We could keep both for the record or just remove the old one if this is better.

Use `nextest` to run tests

I was looking for a way to show the test coverage and found the nextest crate.

Add test coverage: https://nexte.st/book/test-coverage.html

This is how it looks: https://github.com/nextest-rs/nextest/runs/7537588703?check_suite_focus=true#step:7:1

Create a docker image

I've created another docker image for a rust app here.

Once it's done, we could publish it on the docker hub.

Use LaTeX formatted math for the formulas

Convert this image in the README

into LaTeX formatted within Markdown.

Maybe it can be done once we have a good full and clear explanation.

We are using ColorType::L8. We could use RBG to apply other colours, but that would increase the size needed in memory to 3 bytes. And that would lower the maximum image size you can render with your computer because the full image is in memory before writing it into a file. In case you want a bigger image, you could always split it into parts.

josecelano / mandelbrot-orbits-rust Goto Github PK

mandelbrot-orbits-rust's Introduction

Mandelbrot Orbits

Requirements

Use

Development

Math

Execution time

Credits

License

Links

Repositories

Papers

Books

Wikibook

Demos

Other

mandelbrot-orbits-rust's People

Contributors

Stargazers

Watchers

mandelbrot-orbits-rust's Issues

Recommend Projects

Recommend Topics

Recommend Org