#  Neural Implicit Surface Evolution using Differential Equations

Tiago Novello
IMPA  Vinicius da Silva
PUC-Rio  Guilherme Schardong
U Coimbra  Luiz Schirmer
U Coimbra  Helio Lopes
PUC-Rio  Luiz Velho
IMPA

###### Abstract

This work investigates the use of smooth neural networks for modeling dynamic
variations of implicit surfaces under partial differential equations (PDE).
For this purpose, it extends the representation of neural implicit surfaces to
the space-time $\mathbb{R}^{3}\times\mathbb{R}$, which opens up mechanisms for
continuous geometric transformations. Examples include evolving an initial
condition surface towards general vector fields, smoothing and sharpening
using the mean curvature equation, and interpolations of initial conditions
regularized by specific differential equations.

The network training considers two constraints. A data term is responsible for
fitting the PDE’s initial condition to the corresponding time instant, usually
$\mathbb{R}^{3}\times\\{0\\}$. Then, a PDE term forces the network to
approximate a solution of the underlying equation, without any supervision.
The network can also be initialized based on previously trained initial
conditions resulting in faster convergence when compared with the standard
approach.

##  1 Introduction

A smooth neural implicit function, $g:\mathbb{R}^{3}\to\mathbb{R}$, is a
neural network capable of representing smooth implicit functions. Since $g$ is
smooth, objects from the differential geometry of its regular level sets can
be used in closed form, for instance, during the training of its parameters
[29, 21].

In this work, we investigate the extension of the domain of neural implicit
functions from $\mathbb{R}^{3}$ to the space-time
$\mathbb{R}^{3}\times\mathbb{R}$. In this context, a single neural network
$f:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ encodes the animation of an
implicit surface $S\subset\mathbb{R}^{3}$. For each
$t_{1},t_{2}\in\mathbb{R}$, the function $f$ represents an homotopy between
the neural implicit functions $f_{t_{1}}:=f(\cdot,t_{1})$ and $f_{t_{2}}$. In
other words, a homotopy is a continuous deformation between functions. Notice
that the zero-level sets $S_{t}$ of $f_{t}$ produce an animation of $S$.

We consider the (neural) homotopy $f$ to be an approximation of a solution of
a given partial differential equation (PDE). This equation encodes the
animation model to be learned by the network. Therefore, we can add an initial
condition, $f_{0}=g$ on $\mathbb{R}^{3}\times\\{0\\}$, to the PDE problem. If
$g$ is the signed distance function (SDF) of $S$, a solution $f$ of the
resulting problem encodes an animation of $S$.

Two ingredients are used in the training of the neural homotopy $f$. First, a
sample $\\{p_{i},g(p_{i})\\}$ of the SDF $g$ enables us to train the initial
condition, $f_{0}=g$ on $\mathbb{R}^{3}\times\\{0\\}$. Second, a PDE
constraint is used to fit $f$ into a solution of the PDE in
$\mathbb{R}^{3}\times\mathbb{R}$. This constraint does not need any
supervision at the training, i.e. it does not consider samples of $f$. The
constraint only uses samples in the form
$\\{(p_{i},t_{i})\\}\subset\mathbb{R}^{3}\times\mathbb{R}$. The only
requirements of our method are that $f$ must be smooth and must be represented
by a network. The main contributions of this work can be summarized as
follows:

  * •

The extension of neural implicit surfaces to the space-time without the use of
numerical or discrete approximations (Section 5);

  * •

The development of a machine learning framework to approximate solutions of
geometric differential equations using only their analytical expression
(Section 4);

  * •

The resulting shape transformation workflow is flexible enough to be used in a
variety of applications, such as surface motion driven by vector fields,
smoothing, sharpening, and interpolation (Section 6);

  * •

The framework supports a neural network initialization based on previously
trained initial conditions on the form $g:\mathbb{R}^{3}\to\mathbb{R}$
(Section 4.4).

The research topics related to our work include the evolution and
interpolation of implicit surfaces; level set methods; implicit surface
representations using neural networks; differential geometry; PDEs and
physics-based methods.

##  2 Related Works

Deforming surfaces under a given rule has been an active area of research in
computer graphics since the 1990’s [13]. Many problems in this area, such as
shape correspondence and topology changes, can be elegantly solved using
implicit surfaces [26, 2]. Additionally, animation of deformable and soft
objects can be effectively posed in the context of implicit representations
[3, 11, 10].

The study of shape properties through differential geometry leads to a
mathematical framework for intrinsic operations on surfaces. In this setting,
it is possible to define operators that change the shape in meaningful ways.
An example is smoothing a surface using the mean curvature flow [4]. However,
most of the research in geometry processing is in discrete parametric
representations, such as polygonal meshes [5, 8, 9]. A practical neural
implicit approach for this task is the aim of this work.

Particularly, modeling shapes as level sets of neural networks (neural
implicits) has recently been demonstrated to be an effective geometric surface
representation [23, 20, 14, 25]. Important properties of those networks
include compactness and smoothness. They allow us to compute classical
differentiable objects (gradient and curvatures) in closed forms, without any
discretization [21]. Moreover, we can compute them in real-time for
visualizations [7].

Most of the works in neural implicits perform overfitting, where data is
fitted into a network by solving a problem similar to a regression. In the SDF
case, a regularizer term forces the underlying network $f_{\theta}$ to satisfy
the Eikonal equation $\left\lVert\nabla f_{\theta}\right\rVert=1$. The
robustness of those approaches is our motivation to study neural implicit
evolution using PDEs. We still overfit the function at the initial conditions
using a (data) constraint, which we denote by $\mathcal{L}_{\text{data}}$.
However, no supervision is needed in the intermediate times. Training the
evolution of the initial condition by a PDE $\mathcal{F}=0$ is performed by
defining a (PDE) constraint $\mathcal{L}_{\text{PDE}}$. The resulting trained
networks have the essential property of being smooth approximations of PDE
solutions.

Recall that numerical solutions of PDEs using traditional methods are
discrete. Moreover, adding several initial conditions is non-trivial in
numerical formulations, while it will be quite simple in our neural implicit
approach.

Recently, Mehta et al [19] approached the problem of evolving level sets using
explicit flows (NIE). Given a time step $\Delta t$ and a trained network
$g:\mathbb{R}^{3}\to\mathbb{R}$, NIE considers a finite difference approach
(in the time derivative) to approximate a (discrete) solution (the next state)
of the mean curvature equation. Moreover, a discrete Laplacian approximates
the Laplacian (used in the mean curvature equation) at the vertices of a mesh
approximating the zero-level set of $g$. Therefore, NIE approximates the
solution of the mean curvature equation at discrete instants $\\{i\Delta t\\}$
and for each $i$ it creates a new network with domain in $\mathbb{R}^{3}$. In
contrast, our approach learns the solution in a continuous interval of time
using a single network with a domain in $\mathbb{R}^{3}\times\mathbb{R}$.
Moreover, NIE cannot consider multiple initial conditions and does not use the
available high-order derivatives of $g$ as our method.

Recently, Yang et al [29] approached the use of neural implicit functions in
geometry processing (NFGP). NFGP evolves the parameters $\theta$ of a trained
network $g_{\theta}:\mathbb{R}^{3}\to\mathbb{R}$ such that the zero-level set
of the resulting network $g_{\phi}$ smooths (or sharpens) the zero-level set
of $g_{\theta}$. The training considers the optimization of
$(\kappa_{\phi}-\beta\kappa_{\theta})^{2}$ in a specific region of the domain,
where $\kappa_{\phi}$ is the mean curvature of the level sets of $g_{\phi}$
and $\kappa_{\theta}$ is the curvature of $g_{\theta}$. Then, considering
$\beta<1$ ($\beta>1$) the training would force a smoothing (sharpening) of the
initial surface. However, NFGP trains a neural network $g_{\phi}$ for each
parameter $\beta$, thus, it cannot represent a continuous evolution controlled
by $\beta$. In contrast, our framework directly evolves over time with a
smooth function represented by a single neural network. Moreover, asking for
$(g_{\phi}-{g_{\theta}})^{2}$ and $(\kappa_{\phi}-\beta\kappa_{\theta})^{2}$
could be problematic, since the level sets would try evolve but
$(g_{\phi}-g_{\theta})^{2}$ forces it to be constant (see Sec 6.2.2).

