有符号距离函数

A signed distance function, usually shortened to SDF, is a rule that takes any point in space and returns one number: how far that point is from the nearest surface of a shape. The sign carries extra information. By the most common convention, used in the DeepSDF paper, points inside the shape get negative values and points outside get positive values. The surface itself is the set of points where the function equals zero, called the zero level set. A sphere of radius r centered at the origin is the simplest example: its SDF is the length of the point's position vector minus r. A point 3 units from the center of a sphere of radius 1 has a value of 2, and the center has a value of -1. Because the description is a function rather than a list of triangles, it is called an implicit representation of the surface.

An SDF can come from three places. It can be written as a formula, as shader programmers do for spheres, boxes, capsules and tori. It can be stored as samples on a 3D grid of voxels, small cubes of space, with values between grid points interpolated. Or it can be learned by a neural network that takes a 3D coordinate as input and outputs the distance. In every case the same two operations matter: evaluating the distance at a point, and finding where the value crosses zero.

Rendering an SDF directly uses a technique called sphere tracing, described by John C. Hart in The Visual Computer in 1996. A ray leaves the camera. At each step the renderer evaluates the SDF at the current point. That value is the radius of a sphere guaranteed to contain no surface, so the ray can safely jump forward by exactly that much. Steps are long in empty space and shrink as the ray approaches a surface, and the loop stops when the value falls below a small threshold. The guarantee holds when the function never overstates the true distance, a property the paper ties to the Lipschitz condition, which limits how fast the function can change. The gradient of the SDF at the hit point gives the surface normal for lighting.

Combining shapes is where SDFs become a modeling tool. Given two SDFs a and b, the union of the shapes is min(a, b), the intersection is max(a, b), and subtracting a from b is max(-a, b). Smooth versions replace min and max with blended functions controlled by a radius k, producing organic joins without seams. Inigo Quilez's widely used reference of distance functions makes an important distinction: basic primitives such as the sphere and box are exact, while subtraction, intersection, smooth blends and non-uniform scaling produce bounds, values that are never larger than the true distance but may be smaller. Bounds still render correctly with sphere tracing but need more steps, and they can break effects that rely on true distances, such as soft shadows.

SDFs also became the standard way to merge real scans. In 1996 Brian Curless and Marc Levoy presented a volumetric method at SIGGRAPH that adds each range image into a cumulative weighted signed distance function stored on a grid, then extracts the zero isosurface. They showed the result is least-squares optimal under certain assumptions, integrated up to 70 range images, and produced models of about 2.6 million triangles. The DeepSDF authors credit that work and KinectFusion (Newcombe and colleagues, 2011) as the pioneers of truncated SDF fusion, in which distances are stored only near the surface. KinectFusion applied the idea in real time with a moving Kinect depth camera.

Neural SDFs arrived in 2019. DeepSDF, from researchers at the University of Washington, MIT and Facebook Reality Labs, trained an eight-layer fully connected network with 512-unit layers to output the SDF of a shape given a 3D point and a latent code, a short vector identifying which shape. Training samples 500,000 points per ShapeNet mesh, concentrated near the surface, and clamps distances to 0.1 so capacity is spent near the surface. One network represented an entire shape category in 7.4 MB, and the paper reports state-of-the-art shape reconstruction and completion from partial, noisy scans. In 2020 Implicit Geometric Regularization (IGR) showed that a network could be fit to raw point clouds with a loss that makes the function vanish on the points and keeps its gradient at unit length. In 2021 NeuS learned SDFs from photographs by deriving a volume-rendering formulation that is unbiased to first order at the surface, and reported better Chamfer distance than IDR and NeRF on the DTU benchmark.

Compared with the alternatives, SDFs trade explicitness for convenience. Triangle meshes are what graphics hardware draws fastest, but they make topology changes and inside-outside queries awkward. Occupancy fields store only inside or outside, which loses the distance information that sphere tracing and collision tests use. Point clouds have no surface at all. Density fields such as the original NeRF render well, but the NeuS authors note that extracting high-quality surfaces from them is difficult because the representation has too few surface constraints. An SDF gives a well-defined surface, cheap inside tests, smooth normals from the gradient, and arbitrary topology, and a mesh can always be extracted with Marching Cubes when one is needed.

The limitations are concrete. A sign requires a closed shape; the DeepSDF authors note that human-made meshes are often not watertight and contain internal structures that must be cleaned before distances can be computed. Grid SDFs grow with the cube of resolution, which is why fusion systems truncate them. Neural SDFs are limited by the number of sample points and the network's capacity, and they must be evaluated many times per ray. Learned functions are not guaranteed to be true distances everywhere, which is why IGR and NeuS add an Eikonal term that pushes the gradient length toward one. Optimization can also be slow: NeuS trained each scene for 300,000 iterations, about 14 to 16 hours on a single NVIDIA RTX 2080 Ti GPU.

In practice the cost depends on the representation. Analytic SDFs cost almost nothing to store and run in real time in a fragment shader. Voxel SDFs need memory proportional to the grid size but allow constant-time lookups. Neural SDFs compress shapes well, as DeepSDF's 7.4 MB category model shows, but each query is a full network evaluation, so rendering and mesh extraction need a GPU and careful sampling.