Signed Distance Function (SDF)

The core defining property of an SDF is that for any point p in space, the function f(p) returns the shortest Euclidean distance to the surface of the represented object. The sign of this value is critical:

• Positive: The point is outside the object.
• Zero: The point is exactly on the surface.
• Negative: The point is inside the object. This sign provides an unambiguous, continuous classification of any point in space relative to the object's boundary.

The gradient (∇) of a true SDF at any point on the zero-level set (the surface) is equivalent to the outward-facing surface normal. This is a direct consequence of the distance property. In practice, this means:

• Normal = ∇f(p) where f(p) = 0.
• This property enables efficient lighting calculations (like Phong shading) directly from the SDF without needing explicit normal maps or mesh data.
• It is leveraged in sphere tracing (ray marching) to take optimal step sizes toward the surface.

An SDF uses the standard Euclidean (L2) distance metric. This ensures the distance value represents the true geometric shortest path to the surface. Key implications include:

• The zero-level set (where f(p)=0) is the true surface of the object.
• The magnitude of the SDF value corresponds to a physically meaningful distance in world units.
• This contrasts with other implicit functions (like occupancy networks) that output arbitrary scalars without a direct distance interpretation.

A proper SDF is Lipschitz continuous with a Lipschitz constant of 1. This means the rate of change of the function is bounded: the distance between two SDF values cannot exceed the spatial distance between the points where they are sampled.

• Mathematically: |f(p) - f(q)| ≤ ||p - q|| for all points p, q.
• This property guarantees stability for numerical methods like ray marching, ensuring the distance field provides a safe "step size" toward the surface.
• It is a foundational requirement for the convergence of sphere tracing algorithms.

A well-defined SDF is almost everywhere differentiable. This property is essential for modern applications:

• Gradient-Based Optimization: Enables the use of SDFs within neural networks (like in DeepSDF, NeuS) where gradients are backpropagated to learn scene geometry from images.
• Differentiable Rendering: Allows the SDF representation to be integrated into a full differentiable rendering pipeline, where scene parameters (shape, pose, appearance) can be optimized by comparing rendered outputs to ground truth images.
• Discontinuities typically only occur at medial axes (the skeleton of the shape).

SDFs support exact, closed-form constructive solid geometry (CSG) operations. This allows complex shapes to be built from primitives using simple mathematical operators:

• Union: f_union(p) = min( f_A(p), f_B(p) )
• Intersection: f_intersect(p) = max( f_A(p), f_B(p) )
• Difference: f_difference(p) = max( f_A(p), -f_B(p) )
• Smooth Blending: Using polynomial or exponential functions (e.g., smooth-min) to create fillets and organic transitions. This makes SDFs a procedural modeling powerhouse, unlike mesh-based representations where Boolean operations are geometrically complex and error-prone.

SDFs are the core primitive for ray marching, a rendering algorithm that samples the distance field to find surface intersections. This is essential for:

• Real-time rendering of complex, procedurally generated scenes in tools like Shadertoy.
• Generating volumetric effects like fog, clouds, and smoke with accurate lighting.
• Enabling global illumination and soft shadows directly from the SDF representation without a polygonal mesh. The algorithm's efficiency stems from the SDF's distance property, which allows for safe, large step sizes along the ray.

The signed distance value provides an immediate, analytic measure of proximity to a surface, making SDFs exceptionally fast for collision queries.

• Rigid body dynamics: Determine if objects are intersecting and calculate penetration depth for response.
• Character controller: Efficiently keep avatars or robots from passing through walls and floors.
• Particle systems: Simulate particles flowing around complex implicit shapes. This is superior to mesh-based methods for many continuous collision detection scenarios, as the exact distance and direction to the surface are known at any point.

SDFs are a leading choice for implicit neural representations of 3D geometry learned from data.

• Neural SDFs: Models like DeepSDF and NeuS use a multilayer perceptron (MLP) to regress the signed distance at any 3D coordinate, enabling high-fidelity surface reconstruction from sparse point clouds or images.
• Multi-resolution hashing: Frameworks like Instant-NGP use SDFs encoded in multi-resolution hash tables for real-time training and rendering.
• Surface extraction: The zero-level set (isosurface) of the learned SDF is extracted using algorithms like Marching Cubes to produce a final mesh.