Regarding the interpolation problem, Liu et al. [16] propose the Lipschitz
MLP, a regularization designed to encourage smooth latent spaces of a neural
network $f_{\theta}$ by penalizing the upper bound of its Lipschitz constant.
The training of $f_{\theta}$ to interpolate shape functions consists of using
the constraint $\mathcal{L}_{\text{data}}$ with an additional term that forces
the Lipschitz constant of $f_{\theta}$ to be zero. Due to the high
representation capacity of sinusoidal MLPs, our technique needs a smaller
architecture. We also use a specific PDE to interpolate SDFs which results in
smoother and more natural transitions between shapes (see Sec 6.3).

##  3 Background and conceptualization

#### Implicit surfaces

The zero-level set $g^{-1}(0)$ of a function $g:\mathbb{R}^{3}\to\mathbb{R}$
can be used to represent a surface $S$ in $\mathbb{R}^{3}$. If $g$ is smooth
and has zero as a regular value ($\nabla g\neq 0$ in $g^{-1}(0)$), then
$g^{-1}(0)$ is a regular surface. Conversely, given a regular surface $S$ in
$\mathbb{R}^{3}$, there is a function $g:\mathbb{R}^{3}\to\mathbb{R}$ having
$S$ as its zero-level set, i.e. $g^{-1}(0)=S$. Therefore, given a sample of
points on the surface $S$, we can construct the implicit function $g$, which
this paper considers being a neural network.

We say that the implicit function $g$ is neural if it is modeled by a neural
network. We call the level set $g^{-1}(0)$ a neural implicit surface. SIREN
[25] and IGR [14] are examples of networks capable of representing smooth
functions.

Let $S$ be a surface in $\mathbb{R}^{3}$, and $g:\mathbb{R}^{3}\to\mathbb{R}$
be a neural network. To compute the parameters of $g$ such that $g^{-1}(0)$
approximates $S$, it is common to define a loss functional based on the
Eikonal problem:

$\displaystyle\begin{cases}\left\lVert\nabla g\right\rVert=1&\text{ in
}\mathbb{R}^{3},\\\ g=0&\text{ on }S.\end{cases}$ (1)

The equation $\left\lVert\nabla g\right\rVert=1$ asks for $g$ to be a SDF. The
Dirichlet condition, $g=0$ on $S$, requires $g$ to be the SDF of a set
containing $S$. These two constraints imply the Neumann condition,
$\frac{\partial g}{\partial N}=\big{\langle}\nabla g,N\big{\rangle}=1$ on $S$,
which forces $\nabla g$ to be aligned with the normals $N$ of $S$.

We are interested in using neural networks to model animations of the initial
implicit surface $S$. The level sets $g^{-1}(c)$, with $c\in
g(\mathbb{R}^{3})$, of the neural implicit function $g$ could be used to
animate $S\approx g^{-1}(0)$. However, this does not allow intersections
between surfaces at different time instants, because the level sets of $g$ are
disjoint. To avoid this, we extend the domain of the neural implicit function,
from $\mathbb{R}^{3}$ to $\mathbb{R}^{3}\times\mathbb{R}$, to control
animations using time.

#### Neural homotopies and PDEs

Let $f:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ be a smooth network
representing an one-parameter family of networks
$f_{t}:\mathbb{R}^{3}\to\mathbb{R}$ defined by $f_{t}(p)=f(p,t)$. The family
$f_{t}$ represents homotopies between any two functions
$f_{t_{0}},\,f_{t_{1}}:\mathbb{R}^{3}\to\mathbb{R}$, with
${t_{0}},{t_{1}}\in\mathbb{R}$. Thus, we say that $f$ is a neural homotopy.
The family of neural implicit surfaces $S_{t}:=f_{t}^{-1}(0)$ animates the
initial surface $S_{0}=S$. Restricted to the interval $[t_{0},t_{1}]$, the
surfaces $S_{t}$ correspond to a deformation between $S_{t_{0}}$ and
$S_{t_{1}}$. Observe that these surfaces can contain singularities as their
topologies may change over time $t$. Hart [15] has studied this phenomenon
using Morse Theory.

In the same sense that we considered a neural implicit function as a solution
of the Eikonal problem (Eq (1)), we assume that the neural homotopy
$f:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ is a solution of a general
partial differential equation (PDE)
$\mathcal{F}\big{(}\nabla^{n}f,\dots,\nabla^{1}f,f,p,t\big{)}=0,$ where
$\nabla^{k}f$ denotes the derivative of order $k$ of $f$. Initial conditions
could also be used. Section 5 presents examples of PDEs in the context of
implicit surface evolution.

The time $t$ allows a continuous navigation in the neural animation
$S_{t}=f_{t}^{-1}(0)$. Each instant $t$ also represents a transformation
$S_{0}\to S_{t}$ of the initial implicit surface $S_{0}$.

##  4 Method

Let $g_{i}$ be $n$ implicit functions, and
$f_{\theta}:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ be a neural homotopy.
This section defines a loss function to estimate the parameters $\theta$ such
that the resulting network $f_{\theta}$ approximates a solution of a given PDE
problem satisfying the conditions $(f_{\theta})_{t_{i}}=g_{i}$ on
$\mathbb{R}^{3}\times\\{t_{i}\\}$.

We train the parameters $\theta$ by forcing $f_{\theta}$ to approximate a
solution of a PDE problem:

$\displaystyle\begin{cases}\displaystyle\mathcal{F}\big{(}\nabla^{n}f_{\theta},\dots,\nabla^{1}f_{\theta},f_{\theta},p,t\big{)}=0&\text{
in }\mathbb{R}^{3}\\!\\!\times\\!\\!(a,b),\\\ f_{\theta}=g_{i}&\text{ on
}\mathbb{R}^{3}\\!\\!\times\\!\\!\\{t_{i}\\}.\end{cases}$ (2)

$\mathcal{F}$ is a smooth function depending on the derivatives of
$f_{\theta}$. The untrained network $f_{\theta}$ encodes the phenomenon ruled
by $\mathcal{F}$. The interval $(a,b)$ can be used to control the neural
animation $S_{t}=(f_{\theta})_{t}^{-1}(0)$. The implicit functions $g_{i}$ are
the PDE conditions at the times $t_{i}\in(a,b)$.

###  4.1 Loss functional

We use Equation (2) to define a loss function to train $f_{\theta}$.

$\displaystyle\mathcal{L}(\theta)=\underbrace{\int\limits_{\mathbb{R}^{3}\times(a,b)}\\!\\!\\!\big{|}\mathcal{F}\big{|}dpdt}_{\mathcal{L}_{\text{PDE}}}+\underbrace{\sum_{i=1}^{n}\int\limits_{\mathbb{R}^{3}\times\\{t_{i}\\}}\\!\\!\\!\big{|}f_{\theta}-g_{i}\big{|}dp}_{\mathcal{L}_{\text{data}}}.$
(3)

The PDE constraint ${\mathcal{L}_{\text{PDE}}}$ forces the network
$f_{\theta}$ to satisfy
$\mathcal{F}\big{(}\nabla^{n}f_{\theta},\dots,\nabla^{1}f_{\theta},f_{\theta},p,t\big{)}=0.$
This constraint works like a regularization of $f_{\theta}$ requiring it to
obey the phenomenon ruled by $\mathcal{F}$. The data constraint
$\mathcal{L}_{\text{data}}$ asks for $f_{\theta}$ to satisfies
$f_{\theta}=g_{i}$ on $\mathbb{R}^{3}\times\\{t_{i}\\}$.

###  4.2 Sampling

