masterarbeit/arbeit/ma.tex

% bibtotoc[numbered] : Literaturv. wird in Inhaltsv. aufgenommen
% abstracton : Abstract mit Ueberschrift
\documentclass[
a4paper,				% default
12pt, 					% default = 11pt
BCOR6mm,				% Bindungskorrektur bei Klebebindung 6mm, bei Lochen BCOR8.25mm
twoside,				% default, 2seitig
titlepage,
% pagesize=auto
% openany,				% Kapitel koennen auch auf geraden Seiten starten
% draft						% schneller compillieren, Bild-dummy
% appendixprefix,	% Anhang mit Bezeichner
bibtotocnumbered,
liststotocnumbered,
listof=totocnumbered,
index=totocnumbered,
xcolor=dvipsnames,
]{scrbook}

%%%%%%%%%%%%%%% Literaturverzeichnisstil %%%%%%%%%%%%%%%
% achtung, auch \bibstyle, unten, anpassen!
% \usepackage[square]{natbib} % fuer bibstyle natdin/ see ../natbib.pdf

%%%%%%%%%%%%%%% Packages %%%%%%%%%%%%%%%
\input{settings/packages}
\makeindex

%%%%%%%%%%%%%%% Graphics %%%%%%%%%%%%%%%
\graphicspath{{pics/}}

%%%%%%%%%%%%%%% Globale Einstellungen %%%%%%%%%%%%%%%
\input{settings/commands}
\input{settings/environments}
%\setlength{\parindent}{0pt} % kein einzug bei absaetzen
%\setlength{\lineskip}{1ex plus0.5ex minus0.5ex} % dafr abstand zwischen abs<62>zen (funktioniert noch nicht)
% \renewcommand{\familydefault}{\sfdefault}
\setstretch{1.44} % 1.5-facher zeilenabstand