In robotics, an SDF of the environment acts as a configuration space map, directly encoding obstacle proximity.

• Motion planning: Algorithms like RRT* and CHOMP use the SDF gradient to efficiently plan collision-free paths, pushing the planned trajectory away from obstacles.
• Gradient information: The gradient of the SDF points directly away from the nearest surface, providing a repulsive force for potential field methods.
• Safe distance maintenance: Ensures robots and autonomous vehicles maintain a buffer zone from all obstacles, which is critical for safety in dynamic environments.

SDFs enable powerful Constructive Solid Geometry (CSG) through simple mathematical operations on the distance fields.

• Boolean operations: Union, intersection, and difference of shapes are achieved using min, max, and other combination functions on their SDFs (e.g., unionSDF = min(sdfA, sdfB)).
• Smooth blending: Create organic, blended transitions between shapes using smooth minimum functions, which is difficult with explicit mesh representations.
• Offsetting & rounding: Creating inflated, deflated, or filleted versions of a shape is trivial by adding/subtracting a constant from the SDF. This makes SDFs ideal for procedural content generation and parametric design.

In medical image analysis, SDFs (often called level set functions) are used to represent and evolve contours and surfaces.

• Image segmentation: The zero-level set of an SDF is evolved to fit organ boundaries in MRI or CT scans, a technique central to the level-set method.
• Tumor growth modeling: The SDF can be evolved according to differential equations to simulate biological processes.
• Shape analysis: SDFs provide a consistent representation for comparing anatomical structures across patients or over time. The implicit representation naturally handles changes in topology, such as splitting or merging regions, which is a major advantage over parametric models.

A class of 3D shape representations defined by a continuous function, typically a neural network, that can be queried at any point in space. Unlike explicit representations like meshes or voxel grids, implicit functions define geometry implicitly through a decision boundary (e.g., the zero-level set of an SDF).

• Key Types: Signed Distance Functions (SDFs), occupancy networks, and neural radiance fields (NeRFs) with density.
• Advantages: Memory efficiency for high-resolution shapes, differentiable, and naturally represent watertight surfaces.
• Core Operation: A network takes a 3D coordinate as input and outputs a scalar value (distance, occupancy probability).

An explicit, discrete volumetric representation where space is divided into a regular 3D grid of cubes called voxels. Each voxel stores attributes like occupancy, density, or color. This contrasts with the continuous, implicit nature of an SDF.

• Structure: Analogous to a 3D pixel (pixel + volume = voxel).
• Trade-offs: Simple to index and process but suffers from the "curse of dimensionality"—memory grows cubically with resolution.
• Hybrid Approaches: Often used as an initial coarse representation or an acceleration structure for querying neural implicit functions like SDFs.

The process of creating a continuous surface model (typically a triangle mesh) from discrete 3D data, such as a point cloud or the zero-level set of an SDF. It is the final step in converting an implicit SDF into a usable, explicit asset.

• Marching Cubes: The canonical algorithm for extracting a mesh from a scalar field (like an SDF) by "marching" through a grid and constructing triangles based on values at grid vertices.
• Dual Contouring: An alternative method that can produce sharper features by placing vertices inside grid cells.
• Pipeline: SDF inference → Marching Cubes/Contouring → Mesh simplification and cleanup.

A framework that allows gradients to flow from rendered 2D images back to 3D scene parameters (like SDF values or vertex positions). This is the enabling technology for optimizing neural SDFs from multi-view images without 3D supervision.

• Core Idea: Makes the rendering pipeline a differentiable function.
• Application to SDFs: Enables the use of 2D image loss (e.g., photometric, silhouette) to train a neural network to predict a correct SDF.
• Key Technique: Uses a differentiable approximation of visibility and surface normal calculation derived from the SDF gradient.

A specific type of implicit neural representation where the network predicts a binary occupancy probability (inside/outside) for a queried 3D point, rather than a signed distance. The surface is defined at the 0.5 decision boundary.

• Comparison to SDF: Less precise geometric information than a distance value, but sufficient for many tasks. Often easier to learn from data.
• Output: A value between 0 and 1, interpreted as the probability the point is inside the object.
• Use Case: Common in 3D reconstruction and shape completion from partial data (e.g., single images).