Demystifying Signed Distance Functions (SDF) in Computer Graphics

Introduction

If you’ve delved into the realms of computer graphics, game development, or even 3D printing, you might have come across the term “SDF” or “Signed Distance Function.” At first glance, it may sound like a cryptic acronym, but fear not – in this article, we’ll demystify the concept of Signed Distance Functions and explore their significance in various domains. To make things more tangible, we’ll also delve into coding examples to illustrate how SDFs work.

Understanding the Basics

What is an SDF?

A Signed Distance Function (SDF) is a mathematical function that describes the distance from a point in space to the nearest surface of an object, with the sign indicating whether the point is inside or outside the object. In simpler terms, it provides a way to represent and manipulate shapes in a 3D space.

Why “Signed”?

The “signed” part in SDF is what sets it apart. The sign of the distance indicates whether the point is inside or outside the object. If the distance is positive, the point is outside the object; if negative, it’s inside. This property proves invaluable in various computer graphics applications, especially when dealing with constructive solid geometry (CSG) and ray marching.

The Magic of SDF in Code

Let’s delve into some code snippets to grasp how SDF works in practical scenarios. We’ll use a simple example of a sphere to keep things clear.

Representing a Sphere with SDF

To represent a sphere using an SDF, we can use the formula:

python

import numpy as np

def sdf_sphere(position, radius):
distance = np.linalg.norm(position) – radius
return distance

In this Python example, position is a 3D vector representing a point in space, and radius is the radius of the sphere. The function sdf_sphere calculates the signed distance from the point to the surface of the sphere.

Visualizing SDF with Ray Marching

One of the powerful applications of SDF is in ray marching, a technique commonly used in rendering. Ray marching involves casting rays into a scene, incrementally stepping along the ray, and determining the distance to the nearest surface using the SDF. Let’s create a simple ray marching function to visualize our sphere:

python

def ray_march(origin, direction, max_steps=100, epsilon=1e-6):

for step in range(max_steps):

position = origin + step * direction

distance = sdf_sphere(position, radius)

if abs(distance) < epsilon:
return positionreturn None # Ray didn’t hit anything within max_steps

In this code, origin is the starting point of the ray, direction is the ray direction, max_steps is the maximum number of steps to take, and epsilon is a small value to determine when the ray is considered to have hit the surface.

Putting it All Together

Now, let’s visualize our sphere by combining the SDF and ray marching:

python

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

radius = 2.0def visualize_sphere():
fig = plt.figure()
ax = fig.add_subplot(111, projection=‘3d’)for x in range(-10, 11):
for y in range(-10, 11):
for z in range(-10, 11):
position = np.array([x, y, z], dtype=float)
distance = sdf_sphere(position, radius)if abs(distance) < 0.1:
ax.scatter(position[0], position[1], position[2], c=‘b’, marker=‘o’)ax.set_xlabel(‘X’)
ax.set_ylabel(‘Y’)
ax.set_zlabel(‘Z’)
plt.show()visualize_sphere()

This code generates a 3D plot of points representing the surface of the sphere using our SDF. Adjusting the radius and parameters in the ray marching function can provide different visual outcomes.

Applications of SDF

Constructive Solid Geometry (CSG)

SDFs are fundamental in CSG, a technique for combining simple shapes to create more complex ones. By using operations like union, intersection, and subtraction on SDFs of basic shapes, intricate and detailed structures can be formed.

Let’s consider the union of two spheres using SDF:

python

def sdf_union(sdf_a, sdf_b):

return min(sdf_a, sdf_b)

In this example, sdf_a and sdf_b are the SDFs of two objects. The union is represented by taking the minimum distance to the surfaces of both objects.

Implicit Surface Modeling

SDFs enable the creation of implicit surfaces, where surfaces are defined by an implicit function rather than an explicit geometric representation. This allows for more flexible and dynamic modeling.

python

def sdf_torus(position, major_radius, minor_radius):

xz_distance = np.sqrt(position[0] ** 2 + position[2] ** 2) - major_radius

return np.sqrt(xz_distance ** 2 + position[1] ** 2) - minor_radius

Here, we define an SDF for a torus, showcasing the versatility of SDFs in modeling various shapes.

Conclusion

In conclusion, Signed Distance Functions are not just a mathematical curiosity; they are a versatile tool with practical applications in computer graphics, game development, 3D printing, and geometry processing. By efficiently representing complex shapes, SDFs enable faster and more resource-friendly computations, revolutionizing how we interact with and manipulate 3D data.

In this article, we’ve explored the basics of SDFs, their role in graphics through ray marching, and their broader applications in fields like 3D printing and geometry processing. Armed with this knowledge, you’re now better equipped to appreciate the magic behind the scenes when you encounter these seemingly cryptic functions in the world of digital creation.