Differentiable Rendering Techniques

• Differentiable rendering techniques are frameworks that compute gradients of rendering outputs with respect to scene parameters, enabling inverse graphics and efficient 3D reconstruction.
• Recent advances leverage neural implicit representations such as Signed Directional Distance Functions to model complex geometries with analytical guarantees and learn from partial depth data.
• Practical applications include shape inference and category-level modeling using depth or Lidar inputs, though challenges remain for complex topologies and infinite-distance predictions.

Differentiable rendering techniques are computational frameworks that enable the calculation of gradients of rendering outputs with respect to scene parameters, facilitating inverse graphics tasks such as 3D reconstruction, shape inference, and optimization of object representations using only indirect supervision such as depth or occupancy maps. Recent advances include the development of neural, implicit representations capable of synthesizing novel views, predicting distance measurements, and reconstructing object surfaces in a continuous and differentiable manner. One significant approach deploys deep networks to represent Signed Directional Distance Functions (SDDFs), enabling geometry-aware modeling, efficient learning from partial information, and precise analytical guarantees (Zobeidi et al., 2021).

1. Mathematical Foundations

Differentiable rendering utilizes mathematical models that support the computation of derivatives through the rendering process. Central to high-fidelity 3D object representation is the Signed Distance Function (SDF), mapping a point in $\mathbb{R}^3$ to the closest distance (with sign) to a surface. The SDDF generalizes the SDF by associating with each spatial point $p\in\mathbb{R}^3$ and unit direction $d\in S^2$ a signed distance along $d$ to the boundary $\partial O$ of a closed object $O$:

$h(p, d) := d_{(d)}(p, \partial O)$

where $$d_{(d)}(p, \partial O) = \min\{ t \in \mathbb{R} \mid p + t\,d \in \partial O \}$$. For the special case $d = e_3 = (0,0,1)$, $h(p,e_3)$ represents the signed distance along the $+Z$ axis and defines the Z-monotonic SDF $f_Z(x) := h(x, (0,0,1))$ (Zobeidi et al., 2021).

2. The Directional Eikonal Constraint

A critical geometric constraint in SDDF models is the directional Eikonal constraint, which enforces monotonicity along the direction of interest. For valid SDDFs, this states:

$\frac{\partial}{\partial t} h(p + t\,d, d) = -1$

for all $p, d, t$ such that the ray $p + t\,d$ hits the same surface point. In differential form,

$\nabla_p h(p, d)^\top d = -1$

For the Z-monotonic case, this reduces to the constraint $\frac{\partial h}{\partial z}(p, e_3) = -1$, ensuring linear decrease of the SDDF along $+Z$.

3. Neural Network Architecture and Encoding

Network architectures for learning SDDFs must, by construction, enforce the directional Eikonal constraint. The approach defines $g(p, d) := h(p, d) + p^\top d$ such that $\nabla_p g(p, d)^\top d = 0$. Generally, $(p, d)$ is rotated so $d$ aligns with the canonical axis, and the last coordinate of $p$ is ignored, forming $g(p, d) = F(P R_d p, d)$ with learnable $F$. In the Z-monotonic case, $R_d$ is the identity, $P$ projects $(x, y, z) \rightarrow (x, y)$, and input to the MLP network comprises $[x', y', \mathrm{encode}(d), z]$ for optional latent code $z$. The network outputs $q(p,d,z)$, which is related to the SDDF through a strictly-monotonic squashing function $\varphi$ (e.g. $\sigma, \tanh, \mathrm{erf}$):

$h(p, e_3) = \varphi^{-1}(q(p, e_3)) - z$

This network enforces the desired structure by design, rather than relying solely on data-driven learning (Zobeidi et al., 2021).

4. Training and Loss Function