To approximate a solution $f_{\theta}$ of Eq (2) we seek a minimum $\theta$ of
the loss function $\mathcal{L}$ using the stochastic gradient descent. For
this, we enforce
$\mathcal{L}={\mathcal{L}_{\text{PDE}}}+\mathcal{L}_{\text{data}}$ with a
sampling in $\mathbb{R}^{3}\times(a,b)$ and another in
$\bigcup_{i=1}^{n}\mathbb{R}^{3}\times\\{t_{i}\\}$.

#### Sampling space-time points

During training, we sample minibatches of $l_{1}\in\mathbb{N}$ space-time
points $(p_{j},t_{j})\in{\mathbb{R}^{3}\times(a,b)}$ randomly. Then,
$\mathcal{L}_{\text{PDE}}$ is enforced in $(p_{j},t_{j})$, yielding the
approximation:

$\widetilde{\mathcal{L}_{\text{PDE}}}(\theta)=\frac{1}{l_{1}}\sum_{j=1}^{l_{1}}\Big{|}\mathcal{F}\big{(}\nabla^{n}f_{\theta},\dots,\nabla^{1}f_{\theta},f_{\theta},p_{j},t_{j}\big{)}\Big{|}$

Where $f_{\theta}$ and its derivatives $\nabla^{i}f_{\theta}$ are evaluated at
$(p_{j},t_{j})$. The Monte Carlo integration ensures that the approximation of
$\mathcal{L}_{\text{PDE}}$ gets better as the size $l_{1}$ of the sampling
grows. Observe that the constraint $\mathcal{L}_{\text{PDE}}$ does not need
supervision since it only use the points $(p_{j},t_{j})$.

#### Sampling initial conditions

The data constraint $\mathcal{L}_{\text{data}}$ forces $f_{\theta}$ to fit to
the input dataset which we consider to be the SDFs $g_{i}$ of $n$ surfaces
$S_{i}$.

We follow the approach in [21] to fit $f_{\theta}$ to $g_{i}$ at $t_{i}$. This
uses Equation (1) to define $\mathcal{L_{\text{data}}}=\sum\mathcal{L}_{i}$,
with $\mathcal{L}_{i}$ managing the approximation of $g_{i}$ by
$(f_{\theta})_{t_{i}}$.

$\displaystyle\mathcal{L}_{i}\\!\\!=\\!\\!\\!\\!\\!\\!\underbrace{\int\limits_{\mathbb{R}^{3}\times{t_{i}}}\\!\\!\\!\\!\Big{|}1\\!-\\!\big{|}\nabla
f_{\theta}\big{|}\Big{|}dp}_{\mathcal{L}_{\text{Eikonal}}}+\\!\\!\\!\\!\underbrace{\int\limits_{\mathbb{R}^{3}\times{t_{i}}}\\!\\!\\!\big{|}f_{\theta}-g_{i}\big{|}dp}_{\mathcal{L}_{\text{Dirichlet}}}+\\!\\!\\!\underbrace{\int\limits_{S_{i}}\\!\big{|}1\\!-\\!\big{\langle}\nabla
f_{\theta},N_{i}\big{\rangle}\big{|}dS_{i}}_{\mathcal{L}_{\text{Neumann}}}.$

Where ${\mathcal{L}_{\text{Dirichlet}}}$ asks for $(f_{\theta})_{t_{i}}$ to
fit $g_{i}$, ${\mathcal{L}_{\text{Neumann}}}$ requires the alignment between
$\nabla f_{\theta}$ and the normals of $S_{i}$, and
${\mathcal{L}_{\text{Eikonal}}}$ is the Eikonal regularization. During
training, these constraints are discretized, as in the PDE constraint case.
Then, we sample minibatches with $l_{2}$ on-surface points ($g_{i}=0$) and
$l_{3}$ off-surface points ($g_{i}\neq~{}0$).

In practice, we use two kinds of initial conditions: 1) smooth neural networks
$g_{i}$ approximating the SDFs of $S_{i}$ or 2) oriented point clouds
$\\{p_{j},N_{j}\\}_{i}$ sampled from $S_{i}$. Option 1) results in faster
training since we have, for each minibatch $p_{i}$, the values $g_{i}(p_{i})$
and $N_{i}=\nabla g_{i}$ are given by the evaluation of the network $g_{i}$
and its derivative at $p_{i}$. For case 2) we have to approximate the SDF of
$S_{i}$. We use the framework presented in [21] for this task.

Therefore, during the training of the homotopy $f_{\theta}$, we sample
minibatches of $l_{1}+l_{2}+l_{3}$ points to feed the loss function. Where
$l_{1}$, $l_{2}$, $l_{3}$, are the numbers of space-time, on-surface, and off-
surface points, respectively. In the experiments, we obtained good results
considering that $l_{1}$, $l_{2}$, $l_{3}$ have $50\%$, $25\%$, $25\%$ of the
minibatch size.

###  4.3 Neural network architecture

We consider the network to be a sinusoidal MLP (SIREN)
$f_{\theta}(p)=W_{d+1}\circ f_{d}\circ\cdots\circ f_{1}(p)+b_{d+1},$
consisting of $d$ hidden layers $f_{i}(p_{i})=\sin(W_{i}(p_{i})+b_{i})$, where
$W_{i}:\mathbb{R}^{N_{i}}\to\mathbb{R}^{N_{i+1}}$ are linear maps, and
$b_{i}\in\mathbb{R}^{N_{i+1}}$ are the biases. The sine function is applied at
each coordinate of $W_{i}(p_{i})+b_{i}$. $\theta$ consists of the union of the
coefficients of $W_{i}$ and the biases $b_{i}$. The integer $d$ is the depth
of $f_{\theta}$ and the dimensions $N_{i}$ are the layers widths.

The network $f_{\theta}$ is smooth since $\sin$ is smooth and we can compute
its gradient using the chain rule. See [21] for explicit formulas for its
gradient and Hessian operators.

We train $f_{\theta}$ using the loss function $\mathcal{L}$ in Equation (3).

###  4.4 Network initialization

We follow the standard definitions in [25] to initialize $\theta$.
Alternatively, our framework may consider a trained network
$g_{\phi}:\mathbb{R}^{3}\to\mathbb{R}$ as the initial condition. In this case
we initialize $f_{\theta}$ based on $\phi$, which may result in faster
training (see experiments in Section 6.4).

Suppose the network $f_{\theta}:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$
is subject to a PDE problem with the condition of $f_{\theta}=g_{\phi}$ on
$\mathbb{R}^{3}\times\\{0\\}$. We present a simple initialization of $\theta$
based on $\phi$ such that $f_{\theta}(p,t)=g_{\phi}(p)$ for all $t$, i.e.
$f_{\theta}$ will be constant and equal to $g_{\phi}$ along the time.

Suppose that $f_{\theta}$ is wider than $g_{\phi}$ and that their depths are
equal to $d$. Recall that $g_{\phi}(p)=B_{d+1}\circ g_{d}\circ\cdots\circ
g_{1}(p)+b_{d+1}$, where $g_{i}(p_{i})\\!=\\!\sin(B_{i}p_{i}\\!+\\!b_{i})$ is
the $i$-layer, $B_{i}$ is a matrix in $\mathbb{R}^{N_{i+1}\times{N_{i}}}$, and
$b_{i}\in\mathbb{R}^{N_{i+1}}$ is the $i$th bias. Analogously,
$f_{\theta}(p,t)=A_{d+1}\circ f_{d}\circ\cdots\circ f_{1}(p,t)+a_{d+1}$, with
its $i$-layer $f_{i}:\mathbb{R}^{M_{i}}\to~{}\mathbb{R}^{M_{i+1}}$ given by
$f_{i}(p_{i})=\sin(A_{i}p_{i}+a_{i})$.

Since $f_{\theta}$ and $g_{\phi}$ have the same depth $d$ and $N_{i}\leq
M_{i}$, we define the hidden layers of $f_{\theta}$ using

$A_{1}=\left(\begin{smallmatrix}B_{1}&0\\\
0&0\end{smallmatrix}\right),\,\,A_{i}=\left(\begin{smallmatrix}B_{i}&0\\\
0&I\end{smallmatrix}\right)\text{ for }i=2,\ldots,d,$