%%%%%%%%%%%%%%% Header - Footer %%%%%%%%%%%%%%%
% ### Fr 2 Seitig (option twopage):
\usepackage{fancyhdr}%http://www.tug.org/tex-archive/info/german/fancyhdr
\pagestyle{fancy} % must be called before the following renewcommands !!!
\fancyhead{} % Alte Definition loeschen
\fancyfoot{} % dito
\renewcommand{\chaptermark}[1]{\markboth{\chaptername\ \thechapter{}: #1}{}}
\renewcommand{\sectionmark}[1]{\markright{\thesection{}~~#1}}
% % um das hard codierte makeuppercase zu verhindern
\fancyhead[EL]{\textrm{\nouppercase\leftmark}}% Even=linke Seiten und dort links, also aussn das \leftmark
\fancyhead[OR]{\textrm{\nouppercase\rightmark}}% Odd=rechte Seiten und dort rechts, also aussen das \rightmark
\fancyfoot[RO,LE]{\thepage} % Seitenzahl : rechts ungerade, links gerade

% ###### Title ######

\usepackage[explicit]{titlesec}
\newcommand{\hsp}{\hspace{20pt}}
% \titleformat{\chapter}[hang]{\Huge\bfseries\ }{\textcolor{CadetBlue}{\thechapter} #1}{20pt}{\Huge\bfseries\ }
\titleformat{name=\chapter,numberless}[hang]{\Huge\bfseries\ }{#1}{20pt}{\Huge\bfseries\ }
\titleformat{\chapter}[hang]{\Huge\bfseries\ }{\color{CadetBlue}\thechapter}{20pt}{\begin{tabular}[t]{@{\color{CadetBlue}\vrule width 2pt}>{\hangindent=20pt\hsp}p{\dimexpr 1\textwidth -44pt}}#1\end{tabular}}

\titleformat{name=\section,numberless}[hang]{\Large\bfseries\ }{#1}{32pt}{\Large\bfseries\ }
\titleformat{\section}[hang]{\Large\bfseries\ }{\color{CadetBlue}\thesection}{32pt}{\begin{tabular}[t]{p{\dimexpr 1\textwidth -44pt}}#1\end{tabular}}
\titleformat{name=\subsection,numberless}[hang]{\large\bfseries\ }{#1}{27pt}{\large\bfseries\ }
\titleformat{\subsection}[hang]{\large\bfseries\ }{\color{CadetBlue}\thesubsection}{27pt}{\begin{tabular}[t]{p{\dimexpr 1\textwidth -44pt}}#1\end{tabular}}

% ### fr 1 seitig
%\usepackage{fancyhdr} %
%\lhead{\textsf{\noupercase\leftmark}}
%\chead{}
%\rhead{\textsf{\nouppercase\rightmark}}
%\lfoot{}
%\cfoot{\textsf{\thepage}}
%\rfoot{}

\setkomafont{sectioning}{\rmfamily\bfseries}
\setcounter{tocdepth}{3}
%\setcounter{secnumdepth}{3}
% \input{settings/hyphenation} %% Manchmal bricht latex nicht richtig um. hier trennregeln rein.
% \includeonly{%
% % 	files/0_titlepage.tex
% % 	files/1_0_introduction,%
% % 	files/2_0_knownDCJ,%
% % 	files/3_0_DCJIndels,%
% % 	files/4_0_DCJIndels_1comps,%
% 	files/5_0_DCJIndels_2comps,%
% % 	files/6_0_implementation,%
% % 	files/7_0_evaluation%
% % 	,files/8_0_conclusion%
% }

%%%%%%%%%%%%%%% PANDOC-nedded defs %%%%%%%%%%
\providecommand{\tightlist}{%
  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}

%disable "Redefining ngerman shorthand"-Message
% \makeatletter
% \patchcmd{\pdfstringdef}
%   {\csname HyPsd@babel@}
%   {\let\bbl@info\@gobble\csname HyPsd@babel@}
%   {}{}
% \makeatother

%%%%%%%%%%%%%%% Hauptdokument %%%%%%%%%%%%%%%
\begin{document}


% ###### Autoref definitions (hyperref package)#####
\def\subtableautorefname{Table}
\def\algorithmautorefname{Algorithm}
\def\chapterautorefname{Chapter}
\def\sectionautorefname{Section}
\def\definitionautorefname{Definition}
\def\exampleautorefname{Example}
\def\observationautorefname{Observation}
\def\propositionautorefname{Proposition}
\def\lemmaautorefname{Lemma}
% in diesem Dokument nicht verwendet:
% \def\subsectionautorefname{Subsection}
% \def\Subsubsectionautorefname{Subsubsection}
% \def\subfigureautorefname{Figure}
% \def\claimautorefname{Claim}

%%%%%%%%%%%%%%% Deckblatt %%%%%%%%%%%%%%%
\extratitle{}
	\input{files/titlepage}
	%\input{files/titlepage.pdf}	% Rueckseite leer
% 	\input{files/0_deckblatt/title}
	\pagestyle{empty} 	% Rueckseite leer
%
%%%%%%%%%%%%%%% Verzeichnisse %%%%%%%%%%%%%%%
\frontmatter % Abstrakte Gliederungsebene: Anfang des Buches
\renewcommand{\autodot}{}
\tableofcontents		% Rueckseite leer
%\lstlistoflistings % fuer listingsverzeichnis mit package listings

%%%%%%%%%%%%%%% Hauptteil %%%%%%%%%%%%%%%
% Insgesamt ca. 60-100 Seiten Davon mindesten 50% Eigene Arbeit
\mainmatter %Abstrakte Gliederungsebene: Hauptteil des Buches
\pagestyle{fancy}
\pagenumbering{arabic}
\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:

\begin{itemize}
\tightlist
\item
  lowercase letters \(x,y,z\)\\
   refer to real variables and represent the coordinates of a point in
  3D--Space.
\item
  lowercase letters \(u,v,w\)\\
   refer to real variables between \(0\) and \(1\) used as coefficients
  in a 3D B--Spline grid.
\item
  other lowercase letters\\
   refer to other scalar (real) variables.
\item
  lowercase \textbf{bold} letters (e.g. \(\vec{x},\vec{y}\))\\
   refer to 3D coordinates
\item
  uppercase \textbf{BOLD} letters (e.g. \(\vec{D}, \vec{M}\))\\
   refer to Matrices
\end{itemize}

\chapter{Introduction}\label{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 \emph{genome} and \emph{fitness--function}. While one can
typically use an arbitrary cost--function for the
\emph{fitness--functions} (i.e.~amount of drag, amount of space, etc.),
the translation of the problem--domain into a simple parametric
representation (the \emph{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
\emph{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 \emph{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 \emph{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 \emph{regularity}, \emph{variability},
and \emph{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 \emph{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}.

\chapter{Background}\label{background}

\label{sec:back}

\section{\texorpdfstring{What is \acf{FFD}?}{What is ?}}\label{what-is}

\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\)\footnote{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\)\footnote{\emph{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 \textbf{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}.

\subsection{\texorpdfstring{Why is \ac{FFD} a good deformation
function?}{Why is  a good deformation function?}}\label{why-is-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 \emph{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.

\section{What is evolutionary
optimization?}\label{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 \emph{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
\emph{Genotypes} while \(M\) represents the possible observable
\emph{Phenotypes}.

The main algorithm just repeats the following steps:

\begin{itemize}
\tightlist
\item
  \textbf{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.
\item
  \textbf{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.
\item
  \textbf{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.
\end{itemize}

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).

\section{Advantages of evolutionary
algorithms}\label{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.

\section{Criteria for the evolvability of linear
deformations}\label{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.

\subsection{Variability}\label{variability}

In \cite{anrichterEvol} \emph{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\).

\subsection{Regularity}\label{regularity}

\emph{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}.

\subsection{Improvement Potential}\label{improvement-potential}

In contrast to the general nature of \emph{variability} and
\emph{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 \emph{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.

\chapter{\texorpdfstring{Implementation of
\acf{FFD}}{Implementation of }}\label{implementation-of}

\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 \emph{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.

\section{\texorpdfstring{Adaption of
\ac{FFD}}{Adaption of }}\label{adaption-of}

\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\)).

\section{\texorpdfstring{Adaption of \ac{FFD} for a
3D--Mesh}{Adaption of  for a 3D--Mesh}}\label{adaption-of-for-a-3dmesh}

\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.

\section{Deformation Grid}\label{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\footnote{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\footnote{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?}

\chapter{\texorpdfstring{Scenarios for testing evolvability criteria
using
\acf{FFD}}{Scenarios for testing evolvability criteria using }}\label{scenarios-for-testing-evolvability-criteria-using}

\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.

\section{Test Scenario: 1D Function
Approximation}\label{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}

\textbackslash{}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 \emph{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\footnote{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.

\section{Procedure: 1D Function
Approximation}\label{procedure-1d-function-approximation}

For our setup we first compute the coefficients of the
deformation--matrix and use then the formulas for \emph{variability} and
\emph{regularity} to get our predictions. Afterwards we solve the
problem analytically to get the (normalized) correct gradient that we
use as guess for the \emph{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\)\footnote{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}.

\section{Test Scenario: 3D Function
Approximation}\label{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
\emph{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 \emph{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.}

\section{Procedure: 3D Function
Approximation}\label{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
\emph{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}

\chapter{Evaluation of Scenarios}\label{evaluation-of-scenarios}

\label{sec:res}

\section{Spearman/Pearson--Metriken}\label{spearmanpearsonmetriken}

\begin{itemize}
\tightlist
\item
  Was ist das?
\item
  Wieso sollte uns das interessieren?
\item
  Wieso reicht Monotonie?
\item
  Haben wir das gezeigt?
\item
  Statistik, Bilder, blah!
\end{itemize}

\section{Results of 1D Function
Approximation}\label{results-of-1d-function-approximation}

\begin{figure}[!ht]
\includegraphics[width=\textwidth]{img/evolution1d/20171005-all_appended.png}
\caption{Results 1D}

\end{figure}

\section{Results of 3D Function
Approximation}\label{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}

\chapter{Schluss}\label{schluss}

\label{sec:dis}

HAHA .. als ob -.-

% \backmatter
\cleardoublepage

\renewcommand\thechapter{\Alph{chapter}}
\chapter*{Appendix}
\addcontentsline{toc}{chapter}{\protect\numberline{}Appendix}
\addtocontents{toc}{\protect\setcounter{tocdepth}{1}}
\setcounter{chapter}{0} % reset section to 1 so its stars I, II, III,...
\pagenumbering{roman}
%%%%%%%%%%%%%%% Literaturverzeichnis %%%%%%%%%%%%%%%
    \bibliographystyle{unsrtdin} % 	\bibliographystyle{natdin}
    \bibliography{bibma}
    % \addcontentsline{toc}{chapter}{\protect\numberline{\thechapter}Bibliography} % Literaturverzeichnis in das Inhaltsverzeichnis aufnehmen
    % \addtocounter{chapter}{1}
    \newpage

%%%%%%%%%%%%%%% Anhang %%%%%%%%%%%%%%%
%    \clearpage					%spaeter alles wieder rein
% % 		\input{files/appendix}
    \input{settings/abkuerzungen}
    % \addcontentsline{toc}{chapter}{\protect\numberline{\thechapter}Abbreviations}
    % \addtocounter{chapter}{1}
    \newpage

    % \listofalgorithms
    % \addcontentsline{toc}{section}{\protect\numberline{\thesection}List of Algorithms}
    % \addtocounter{section}{1}
    % \newpage
	%
	\listoffigures
    % \addcontentsline{toc}{chapter}{\protect\numberline{\thechapter}List of Figures}
    % \addtocounter{chapter}{1}
    \newpage
	% \listoftables
	\listoftodos
    % \addcontentsline{toc}{chapter}{\protect\numberline{\thechapter}TODOs}
    % \addtocounter{chapter}{1}
    \newpage
% 	\printindex

%%%%%%%%%%%%%%% Erklaerung %%%%%%%%%%%%%%%
% 	*\input{settings/declaration}
	\include{files/erklaerung}
\end{document}