Fractal Tree

Stochastic Fractals: Digital Nature Through Random Recursion

Procedural Tree Generation

A generative art project that simulates natural tree growth by introducing randomness into fractal recursion.

Summary

This project implements a recursive branching algorithm where each generation of branches incorporates controlled randomness in multiple parameters: the number of branches that spawn from each parent branch, the angles at which they emerge, their lengths, and their thicknesses. By carefully balancing deterministic rules with stochastic elements, the system generates infinitely varied trees that nevertheless remain recognizably tree-like.

The interactive controls allow users to experiment with various parameters that affect the tree’s growth patterns. You can adjust the amount of randomness in branch count and angles, modify the probability of branches terminating early, or change environmental factors like wind direction and seasonal effects. This creates a fascinating sandbox for exploring how different levels of randomness affect the overall structure and how complex, organic forms can emerge from relatively simple rules.

Process

The development of this project was an exercise in finding balance, between performance and detail.

I began with a standard recursive tree algorithm where each branch spawns two smaller branches at fixed angles. This produced perfectly symmetrical trees that looked artificial. The breakthrough came when I started adding variability to each parameter:

// Calculate base angle for this branch
let branchAngle;
if (branchCount === 1) {
  // Single branch continues more or less straight
  branchAngle = angle + random(-0.1, 0.1);
} else {
  // Spread branches out
  branchAngle = angle - PI/4 + angleStep * (i + 1);
}

The most challenging aspect was creating a system where randomness produced interesting variation without creating visual chaos. Early versions either looked too regular or completely random and unrecognizable. Finding the right probability distributions and parameter ranges required extensive experimentation and tuning.

Performance was another significant challenge. Each tree can involve hundreds of recursive function calls, and early versions would freeze the browser when parameters were adjusted. I implemented optimizations like terminating branches probabilistically based on depth and adding constraints to prevent exponential growth:

// Random termination
const terminationChance = config.branchTermination * (1 + (6 - depth) / 2);
if (random() < terminationChance) {
  // Draw leaves at terminated branches
  if (random() < config.leafDensity && depth < 4) {
    drawLeaves(endX, endY, thickness, config.season);
  }
  return;
}

Code References

This project builds on several key resources:

1. Daniel Shiffman’s Coding Train series on L-systems and recursive trees provided the foundational approach: https://thecodingtrain.com/challenges/14-fractal-trees-recursive

2. The p5.js documentation and examples on recursion and randomness: https://p5js.org/examples/structure-recursion.html

3. Algorithmic Botany by Przemyslaw Prusinkiewicz and Aristid Lindenmayer: http://algorithmicbotany.org/papers/ - This academic resource provided the theoretical background on modeling plant growth.

4. The UI controls implementation was adapted from examples in the DAT.GUI documentation: https://github.com/dataarts/dat.gui