Generative Art | Tahsin Tariq Banna

Random Crawlers

Wed, 11 Jun 2025 00:00:00 +0000

Introducing Random Crawlers

Controls:

i - Toggle trajectory
p - Toggle pendulums
l - Toggle pendulum joints
u - Toggle crawlers
o - Toggle attachment points

What is it?

A random crawlers as I call it is a set of very simple rules that can simulate natural looking movement. But even though the underlying mechanism is simple, the results are anything but. The name random crawlers is a reference to one of my favorite processes in mathematics, the Random Walk algorithm. This simple process links several fields of modern technology including computer graphics, game dev, physics, fluid simulation and even social sciences. But I find it quite fascinating how linking one stochastic process to another completely seemingly unrelated thing can result in beautiful visualizations.

How does it work?

This is a piece I’ve worked on for quite a while. it’s essentially a set of chained rotating arms connected end to end. Each have their own length and rotational speed. At the end of the chain is anchored a crawler agent that simply connects to nearby points and therefore, the anchor and the connecting lines make it seem like crawlers. The end of the chains form what is known as an epicycle. Since the initialization for the chains are random every step, the generated curve also varies drastically and is extremely sensitive to initial conditions. However, unlike a multi-pendulum system, this is not chaotic, rather deterministic. This gives us the added benefit of parameterizing the model so we don’t depend on the previous step of the simulation to predict the next. The tip position is a closed-form function of time.

Link $i$ has length $L_i$, an initial angle $\varphi_i$, and an angular velocity $\omega_i$, so its angle at time $t$ is simply $\varphi_i + \omega_i t$. Summing the contributions down a chain of $N$ links from a pivot at $(x_0, y_0)$:

$$ x(t) = x_0 + \sum_{i=1}^{N} L_i \sin(\varphi_i + \omega_i t) $$

$$ y(t) = y_0 + \sum_{i=1}^{N} L_i \cos(\varphi_i + \omega_i t) $$

Or, treating the plane as the complex plane, which is much tidier:

$$ z(t) = z_0 + \sum_{i=1}^{N} L_i e^{i(\varphi_i + \omega_i t)} $$

With this parameterizion, we can now predict the state of the chain at any point in time and even look ahead many many steps in the future. Simulating the entire thing by stepping through frames of the sketch is really slow and dependent on the hardware capability of the machine it’s running on. This parameterizion actually fixes the issue as it is no longer dependent on the framerate.

The random points around the crawler anchor is generated using poisson disk sampling. Pure random (or even pseudo random) numbers have a tendency to cluster together, a phenomenon know as poisson clumping. Poisson disk sampling gives a uniform look to the randomly scattered points.

Motivation

This was largely inspired from the work Process Compendium by Casey Reas. There he describes how a simple set of elements and interaction processes can lead to complex forms and behaviours. For Random Crawlers, this can be described simply as follows:

Element 1. A point that moves along the sum of $N$ circular motions.

Element 2. Stationary points distributed uniformly along the plane.

Process. Draw a line from each Element 1 to every Element 2 within distance $d$.

I drew this with mathematical equations

Mon, 10 Feb 2025 00:00:00 +0000

Photos and videos are processed on device and not uploaded elsewhere.

Settings

Procedural Terrain Generation

Wed, 15 Apr 2020 00:00:00 +0000

Introduction

Creating a terrain manually for a game or just for visualization purposes is a really daunting task. Instead, a better way to do so is to programmatically generate it by passing some parameters to a code. Here, I discuss how to make a procedural terrain generator mostly using processing for python. This can also be done in any other language or game engine or 3D design software. I will be making a simple terrain using height maps for stylized purposes. But, first we need to understand how to generate height maps using perlin noise.

Perlin noise is a procedurally generated noise texture developed by ken perlin. How perlin noise is generated using code is discussed thoroughly here. I’ll be using the built in noise function that generates perlin noise for processing.

Generating sample points

In order to render the terrain, we need some geometry. We can generate tile the plane with cubes, but that would look more like minecraft. We could choose randomly generated points. But purely random or even pseudo-random choices have a tendency of clustering together. This phenomenon is known as Poisson Clumping. Pure or pseudo-random points are not good choices because of this phenomenon, as shown below.

Generated random points tend to cluster together.

So, instead we use a different sort of random point generation called Poisson Disc Sampling. This generates random points at a given interval and thus making them more uniform. This is a much better choice for generating terrains.

Now if we triangulate the points,We should get a plane with enough geometry to offset using the generated height map. I go into some details on triangulation here. The final result should look something like this (without the animation of course):

Creating a rough 3D terrain

Now we rotate the canvas on the y-axis so it looks more like a plane.

The entire plane rotated along the Y-axis to give it a 3D look

Now, using the generated height map, we offset the z-position of the points by the value corresponding to that x and y position in the height map. This gives us a stylized terrain.

A generated rough terrain

We can change the shape of this terrain by changing the noise using offsets. This can result in traversing through the terrain as if we were flying on top of it, or changing the entire topology of the terrain. It will depend on how the noise is being offset.

I’ve put the processing.py codes for this project here.

Smoother surfaces

The generated surface is still pretty low resolution and looks pointy. This can be solved in two ways. First, we can either increase the number of points from the poisson disk sampling process. The other method is using the Catmull-Clark algorithm. This is a technique used in 3D computer graphics to represent curved surfaces by the specification of a coarser polygonal mesh and produced by a recursive algorithmic method.

Furthermore, the same process can be used to generate terrain in 3D modelling software. The Catmull-Clark algorithm can be used easily here as most software have built in support. The following demonstrates the improvements made while using the algorithm.

The left image shows a coarse pointy surface the right image shows a smooth, curved, subdivided surface and below is an animated terrain made in Blender 3D.

Example videos

Below are two different renders I’ve made using the processing.py. One with a half inverted render and the other colored according to the height of the points i.e. a topological height map.