Marching Cubes SDF to Mesh

1. Background Knowledge

A signed distance field (SDF) is a scalar function $f: \mathbb{R}^3 \to \mathbb{R}$ where each point stores the (signed) distance to the nearest surface: negative values are inside, positive are outside, and the zero level set $f(x)=0$ represents the surface you want to reconstruct. In discrete form, you have a 3D grid (voxel volume) of SDF samples $f(i,j,k)$. The surface will generally cut through the cells between these grid points, not pass exactly through them.

The Marching Cubes algorithm is a classic method to extract a triangle mesh approximating an isosurface (here, the zero level set) from a scalar field. Each cube is formed by 8 neighboring grid samples (at the corners). By checking which corners are inside (negative) and which are outside (positive), you can determine how the isosurface intersects that cube. A precomputed lookup table maps each of the 256 possible inside/outside patterns to a set of edges that the surface intersects and to the triangles formed between those intersection points.

Conceptually, Marching Cubes does local interpolation: for each cube edge whose endpoints have opposite signs, the surface crosses that edge. The intersection position is found via linear interpolation between the two SDF values. Connecting these interpolated edge points according to the lookup table yields a set of triangles per cube; collecting them over all cubes yields the full mesh.

2. Algorithm / General Approach

At a high level, the approach is:

• Treat the SDF grid as a 3D array of samples.
• For each voxel cell (cube) between samples:
• Classify its 8 corners as inside/outside relative to the isovalue (0).
• Form an 8-bit cube index from these classifications.
• Use the cube index to:
• Look up which edges are intersected.
• For each intersected edge, compute the exact intersection via interpolation.
• Look up which triangles to emit using those edge points.
• Aggregate all triangle vertices (and optionally deduplicate / index them) into a mesh.

This is a local, data-parallel algorithm: each cube can be processed independently, which is why it’s used widely in graphics and 3D reconstruction.

3. Step-by-Step Strategy

4. Define grid and indexing

• Assume SDF values stored in sdf[z][y][x] (or similar).
• A cube at integer index $(x, y, z)$ has 8 corners at:
• $(x,y,z), (x+1,y,z), (x+1,y+1,z), (x,y+1,z)$
• $(x,y,z+1), (x+1,y,z+1), (x+1,y+1,z+1), (x,y+1,z+1)$
• Also know the world-space position of each grid point: e.g. p = origin + spacing * (x,y,z).

2. Loop over cubes

for z in range(nz-1):
for y in range(ny-1):
for x in range(nx-1):
process_cube(x, y, z)

3. Compute cube index (inside/outside pattern)

• Sample the 8 corner SDF values v[0..7].
• Initialize cubeIndex = 0.
• For each corner i:
• If v[i] < 0 (inside for isovalue 0), set bit i in cubeIndex.
• Now cubeIndex is in [0, 255].

4. Early out for trivial cases

• If cubeIndex == 0 or cubeIndex == 255, the surface does not pass through the cube (all outside or all inside) → skip.