Standard signed-distance-field (SDF) surface representation, combined with marching cubes for explicit-mesh extraction, has two error sources. Fitting error — the neural-network SDF estimate is imperfect. Interpolation error — marching cubes linearly interpolates between grid-corner SDF values to estimate the zero-crossing, which is inaccurate when the underlying surface is non-linear. For watertight closed surfaces at high resolution both errors are small. For open surfaces (garments, leaves, single-sided geometry) and for complex internal structures (hollow objects, multi-layer hexplane-style surfaces) the interpolation error dominates and reconstruction quality collapses.
The UODF paper [1] sidesteps the interpolation error entirely by changing what is stored. Instead of storing the minimum distance to the surface in any direction (which requires gradient-based zero-crossing localisation), it stores three separate axis-aligned distances. Each per-voxel value names the actual surface intersection along its axis directly. No interpolation needed.
This paper does two things. First, it summarises the UODF construction and the empirical gains (§2). Second, it points out that the axis-aligned principle UODF formalises is implicitly the principle used by two thesis-line topics — Six-Plane Mesh [2] and Hexplane AE [3] — and that UODF provides the theoretical justification for why those representations admit clean surface extraction (§3). The architectural implication for future thesis-line work is in §4.
Three axis-aligned unsigned distance fields, each a 3-D scalar field. Given a surface S ⊂ ℝ³ and a query point p ∈ ℝ³:
UODF_LR(p) = min { |t| : p + t · e_x ∈ S, t ∈ ℝ } UODF_FB(p) = min { |t| : p + t · e_y ∈ S, t ∈ ℝ } UODF_UD(p) = min { |t| : p + t · e_z ∈ S, t ∈ ℝ }where e_x, e_y, e_z are the standard axis unit vectors. Each field's value at p is the minimum unsigned distance along its axis to the nearest surface point. Contrast with SDF, which stores min { ‖p − q‖ : q ∈ S } — the minimum distance in any direction with a sign indicating inside / outside.
| Field | Stores | Query semantics |
|---|---|---|
| UODF_LR (X-axis) | Distance to nearest surface along ±X from each grid voxel | "How far to the surface if I shoot a ray along X?" |
| UODF_FB (Y-axis) | Distance along ±Y | Same, Y |
| UODF_UD (Z-axis) | Distance along ±Z | Same, Z |
For each grid voxel p, three candidate surface points are named directly:
q_x = p ± UODF_LR(p) · e_x q_y = p ± UODF_FB(p) · e_y q_z = p ± UODF_UD(p) · e_zThe union of candidate points across all grid voxels is the reconstructed surface. No marching-cubes interpolation. The interpolation error term that dominates SDF-based extraction on open surfaces is structurally absent.
A single axis-aligned ray can hit the surface multiple times — a ray through a hollow sphere hits four times (enter outer, exit outer, enter inner, exit inner). The naive single-depth UODF representation cannot encode this. The paper's representation: per-axis per-pixel, store a 1-D function of distance along the axis rather than a single distance value. The function is encoded via a small neural-network MLP whose input is the axis-parameter t and whose output is the signed-occupancy at p + t · e_axis.
Reported empirical gains [1]: 20–100× quality improvement over SDF on open surfaces (the regime where interpolation error dominates). The triplane variant — store the three UODFs as 2-D feature planes per axis with per-pixel 1-D distance functions — runs at 30–80 M points/second on consumer GPUs, against ~0.3–1 M/s for SDF + marching cubes. The speed-up factor of ~100× combined with the quality-up factor of ~20–100× makes UODF a strict Pareto-improvement over SDF in the open-surface regime; for closed watertight surfaces at high grid resolution SDF + marching cubes is still competitive on quality.
The thesis line's Six-Plane Mesh work [2] and Hexplane Autoencoder work [3] both use six axis-aligned 2-D representations of a 3-D mesh: six depth maps (Six-Plane Mesh) or six occupancy / continuous-feature planes (Hexplane AE). The "six" is "three axes × two signs" — the same axis-aligned principle UODF uses, generalised from per-axis 1-D distance functions to per-axis 2-D feature planes.
The thesis-line work used this representation for empirical reasons (six planes are sufficient to fully cover a 3-D mesh's axis-aligned projections; the storage is compact; the per-plane work composes with CNN-class architectures). UODF gives the theoretical reason: the per-plane representation is interpolation-free at extraction time because each plane already encodes axis-aligned surface intersections. This is why the Six-Plane Mesh work's extraction step is stable and the Hexplane AE work's reconstruction step (after the binary-to-continuous fix) is stable.
UODF and the thesis-line representations differ in what they store per axis. UODF stores 1-D unsigned distance functions; Six-Plane Mesh stores 2-D depth maps; Hexplane AE stores 2-D continuous feature planes. The information content is similar (each names axis-aligned surface positions), but the storage format and the downstream consumer differ.
The thesis line's commitment to axis-aligned per-direction representations — six-plane orthographic for mesh extraction, hexplane for continuous-feature autoencoders, triplane for the universal intermediate [4] — is theoretically justified by the UODF analysis. The justification: per-axis representations admit interpolation-free surface extraction because each axis directly encodes its own surface intersections. The implication for future thesis-line work: when a new 3-D representation is needed, prefer axis-aligned over rotationally-symmetric (SDF, voxel occupancy) representations, especially for open-surface or thin-feature geometry where interpolation error dominates.
Two honest caveats. (i) Multiple intersections. A single axis-aligned ray can hit the surface multiple times (a ray through a hollow sphere hits four times: enter outer, exit outer, enter inner, exit inner). UODF stores per-axis a 1-D distance function, not a single depth — naive single-depth axis-aligned storage cannot represent multiple intersections. Implementation work goes into the per-axis 1-D function representation. (ii) Non-axis-aligned features. The interpolation-free claim holds for surfaces approximately axis-aligned at the relevant scale. For features that are perfectly oblique to all three axes (a diagonal plane in 3-D), each axis-aligned ray's surface intersection is still well-defined but the resulting per-axis sampling can miss thin oblique features at coarse grid resolution.
UODF formalises an axis-aligned per-direction principle that gives interpolation-free surface extraction. The thesis-line Six-Plane Mesh and Hexplane Autoencoder work uses the same principle implicitly; UODF provides the theoretical justification. The implication for future work: prefer axis-aligned representations for open-surface and thin-feature geometry.