julia.c

Go to the documentation of this file.

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   julia.c                                            :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: meghribe <meghribe@student.42barcelona.co  +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2024/12/24 19:09:26 by meghribe          #+#    #+#             */
/*   Updated: 2025/01/05 14:00:18 by meghribe         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */
 
#include "fractol.h"
 
/**
 * @file julia
 * @brief Implementation of the Julia set rendering.
 *
 * This file handles all calculations and rendering logic for he Julia set
 *  fractal.
 * It contains functions that:
 * - Perrform the iterative mathematical calculations for each point in the
 *   Julia set.
 * - Render invidiaul rows of the fractal to optimize performance.
 * - Manage the rendering off the entire fractal based on user-defined
 *   parameters.
 *
 * ### For Technical Users:
 * - **Core Alrogithm:** The Julia set is calculated iteratively using the
 *   formula: `z = z^2 + c`, where `z` is a complex number and `c` is
 *   a constant parameter.
 *   The function computes whether each point "escapes" or remains bounded
 *   within a set threshold.
 * - **Optimization:** The fractal is rendered row by row to efficiently
 *   utilize memory and computational resources. Intermediate results like
 *   squared values are stored to avoid redundant calculations.
 * - **Color Mapping:** Each point's "escape time" determines its color,
 *   creating the fractal's visually striking patterns.
 *
 * ### For Non-Technical Users:
 * - **What is the Julia Set?**
 *   The Julia set is a mathematical pattern generated by repeatedly
 *   applying a formula to points on a grid. Some points "escape" quickly,
 *   while others stay trapped. The resulting image is mesmerizing, intricate
 *   design.
 * - **How does this file work?**
 *   Think of this like as the "artist" responsible for drawing the Julia set.
 *   It decides:
 *   - Where each point in the fractal goes on the screen.
 *   - How many iterations it takes for each point to escape the threshold.
 *   - What color each point should have based on its behavior.
 * - **Why is it row by row?**
 *   Instead of drawing the entire image at once, this program works row by row
 *   for better performance, like filling in coloring book on line at a time
 *   Instead of drawing the entire image at once, this program works row by row
 *   for better performance, like filling in coloring book on line at a time.
 *
 * The Julia set is unique because its shape depends on the user-provided
 * parameters. You can explore endless variations by tweaking the input values!
 */
 
/**
 * @brief Performs the iterations for a signle point in the Julia set.
 *
 * This function applies the Julia set formula iteratively to determine
 * whether a given point escapes the threshold. The number of iterations taken
 * before escape determines the point's color.
 *
 * - **Core Algorithm:** The formula `z = z^2 + c` is applied, where:
 *   - `z` is a complex number, represented by real (`z_re`) and 
 *    imaginary (`z_im`) parts.
 *   - `c` is a constant defined by the user (real and imaginary parts).
 * - **Bounding Condition:** The iteerations stop when:
 *   - The sum of the squares of the real and imaginary parts exceeds 4.0.
 *   - The maximum number of iterations (`MAX_ITERATIONS`) is reached.
 * - **Optimization:** Squared values (`z_re^2` and `z_im^2`) are cached
 *   to avoid redundant calculations.
 *
 * @param vars Pointer to the structure holding rendering variables
 *  (e.g., `z` and `iterations`).
 * @params data Pointer to the main fractal data, including the Julia
 *  constant (`c`).
 */
static void julia_iterations(t_render_vars *vars, t_data *data)
{
    double  temp_z_re;
 
    vars->iterations = 0;
    while (vars->z_squared[COMPLEX_RE] + vars->z_squared[COMPLEX_IM] <= 4.0 && \
            vars->iterations < MAX_ITERATIONS)
    {
        temp_z_re = vars->z_squared[COMPLEX_RE];
        temp_z_re -= vars->z_squared[COMPLEX_IM];
        temp_z_re += data->c[COMPLEX_RE];
        vars->z[COMPLEX_IM] = 2.0 * vars->z[COMPLEX_RE] * \
            vars->z[COMPLEX_IM] + data->c[COMPLEX_IM];
        vars->z[COMPLEX_RE] = temp_z_re;
        vars->z_squared[COMPLEX_RE] = vars->z[COMPLEX_RE] * vars->z[COMPLEX_RE];
        vars->z_squared[COMPLEX_IM] = vars->z[COMPLEX_IM] * vars->z[COMPLEX_IM];
        vars->iterations++;
    }
}
 
/**
 * @brief Renders a single row of the Julia set.
 *
 * This function processes one row of the pixel in the Juliaa set by iterating
 * through each pixel, applying the Juliaa set formula, and determining its
 * color.
 *
 * - **Coordinate Mapping:**
 *   - Each pixel is mapped to a complex number (`z`) based on its position
 *      and the scaling factors calculated from the zoom and offsets.
 * - **Iteration and Coloring:**
 *   - The Julia set formula is applied iteratively for each pixel.
 *   - The number of iterations is used to calculate the pixel's color.
 * - **Row Processing:** Each pixel in the row is processed sequentially,
 *   and the result is stored in the image buffer.
 *
 * @param vars Pointer to the rendering variables structure (e.g., pixel and
 *  scaling).
 * @param data Pointer to the main fractal data.
 * @param y The current row index being processed (0 for the first row, up to
 * `HEIGHT - 1`).
 */
static void render_julia_row(t_render_vars *vars, t_data *data, int y)
{
    int x;
 
    x = 0;
    while (x < WIDTH)
    {
        vars->c_re[0] = vars->start[COMPLEX_RE] + x * vars->scale[SCALE_X];
        vars->z[COMPLEX_RE] = vars->c_re[0];
        vars->z[COMPLEX_IM] = vars->c_im;
        vars->z_squared[COMPLEX_RE] = vars->z[COMPLEX_RE] * vars->z[COMPLEX_RE];
        vars->z_squared[COMPLEX_IM] = vars->z[COMPLEX_IM] * vars->z[COMPLEX_IM];
        julia_iterations(vars, data);
        vars->row = vars->pixels + y * WIDTH + x;
        *vars->row = calculate_color(vars->iterations);
        x++;
    }
}
 
/**
 * @brief Renders the Julia set fractal.
 *
 * This function handles the full rendering process for the Julia set by
 * iterating through all rows of the screen, rendering each row sequentially.
 *
 * - **Setup:**
 *   - Calculates the scaling and starting coordinates based on the zoom level
 *      and positional offsets provided by the user.
 * - **Row-by-Row Rendering:**
 *   - For each row on the screen (`y` coordinate), the corresponding imaginary
 *      coordinate is computed.
 *   - The row is passed to `render_julia_row`, which handles the pixel-by-pixel
 *   rendering.
 * - **Full Image Construction:**
 *   - The ffunction processes every row until the entire fractal is rendered.
 *
 * @param data Pointer to the main fractal data structure, including rendering
 *  details such as zoom, offsets, and fractal paarameters.
 */
void    render_julia(t_data *data)
{
    t_render_vars   vars;
    int             y;
 
    calculate_scales_and_limits(&vars, data);
    y = 0;
    while (y < HEIGHT)
    {
        vars.c_im = vars.start[COMPLEX_IM] + y * vars.scale[SCALE_Y];
        render_julia_row(&vars, data, y++);
    }
}