GitHub - librity/ft_fractol: 42 São Paulo - fract-ol

42 São Paulo - fract-ol

A fractal navigator in pure C.

📜 Table of Contents

About
Checklist
Getting Started
Controls
Gallery
Notes
42 São Paulo
Resources

🧐 About

This is an interactive program that lets you explore the three fractals: The Mandelbrot and Julia sets, and the Newton fractal of the polynomial z^3 - 1. All three produce beautiful geometric structures that repeat themselves over increasing levels of detail.

It also lets you switch between three different color modes (algorithms): Escape-Time, Linear Interpolation and Bernstein polynomials. The first one is the quickest while the last two are the prettiest.

This is my favorite project from the 42 curriculum: I not only learned a lot, I now have a folder full of sick desktop background I can show off. It taught me how to translate mathematical objects and operations into structures and functions. I also learned many different C optimizations, from compiler flags to changes in workflow and logic.

✅ Checklist

Mandatory

Bonus

Render another fractal of your choice
Zoom follows mouse position
Arrow keys move the view
Changes color on keypress

Extra Features

🏁 Getting Started

⚙️ Prerequisites

This will only compile on Linux and FreeBSD.

You will need a C compiler (gcc or clang) and minilibx, an X-Window API in C made by 42 Paris:

# Clone the repo
git clone https://github.com/42Paris/minilibx-linux.git
cd minilibx-linux

# Install dependencies and build
sudo apt install libxext-dev libxrandr-dev libx11-dev libbsd-dev libssl-dev
make

# Copy archive and headers to system path
sudo cp libmlx.a /usr/local/lib/
sudo cp mlx.h /usr/local/include/