and $a_{i}=\left(\begin{smallmatrix}b_{i}\\\ 0\end{smallmatrix}\right)$. Where
$I$ is the identity matrix. For more details and proofs see Appendix B.

##  5 Applications

This section presents applications of neural implicit evolution using PDEs.
The section is divided into three parts: 1) Section 5.1 presents the level set
equation, the standard PDE for evolving level sets. We mention the example of
vector fields. 2) Section 5.2 considers the mean curvature equation, which is
intrinsically related to the implicit surface. As a result, we present
smoothing/sharpening applications of neural implicit surfaces. 3) Section 5.3
investigates interpolations between neural implicit surfaces (initial
conditions) using PDEs to regularize the intermediate times.

Recently, these problems have been addressed by different neural methods [19,
29, 16]. Comparisons are done in Section 6. Hereafter, we give the
conceptualization and the corresponding loss function for each application.

###  5.1 Level set method

The level set equation is the classic approach for evolving level sets [22,
28, 10, 17]. It uses a time-dependent vector field to drive the animation of
an initial surface $S$. Next, we give an interpretation of how this technique
works.

Let $\text{{x}}:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}^{3}$ be an one-
parameter family of deformation such that $\text{{x}}(p,0)=p$.
$\text{{x}}(S,t)$ is an animation of $S$. It may be expressed implicitly in
the following way.

Let $g$ be the SDF of $S$. A function
$f:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ such that
$f_{t}^{-1}(0)=\text{{x}}(S,t)$ for $t\in\mathbb{R}$ must satisfies:

  * •

$f=g$ on $\mathbb{R}^{3}\times\\{0\\}$;

  * •

$f$ must be constant along each curve $\alpha(t):=\text{{x}}(p,t)$ for
$p\in\mathbb{R}^{3}$, i.e. $f\big{(}\alpha(t),t\big{)}=c$ iff $g(p)=c$.

The second condition requires that each $c$-level set of $f_{t}$ matches with
$\text{{x}}(g^{-1}(c),t)$. To compute $f$, we observe that for each point $p$,
$f(\alpha(t),t)$ is constant. Deriving,

$\displaystyle\displaystyle\frac{\partial f}{\partial
t}(\alpha(t),t)+\big{\langle}\nabla_{p}f(\alpha(t),t),\alpha^{\prime}(t)\big{\rangle}=0.$
(4)

The derivative $\alpha^{\prime}(t)$ is a vector field along the path
$\alpha(t)$.

As Equation (4) holds for each point $p$, we can drop their paths $\alpha$ and
use only $\alpha^{\prime}$ in the equation. Assume these derivatives to be
represented by a time-dependent vector field
$V:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}^{3}$, where
$V(p,t)=\alpha^{\prime}(t)$. Then, the function $f$ encoding the animation
should be the solution of the (neural) level set equation.

$\displaystyle\begin{cases}\displaystyle\frac{\partial f}{\partial
t}+\big{\langle}\nabla_{p}f,V\big{\rangle}=0&\text{ in
}\mathbb{R}^{3}\times(a,b),\\\ f=g&\text{ on
}\mathbb{R}^{3}\times\\{t=0\\}.\end{cases}$ (5)

A solution $f$ of Equation (5) implicitly encodes the integration of $V$.
Thus, defining a family of vector fields is a way to animate a given surface
using the level set equation.

To define a loss function
$\mathcal{L}=\mathcal{L}_{\text{PDE}}+\mathcal{L}_{\text{data}}$ to fit a
solution of Equation (5), we substitute $\mathcal{F}:=\frac{\partial
f}{\partial t}+\big{\langle}\nabla_{p}f,V\big{\rangle}$ and its initial
conditions in Equation (3).

An important example of the level set equation is the transport of the initial
condition $g$ towards a vector field $V:\mathbb{R}^{3}\to\mathbb{R}^{3}$. In
this case, $V$ does not depend on the time. Section 6.1 presents two examples
of vector fields.

###  5.2 The mean curvature equation

The mean curvature equation evolves the level sets with velocity given by the
negative of their mean curvature, resulting in a smoothing along the time [4,
1].

Let $V(p,t)=-\kappa(p,t)N(p,t)$ be the mean curvature vector, where $N$ is the
normal field of the level sets and $\kappa=\,\text{{div}}\,N$ is the mean
curvature; div is the divergence operator. Replacing $V$ in Eq (5) results in
the PDE problem:

$\displaystyle\begin{cases}\displaystyle\frac{\partial f}{\partial
t}-\alpha\left\lVert\nabla_{p}f\right\rVert\,\kappa_{\theta}=0&\text{ in
}\mathbb{R}^{3}\times(a,b),\\\ f=g&\text{ on
}\mathbb{R}^{3}\times\\{t=0\\}.\end{cases}$ (6)

Intuitively, the level sets $f_{t}^{-1}(0)$ move in the direction of the mean
curvature vector $-\kappa N$. Then, over time it contracts regions of $S$ with
positive curvature and expands regions with negative curvature. As a
consequence, this procedure smooths $S$ if $t>0$ and sharpens it if $t<0$. The
parameter $\alpha$ controls the evolution of the level sets. Such evolution
has relations with minimal surfaces, see Appendix A.

Analogous to Equation (5), we define a loss function
$\mathcal{L}=\mathcal{L}_{\text{PDE}}+\mathcal{L}_{\text{data}}$ to fit a
solution of Equation 6 by considering $\mathcal{F}:=\frac{\partial f}{\partial
t}-\alpha\left\lVert\nabla_{p}f\right\rVert\,\kappa_{\theta}$. Section 6.2
presents smoothing and sharpening using this technique.

A trained neural network $f_{\theta}$ approximating a solution Equation 6
provides a continuous multi-resolution to $S$ once it smooths the surface
along time.

###  5.3 Interpolation between implicit surfaces

Let $S_{i}$ be two surfaces and $g_{i}$ be their SDFs. This section presents a
PDE whose solution interpolates $g_{i}$. A family of vector fields
$V:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}^{3}$ for Equation (5), such
that its solution interpolates between $S_{i}$ has the following form.

$\displaystyle
V(p,t)=-\big{(}g_{2}(p)-f(p,t)\big{)}\frac{\nabla_{p}f(t,p)}{\left\lVert\nabla_{p}f(t,p)\right\rVert},$
(7)

with $f(p,0)=g_{1}(p)$. Note that the evolution through $V$ forces each
$c$-level set of $g_{1}$ to match the $c$-level set of $g_{2}$.

The corresponding PDE problem is obtained by substituting Equation (7) in
Equation (5).

$\displaystyle\begin{cases}\displaystyle\frac{\partial f}{\partial
t}-\left\lVert\nabla_{p}f\right\rVert(g_{2}-f)=0&\text{ in
}\mathbb{R}^{3}\times\mathbb{R},\\\ f=g_{i}&\text{ on
}\mathbb{R}^{3}\times\\{t_{i}\\}.\end{cases}$ (8)

Intuitively, a solution $f$ of Equation (8) will locally inflate $S_{1}$ if
inside $S_{2}$, and deflate it if outside, so that $S_{1}$ will always try to
fit into $S_{2}$ [10]. Again, we define a loss function
$\mathcal{L}=\mathcal{L}_{\text{PDE}}+\mathcal{L}_{\text{data}}$ to fit a
solution of Equation 5 considering $\mathcal{F}:=\frac{\partial f}{\partial
t}-\left\lVert\nabla_{p}f\right\rVert(g_{2}-f)$.

Theoretically, we could also use the mean curvature equation to minimize
deformations along the interpolation. This equation has the property of
minimizing area distortions along the resulting surface evolution, see
Appendix A.

##  6 Experiments

This section presents the experiments of the applications described in the
previous section.

###  6.1 Deformation driven by vector fields

We train an animation using vector fields spatially related to the initial
surface. We use the definitions in Sec 5.1.

