820 lines
37 KiB
Markdown
820 lines
37 KiB
Markdown
---
|
||
fontsize: 12pt
|
||
---
|
||
|
||
\chapter*{How to read this Thesis}
|
||
|
||
As a guide through the nomenclature used in the formulas we prepend this
|
||
chapter.
|
||
|
||
Unless otherwise noted the following holds:
|
||
|
||
- lowercase letters $x,y,z$
|
||
refer to real variables and represent the coordinates of a point in 3D--Space.
|
||
- lowercase letters $u,v,w$
|
||
refer to real variables between $0$ and $1$ used as coefficients in a 3D
|
||
B--Spline grid.
|
||
- other lowercase letters
|
||
refer to other scalar (real) variables.
|
||
- lowercase **bold** letters (e.g. $\vec{x},\vec{y}$)
|
||
refer to 3D coordinates
|
||
- uppercase **BOLD** letters (e.g. $\vec{D}, \vec{M}$)
|
||
refer to Matrices
|
||
|
||
# Introduction
|
||
|
||
\improvement[inline]{Mehr Bilder}
|
||
|
||
Many modern industrial design processes require advanced optimization methods
|
||
due to the increased complexity resulting from more and more degrees of freedom
|
||
as methods refine and/or other methods are used. Examples for this are physical
|
||
domains like aerodynamic (i.e. drag), fluid dynamics (i.e. throughput of liquid)
|
||
--- where the complexity increases with the temporal and spatial resolution of
|
||
the simulation --- or known hard algorithmic problems in informatics (i.e.
|
||
layouting of circuit boards or stacking of 3D--objects). Moreover these are
|
||
typically not static environments but requirements shift over time or from case
|
||
to case.
|
||
|
||
Evolutionary algorithms cope especially well with these problem domains while
|
||
addressing all the issues at hand\cite{minai2006complex}. One of the main
|
||
concerns in these algorithms is the formulation of the problems in terms of a
|
||
*genome* and *fitness--function*. While one can typically use an arbitrary
|
||
cost--function for the *fitness--functions* (i.e. amount of drag, amount of space,
|
||
etc.), the translation of the problem--domain into a simple parametric
|
||
representation (the *genome*) can be challenging.
|
||
|
||
This translation is often necessary as the target of the optimization may have
|
||
too many degrees of freedom. In the example of an aerodynamic simulation of drag
|
||
onto an object, those objects--designs tend to have a high number of vertices to
|
||
adhere to various requirements (visual, practical, physical, etc.). A simpler
|
||
representation of the same object in only a few parameters that manipulate the
|
||
whole in a sensible matter are desirable, as this often decreases the
|
||
computation time significantly.
|
||
|
||
Additionally one can exploit the fact, that drag in this case is especially
|
||
sensitive to non--smooth surfaces, so that a smooth local manipulation of the
|
||
surface as a whole is more advantageous than merely random manipulation of the
|
||
vertices.
|
||
|
||
The quality of such a low-dimensional representation in biological evolution is
|
||
strongly tied to the notion of *evolvability*\cite{wagner1996complex}, as the
|
||
parametrization of the problem has serious implications on the convergence speed
|
||
and the quality of the solution\cite{Rothlauf2006}.
|
||
However, there is no consensus on how *evolvability* is defined and the meaning
|
||
varies from context to context\cite{richter2015evolvability}, so there is need
|
||
for some criteria we can measure, so that we are able to compare different
|
||
representations to learn and improve upon these.
|
||
|
||
One example of such a general representation of an object is to generate random
|
||
points and represent vertices of an object as distances to these points --- for
|
||
example via \acf{RBF}. If one (or the algorithm) would move such a point the
|
||
object will get deformed locally (due to the \ac{RBF}). As this results in a
|
||
simple mapping from the parameter-space onto the object one can try out
|
||
different representations of the same object and evaluate the *evolvability*.
|
||
This is exactly what Richter et al.\cite{anrichterEvol} have done.
|
||
|
||
As we transfer the results of Richter et al.\cite{anrichterEvol} from using
|
||
\acf{RBF} as a representation to manipulate geometric objects to the use of
|
||
\acf{FFD} we will use the same definition for evolvability the original author
|
||
used, namely *regularity*, *variability*, and *improvement potential*. We
|
||
introduce these term in detail in Chapter \ref{sec:intro:rvi}. In the original
|
||
publication the author could show a correlation between these
|
||
evolvability--criteria with the quality and convergence speed of such
|
||
optimization.
|
||
|
||
We will replicate the same setup on the same objects but use \acf{FFD} instead of
|
||
\acf{RBF} to create a local deformation near the control points and evaluate if
|
||
the evolution--criteria still work as a predictor for *evolvability* of the
|
||
representation given the different deformation scheme, as suspected in
|
||
\cite{anrichterEvol}.
|
||
|
||
First we introduce different topics in isolation in Chapter \ref{sec:back}. We
|
||
take an abstract look at the definition of \ac{FFD} for a one--dimensional line
|
||
(in \ref{sec:back:ffd}) and discuss why this is a sensible deformation function
|
||
(in \ref{sec:back:ffdgood}).
|
||
Then we establish some background--knowledge of evolutionary algorithms (in
|
||
\ref{sec:back:evo}) and why this is useful in our domain (in
|
||
\ref{sec:back:evogood}).
|
||
In a third step we take a look at the definition of the different evolvability
|
||
criteria established in \cite{anrichterEvol}.
|
||
|
||
In Chapter \ref{sec:impl} we take a look at our implementation of \ac{FFD} and
|
||
the adaptation for 3D--meshes that were used.
|
||
|
||
Next, in Chapter \ref{sec:eval}, we describe the different scenarios we use to
|
||
evaluate the different evolvability--criteria incorporating all aspects
|
||
introduced in Chapter \ref{sec:back}. Following that, we evaluate the results in
|
||
Chapter \ref{sec:res} with further on discussion in Chapter \ref{sec:dis}.
|
||
|
||
|
||
# Background
|
||
\label{sec:back}
|
||
|
||
## What is \acf{FFD}?
|
||
\label{sec:back:ffd}
|
||
|
||
First of all we have to establish how a \ac{FFD} works and why this is a good
|
||
tool for deforming geometric objects (esp. meshes in our case) in the first
|
||
place. For simplicity we only summarize the 1D--case from
|
||
\cite{spitzmuller1996bezier} here and go into the extension to the 3D case in
|
||
chapter \ref{3dffd}.
|
||
|
||
The main idea of \ac{FFD} is to create a function $s : [0,1[^d \mapsto
|
||
\mathbb{R}^d$ that spans a certain part of a vector--space and is only linearly
|
||
parametrized by some special control points $p_i$ and an constant
|
||
attribution--function $a_i(u)$, so
|
||
$$
|
||
s(u) = \sum_i a_i(u) p_i
|
||
$$
|
||
can be thought of a representation of the inside of the convex hull generated by
|
||
the control points where each point can be accessed by the right $u \in [0,1[$.
|
||
|
||
\begin{figure}[!ht]
|
||
\begin{center}
|
||
\includegraphics[width=0.7\textwidth]{img/B-Splines.png}
|
||
\end{center}
|
||
\caption[Example of B-Splines]{Example of a parametrization of a line with
|
||
corresponding deformation to generate a deformed objet}
|
||
\label{fig:bspline}
|
||
\end{figure}
|
||
|
||
In the example in figure \ref{fig:bspline}, the control--points are indicated as
|
||
red dots and the color-gradient should hint at the $u$--values ranging from
|
||
$0$ to $1$.
|
||
|
||
We now define a \acf{FFD} by the following:
|
||
Given an arbitrary number of points $p_i$ alongside a line, we map a scalar
|
||
value $\tau_i \in [0,1[$ to each point with $\tau_i < \tau_{i+1} \forall i$
|
||
according to the position of $p_i$ on said line.
|
||
Additionally, given a degree of the target polynomial $d$ we define the curve
|
||
$N_{i,d,\tau_i}(u)$ as follows:
|
||
|
||
\begin{equation} \label{eqn:ffd1d1}
|
||
N_{i,0,\tau}(u) = \begin{cases} 1, & u \in [\tau_i, \tau_{i+1}[ \\ 0, & \mbox{otherwise} \end{cases}
|
||
\end{equation}
|
||
and
|
||
\begin{equation} \label{eqn:ffd1d2}
|
||
N_{i,d,\tau}(u) = \frac{u-\tau_i}{\tau_{i+d}} N_{i,d-1,\tau}(u) + \frac{\tau_{i+d+1} - u}{\tau_{i+d+1}-\tau_{i+1}} N_{i+1,d-1,\tau}(u)
|
||
\end{equation}
|
||
|
||
If we now multiply every $p_i$ with the corresponding $N_{i,d,\tau_i}(u)$ we get
|
||
the contribution of each point $p_i$ to the final curve--point parameterized only
|
||
by $u \in [0,1[$. As can be seen from \eqref{eqn:ffd1d2} we only access points
|
||
$[p_i..p_{i+d}]$ for any given $i$^[one more for each recursive step.], which gives
|
||
us, in combination with choosing $p_i$ and $\tau_i$ in order, only a local
|
||
interference of $d+1$ points.
|
||
|
||
We can even derive this equation straightforward for an arbitrary
|
||
$N$^[*Warning:* in the case of $d=1$ the recursion--formula yields a $0$
|
||
denominator, but $N$ is also $0$. The right solution for this case is a
|
||
derivative of $0$]:
|
||
|
||
$$\frac{\partial}{\partial u} N_{i,d,r}(u) = \frac{d}{\tau_{i+d} - \tau_i} N_{i,d-1,\tau}(u) - \frac{d}{\tau_{i+d+1} - \tau_{i+1}} N_{i+1,d-1,\tau}(u)$$
|
||
|
||
For a B--Spline
|
||
$$s(u) = \sum_{i} N_{i,d,\tau_i}(u) p_i$$
|
||
these derivations yield $\frac{\partial^d}{\partial u} s(u) = 0$.
|
||
|
||
Another interesting property of these recursive polynomials is that they are
|
||
continuous (given $d \ge 1$) as every $p_i$ gets blended in between $\tau_i$ and
|
||
$\tau_{i+d}$ and out between $\tau_{i+1}$, and $\tau_{i+d+1}$ as can bee seen from the two coefficients
|
||
in every step of the recursion.
|
||
|
||
This means that all changes are only a local linear combination between the
|
||
control--point $p_i$ to $p_{i+d+1}$ and consequently this yields to the
|
||
convex--hull--property of B-Splines --- meaning, that no matter how we choose
|
||
our coefficients, the resulting points all have to lie inside convex--hull of
|
||
the control--points.
|
||
|
||
For a given point $v_i$ we can then calculate the contributions
|
||
$n_{i,j}~:=~N_{j,d,\tau}$ of each control point $p_j$ to get the
|
||
projection from the control--point--space into the object--space:
|
||
$$
|
||
v_i = \sum_j n_{i,j} \cdot p_j = \vec{n}_i^{T} \vec{p}
|
||
$$
|
||
or written for all points at the same time:
|
||
$$
|
||
\vec{v} = \vec{N} \vec{p}
|
||
$$
|
||
where $\vec{N}$ is the $n \times m$ transformation--matrix (later on called
|
||
**deformation matrix**) for $n$ object--space--points and $m$ control--points.
|
||
|
||
\begin{figure}[ht]
|
||
\begin{center}
|
||
\includegraphics[width=\textwidth]{img/unity.png}
|
||
\end{center}
|
||
\caption[B--spline--basis--function as partition of unity]{From \cite[Figure 2.13]{brunet2010contributions}:\newline
|
||
\glqq Some interesting properties of the B--splines. On the natural definition domain
|
||
of the B--spline ($[k_0,k_4]$ on this figure), the B--spline basis functions sum
|
||
up to one (partition of unity). In this example, we use B--splines of degree 2.
|
||
The horizontal segment below the abscissa axis represents the domain of
|
||
influence of the B--splines basis function, i.e. the interval on which they are
|
||
not null. At a given point, there are at most $ d+1$ non-zero B--spline basis
|
||
functions (compact support).\grqq \newline
|
||
Note, that Brunet starts his index at $-d$ opposed to our definition, where we
|
||
start at $0$.}
|
||
\label{fig:partition_unity}
|
||
\end{figure}
|
||
|
||
Furthermore B--splines--basis--functions form a partition of unity for all, but
|
||
the first and last $d$ control-points\cite{brunet2010contributions}. Therefore
|
||
we later on use the border-points $d+1$ times, such that $\sum_j n_{i,j} p_j = p_i$
|
||
for these points.
|
||
|
||
The locality of the influence of each control--point and the partition of unity
|
||
was beautifully pictured by Brunet, which we included here as figure
|
||
\ref{fig:partition_unity}.
|
||
|
||
### Why is \ac{FFD} a good deformation function?
|
||
\label{sec:back:ffdgood}
|
||
|
||
The usage of \ac{FFD} as a tool for manipulating follows directly from the
|
||
properties of the polynomials and the correspondence to the control points.
|
||
Having only a few control points gives the user a nicer high--level--interface, as
|
||
she only needs to move these points and the model follows in an intuitive
|
||
manner. The deformation is smooth as the underlying polygon is smooth as well
|
||
and affects as many vertices of the model as needed. Moreover the changes are
|
||
always local so one risks not any change that a user cannot immediately see.
|
||
|
||
But there are also disadvantages of this approach. The user loses the ability to
|
||
directly influence vertices and even seemingly simple tasks as creating a
|
||
plateau can be difficult to
|
||
achieve\cite[chapter~3.2]{hsu1991dmffd}\cite{hsu1992direct}.
|
||
|
||
This disadvantages led to the formulation of
|
||
\acf{DM--FFD}\cite[chapter~3.3]{hsu1991dmffd} in which the user directly
|
||
interacts with the surface--mesh. All interactions will be applied
|
||
proportionally to the control--points that make up the parametrization of the
|
||
interaction--point itself yielding a smooth deformation of the surface *at* the
|
||
surface without seemingly arbitrary scattered control--points. Moreover this
|
||
increases the efficiency of an evolutionary optimization\cite{Menzel2006}, which
|
||
we will use later on.
|
||
|
||
\begin{figure}[!ht]
|
||
\includegraphics[width=\textwidth]{img/hsu_fig7.png}
|
||
\caption{Figure 7 from \cite{hsu1991dmffd}.}
|
||
\label{fig:hsu_fig7}
|
||
\end{figure}
|
||
|
||
But this approach also has downsides as can be seen in figure
|
||
\ref{fig:hsu_fig7}, as the tessellation of the invisible grid has a major impact
|
||
on the deformation itself.
|
||
|
||
All in all \ac{FFD} and \ac{DM--FFD} are still good ways to deform a high--polygon
|
||
mesh albeit the downsides.
|
||
|
||
## What is evolutionary optimization?
|
||
\label{sec:back:evo}
|
||
|
||
In this thesis we are using an evolutionary optimization strategy to solve the
|
||
problem of finding the best parameters for our deformation. This approach,
|
||
however, is very generic and we introduce it here in a broader sense.
|
||
|
||
\begin{algorithm}
|
||
\caption{An outline of evolutionary algorithms}
|
||
\label{alg:evo}
|
||
\begin{algorithmic}
|
||
\STATE t := 0;
|
||
\STATE initialize $P(0) := \{\vec{a}_1(0),\dots,\vec{a}_\mu(0)\} \in I^\mu$;
|
||
\STATE evaluate $F(0) : \{\Phi(x) | x \in P(0)\}$;
|
||
\WHILE{$c(F(t)) \neq$ \TRUE}
|
||
\STATE recombine: $P’(t) := r(P(t))$;
|
||
\STATE mutate: $P''(t) := m(P’(t))$;
|
||
\STATE evaluate $F''(t) : \{\Phi(x) | x \in P''(t)\}$
|
||
\STATE select: $P(t + 1) := s(P''(t) \cup Q,\Phi)$;
|
||
\STATE t := t + 1;
|
||
\ENDWHILE
|
||
\end{algorithmic}
|
||
\end{algorithm}
|
||
|
||
The general shape of an evolutionary algorithm (adapted from
|
||
\cite{back1993overview}) is outlined in Algorithm \ref{alg:evo}. Here, $P(t)$
|
||
denotes the population of parameters in step $t$ of the algorithm. The
|
||
population contains $\mu$ individuals $a_i$ from the possible individual--set
|
||
$I$ that fit the shape of the parameters we are looking for. Typically these are
|
||
initialized by a random guess or just zero. Further on we need a so--called
|
||
*fitness--function* $\Phi : I \mapsto M$ that can take each parameter to a measurable
|
||
space $M$ (usually $M = \mathbb{R}$) along a convergence--function $c : I \mapsto \mathbb{B}$
|
||
that terminates the optimization.
|
||
|
||
Biologically speaking the set $I$ corresponds to the set of possible *Genotypes*
|
||
while $M$ represents the possible observable *Phenotypes*.
|
||
|
||
The main algorithm just repeats the following steps:
|
||
|
||
- **Recombine** with a recombination--function $r : I^{\mu} \mapsto I^{\lambda}$ to
|
||
generate $\lambda$ new individuals based on the characteristics of the $\mu$
|
||
parents.
|
||
This makes sure that the next guess is close to the old guess.
|
||
- **Mutate** with a mutation--function $m : I^{\lambda} \mapsto I^{\lambda}$ to
|
||
introduce new effects that cannot be produced by mere recombination of the
|
||
parents.
|
||
Typically this just adds minor defects to individual members of the population
|
||
like adding a random gaussian noise or amplifying/dampening random parts.
|
||
- **Selection** takes a selection--function $s : (I^\lambda \cup I^{\mu + \lambda},\Phi) \mapsto I^\mu$ that
|
||
selects from the previously generated $I^\lambda$ children and optionally also
|
||
the parents (denoted by the set $Q$ in the algorithm) using the
|
||
fitness--function $\Phi$. The result of this operation is the next Population
|
||
of $\mu$ individuals.
|
||
|
||
All these functions can (and mostly do) have a lot of hidden parameters that
|
||
can be changed over time. One can for example start off with a high
|
||
mutation--rate that cools off over time (i.e. by lowering the variance of a
|
||
gaussian noise).
|
||
|
||
## Advantages of evolutionary algorithms
|
||
\label{sec:back:evogood}
|
||
|
||
The main advantage of evolutionary algorithms is the ability to find optima of
|
||
general functions just with the help of a given fitness--function. With this
|
||
most problems of simple gradient--based procedures, which often target the same
|
||
error--function which measures the fitness, as an evolutionary algorithm, but can
|
||
easily get stuck in local optima.
|
||
|
||
Components and techniques for evolutionary algorithms are specifically known to
|
||
help with different problems arising in the domain of
|
||
optimization\cite{weise2012evolutionary}. An overview of the typical problems
|
||
are shown in figure \ref{fig:probhard}.
|
||
|
||
\begin{figure}[!ht]
|
||
\includegraphics[width=\textwidth]{img/weise_fig3.png}
|
||
\caption{Fig.~3. taken from \cite{weise2012evolutionary}}
|
||
\label{fig:probhard}
|
||
\end{figure}
|
||
|
||
Most of the advantages stem from the fact that a gradient--based procedure has
|
||
only one point of observation from where it evaluates the next steps, whereas an
|
||
evolutionary strategy starts with a population of guessed solutions. Because an
|
||
evolutionary strategy modifies the solution randomly, keeps the best solutions
|
||
and purges the worst, it can also target multiple different hypothesis at the
|
||
same time where the local optima die out in the face of other, better
|
||
candidates.
|
||
|
||
If an analytic best solution exists and is easily computable (i.e. because the
|
||
error--function is convex) an evolutionary algorithm is not the right choice.
|
||
Although both converge to the same solution, the analytic one is usually faster.
|
||
|
||
But in reality many problems have no analytic solution, because the problem is
|
||
either not convex or there are so many parameters that an analytic solution
|
||
(mostly meaning the equivalence to an exhaustive search) is computationally not
|
||
feasible. Here evolutionary optimization has one more advantage as you can at
|
||
least get suboptimal solutions fast, which then refine over time.
|
||
|
||
## Criteria for the evolvability of linear deformations
|
||
\label{sec:intro:rvi}
|
||
|
||
As we have established in chapter \ref{sec:back:ffd}, we can describe a
|
||
deformation by the formula
|
||
$$
|
||
V = UP
|
||
$$
|
||
where $V$ is a $n \times d$ matrix of vertices, $U$ are the (during
|
||
parametrization) calculated deformation--coefficients and $P$ is a $m \times d$ matrix
|
||
of control--points that we interact with during deformation.
|
||
|
||
We can also think of the deformation in terms of differences from the original
|
||
coordinates
|
||
$$
|
||
\Delta V = U \cdot \Delta P
|
||
$$
|
||
which is isomorphic to the former due to the linear correlation in the
|
||
deformation. One can see in this way, that the way the deformation behaves lies
|
||
solely in the entries of $U$, which is why the three criteria focus on this.
|
||
|
||
### Variability
|
||
|
||
In \cite{anrichterEvol} *variability* is defined as
|
||
$$V(\vec{U}) := \frac{\textrm{rank}(\vec{U})}{n},$$
|
||
whereby $\vec{U}$ is the $n \times m$ deformation--Matrix \unsure{Nicht $(n\cdot d) \times m$? Wegen $u,v,w$?} used to map the $m$
|
||
control points onto the $n$ vertices.
|
||
|
||
Given $n = m$, an identical number of control--points and vertices, this
|
||
quotient will be $=1$ if all control points are independent of each other and
|
||
the solution is to trivially move every control--point onto a target--point.
|
||
|
||
In praxis the value of $V(\vec{U})$ is typically $\ll 1$, because as
|
||
there are only few control--points for many vertices, so $m \ll n$.
|
||
|
||
### Regularity
|
||
|
||
*Regularity* is defined\cite{anrichterEvol} as
|
||
$$R(\vec{U}) := \frac{1}{\kappa(\vec{U})} = \frac{\sigma_{min}}{\sigma_{max}}$$
|
||
where $\sigma_{min}$ and $\sigma_{max}$ are the smallest and greatest right singular
|
||
value of the deformation--matrix $\vec{U}$.
|
||
|
||
As we deform the given Object only based on the parameters as $\vec{p} \mapsto
|
||
f(\vec{x} + \vec{U}\vec{p})$ this makes sure that $\|\vec{Up}\| \propto
|
||
\|\vec{p}\|$ when $\kappa(\vec{U}) \approx 1$. The inversion of $\kappa(\vec{U})$
|
||
is only performed to map the criterion--range to $[0..1]$, whereas $1$ is the
|
||
optimal value and $0$ is the worst value.
|
||
|
||
On the one hand this criterion should be characteristic for numeric
|
||
stability\cite[chapter 2.7]{golub2012matrix} and on the other hand for the
|
||
convergence speed of evolutionary algorithms\cite{anrichterEvol} as it is tied to
|
||
the notion of locality\cite{weise2012evolutionary,thorhauer2014locality}.
|
||
|
||
### Improvement Potential
|
||
|
||
In contrast to the general nature of *variability* and *regularity*, which are
|
||
agnostic of the fitness--function at hand the third criterion should reflect a
|
||
notion of potential.
|
||
|
||
As during optimization some kind of gradient $g$ is available to suggest a
|
||
direction worth pursuing we use this to guess how much change can be achieved in
|
||
the given direction.
|
||
|
||
The definition for an *improvement potential* $P$ is\cite{anrichterEvol}:
|
||
$$
|
||
P(\vec{U}) := 1 - \|(\vec{1} - \vec{UU}^+)\vec(G)\|^2_F
|
||
$$
|
||
given some approximate $n \times d$ fitness--gradient $\vec{G}$, normalized to
|
||
$\|\vec{G}\|_F = 1$, whereby $\|\cdot\|_F$ denotes the Frobenius--Norm.
|
||
|
||
# Implementation of \acf{FFD}
|
||
\label{sec:impl}
|
||
|
||
The general formulation of B--Splines has two free parameters $d$ and $\tau$
|
||
which must be chosen beforehand.
|
||
|
||
As we usually work with regular grids in our \ac{FFD} we define $\tau$
|
||
statically as $\tau_i = \nicefrac{i}{n}$ whereby $n$ is the number of
|
||
control--points in that direction.
|
||
|
||
$d$ defines the *degree* of the B--Spline--Function (the number of times this
|
||
function is differentiable) and for our purposes we fix $d$ to $3$, but give the
|
||
formulas for the general case so it can be adapted quite freely.
|
||
|
||
|
||
## Adaption of \ac{FFD}
|
||
\label{sec:ffd:adapt}
|
||
|
||
As we have established in Chapter \ref{sec:back:ffd} we can define an
|
||
\ac{FFD}--displacement as
|
||
\begin{equation}
|
||
\Delta_x(u) = \sum_i N_{i,d,\tau_i}(u) \Delta_x c_i
|
||
\end{equation}
|
||
|
||
Note that we only sum up the $\Delta$--displacements in the control points $c_i$ to get
|
||
the change in position of the point we are interested in.
|
||
|
||
In this way every deformed vertex is defined by
|
||
$$
|
||
\textrm{Deform}(v_x) = v_x + \Delta_x(u)
|
||
$$
|
||
with $u \in [0..1[$ being the variable that connects the high--detailed
|
||
vertex--mesh to the low--detailed control--grid. To actually calculate the new
|
||
position of the vertex we first have to calculate the $u$--value for each
|
||
vertex. This is achieved by finding out the parametrization of $v$ in terms of
|
||
$c_i$
|
||
$$
|
||
v_x \overset{!}{=} \sum_i N_{i,d,\tau_i}(u) c_i
|
||
$$
|
||
so we can minimize the error between those two:
|
||
$$
|
||
\underset{u}{\argmin}\,Err(u,v_x) = \underset{u}{\argmin}\,2 \cdot \|v_x - \sum_i N_{i,d,\tau_i}(u) c_i\|^2_2
|
||
$$
|
||
As this error--term is quadratic we just derive by $u$ yielding
|
||
$$
|
||
\begin{array}{rl}
|
||
\frac{\partial}{\partial u} & v_x - \sum_i N_{i,d,\tau_i}(u) c_i \\
|
||
= & - \sum_i \left( \frac{d}{\tau_{i+d} - \tau_i} N_{i,d-1,\tau}(u) - \frac{d}{\tau_{i+d+1} - \tau_{i+1}} N_{i+1,d-1,\tau}(u) \right) c_i
|
||
\end{array}
|
||
$$
|
||
and do a gradient--descend to approximate the value of $u$ up to an $\epsilon$ of $0.0001$.
|
||
|
||
For this we use the Gauss--Newton algorithm\cite{gaussNewton} as the solution to
|
||
this problem may not be deterministic, because we usually have way more vertices
|
||
than control points ($\#v~\gg~\#c$).
|
||
|
||
## Adaption of \ac{FFD} for a 3D--Mesh
|
||
\label{3dffd}
|
||
|
||
This is a straightforward extension of the 1D--method presented in the last
|
||
chapter. But this time things get a bit more complicated. As we have a
|
||
3--dimensional grid we may have a different amount of control--points in each
|
||
direction.
|
||
|
||
Given $n,m,o$ control points in $x,y,z$--direction each Point on the curve is
|
||
defined by
|
||
$$V(u,v,w) = \sum_i \sum_j \sum_k N_{i,d,\tau_i}(u) N_{j,d,\tau_j}(v) N_{k,d,\tau_k}(w) \cdot C_{ijk}.$$
|
||
|
||
In this case we have three different B--Splines (one for each dimension) and also
|
||
3 variables $u,v,w$ for each vertex we want to approximate.
|
||
|
||
Given a target vertex $\vec{p}^*$ and an initial guess $\vec{p}=V(u,v,w)$
|
||
we define the error--function for the gradient--descent as:
|
||
|
||
$$Err(u,v,w,\vec{p}^{*}) = \vec{p}^{*} - V(u,v,w)$$
|
||
|
||
And the partial version for just one direction as
|
||
|
||
$$Err_x(u,v,w,\vec{p}^{*}) = p^{*}_x - \sum_i \sum_j \sum_k N_{i,d,\tau_i}(u) N_{j,d,\tau_j}(v) N_{k,d,\tau_k}(w) \cdot {c_{ijk}}_x $$
|
||
|
||
To solve this we derive partially, like before:
|
||
|
||
$$
|
||
\begin{array}{rl}
|
||
\displaystyle \frac{\partial Err_x}{\partial u} & p^{*}_x - \displaystyle \sum_i \sum_j \sum_k N_{i,d,\tau_i}(u) N_{j,d,\tau_j}(v) N_{k,d,\tau_k}(w) \cdot {c_{ijk}}_x \\
|
||
= & \displaystyle - \sum_i \sum_j \sum_k N'_{i,d,\tau_i}(u) N_{j,d,\tau_j}(v) N_{k,d,\tau_k}(w) \cdot {c_{ijk}}_x
|
||
\end{array}
|
||
$$
|
||
|
||
The other partial derivatives follow the same pattern yielding the Jacobian:
|
||
|
||
$$
|
||
J(Err(u,v,w)) =
|
||
\left(
|
||
\begin{array}{ccc}
|
||
\frac{\partial Err_x}{\partial u} & \frac{\partial Err_x}{\partial v} & \frac{\partial Err_x}{\partial w} \\
|
||
\frac{\partial Err_y}{\partial u} & \frac{\partial Err_y}{\partial v} & \frac{\partial Err_y}{\partial w} \\
|
||
\frac{\partial Err_z}{\partial u} & \frac{\partial Err_z}{\partial v} & \frac{\partial Err_z}{\partial w}
|
||
\end{array}
|
||
\right)
|
||
$$
|
||
$$
|
||
\scriptsize
|
||
=
|
||
\left(
|
||
\begin{array}{ccc}
|
||
- \displaystyle \sum_{i,j,k} N'_{i}(u) N_{j}(v) N_{k}(w) \cdot {c_{ijk}}_x &- \displaystyle \sum_{i,j,k} N_{i}(u) N'_{j}(v) N_{k}(w) \cdot {c_{ijk}}_x & - \displaystyle \sum_{i,j,k} N_{i}(u) N_{j}(v) N'_{k}(w) \cdot {c_{ijk}}_x \\
|
||
- \displaystyle \sum_{i,j,k} N'_{i}(u) N_{j}(v) N_{k}(w) \cdot {c_{ijk}}_y &- \displaystyle \sum_{i,j,k} N_{i}(u) N'_{j}(v) N_{k}(w) \cdot {c_{ijk}}_y & - \displaystyle \sum_{i,j,k} N_{i}(u) N_{j}(v) N'_{k}(w) \cdot {c_{ijk}}_y \\
|
||
- \displaystyle \sum_{i,j,k} N'_{i}(u) N_{j}(v) N_{k}(w) \cdot {c_{ijk}}_z &- \displaystyle \sum_{i,j,k} N_{i}(u) N'_{j}(v) N_{k}(w) \cdot {c_{ijk}}_z & - \displaystyle \sum_{i,j,k} N_{i}(u) N_{j}(v) N'_{k}(w) \cdot {c_{ijk}}_z
|
||
\end{array}
|
||
\right)
|
||
$$
|
||
|
||
With the Gauss--Newton algorithm we iterate via the formula
|
||
$$J(Err(u,v,w)) \cdot \Delta \left( \begin{array}{c} u \\ v \\ w \end{array} \right) = -Err(u,v,w)$$
|
||
and use Cramers rule for inverting the small Jacobian and solving this system of
|
||
linear equations.
|
||
|
||
|
||
## Deformation Grid
|
||
|
||
As mentioned in chapter \ref{sec:back:evo}, the way of choosing the
|
||
representation to map the general problem (mesh--fitting/optimization in our
|
||
case) into a parameter-space it very important for the quality and runtime of
|
||
evolutionary algorithms\cite{Rothlauf2006}.
|
||
|
||
Because our control--points are arranged in a grid, we can accurately represent
|
||
each vertex--point inside the grids volume with proper B--Spline--coefficients
|
||
between $[0,1[$ and --- as a consequence --- we have to embed our object into it
|
||
(or create constant "dummy"-points outside).
|
||
|
||
The great advantage of B--Splines is the locality, direct impact of each
|
||
control point without having a $1:1$--correlation, and a smooth deformation.
|
||
While the advantages are great, the issues arise from the problem to decide
|
||
where to place the control--points and how many.
|
||
|
||
One would normally think, that the more control--points you add, the better the
|
||
result will be, but this is not the case for our B--Splines. Given any point $p$
|
||
only the $2 \cdot (d-1)$ control--points contribute to the parametrization of
|
||
that point^[Normally these are $d-1$ to each side, but at the boundaries the
|
||
number gets increased to the inside to meet the required smoothness].
|
||
This means, that a high resolution can have many control-points that are not
|
||
contributing to any point on the surface and are thus completely irrelevant to
|
||
the solution.
|
||
|
||
\begin{figure}[!ht]
|
||
\begin{center}
|
||
\includegraphics{img/enoughCP.png}
|
||
\end{center}
|
||
\caption[Example of a high resolution control--grid]{A high resolution
|
||
($10 \times 10$) of control--points over a circle. Yellow/green points
|
||
contribute to the parametrization, red points don't.\newline
|
||
An Example--point (blue) is solely determined by the position of the green
|
||
control--points.}
|
||
\label{fig:enoughCP}
|
||
\end{figure}
|
||
|
||
|
||
We illustrate this phenomenon in figure \ref{fig:enoughCP}, where the four red
|
||
central points are not relevant for the parametrization of the circle.
|
||
|
||
\unsure[inline]{erwähnen, dass man aus $\vec{D}$ einfach die Null--Spalten
|
||
entfernen kann?}
|
||
|
||
For our tests we chose different uniformly sized grids and added gaussian noise
|
||
onto each control-point^[For the special case of the outer layer we only applied
|
||
noise away from the object, so the object is still confined in the convex hull
|
||
of the control--points.] to simulate different starting-conditions.
|
||
|
||
\unsure[inline]{verweis auf DM--FFD?}
|
||
|
||
# Scenarios for testing evolvability criteria using \acf{FFD}
|
||
\label{sec:eval}
|
||
\improvement[inline]{für 1d und 3d entweder konsistent source/target oder
|
||
anders. Weil sonst in 1d $\vec{s}$ das Ziel, in 3d $\vec{t}$ das Ziel.}
|
||
|
||
In our experiments we use the same two testing--scenarios, that were also used
|
||
by \cite{anrichterEvol}. The first scenario deforms a plane into a shape
|
||
originally defined in \cite{giannelli2012thb}, where we setup control-points in
|
||
a 2--dimensional manner merely deform in the height--coordinate to get the
|
||
resulting shape.
|
||
|
||
In the second scenario we increase the degrees of freedom significantly by using
|
||
a 3--dimensional control--grid to deform a sphere into a face. So each control
|
||
point has three degrees of freedom in contrast to first scenario.
|
||
|
||
## Test Scenario: 1D Function Approximation
|
||
|
||
In this scenario we used the shape defined by Giannelli et al.\cite{giannelli2012thb},
|
||
which is also used by Richter et al.\cite{anrichterEvol} using the same
|
||
discretization to $150 \times 150$ points for a total of $n = 22\,500$ vertices. The
|
||
shape is given by the following definition
|
||
$$
|
||
s(x,y) =
|
||
\begin{cases}
|
||
0.5 \cos(4\pi \cdot q^{0.5}) + 0.5 & q(x,y) < \frac{1}{16},\\
|
||
2(y-x) & 0 < y-x < 0.5,\\
|
||
1 & 0.5 < y - x
|
||
\end{cases}
|
||
$$
|
||
with $(x,y) \in [0,2] \times [0,1]$ and $q(x,y)=(x-1.5)^2 + (y-0.5)^2$, which we have
|
||
visualized in figure \ref{fig:1dtarget}.
|
||
|
||
begin{figure}[ht]
|
||
\begin{center}
|
||
\includegraphics[width=0.7\textwidth]{img/1dtarget.png}
|
||
\end{center}
|
||
\caption{The target--shape for our 1--dimensional optimization--scenario
|
||
including a wireframe--overlay of the vertices.}
|
||
\label{fig:1dtarget}
|
||
\end{figure}
|
||
|
||
As the starting-plane we used the same shape, but set all
|
||
$z$--coordinates to $0$, yielding a flat plane, which is partially already
|
||
correct.
|
||
|
||
Regarding the *fitness--function* $f(\vec{p})$, we use the very simple approach
|
||
of calculating the squared distances for each corresponding vertex
|
||
$$
|
||
\textrm{f(\vec{p})} = \sum_{i=1}^{n} \|(\vec{Up})_i - s_i\|_2^2 = \|\vec{Up} - \vec{s}\|^2 \rightarrow \min
|
||
$$
|
||
where $s_i$ are the respective solution--vertices to the parametrized
|
||
source--vertices^[The parametrization is encoded in $\vec{U}$ and the initial
|
||
position of the control points. See \ref{sec:ffd:adapt}] with the current
|
||
deformation--parameters $\vec{p} = (p_1,\dots, p_m)$. We can do this
|
||
one--to--one--correspondence because we have exactly the same number of
|
||
source and target-vertices do to our setup of just flattening the object.
|
||
|
||
This formula is also the least--squares approximation error for which we
|
||
can compute the analytic solution $\vec{p^{*}} = \vec{U^+}\vec{s}$, yielding us
|
||
the correct gradient in which the evolutionary optimizer should move.
|
||
|
||
## Procedure: 1D Function Approximation
|
||
|
||
For our setup we first compute the coefficients of the deformation--matrix and
|
||
use then the formulas for *variability* and *regularity* to get our predictions.
|
||
Afterwards we solve the problem analytically to get the (normalized) correct
|
||
gradient that we use as guess for the *improvement potential*. To check we also
|
||
consider a distorted gradient $\vec{g}_{\textrm{d}}$
|
||
$$
|
||
\vec{g}_{\textrm{d}} = \frac{\vec{g}_{\textrm{c}} + \mathbb{1}}{\|\vec{g}_{\textrm{c}} + \mathbb{1}\|}
|
||
$$
|
||
where $\mathbb{1}$ is the vector consisting of $1$ in every dimension and
|
||
$\vec{g}_\textrm{c} = \vec{p^{*}}$ the calculated correct gradient.
|
||
|
||
\begin{figure}[ht]
|
||
\begin{center}
|
||
\includegraphics[width=\textwidth]{img/example1d_grid.png}
|
||
\end{center}
|
||
\caption{\newline Left: A regular $7 \times 4$--grid\newline Right: The same grid after a
|
||
random distortion to generate a testcase.}
|
||
\label{fig:example1d_grid}
|
||
\end{figure}
|
||
|
||
We then set up a regular 2--dimensional grid around the object with the desired
|
||
grid resolutions. To generate a testcase we then move the grid--vertices
|
||
randomly inside the x--y--plane. As we do not want to generate hard to solve
|
||
grids we avoid the generation of self--intersecting grids.\improvement{besser
|
||
formulieren} To achieve that we select a uniform distributed number
|
||
$r \in [-0.25,0.25]$ per dimension and shrink the distance to the neighbours
|
||
(the smaller neighbour for $r < 0$, the larger for $r > 0$) by the factor
|
||
$r$^[Note: On the Edges this displacement is only applied outwards by flipping the sign of $r$, if appropriate.].
|
||
|
||
An Example of such a testcase can be seen for a $7 \times 4$--grid in figure
|
||
\ref{fig:example1d_grid}.
|
||
|
||
## Test Scenario: 3D Function Approximation
|
||
|
||
Opposed to the 1--dimensional scenario before, the 3--dimensional scenario is
|
||
much more complex --- not only because we have more degrees of freedom on each
|
||
control point, but also because the *fitness--function* we will use has no known
|
||
analytic solution and multiple local minima.
|
||
|
||
\begin{figure}[ht]
|
||
\begin{center}
|
||
\includegraphics[width=0.7\textwidth]{img/3dtarget.png}
|
||
\end{center}
|
||
\caption{\newline
|
||
Left: The sphere we start from with 10\,807 vertices\newline
|
||
Right: The face we want to deform the sphere into with 12\,024 vertices.}
|
||
\label{fig:3dtarget}
|
||
\end{figure}
|
||
|
||
First of all we introduce the set up: We have given a triangulated model of a
|
||
sphere consisting of 10\,807 vertices, that we want to deform into a
|
||
the target--model of a face with a total of 12\,024 vertices. Both of
|
||
these Models can be seen in figure \ref{fig:3dtarget}.
|
||
|
||
Opposed to the 1D--case we cannot map the source and target--vertices in a
|
||
one--to--one--correspondence, which we especially need for the approximation of
|
||
the fitting--error. Hence we state that the error of one vertex is the distance
|
||
to the closest vertex of the other model.
|
||
|
||
We therefore define the *fitness--function* to be:
|
||
$$
|
||
f(\vec{P}) = \frac{1}{n} \underbrace{\sum_{i=1}^n \|\vec{c_T(s_i)} -
|
||
\vec{s_i}\|_2^2}_{\textrm{source-to-target--distance}}
|
||
+ \frac{1}{m} \underbrace{\sum_{i=1}^m \|\vec{c_S(t_i)} -
|
||
\vec{t_i}\|_2^2}_{\textrm{target-to-source--distance}}
|
||
+ \lambda \cdot \textrm{regularization}
|
||
$$
|
||
where $\vec{c_T(s_i)}$ denotes the target--vertex that is corresponding to the
|
||
source--vertex $\vec{s_i}$ and $\vec{c_S(t_i)}$ denotes the source--vertex that
|
||
corresponds to the target--vertex $\vec{t_i}$. Note that the target--vertices
|
||
are given and fixed by the target--model of the face we want to deform into,
|
||
whereas the source--vertices vary depending on the chosen parameters $\vec{P}$,
|
||
as those get calculated by the previously introduces formula $\vec{S} = \vec{UP}$
|
||
with $\vec{S}$ being the $n \times 3$--matrix of source--vertices, $\vec{U}$ the
|
||
$n \times m$--matrix of calculated coefficients for the \ac{FFD} --- analog to
|
||
the 1D case --- and finally $\vec{P}$ being the $m \times 3$--matrix of the
|
||
control--grid defining the whole deformation.
|
||
|
||
As regularization-term we introduce a weighted decaying
|
||
laplace--coefficient\unsure{heisst der so?}
|
||
that is known to speed up the optimization--process\improvement{cite [34] aus
|
||
ref{anrichterEvol}} and simulates a material that is very stiff in the
|
||
beginning --- to do a coarse deformation --- and gets easier to deform over
|
||
time.
|
||
|
||
\improvement[inline]{mehr zu regularisierung, Formel etc.}
|
||
|
||
## Procedure: 3D Function Approximation
|
||
|
||
Initially we set up the correspondences $\vec{c_T(\dots)}$ and $\vec{c_S(\dots)}$ to be
|
||
the respectively closest vertices of the other model. We then calculate the
|
||
analytical solution given these correspondences via $\vec{P^{*}} = \vec{U^+}\vec{T}$,
|
||
and also use the first solution as guessed gradient for the calculation of the
|
||
*improvement--potential*, as the optimal solution is not known.
|
||
We then let the evolutionary algorithm run up within $1.05$ times the error of
|
||
this solution and afterwards recalculate the correspondences $\vec{c_T(\dots)}$
|
||
and $\vec{c_S(\dots)}$.
|
||
For the next step we then halve the regularization--impact $\lambda$ and
|
||
calculate the next incremental solution $\vec{P^{*}} = \vec{U^+}\vec{T}$ with
|
||
the updated correspondences to get our next target--error.
|
||
We repeat this process as long as the target--error keeps decreasing.
|
||
|
||
\improvement[inline]{grid-setup}
|
||
|
||
# Evaluation of Scenarios
|
||
\label{sec:res}
|
||
|
||
## Spearman/Pearson--Metriken
|
||
|
||
- Was ist das?
|
||
- Wieso sollte uns das interessieren?
|
||
- Wieso reicht Monotonie?
|
||
- Haben wir das gezeigt?
|
||
- Statistik, Bilder, blah!
|
||
|
||
## Results of 1D Function Approximation
|
||
|
||
\begin{figure}[!ht]
|
||
\includegraphics[width=\textwidth]{img/evolution1d/20171005-all_appended.png}
|
||
\caption{Results 1D}
|
||
|
||
\end{figure}
|
||
|
||
<!-- ![Improvement potential vs steps](img/evolution1d/20170830-evolution1D_5x5_100Times-all_improvement-vs-steps.png) -->
|
||
<!-- -->
|
||
<!-- ![Improvement potential vs evolutional error](img/evolution1d/20170830-evolution1D_5x5_100Times-all_improvement-vs-evo-error.png) -->
|
||
<!-- -->
|
||
<!-- ![Regularity vs steps](img/evolution1d/20170830-evolution1D_5x5_100Times-all_regularity-vs-steps.png) -->
|
||
|
||
## Results of 3D Function Approximation
|
||
|
||
|
||
\begin{figure}[!ht]
|
||
\includegraphics[width=\textwidth]{img/evolution3d/4x4xX_montage.png}
|
||
\caption{Results 3D for 4x4xX}
|
||
\end{figure}
|
||
|
||
\begin{figure}[!ht]
|
||
\includegraphics[width=\textwidth]{img/evolution3d/Xx4x4_montage.png}
|
||
\caption{Results 3D for Xx4x4}
|
||
\end{figure}
|
||
|
||
<!-- ![Improvement potential vs steps](img/evolution3d/20170926_3dFit_both_improvement-vs-steps.png) -->
|
||
<!-- -->
|
||
<!-- ![Improvement potential vs evolutional -->
|
||
<!-- error](img/evolution3d/20170926_3dFit_both_improvement-vs-evo-error.png) -->
|
||
<!-- -->
|
||
<!-- ![Regularity vs steps](img/evolution3d/20170926_3dFit_both_regularity-vs-steps.png) -->
|
||
|
||
# Schluss
|
||
\label{sec:dis}
|
||
|
||
HAHA .. als ob -.-
|