Introduction to Signed Distance Functions (SDFs)

1. The Geometry of Signed Distance

At its core, a Signed Distance Function is a very elegant way to describe a shape. Instead of listing the points that make up a shape's surface, an SDF defines the shape by telling you, for any point in space, how far it is from the surface.

Formally, an SDF is a function $f(\mathbf{x})$ that takes a 3D coordinate $\mathbf{x}=(x,y,z)$ and returns a scalar value representing the shortest distance to a surface $\mathcal{S}$. The "signed" part is key:

• If $\mathbf{x}$ is outside the shape, the distance is positive.
• If $\mathbf{x}$ is inside the shape, the distance is negative.
• If $\mathbf{x}$ is exactly on the surface, the distance is zero.

This means the surface itself is implicitly defined as the zero level-set of the function: $\mathcal{S}=\{\mathbf{x}\in {\mathbb{R}}^3\mid f(\mathbf{x})=0\}$.

This video provides an excellent mathematical introduction to SDFs. It starts by motivating their use with a rendering technique called ray-marching, defines them formally, and shows how they can be manipulated.

As you saw, one of the elegant properties of SDFs is their compositionality. You can combine primitive shapes using simple mathematical operations:

• Union ($\cup$): min(sdf_A(x), sdf_B(x))
• Intersection ($\cap$): max(sdf_A(x), sdf_B(x))
• Difference (A \ B): max(sdf_A(x), -sdf_B(x))

While these are approximations that can have issues at sharp corners, they provide a powerful procedural modeling toolkit.

2. From Analytical Functions to Neural Networks: DeepSDF

The examples in the video (circles, rectangles) have simple analytical formulas. But how can we represent the SDF for a complex, arbitrary shape like a car or a chair? This is where neural networks come in.

The seminal work DeepSDF proposed using a Multi-Layer Perceptron (MLP) to learn a continuous SDF for a class of shapes. The idea is to train the network to act as the function $f_{\theta }$, where $\theta$ are the network's weights.

The simplest version would train one network per shape. However, the real power comes from training a single network to represent an entire category of shapes (e.g., all chairs). This is achieved by conditioning the network on a latent code $\mathbf{z}$, a low-dimensional vector that captures the unique geometry of a specific shape instance.

The network architecture then becomes: $f_{\theta }(\mathbf{x},\mathbf{z})\to s$, where $s$ is the predicted signed distance.

The following reading explains this concept clearly, detailing how the model is trained and how the latent codes are learned.

The training process for DeepSDF is a supervised learning task:

1. Data: For a given shape, we need a large set of 3D points $\{{\mathbf{x}}_i\}$ and their corresponding ground-truth signed distance values $\{s_i\}$. This data is typically pre-computed from a high-quality mesh.
2. Model: The MLP takes a point ${\mathbf{x}}_i$ and the shape's latent code $\mathbf{z}$ as input and predicts a distance value ${\hat{s}}_i$.
3. Loss: The network weights $\theta$ and the latent codes $\mathbf{z}$ are optimized simultaneously to minimize a regression loss, typically the L1 loss between the predicted and true distances: $\mathcal{L}={\sum }_i|{\hat{s}}_i-s_i|$.

For more detail on the specific loss function, which often includes a clamp operation to focus the network's capacity on accurately representing the region near the surface, you can refer to the "DeepSDF" section (3.1) in the report Neural Signed Distance Functions for 3D Shape ....

3. Practical Usage: Rendering and Mesh Extraction

Once we have a trained neural SDF, we can use it to visualize the 3D shape. There are two primary methods:

1. Rendering with Ray Marching: As introduced in the first video, we can render the shape directly. For each pixel, we march a ray from the camera. At each step, we query the SDF to find the distance to the surface. This value tells us the maximum safe step size we can take along the ray. We repeat this until we are very close to the zero-crossing, which indicates we've hit the surface.

2. Mesh Extraction with Marching Cubes: A more common approach is to first extract an explicit mesh representation from the implicit function. The Marching Cubes algorithm is perfect for this. We evaluate the SDF on a dense 3D grid of points. The algorithm then identifies all the grid cells where the SDF transitions from negative to positive, meaning the surface passes through them, and generates the corresponding triangle mesh.

A key advantage of SDFs for rendering is the ease of calculating surface normals. The normal at a surface point $\mathbf{x}$ is simply the gradient of the SDF at that point, $\mathbf{n}={\nabla }_{\mathbf{x}}f(\mathbf{x})$. For a neural SDF, this gradient can be calculated analytically and efficiently using autodifferentiation. These normals are essential for realistic lighting calculations.

This short clip provides a great summary of how a trained DeepSDF is used in practice.

4. SDFs vs. NeRFs

Let's compare the two implicit representations we've now seen.

The learned latent space of a conditional DeepSDF is also very powerful for generative tasks. By interpolating between the latent codes of two shapes, you can generate smooth transitions between them, as shown here.

Conclusion

In this lesson, we've defined Signed Distance Functions as a powerful implicit representation for 3D geometry. We saw how they work, how they can be learned with neural networks like DeepSDF, and how they compare to NeRFs.

Key Takeaways:

• An SDF represents a shape by a function that gives the distance to the surface from any point in space, with a sign indicating inside/outside.
• The surface is defined as the zero level-set of the SDF.
• DeepSDF uses an MLP to learn a continuous SDF, often conditioned on a latent vector to represent an entire class of shapes.
• SDFs are well-suited for clean surface extraction (e.g., via Marching Cubes) and provide high-quality surface normals via the gradient, which is critical for rendering.
• Compared to NeRFs, SDFs offer a more direct representation of geometry, while NeRFs are designed to represent appearance and volumetric effects for view synthesis.

Next Lesson Preview:

Having explored both NeRFs and SDFs, we now have a solid conceptual understanding of the two most important implicit representations for 3D generation. We will now shift gears back to implementation. In the next lesson, we will begin the hands-on process of building a NeRF renderer from scratch, starting with the very first component: implementing ray generation for a pinhole camera model.