First, consider the twist $V(x,y,z)=y(-z,0,x)$ of $\mathbb{R}^{3}$ along the
$y$-axis. Substituting it in Eq 5 results in a level set equation, which we
use to derive a loss function.

Let $g$ be the SDF of the Armadillo and $f_{\theta}$ to be a network with $2$
hidden layers $f_{i}:\mathbb{R}^{256}\to\mathbb{R}^{256}$. We trained
$f_{\theta}$ during $48000$ epochs using minibatches of $25000$ on-surface
points ($g=0$), $25000$ off-surface points ($g\neq 0$), and $8000$ points in
$\mathbb{R}^{3}\times[-1,1]$. Figure 1 shows $3$ reconstructions of the zero-
level sets of $(f_{\theta})_{t_{i}}$ with $t_{i}=0,0.25,0.5$.

Figure 1: Evolving the level sets of Armadillo’s SDF using the vector field
that represents a twist of $\mathbb{R}^{3}$ along the $y$-axis.

Although we do not provide data in $\mathbb{R}^{3}\times\\{t\neq 0\\}$, the
solution of the equation is visually well approximated, as show in Fig 1. The
vertical axis coincides with the $y$-axis and the origin of $\mathbb{R}^{3}$
is in the ground below the Armadillo.

For the next experiment, let $g$ be the SDF of the Spot model (Fig 2, center).
Define a vector field $V=V_{1}-V_{2}$ as the sum of a source $V_{1}$ and a
sink $-V_{2}$, where $V_{i}(p)=e^{-\frac{|{p-p_{i}}|^{2}}{0.18}}(p-p_{i})$ and
$p_{1}$, $p_{2}$ are the centers of Spot’s body and head, respectively. Again,
we use $V$ to derive a loss function to train $f_{\theta}$. We parameterize
$f_{\theta}$ with $1$ hidden layer $f_{i}:\mathbb{R}^{128}\to\mathbb{R}^{128}$
and train it for $46000$ epochs. As expected, evolving the zero-level set of
$g$ under $V$ reduces the Spot’s head while it increases the body size, see
Fig 2.

Figure 2: Evolving the zero-level sets of a network according to a vector
field with a source and a sink. We set the SDF of the Spot as the initial
condition at $t=0$ (middle). The sink/source are inside the head/body of the
Spot. From left to right, the reconstructions at $t=-1,-0.5,0,0.5,1$.

Table 1 shows that the above networks are close to satisfying the PDE
problems. We compare $f_{\theta}(\cdot,0)$ with the initial condition $g$ and
measure how close $f_{\theta}$ is from satisfying the PDE $\mathcal{F}=0$. For
this we use the following measures: 1) The absolute difference
$\left|f_{\theta}(\cdot,0)-g\right|$ in $\mathbb{R}^{3}\times\\{0\\}$; 2) The
evaluation of $f_{\theta}$ in $\left|\mathcal{F}\right|$ in
$\mathbb{R}^{3}\times\mathbb{R}$. We used a sample of $1000$ points in
$\mathbb{R}^{3}\times\\{0\\}$ and $\mathbb{R}^{3}\times\mathbb{R}$, not
included in the training process, to evaluate the mean/maximum of each
measure.

Vector field |  | on-surface
---
constraint
| off-surface
---
constraint
| PDE
---
constraint
mean | max | mean | max | mean | max
twist | 0.0008 | 0.0032 | 0.002 | 0.028 | 1e-05 | 0.0004
min-max | 0.0009 | 0.0052 | 0.001 | 0.015 | 2.7e-06 | 0.0005
Table 1: Comparisons between the ground truth initial conditions at $t=0$ and
the measures of how close the trained networks are to satisfying the
underlying PDEs.

###  6.2 The mean curvature equation

Here we seek a solution of the mean curvature equation. First, we consider
simple initial conditions: the cube and dumbbell. Then we use the intrinsic
properties of this PDE to provide smoothing/sharpening of detailed surfaces.

####  6.2.1 Simple initial conditions for validation

Let $g$ be the SDF of the cube, and
$f_{\theta}:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ be a network with $3$
hidden layers $f_{i}:\mathbb{R}^{256}\to\mathbb{R}^{256}$. We set $\alpha=0.1$
and optimized $f_{\theta}$ for $8000$ epochs using the loss function given in
Section 5.2. We used an oriented point cloud of size $40000$, sampled from the
cube. During training, we consider minibatches of $5000$ on-surface points,
$5000$ off-surface points, and $10000$ in $\mathbb{R}^{3}\times[-1,1]$.

Figure 3 shows the level sets of $(f_{\theta})_{t_{i}}$, with
$t_{i}=\frac{i}{5}$, $i=0,\ldots,5$. As expected, regions with positive mean
curvature, such as the cube corners, have contracted. Remember that this PDE
evolves the level sets toward their normals weighted by the negative of the
mean curvature. Therefore, the cube will at some instant of time collapse to a
point, but right before it will be very close to a sphere [4].

Figure 3: Mean curvature equation of cube surface.

We now present a classical example. Let $g$ be the SDF of the dumbbell, and
$f_{\theta}:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ be a network with $2$
hidden layers $f_{i}:\mathbb{R}^{256}\to~{}\mathbb{R}^{256}$. We set
$\alpha=0.05$ and sampled an oriented point cloud of size $80000$ from the
dumbbell. The training took $2800$ epochs using minibatches of $5000$ on-
surface points, $5000$ off-surface points, and $10000$ in the space-time
domain $\mathbb{R}^{3}\times[-1,1]$.

Figure 4 shows the level sets of $(f_{\theta})_{t_{i}}$, where
$t_{i}=\frac{i}{10}$ for $i=0,\ldots,7$. As expected, since the neck region
has higher mean curvature, it pinches off first creating two connected
components. Later, each component collapses to a point, becoming small spheres
right before that. The resulting flow has critical points in different
instances of time.

Figure 4: Mean curvature equation of Dumbbell surface.

####  6.2.2 Smoothing and sharpening

The mean curvature equation evolves the level sets by contracting (expanding)
regions with positive (negative) mean curvature. As a consequence, its
solution smooths (sharpens) the level sets when $t>0$ ($t<0$).

Let $g$ be the SDF of the Armadillo, and $f_{\theta}$ be a network with $2$
hidden layers $f_{i}:\mathbb{R}^{256}\to\mathbb{R}^{256}$. We set
$\alpha=0.001$ in Equation (6). The network $f_{\theta}$ was trained during
$33000$ epochs using an oriented point cloud of size $80000$. During training,
we used minibatches of $5000$ on-surface points, $5000$ off-surface points,
and $10000$ in $\mathbb{R}^{3}\times[-1,1]$.

Figure 5 presents three reconstructions of the zero-level sets of
$(f_{\theta})_{t_{i}}$ at $t_{i}=0,0.1,0.2$. As expected the surface of the
Armadillo was properly reconstructed at $t=0$ and as time progressed it became
smoother. Regions with positive mean curvature, such as the fingers,
contracted.

Figure 5: Using the mean curvature equation to smooth the Armadillo surface.

For the sharpening of the Armadillo we reconstruct the zero-level sets of
$(f_{\theta})_{t_{i}}$ for $t_{i}=0,-0.1,-0.2$. See Figure 6 for
illustrations. As expected, regions with positive mean curvature have
expanded, resulting in an enhancement of the surface geometrical features.

Figure 6: Using the mean curvature equation to enhance the geometrical details
of the Armadillo surface.

#### Numerical evaluation

Table 2 shows that the above networks (trained considering the Cube, Dumbbell,
and Armadillo as initial surfaces) are close to satisfying the mean curvature
equation. We compare the networks at $t=0$ with the initial surfaces. We also
measure how close the networks are to satisfying the PDE. We used a sample of
$1000$ points in $\mathbb{R}^{3}\times\\{0\\}$ and
$\mathbb{R}^{3}\times\mathbb{R}$, not included in the training process, to
evaluate the mean and maximum values of each measure.