SDDF models are trained using distance measurements from depth or Lidar sensors. Data is collected as triplets $(p, d, d_\text{true})$ and split into finite (F) and infinite (I) distance sets. The chosen loss (Eq. 10 in (Zobeidi et al., 2021)) for parameters $\Theta, \alpha, \beta, \gamma, p$ is: \begin{align*} \ell(\Theta; F, I) =\ &\alpha |F|^{-1} \sum_{(p,d,d_\text{true}) \in F} |\varphi(d_\text{true} + p^\top d) - q_\Theta(p,d)|^p \ &+ \beta |I|^{-1} \sum_{(p,d,\infty)\in I} r\big(\varphi(\infty) - q_\Theta(p,d)\big)^p \ &+ \gamma |\Theta|^p \end{align*} where $r(\cdot)$ is $\max(0, \cdot)$ or softplus. For category-level learning, an additional regularizer $\sigma \|z_l\|^p$ is applied to the latent codes. Only depth supervision is required; no RGB or mesh ground truth is needed.

5. Analytical Guarantees

The model yields analytical guarantees via its structural constraints:

• The directional Eikonal property is satisfied exactly by construction (Lemma 1, Eq. 2 in (Zobeidi et al., 2021)).
• Squashing with any strictly-monotonic function $\varphi$ preserves the required property (Lemma 4).
• Proposition 1 affirms that the reconstructed $h$ is a valid SDDF, ensuring linear decrease along direction $d$ with constant gradient.
• Prediction error is independent of distance to the surface, making dense sampling near the surface unnecessary and affording confidence in distant predictions.

6. Implementation: Training and Inference

The Z-monotonic SDDF can be implemented with the following algorithmic sketch.

Algorithm 1: Training

• Input: Training sets $F = \{ (p_i, (0,0,1), d_i) \}_i$, $I = \{ (p_j, (0,0,1), \infty) \}_j$
• Initialization: Network parameters $\Theta$ (and latent codes $z$ for category-level)
• Repeat until convergence:
  • Sample minibatch $F_b \subset F$, $I_b \subset I$
  • Compute $q_i = q_\Theta(p_i, (0,0,1), z)$ for $(p_i, d_i) \in F_b \cup I_b$
  • Compute $$\ell_f = |F_b|^{-1} \sum | \varphi(d_i + p_i.z) - q_i |^p$$
  • Compute $$\ell_\infty = |I_b|^{-1} \sum r( \varphi(\infty) - q_j )^p$$
  • Regularizer $\ell_\text{reg} = \gamma\|\Theta\|^p$ (plus $\sigma\|z\|^p$ when needed)
  • Loss $$\ell = \alpha \ell_f + \beta \ell_\infty + \ell_\text{reg}$$
  • Update $\Theta \leftarrow \Theta - \eta \nabla_\Theta \ell$ ($z \leftarrow z - \eta_z \nabla_z \ell$ for category-level)

Algorithm 2: Inference and Surface Extraction

• Given trained $\Theta$, and test $z$,
  • To query SDF at $x = (x, y, z)$:
  • $q = q_\Theta([x, y, z], (0,0,1), z)$
  • $h = \varphi^{-1}(\min(q, \varphi(\infty))) - z$
  • For mesh extraction:
  • Evaluate $h$ on a 3D grid
  • Run Marching Cubes on grid of $h$ values to extract the surface mesh

7. Applications, Limitations, and Considerations

Differentiable rendering techniques based on SDDFs efficiently learn from partial, unstructured measurements, offering a direct connection to sensor modalities such as depth cameras or Lidar. These paradigms enable representation and generalization of entire shape categories, surface interpolation from incomplete data, and obviate mesh-based supervision or explicit geometry at training time. However, the Z-monotonic SDF only captures distances along the $+Z$ axis; for objects with complex topology (e.g., overhangs), some ray queries may yield infinite distance. Valid training requires rays with both finite and infinite intersections, and only depth data is supported (no RGB cues). Extraction with Marching Cubes inherits resolution and smoothness tradeoffs. The use of a scalar squashing $\varphi$ and infinite-distance caps introduces slight bias near $\infty$, necessitating careful selection (e.g., $\mathrm{erf}$ or $\tanh$). For category-level models, code optimization at test time requires suitable initialization.