CCLee / Blog / Drawing Fractal (Mandelbrot Set) in Rust

1. Result

2. Methametical Definition

For each , define , we say that is in a Mandelbrot set if the sequence

is bounded, which is the same as saying the seqeunce of complex numbers defined by is bounded with .

3. Coding

Since we have a sequential definition, in coding which is the same as saying

1let mut z = Complex { re: 0.0, im: 0.0 };
2
3for i in 0..n {
4  z = z * z + c
5}

is bounded for however large .

3.1. Preliminary Functions

3.1.1. Crates

1use image::codecs::png::PngEncoder;
2use image::{ExtendedColorType, ImageEncoder, ImageError};
3use num::Complex;
4use std::fs::File;
5use std::time::Instant;

3.1.2. ecape_time

1fn escape_time(c: Complex<f64>, limit: usize) -> Option<usize> {
2    let mut z = Complex { re: 0.0, im: 0.0 };
3    for i in 0..limit {
4        if z.norm_sqr() > 4.0 {
5            return Some(i);
6        }
7        z = z * z + c
8    }
9    None
10}

A theorem in fractal analysis says that

Theorem. A point belongs to the Mandelbrot set if and only if for all .

To plot the graph of Mandelbrot set, it is enough to loop through a set of points in a complex plane and for each point we consider it as a point in Mandelbrot set if let mut z = c;, z = z * z + c; has norm smaller than 2 for each of 255 loops. If it is bigger than 2 for some iteration, we end the loop.

3.1.3. pixel_plane_to_complex_plane

1fn pixel_plane_to_complex_plane(
2    pixel_img_dim: (usize, usize),
3    pixel_coordinate: (usize, usize),
4    complex_plane_upper_left: Complex<f64>,
5    complex_plane_lower_right: Complex<f64>,
6) -> Complex<f64> {
7    let complex_plane_width = complex_plane_lower_right.re - complex_plane_upper_left.re;
8    let compelx_palne_height = complex_plane_upper_left.im - complex_plane_lower_right.im;
9    let pixel_img_width = pixel_img_dim.0 as f64;
10    let pixel_img_height = pixel_img_dim.1 as f64;
11    let new_re = complex_plane_upper_left.re
12        + (pixel_coordinate.0 as f64) * complex_plane_width / pixel_img_width;
13    let new_im = complex_plane_lower_right.im
14        + (pixel_img_height - pixel_coordinate.1 as f64) * compelx_palne_height / pixel_img_height;
15    Complex {
16        re: new_re,
17        im: new_im,
18    }
19}

3.1.4. render

1fn render(
2    pixels: &mut [u8],
3    image_dim: (usize, usize),
4    complex_upper_left: Complex<f64>,
5    complex_bottom_right: Complex<f64>,
6) {
7    assert!(pixels.len() == image_dim.0 * image_dim.1);
8    for row in 0..image_dim.1 {
9        for col in 0..image_dim.0 {
10            let z = pixel_plane_to_complex_plane(
11                image_dim,
12                (col, row),
13                complex_upper_left,
14                complex_bottom_right,
15            );
16            pixels[row * image_dim.0 + col] = match escape_time(z, 255) {
17                Some(count) => 255 - (count as u8),
18                None => 0,
19            }
20        }
21    }
22}

3.1.5. write_png

1fn write_png(file_name: &str, pixels: &[u8], dimension: (usize, usize)) -> Result<(), ImageError> {
2    let output = File::create(file_name)?;
3    let encoder = PngEncoder::new(output);
4    encoder.write_image(
5        pixels,
6        dimension.0 as u32,
7        dimension.1 as u32,
8        ExtendedColorType::L8,
9    )?;
10    Ok(())
11}

3.2. run_in_single_thread

1fn run_in_single_thread() -> Result<(), ImageError> {
2    let image_dim = (3000, 2000);
3    let mut pixels = vec![0; image_dim.0 * image_dim.1];
4    let z_upper_left = Complex {
5        re: -1.20,
6        im: 0.35,
7    };
8    let z_lower_right = Complex { re: -1.0, im: 0.20 };
9    render(&mut pixels, image_dim, z_upper_left, z_lower_right);
10    write_png("fractal.png", &pixels, image_dim)?;
11    Ok(())
12}

Contents