Model |  | on-surface
---
constraint
| off-surface
---
constraint
| PDE
---
constraint
mean | max | mean | max | mean | max
Cube | 0.0006 | 0.0071 | 0.0013 | 0.024 | 0.0015 | 0.009
Dumbbell | 0.0003 | 0.0020 | 0.0010 | 0.013 | 0.0009 | 0.017
Armadillo | 0.0008 | 0.0043 | 0.0022 | 0.016 | 0.0019 | 0.013
Table 2: Quantitative evaluation of our method in the problem of approximating
solutions of the mean curvature equation.

#### Comparisons

We compare our technique with NFGP [29] and NIE [19] for smoothing and
sharpening of neural surfaces. These approaches were briefly described in Sec
2.

NFGP trains a network for each smoothing parameter $\beta$, thus, it cannot
represent a continuous evolution. The underlying smoothing model is not
equivalent to the mean curvature equation. As a consequence, we cannot compare
it numerically with our approach and proceed to perform a qualitative analysis
instead. Figure 7 presents this comparison for sharpening. The artifacts in
Armadillo’s ears are probably due to the inconsistencies in the loss function
of NFGP, as mentioned in Section 2.

Figure 7: Sharpening comparison of our approach with NFGP [29]. We use the
same Armadillos in Fig 6, and $\beta=2,2.5$ for the NFGP. The experiments used
the same initial condition. Notice that NFGP may produce artifacts while
sharpening, as can be seen in the Armadillo’s ears.

We also compare with NIE [19]. Given a time step $\Delta t$, it fits the
solution of Eq 6 at discrete instant of times $t_{i}=i\Delta t$ using the
approximation $f_{t_{i+1}}=f_{t_{i}}-\Delta
t\alpha\big{\langle}\nabla_{p}f_{t_{i}},\kappa_{\theta}N\big{\rangle}$. Thus,
given a network $g_{\phi_{i}}\approx f_{t_{i}}$, NIE trains the next state
$g_{\phi_{i+1}}$ by minimizing $\big{(}g_{\phi_{i+1}}-f_{t_{i+1}}\big{)}^{2}$.
Moreover, a discrete Laplacian estimates $\kappa_{\theta}N$ at the vertices of
a mesh approximating the zero-level set of $g_{\phi_{i}}$. The resulting
networks $g_{\phi_{i}}$ have the domain in $\mathbb{R}^{3}$ while our approach
learns the solution in an interval of time using a single network with domain
in $\mathbb{R}^{3}\times\mathbb{R}$.

Figure 8 presents two smoothings of the Armadillo using our method, NIE, and
NFGP. Line 1 repeats the results of Figure 5. Line 2 shows results for NIE,
considering $4$ and $7$ steps with $\Delta t=1$. Line 3 presents the results
using NFGP to train a network with the smoothing parameters $\beta=0.95,0.8$.
We define the constant $\beta$ empirically since NFGP considers a different
approach to smooth the initial surface. To present a fair comparison we
considered the initial network to be $f_{\theta}(\cdot,0)$, where $f_{\theta}$
is the neural homotopy from the previous experiment. We used the procedure
given in Appendix C to extract $f_{\theta}(\cdot,0)$ from $f_{\theta}$.

Figure 8: Smoothing comparison. Line 1 repeats Fig 5. Line 2 presents steps 4
and 7 of smoothing using NIE [19]. Line 3 shows the results using NFGP [29]
with $\beta=0.95,0.8$. All experiments used the same initial condition. As
expected our approach is comparable with NIE because they are based on the
mean curvature equation. While the overall result of NFGP is a smoothing, it
may produce artifacts, as can be noticed in the fingers.

###  6.3 Interpolation between implicit surfaces

Suppose $g_{i}$ are the SDFs of the Bob and Spot (Fig 9, left-right) and that
$f_{\theta}$ has $1$ hidden layer $f_{i}:\mathbb{R}^{128}\to\mathbb{R}^{128}$.
We train $f_{\theta}$ using
$\mathcal{L}_{\text{PDE}}+\mathcal{L}_{\text{data}}$, as described in Sec 5.3.
Line $1$ in Fig 9 shows the reconstructions of the level sets of $f_{\theta}$.

Figure 9: Interpolation between Bob and Spot. Line 1 shows the result using
our method and line 2 the Lipschitz MLP. Notice that our method results in
smoother transitions between the images.

We compare our method with Lipschitz MLP [16]. For this, we opt for a
Lipschitz MLP with $5$ hidden layers of $256$ neurons with the $tanh$
activation. Each layer is followed by a Lipschitz regularization. The network
was trained during $100000$ epochs. See the resulting interpolation in Line
$2$ of Fig 9. Our network is significantly smaller than the Lipschitz MLP but
results in natural interpolation. This is probably due to the high
representation capacity of the SIREN.

Our method is also capable of interpolating more complex models. Figure 10
presents the reconstructions of an interpolation between the Witch and Falcon
(from the Thingi10K dataset [30]). The first line is the result of our method
using a network with $2$ hidden layers $\mathbb{R}^{128}\to\mathbb{R}^{128}$
trained during $20000$ epochs. For the Lipschitz MLP, we have to consider a
larger network with $5$ hidden layers of $512$ neurons and train it for
$100000$ epochs. Even with the added capacity and training iterations, the
Lipschitz MLP can not approximate the initial conditions properly.

Figure 10: Interpolation between Witch and Falcon. Line 1 (20000 epochs) is
the result of our method and Line 2 (100000 epochs) considers the Lipschitz
MLP network. Notice that our approach results in a better approximation of the
initial conditions, as can be seen in the Witch’s hood and sword, and Falcon’s
beak and talons.

###  6.4 Initialization based on trained networks

This section presents the experiment of initializing the weights of the neural
homotopy using the trained weights of a neural implicit function (the initial
condition).

Let $g_{\phi}:\mathbb{R}^{3}\to\mathbb{R}$ be a trained network with $2$
hidden layers $g_{i}:\mathbb{R}^{256}\to\mathbb{R}^{256}$ approximating the
SDF of the Bunny. $\phi$ is the only available data. Let
$f_{\theta}:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ be a network with $2$
hidden layers $f_{i}:\mathbb{R}^{256}\to\mathbb{R}^{256}$. We train
$f_{\theta}$ to approximate a solution of the mean curvature equation subject
to $f_{\theta}=g_{\phi}$ on $\mathbb{R}^{3}\times\\{t=0\\}$.

In the previous experiments, we initialized $\theta$ following the standard
definitions given in [25]. Here we consider the initialization scheme proposed
in Section 4.4 which initializes $\theta$ in terms of $\phi$ such that
$f_{\theta}(p,t)=g_{\phi}(p)$ for all $t\in\mathbb{R}$.

Figure 11 presents qualitative comparisons between the standard initialization
and the proposed data initialization. For this, we trained $f_{\theta}$ during
$1500$ epochs for both initializations. We empirically observed that our
approach speeds up the learning of the level set evolution. For example, Line
1 shows the reconstructions of the zero-level sets of $(f_{\theta})_{t_{i}}$
for $t_{i}=-0.2,0.0,0.6$ after $500$ epochs of training. Line 2 presents the
analogous results using our initialization which results in faster
convergence. Note the preservation of surface details using the proposed
initialization method at $t_{i}=-0.2$ and $0.0$, (Line 2), compared to the
standard initialization proposed by [25] in Line 1.

Figure 11: Network initialization comparison. Line 1 shows the results of
using the initialization given in [25] and Line 2 considers the proposed
initialization. Notice how the new network initialization results in a model
that can represent higher frequencies, as shown by the increased surface
details at Line 2.

Figure 12 shows the plots of the PDE and data constraints used to optimize
$f_{\theta}$. Note that, using our scheme, the training starts closer to a
minimum of the loss function.

Figure 12: Loss function comparisons. Column 1 shows the plots of the PDE/data
constraint using the standard initialization. Column 2 shows the corresponding
plots applying our initialization scheme. The horizontal axis represents the
number of epochs.

##  7 Conclusions and Future Work