# Add pages to man (optional)
sudo mkdir /usr/local/man/man1
sudo cp man/man1/* /usr/local/man/man1/
man mlx

🖥️ Installing

Clone the repo and build with make:

$ git clone --recurse-submodules https://github.com/librity/ft_fractol.git
$ cd ft_fractol
$ make
$ fractol mandelbrot

This should open a new window rendering the mandelbrot fractal. You can also render the julia set (that requires a complex factor), and the Newton fractal of the polynomial z^3 - 1:

$ fractol julia -0.391 -0.587
$ fractol newton

🕹️ Controls

Esc or q: Exit program
= and -: Zoom in and out
Mouse Wheel: Zoom in and out
Arrow Keys: Move fractal position
Mouse Left Click: Warp to clicked pixel
c: Switch color mode
l and .: Shift color bases up and down
i and k: Increase and decrease iterations
t and g: Increase and decrease infinity
s: Save viewport to bitmap

🎨 Gallery

and much, much more...

📝 Notes

We can understand the basic workflow of the program from its main.c: all its function behave on the program's highest levels of abstraction.

We have a control structure ctl of type t_fractol where we inject anything that might change during runtime: we have the window size, the mlx instance, window and buffer, rendering params like the maximum number of iterations, and function pointers that allow us to dynamically change which fractal and how color is rendered. We set all its default settings with initialize_params: this ensures that the program won't crash if you forgot to set a param.

The window buffer is mostly handled by minilibx: we just create it in initialize_mlx, then set the color of its pixels and draw it to the window whenever we render a fractal.

In handle_arguments we verify and parse the strings we received from the shell. If the arguments don't match any of the options we exit the program with a help message.

We then initialize_mlx, which safely creates an mlx instance, window and image (a.k.a. the frame buffer). We always check and exit the program if any of the pointers are NULL: Not doing this WILL CRASH YOUR COMPUTER AND IT'S REALLY NOT FUNNY (mine crashed three times during this project). We also set the event handlers with mlx_hooks: this will let us interact with the program with our mouse and keyboard (zoom in/out, move, etc.) We finally render the first frame of the fractal and draw it to the window.

When we run the function mlx_loop we initialize the internal workflow of mlx. It basically listens for events and runs the handlers functions we set. All our handlers do basically the same thing: they change a ctl parameter, then render another frame and draw it to the window.

The renderers is where the magic happens:

Iterate through every pixel in the buffer
Transform it to a complex number (pixel(x, y) = x + y*i)
Run the fractal algorithm on that number
Run the color algorithm on the number of iterations
Draw that color to the buffer's pixel.

The Mandelbrot algorithm iterates the complex number c inside the function Fn(z) = z^2 + c, where F0(z) = 0.

The Julia algorithm is very similar to Mandelbrot's: we iterate the complex number c and factor f inside the function Fn(z) = z^2 + f, where F0(z) = c.

The Newton fractal iterates the Newton–Raphson method over an arbitrary differentiable function (z^3 - 1 in this case) for every pixel on the screen.

🛸 42 São Paulo

Part of the larger 42 Network, 42 São Paulo is a software engineering school that offers a healthy alternative to traditional education:

It doesn't have any teachers and classes.
Students learn by cooperating and correcting each other's work (peer-to-peer learning).
Its focus is as much on social skills as it is on technical skills.
It's completely free to anyone that passes its selection process - The Piscine

It's an amazing school, and I'm grateful for the opportunity.

📚 Resources

minilibx

minilibx functions

void	*mlx_init();
void	*mlx_new_window(void *mlx_ptr, int size_x, int size_y, char *title);
int	mlx_clear_window(void *mlx_ptr, void *win_ptr);
int	mlx_pixel_put(void *mlx_ptr, void *win_ptr, int x, int y, int color);
void	*mlx_new_image(void *mlx_ptr,int width,int height);
char	*mlx_get_data_addr(void *img_ptr, int *bits_per_pixel,
			   int *size_line, int *endian);
int	mlx_put_image_to_window(void *mlx_ptr, void *win_ptr, void *img_ptr,
				int x, int y);
int	mlx_get_color_value(void *mlx_ptr, int color);
int	mlx_mouse_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int	mlx_key_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int	mlx_expose_hook (void *win_ptr, int (*funct_ptr)(), void *param);
int	mlx_loop_hook (void *mlx_ptr, int (*funct_ptr)(), void *param);
int	mlx_loop (void *mlx_ptr);
int mlx_loop_end (void *mlx_ptr);
int	mlx_string_put(void *mlx_ptr, void *win_ptr, int x, int y, int color,
		       char *string);
void	mlx_set_font(void *mlx_ptr, void *win_ptr, char *name);
void	*mlx_xpm_to_image(void *mlx_ptr, char **xpm_data,
			  int *width, int *height);
void	*mlx_xpm_file_to_image(void *mlx_ptr, char *filename,
			       int *width, int *height);
int	mlx_destroy_window(void *mlx_ptr, void *win_ptr);
int	mlx_destroy_image(void *mlx_ptr, void *img_ptr);
int	mlx_destroy_display(void *mlx_ptr);
int	mlx_hook(void *win_ptr, int x_event, int x_mask,
                 int (*funct)(), void *param);
int	mlx_do_key_autorepeatoff(void *mlx_ptr);
int	mlx_do_key_autorepeaton(void *mlx_ptr);
int	mlx_do_sync(void *mlx_ptr);
int	mlx_mouse_get_pos(void *mlx_ptr, void *win_ptr, int *x, int *y);
int	mlx_mouse_move(void *mlx_ptr, void *win_ptr, int x, int y);
int	mlx_mouse_hide(void *mlx_ptr, void *win_ptr);
int	mlx_mouse_show(void *mlx_ptr, void *win_ptr);
int	mlx_get_screen_size(void *mlx_ptr, int *sizex, int *sizey);

Fractals

Mandelbrot set

Julia set

Tricorn

https://en.wikipedia.org/wiki/Tricorn_(mathematics)

Burning Ship

https://en.wikipedia.org/wiki/Burning_Ship_fractal

Newton Fractal

https://github.com/jcponce

OneLoneCoder

Window Viewport

https://www.geeksforgeeks.org/window-to-viewport-transformation-in-computer-graphics-with-implementation/

Videos

Math

Luc de Jonckheere’s Thesis

Fractal Software

Map

https://github.com/processing/p5.js/blob/main/src/math/calculation.js#L451

`valgrind`

GCC `-fsanitize=address` `-fsanitize=leak`

Faster than valgrind , but detects less leaks.
Incompatible with valgrind
Probably slows down runtime
https://stackoverflow.com/questions/11524960/memory-leaks-not-detected-by-crt-memory-leak-detection
https://stackoverflow.com/questions/31210053/gcc-and-fsanitize-leak
https://stackoverflow.com/questions/65572114/how-does-fsanitize-leak-affect-runtime-performance

// Won't detect this leak
int	main(void)
{
	void	*ptr;
	ptr = malloc(8);
	return (0);
}

Debug Flag `-g`

https://stackoverflow.com/questions/24117063/is-a-program-compiled-with-g-gcc-flag-slower-than-the-same-program-compiled-wit

Optimization Flags

-O3 and -O2
https://www.rapidtables.com/code/linux/gcc/gcc-o.html

Minilibx close window on red cross click

X Server/X11/X Window System

Wayland

https://en.wikipedia.org/wiki/Wayland_(display_server_protocol)#Differences_between_Wayland_and_X

Zoom

GNU Multiple Precision Arithmetic Library

Nvidia Compute Unified Device Architecture

C Optimizations

https://stackoverflow.com/questions/54297525/fast-way-to-get-a-close-power-of-2-number-floating-point

Coloring Algorithms

Escape-Time Algorithm

Linear Interpolation (lerp)

Color Gradients

Bernstein polynomials Color

r(t) = 9 ∗ (1 − t) ∗ t^3 ∗ 255
g(t) = 15 ∗ (1 − t)^2 ∗ t^2 ∗ 255
b(t) = 8.5 ∗ (1 − t)^3 ∗ t ∗ 255

Graphic Effects

`pthread.h`

`ft_ftoa`, `ft_dtoa`, `ft_ldtoa`

sizeof(int): 4
sizeof(long): 8
sizeof(long long): 8
sizeof(float): 4
sizeof(double): 8
sizeof(long double): 16

`ft_atof`, `ft_atold`

Norminette-compliant C formatter

Automatically add functions to C header

C Multiline String Literal

https://jameshfisher.com/2016/11/30/c-multiline-literal/

C Documenting Functions

https://stackoverflow.com/questions/3568052/where-to-document-functions-in-c-or-c

C Testing

C Function Pointers

Makefile `wildcard` `foreach` `patsubst` `addprefix` `filter-out`

Relinking

https://stackoverflow.com/questions/29659569/what-is-relinking-warning

Git

https://www.gitkraken.com/learn/git/problems/revert-git-commit

Git `submodule`

git clone --recurse-submodule REMOTE_REPO
git submodule add REMOTE_REPO
git submodule foreach git pull
git submodule update --init --recursive
https://stackoverflow.com/questions/33714063/how-to-update-submodules-in-git
https://stackoverflow.com/questions/59271919/how-to-clone-public-submodule-in-github-actions
https://stackoverflow.com/questions/50254184/git-submodule-and-fetch
https://www.w3docs.com/snippets/git/how-to-add-a-submodule-in-git.html
https://stackoverflow.com/questions/1260748/how-do-i-remove-a-submodule#1260982

Color Inspirations

https://en.wikipedia.org/wiki/Calliophis_bivirgatus

Name		Name	Last commit message	Last commit date
Latest commit History 93 Commits
.github/workflows		.github/workflows
.vscode		.vscode
bitmaps		bitmaps
examples		examples
gallery		gallery
includes		includes
libs		libs
scripts		scripts
snippets		snippets
sources		sources
tests		tests
.gitignore		.gitignore
.gitmodules		.gitmodules
.linux		.linux
.normignore		.normignore
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
main.c		main.c

License

librity/ft_fractol

Folders and files

Latest commit

History

Repository files navigation