We introduced a framework to explore the differentiable properties of smooth
neural networks. For this, we extended their domain to space-time which opens
up possibilities to control geometric animation and modeling using PDEs.

The method allows evolving neural implicit surfaces under PDEs without the use
of additional data, only the initial conditions are used. We divided the data
into two components. First, the initial condition corresponds to fitting the
networks at a fixed instant of times to a given set of SDFs. Second, we only
give points to force the network to be a solution of the PDE. For this, we
designed a specific PDE constraint where no additional data is used. Note that
other methods compute an approximation of the PDE solution using numerical
simulations and then fit it to the neural network. However, our framework was
capable of learning the animation only considering the PDE constraint.

This is powerful because the models are expressed in compact PDEs that are
used to define constraints. This approach enables learning the corresponding
animations without any supervision. Most techniques in geometric processing
use differential equations to model various kinds of phenomena which, in
general, are written in terms of their energy formulation. An interesting
exercise would be approximating a solution of the Willmore flow [6], since
there is a level set formulation for this problem [24].

The resulting networks are smooth approximations of PDE solutions. Numerical
solutions of PDEs using the traditional methods are discrete, making non-
trivial the task of introducing more conditions. This is a quite simple task
in our method, however. We believe that the development of such methods in
computer graphics would enable the community to use the robustness of
classical continuous theories without the need for discretizations.

We emphasized the space-time setting. Future work includes a generalization of
a setting with more dimensions for controlling a wider parameter space of
shape variations.

## Acknowledgments

We thank the Stanford Computer Graphics Laboratory for the Bunny and Armadillo
models, acquired through the Stanford 3D scan repository. We also thank Keenan
Crane for the Spot and Bob models.

## References

  * [1] Giovanni Bellettini.  Lecture notes on mean curvature flow: barriers and singular perturbations, volume 12.  Springer, 2014.
  * [2] D.E. Breen and R.T. Whitaker.  A level-set approach for the metamorphosis of solid models.  IEEE Transactions on Visualization and Computer Graphics, 7(2):173–192, 2001.
  * [3] M. Cani-Gascuel and M. Desbrun.  Animation of deformable models using implicit surfaces.  IEEE Transactions on Visualization and Computer Graphics, 3(1):39–50, 1997.
  * [4] Tobias Holck Colding, William P. Minicozzi II, and Erik Kjær Pedersen.  Mean curvature flow.  Bulletin of the American Mathematical Society, 52(2):297–333, 2015\.
  * [5] Keenan Crane, Fernando de Goes, Mathieu Desbrun, and Peter Schröder.  Digital geometry processing with discrete exterior calculus.  In ACM SIGGRAPH 2013 courses, SIGGRAPH ’13, New York, NY, USA, 2013\. ACM.
  * [6] Keenan Crane, Ulrich Pinkall, and Peter Schröder.  Robust fairing via conformal curvature flow.  ACM Transactions on Graphics (TOG), 32(4):1–10, 2013.
  * [7] Vinícius da Silva, Tiago Novello, Guilherme Schardong, Luiz Schirmer, Hélio Lopes, and Luiz Velho.  Mip-plicits: Level of detail factorization of neural implicits sphere tracing.  arXiv preprint arXiv:2201.09147, 2022.
  * [8] Fernando De Goes, Andrew Butts, and Mathieu Desbrun.  Discrete differential operators on polygonal meshes.  ACM Trans. Graph., 39(4), July 2020.
  * [9] Fernando de Goes, Mathieu Desbrun, Mark Meyer, and Tony DeRose.  Subdivision exterior calculus for geometry processing.  ACM Trans. Graph., 35(4), July 2016.
  * [10] Mathieu Desbrun and Marie-Paule Cani-Gascuel.  Active implicit surface for animation.  In Proceedings of the Graphics Interface 1998 Conference, June 18-20, 1998, Vancouver, BC, Canada, pages 143–150, June 1998.
  * [11] Mathieu Desbrun and Marie-Paule Gascuel.  Animating soft substances with implicit surfaces.  In Proceedings of the 22nd Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH ’95, page 287–290, New York, NY, USA, 1995. Association for Computing Machinery.
  * [12] Manfredo P Do Carmo.  Differential geometry of curves and surfaces: revised and updated second edition.  Courier Dover Publications, 2016.
  * [13] Jonas Gomes, Lucia Darsa, Bruno Costa, and Luiz Velho.  Warping and Morphing of Graphical Objects.  Morgan Kaufmann Publishers, 1998.
  * [14] Amos Gropp, Lior Yariv, Niv Haim, Matan Atzmon, and Yaron Lipman.  Implicit geometric regularization for learning shapes.  arXiv preprint arXiv:2002.10099, 2020.
  * [15] John C Hart.  Morse theory for implicit surface modeling.  In Mathematical Visualization, pages 257–268. Springer, 1998.
  * [16] Hsueh-Ti Derek Liu, Francis Williams, Alec Jacobson, Sanja Fidler, and Or Litany.  Learning smooth neural functions via lipschitz regularization.  In ACM SIGGRAPH 2022 Conference Proceedings, SIGGRAPH ’22. Association for Computing Machinery, 2022.
  * [17] Ravi Malladi, James A Sethian, and Baba C Vemuri.  Shape modeling with front propagation: A level set approach.  IEEE transactions on pattern analysis and machine intelligence, 17(2):158–175, 1995.
  * [18] Francisco Martín and Jesús Pérez.  An introduction to the mean curvature flow.  In XXIII International Fall Workshop on Geometry and Physics, held in Granada. https://www. ugr. es/jpgarcia/investigacion. html, 2014.
  * [19] Ishit Mehta, Manmohan Chandraker, and Ravi Ramamoorthi.  A level set theory for neural implicit evolution under explicit flows.  arXiv preprint arXiv:2204.07159, 2022.
  * [20] Mateusz Michalkiewicz, Jhony Kaesemodel Pontes, Dominic Jack, Mahsa Baktashmotlagh, and Anders Eriksson.  Implicit surface representations as layers in neural networks.  In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), pages 4742–4751, 2019.
  * [21] Tiago Novello, Guilherme Schardong, Luiz Schirmer, Vinícius da Silva, Hélio Lopes, and Luiz Velho.  Exploring differential geometry in neural implicits.  Computers & Graphics, 108, 2022.
  * [22] Stanley Osher and James A Sethian.  Fronts propagating with curvature-dependent speed: Algorithms based on hamilton-jacobi formulations.  Journal of computational physics, 79(1):12–49, 1988.
  * [23] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove.  Deepsdf: Learning continuous signed distance functions for shape representation.  In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.
  * [24] Martin Rumpf and M Droske.  A level set formulation for willmore flow.  Interfaces and free boundaries, 6(3):361–378, 2004.
  * [25] Vincent Sitzmann, Julien Martel, Alexander Bergman, David Lindell, and Gordon Wetzstein.  Implicit neural representations with periodic activation functions.  Advances in Neural Information Processing Systems, 33, 2020.
  * [26] Greg Turk and James F. O’Brien.  Shape transformation using variational implicit functions.  In Proceedings of the 26th Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH ’99, page 335–342, USA, 1999\. ACM Press/Addison-Wesley Publishing Co.
  * [27] Stephanie Wang and Albert Chern.  Computing minimal surfaces with differential forms.  ACM Transactions on Graphics (TOG), 40(4):1–14, 2021.
  * [28] Ross T Whitaker.  Algorithms for implicit deformable models.  In Proceedings of IEEE International Conference on Computer Vision, pages 822–827. IEEE, 1995.
  * [29] Guandao Yang, Serge Belongie, Bharath Hariharan, and Vladlen Koltun.  Geometry processing with neural fields.  Advances in Neural Information Processing Systems, 34, 2021.
  * [30] Qingnan Zhou and Alec Jacobson.  Thingi10k: A dataset of 10,000 3d-printing models.  arXiv preprint arXiv:1605.04797, 2016.

##  Appendix A Minimal surfaces

The evolution of a surface $S$ under the mean curvature equation produces a
family of surfaces that decrease the area. Let
$f:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ be a solution of Equation 6,
and $S_{t}$ be its corresponding one-parameter family of surfaces. We can
measure the area of these surfaces using
$\text{Area}(S_{t})=\int_{S_{t}}dS_{t}$, where $dS_{t}$ is the area form of
$S_{t}$. It can be proved [12, Sec. 3.5], [18, Cor. 6.2] that the first
variation of area of the family $S_{t}$ is given by

$\displaystyle\frac{d}{dt}\text{Area}(S_{t})\Bigr{|}_{t=0}=-\int\limits_{S_{0}}H^{2}dS_{0},$
(9)

Thus, if $H\neq 0$ the area of $S_{t}$ is initially decreasing because the
derivative of its area is negative at $t=0$.

A surface $S_{t_{0}}$ is critical if
$\frac{d}{dt}\text{Area}(S_{t})\Bigr{|}_{t=t_{0}}=0$, in other words, if its
mean curvature is constant equal to zero. This surface is called minimal.
Examples of minimal surfaces include the plane, catenoids, helicoids, Enneper
surface, Costa’s minimal surfaces, etc.

We can add a boundary constraint in the mean curvature equation to fix a given
region of the initial surface $S$ along the time. In the case that $S$ has a
boundary curve, fixing this curve and evolving Equation (6) leads to a surface
of minimal area. This problem is related to the physical shapes of soap films
at equilibrium under the surface tension [27].

##  Appendix B Network initialization

######  Proposition B.1.

Let $g_{\phi}:\mathbb{R}^{3}\to\mathbb{R}$ and
$f_{\theta}:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ be networks with
depth $d$. If $f_{\theta}$ is wider than $g_{\phi}$, we can define $\theta$ in
terms of $\phi$ such that $f_{\theta}(p,t)=g_{\phi}(p)$ for all $(p,t)$.

###### Proof.

Recall that $g_{\phi}(p)=B_{d+1}\circ g_{d}\circ\cdots\circ g_{1}(p)+b_{d+1}$,
where $g_{i}(p_{i})\\!=\\!\sin(B_{i}p_{i}\\!+\\!b_{i})$ is the $i$-layer,
$B_{i}$ is a matrix in $\mathbb{R}^{N_{i+1}\times{N_{i}}}$, and
$b_{i}\in\mathbb{R}^{N_{i+1}}$ is the $i$th bias. Analogously,
$f_{\theta}(p,t)=A_{d+1}\circ f_{d}\circ\cdots\circ f_{1}(p,t)+a_{d+1}$, with
its $i$-layer $f_{i}:\mathbb{R}^{M_{i}}\to~{}\mathbb{R}^{M_{i+1}}$ given by
$f_{i}(p_{i})=\sin(A_{i}p_{i}+a_{i})$.

By hypothesis, $f_{\theta}$ and $g_{\phi}$ have the same depth $d$ and the
width of each layer of $g_{\phi}$ is less than or equal to the width of the
respective layer of $f_{\theta}$, i.e. $N_{i}\leq M_{i}$. Thus, we define the
hidden layers of $f_{\theta}$ using $A_{i}=\left(\begin{smallmatrix}B_{i}&0\\\
0&I\end{smallmatrix}\right)$, $a_{i}=\left(\begin{smallmatrix}b_{i}\\\
0\end{smallmatrix}\right)$, where
$I\in\mathbb{R}^{(M_{i+1}-N_{i+1})\times(M_{i}-N_{i})}$ is the identity
matrix. Evaluating $(p,c)\in\mathbb{R}^{N_{i}}\times\mathbb{R}^{M_{i}-N_{i}}$
in $f_{i}$ results in

$f_{i}(p,c)=\sin\left(\left(\begin{smallmatrix}B_{i}&0\\\
0&I\end{smallmatrix}\right)\left(\begin{smallmatrix}p\\\
c\end{smallmatrix}\right)+\left(\begin{smallmatrix}b_{i}\\\
0\end{smallmatrix}\right)\right)=\left(\begin{smallmatrix}g_{i}(p)\\\
\sin(c)\end{smallmatrix}\right).$

If $\sin(c)=0$ at each layer, we get the desired result. For this, define
$f_{1}$ using $A_{1}=\left(\begin{smallmatrix}B_{1}&0\\\
0&0\end{smallmatrix}\right)$, $a_{1}=\left(\begin{smallmatrix}b_{1}\\\
0\end{smallmatrix}\right)$ ∎

To reproduce Proposition B.1 with $f_{\theta}$ deeper than $g_{\phi}$, we
would have to deal with hidden layers $f(p_{i})=\varphi(Ap+a)$ which does not
exist in $g_{\phi}$. Thus, it would be desirable to initialize $f$ as an
identity $f(p)=p$. Following the above approach, we could define $A=I$ and
$a=0$ obtaining $f(p)=\varphi(p)$, however, in general, $\varphi(p)\neq p$.

##  Appendix C From a neural homotopy to neural implicit functions

Here, we study the problem of extracting a neural implicit function at a given
”time” from a neural homotopy.

Let $f_{\theta}:\mathbb{R}^{3}\times\mathbb{R}\to\mathbb{R}$ be a trained
network represented by $f_{\theta}(p,t)=A_{d+1}\circ f_{d}\circ
f_{d-1}\circ\cdots\circ f_{1}(p,t)+a_{d+1}$, with each $i$-layer defined by
$f_{i}(p_{i})=\varphi(A_{i}p_{i}+a_{i})$.

Let $t\in\mathbb{R}$, we define a network
$g_{\phi}:\mathbb{R}^{3}\to\mathbb{R}$ satisfying
$g_{\phi}(p)=f_{\theta}(p,t)$ for all
$(p,t)\in\mathbb{R}^{3}\times\mathbb{R}$. For this, modify the first layer
$f_{1}(p,t)=\varphi(A_{1}(p,t)+a_{1})$ of $f_{\theta}$. The matrix $A_{1}$ has
$4$ column vectors $\\{w_{1},w_{2},w_{3},u\\}$ in $\mathbb{R}^{M_{2}}$, where
${M_{2}}$ is the dimension of the codomain of the first layer $f_{1}$.
Denoting $p$ by $(x,y,z)$, we obtain

$A_{1}(p,t)=x\cdot w_{1}+y\cdot w_{2}+z\cdot w_{3}+t\cdot u,$

We use the matrix $B_{1}$ consisting of the $3$ column vectors
$w_{1},w_{2},w_{3}$, and the vector bias $b_{1}=a_{1}+t\cdot u$ to construct
the first layer $g_{1}$ of the neural network $g_{\phi}$. Specifically, we
define $g_{\phi}$ through the following neural network

$g_{\phi}(p)=A_{d+1}\circ f_{d}\circ f_{d-1}\circ\cdots\circ f_{2}\circ
g_{1}(p)+a_{d+1}.$

Note that the network $g_{\phi}$ is the neural homotopy $f_{\theta}$ with its
first layer $f_{1}(p,t)$ replaced by $g_{1}(p)$, which we define as

$\displaystyle g_{1}(p)$ $\displaystyle=\varphi\Big{(}\underbrace{x\cdot
w_{1}+y\cdot w_{2}+z\cdot w_{3}}_{B_{1}p}+\underbrace{t\cdot
u+a_{1}}_{b_{1}}\Big{)}$ $\displaystyle=\varphi\big{(}B_{1}p+b_{1}\big{)}.$

From the definition of $g_{\phi}$ we have $g_{\phi}(p)=f_{\theta}(p,t)$, which
implies a kind of opposite direction to Proposition B.1.

######  Proposition C.1.

Let $f_{\theta}$ be a neural homotopy, and $t\in\mathbb{R}$. There is a
network $g_{\phi}:\mathbb{R}^{3}\to\mathbb{R}$ with the same hidden layers of
$f_{\theta}$ such that $f_{\theta}(p,t)=g_{\phi}(p)$ for all
$p\in\mathbb{R}^{3}$.