Added _minted* to gitignore

Signed-off-by: Jim Martens <github@2martens.de>

.gitignore

@@ -4,9 +4,13 @@
 *.aux
 *.bak
 *.bbl
+*.bcf
 *.blg
+*.bmp
 *.dvi
+*.exe
 *.fdb_latexmk
+*.fls
 *.glg
 *.glo
 *.gls
@@ -14,10 +18,13 @@
 *.ilg
 *.ind
 *.ist
+*.jpg
+*.JPG
 *.lof
 *.log
 *.lot
 *.maf
+*.mp4
 *.mtc
 *.mtc0
 *.nav
@@ -25,12 +32,20 @@
 *.out
 *.pdf
 *.pdfsync
+*.png
 *.ps
+*.pyg
+*.run.xml
 *.snm
 *.synctex.gz
 *.toc
 *.vrb
+*.xcf
 *.xdy
 *.tdo
 *.zip
-*~
+build/
+cmake-build-debug/
+env/
+ENV/
+_minted*/

README.md

@@ -1,4 +1,13 @@
 uni
 ===
 
-University stuff
+Aus gegebenem Anlass:
+
+Die in diesem Repository zu findenen Latex- und .rkt-Dateien sind Hausaufgaben. Zum Zwecke der Zusammenarbeit innerhalb 
+**meiner** Gruppe werden auch Dateien hochgeladen, deren Abgabedeadline noch nicht erreicht ist.
+
+Es nutzt anderen Gruppen kein Stück diese noch ausstehenden Abgaben 1:1 zu kopieren, die Namen zu ändern und als ihre 
+eigene Arbeit auszugeben. Denn dann bekommen beide Gruppen keine Punkte. Da dies so in GDB passiert ist, werden die entsprechenden
+Latexdateien für GDB ab sofort erst nach der Abgabedeadline hochgeladen. Es ist bedauerlich, dass einige Personen in dieser
+Hinsicht derartig dumm sind. Es spricht nichts dagegen sich die von mir bearbeiteten Abgaben anzusehen und sich Ideen zu holen.
+Identische Kopien sind aber in keinem Falle angebracht.

ad/AD-Gruppe_8_Koehler_Krabbe_Martens_Blatt4.tex

@@ -0,0 +1,334 @@
+\documentclass[10pt,a4paper,oneside,ngerman,numbers=noenddot]{scrartcl}
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{bytefield}
+\usepackage{paralist}
+\usepackage{gauss}
+\usepackage{pgfplots}
+\usepackage{textcomp}
+\usepackage[locale=DE,exponent-product=\cdot,detect-all]{siunitx}
+\usepackage{tikz}
+\usepackage{algorithm}
+\usepackage{algorithmic}
+\usetikzlibrary{automata,matrix,fadings,calc,positioning,decorations.pathreplacing,arrows,decorations.markings}
+\usepackage{polynom}
+\polyset{style=C, div=:,vars=x}
+\pgfplotsset{compat=1.8}
+\pagenumbering{arabic}
+\def\thesection{\arabic{section})}
+\def\thesubsection{(\alph{subsection})}
+\def\thesubsubsection{(\roman{subsubsection})}
+\makeatletter
+\renewcommand*\env@matrix[1][*\c@MaxMatrixCols c]{%
+  \hskip -\arraycolsep
+  \let\@ifnextchar\new@ifnextchar
+  \array{#1}}
+\makeatother
+\parskip 12pt plus 1pt minus 1pt
+\parindent 0pt
+
+\begin{document}
+\author{Reinhard Köhler (6425686), Tronje Krabbe (6435002), \\
+Jim Martens (6420323)}
+\title{Hausaufgaben zum 4. Dezember}
+\subtitle{Gruppe 8}
+\maketitle
+\section{} %1
+	\subsection{} %a
+		Der Algorithmus funktioniert nicht mehr. Dies wird anhand dieses Gegenbeispiels deutlich:
+		
+		\begin{verbatim}
+		    A = [0,1,4,8,10,13]
+		    value = 1
+		    low = 0
+		    high = 5
+		    // erster Schleifendurchlauf 0 < 5, daher Rumpf ausführen
+		    mid = (0 + 5) / 2 = 2
+		    // A[2] = 4 > value
+		    high = 2 - 1 = 1
+		    // zweiter Schleifendurchlauf 0 < 1, daher Rumpf ausführen
+		    mid = (0 + 1) / 2 = 0
+		    // A[0] = 0 < value
+		    low = 0 + 1 = 1
+		    // dritter Schleifendurchlauf 1 = 1, daher Rumpf nicht ausführen
+		    return not_found
+		\end{verbatim}
+		
+		Obwohl das Element vorhanden ist, wird zurückgegeben, dass es nicht vorhanden sei. Da es ein Gegenbeispiel gibt, funktioniert der Algorithmus nach der Änderung von \texttt{while (low <= high)} zu \texttt{while (low < high)} nicht mehr.
+	\subsection{} %b
+		\begin{verbatim}
+		    BinarySearch(A[0..N-1], value) {
+		        low = N - 1
+		        high = 0
+		        while (high <= low) {
+		            // invariants: value > A[i] for all i < low
+		                           value < A[i] for all i > high
+		            mid = (low + high) / 2
+		            if (A[mid] > value)
+		                high = mid + 1
+		            else if (A[mid] < value)
+		                low = mid - 1
+		            else
+		                return mid
+		        }
+		        return not_found
+		    }
+		\end{verbatim}
+	\subsection{} %c
+		\textbf{Formaler Beweis:} Wir müssen beweisen, dass die while-Schleife endet. Angenommen wir befinden uns in Iteration $i$ der while-Schleife.
+		\begin{itemize}
+			\item	Zu Beginn der while-Schleife haben wir \texttt{high $\leq$ low} (andernfalls hätten wir die while-Schleife nicht betreten).
+			\item	Nach dem Ausdruck \texttt{mid = (low + high) / 2} gilt \texttt{high $\leq$ mid $\leq$ low}.
+			\item	Entweder die Schleife wird durch die Rückgabe von \texttt{mid} beendet, womit wir fertig wären.
+			\item	Oder sie befindet sich in einer der ersten beiden Fälle des if-Statements. Entweder high wird um mindestens eins erhöht oder low wird um mindestens eins verkleinert, wodurch sich in jedem Schleifendurchlauf die Differenz von \texttt{low - high} um mindestens eins verringert.
+			\item	Damit gilt \texttt{low - high < 0} nach maximal $n$ Iterationen der while-Schleife und die Schleife terminiert.
+		\end{itemize}
+	\subsection{} %d
+		\textbf{Beweis der Korrektheit:}
+		
+		Offensichtlich gibt der Algorithmus ein korrektes Ergebnis zurück, wenn \texttt{mid} zurückgegeben wird, da dann \texttt{A[mid] $=$ value} gilt.
+		
+		Zu zeigen: Wenn der Algorithmus \texttt{not\_found} zurückgibt, dann kommt \texttt{value} tatsächlich nicht in dem Array vor.
+		
+		Wir werden dies nun durch die Gegenposition beweisen: Wir müssen zeigen, dass wenn \texttt{value} im Array vorkommt, der Algorithmus \texttt{mid} zurückgibt.
+		
+		\textbf{Erster Schritt:} Es ist einfach zu sehen, dass die folgenden Invarianten immer gelten:
+		\begin{itemize}
+			\item	\texttt{value > A[i] for all i < low (strict inequality!)}
+			\item	\texttt{value < A[i] for all i > high (strict inequality!)}
+		\end{itemize}
+		
+		\textbf{Zweiter Schritt:} Annahme, dass \texttt{value} im Array vorkommt.
+		\begin{itemize}
+			\item	Bereits bekannt: Invarianten sind wahr. Das bedeutet zu keinem Zeitpunkt im Algorithmus kann sich das Element, das wir suchen, links von \texttt{high} oder rechts von \texttt{low} befinden.
+			\item	Der einzige Weg, wie wir theoretisch das gesuchte Element "`verpassen"' könnten, wäre, dass \texttt{high = mid + 1} oder \texttt{low = mid - 1} zu der Situation führen, dass \texttt{high > low} gilt bevor wir das gesuchte Element gefunden haben (weil wir dann die Schleife verlassen).
+			\begin{itemize}
+				\item	Durch die Konstruktion des Algorithmus haben wir immer \texttt{high $\leq$ mid $\leq$ low} nachdem \texttt{mid = (low + high) / 2} ausgeführt wurde.
+				\item	Solange \texttt{low $\geq$ high + 2} gilt, haben wir immer \texttt{high < mid < low}.
+				In dieser Situation, \texttt{mid - 1 $\geq$ high} und \texttt{mid + 1 $\leq$ low}, haben wir immer noch \texttt{high $\leq$ low} nachdem entweder \texttt{high = mid + 1} oder \texttt{low = mid - 1} ausgeführt wurden, sodass die while-Schleife ein weiteres Mal betreten wird.
+
+				Es gibt zwei kritische Fälle, in denen wir die Schleife verlassen könnten:
+				\begin{itemize}
+					\item	\texttt{low = high}. Aber dann gilt auch \texttt{mid = high}. Nach der Annahme, dass \texttt{value} im Array ist, muss \texttt{A[high] = value} gelten. Durch die Rückgabe von \texttt{mid} wird demnach genau der richtige Index zurückgegeben.
+					\item	\texttt{low = high + 1}. In diesem Fall gilt \texttt{mid = high}. Nun gilt entweder \texttt{A[high] = A[mid] = value}, wodurch durch Rückgabe von \texttt{mid} das richtige Ergebnis zurückgegeben würde, oder es gilt \texttt{A[high] = A[mid] > value}, wodurch \texttt{high} um eins erhöht würde, was beim nächsten Schleifendurchlauf im Fall \texttt{low = high} enden würde. In dem Fall wird das korrekte Ergebnis zurückgegeben, wie bereits gezeigt wurde.
+				\end{itemize}
+			\end{itemize}
+			\item	Dies zeigt, dass wenn \texttt{value} im Array vorhanden ist, der Algorithmus immer damit endet \texttt{mid} zurückzugeben.
+		\end{itemize}
+\section{} %2
+	\subsection{} %a
+		\subsubsection{} %i
+			In einem Graph ohne Kanten kann jeder Knoten gleich gefärbt sein. Dies gilt, weil die Bedingung $c_{k}(i= \neq c_{k}(j)$ nur gilt, wenn $i$ und $j$ mit einer Kante verbunden sind, was in solch einem Graphen nicht gegeben ist. Daher ist hier nichts zu zeigen.
+		\subsubsection{} %ii
+			Wenn ein Graph k-färbbar ist, dann kann man auch eine weitere Farbe in die Abbildung $c_{k}$ hinzunehmen ohne sie zu benutzen. Dies gilt da $c_{k}$ nicht surjektiv sein muss.
+		\subsubsection{} %iii
+			Man nehme einen k-färbbaren Graphen. Nun kann man solange weitere Farben hinzufügen, bis n Farben in der Abbildung vorkommen. Diese müssen jedoch nicht benutzt werden. Daher ist jeder Graph n-färbbar.
+	\subsection{} %b
+		\subsubsection{} %i
+			Wenn ein Graph 2-färbbar ist, dann gibt es keine Zyklen ungerader Länge. Bei einem Zyklus gerader Länge kann jeder zweiter Knoten die gleiche Farbe haben, ohne mit einem Knoten verbunden zu sein, der die gleiche Farbe hat.
+			
+			Alle Knoten mit einer Farbe kann man als eine Untermenge einer Abbildung eines bipartiten Graphen verstehen.
+		\subsubsection{} %ii
+			\begin{verbatim}
+			    IST_2FAERBUNG(G) {
+			        kanten = E(G)
+			        valid = true
+			        farben = new Set()
+			        foreach kante in kanten {
+			            knoten1 = kante.knoten1
+			            knoten2 = kante.knoten2
+			            farben.add(knoten1.farbe)
+			            farben.add(knoten2.farbe)
+			            if (knoten1.farbe == knoten2.farbe) {
+			                valid = false
+			                break
+			            }
+			        }
+			        
+			        return (valid && (farben.getAnzahl() == 2))
+			    }
+			\end{verbatim}
+		\subsubsection{} %iii
+			Es gibt 2 verschiedene 2-Färbungen, sofern man unterschiedliche Farben nicht als Unterschied ansieht. Pro 2 Farben gibt es genau 2 verschiedene Färbungen.
+	\subsection{} %c
+		Bei einer beliebigen Landkarte werden mindestens vier Farben benötigt, damit direkt benachbarte Länder stets unterschiedliche Farben haben.
+		\subsubsection{} %i
+			\begin{tikzpicture}
+				\node (altona) {A};
+				\node (eimsbuettel) [above right=of altona] {E};
+				\node (nord) [right=of eimsbuettel] {N};
+				\node (wandsbek) [right=of nord] {W};
+				\node (mitte) [below=of eimsbuettel] {M};
+				\node (harburg) [below left=of mitte] {H};
+				\node (bergedorf) [below right=of mitte] {B};
+				
+				\path[every node/.style={font=\scriptsize}] 
+					(altona) edge (mitte)
+					(altona) edge (eimsbuettel)
+					(mitte) edge (harburg)
+					(mitte) edge (bergedorf)
+					(mitte) edge (eimsbuettel)
+					(mitte) edge (nord)
+					(mitte) edge (wandsbek)
+					(eimsbuettel) edge (nord)
+					(nord) edge (wandsbek);
+			\end{tikzpicture}
+		\subsubsection{} %ii
+			\begin{alignat*}{2}
+				c_{k}(A) &=& gelb \\
+				c_{k}(E) &=& rot \\
+				c_{k}(M) &=& blau \\
+				c_{k}(H) &=& rot \\
+				c_{k}(B) &=& rot \\
+				c_{k}(N) &=& gelb \\
+				c_{k}(W) &=& rot
+			\end{alignat*}
+		\subsubsection{} %iii
+			Die Aussage, dass vier Farben minimal sind, besagt nur, dass man es bei einer beliebigen Landkarte schafft diese mit maximal vier Farben zu färben. Es gibt die Obergrenze der nötigen Farben an. Die Regel besagt hingegen nicht, dass immer mindestens vier Farben benötigt werden. Bei einer Landkarte mit nur zwei aneinandergrenzenden Ländern reichen auch zwei Farben. Bei einer Karte mit nur einer zusammenhängenden Fläche ohne angrenzende Flächen reicht sogar eine Farbe.
+		\subsubsection{} %iv
+			\begin{tikzpicture}
+				\node (sh) {SH};
+				\node (hh) [below right=of sh] {HH};
+				\node (meck) [right=of hh] {MP};
+				\node (bremen) [below left=of hh] {B};
+				\node (nieder) [below=of hh] {N};
+				
+				\path[every node/.style={font=\scriptsize}] 
+					(sh) edge (hh)
+					(sh) edge (meck)
+					(hh) edge (nieder)
+					(bremen) edge (nieder)
+					(sh) edge (nieder)
+					(bremen) edge (sh)
+					(bremen) edge (hh);
+			\end{tikzpicture}
+			
+			In dieser konstruierten Karte (dargestellt als Graph), müssen mindestens vier Farben verwendet werden.
+\section{} %3
+	\subsection{} %a
+		\[
+			G_{1}: 1, 3, 4, 5, 2, 8, 6, 7
+		\]
+		\[
+			G_{2}: 1, 3, 5, 6, 4, 7, 2
+		\]
+	\subsection{} %b
+		\[
+			G_{1}: 4, 3, 7, 6, 8, 2, 5, 1
+		\]
+		\[
+			G_{2}: 4, 6, 5, 3, 2, 7, 1
+		\]
+	\subsection{} %c
+		\[
+			G_{1}: 1, 3, 5, 4, 2, 7, 8, 6
+		\]
+		\[
+			G_{2}: 1, 3, 4, 7, 5, 2, 6
+		\]
+	\subsection{} %d
+            Für $G_1$ existiert keine topologische Sortierung, da es sich nicht um einen DAG (Directed acyclic graph) handelt. Dies erkennt man daran, dass beispielsweise ein Zyklus von 1 über 5 über 2 zurück zur 1 existiert. $\square$
+            
+            Für $G_2$ existieren topologische Sortierungen, z.B.:
+            \[
+                1, 3, 5, 6, 4, 7, 2
+            \]
+        \subsection{} %e
+            Wie  bereits etabliert, existieren für $G_1$ keine mit ihm konsistenten topologischen Sortierungen. Für $G_2$ allerdings existieren mehrere:
+            
+          Nach Proposition 5 (Uniqueness of topological Sort) im Skript, Folie 163, ist eine topologische Sortierung nur eindeutig, wenn der dazugehörige Graph einen Hamilton-Kreis enthält. $G_2$ enthält keinen Hamilton-Kreis. Dies ist leicht zu erkennen: es gibt keinen Pfad in dem Graphen, der die Knoten $2$ \textit{und} $3$ besucht. Daher gibt es mehrere topologische Sortierungen.
+          
+          Eine weitere wäre z.B.:
+          \[
+                1, 7, 2, 5, 6, 4, 3
+          \]
+	\subsection{} %f
+		starke Zusammenhangskomponenten von $G_{1}:$
+		\begin{alignat*}{2}
+			comp1:&&\; 1, 2, 5, 6, 7, 8 \\
+			comp2:&&\; 3 \\
+			comp3:&&\; 4
+		\end{alignat*}
+		
+		starke Zusammenhangskomponenten von $G_{2}:$
+		\begin{alignat*}{1}
+			comp1: 1 \\
+			comp2: 2 \\
+			comp3: 3 \\
+			comp4: 4 \\
+			comp5: 5 \\
+			comp6: 6 \\
+			comp7: 7
+		\end{alignat*}
+\section{} %4
+	\subsection{} %a
+        % Senken finden (alle Senken infiltrieren, dadurch werden alle Module eliminiert)
+        % Algorithmus aus Vorlesung benutzen
+        Es müssen alle Module (oder Knoten) ohne eingehende Kanten eliminiert (bzw. markiert) werden, da diese andernfalls nie erreicht werden können. Zu allen anderen Knoten muss es gerichtete Pfade von einem dieser Knoten geben. Ausnahmen können starke Zusammenhangskomponenten bilden. In jeder starken Zusammenhangskomponente wird daher ebenfalls ein Knoten eliminiert.
+        \newpage
+        \begin{verbatim}
+            function eliminiereMCP() {
+                int zaehler = 0
+
+                list infiltrierteKnoten
+                // füge alle Knoten ohne Vorgänger hinzu:
+                for-all v in Knotenmenge:
+                    if v.eingehendeKanten == 0:
+                        infiltriere(v)
+                        infiltrierteKnoten.add(v)
+                    end if
+                end for-all
+                // füge einen Knoten aus jeder
+                // starken Zusammenhangskomponente hinzu:
+                list starkZusammenhaengend = findeStarkeZusammenhangskomponenten()
+                for-all elemente in starkZusammenhaengend:
+                    for i = 0; i < elemente.length; i++
+                        if infiltrierteKnoten.contains(elemente[i]):
+                            zaehler++
+                        end if
+                        if zaehler == 0:
+                            infiltriere(elemente[0])
+                            infiltrierteKnoten.add(elemente[0])
+                        end if
+                    end for
+                end for-all
+                eliminiere(infiltrierteKnoten)
+            }
+                \end{verbatim}
+	\subsection{} %b
+		Wenn alle Senken infiltriert werden, werden dadurch alle Module eliminiert, da alle Module direkt oder indirekt mit mindestens einer Senke verbunden sind.
+	\subsection{} %c
+		Es müssen alle Senken infiltriert werden, da ansonsten einzelne Module nicht eliminiert werden könnten.
+	
+\section*{Zusatzaufgabe} %Zusatz
+		
+	Beweis der Terminierung für beliebige natürliche Zahlen größer $0$.\\
+	Trivialer Fall: \\
+	Der Algorithmus terminiert für $n=1$. \\
+	Zweiter Fall: \\
+	Der Algorithmus terminiert für $2^{c} = n$. Dies gilt, da damit nach $c$ Rekursionsschritten immer $n=1$ gilt. \\
+	Dritter Fall: \\
+	Es ist zu zeigen, dass nach endlich vielen Rekursionsschritten \textsc{Coll} mit einer 2er-Potenz aufgerufen wird.
+	
+	Dazu lohnt es sich die verbleibenden Zahlen bis 10 anzuschauen.
+	\begin{alignat*}{2}
+		3 \rightarrow 10 \rightarrow 5 \rightarrow 16 \\
+		5 \rightarrow 16 \\
+		6 \rightarrow 3 \\
+		7 \rightarrow 22 \rightarrow 11 \rightarrow 34 \rightarrow 17 \rightarrow 52 \rightarrow 26 \rightarrow 13 \rightarrow 40 \rightarrow 20 \rightarrow 10 \rightarrow 5 \rightarrow 16 \\
+		9 \rightarrow 28 \rightarrow 14 \rightarrow 7 \\
+		10 \rightarrow 5
+	\end{alignat*}
+	
+	Was kann aus dieser Reihe geschlossen werden? Alle Zahlen, die aus dem Produkt einer 2er-Potenz und einer dieser Zahlen entstehen, lassen sich auf eine 2er-Potenz zurückführen. Auf diese Weise könnte man für die ersten $d$ natürlichen Zahlen zeigen, dass sie sich alle auf eine 2er-Potenz zurückführen lassen.
+	
+	Aufgrund dieser Annahme steigt die Wahrscheinlichkeit bei einem Rekursionsaufruf mit $3n+1$ auf ein solches Vielfaches einer bereits auf eine 2er-Potenz zurückgeführte Zahl zu stoßen.
+	
+	Da es jedoch unendlich viele Primzahlen gibt, wenngleich sich deren Abstand zueinander immer weiter erhöht, findet man immer Zahlen, die noch nicht auf eine 2er-Potenz zurückgeführt sind. Aufgrund dieser Tatsache kann es keine allgemeingültige Aussage für alle natürlichen Zahlen geben. Allerdings kann dieser Algorithmus selbst als Antwort verstanden werden. Für eine beliebig große Zahl, die nicht ein gerades Vielfaches einer bereits zurückgeführten Zahl ist, muss daher nur der Algorithmus ausgeführt werden bis ein solches Vielfaches erreicht wurde.
+	
+	Nach endlich vielen Schritten wird dies praktisch der Fall sein, wenngleich die Anzahl dieser Schritte dramatisch zunehmen wird. Es ist jedoch nicht möglich dafür einen theoretischen Beweis zu finden, der ebenjene Tatsache darlegen kann.
+\end{document}

ad/AD-Gruppe_8_Koehler_Krabbe_Martens_Blatt5.tex

@@ -0,0 +1,300 @@
+\documentclass[10pt,a4paper,oneside,ngerman,numbers=noenddot]{scrartcl}
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{bytefield}
+\usepackage{paralist}
+\usepackage{gauss}
+\usepackage{pgfplots}
+\usepackage{textcomp}
+\usepackage[locale=DE,exponent-product=\cdot,detect-all]{siunitx}
+\usepackage{tikz}
+\usepackage{algorithm}
+\usepackage{algorithmic}
+\usepackage{minted}
+\usetikzlibrary{automata,matrix,fadings,calc,positioning,decorations.pathreplacing,arrows,decorations.markings}
+\usepackage{polynom}
+\polyset{style=C, div=:,vars=x}
+\pgfplotsset{compat=1.8}
+\pagenumbering{arabic}
+\def\thesection{\arabic{section})}
+\def\thesubsection{(\alph{subsection})}
+\def\thesubsubsection{(\roman{subsubsection})}
+\makeatletter
+\renewcommand*\env@matrix[1][*\c@MaxMatrixCols c]{%
+  \hskip -\arraycolsep
+  \let\@ifnextchar\new@ifnextchar
+  \array{#1}}
+\makeatother
+\parskip 12pt plus 1pt minus 1pt
+\parindent 0pt
+
+\begin{document}
+\author{Reinhard Köhler (6425686), Tronje Krabbe (6435002), \\
+Jim Martens (6420323)}
+\title{Hausaufgaben zum 4. Dezember}
+\subtitle{Gruppe 8}
+\maketitle
+
+\section{} %1
+	Dieser folgende Pseudocode beschreibt eine leichte Abänderung, die vorzeitig abbricht, wenn sich nach einem kompletten Durchlauf aller Kanten nichts geändert hat. Nach $m$ Durchläufen hat der Algorithmus alle kürzeste Pfade mit maximal $m$ Kanten entdeckt. In einem weiteren Durchlauf wird sich dann nichts mehr ändern, da keine neuen kürzesten Pfade mehr gefunden werden können, wodurch die geänderte Variante abbricht. Um die Abbruchbedingung zu erreichen muss $m$ nicht bekannt sein, da nach $m+1$ Durchläufen die Abbruchbedingung immer gegeben ist.
+	\begin{minted}{python}
+function BellmanFord(G,s)
+    InitializeSingleSource(G,s)
+    for i = 1, ... |V| - 1
+        changed = false	            
+        for all edges (u,v) in E
+            changedTmp = Relax(u,v)
+            if (!changed)
+                changed = changedTmp
+        if (!changed)
+            break
+    for all edges (u,v) in E
+        if v.dist > u.dist + w(u,v)
+            return false
+    return true
+	\end{minted}
+	% \begin{verbatim}
+	%     function BellmanFord(G,s)
+	%         InitializeSingleSource(G,s)
+	%         for i = 1, ... |V| - 1
+	%             changed = false	            
+	%             for all edges (u,v) in E
+	%                 changedTmp = Relax(u,v)
+	%                 if (!changed)
+	%                     changed = changedTmp
+	%             if (!changed)
+	%                 break
+	%         for all edges (u,v) in E
+	%             if v.dist > u.dist + w(u,v)
+	%                 return false
+	%         return true
+	% \end{verbatim}
+\section{} %2
+	\begin{minted}{python}
+function DAG-SP(G,s)
+    sort vertices topologically
+    InitializeSingleSource(G,s)
+    for each u in V in topological sort order
+        for each v in Adj(u)
+            Relax(u,v)
+	\end{minted}
+	% \begin{verbatim}
+	%     function DAG-SP(G,s)
+	%         sort vertices topologically
+	%         InitializeSingleSource(G,s)
+	%         for each u in V in topological sort order
+	%             for each v in Adj(u)
+	%                 Relax(u,v)
+	% \end{verbatim}
+\section{} %3
+	Wir wissen, dass der Dijkstra-Algorithmus für rein positive Kantengewichte funktioniert. Es bleibt also nur zu zeigen, dass die kürzesten Wege zu den Knoten korrekt berechnet werden, die eine Kante von dem Startknoten entfernt sind. Ferner ist bekannt, dass Dijkstra zuerst den Knoten besucht, der am billigsten zu erreichen ist. Damit geht der Algorithmus die Kante mit dem kleinsten Gewicht zu erst (einschließlich negative Gewichte). Der somit erreichte Knoten kann also gar nicht billiger zu erreichen sein, da jeder andere Pfad dorthin aus mindestens zwei Kanten besteht, die zusammen bestenfalls das gleiche Gewicht haben wie die gegangene Kante.
+	
+	Dies ist so, da die erste Kante vom Startknoten zu einem anderen Knoten minimal so klein sein kann, wie die zuerst gegangene Kante, da andernfalls die zuerst gegangene Kante nicht das geringste Gewicht gehabt hätte. Die zweite Kante muss mindestens 0 als Gewicht haben, womit nur ein gleich großes oder größeres Gesamtgewicht entstehen kann, als durch die zuerst gegangene Kante verwendet wurde.
+\section{} %4
+	\subsection{} %a
+		In einem Baum gibt es keine Zyklen. Daher gibt es genau einen direkten Weg (ohne Umwege mit mehrmaligem Besuchen eines Knotens) zu jedem Knoten von dem Wurzelknoten aus. Demnach müssen einfach vom Wurzelknoten aus alle Knoten besucht werden. Dabei wird ähnlich wie in der Breitensuche vorgegangen, indem zunächst alle Knoten, die direkt mit dem Wurzelknoten per Kante verbunden sind, besucht werden und anschließend alle Knoten, die zwei Kanten vom Wurzelknoten entfernt sind, etc. Dabei wird eine Variable zu Beginn auf 0 gesetzt und bei jedem Knoten wird geschaut, ob seine Entfernung zum Wurzelknoten größer ist als diese Variable. Wenn dem so ist, dann wird die Variable entsprechend angepasst. Nach einmaligem Besuchen jedes Knotens hat man damit die längste Entfernung eines Knotens von dem Wurzelknoten ermittelt.
+		
+		In Pseudocode sieht das dann so aus:
+
+		\begin{minted}{python}
+function berechneDurchmesser(G)
+    longestPath = 0
+    current = G.root
+    queue.enqueue(current.getChilds())
+    while (!empty(queue))
+        current = queue.dequeue()
+	        parent = current.parent
+	        distance = parent.getDistance() + w(parent,current)
+	        current.setDistance(distance)
+        if (distance > longestPath)
+            longestPath = distance
+        
+        childs = current.getChilds()
+        if (!empty(childs))
+            queue.enqueue(current.getChilds())
+		\end{minted}
+		% \begin{verbatim}
+		%     function berechneDurchmesser(G)
+		%         longestPath = 0
+		%         current = G.root
+		%         queue.enqueue(current.getChilds())
+		%         while (!empty(queue))
+		%             current = queue.dequeue()
+		%    	        parent = current.parent
+		%    	        distance = parent.getDistance() + w(parent,current)
+		%    	        current.setDistance(distance)
+		%             if (distance > longestPath)
+		%                 longestPath = distance
+		            
+		%             childs = current.getChilds()
+		%             if (!empty(childs))
+		%                 queue.enqueue(current.getChilds())
+		% \end{verbatim}
+	\subsection{} %b
+		\begin{minted}{python}
+def Durchmesser(G):
+	laengsterWeg = 0
+	for v1 in G.kanten:
+		for v2 in G.kanten with v1 != v2:
+			P = findeKuerzestenWeg(v1, v2)
+			if P.laenge() > laengsterWeg:
+				laengsterWeg = P.laenge()
+	return laengsterWeg
+		\end{minted}
+		% \begin{verbatim}		
+		% Diam(G)
+		%     longestPath = 0
+		%     for each v1 in G.vertices
+		%         for each v2 in G.vertices with v1 != v2
+		%             find shortest path P from v1 to v2
+		%             if P.length > longestPath
+		%                 longestPath = P.length
+		%     return longestPath
+  %   	\end{verbatim}
+    	
+    	Die Laufzeit dieses Algorithmus beträgt $\mathcal{O}(|V|^3)$.
+\section{} %5
+	\subsection{} %a
+		Man konstruiert einen vollständigen Graphen aus der Matrix, in welchem die Knoten Währungen repräsentieren, und als Kantengewichte die Werte verwendet werden.
+		Gibt es nun in diesem Graphen einen Zyklus, in dem das Produkt aller Kantengewichte ungleich 1 ist, existiert Währungsarbitrage. Ansonsten ist dies nicht der Fall.
+	\subsection{} %b
+		Nein, unsere Lösung kann nicht zu negativen Zyklen führen, denn dafür müssten negative Werte in der Matrix vorhanden sein.
+		Würden solche Zyklen existieren, bedeuteten sie, man verliere all sein Geld bei einem Tausch, und müsste außerdem eine Strafe zahlen.
+\section{} %6
+		\begin{tikzpicture}[shorten >=1pt,node distance=1.1cm]
+			\node[state] (s) {s};		
+			\node[state] (a) [above right=1.5 and 1.0 of s] {A};
+			\node[state] (b) [below right=1.5 and 1.0 of s] {B};
+			\node[state] (d) [above right=1.0 and 1.0 of a] {D};
+			\node[state] (c) [right=of a] {C};
+			\node[state] (f) [below right=1.0 and 1.25 of a] {F};
+			\node[state] (e) [right=1.0 of c] {E};
+			\node[state] (g) [right=of f] {G};
+			
+			\path[every node/.style={font=\scriptsize},->] 	
+				(s) edge node [above] {30} (a)
+				(s) edge node [below] {18} (b)
+				(a) edge node [above] {21} (c)
+				(a) edge node [above] {38} (d)
+				(a) edge node [below] {22} (f)
+				(c) edge node [right] {22} (f)
+				(c) edge node [above] {20} (e)
+				(f) edge node [above] {9} (g)
+				(b) edge node [left] {30} (a);
+		\end{tikzpicture}
+		
+		Da dies ein gerichteter Graph ohne Zyklen ist und auch keine negativen Kantengewichte vorkommen, kann der Dijkstra-Algorithmus angewendet werden. Da von 9 bis 17 Uhr Fahrer bezahlt werden müssen, kommen nur die Pfade in Betrachtung, die zu einer Senke führen. Senken sind D, E und G. Derjenige dieser Knoten welcher als erster vom Algorithmus gefunden wird (über den eindeutig bestimmbaren Weg), ist auch der kürzeste Pfad vom Startknoten aus, der die Bedingungen erfüllt.
+		
+		Es ergibt sich folgende Abfolge:
+		\begin{verbatim}
+		S = {s}
+		d(s) = 0
+		while 1.
+		    U = {A, B}
+		    for all u in U -> u = A
+		        for all pre(u) in S that are predecessors of u -> pre(u) = s
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 0 + 30
+		    for all u in U -> u = B
+		        for all pre(u) in S that are predecessors of u -> pre(u) = s
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 0 + 18
+		    u* = B
+		    d(u*) = 18
+		    S = {s, B}
+		while 2.
+		    U = {A}
+		    for all u in U -> u = A
+		        for all pre(u) in S that are predecessors of u -> pre(u) = s
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 0 + 30
+		        for all pre(u) in S that are predecessors of u -> pre(u) = B
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 18 + 30
+		    u* = A
+		    d(u*) = 30
+		    S = {S, B, A}
+		while 3.
+		    U = {D, C, F}
+		    for all u in U -> u = D
+		        for all pre(u) in S that are predecessors of u -> pre(u) = A
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 30 + 38
+		    for all u in U -> u = C
+		        for all pre(u) in S that are predecessors of u -> pre(u) = A
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 30 + 21
+		    for all u in U -> u = F
+		        for all pre(u) in S that are predecessors of u -> pre(u) = A
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 30 + 22
+		    u* = C
+		    d(u*) = 51
+		    S = {s, B, A, C}
+		while 4.
+		    U = {D, F, E}
+		    for all u in U -> u = D
+		        for all pre(u) in S that are predecessors of u -> pre(u) = A
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 30 + 38
+		    for all u in U -> u = F
+		        for all pre(u) in S that are predecessors of u -> pre(u) = A
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 30 + 22
+		        for all pre(u) in S that are predecessors of u -> pre(u) = C
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 51 + 22
+		    for all u in U -> u = E
+		        for all pre(u) in S that are predecessors of u -> pre(u) = C
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 51 + 20
+		    u* = F
+		    d(u*) = 52
+		    S = {s, B, A, C, F}
+		while 5.
+		    U = {D, E, G}
+		    for all u in U -> u = D
+		        for all pre(u) in S that are predecessors of u -> pre(u) = A
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 30 + 38
+		    for all u in U -> u = E
+		        for all pre(u) in S that are predecessors of u -> pre(u) = C
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 51 + 20
+		    for all u in U -> u = G
+		        for all pre(u) in S that are predecessors of u -> pre(u) = F
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 52 + 9
+		    u* = G
+		    d(u*) = 61
+		    S = {s, B, A, C, F, G}
+		while 6.
+		    U = {D, E}
+		    for all u in U -> u = D
+		        for all pre(u) in S that are predecessors of u -> pre(u) = A
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 30 + 38
+		    for all u in U -> u = E
+		        for all pre(u) in S that are predecessors of u -> pre(u) = C
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 51 + 22
+		    u* = D
+		    d(u*) = 68
+		    S = {s, B, A, C, F, G, D}
+		while 7.
+		    U = {E}
+		    for all u in U -> u = E
+		        for all pre(u) in S that are predecessors of u -> pre(u) = C
+		            d'(u, pre(u)) = d(pre(u)) + w(pre(u), u)
+		            d'(u, pre(u)) = 51 + 20
+		    u* = E
+		    d(u*) = 71
+		    S = {s, B, A, C, F, G, D, E}
+		\end{verbatim}
+		
+		Wie zu sehen ist wird die Senke G zuerst erreicht. Folgt man dem Weg zu G, so ergibt sich, dass der kürzeste Pfad von s über A und F nach G führt. Weniger Kosten als 61 sind daher nicht möglich.
+\end{document}

ad/AD-Gruppe_8_Koehler_Krabbe_Martens_Blatt6.tex

@@ -0,0 +1,206 @@
+\documentclass[10pt,a4paper,oneside,ngerman,numbers=noenddot]{scrartcl}
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{bytefield}
+\usepackage{paralist}
+\usepackage{gauss}
+\usepackage{pgfplots}
+\usepackage{textcomp}
+\usepackage[locale=DE,exponent-product=\cdot,detect-all]{siunitx}
+\usepackage{tikz}
+\usepackage{algpseudocode}
+\usepackage{algorithm}
+%\usepackage{algorithmic}
+%\usepackage{minted}
+\usetikzlibrary{automata,matrix,fadings,calc,positioning,decorations.pathreplacing,arrows,decorations.markings}
+\usepackage{polynom}
+\polyset{style=C, div=:,vars=x}
+\pgfplotsset{compat=1.8}
+\pagenumbering{arabic}
+\def\thesection{\arabic{section})}
+\def\thesubsection{(\alph{subsection})}
+\def\thesubsubsection{(\roman{subsubsection})}
+\makeatletter
+\renewcommand*\env@matrix[1][*\c@MaxMatrixCols c]{%
+  \hskip -\arraycolsep
+  \let\@ifnextchar\new@ifnextchar
+  \array{#1}}
+\makeatother
+\parskip 12pt plus 1pt minus 1pt
+\parindent 0pt
+
+\begin{document}
+\author{Reinhard Köhler (6425686), Tronje Krabbe (6435002), \\
+Jim Martens (6420323)}
+\title{Hausaufgaben zum 15. Januar}
+\subtitle{Gruppe 8}
+\maketitle
+
+\section{} %1
+	\subsection{} %a
+		\begin{tabular}{c|c|c|c|c|c|c|c|c}
+			EXTRACT & 1 & 2 & 3 & 4 & 5 & 6 & 7 &\\
+			\hline
+			- & 0 & $\infty$ & $\infty$ & $\infty$ & $\infty$ & $\infty$ & $\infty$ & (v.dist) \\
+			& - & - & - & - & - & - & - & (v.$\pi$) \\
+			\hline
+			1 & 0 & 4 & $\infty$ & $\infty$ & $\infty$ & 5 & $\infty$ & \\
+			& - & 1 & - & - & - & 1 & - & \\
+			\hline
+			2 & 0 & 4 & 14 & $\infty$ & $\infty$ & 5 & 7 & \\
+			& - & 1 & 2 & - & - & 1 & 2 & \\
+			\hline
+			6 & 0 & 4 & 14 & $\infty$ & 14 & 5 & 7 & \\
+			& - & 1 & 2 & - & 6 & 1 & 2 & \\
+			\hline
+			7 & 0 & 4 & 13 & $\infty$ & 10 & 5 & 7 & \\
+			& - & 1 & 7 & - & 7 & 1 & 2 & \\
+			\hline
+			5 & 0 & 4 & 12 & 15 & 10 & 5 & 7 & \\
+			& - & 1 & 5 & 5 & 7 & 1 & 2 & \\
+			\hline
+			3 & 0 & 4 & 12 & 14 & 10 & 5 & 7 & \\
+			& - & 1 & 5 & 3 & 7 & 1 & 2 & \\
+			\hline
+			4 & 0 & 4 & 12 & 14 & 10 & 5 & 7 & \\
+			& - & 1 & 5 & 3 & 7 & 1 & 2 & 
+		\end{tabular}
+		
+		Der kürzeste Pfad von 1 nach 4 verläuft über 2, 7, 5 und 3 nach 4. Insgesamt kostet der Pfad 14.
+	\subsection{} %b
+		In $G_{2}$ ist 3 die Quelle. 
+		
+		\begin{tabular}{c|c|c|c|c|c|c|c|c}
+			EXTRACT & 3 & 1 & 2 & 4 & 5 &\\
+			\hline
+			- & 0 & $\infty$ & $\infty$ & $\infty$ & $\infty$ & (v.dist) \\
+			& - & - & - & - & - & (v.$\pi$) \\
+			\hline
+			3 & 0 & $\infty$ & 9 & 4 & $\infty$ & \\
+			& - & - & 3 & 3 & - & \\
+			\hline
+			4 & 0 & 5 & 8 & 4 & 6 & \\
+			& - & 4 & 4 & 3 & 4 & \\
+			\hline
+			1 & 0 & 5 & 8 & 4 & 6 & \\
+			& - & 4 & 4 & 3 & 4 & \\
+			\hline
+			5 & 0 & 1 & 8 & 4 & 6 & \\
+			& - & 5 & 4 & 3 & 4 & \\
+		\end{tabular}
+		
+		Durch die negative Kante von 5 nach 1, würde sich der kürzeste Pfad von 1 von 5 auf 1 ändern, was jedoch nicht geht, da 1 bereits besucht wurde. Daher liefert Dijkstra für das Single-Source-Shortest-Path Problem in $G_{2}$ ein falsches Ergebnis.
+\section{} %2
+	\begin{algorithm}
+		\caption{Relax}
+		\begin{algorithmic}[1]
+			\Procedure{Relax}{$u,v$}
+				\State $maxWeight \gets max(u.maxWeight, w(u,v))$
+				\If{$maxWeight < v.maxWeight$}
+					\State $v.maxWeight \gets w(u,v)$
+					\State $v.\pi \gets u$
+				\EndIf
+			\EndProcedure
+		\end{algorithmic}
+	\end{algorithm}
+	
+	\begin{algorithm}
+		\caption{Initialize single source}
+		\begin{algorithmic}[1]
+			\Procedure{InitializeSingleSource}{$G,s$}
+				\ForAll{$v \in V$}
+					\State $v.maxWeight \gets \infty$
+					\State $v.\pi \gets NIL$
+				\EndFor
+				\State $s.maxWeight \gets 0$
+			\EndProcedure
+		\end{algorithmic}
+	\end{algorithm}
+
+	\begin{algorithm}
+  		\caption{Dijkstra für leichtest mögliche schwerste Kanten}
+		\begin{algorithmic}[1]
+			\Procedure{Dijkstra}{$G,w,s$}
+				\State $\Call{InitializeSingleSource}{G,s}$
+				\State $Q \gets (V, V.maxWeight)$\Comment{ordered by the maximum weight (edge with highest weight) per path in ascending order}
+				\While{$Q \neq \emptyset$}
+					\State $u \gets \Call{Extract}{Q}$
+					\ForAll{v adjacent to u}
+		            	\State $\Call{Relax}{u,v}$ and update the keys in Q accordingly
+					\EndFor
+				\EndWhile
+			\EndProcedure
+		\end{algorithmic}
+	\end{algorithm}
+\section{} %3
+	\subsection{} %a
+		Es sei $B(k)$ die in der Aufgabenstellung formulierte Behauptung in Abhängigkeit von $k$.
+
+	    \textbf{Behauptung}\\ $B(k)$ gilt für alle $k \in \mathbb{N}_{\geq 0}$.
+
+	    \textbf{Induktionsanfang}\\ Zu Zeigen: Es gilt $B(0)$.
+
+	    $A^0$ ist die Einheitsmatrix $E$. Ein Eintrag in $E$ ist genau dann 1, wenn er auf der Hauptdiagonalen liegt, andernfalls ist er 0.
+	    Das bedeutet, dass es über 0 Kanten jeweils genau einen Pfad von einem Knoten $i$ zu einem Knoten $j$ gibt, wenn $i = j$ gilt. Bei 0 Kanten sind
+	    dies genau die Pfade, die in einem beliebigen Graphen möglich sind, da ein Weg zu einem anderen Knoten über mindestens eine Kante gehen würde.
+	    Die Matrix $A^0$ ist also korrekt und $B(0)$ gilt.
+
+	    \textbf{Induktionsschritt} Wir nehmen an, dass $B(k)$ gilt. Zu zeigen ist, dass daraus $B(k+1)$ folgt.
+
+	    Sei $X$ eine Matrix, die erfüllt, dass jeder Eintrag $X[i,j]$ die Anzahl der verschiedenen Pfade vom Knoten $i$ über $k+1$ Kanten zum Knoten $j$ repräsentiert.
+	    Nun ist zu zeigen, dass $X=A^{k+1}$ gilt.
+
+	    Wir betrachten nun einen beliebigen Eintrag $L[i,j]$. Um einen solchen Eintrag zu berechnen, summieren wir zunächst die Anzahlen aller Möglichkeiten,
+	    über $k$ Kanten vom Knoten $i$ zu einem beliebigen Knoten $h$ zu gelangen. Laut Induktionsannahme finden wir genau diese in der Matrix $A$,
+	    im Eintrag $A^k[i,h]$. Die Summe aller dieser Möglichkeiten ist wie folgt definiert:
+
+	    $$\sum_{h=1}^{n}{A^k[i,h]}$$
+
+	    Jetzt wollen wir eine Möglichkeit nur betrachten, wenn eine Kante $(h,j)$ existiert.
+	    Also betrachten wir nur noch die Möglichkeiten, über $k+1$ Kanten vom Knoten $i$ zum Knoten $j$ zu gelangen. Wir definieren das $n$-Tupel $Z$:
+
+	    $$ Z=(z_0, z_1, \cdots, z_n), z_h = \left\{
+	    \begin{array}{l}
+	        1: (h,j) \in G \\
+	        0: (h,j) \notin G
+	    \end{array}\right.$$
+
+	    Wir definieren nun die Einträge der Matrix $X$, in denen jeweils alle korrekten Möglichkeiten aufsummiert werden:
+
+	    $$\sum_{h=1}^{n}{A^k[i,h] \cdot z_h} $$
+
+	    Nun entspricht ein Eintrag der Adjazenzmatrix $A$ an der Stelle $A[h,j]$ laut ihrer Definition genau dem Eintrag $z_h$ in dem $j$ zugehörigen Tupel $Z$.
+	    Wir können also genauso schreiben:
+
+	    $$ \sum_{h=1}^{n}{A^k[i,h] \cdot A[h,j]}$$
+
+	    Dies ist nach der Definition der Matrixmultiplikation äquivalent mit:
+
+	    $$ X = A^k \cdot A = A^{k+1} $$
+
+	    Es wurde also gezeigt, dass $X = A^{k+1}$ gilt, und somit jede Matrix, die unsere Forderungen erfüllt, $A^{k+1}$ sein muss.
+	    Demnach gilt $B(k) \Rightarrow B(k+1)$.
+
+	    Damit ist die Induktion abgeschlossen und die Behauptung bewiesen.$\square$
+	\subsection{} %b
+	\subsection{} %c
+\section{} %4
+	\subsection{} %a
+		Wäre die Last in $W$ aboslut gleich verteilt, hätte natürlich jede Kante die gleiche Last.
+		$ \sum_{p \in W} l(p) $ ist die Summe aller Pfadlängen, also die Anzahl aller verwendeten Kanten.
+		Diese Anzahl wird in einem optimierten Pfadsystem gleichmäßig verteilt, also ergibt sich
+		$ \frac{1}{|E|} \sum_{p \in W} l(p) $ als untere Grenze von $ c(W) $.
+
+		Ist $ W $ jedoch nicht optimal, ist $ c(W) $ natürlich größer. Somit gilt
+		$ c(W) \ge \frac{1}{|E|} \sum_{p \in W} l(p) $.
+	\newpage
+	\subsection{} %b
+		$ c(W) $ ist die größte Kantenlast unter Berücksichtigung aller Kanten in allen Pfaden in $N$. $ c(W^*) $ ist die größte Kantenlast
+		unter Berücksichtigung aller Kanten in allen kürzesten Pfaden in $N$. Dies bedeutet, dass $ c(W) $ die absolute Maximalkantenlast ist,
+		während $ c(W) $ nicht unbedingt alle Kanten berücksichtigt, deswegen auch nicht unbedingt gleich $ c(W) $ ist.
+
+\end{document}

ad/AD-Gruppe_8_Koehler_Krabbe_Martens_Blatt7.tex

@@ -0,0 +1,152 @@
+\documentclass[10pt,a4paper,oneside,ngerman,numbers=noenddot]{scrartcl}
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{bytefield}
+\usepackage{paralist}
+\usepackage{gauss}
+\usepackage{pgfplots}
+\usepackage{textcomp}
+\usepackage[locale=DE,exponent-product=\cdot,detect-all]{siunitx}
+\usepackage{tikz}
+\usepackage{algpseudocode}
+\usepackage{algorithm}
+%\usepackage{algorithmic}
+%\usepackage{minted}
+\usetikzlibrary{automata,matrix,fadings,calc,positioning,decorations.pathreplacing,arrows,decorations.markings}
+\usepackage{polynom}
+\polyset{style=C, div=:,vars=x}
+\pgfplotsset{compat=1.8}
+\pagenumbering{arabic}
+\def\thesection{\arabic{section})}
+\def\thesubsection{(\alph{subsection})}
+\def\thesubsubsection{(\roman{subsubsection})}
+\makeatletter
+\renewcommand*\env@matrix[1][*\c@MaxMatrixCols c]{%
+  \hskip -\arraycolsep
+  \let\@ifnextchar\new@ifnextchar
+  \array{#1}}
+\makeatother
+\parskip 12pt plus 1pt minus 1pt
+\parindent 0pt
+
+\begin{document}
+\author{Reinhard Köhler (6425686), Tronje Krabbe (6435002), \\
+Jim Martens (6420323)}
+\title{Hausaufgaben zum 22. Januar}
+\subtitle{Gruppe 8}
+\maketitle
+
+\section{} %1
+	\subsection{} %a
+		\[
+			(F, H), (E, G), (D, F), (C, E), (E, F), (I, J), (C, B), (B, A), (G, I)
+		\]
+	\subsection{} %b
+		\begin{tikzpicture}
+			\node (A) {$A^{1}$};
+			\node (B) [below=of A] {$B^{0}$};
+			\node (C) [above right=of A] {$C^{3}$};
+			\node (D) [below=of C] {$D^{0}$};
+			\node (E) [right=of D] {$E^{1}$};
+			\node (F) [below=of E] {$F^{0}$};
+			\node (G) [right=of E] {$G^{2}$};
+			\node (H) [below=of G] {$H^{0}$};
+			\node (I) [right=of H] {$I^{1}$};
+			\node (J) [below=of I] {$J^{0}$};
+			
+			\path[->,line width=1pt] 
+			    (B) edge (A)
+			    (D) edge (C)
+			    (F) edge (E)
+			    (H) edge (G)
+			    (J) edge (I)
+			    (E) edge (C)
+			    (I) edge (G)
+			    (A) edge (C)
+			    (G) edge (C);
+		\end{tikzpicture}
+	\subsection{} %c
+		\[
+			(A, B), (B, G), (E, G), (C, E), (E, F), (F, H), (D, F), (A, I), (I, J)
+		\]
+	\subsection{} %d
+		Beim Algorithmus von Prim wird zunächst eine for-Schleife über alle Knoten durchlaufen, welche damit die Laufzeit $\mathcal{O}(|V|)$ hat. Hinzu kommt eine while-Schleife über eine Queue mit initial $|V|$ Einträgen. Damit wird die while-Schleife genau $|V|$ mal durchlaufen, da in jedem Durchgang ein Eintrag entfernt wird. Die Operation deletemin hat eine Laufzeit von $\mathcal{O}(\log V)$, womit die Aufrufe von deletemin insgesamt $\mathcal{O}(V \cdot \log V)$ Zeit erfordern.
+		
+		Die for each Schleife wird \underline{insgesamt} $2|E|$ mal ausgeführt, was $\mathcal{O}(E)$ entspricht. Die decreasekey-Operation hat eine Laufzeit von $\mathcal{O}(\log V)$, womit sich insgesamt eine Laufzeit von $\mathcal{O}(V + V \cdot \log V + E \cdot \log V) = \mathcal{O}(E \cdot \log V)$ ergibt.		
+		
+\section{} %2
+	\begin{algorithmic}[1]
+		\Function{CanBeDivided}{s}
+			\State $l \gets \Call{Length}{s}$
+			\If{\Call{Dict}{s} = 1}
+				\State \Return 1
+			\ElsIf{$l$ = 0}
+				\State \Return 0
+			\Else
+				\State $Q \gets \Call{CreateQueue}$
+				\For{$i = 1 ... l-1$}
+					\If{\Call{Dict}{$s_{1}...s_{i}$} = 1}
+						\State $Q.enqueue(i+1)$
+					\EndIf
+				\EndFor
+				\State $result \gets 0$
+				\While{Q not empty}
+					\State $pos \gets Q.dequeue()$
+					\If{$!result$}
+						\State $result \gets \Call{CanBeDivided}{s_{pos}...s_{l}}$
+					\EndIf
+				\EndWhile
+				\State \Return $result$	
+			\EndIf
+		\EndFunction
+	\end{algorithmic}
+\setcounter{section}{6}
+\section{} %7
+	\setcounter{subsection}{4}
+	\subsection{} %e
+	\begin{tikzpicture}
+		\node (592) {6};
+		\node (301) [right=of 592] {3};
+		\node (297) [right=of 301] {4};
+		\node (170) [right=of 297] {2};
+		\node (92) [right=of 170] {1};
+		\node (87) [right=of 92] {5};
+		\node (86) [right=of 87] {0};
+		\node (79) [right=of 86] {8};
+		\node (69) [right=of 79] {9};
+		\node (68) [right=of 69] {7};
+		
+		\node[state] (137) [above right=1 and 0.3 of 69] {137};
+		\node[state] (165) [above right=1 and 0.3 of 86] {165};
+		\node[state] (179) [above right=1 and 0.3 of 92] {179};
+		\node[state] (302) [above right=of 165] {302};
+		\node[state] (349) [above left=of 179] {349};
+		\node[state] (598) [above right=1 and 0.3 of 301] {598};
+		\node[state] (651) [above right=2 and 3 of 349] {651};
+		\node[state] (1190) [above left=of 598] {1190};
+		\node[state] (1841) [above left=of 651] {1841};
+		
+		\path (69) edge (137)
+		      (68) edge (137)
+		      (86) edge (165)
+		      (79) edge (165)
+		      (92) edge (179)
+		      (87) edge (179)
+		      (165) edge (302)
+		      (137) edge (302)
+		      (170) edge (349)
+		      (179) edge (349)
+		      (301) edge (598)
+		      (297) edge (598)
+		      (592) edge (1190)
+		      (598) edge (1190)
+		      (349) edge (651)
+		      (302) edge (651)
+		      (1190) edge (1841)
+		      (651) edge (1841);
+	\end{tikzpicture}
+\end{document}

ad/Zusammenfassung.tex

@@ -0,0 +1,611 @@
+\documentclass[10pt,a4paper,oneside,ngerman,numbers=noenddot]{scrartcl}
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{bytefield}
+\usepackage{paralist}
+\usepackage{gauss}
+\usepackage{pgfplots}
+\usepackage{textcomp}
+\usepackage[locale=DE,exponent-product=\cdot,detect-all]{siunitx}
+\usepackage{tikz}
+\usepackage{algpseudocode}
+\usepackage{algorithm}
+\usepackage{mathtools}
+\usepackage{hyperref}
+%\usepackage{algorithmic}
+%\usepackage{minted}
+\usetikzlibrary{automata,matrix,fadings,calc,positioning,decorations.pathreplacing,arrows,decorations.markings}
+\usepackage{polynom}
+\polyset{style=C, div=:,vars=x}
+\pgfplotsset{compat=1.8}
+\pagenumbering{arabic}
+%\def\thesection{\arabic{section})}
+%\def\thesubsection{(\alph{subsection})}
+%\def\thesubsubsection{(\roman{subsubsection})}
+\makeatletter
+\renewcommand*\env@matrix[1][*\c@MaxMatrixCols c]{%
+  \hskip -\arraycolsep
+  \let\@ifnextchar\new@ifnextchar
+  \array{#1}}
+\makeatother
+\parskip 12pt plus 1pt minus 1pt
+\parindent 0pt
+
+\DeclarePairedDelimiter\abs{\lvert}{\rvert}%
+\DeclarePairedDelimiter{\ceil}{\lceil}{\rceil}
+
+%switch starred and non-starred (auto-size)
+\makeatletter
+\let\oldabs\abs
+\def\abs{\@ifstar{\oldabs}{\oldabs*}}
+\makeatother
+
+\hypersetup{
+    colorlinks,
+    citecolor=black,
+    filecolor=black,
+    linkcolor=black,
+    urlcolor=black
+}
+
+\begin{document}
+\author{Jim Martens}
+\title{Zusammenfassung AD}
+\maketitle
+
+\section*{Disclaimer}
+
+	Diese Zusammenfassung setzt ein Belegen der AD-Veranstaltung voraus. Es kann den Besuch der Vorlesungen und Übungen durch das Semester hinweg nicht ersetzen und erhebt auch keinen Anspruch auf Vollständigkeit. Diese Zusammenfassung bezieht sich auf den Stoff der AD-Veranstaltung im Wintersemester 2013/2014 von Frau Luxburg.
+
+\tableofcontents
+
+\clearpage
+
+\section{Landau--Notation}
+
+	Es gibt fünf verschiedene Abschätzungen für die asymptotische Laufzeit eines Algorithmus.
+	
+	\[
+		\mathcal{O}, o, \omega, \theta, \Omega
+	\]
+	
+	$\mathcal{O}$ gibt die obere Schranke der Laufzeit an. Ein Algorithmus, der in $\mathcal{O}(n)$ liegt, hat demnach eine asymptotische Laufzeit von höchstens $n$. $\mathcal{O}$ wird am häufigsten benutzt, weswegen die gesamte Notation häufig auch O-Notation genannt wird.
+	
+	$o$ verhält sich ähnlich, weist aber einen kleinen Unterschied auf. Ein Algorithmus in $o(n)$ wächst asymptotisch echt langsamer als $n$.
+	
+	$\theta$ gibt eine genaue Laufzeit an. Ein Algorithmus in $\theta(n)$ wächst asymptotisch genauso schnell wie $n$.
+	
+	$\omega$ ist das Gegenstück zu $o$ für die untere Schranke. Ein Algorithmus in $\omega(n)$ wächst echt schneller als $n$.
+	
+	$\Omega$ schließlich ist das Gegenstück zu $\mathcal{O}$ für die untere Schranke. Ein Algorithmus in $\Omega(n)$ wächst mindestens so schnell wie $n$.
+	
+	Bei der Landau--Notation fallen Konstanten und niedrigere Potenzen weg. Ein Algorithmus mit der konkreten Laufzeit von $45n^{2} + 100n$ liegt demnach in $\mathcal{O}(n^{2})$.
+	
+	Geht es um den Vergleich zweier Algorithmen und ist die Laufzeit nicht eindeutig feststellbar, dann hilft es den Limes zu bilden. Dabei gelten folgende Regeln.
+	
+	\begin{alignat*}{2}
+		f \in \mathcal{O}(g):& \limsup_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &<& \infty \\
+		f \in o(g):& \lim_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &=& 0 \\
+		f \in \Omega(g) :& \liminf_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &>& 0 \\
+		f \in \omega(g) :& \liminf_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &=& \infty \\
+		f \in \theta(g) :& 0 < \liminf_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} \leq  \limsup_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &<& \infty
+	\end{alignat*}
+	
+\section{Mastertheorem}
+
+	Das Mastertheorem gehört ebenso wie die Landau--Notation zur Komplexitätstheorie und wird benutzt, um Algorithmen in Komplexität einzuteilen. Es ist jedoch wichtig zu beachten, dass es nur auf ganz bestimmte Algorithmen anwendbar ist. So kann es nur für divide-and-conquer Algorithmen benutzt werden, bei denen sich die Größe der Subprobleme in jedem Rekursionsschritt um einen festen Faktor verkleinert.
+	
+	Das Mastertheorem behandelt Rekurrenzgleichungen dieser Form:
+	
+	\[
+		T(n) = a \cdot T\left(\ceil*{\frac{n}{b}} \right) + \mathcal{O}(n^{d})
+	\]
+	
+	In dieser Formel steht $a$ für die Anzahl der Subprobleme pro Rekursionsschritt, $b$ für den Faktor, um den sich die Subprobleme pro Schritt verkleinern, $\mathcal{O}(n^{d})$ für die Kosten des Algorithmus, die nicht in der Rekursion liegen und $n$ für die Größe des Gesamtproblems. Dabei gelten diese formalen Bedingungen für die Variablen: 
+	
+	\[
+		a \geq 1, b > 1
+	\]
+	
+	Hat man solch eine Rekurrenzgleichung gefunden, so kann man daraus die Komplexität berechnen.
+	
+	\[
+		T(n) = \begin{cases}
+					\mathcal{O}(n^{d}) &, \text{wenn}\, d > \log_{b}(a) \\
+					\mathcal{O}(n^{d} \cdot \log(n)) &, \text{wenn}\, d = \log_{b}(a) \\
+					\mathcal{O}(n^{\log_{b}(a)}) &, \text{wenn}\, d < \log_{b}(a)
+				\end{cases}
+	\]
+	
+	Die Komplexität der rekursiven Berechnung der Fibonacci-Zahlen beispielsweise lässt sich nicht mit dem Mastertheorem berechnen, da sich die Größe der Subprobleme pro Rekursionsschritt nicht um einen festen Faktor verkleinern.
+	
+\section{Datenstrukturen}
+
+	\subsection{Listen}
+	
+		Es gibt zwei unterschiedliche Arten von Listen. Zum Einen gibt es Single-Linked-Lists, die nur in eine Richtung verbunden sind. Will man das letzte Element der Liste finden, muss man demnach vom Kopfelement die gesamte Liste durchgehen, um das letzte Element zu finden. Zum Anderen gibt es die Double-Linked-Lists, die in beide Richtungen verbunden sind. Dort kann man sich in beide Richtungen bewegen und spart damit Suchzeit, wenn man ein Element am Ende der Liste sucht.
+		
+		Neben diesen zwei grundsätzlichen Arten von Listen gibt es noch unterschiedliche Ausführungsvarianten. In der Praxis trifft man meistens auf Listen, die ein dediziertes Kopf- und Schlusselement haben, welches keinen eigentlichen Wert enthält. Diese "`Wächterknoten"' verhindern eine Reihe von Problemen (siehe SE 1). Desweiteren gibt es noch für Double-Linked-Lists die Variante mit einem und nicht zwei solcher Wächterknoten. Dabei zeigt das letzte Element der Liste wieder auf den Wächterknoten, wodurch ein Ring entsteht.
+		
+	\subsection{Bäume}
+	
+		Bäume sind eine besondere Art von Graphen, die keine Zyklen enthalten und ungerichtet sind. Bäume haben einen Wurzelknoten und ein oder mehrere Blätter (Knoten ohne Kindknoten). Jeder Knoten hat entweder Kindknoten oder ist ein Blatt. Bei einem Baum mit einem einzigen Knoten ist dieser sowohl Wurzel als auch Blatt.
+		
+		Es gibt für t-näre Bäume eine Sprachregelung, die festlegt wie ein solcher Baum heißt. Bei einem vollen (engl.: full) Baum hat jeder Knoten bis auf die Blätter t Kindknoten. Auf der untersten Ebene finden sich also $t^{h}$ Knoten, wobei $h$ die Höhe des Baumes bezeichnet. Die Wurzelebene ist mit Höhe $0$ versehen. Ein vollständiger Baum (engl.: complete) ist bis auf die unterste Ebene wie ein voller Baum. Auf der untersten Ebene befinden sich $1$ bis $t^{h}$ Blätter, die von links nach rechts angeordnet sind.
+		
+		Die Gesamtanzahl an Knoten entspricht bei einem vollen Baum $t^{h+1}-1$ und bei einem vollständigen Baum $t^{h} - 1 + c : 1 \leq c \leq t^{h}$. Die Höhe des Baumes wiederum lässt sich aus der gesamten Anzahl der Knoten berechnen. Bei einem vollen Baum entspricht die Höhe des Baumes, wenn $n$ die Anzahl der Knoten symbolisiert, $\log_{t}(n+1) - 1$. Für einen vollständigen Baum entspricht es $\ceil*{\log_{t}(n+1)-1}$.
+		
+	\subsection{Stack}
+	
+		Ein Stack ist nach dem LIFO--Prinzip organisiert und unterstützt zwei Operationen, die je nach Literatur anders heißen. Die erste Operation erlaubt das Einfügen eines Elementes in den Stack (\texttt{Insert(e)} bzw. \texttt{Push(e)}) und die zweite Operation erlaubt das Entnehmen des zuletzt eingefügten Elementes (\texttt{Delete()} bzw. \texttt{Pop()}).
+		
+		Ein Stack könnte sinnvoll mit einem Array implementiert werden.
+		
+	\subsection{Queue}
+	
+		Eine Queue arbeitet nach dem FIFO--Prinzip und unterstützt ebenso zwei Operationen. Die erste fügt ein Element in die Queue ein (\texttt{Insert(e)} bzw. \texttt{Enqueue(e)}) und die zweite Operation entfernt das vorderste Element in der Queue (\texttt{Delete()} bzw. \texttt{Dequeue()}).
+		
+		Queues können sinnvoll als Double--Linked--Lists implementiert werden. Alternativ könnte man ein Array nehmen, bei dem man sich immer merkt welche Position gerade vorne und welche hinten ist.
+		
+		Es gibt Abwandlungen der Queue, die das FIFO--Prinzip verletzen. Dies sind sogenannte Priority Queues, die das vorderste Element nach einer Sortierung bestimmen. Beispielsweise sorgt eine Min-Priority-Queue dafür, dass immer das Element mit dem geringsten Wert ganz vorne steht.
+		
+	\subsection{Heap}
+	
+		Ein Heap ist ein besonderer Baum, der nach bestimmten Kriterien sortiert ist. Bei einem Max--Heap befindet sich an der Wurzel der Knoten mit dem höchsten Wert und alle Kindknoten haben kleinere Werte. Dies gilt aber nicht nur für die Wurzel, sondern die Kindknoten jedes Knotens haben kleinere Werte als der Knoten, von dem sie Kinder sind.
+		
+		Für einen Heap sind fünf Operationen definiert. Die Operation \texttt{Heapify} geht vom gewählten Knoten zu den Blättern und tauscht den Knoten so lange herunter, bis die Heapeigenschaft für den gesamten Heap unter dem Knoten wieder gilt. Die Operation erfordert gültige Heaps unter dem Knoten. Das bedeutet, dass die Subbäume für sich (mit den Kindern des Knotens als Wurzelknoten) gültige Heaps sind. Die worst case Laufzeit ist $\mathcal{O}(\log n)$.
+		
+		Die zweite Operation \texttt{BuildMaxHeap} geht von den Blättern zum Wurzelknoten und stellt die Heapeigenschaft her. Dabei wird \texttt{Heapify} auf jeden Knoten ausgeführt. In jeder Ebene wird von rechts nach links vorgegangen, angefangen bei dem am weitesten unten rechts stehenden Knoten. Effektiv passiert auf Blattebene jedoch nichts, da diese keine Kindknoten haben, mit denen sie vertauscht werden könnten. Die Laufzeit beträgt $\mathcal{O}(n)$.
+		
+		Die dritte Operation ist \texttt{ExtractMax}. Die Operation entfernt den Wurzelknoten und zieht den am weitesten rechts unten stehenden Knoten zur Wurzelposition und wendet \texttt{Heapify} auf diesen Knoten an. Die Laufzeit beträgt $\mathcal{O}(\log n)$.
+	
+		Die vierte Operation heißt \texttt{DecreaseKey} und setzt den betreffenden Knoten auf den gewählten geringeren Wert und wendet \texttt{Heapify} auf diesen Knoten an. Die Laufzeit beträgt $\mathcal{O}(\log n)$.
+		
+		Das Gegenstück dazu ist \texttt{IncreaseKey}, welches nach dem Verändern des Wertes die Operation \texttt{BuildMaxHeap} ausführt. Die Laufzeit beträgt $\mathcal{O}(\log n)$.
+		
+\section{Hashing}
+
+	Hashing hat das Ziel eine große Menge an Werten auf eine kleinere Menge abzubilden. Eine der einfachsten Hashfunktionen ist die modulo-Funktion für ganze Zahlen. 
+	
+	Die Zielmenge wird durch ein Array repräsentiert, wobei die Indizes für die Werte stehen, auf die abgebildet wird. Wenn auf eine kleinere Menge abgebildet wird, sind Kollisionen natürlich unvermeidlich. Dies wird dadurch gehandhabt, dass jedes Arrayelement eine Liste ist, in die alle Werte eingetragen werden, die auf den zugehörigen Index gehasht werden.
+	
+	Das Ziel ist natürlich die Anzahl an Kollisionen pro Index möglichst klein zu halten und möglichst gleichmäßig zu hashen. Aus diesen Anforderungen ergibt sich, dass es bessere und schlechtere Hashfunktionen gibt. Allerdings gibt es keine perfekte Hashfunktion, sondern je nach Anwendungsgebiet kommen andere Funktionen in Betracht.
+	
+	Eine mögliche Strategie der Kollisionsvermeidung ist das Weiterlaufen bis zum nächsten freien Index. Kommt man am Ende des Arrays an, wird wieder von vorne begonnen.
+	
+\section{Sortierverfahren}
+
+	\subsection{Selection Sort}
+	
+		Selection Sort kann man sich gut mit Karten veranschaulichen. Man hat eine Menge an Karten offen vor sich liegen und nimmt nacheinander die Karten in die Hand, beginnend mit der niedrigsten Karte, und reiht sie dort von links nach rechts auf. Die Laufzeit beträgt im worst case $\mathcal{O}(n^{2})$.
+		
+	\subsection{Insertion Sort}
+	
+		Insertion Sort wendet man zum Beispiel bei Skat meist intuitiv an. Man hat eine Menge an verdeckten Karten, zieht nacheinander die jeweils höchste Karte und reiht sie entsprechend in die Hand ein, wobei die niedrigste Karte links und die höchstwertige Karte rechts ist. Die worst case Laufzeit beträgt hier ebenfalls $\mathcal{O}(n^{2})$.
+		
+	\subsection{Bubble Sort}
+	
+		Bubble Sort ist trotz gleicher worst case Laufzeit deutlich arbeitsaufwendiger für Menschen. Denn bereits bei 4 Werten ergeben sich 16 Durchgänge, um die Werte korrekt zu sortieren.
+		
+		Die beste Erklärung des Sortierverfahrens bietet der Pseudocode.
+		
+		\begin{algorithmic}[1]
+			\Procedure{Bubblesort}{A}
+				\For{i $\gets$ 1 to A.length - 1}
+					\For{j $\gets$ A.length downto i + 1}
+						\If{A[j] < A[j - 1]}
+							\State exchange A[j] with A[j - 1]
+						\EndIf
+					\EndFor
+				\EndFor
+			\EndProcedure
+		\end{algorithmic}
+		
+	\subsection{Merge Sort}
+	
+		Merge Sort ist mit einer worst case Laufzeit von $\mathcal{O}(n \cdot \log n)$ eines der besten vergleichsbasierten Sortierverfahren. Man nehme eine Reihe von Werten und sehe sie als einzelne Elemente an. Nun verbindet man immer zwei Elemente miteinander und bringt sie gleich in die richtige Reihenfolge. Dabei geht man rigoros von links nach rechts. Man verbindet demnach das erste und zweite Element, das dritte und vierte Element usw. Ist man damit fertig, verbindet man jeweils zwei dieser Zweierpärchen und sortiert alle enthaltenen Elemente in die richtige Reihenfolge. Auch dies wiederholt man für alle Pärchen. Diesen Vorgang wiederholt man nun solange bis am Ende nur noch eine korrekt sortierte Liste herauskommt. 
+		
+		Merge Sort kann man auch als Divide--and--conquer Verfahren bezeichnen. Es ergibt sich die folgende Rekurrenzgleichung.
+		
+		\[
+			T(n) = 2 \cdot T\left(\frac{n}{2}\right) + \mathcal{O}(n)
+		\]
+		
+	\subsection{Heap Sort}
+	
+		Heap Sort macht sich die Heapeigenschaft zunutze und speichert alle Elemente in einem Heap. Somit lässt sich der höchste Wert (Max--Heap) einfach auslesen.
+		
+		Der Pseudocode liest sich folgendermaßen:
+		
+		\begin{algorithmic}[1]
+			\Function{HeapSort}{A}
+				\State n $\gets$ \Call{length}{A}
+				\State B $\gets$ empty array of length n
+				\State H $\gets$ \Call{BuildMaxHeap}{A}
+				\For{i $\gets$ 1 to n}
+					\State B(n - i) $\gets$ \Call{ExtractMax}{H}
+				\EndFor
+				\State \Return B
+			\EndFunction
+		\end{algorithmic}
+		
+		Das Verfahren hat eine Laufzeit von $\mathcal{O}(n \cdot \log n)$, die sowohl die sowohl worst case als auch best case Laufzeit ist.
+		
+	\subsection{Quick Sort}
+	
+		Quick Sort funktioniert ähnlich wie Merge Sort, nur dass es mit einer kompletten Liste anfängt und dann immer weiter aufteilt und am Ende nur noch zusammenfügen muss. Dies funktioniert durch die Wahl eines Pivotelementes. Im Idealfall teilt es die Liste in zwei gleichgroße Teillisten. Die worst case Laufzeit beträgt $\mathcal{O}(n^{2})$. In den meisten Fällen benötigt Quick Sort jedoch nur $\mathcal{O}(n \cdot \log n)$.
+		
+		Trotz der vermeintlich schlechten Laufzeit wird Quick Sort in der Praxis viel eingesetzt, da es in der Praxis auch auf die Konstanten ankommt, die in der Landau--Notation weggelassen werden. Quick Sort hat vergleichsweise kleine Konstanten wohingegen andere Verfahren mit einer besseren worst case Laufzeit meist größere Konstanten haben.
+	
+	\subsection{Counting Sort}
+	
+		Counting Sort ist ein Sortierverfahren, welches nicht vergleichsbasiert ist. Es gibt zwei prominente Implementationsmöglichkeiten. Die erste Möglichkeit ist ein Array mit Countern. Die zweite Möglichkeit ist ein Array mit Listen. Im Folgenden bezeichne K den höchsten Wert in der zu sortierenden Liste (nicht unbedingt die Datenstruktur in der diese Liste an Werten gespeichert ist).
+		
+		Zunächst der Pseudocode für die erste Variante.
+		
+		\begin{algorithmic}[1]
+			\Function{CountingSort}{A}
+				\State n $\gets$ \Call{length}{A}
+				\State Allocate array B with length K, initialize each cell with 0
+				\For{i $\gets$ 1 to n}
+					\State B[A[i]] $\gets$ B[A[i]] + 1
+				\EndFor
+				\State C $\gets$ empty list
+				\For{key, count in B}
+					\While{count > 0}
+						\State C.append(key)
+						\State count $\gets$ count - 1
+					\EndWhile
+				\EndFor
+				\State \Return C
+			\EndFunction
+		\end{algorithmic}
+		
+		Die zweite For-Schleife ist nur zum Erstellen der sortierten Liste. Die Laufzeit beträgt K für das Initialisieren des Arrays B, n für die erste For-Schleife, K für die zweite For-Schleife und maximal n für die While-Schleife. Dabei ist jedoch zu berücksichtigen, dass die While-Schleife insgesamt über alle Iterationen der For-Schleife nur n--mal aufgerufen wird, denn die Summe aller Counts entspricht der Länge der zu sortierenden Liste an Zahlen. Die Gesamtlaufzeit ist demnach $\mathcal{O}(K + n + n)$ bzw. $\mathcal{O}(K + 2n)$. Die Laufzeit K der zweiten For-Schleife ist hier nicht berücksichtigt, da die While-Schleife insgesamt nur n--mal aufgerufen wird und in den übrigen Fällen in der For-Schleife nichts ausgeführt wird. Nach den Regeln der Landau--Notation entfällt hier das zweite n bzw. die Konstante, da es nichts an der asymptotischen Laufzeit verändert. Die Gesamtlaufzeit ist damit $\mathcal{O}(K + n)$.
+		
+		Die zweite Variante mit Listen im Array wird etwas anders implementiert, hat aber die gleiche Laufzeit.
+		
+		\begin{algorithmic}[1]
+			\Function{CountingSort}{A}
+				\State n $\gets$ \Call{length}{A}
+				\State Allocate array B with length K, initialize each cell with an empty list
+				\For{i $\gets$ 1 to n}
+					\State B[A[i]].append(A[i])
+				\EndFor
+				\State \Return concatenation of B[1], B[2], ..., B[K]
+			\EndFunction
+		\end{algorithmic}
+		
+		Die Laufzeit beträgt hier K für das Initialisieren von B und n für die For-Schleife. Insgesamt ergibt sich somit $\mathcal{O}(n + K)$.
+		
+	\subsection{Radix Sort}
+	
+		Radix Sort ist im Prinzip Counting Sort mit ein paar Veränderungen. Die obere Grenze der Zahlen kann riesig sein ($K = \omega(n)$). Um dem beizukommen stellt man sich jede Zahl als ein String vor. Zunächst werden die Zahlen nach der letzten Ziffer sortiert, dann nach der zweitletzten und so weiter. Dieses Verfahren setzt Counting Sort in der zweiten Variante voraus.
+		
+		Da stets nur nach Ziffern sortiert wird, kann man die Arraylänge auf 10 begrenzen, denn es gibt nur 10 Ziffern. Demzufolge braucht man auch bei einem K von einer Million nur ein Array von 10, um alle Zahlen nach der letzten Ziffer dort einzusortieren in Listen.
+		
+		Als Beispiel nehme man die Zahlen 10, 3, 5, 15, 20, 7 , 11 und 13. Diese werden in der Reihenfolge ihres Erscheinens sortiert und ergeben folgendes Bild im Array B.
+		
+		\begin{alignat*}{1}
+			B[0]:& 10 \rightarrow 20 \\
+			B[1]:& 11 \\
+			B[2]:& \\
+			B[3]:& 3 \rightarrow 13 \\
+			B[4]:& \\
+			B[5]:& 5 \rightarrow 15 \\
+			B[6]:& \\
+			B[7]:& 7 \\
+			B[8]:& \\
+			B[9]:&
+		\end{alignat*}
+		
+		Im zweiten Schritt wird nun das Array und in jeder Zelle die Liste von vorne bis hinten durchgegangen und die jeweils aktuelle Zahl wird dann nach der zweitletzten Ziffer in ein Array C einsortiert. Zahlen mit weniger Ziffern (in diesem Fall die einstelligen Zahlen) werden bei der 0 einsortiert. Am Ende ergibt sich die richtige Reihenfolge und es müssen nur noch alle Zahlen konkateniert werden, um das Ergebnis zu erhalten.
+		
+		Allerdings kann Radix Sort auch auf andere Zahlensysteme angewendet werden. Dann ist die Menge an möglichen Ziffern nicht gleich 10. Daher wird die Anzahl an möglichen Ziffern mit k bezeichnet und die Laufzeit zum Sortieren nach einer Ziffernposition ist dementsprechend $\theta(n + k)$. Counting Sort muss n--mal ausgeführt werden und das Array mit den Listen muss k lang sein und initialisiert werden. Dies ist jedoch nur ein Durchgang. Für die insgesamte Laufzeit von Radix Sort wird eine weitere Variable namens d benötigt, die die maximal mögliche Anzahl an Ziffern in einer Zahl bezeichnet (nicht zu verwechseln mit der Menge der möglichen Ziffern). Die Laufzeit beträgt sodann auch $\theta(d(n + k))$.
+		
+		In unserem Beispiel oben ist k konstant und d ebenso. Demnach fallen beide Weg und es bleibt $\mathcal{O}(n)$ übrig. Wenn k konstant bleibt, aber d in logarithmische Abhängigkeit zu n gestellt wird, dann ergibt sich eine Laufzeit von $\mathcal{O}(n \cdot \log n)$. Ist d sogar gleich n, dann benötigt Radix Sort $\mathcal{O}(n^{2})$.
+		
+		Warum wird Radix Sort dann überhaupt benutzt? Mithilfe von einigen Modifikationen kann man eine lineare Laufzeit erreichen und zwar als worst case. Dies ist möglich mit dem Block-based Radix Sort. Allerdings muss man vorher wissen in welchen Bereich die zu sortierenden Zahlen fallen. Genaueres siehe AD-Folienskript.
+		
+	\subsection{Bucket Sort}
+	
+		Bucket Sort wird zur Sortierung von reellen Zahlen verwendet, die gleichmäßig im Intervall [0,1] vorkommen. Angenommen man bekommt ein Eingabearray der Länge n, dann kann man das Intervall in n Buckets gleicher Länge zerteilen, wobei Bucket i alle Schlüsselwerte des Intervalls $\left[\frac{i}{n}, \frac{(i + 1)}{n}\right[$ enthält.
+		
+		Die durchschnittliche Laufzeit beträgt $\mathcal{O}(n)$ und die worst case Laufzeit beträgt $\mathcal{O}(n \cdot \log n)$.
+		
+	\subsection{Stabilität von Sortierverfahren}
+		
+		Die Angabe "`wie in AD"' bedeutet, dass die in AD verwendete Variante gemeint ist und es andere Varianten gibt, bei denen das Gegenteilige gilt.
+		
+		\begin{tabular}{c|c}
+			Verfahren & stabil \\
+			\hline
+			Merge Sort & ja \\
+			Quick Sort & ja, wie in AD \\
+			Insertion Sort & nein, wie in AD \\
+			Selection Sort & nein, wie in AD \\
+			Heap Sort & nein \\
+			Bubble Sort & ja \\
+			Counting Sort & ja, in der zweiten Variante
+		\end{tabular}
+		
+	\subsection{Lower bound}
+	
+		Für alle vergleichsbasierten Sortierverfahren gilt, dass sie eine worst case Laufzeit von $\Omega(n \cdot \log n)$ haben.
+		
+\section{Binäre Suchbäume}
+
+	Binäre Suchbäume haben eine besondere Struktur, die das Suchen erleichtert. Alle linken Kindknoten sind kleiner oder gleich des Elternknoten und alle rechten Kindknoten sind größer oder gleich des Elternknoten. Diese Bedingung gilt für alle Knoten mit Kindern.
+	
+	Aufgrund dessen ist das Einfügen in solch einen Baum relativ deterministisch. Das Löschen gestaltet sich da schon etwas komplizierter.
+	
+	Zunächst werden jedoch die Operationen der Reihe nach durchgegangen. Die erste Operation ist \texttt{Tree-Search} mit folgendem Pseudocode.
+	
+	\begin{algorithmic}[1]
+		\Function{Tree-Search}{x, k}
+			\If{x == NIL or k == x.key}
+				\State \Return x
+			\EndIf
+			\If {k < x.key}
+				\State \Return \Call{Tree-Search}{x.left, k}
+			\Else
+				\State \Return \Call{Tree-Search}{x.right, k}			
+			\EndIf
+		\EndFunction
+	\end{algorithmic}
+	
+	Die Laufzeit beträgt $\mathcal{O}(h)$, wobei h die Höhe des Baumes angibt.
+	
+	Das Minimum des Baumes kann gefunden werden, indem immer das linke Kind genommen wird bis ein Blatt erreicht wird. Dieses Blatt ist das minimale Element des Baumes. Die Laufzeit beträgt ebenso $\mathcal{O}(h)$. Das Maximum findet man analog, nur dass man dort immer das rechte Kind benutzt.
+	
+	Die zweite Operation ist \texttt{Inorder-Tree-Walk} mit diesem Pseudocode.
+	
+	\begin{algorithmic}[1]
+		\Procedure{Inorder-Tree-Walk}{x}
+			\If{x $\neq$ NIL}
+				\State \Call{Inorder-Tree-Walk}{x.left}
+				\State \Call{print}{x.key}
+				\State \Call{Inorder-Tree-Walk}{x.right}
+			\EndIf
+		\EndProcedure
+	\end{algorithmic}
+	
+	Sie hat eine Laufzeit von $\theta(n)$.
+	
+	Nun kommen wir zum Einfügen von Elementen. Für das Einfügen wird der Baum einfach heruntergegangen und das neue Element an der richtigen Stelle eingefügt. Die Laufzeit beträgt hier ebenso $\mathcal{O}(h)$.
+	
+	Für das Entfernen eines Blattes ist es vergleichsweise einfach. Das Blatt kann einfach entfernt werden. Wenn ein Knoten nur einen linken oder nur einen rechten Kindknoten hat, dann können diese einfach an die Position des zu löschenden Knoten rücken. Hat der zu löschende Knoten jedoch sowohl einen linken als auch einen rechten Kindknoten, dann muss dessen Nachfolger gefunden werden. Dafür wird der am weitesten links stehende Knoten im rechten Teilbaum (mit dem rechten Kind des zu löschenden Knoten als Wurzel) herangezogen. Dieser wird dann an die Stelle des zu löschenden Knoten gesetzt und dessen rechtes Kind (falls vorhanden) wird an die Stelle von dem Nachfolger gesetzt.
+	
+	Den Nachfolger zu finden dauert $\mathcal{O}(h)$. Der Rest passiert in konstanter Zeit, sodass die insgesamte Dauer ebenfalls $\mathcal{O}(h)$ ist. Da alle Operationen nur $\mathcal{O}(h)$ benötigen, wäre es natürlich von Interesse das h so klein wie möglich zu haben. Da kommen balancierte Bäume ins Spiel. Bei balancierten Bäumen unterscheidet sich die Höhe der beiden Teilbäume unter einem Knoten um maximal 1 (Bedingung gilt für alle Knoten).
+	
+	\subsection{AVL Bäume}
+
+		AVL Bäume unterstützen Operationen, um die Balanciertheit wiederherzustellen. Allerdings ist dies nicht klausurrelevant, da Frau Luxburg diesen Bereich selber nicht sonderlich versteht.
+	
+		Dennoch wird hier eine kurze Information zu den Operationen gegeben. Die Operationen heißen \texttt{RightRotate} und \texttt{LeftRotate} und benötigen jeweils nur konstante Zeit. Wird die Balanciertheit eines Baumes durch eine Einfüge- oder Löschoperation verletzt, dann müssen maximal Balancieroperationen ausgeführt werden, um die Balanciertheit wiederherzustellen.
+	
+		Die Laufzeit vom Einfügen in einen solchen balancierten Baum beträgt $\mathcal{O}(\log n)$. Das Standardeinfügen benötigt $\mathcal{O}(\log n)$, das checken der Balanciertheit dauert ebenfalls $\mathcal{O}(\log n)$ und für die Wiederherstellung der Balanciertheit werden maximal zwei Rotationen in je konstanter Zeit ausgeführt.
+	
+	\subsection{Red-black tree}
+	
+		Ein Red-black tree hat folgende Eigenschaften.
+		
+		\begin{itemize}
+			\item jeder Knoten ist gefärbt (schwarz/rot)
+			\item Wurzel und Blätter sind schwarz
+			\item roter Knoten hat zwei schwarze Kinder
+			\item von jedem Knoten aus haben alle Pfade zu den Blättern die gleiche Anzahl schwarze Knoten
+			\item ein schwarzer Knoten kann sowohl schwarze als auch rote Kinder haben
+		\end{itemize}
+		
+\section{Binäre Suche}
+
+	Bei der binären Suche hat man ein sortiertes Array gegeben. Nun schaut man sich immer das mittlere Element an und wenn dies kleiner dem gesuchten Element ist, dann wird die binäre Suche auf den rechten Teilbereich des Arrays angewendet. Ist das mittlere Element größer, so wird die binäre Suche auf den linken Teil angewendet und wenn das mittlere Element dem gesuchten Element entspricht, dann wird die Indexposition zurückgegeben. Wird das gesuchte Element nicht gefunden, dann wird \texttt{not\_found} zurückgegeben.
+	
+	Der Pseudocode sieht folgendermaßen aus.
+	
+	\begin{algorithmic}[1]
+		\Function{BinarySearch}{A, value}
+			\State low $\gets$ 0
+			\State high $\gets$ N - 1
+			\While{low $\leq$ high}
+				\State mid $\gets$ (low + high) / 2
+				\If{A[mid] > value}
+					\State high $\gets$ mid - 1
+				\ElsIf{A[mid] < value}
+					 \State low $\gets$ mid + 1
+				\Else
+					\State \Return mid
+				\EndIf
+			\EndWhile
+		\EndFunction
+	\end{algorithmic}
+	
+	Die Laufzeit beträgt $\mathcal{O}(\log n)$.
+	
+	Es gibt jedoch auch noch andere Varianten der binären Suche, wie eine rekursive Variante und eine Variante, bei der, wenn das gesuchte Element nicht vorhanden ist, die Position zurückgegeben wird, bei der das gesuchte Element eingefügt werden kann, sodass das Array weiterhin sortiert ist.
+	
+\section{Graphen}
+
+	Bei dem Abschnitt über Bäume wurden Graphen kurz angeschnitten. Hier wird sich jetzt ausführlicher mit ihnen beschäftigt. Es gibt verschiedene Arten von Graphen.
+	
+	Graphen können ungerichtet oder gerichtet sein und sie können gewichtet oder ungewichtet sein. Allerdings ist ein ungewichteter Graph äquivalent mit einem gewichteten Graphen, bei dem alle Kanten das Gewicht 1 haben. Ein ungerichteter Graph kann in einen gleichwertigen gerichteten Graphen überführt werden, indem jede Kante durch eine Hin- und Rückkante ersetzt wird.
+	
+	Der Grad eines Knotens kann in einem ungerichteten Graphen durch folgende Formel errechnet werden.
+	
+	\[
+		Grad(u) = \sum\limits_{v \in V} w(u, v)
+	\]
+	
+	Bei einem gerichteten Graphen gibt es zwei Grade bei einem Knoten. Der Eingangsgrad und der Ausgangsgrad. Beide können folgendermaßen berechnet werden.
+	
+	\begin{alignat*}{1}
+		Grad-in(u) =& \sum\limits_{v \in V} w(v, u) \\
+		Grad-out(u) =& \sum\limits_{v \in V} w(u, v)
+	\end{alignat*}
+	
+	Pfade sind eine beliebige Abfolge von Kanten. Ein Pfad ist ein Zyklus, wenn ein Knoten sowohl Anfangs- als auch Endknoten ist. Ein Pfad ist einfach (engl.: simple), wenn jeder Knoten nur einmal vorkommt.
+	
+	Man kann Graphen in zusammenhängende und nicht zusammenhängende Graphen unterteilen. Dabei wird ein Graph als zusammenhängend bezeichnet, wenn von jedem Knoten zu jedem anderen Knoten ein Pfad gefunden werden kann (ungerichteter Graph). Ein gerichteter Graph heißt stark zusammenhängend, wenn von jedem Knoten zu jedem anderen ein gerichteter Pfad gefunden werden kann. Ein gerichteter Graph ist schwach zusammenhängend, wenn der zugehörige ungerichtete Graph zusammenhängend ist.
+	
+	Eine Zusammenhangskomponente ist ein Teilgraph des Graphen und ist zusammenhängend. In einem zusammenhängenden Graphen gibt es nur eine Zusammenhangskomponente. In einem gerichteten Graphen sind die starken Zusammenhangskomponenten interessant. Dies sind Teilgraphen des Graphen, die stark zusammenhängend sind. Ein Graph kann schwach zusammenhängend sein und dennoch mehrere starke Zusammenhangskomponenten haben.
+	
+	In einem vollständigen Graph ist jeder Knoten mit jedem anderen Knoten durch eine Kante verbunden.
+	
+	Die Kanten eines Graphen können mithilfe von Adjazenzlisten oder einer Adjazenzmatrix dargestellt werden.
+	
+	Desweiteren kann ein Graph dicht sein (engl.: dense). Dies bedeutet, dass der Graph sehr viele Kanten hat (ungefähr $|V|^{2}$). Außerdem kann ein Graph dünn sein (engl.: sparse). Dies bedeutet, dass der Graph sehr wenige Kanten hat.
+	
+\section{Graphalgorithmen}
+
+	\subsection{Bellman--Ford}
+	
+		Der Bellman-Ford Algorithmus hat folgenden Pseudocode, der bereits eindrücklich zeigen sollte, wie der Algorithmus funktioniert.
+		
+		\begin{algorithmic}[1]
+			\Function{BellmanFord}{G, s}
+				\State \Call{InitializeSingleSource}{G, s}
+				\For{i $\gets$ 1 to |V| - 1}
+					\ForAll{edges (u, v) $\in$ E}
+						\State \Call{Relax}{u, v}
+					\EndFor
+				\EndFor
+				\ForAll{edges (u, v) $\in$ E}
+					\If{v.dist > u.dist + w(u, v)} \Comment{auf negativen Zyklus prüfen}
+						\State \Return false
+					\EndIf
+				\EndFor
+			\EndFunction
+		\end{algorithmic}
+		
+		Die Laufzeit ist wenig verwunderlich: $\mathcal{O}(|V| \cdot |E|)$.
+		
+		Der Algorithmus wird benutzt, um kürzeste Wege zu berechnen. Genauer wird er für das Single--Source--Shortest--Path--Problem verwendet.
+		
+	\subsection{Dijkstra}
+	
+		Dijkstra gibt es in zwei Variationen. Beide verhalten sich gleich, haben aber Unterschiede in der Laufzeit. Die naive Variante hat diesen Pseudocode.
+		
+		\begin{algorithmic}[1]
+			\Procedure{DijkstraNaive}{G, w, s}
+				\State S $\gets$ {s}
+				\State d(s) $\gets$ 0
+				\While{S $\neq$ V}
+					\State U $\gets$ {u $\not\in$ S | u neighbour of a vertex $\in$ S}
+					\ForAll{u $\in$ U}
+						\ForAll{\Call{pre}{u} $\in$ S that are predecessors of u}
+							\State d'(u, \Call{pre}{u}) $\gets$ d(\Call{pre}{u}) + w(\Call{pre}{u}, u)
+						\EndFor
+					\EndFor
+					\State $u^{*} \gets$ argmin\{d'(u, \Call{pre}{u}) | u $\in$ U, \Call{pre}{u} $\in$ S\}
+					\State d($u^{*}$) $\gets$ d'($u^{*}$)
+					\State S $\gets$ S $\cup$ \{$u^{*}$\}
+				\EndWhile
+			\EndProcedure
+		\end{algorithmic}
+		
+		Die Laufzeit der naiven Variante beträgt $\mathcal{O}(|V| \cdot |E|)$.
+		
+		Die zweite Variante ist die Implementation mit der Min--Priority--Queue. Der Pseudocode dieser Variante folgt.
+		
+		\begin{algorithmic}[1]
+			\Procedure{Dijkstra}{G, w, s}
+				\State Q $\gets$ (V, V.dist)
+				\While{Q $\neq \empty$}
+					\State u $\gets$ \Call{Extract}{Q}
+					\ForAll{v adjacent to u}
+						\State \Call{Relax}{u, v} and update the keys in Q accordingly
+					\EndFor
+				\EndWhile
+			\EndProcedure
+		\end{algorithmic}
+		
+		Die Laufzeit mit der Min--Priority--Queue hängt von der Implementation der Queue ab. Bei einem naiven Array beträgt die Laufzeit $\mathcal{O}(n^{2})$. Bei der Implementation mit einem binären Heap sind es nur noch $\mathcal{O}((V + E)\log V)$. Bei der Implementation mit einem t-nären Heap sind es $\mathcal{O}\left((|V| \cdot t + |E|)\frac{\log V}{\log t}\right)$. Die beste Laufzeit kann mit einem Fibonacci Heap erreicht werden: $\mathcal{O}(V \log V + E)$.
+		
+		Wenn der Graph dicht ist, dann sollte die Arrayimplementation genommen werden. Wenn der Graph dünn ist, dann sollte die Heapimplementation bevorzugt werden. Wenn der Graph sehr dünn ist (|E| = $\Omega(|V|)$) bekommen wir die Laufzeit $\mathcal{O}(|V| \log |V|)$.
+		
+		Auch dieser Algorithmus gehört zum Single--Source--Shortest--Path--Problem.
+	
+	\subsection{Floyd--Warshall}
+	
+		Floyd--Warshall ist ein Graphalgorithmus, mit dem man die kürzesten Pfade von jedem Knoten zu jedem Knoten herausfinden kann (All--Pairs--Shortest--Path--Problem). Der Pseudocode ist folgender.
+		
+		\begin{algorithmic}[1]
+			\Function{FloydWarshall}{}
+				\State n $\gets$ |V|
+				\State $D^{(0)} \gets$ new $n \times n$ matrix with all values being $\infty$
+				\ForAll{v $\in$ V}
+					 \State $d_{0}(v,v) \gets$ 0
+				\EndFor
+				\ForAll{(u,v) $\in$ E}
+					\State $d_{0}(u,v) \gets$ w(u,v)
+				\EndFor
+				\For{k $\gets$ 1 to n}
+					\State $D^{k} \gets$ new $n \times n$ matrix
+					\For{s $\gets$ 1 to n}
+						\For{t $\gets$ 1 to n}
+							\State $d_{k}(s, t) \gets$ min\{$d_{k-1}(s, t)$, $d_{k-1}(s, k) + d_{k-1}(k, t)$\}
+						\EndFor
+					\EndFor
+				\EndFor
+				\State \Return $D^{(n)}$
+			\EndFunction
+		\end{algorithmic}
+		
+		Die Laufzeit beträgt $\mathcal{O}(|V|^{3})$.
+		
+	\subsection{Bidirektionaler Dijkstra}
+	
+		Der Bidirektionale Dijkstra besteht aus zwei Dijkstra--Algorithmen, die wechselweise ausgeführt werden. Der erste Dijkstra startet beim Startknoten und der zweite Dijkstra startet beim Zielknoten. Beide Algorithmen sind ganz normale Dijkstra--Algorithmen, die solange laufen bis ein Algorithmus einen Knoten aufnimmt, der bereits von dem anderen Algorithmus aufgenommen wurde.
+		
+		Der kürzeste Pfad muss aber nicht über diesen Knoten laufen.
+	
+	\subsection{A*--Suche}
+	
+		$A^{*}$--Suche ist ein modifizierter Dijkstra--Algorithmus. Für jeden Knoten gibt es einen Wert, der die Entfernung zum Ziel angibt. Diese Entfernung muss nicht immer exakt sein, sodass auch eine untere Grenze wie die Luftlinienentfernung hinreichend ist.
+		
+		Diese Entfernung wird bei der Auswahl des nächsten Knotens berücksichtigt. Der Knoten mit dem geringsten Abstand zum Startknoten plus der abgeschätzten Entfernung zum Ziel wird als nächstes ausgewählt.
+		
+	\subsection{SCC--Algorithmus}
+	
+		Der SCC--Algorithmus wird zum Bestimmen von starken Zusammenhangskomponenten beynutzt. Der Algorithmus kann in Worten wie folgt beschrieben werden.
+		
+		\begin{algorithmic}[1]
+			\Procedure{SCC}{G}
+				\State Call \Call{DFS}{G} to compute the finishing times \Call{f}{u}
+				\State Compute the reverse graph $G^{t}$
+				\State Call \Call{DFS}{$G^{t}$}, where the vertices in the main loop are considered in order of decreasing \Call{f}{u}
+				\State Output the subsets that have been discovered by the individual calls of DFS--Visit
+			\EndProcedure
+		\end{algorithmic}
+		
+		Die Laufzeit beträgt insgesamt $\mathcal{O}(|V| + |E|)$.
+		
+	\subsection{Kruskals Algorithmus}
+	
+		Kruskals Algorithmus geht die Kanten in nicht absteigender Reihenfolge durch und nimmt alle Kanten auf, die keinen Zyklus ergeben.
+		
+	\subsection{Prims Algorithmus}
+	
+		Prims Algorithmus beginnt bei einem Startknoten, der zu Beginn einziger Bestandteil der Menge $S$ ist. Prim fügt in jedem Schritt eine Kante hinzu, die $S$ mit $V \setminus S$ verbindet und von allen potentiellen Kanten die mit dem geringsten Gewicht ist.
+		
+\section{Dynamisches Programmieren}
+
+	%TODO
+	
+\section{Edit distance}
+
+	%TODO
+	
+	\[
+		E(i, j) = min\begin{cases}
+			E(i - 1, j) + 1 \\
+			E(i, j - 1) + 1 \\
+			E(i - 1, j - 1) + \mathrm{1}_{x[i] \neq y[j]}
+		\end{cases}
+	\]
+\end{document}

ad/Zusammenfassung_WS1516.tex

@@ -0,0 +1,611 @@
+\documentclass[10pt,a4paper,oneside,ngerman,numbers=noenddot]{scrartcl}
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{bytefield}
+\usepackage{paralist}
+\usepackage{gauss}
+\usepackage{pgfplots}
+\usepackage{textcomp}
+\usepackage[locale=DE,exponent-product=\cdot,detect-all]{siunitx}
+\usepackage{tikz}
+\usepackage{algpseudocode}
+\usepackage{algorithm}
+\usepackage{mathtools}
+\usepackage{hyperref}
+%\usepackage{algorithmic}
+%\usepackage{minted}
+\usetikzlibrary{automata,matrix,fadings,calc,positioning,decorations.pathreplacing,arrows,decorations.markings}
+\usepackage{polynom}
+\polyset{style=C, div=:,vars=x}
+\pgfplotsset{compat=1.8}
+\pagenumbering{arabic}
+%\def\thesection{\arabic{section})}
+%\def\thesubsection{(\alph{subsection})}
+%\def\thesubsubsection{(\roman{subsubsection})}
+\makeatletter
+\renewcommand*\env@matrix[1][*\c@MaxMatrixCols c]{%
+  \hskip -\arraycolsep
+  \let\@ifnextchar\new@ifnextchar
+  \array{#1}}
+\makeatother
+\parskip 12pt plus 1pt minus 1pt
+\parindent 0pt
+
+\DeclarePairedDelimiter\abs{\lvert}{\rvert}%
+\DeclarePairedDelimiter{\ceil}{\lceil}{\rceil}
+
+%switch starred and non-starred (auto-size)
+\makeatletter
+\let\oldabs\abs
+\def\abs{\@ifstar{\oldabs}{\oldabs*}}
+\makeatother
+
+\hypersetup{
+    colorlinks,
+    citecolor=black,
+    filecolor=black,
+    linkcolor=black,
+    urlcolor=black
+}
+
+\begin{document}
+\author{Jim Martens}
+\title{Zusammenfassung AD}
+\maketitle
+
+\section*{Disclaimer}
+
+	Diese Zusammenfassung setzt ein Belegen der AD-Veranstaltung voraus. Es kann den Besuch der Vorlesungen und Übungen durch das Semester hinweg nicht ersetzen und erhebt auch keinen Anspruch auf Vollständigkeit. Diese Zusammenfassung bezieht sich auf den Stoff der AD-Veranstaltung im Wintersemester 2015/2016 von Frank Heitmann.
+
+\tableofcontents
+
+\clearpage
+
+\section{Landau--Notation}
+
+	Es gibt fünf verschiedene Abschätzungen für die asymptotische Laufzeit eines Algorithmus.
+	
+	\[
+		\mathcal{O}, o, \omega, \theta, \Omega
+	\]
+	
+	$\mathcal{O}$ gibt die obere Schranke der Laufzeit an. Ein Algorithmus, der in $\mathcal{O}(n)$ liegt, hat demnach eine asymptotische Laufzeit von höchstens $n$. $\mathcal{O}$ wird am häufigsten benutzt, weswegen die gesamte Notation häufig auch O-Notation genannt wird.
+	
+	$o$ verhält sich ähnlich, weist aber einen kleinen Unterschied auf. Ein Algorithmus in $o(n)$ wächst asymptotisch echt langsamer als $n$.
+	
+	$\theta$ gibt eine genaue Laufzeit an. Ein Algorithmus in $\theta(n)$ wächst asymptotisch genauso schnell wie $n$.
+	
+	$\omega$ ist das Gegenstück zu $o$ für die untere Schranke. Ein Algorithmus in $\omega(n)$ wächst echt schneller als $n$.
+	
+	$\Omega$ schließlich ist das Gegenstück zu $\mathcal{O}$ für die untere Schranke. Ein Algorithmus in $\Omega(n)$ wächst mindestens so schnell wie $n$.
+	
+	Bei der Landau--Notation fallen Konstanten und niedrigere Potenzen weg. Ein Algorithmus mit der konkreten Laufzeit von $45n^{2} + 100n$ liegt demnach in $\mathcal{O}(n^{2})$.
+	
+	Geht es um den Vergleich zweier Algorithmen und ist die Laufzeit nicht eindeutig feststellbar, dann hilft es den Limes zu bilden. Dabei gelten folgende Regeln.
+	
+	\begin{alignat*}{2}
+		f \in \mathcal{O}(g):& \limsup_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &<& \infty \\
+		f \in o(g):& \lim_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &=& 0 \\
+		f \in \Omega(g) :& \liminf_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &>& 0 \\
+		f \in \omega(g) :& \liminf_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &=& \infty \\
+		f \in \theta(g) :& 0 < \liminf_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} \leq  \limsup_{n \rightarrow \infty} \abs{\frac{f(n)}{g(n)}} &<& \infty
+	\end{alignat*}
+	
+\section{Mastertheorem}
+
+	Das Mastertheorem gehört ebenso wie die Landau--Notation zur Komplexitätstheorie und wird benutzt, um Algorithmen in Komplexität einzuteilen. Es ist jedoch wichtig zu beachten, dass es nur auf ganz bestimmte Algorithmen anwendbar ist. So kann es nur für divide-and-conquer Algorithmen benutzt werden, bei denen sich die Größe der Subprobleme in jedem Rekursionsschritt um einen festen Faktor verkleinert.
+	
+	Das Mastertheorem behandelt Rekurrenzgleichungen dieser Form:
+	
+	\[
+		T(n) = a \cdot T\left(\ceil*{\frac{n}{b}} \right) + \mathcal{O}(n^{d})
+	\]
+	
+	In dieser Formel steht $a$ für die Anzahl der Subprobleme pro Rekursionsschritt, $b$ für den Faktor, um den sich die Subprobleme pro Schritt verkleinern, $\mathcal{O}(n^{d})$ für die Kosten des Algorithmus, die nicht in der Rekursion liegen und $n$ für die Größe des Gesamtproblems. Dabei gelten diese formalen Bedingungen für die Variablen: 
+	
+	\[
+		a \geq 1, b > 1
+	\]
+	
+	Hat man solch eine Rekurrenzgleichung gefunden, so kann man daraus die Komplexität berechnen.
+	
+	\[
+		T(n) = \begin{cases}
+					\mathcal{O}(n^{d}) &, \text{wenn}\, d > \log_{b}(a) \\
+					\mathcal{O}(n^{d} \cdot \log(n)) &, \text{wenn}\, d = \log_{b}(a) \\
+					\mathcal{O}(n^{\log_{b}(a)}) &, \text{wenn}\, d < \log_{b}(a)
+				\end{cases}
+	\]
+	
+	Die Komplexität der rekursiven Berechnung der Fibonacci-Zahlen beispielsweise lässt sich nicht mit dem Mastertheorem berechnen, da sich die Größe der Subprobleme pro Rekursionsschritt nicht um einen festen Faktor verkleinern.
+	
+\section{Datenstrukturen}
+
+	\subsection{Listen}
+	
+		Es gibt zwei unterschiedliche Arten von Listen. Zum Einen gibt es Single-Linked-Lists, die nur in eine Richtung verbunden sind. Will man das letzte Element der Liste finden, muss man demnach vom Kopfelement die gesamte Liste durchgehen, um das letzte Element zu finden. Zum Anderen gibt es die Double-Linked-Lists, die in beide Richtungen verbunden sind. Dort kann man sich in beide Richtungen bewegen und spart damit Suchzeit, wenn man ein Element am Ende der Liste sucht.
+		
+		Neben diesen zwei grundsätzlichen Arten von Listen gibt es noch unterschiedliche Ausführungsvarianten. In der Praxis trifft man meistens auf Listen, die ein dediziertes Kopf- und Schlusselement haben, welches keinen eigentlichen Wert enthält. Diese "`Wächterknoten"' verhindern eine Reihe von Problemen (siehe SE 1). Desweiteren gibt es noch für Double-Linked-Lists die Variante mit einem und nicht zwei solcher Wächterknoten. Dabei zeigt das letzte Element der Liste wieder auf den Wächterknoten, wodurch ein Ring entsteht.
+		
+	\subsection{Bäume}
+	
+		Bäume sind eine besondere Art von Graphen, die keine Zyklen enthalten und ungerichtet sind. Bäume haben einen Wurzelknoten und ein oder mehrere Blätter (Knoten ohne Kindknoten). Jeder Knoten hat entweder Kindknoten oder ist ein Blatt. Bei einem Baum mit einem einzigen Knoten ist dieser sowohl Wurzel als auch Blatt.
+		
+		Es gibt für t-näre Bäume eine Sprachregelung, die festlegt wie ein solcher Baum heißt. Bei einem vollen (engl.: full) Baum hat jeder Knoten bis auf die Blätter t Kindknoten. Auf der untersten Ebene finden sich also $t^{h}$ Knoten, wobei $h$ die Höhe des Baumes bezeichnet. Die Wurzelebene ist mit Höhe $0$ versehen. Ein vollständiger Baum (engl.: complete) ist bis auf die unterste Ebene wie ein voller Baum. Auf der untersten Ebene befinden sich $1$ bis $t^{h}$ Blätter, die von links nach rechts angeordnet sind.
+		
+		Die Gesamtanzahl an Knoten entspricht bei einem vollen Baum $t^{h+1}-1$ und bei einem vollständigen Baum $t^{h} - 1 + c : 1 \leq c \leq t^{h}$. Die Höhe des Baumes wiederum lässt sich aus der gesamten Anzahl der Knoten berechnen. Bei einem vollen Baum entspricht die Höhe des Baumes, wenn $n$ die Anzahl der Knoten symbolisiert, $\log_{t}(n+1) - 1$. Für einen vollständigen Baum entspricht es $\ceil*{\log_{t}(n+1)-1}$.
+		
+	\subsection{Stack}
+	
+		Ein Stack ist nach dem LIFO--Prinzip organisiert und unterstützt zwei Operationen, die je nach Literatur anders heißen. Die erste Operation erlaubt das Einfügen eines Elementes in den Stack (\texttt{Insert(e)} bzw. \texttt{Push(e)}) und die zweite Operation erlaubt das Entnehmen des zuletzt eingefügten Elementes (\texttt{Delete()} bzw. \texttt{Pop()}).
+		
+		Ein Stack könnte sinnvoll mit einem Array implementiert werden.
+		
+	\subsection{Queue}
+	
+		Eine Queue arbeitet nach dem FIFO--Prinzip und unterstützt ebenso zwei Operationen. Die erste fügt ein Element in die Queue ein (\texttt{Insert(e)} bzw. \texttt{Enqueue(e)}) und die zweite Operation entfernt das vorderste Element in der Queue (\texttt{Delete()} bzw. \texttt{Dequeue()}).
+		
+		Queues können sinnvoll als Double--Linked--Lists implementiert werden. Alternativ könnte man ein Array nehmen, bei dem man sich immer merkt welche Position gerade vorne und welche hinten ist.
+		
+		Es gibt Abwandlungen der Queue, die das FIFO--Prinzip verletzen. Dies sind sogenannte Priority Queues, die das vorderste Element nach einer Sortierung bestimmen. Beispielsweise sorgt eine Min-Priority-Queue dafür, dass immer das Element mit dem geringsten Wert ganz vorne steht.
+		
+	\subsection{Heap}
+	
+		Ein Heap ist ein besonderer Baum, der nach bestimmten Kriterien sortiert ist. Bei einem Max--Heap befindet sich an der Wurzel der Knoten mit dem höchsten Wert und alle Kindknoten haben kleinere Werte. Dies gilt aber nicht nur für die Wurzel, sondern die Kindknoten jedes Knotens haben kleinere Werte als der Knoten, von dem sie Kinder sind.
+		
+		Für einen Heap sind fünf Operationen definiert. Die Operation \texttt{Heapify} geht vom gewählten Knoten zu den Blättern und tauscht den Knoten so lange herunter, bis die Heapeigenschaft für den gesamten Heap unter dem Knoten wieder gilt. Die Operation erfordert gültige Heaps unter dem Knoten. Das bedeutet, dass die Subbäume für sich (mit den Kindern des Knotens als Wurzelknoten) gültige Heaps sind. Die worst case Laufzeit ist $\mathcal{O}(\log n)$.
+		
+		Die zweite Operation \texttt{BuildMaxHeap} geht von den Blättern zum Wurzelknoten und stellt die Heapeigenschaft her. Dabei wird \texttt{Heapify} auf jeden Knoten ausgeführt. In jeder Ebene wird von rechts nach links vorgegangen, angefangen bei dem am weitesten unten rechts stehenden Knoten. Effektiv passiert auf Blattebene jedoch nichts, da diese keine Kindknoten haben, mit denen sie vertauscht werden könnten. Die Laufzeit beträgt $\mathcal{O}(n)$.
+		
+		Die dritte Operation ist \texttt{ExtractMax}. Die Operation entfernt den Wurzelknoten und zieht den am weitesten rechts unten stehenden Knoten zur Wurzelposition und wendet \texttt{Heapify} auf diesen Knoten an. Die Laufzeit beträgt $\mathcal{O}(\log n)$.
+	
+		Die vierte Operation heißt \texttt{DecreaseKey} und setzt den betreffenden Knoten auf den gewählten geringeren Wert und wendet \texttt{Heapify} auf diesen Knoten an. Die Laufzeit beträgt $\mathcal{O}(\log n)$.
+		
+		Das Gegenstück dazu ist \texttt{IncreaseKey}, welches nach dem Verändern des Wertes die Operation \texttt{BuildMaxHeap} ausführt. Die Laufzeit beträgt $\mathcal{O}(\log n)$.
+		
+\section{Hashing}
+
+	Hashing hat das Ziel eine große Menge an Werten auf eine kleinere Menge abzubilden. Eine der einfachsten Hashfunktionen ist die modulo-Funktion für ganze Zahlen. 
+	
+	Die Zielmenge wird durch ein Array repräsentiert, wobei die Indizes für die Werte stehen, auf die abgebildet wird. Wenn auf eine kleinere Menge abgebildet wird, sind Kollisionen natürlich unvermeidlich. Dies wird dadurch gehandhabt, dass jedes Arrayelement eine Liste ist, in die alle Werte eingetragen werden, die auf den zugehörigen Index gehasht werden.
+	
+	Das Ziel ist natürlich die Anzahl an Kollisionen pro Index möglichst klein zu halten und möglichst gleichmäßig zu hashen. Aus diesen Anforderungen ergibt sich, dass es bessere und schlechtere Hashfunktionen gibt. Allerdings gibt es keine perfekte Hashfunktion, sondern je nach Anwendungsgebiet kommen andere Funktionen in Betracht.
+	
+	Eine mögliche Strategie der Kollisionsvermeidung ist das Weiterlaufen bis zum nächsten freien Index. Kommt man am Ende des Arrays an, wird wieder von vorne begonnen.
+	
+\section{Sortierverfahren}
+
+	\subsection{Selection Sort}
+	
+		Selection Sort kann man sich gut mit Karten veranschaulichen. Man hat eine Menge an Karten offen vor sich liegen und nimmt nacheinander die Karten in die Hand, beginnend mit der niedrigsten Karte, und reiht sie dort von links nach rechts auf. Die Laufzeit beträgt im worst case $\mathcal{O}(n^{2})$.
+		
+	\subsection{Insertion Sort}
+	
+		Insertion Sort wendet man zum Beispiel bei Skat meist intuitiv an. Man hat eine Menge an verdeckten Karten, zieht nacheinander die jeweils höchste Karte und reiht sie entsprechend in die Hand ein, wobei die niedrigste Karte links und die höchstwertige Karte rechts ist. Die worst case Laufzeit beträgt hier ebenfalls $\mathcal{O}(n^{2})$.
+		
+	\subsection{Bubble Sort}
+	
+		Bubble Sort ist trotz gleicher worst case Laufzeit deutlich arbeitsaufwendiger für Menschen. Denn bereits bei 4 Werten ergeben sich 16 Durchgänge, um die Werte korrekt zu sortieren.
+		
+		Die beste Erklärung des Sortierverfahrens bietet der Pseudocode.
+		
+		\begin{algorithmic}[1]
+			\Procedure{Bubblesort}{A}
+				\For{i $\gets$ 1 to A.length - 1}
+					\For{j $\gets$ A.length downto i + 1}
+						\If{A[j] < A[j - 1]}
+							\State exchange A[j] with A[j - 1]
+						\EndIf
+					\EndFor
+				\EndFor
+			\EndProcedure
+		\end{algorithmic}
+		
+	\subsection{Merge Sort}
+	
+		Merge Sort ist mit einer worst case Laufzeit von $\mathcal{O}(n \cdot \log n)$ eines der besten vergleichsbasierten Sortierverfahren. Man nehme eine Reihe von Werten und sehe sie als einzelne Elemente an. Nun verbindet man immer zwei Elemente miteinander und bringt sie gleich in die richtige Reihenfolge. Dabei geht man rigoros von links nach rechts. Man verbindet demnach das erste und zweite Element, das dritte und vierte Element usw. Ist man damit fertig, verbindet man jeweils zwei dieser Zweierpärchen und sortiert alle enthaltenen Elemente in die richtige Reihenfolge. Auch dies wiederholt man für alle Pärchen. Diesen Vorgang wiederholt man nun solange bis am Ende nur noch eine korrekt sortierte Liste herauskommt. 
+		
+		Merge Sort kann man auch als Divide--and--conquer Verfahren bezeichnen. Es ergibt sich die folgende Rekurrenzgleichung.
+		
+		\[
+			T(n) = 2 \cdot T\left(\frac{n}{2}\right) + \mathcal{O}(n)
+		\]
+		
+	\subsection{Heap Sort}
+	
+		Heap Sort macht sich die Heapeigenschaft zunutze und speichert alle Elemente in einem Heap. Somit lässt sich der höchste Wert (Max--Heap) einfach auslesen.
+		
+		Der Pseudocode liest sich folgendermaßen:
+		
+		\begin{algorithmic}[1]
+			\Function{HeapSort}{A}
+				\State n $\gets$ \Call{length}{A}
+				\State B $\gets$ empty array of length n
+				\State H $\gets$ \Call{BuildMaxHeap}{A}
+				\For{i $\gets$ 1 to n}
+					\State B(n - i) $\gets$ \Call{ExtractMax}{H}
+				\EndFor
+				\State \Return B
+			\EndFunction
+		\end{algorithmic}
+		
+		Das Verfahren hat eine Laufzeit von $\mathcal{O}(n \cdot \log n)$, die sowohl die sowohl worst case als auch best case Laufzeit ist.
+		
+	\subsection{Quick Sort}
+	
+		Quick Sort funktioniert ähnlich wie Merge Sort, nur dass es mit einer kompletten Liste anfängt und dann immer weiter aufteilt und am Ende nur noch zusammenfügen muss. Dies funktioniert durch die Wahl eines Pivotelementes. Im Idealfall teilt es die Liste in zwei gleichgroße Teillisten. Die worst case Laufzeit beträgt $\mathcal{O}(n^{2})$. In den meisten Fällen benötigt Quick Sort jedoch nur $\mathcal{O}(n \cdot \log n)$.
+		
+		Trotz der vermeintlich schlechten Laufzeit wird Quick Sort in der Praxis viel eingesetzt, da es in der Praxis auch auf die Konstanten ankommt, die in der Landau--Notation weggelassen werden. Quick Sort hat vergleichsweise kleine Konstanten wohingegen andere Verfahren mit einer besseren worst case Laufzeit meist größere Konstanten haben.
+	
+	\subsection{Counting Sort}
+	
+		Counting Sort ist ein Sortierverfahren, welches nicht vergleichsbasiert ist. Es gibt zwei prominente Implementationsmöglichkeiten. Die erste Möglichkeit ist ein Array mit Countern. Die zweite Möglichkeit ist ein Array mit Listen. Im Folgenden bezeichne K den höchsten Wert in der zu sortierenden Liste (nicht unbedingt die Datenstruktur in der diese Liste an Werten gespeichert ist).
+		
+		Zunächst der Pseudocode für die erste Variante.
+		
+		\begin{algorithmic}[1]
+			\Function{CountingSort}{A}
+				\State n $\gets$ \Call{length}{A}
+				\State Allocate array B with length K, initialize each cell with 0
+				\For{i $\gets$ 1 to n}
+					\State B[A[i]] $\gets$ B[A[i]] + 1
+				\EndFor
+				\State C $\gets$ empty list
+				\For{key, count in B}
+					\While{count > 0}
+						\State C.append(key)
+						\State count $\gets$ count - 1
+					\EndWhile
+				\EndFor
+				\State \Return C
+			\EndFunction
+		\end{algorithmic}
+		
+		Die zweite For-Schleife ist nur zum Erstellen der sortierten Liste. Die Laufzeit beträgt K für das Initialisieren des Arrays B, n für die erste For-Schleife, K für die zweite For-Schleife und maximal n für die While-Schleife. Dabei ist jedoch zu berücksichtigen, dass die While-Schleife insgesamt über alle Iterationen der For-Schleife nur n--mal aufgerufen wird, denn die Summe aller Counts entspricht der Länge der zu sortierenden Liste an Zahlen. Die Gesamtlaufzeit ist demnach $\mathcal{O}(K + n + n)$ bzw. $\mathcal{O}(K + 2n)$. Die Laufzeit K der zweiten For-Schleife ist hier nicht berücksichtigt, da die While-Schleife insgesamt nur n--mal aufgerufen wird und in den übrigen Fällen in der For-Schleife nichts ausgeführt wird. Nach den Regeln der Landau--Notation entfällt hier das zweite n bzw. die Konstante, da es nichts an der asymptotischen Laufzeit verändert. Die Gesamtlaufzeit ist damit $\mathcal{O}(K + n)$.
+		
+		Die zweite Variante mit Listen im Array wird etwas anders implementiert, hat aber die gleiche Laufzeit.
+		
+		\begin{algorithmic}[1]
+			\Function{CountingSort}{A}
+				\State n $\gets$ \Call{length}{A}
+				\State Allocate array B with length K, initialize each cell with an empty list
+				\For{i $\gets$ 1 to n}
+					\State B[A[i]].append(A[i])
+				\EndFor
+				\State \Return concatenation of B[1], B[2], ..., B[K]
+			\EndFunction
+		\end{algorithmic}
+		
+		Die Laufzeit beträgt hier K für das Initialisieren von B und n für die For-Schleife. Insgesamt ergibt sich somit $\mathcal{O}(n + K)$.
+		
+	\subsection{Radix Sort}
+	
+		Radix Sort ist im Prinzip Counting Sort mit ein paar Veränderungen. Die obere Grenze der Zahlen kann riesig sein ($K = \omega(n)$). Um dem beizukommen stellt man sich jede Zahl als ein String vor. Zunächst werden die Zahlen nach der letzten Ziffer sortiert, dann nach der zweitletzten und so weiter. Dieses Verfahren setzt Counting Sort in der zweiten Variante voraus.
+		
+		Da stets nur nach Ziffern sortiert wird, kann man die Arraylänge auf 10 begrenzen, denn es gibt nur 10 Ziffern. Demzufolge braucht man auch bei einem K von einer Million nur ein Array von 10, um alle Zahlen nach der letzten Ziffer dort einzusortieren in Listen.
+		
+		Als Beispiel nehme man die Zahlen 10, 3, 5, 15, 20, 7 , 11 und 13. Diese werden in der Reihenfolge ihres Erscheinens sortiert und ergeben folgendes Bild im Array B.
+		
+		\begin{alignat*}{1}
+			B[0]:& 10 \rightarrow 20 \\
+			B[1]:& 11 \\
+			B[2]:& \\
+			B[3]:& 3 \rightarrow 13 \\
+			B[4]:& \\
+			B[5]:& 5 \rightarrow 15 \\
+			B[6]:& \\
+			B[7]:& 7 \\
+			B[8]:& \\
+			B[9]:&
+		\end{alignat*}
+		
+		Im zweiten Schritt wird nun das Array und in jeder Zelle die Liste von vorne bis hinten durchgegangen und die jeweils aktuelle Zahl wird dann nach der zweitletzten Ziffer in ein Array C einsortiert. Zahlen mit weniger Ziffern (in diesem Fall die einstelligen Zahlen) werden bei der 0 einsortiert. Am Ende ergibt sich die richtige Reihenfolge und es müssen nur noch alle Zahlen konkateniert werden, um das Ergebnis zu erhalten.
+		
+		Allerdings kann Radix Sort auch auf andere Zahlensysteme angewendet werden. Dann ist die Menge an möglichen Ziffern nicht gleich 10. Daher wird die Anzahl an möglichen Ziffern mit k bezeichnet und die Laufzeit zum Sortieren nach einer Ziffernposition ist dementsprechend $\theta(n + k)$. Counting Sort muss n--mal ausgeführt werden und das Array mit den Listen muss k lang sein und initialisiert werden. Dies ist jedoch nur ein Durchgang. Für die insgesamte Laufzeit von Radix Sort wird eine weitere Variable namens d benötigt, die die maximal mögliche Anzahl an Ziffern in einer Zahl bezeichnet (nicht zu verwechseln mit der Menge der möglichen Ziffern). Die Laufzeit beträgt sodann auch $\theta(d(n + k))$.
+		
+		In unserem Beispiel oben ist k konstant und d ebenso. Demnach fallen beide Weg und es bleibt $\mathcal{O}(n)$ übrig. Wenn k konstant bleibt, aber d in logarithmische Abhängigkeit zu n gestellt wird, dann ergibt sich eine Laufzeit von $\mathcal{O}(n \cdot \log n)$. Ist d sogar gleich n, dann benötigt Radix Sort $\mathcal{O}(n^{2})$.
+		
+		Warum wird Radix Sort dann überhaupt benutzt? Mithilfe von einigen Modifikationen kann man eine lineare Laufzeit erreichen und zwar als worst case. Dies ist möglich mit dem Block-based Radix Sort. Allerdings muss man vorher wissen in welchen Bereich die zu sortierenden Zahlen fallen. Genaueres siehe AD-Folienskript.
+		
+	\subsection{Bucket Sort}
+	
+		Bucket Sort wird zur Sortierung von reellen Zahlen verwendet, die gleichmäßig im Intervall [0,1] vorkommen. Angenommen man bekommt ein Eingabearray der Länge n, dann kann man das Intervall in n Buckets gleicher Länge zerteilen, wobei Bucket i alle Schlüsselwerte des Intervalls $\left[\frac{i}{n}, \frac{(i + 1)}{n}\right[$ enthält.
+		
+		Die durchschnittliche Laufzeit beträgt $\mathcal{O}(n)$ und die worst case Laufzeit beträgt $\mathcal{O}(n \cdot \log n)$.
+		
+	\subsection{Stabilität von Sortierverfahren}
+		
+		Die Angabe "`wie in AD"' bedeutet, dass die in AD verwendete Variante gemeint ist und es andere Varianten gibt, bei denen das Gegenteilige gilt.
+		
+		\begin{tabular}{c|c}
+			Verfahren & stabil \\
+			\hline
+			Merge Sort & ja \\
+			Quick Sort & ja, wie in AD \\
+			Insertion Sort & nein, wie in AD \\
+			Selection Sort & nein, wie in AD \\
+			Heap Sort & nein \\
+			Bubble Sort & ja \\
+			Counting Sort & ja, in der zweiten Variante
+		\end{tabular}
+		
+	\subsection{Lower bound}
+	
+		Für alle vergleichsbasierten Sortierverfahren gilt, dass sie eine worst case Laufzeit von $\Omega(n \cdot \log n)$ haben.
+		
+\section{Binäre Suchbäume}
+
+	Binäre Suchbäume haben eine besondere Struktur, die das Suchen erleichtert. Alle linken Kindknoten sind kleiner oder gleich des Elternknoten und alle rechten Kindknoten sind größer oder gleich des Elternknoten. Diese Bedingung gilt für alle Knoten mit Kindern.
+	
+	Aufgrund dessen ist das Einfügen in solch einen Baum relativ deterministisch. Das Löschen gestaltet sich da schon etwas komplizierter.
+	
+	Zunächst werden jedoch die Operationen der Reihe nach durchgegangen. Die erste Operation ist \texttt{Tree-Search} mit folgendem Pseudocode.
+	
+	\begin{algorithmic}[1]
+		\Function{Tree-Search}{x, k}
+			\If{x == NIL or k == x.key}
+				\State \Return x
+			\EndIf
+			\If {k < x.key}
+				\State \Return \Call{Tree-Search}{x.left, k}
+			\Else
+				\State \Return \Call{Tree-Search}{x.right, k}			
+			\EndIf
+		\EndFunction
+	\end{algorithmic}
+	
+	Die Laufzeit beträgt $\mathcal{O}(h)$, wobei h die Höhe des Baumes angibt.
+	
+	Das Minimum des Baumes kann gefunden werden, indem immer das linke Kind genommen wird bis ein Blatt erreicht wird. Dieses Blatt ist das minimale Element des Baumes. Die Laufzeit beträgt ebenso $\mathcal{O}(h)$. Das Maximum findet man analog, nur dass man dort immer das rechte Kind benutzt.
+	
+	Die zweite Operation ist \texttt{Inorder-Tree-Walk} mit diesem Pseudocode.
+	
+	\begin{algorithmic}[1]
+		\Procedure{Inorder-Tree-Walk}{x}
+			\If{x $\neq$ NIL}
+				\State \Call{Inorder-Tree-Walk}{x.left}
+				\State \Call{print}{x.key}
+				\State \Call{Inorder-Tree-Walk}{x.right}
+			\EndIf
+		\EndProcedure
+	\end{algorithmic}
+	
+	Sie hat eine Laufzeit von $\theta(n)$.
+	
+	Nun kommen wir zum Einfügen von Elementen. Für das Einfügen wird der Baum einfach heruntergegangen und das neue Element an der richtigen Stelle eingefügt. Die Laufzeit beträgt hier ebenso $\mathcal{O}(h)$.
+	
+	Für das Entfernen eines Blattes ist es vergleichsweise einfach. Das Blatt kann einfach entfernt werden. Wenn ein Knoten nur einen linken oder nur einen rechten Kindknoten hat, dann können diese einfach an die Position des zu löschenden Knoten rücken. Hat der zu löschende Knoten jedoch sowohl einen linken als auch einen rechten Kindknoten, dann muss dessen Nachfolger gefunden werden. Dafür wird der am weitesten links stehende Knoten im rechten Teilbaum (mit dem rechten Kind des zu löschenden Knoten als Wurzel) herangezogen. Dieser wird dann an die Stelle des zu löschenden Knoten gesetzt und dessen rechtes Kind (falls vorhanden) wird an die Stelle von dem Nachfolger gesetzt.
+	
+	Den Nachfolger zu finden dauert $\mathcal{O}(h)$. Der Rest passiert in konstanter Zeit, sodass die insgesamte Dauer ebenfalls $\mathcal{O}(h)$ ist. Da alle Operationen nur $\mathcal{O}(h)$ benötigen, wäre es natürlich von Interesse das h so klein wie möglich zu haben. Da kommen balancierte Bäume ins Spiel. Bei balancierten Bäumen unterscheidet sich die Höhe der beiden Teilbäume unter einem Knoten um maximal 1 (Bedingung gilt für alle Knoten).
+	
+	\subsection{AVL Bäume}
+
+		AVL Bäume unterstützen Operationen, um die Balanciertheit wiederherzustellen. Allerdings ist dies nicht klausurrelevant, da Frau Luxburg diesen Bereich selber nicht sonderlich versteht.
+	
+		Dennoch wird hier eine kurze Information zu den Operationen gegeben. Die Operationen heißen \texttt{RightRotate} und \texttt{LeftRotate} und benötigen jeweils nur konstante Zeit. Wird die Balanciertheit eines Baumes durch eine Einfüge- oder Löschoperation verletzt, dann müssen maximal Balancieroperationen ausgeführt werden, um die Balanciertheit wiederherzustellen.
+	
+		Die Laufzeit vom Einfügen in einen solchen balancierten Baum beträgt $\mathcal{O}(\log n)$. Das Standardeinfügen benötigt $\mathcal{O}(\log n)$, das checken der Balanciertheit dauert ebenfalls $\mathcal{O}(\log n)$ und für die Wiederherstellung der Balanciertheit werden maximal zwei Rotationen in je konstanter Zeit ausgeführt.
+	
+	\subsection{Red-black tree}
+	
+		Ein Red-black tree hat folgende Eigenschaften.
+		
+		\begin{itemize}
+			\item jeder Knoten ist gefärbt (schwarz/rot)
+			\item Wurzel und Blätter sind schwarz
+			\item roter Knoten hat zwei schwarze Kinder
+			\item von jedem Knoten aus haben alle Pfade zu den Blättern die gleiche Anzahl schwarze Knoten
+			\item ein schwarzer Knoten kann sowohl schwarze als auch rote Kinder haben
+		\end{itemize}
+		
+\section{Binäre Suche}
+
+	Bei der binären Suche hat man ein sortiertes Array gegeben. Nun schaut man sich immer das mittlere Element an und wenn dies kleiner dem gesuchten Element ist, dann wird die binäre Suche auf den rechten Teilbereich des Arrays angewendet. Ist das mittlere Element größer, so wird die binäre Suche auf den linken Teil angewendet und wenn das mittlere Element dem gesuchten Element entspricht, dann wird die Indexposition zurückgegeben. Wird das gesuchte Element nicht gefunden, dann wird \texttt{not\_found} zurückgegeben.
+	
+	Der Pseudocode sieht folgendermaßen aus.
+	
+	\begin{algorithmic}[1]
+		\Function{BinarySearch}{A, value}
+			\State low $\gets$ 0
+			\State high $\gets$ N - 1
+			\While{low $\leq$ high}
+				\State mid $\gets$ (low + high) / 2
+				\If{A[mid] > value}
+					\State high $\gets$ mid - 1
+				\ElsIf{A[mid] < value}
+					 \State low $\gets$ mid + 1
+				\Else
+					\State \Return mid
+				\EndIf
+			\EndWhile
+		\EndFunction
+	\end{algorithmic}
+	
+	Die Laufzeit beträgt $\mathcal{O}(\log n)$.
+	
+	Es gibt jedoch auch noch andere Varianten der binären Suche, wie eine rekursive Variante und eine Variante, bei der, wenn das gesuchte Element nicht vorhanden ist, die Position zurückgegeben wird, bei der das gesuchte Element eingefügt werden kann, sodass das Array weiterhin sortiert ist.
+	
+\section{Graphen}
+
+	Bei dem Abschnitt über Bäume wurden Graphen kurz angeschnitten. Hier wird sich jetzt ausführlicher mit ihnen beschäftigt. Es gibt verschiedene Arten von Graphen.
+	
+	Graphen können ungerichtet oder gerichtet sein und sie können gewichtet oder ungewichtet sein. Allerdings ist ein ungewichteter Graph äquivalent mit einem gewichteten Graphen, bei dem alle Kanten das Gewicht 1 haben. Ein ungerichteter Graph kann in einen gleichwertigen gerichteten Graphen überführt werden, indem jede Kante durch eine Hin- und Rückkante ersetzt wird.
+	
+	Der Grad eines Knotens kann in einem ungerichteten Graphen durch folgende Formel errechnet werden.
+	
+	\[
+		Grad(u) = \sum\limits_{v \in V} w(u, v)
+	\]
+	
+	Bei einem gerichteten Graphen gibt es zwei Grade bei einem Knoten. Der Eingangsgrad und der Ausgangsgrad. Beide können folgendermaßen berechnet werden.
+	
+	\begin{alignat*}{1}
+		Grad-in(u) =& \sum\limits_{v \in V} w(v, u) \\
+		Grad-out(u) =& \sum\limits_{v \in V} w(u, v)
+	\end{alignat*}
+	
+	Pfade sind eine beliebige Abfolge von Kanten. Ein Pfad ist ein Zyklus, wenn ein Knoten sowohl Anfangs- als auch Endknoten ist. Ein Pfad ist einfach (engl.: simple), wenn jeder Knoten nur einmal vorkommt.
+	
+	Man kann Graphen in zusammenhängende und nicht zusammenhängende Graphen unterteilen. Dabei wird ein Graph als zusammenhängend bezeichnet, wenn von jedem Knoten zu jedem anderen Knoten ein Pfad gefunden werden kann (ungerichteter Graph). Ein gerichteter Graph heißt stark zusammenhängend, wenn von jedem Knoten zu jedem anderen ein gerichteter Pfad gefunden werden kann. Ein gerichteter Graph ist schwach zusammenhängend, wenn der zugehörige ungerichtete Graph zusammenhängend ist.
+	
+	Eine Zusammenhangskomponente ist ein Teilgraph des Graphen und ist zusammenhängend. In einem zusammenhängenden Graphen gibt es nur eine Zusammenhangskomponente. In einem gerichteten Graphen sind die starken Zusammenhangskomponenten interessant. Dies sind Teilgraphen des Graphen, die stark zusammenhängend sind. Ein Graph kann schwach zusammenhängend sein und dennoch mehrere starke Zusammenhangskomponenten haben.
+	
+	In einem vollständigen Graph ist jeder Knoten mit jedem anderen Knoten durch eine Kante verbunden.
+	
+	Die Kanten eines Graphen können mithilfe von Adjazenzlisten oder einer Adjazenzmatrix dargestellt werden.
+	
+	Desweiteren kann ein Graph dicht sein (engl.: dense). Dies bedeutet, dass der Graph sehr viele Kanten hat (ungefähr $|V|^{2}$). Außerdem kann ein Graph dünn sein (engl.: sparse). Dies bedeutet, dass der Graph sehr wenige Kanten hat.
+	
+\section{Graphalgorithmen}
+
+	\subsection{Bellman--Ford}
+	
+		Der Bellman-Ford Algorithmus hat folgenden Pseudocode, der bereits eindrücklich zeigen sollte, wie der Algorithmus funktioniert.
+		
+		\begin{algorithmic}[1]
+			\Function{BellmanFord}{G, s}
+				\State \Call{InitializeSingleSource}{G, s}
+				\For{i $\gets$ 1 to |V| - 1}
+					\ForAll{edges (u, v) $\in$ E}
+						\State \Call{Relax}{u, v}
+					\EndFor
+				\EndFor
+				\ForAll{edges (u, v) $\in$ E}
+					\If{v.dist > u.dist + w(u, v)} \Comment{auf negativen Zyklus prüfen}
+						\State \Return false
+					\EndIf
+				\EndFor
+			\EndFunction
+		\end{algorithmic}
+		
+		Die Laufzeit ist wenig verwunderlich: $\mathcal{O}(|V| \cdot |E|)$.
+		
+		Der Algorithmus wird benutzt, um kürzeste Wege zu berechnen. Genauer wird er für das Single--Source--Shortest--Path--Problem verwendet.
+		
+	\subsection{Dijkstra}
+	
+		Dijkstra gibt es in zwei Variationen. Beide verhalten sich gleich, haben aber Unterschiede in der Laufzeit. Die naive Variante hat diesen Pseudocode.
+		
+		\begin{algorithmic}[1]
+			\Procedure{DijkstraNaive}{G, w, s}
+				\State S $\gets$ {s}
+				\State d(s) $\gets$ 0
+				\While{S $\neq$ V}
+					\State U $\gets$ {u $\not\in$ S | u neighbour of a vertex $\in$ S}
+					\ForAll{u $\in$ U}
+						\ForAll{\Call{pre}{u} $\in$ S that are predecessors of u}
+							\State d'(u, \Call{pre}{u}) $\gets$ d(\Call{pre}{u}) + w(\Call{pre}{u}, u)
+						\EndFor
+					\EndFor
+					\State $u^{*} \gets$ argmin\{d'(u, \Call{pre}{u}) | u $\in$ U, \Call{pre}{u} $\in$ S\}
+					\State d($u^{*}$) $\gets$ d'($u^{*}$)
+					\State S $\gets$ S $\cup$ \{$u^{*}$\}
+				\EndWhile
+			\EndProcedure
+		\end{algorithmic}
+		
+		Die Laufzeit der naiven Variante beträgt $\mathcal{O}(|V| \cdot |E|)$.
+		
+		Die zweite Variante ist die Implementation mit der Min--Priority--Queue. Der Pseudocode dieser Variante folgt.
+		
+		\begin{algorithmic}[1]
+			\Procedure{Dijkstra}{G, w, s}
+				\State Q $\gets$ (V, V.dist)
+				\While{Q $\neq \empty$}
+					\State u $\gets$ \Call{Extract}{Q}
+					\ForAll{v adjacent to u}
+						\State \Call{Relax}{u, v} and update the keys in Q accordingly
+					\EndFor
+				\EndWhile
+			\EndProcedure
+		\end{algorithmic}
+		
+		Die Laufzeit mit der Min--Priority--Queue hängt von der Implementation der Queue ab. Bei einem naiven Array beträgt die Laufzeit $\mathcal{O}(n^{2})$. Bei der Implementation mit einem binären Heap sind es nur noch $\mathcal{O}((V + E)\log V)$. Bei der Implementation mit einem t-nären Heap sind es $\mathcal{O}\left((|V| \cdot t + |E|)\frac{\log V}{\log t}\right)$. Die beste Laufzeit kann mit einem Fibonacci Heap erreicht werden: $\mathcal{O}(V \log V + E)$.
+		
+		Wenn der Graph dicht ist, dann sollte die Arrayimplementation genommen werden. Wenn der Graph dünn ist, dann sollte die Heapimplementation bevorzugt werden. Wenn der Graph sehr dünn ist (|E| = $\Omega(|V|)$) bekommen wir die Laufzeit $\mathcal{O}(|V| \log |V|)$.
+		
+		Auch dieser Algorithmus gehört zum Single--Source--Shortest--Path--Problem.
+	
+	\subsection{Floyd--Warshall}
+	
+		Floyd--Warshall ist ein Graphalgorithmus, mit dem man die kürzesten Pfade von jedem Knoten zu jedem Knoten herausfinden kann (All--Pairs--Shortest--Path--Problem). Der Pseudocode ist folgender.
+		
+		\begin{algorithmic}[1]
+			\Function{FloydWarshall}{}
+				\State n $\gets$ |V|
+				\State $D^{(0)} \gets$ new $n \times n$ matrix with all values being $\infty$
+				\ForAll{v $\in$ V}
+					 \State $d_{0}(v,v) \gets$ 0
+				\EndFor
+				\ForAll{(u,v) $\in$ E}
+					\State $d_{0}(u,v) \gets$ w(u,v)
+				\EndFor
+				\For{k $\gets$ 1 to n}
+					\State $D^{k} \gets$ new $n \times n$ matrix
+					\For{s $\gets$ 1 to n}
+						\For{t $\gets$ 1 to n}
+							\State $d_{k}(s, t) \gets$ min\{$d_{k-1}(s, t)$, $d_{k-1}(s, k) + d_{k-1}(k, t)$\}
+						\EndFor
+					\EndFor
+				\EndFor
+				\State \Return $D^{(n)}$
+			\EndFunction
+		\end{algorithmic}
+		
+		Die Laufzeit beträgt $\mathcal{O}(|V|^{3})$.
+		
+	\subsection{Bidirektionaler Dijkstra}
+	
+		Der Bidirektionale Dijkstra besteht aus zwei Dijkstra--Algorithmen, die wechselweise ausgeführt werden. Der erste Dijkstra startet beim Startknoten und der zweite Dijkstra startet beim Zielknoten. Beide Algorithmen sind ganz normale Dijkstra--Algorithmen, die solange laufen bis ein Algorithmus einen Knoten aufnimmt, der bereits von dem anderen Algorithmus aufgenommen wurde.
+		
+		Der kürzeste Pfad muss aber nicht über diesen Knoten laufen.
+	
+	\subsection{A*--Suche}
+	
+		$A^{*}$--Suche ist ein modifizierter Dijkstra--Algorithmus. Für jeden Knoten gibt es einen Wert, der die Entfernung zum Ziel angibt. Diese Entfernung muss nicht immer exakt sein, sodass auch eine untere Grenze wie die Luftlinienentfernung hinreichend ist.
+		
+		Diese Entfernung wird bei der Auswahl des nächsten Knotens berücksichtigt. Der Knoten mit dem geringsten Abstand zum Startknoten plus der abgeschätzten Entfernung zum Ziel wird als nächstes ausgewählt.
+		
+	\subsection{SCC--Algorithmus}
+	
+		Der SCC--Algorithmus wird zum Bestimmen von starken Zusammenhangskomponenten beynutzt. Der Algorithmus kann in Worten wie folgt beschrieben werden.
+		
+		\begin{algorithmic}[1]
+			\Procedure{SCC}{G}
+				\State Call \Call{DFS}{G} to compute the finishing times \Call{f}{u}
+				\State Compute the reverse graph $G^{t}$
+				\State Call \Call{DFS}{$G^{t}$}, where the vertices in the main loop are considered in order of decreasing \Call{f}{u}
+				\State Output the subsets that have been discovered by the individual calls of DFS--Visit
+			\EndProcedure
+		\end{algorithmic}
+		
+		Die Laufzeit beträgt insgesamt $\mathcal{O}(|V| + |E|)$.
+		
+	\subsection{Kruskals Algorithmus}
+	
+		Kruskals Algorithmus geht die Kanten in nicht absteigender Reihenfolge durch und nimmt alle Kanten auf, die keinen Zyklus ergeben.
+		
+	\subsection{Prims Algorithmus}
+	
+		Prims Algorithmus beginnt bei einem Startknoten, der zu Beginn einziger Bestandteil der Menge $S$ ist. Prim fügt in jedem Schritt eine Kante hinzu, die $S$ mit $V \setminus S$ verbindet und von allen potentiellen Kanten die mit dem geringsten Gewicht ist.
+		
+\section{Dynamisches Programmieren}
+
+	%TODO
+	
+\section{Edit distance}
+
+	%TODO
+	
+	\[
+		E(i, j) = min\begin{cases}
+			E(i - 1, j) + 1 \\
+			E(i, j - 1) + 1 \\
+			E(i - 1, j - 1) + \mathrm{1}_{x[i] \neq y[j]}
+		\end{cases}
+	\]
+\end{document}

bv/hist_dist_Euclidean.m

@@ -0,0 +1,18 @@
+function [ distance ] = hist_dist_Euclidean( h1, h2 )
+%HIST_DIST_EUCLIDEAN Calculates euclidean distance between histograms
+
+    sum_of_differences = 0;
+    s = size(h1);
+    if s(1) > 1
+        n = s(1);
+    else
+        n = s(2);
+    end
+    for i = 1:n
+        sum_of_differences = sum_of_differences + (h1(i) - h2(i))^2; 
+    end
+
+    distance = sqrt(sum_of_differences);
+
+end
+

bv/hist_dist_Manhattan.m

@@ -0,0 +1,14 @@
+function [ distance ] = hist_dist_Manhattan( h1, h2 )
+%HIST_DIST_MANHATTAN Calculates the Manhattan distance between 2 histograms
+    distance = 0;
+    s = size(h1);
+    if s(1) > 1
+        n = s(1);
+    else
+        n = s(2);
+    end
+    for i = 1:n
+        distance = distance + abs(h1(i) - h2(i));
+    end
+end
+

bv/hist_dist_intersection.m

@@ -0,0 +1,15 @@
+function [ intersection ] = hist_dist_intersection( h1, h2 )
+%HIST_DIST_INTERSECTION Calculates intersection between 2 histograms
+
+    intersection = 0;
+    s = size(h1);
+    if s(1) > 1
+        n = s(1);
+    else
+        n = s(2);
+    end
+    for i = 1:n
+        intersection = intersection + min(h1(i), h2(i));
+    end
+end
+

bv/uebung1.m

@@ -0,0 +1,15 @@
+% 1.
+M = [1 2; 3 4; 5 6];
+M = [M(1, 1:2) M(3, 1:2) M(2, 1:2)];
+
+% 2.
+lowerBound = 0;
+upperBound = 10;
+M2 = (upperBound-lowerBound).*rand(10, 10) + lowerBound;
+M2(1, 1:end) = 1;
+M2(1:end, 1) = 1;
+
+% 3.
+rowVector = zeros(1, 200);
+rowVector(1:4) = [8 6 4 2];
+rowVector(end) = 10;

bv/uebung10.m

@@ -0,0 +1,42 @@
+% 1.
+I_1 = rgb2gray(imread('laptop-1.JPG'));
+I_1_lighted = rgb2gray(imread('laptop-1l.JPG'));
+I_1_1 = rgb2gray(imread('laptop-1-1.JPG'));
+I_2 = rgb2gray(imread('laptop-2.JPG'));
+I_2_lighted = rgb2gray(imread('laptop-2l.JPG'));
+
+points_1 = detectHarrisFeatures(I_1);
+points_1_lighted = detectHarrisFeatures(I_1_lighted);
+points_1_1 = detectHarrisFeatures(I_1_1);
+points_2 = detectHarrisFeatures(I_2);
+points_2_lighted = detectHarrisFeatures(I_2_lighted);
+
+[features1,valid_points1] = extractFeatures(I_1, points_1);
+[features2,valid_points2] = extractFeatures(I_1_lighted, points_1_lighted);
+[features3,valid_points3] = extractFeatures(I_1_1, points_1_1);
+[features4,valid_points4] = extractFeatures(I_2, points_2);
+[features5,valid_points5] = extractFeatures(I_2_lighted, points_2_lighted);
+
+% compare almost identical images (same spot)
+indexPairs1 = matchFeatures(features1, features3);
+matchedPoints1_1 = valid_points1(indexPairs1(:,1),:);
+matchedPoints1_3 = valid_points3(indexPairs1(:,2),:);
+figure; showMatchedFeatures(I_1, I_1_1, matchedPoints1_1, matchedPoints1_3);
+
+% compare two different viewpoints, same lighting conditions
+indexPairs2 = matchFeatures(features1, features4);
+matchedPoints2_1 = valid_points1(indexPairs2(:,1),:);
+matchedPoints2_4 = valid_points4(indexPairs2(:,2),:);
+figure; showMatchedFeatures(I_1, I_2, matchedPoints2_1, matchedPoints2_4);
+
+% compare same viewpoint, different lighting
+indexPairs3 = matchFeatures(features1, features2);
+matchedPoints3_1 = valid_points1(indexPairs3(:,1),:);
+matchedPoints3_2 = valid_points2(indexPairs3(:,2),:);
+figure; showMatchedFeatures(I_1, I_1_lighted, matchedPoints3_1, matchedPoints3_2);
+
+% compare different viewpoints, different lighting
+indexPairs4 = matchFeatures(features1, features5);
+matchedPoints4_1 = valid_points1(indexPairs4(:,1),:);
+matchedPoints4_5 = valid_points5(indexPairs4(:,2),:);
+figure; showMatchedFeatures(I_1, I_2_lighted, matchedPoints4_1, matchedPoints4_5);

bv/uebung11.txt

@@ -0,0 +1,6 @@
+exercise 1:
+0: blue
+1-left,3: yellow
+1-top: red
+2,4-left,5,6,7: watershed
+4-right,8: green

bv/uebung11_presence.m

@@ -0,0 +1,75 @@
+A = imread('kobi.png');
+[L,N] = superpixels(A,500);
+figure
+BW = boundarymask(L);
+imshow(imoverlay(A,BW,'cyan'))
+
+%   Set color of each pixel in output image to the mean RGB color of the
+%   superpixel region.
+outputImage = zeros(size(A),'like',A);
+idx = label2idx(L);
+numRows = size(A,1);
+numCols = size(A,2);
+for labelVal = 1:N
+    redIdx = idx{labelVal};
+    greenIdx = idx{labelVal}+numRows*numCols;
+    blueIdx = idx{labelVal}+2*numRows*numCols;
+    outputImage(redIdx) = mean(A(redIdx));
+    outputImage(greenIdx) = mean(A(greenIdx));
+    outputImage(blueIdx) = mean(A(blueIdx));
+end
+
+figure
+imshow(outputImage)
+
+% 2.
+he = imread('hestain.png');
+imshow(he), title('H&E image');
+text(size(he,2),size(he,1)+15,...
+     'Image courtesy of Alan Partin, Johns Hopkins University', ...
+     'FontSize',7,'HorizontalAlignment','right');
+ 
+cform = makecform('srgb2lab');
+lab_he = applycform(he,cform);
+
+ab = double(lab_he(:,:,2:3));
+nrows = size(ab,1);
+ncols = size(ab,2);
+ab = reshape(ab,nrows*ncols,2);
+
+nColors = 3;
+% repeat the clustering 3 times to avoid local minima
+[cluster_idx, cluster_center] = kmeans(ab,nColors,'distance','sqEuclidean', ...
+                                      'Replicates',3);
+                                  
+pixel_labels = reshape(cluster_idx,nrows,ncols);
+imshow(pixel_labels,[]), title('image labeled by cluster index');
+
+segmented_images = cell(1,3);
+rgb_label = repmat(pixel_labels,[1 1 3]);
+
+for k = 1:nColors
+    color = he;
+    color(rgb_label ~= k) = 0;
+    segmented_images{k} = color;
+end
+
+imshow(segmented_images{1}), title('objects in cluster 1');
+imshow(segmented_images{2}), title('objects in cluster 2');
+imshow(segmented_images{3}), title('objects in cluster 3');
+
+mean_cluster_value = mean(cluster_center,2);
+[tmp, idx] = sort(mean_cluster_value);
+blue_cluster_num = idx(1);
+
+L = lab_he(:,:,1);
+blue_idx = find(pixel_labels == blue_cluster_num);
+L_blue = L(blue_idx);
+is_light_blue = imbinarize(L_blue);
+
+nuclei_labels = repmat(uint8(0),[nrows ncols]);
+nuclei_labels(blue_idx(is_light_blue==false)) = 1;
+nuclei_labels = repmat(nuclei_labels,[1 1 3]);
+blue_nuclei = he;
+blue_nuclei(nuclei_labels ~= 1) = 0;
+imshow(blue_nuclei), title('blue nuclei');

bv/uebung12_presence.txt

@@ -0,0 +1,4 @@
+O_5 = step_0 (W_35*H_3 + W_45*H_4)
+= step_0(W_35 * step_0(I_1*W_13 + I_2*W_23) + W_45 * step_0(I_1 W_14 + I_2 W_24))
+= step_0(4 * step(2*3 + 4*1) + 1 * step_0(2 * 1 + 4 * (-3)))
+= step_0(4 * step(10) + step_0(-10)) = step_0(4) = 1

bv/uebung2.tex

@@ -0,0 +1,81 @@
+\documentclass[10pt,a4paper,oneside,ngerman,numbers=noenddot]{scrartcl}
+\usepackage[T1]{fontenc}
+\usepackage[utf8]{inputenc}
+\usepackage[ngerman]{babel}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{bytefield}
+\usepackage{paralist}
+\usepackage{gauss}
+\usepackage{pgfplots}
+\usepackage{textcomp}
+\usepackage[locale=DE,exponent-product=\cdot,detect-all]{siunitx}
+\usepackage{tikz}
+\usepackage{algpseudocode}
+\usepackage{algorithm}
+\usepackage{mathtools}
+\usepackage{hyperref}
+\usepackage[german=quotes]{csquotes}
+%\usepackage{algorithmic}
+%\usepackage{minted}
+\usetikzlibrary{automata,matrix,fadings,calc,positioning,decorations.pathreplacing,arrows,decorations.markings}
+\usepackage{polynom}
+\polyset{style=C, div=:,vars=x}
+\pgfplotsset{compat=1.8}
+\pagenumbering{arabic}
+%\def\thesection{\arabic{section})}
+%\def\thesubsection{(\alph{subsection})}
+%\def\thesubsubsection{(\roman{subsubsection})}
+\makeatletter
+\renewcommand*\env@matrix[1][*\c@MaxMatrixCols c]{%
+  \hskip -\arraycolsep
+  \let\@ifnextchar\new@ifnextchar
+  \array{#1}}
+\makeatother
+\parskip 12pt plus 1pt minus 1pt
+\parindent 0pt
+\MakeOuterQuote{"}
+
+\DeclarePairedDelimiter\abs{\lvert}{\rvert}%
+\DeclarePairedDelimiter{\ceil}{\lceil}{\rceil}
+
+\newenvironment{myitemize}{\begin{itemize}\itemsep -9pt}{\end{itemize}} % Zeilenabstand in Aufzählungen geringer
+
+\def\thesection{\arabic{section}.}
+
+%switch starred and non-starred (auto-size)
+\makeatletter
+\let\oldabs\abs
+\def\abs{\@ifstar{\oldabs}{\oldabs*}}
+\makeatother
+
+\hypersetup{
+    colorlinks,
+    citecolor=black,
+    filecolor=black,
+    linkcolor=black,
+    urlcolor=black
+}
+
+\begin{document}
+\author{Jim Martens (6420323)}
+\title{Computer Vision/Image Processing}
+\subtitle{Assignment 2}
+\date{2nd Novembre 2016}
+
+\maketitle
+
+\section{}
+
+\begin{alignat*}{1}
+    \sigma^2 &= \frac{1}{N_{cols}N_{rows}-1} \sum\limits_{x=1}^{N_{cols}} \sum\limits_{y=1}^{N_{rows}} \left( I(y,x) - \mu_{n-1}\right) \cdot \left(I(y,x) - \mu_{n}\right) \\
+    \intertext{Constraints}
+    n_0 &= 0 \\
+    n_n &= n_{n-1} + 1 \\
+    n_i & \{i \in [0, N_{cols}N_{rows}]\} \\
+    \mu_0 &= 0 \\
+    \mu_n &= \mu_{n-1} + \frac{I(y,x) - \mu_{n-1}}{n_n}
+\end{alignat*}
+
+\end{document}

bv/uebung3.m

@@ -0,0 +1,42 @@
+% histogram distances
+rice = imread('rice.png');
+cam = imread('cameraman.tif');
+rice_sp = imnoise(rice, 'salt & pepper', 0.02);
+rice_g = imnoise(rice, 'gaussian');
+[h1,] = imhist(rice);
+[h2,] = imhist(cam);
+[h3,] = imhist(rice_sp);
+[h4,] = imhist(rice_g);
+dist_rice_camera = pdist2(h1', h2');
+dist_rice_rice_sp = pdist2(h1', h3');
+dist_rice_rice_g = pdist2(h1', h4');
+distman_rice_camera = pdist2(h1', h2', 'cityblock');
+distman_rice_rice_sp = pdist2(h1', h3', 'cityblock');
+distman_rice_rice_g = pdist2(h1', h4', 'cityblock');
+% colour spaces
+peppers = imread('peppers.png');
+peppers_gray = rgb2gray(peppers);
+peppers_hsv = rgb2hsv(peppers);
+peppers_lab = rgb2lab(peppers);
+%figure (1), imhist(peppers(:, :, 1));
+%figure (2), imhist(peppers(:, :, 2));
+%figure (3), imhist(peppers(:, :, 3));
+%figure (4), imshow(peppers_hsv);
+%figure (5), imshow(peppers_lab);
+%figure (6), imshow(peppers);
+% binary images
+coins = imread('coins.png');
+coins_bw = coins;
+for i = 1 : numel(coins_bw)
+    if coins_bw(i) < 90
+        coins_bw(i) = 0;
+    else
+        coins_bw(i) = 1;
+    end
+end
+coins_bw_l = logical(coins_bw);
+level = graythresh(coins);
+coins_bw_mat = imbinarize(coins, level);
+figure (1), imhist(coins);
+figure (2), imshow(coins_bw_l);
+figure (3), imshow(coins_bw_mat);

bv/uebung4.m

@@ -0,0 +1,18 @@
+% 2.
+fingerprint = imread('fingerprint.png');
+rec = strel('rectangle', [2 2]);
+lin = strel('line', 4, 0);
+opened = imopen(fingerprint, rec);
+opened2 = imopen(opened, lin);
+figure (1), imshow(fingerprint);
+figure (2), imshow(opened);
+figure (3), imshow(opened2);
+
+% 3.
+img = logical([1 0 0 0 1 1 1 0 1 1]);
+se = strel('line', 3, 0);
+dilated_img = imdilate(img, se);
+eroded_img = imerode(img, se);
+%figure (4), imshow(img);
+%figure (5), imshow(dilated_img);
+%figure (6), imshow(eroded_img);

bv/uebung5.m

@@ -0,0 +1,80 @@
+% 1.
+% First the connected components are determined. Then an array with the
+% color values for the gray colors is defined (possible value range 0-255).
+% The distance of 20 between each color is chosen to make the difference
+% visible for the human eye.
+% Afterwards the 8 values are assigned to the pixels of the 8 components.
+crosses = imread('crosses.gif');
+figure (1), imshow(logical(crosses));
+cc = bwconncomp(crosses);
+pixelIDs = cc.PixelIdxList;
+colors = [60, 80, 100, 120, 140, 160, 180, 200];
+for i = 1 : 8
+    crosses(pixelIDs{i}) = colors(i);
+end
+figure (2), imshow(crosses);
+
+% 2.
+dots = imread('littledots.gif');
+dots_bw = dots;
+% The threshold 50 is determined by looking at imhist(dots).
+% The background is lighter and covers most of the image and
+% it therefore is represented by the largest spike.
+% The cells are a bit darker and the threshold is therefore on the direct 
+% left of the spike.
+%---
+% The cells get the value 1, because the bwconncomp function views black as
+% background and white as objects. Lastly the number of objects is
+% extracted from the cc_dots struct.
+for i = 1 : numel(dots_bw)
+    if dots_bw(i) < 49
+        dots_bw(i) = 1;
+    else
+        dots_bw(i) = 0;
+    end
+end
+dots_bw_l = logical(dots_bw);
+cc_dots = bwconncomp(dots_bw);
+numObjects_dots = cc_dots.NumObjects;
+figure (3), imshow(dots);
+figure (4), imshow(dots_bw_l);
+
+% 3. 
+turkeys = imread('turkeys.jpg');
+turkeys_bw = turkeys;
+% The threshold 48 is determined by looking at imhist(turkeys).
+% There are many spikes and the turkeys have different color values
+% belonging to them. The larger part of them is on the darker side. The
+% exact threshold was determined by try and error to see which value
+% provided the best results. Since there was no single threshold in which
+% only the turkeys remained, some morphological operations were necessary.
+% Once every white dot not belonging to the turkeys was removed, one large
+% dilate operation was necessary to connect the remaining dots in a way
+% that represents the turkeys.
+% ---
+% The last step is to apply bwlabel to the prepared bw image.
+for i = 1 : numel(turkeys_bw)
+    if turkeys_bw(i) == 48
+        turkeys_bw(i) = 255;
+    else
+        turkeys_bw(i) = 0;
+    end
+end
+se = strel('line', 3, 90);
+se_2 = strel('disk', 14);
+se_3 = strel('square', 3);
+se_4 = strel('line', 3, 0);
+turkeys_opened = imopen(turkeys_bw, se);
+t_opened2 = imopen(turkeys_opened, se_4);
+t_opened3 = imopen(t_opened2, se_3);
+t_dilated = imdilate(t_opened3, se_2);
+[labels_turkeys, num_turkeys] = bwlabel(t_dilated);
+figure (5), imshow(turkeys_bw);
+figure (6), imshow(t_dilated);
+
+% 4.
+% I expect the two results to be equal. f shall be the box filter. g shall
+% be the result from convolving f with itself. h shall be the result from
+% convolving g with the image patch (i). Based on the associativity of
+% convolution j = (i * f) * f should be equal to i * (f * f). Combined with 
+% the commutativity j should be equal to (f * f) * i which is h.

bv/uebung5_presence.m

@@ -0,0 +1,36 @@
+text = imread('text.png');
+%figure, imshow(text);
+[L, components] = bwlabel(text, 8);
+cc = bwconncomp(text);
+pixelIDs = cc.PixelIdxList;
+[bin, index] = max(cellfun(@numel, pixelIDs));
+text(pixelIDs{index}) = 0;
+%figure, imshow(text);
+
+%----------
+img = imread('coins.png');
+filter = ones(3, 3) / 9;
+filter2 = ones(5, 5) / 25;
+imgbox = imboxfilt(img);
+img2 = imfilter(img, filter);
+img3 = imfilter(img, filter2);
+
+%----------
+cameraman = imread('cameraman.tif');
+pad1 = padarray(cameraman, [50 50]);
+pad2 = padarray(cameraman, [50 50], 'circular');
+pad3 = padarray(cameraman, [50 50], 'replicate');
+pad4 = padarray(cameraman, [50 50], 'symmetric');
+figure('Name', 'start'), imshow(cameraman);
+figure('Name', 'nullen'), imshow(pad1);
+figure('Name', 'circular'), imshow(pad2);
+figure('Name', 'replicate'), imshow(pad3);
+figure('Name', 'symmetric'), imshow(pad4);
+boxfilter = ones(3, 3) / 9;
+boxfiltered = imfilter(cameraman, boxfilter, 'replicate');
+figure('Name', 'boxfiltered'), imshow(boxfiltered);
+boxgaussfilter = ones(5, 5)/25;
+boxgaussfiltered1 = imfilter(cameraman, boxgaussfilter, 'replicate');
+gaussfiltered = imgaussfilt(cameraman, 1);
+figure('Name', 'gaussfiltered'), imshow(gaussfiltered);
+figure('Name', 'boxgaussfiltered'), imshow(boxgaussfiltered1);

bv/uebung6.m

@@ -0,0 +1,43 @@
+% 1.
+indian = imread('indian.jpg');
+indian_med_filtered1 = medfilt2(indian, [3 3]);
+indian_med_filtered2 = medfilt2(indian, [2 2]);
+figure (1), imshow(indian);
+figure (2), imshow(indian_med_filtered1);
+figure (3), imshow(indian_med_filtered2);
+
+% 2.
+vertical = rgb2gray(imread('verticallines.png'));
+diagonal = rgb2gray(imread('diagonallines.png'));
+
+vertical_med = medfilt2(vertical);
+diagonal_med = medfilt2(diagonal);
+v_med_plus_d_med = vertical_med + diagonal_med;
+vplusd = vertical + diagonal;
+vplusd_med = medfilt2(vplusd);
+
+figure (4), imshow(diagonal);
+figure (5), imshow(vertical);
+figure (6), imshow(vplusd_med);
+figure (7), imshow(v_med_plus_d_med);
+
+% 3. 
+swans = imread('swans_gray.jpg');
+swans_gauss = imgaussfilt(swans, 3);
+swans_1 = swans - swans_gauss;
+swans_size = size(swans_1);
+swans_lev1 = impyramid(swans_1, 'reduce');
+swans_2 = swans_lev1 - imgaussfilt(swans_lev1, 3);
+swans_lev1_size = size(swans_2);
+swans_lev2 = impyramid(swans_2, 'reduce');
+swans_3 = swans_lev2 - imgaussfilt(swans_lev2, 3);
+swans_lev2_size = size(swans_3);
+swans_lev3 = impyramid(swans_3, 'reduce');
+swans_4 = swans_lev3 - imgaussfilt(swans_lev3, 3);
+swans_lev3_size = size(swans_4);
+
+figure (8), imshow(swans);
+figure (9), imshow(swans_1);
+figure (10), imshow(swans_2);
+figure (11), imshow(swans_3);
+figure (12), imshow(swans_4);

bv/uebung6_presence.m

@@ -0,0 +1,34 @@
+coins = imread('coins.png');
+coins_sp = imnoise(coins, 'salt & pepper', 0.02);
+coins_median = medfilt2(coins_sp);
+boxfilter = ones(3, 3) / 9;
+coins_mean = imfilter(coins_sp, boxfilter);
+%figure (1), imshow(coins);
+%figure (2), imshow(coins_sp);
+%figure (3), imshow(coins_median);
+%figure (4), imshow(coins_mean);
+
+rice = imread('rice.png');
+rice_size = size(rice);
+imgPyramid = impyramid(rice, 'reduce');
+imgPyramid_size = size(imgPyramid);
+imgPyramid1 = impyramid(imgPyramid, 'reduce');
+imgPyramid1_size = size(imgPyramid1);
+imgPyramid2 = impyramid(imgPyramid1, 'reduce');
+imgPyramid2_size = size(imgPyramid2);
+%figure (5), imshow(rice);
+%figure (6), imshow(imgPyramid);
+%figure (7), imshow(imgPyramid1);
+%figure (8), imshow(imgPyramid2);
+
+circuit = imread('circuit.tif');
+circuit_edge1 = edge(circuit, 'Sobel');
+circuit_edge2 = edge(circuit, 'Prewitt');
+figure (9), imshow(circuit);
+figure (10), imshow(circuit_edge1);
+figure (11), imshow(circuit_edge2);
+coins_Sobel = edge(coins, 'Sobel');
+coins_Canny = edge(coins, 'Canny');
+figure (12), imshow(coins);
+figure (13), imshow(coins_Sobel);
+figure (14), imshow(coins_Canny);

bv/uebung7.m

@@ -0,0 +1,44 @@
+% 1.
+% Let's take two sequences f(x) = {0 -> 1, 1 -> 1, 2 -> 100} and
+% g(x) = { 0 -> 2, 1 -> 3, 2 -> 0}. The sum of both is 
+% h(x) = {0 -> 3, 1 -> 4, 2 -> 100}. The mean values are: mean(f) = 34,
+% mean(g) = 5/3, mean(h) = 107/3 = 34 + 5/3. The linearity mean(f) +
+% mean(g) = mean(f + g) is satisfied. The median values are: median(f) = 1,
+% median(g) = 2, median(h) = 4. But median(f) + median(g) != median(f + g).
+% Therefore the linearity isn't satisfied which means that median is
+% non-linear.
+
+% 2.
+peppers = rgb2gray(imread('peppers.png'));
+peppers_1 = imnoise(peppers, 'salt & pepper', 0.02);
+peppers_2 = imgaussfilt(peppers);
+peppers_3 = imnoise(peppers, 'salt & pepper', 0.6);
+peppers_4 = imnoise(peppers, 'poisson');
+peppers_5 = imgaussfilt(peppers, 3);
+
+peppers_fft = fftshift(log(abs(fft2(peppers))));
+peppers1_fft = fftshift(log(abs(fft2(peppers_1))));
+peppers2_fft = fftshift(log(abs(fft2(peppers_2))));
+peppers3_fft = fftshift(log(abs(fft2(peppers_3))));
+peppers4_fft = fftshift(log(abs(fft2(peppers_4))));
+peppers5_fft = fftshift(log(abs(fft2(peppers_5))));
+
+%figure (1), imshow(peppers_fft, []);
+%figure (2), imshow(peppers1_fft, []);
+%figure (3), imshow(peppers2_fft, []);
+%figure (4), imshow(peppers3_fft, []);
+%figure (5), imshow(peppers4_fft, []);
+%figure (6), imshow(peppers5_fft, []);
+
+%3.
+low_pass = fspecial('gaussian', [3 3], 1);
+low_pass_fft = fft2(low_pass, size(peppers, 1), size(peppers, 2));
+high_pass = fspecial('laplacian', 0.2);
+high_pass_fft = fft2(high_pass, size(peppers, 1), size(peppers, 2));
+peppers_fft2 = fft2(peppers);
+peppers_filtered_low_fft = peppers_fft2 .* low_pass_fft;
+peppers_filtered_high_fft = peppers_fft2 .* high_pass_fft;
+peppers_filtered_low = real(ifft2(peppers_filtered_low_fft));
+peppers_filtered_high = real(ifft2(peppers_filtered_high_fft));
+figure (7), imshow(peppers_filtered_low, []);
+figure (8), imshow(peppers_filtered_high, []);

bv/uebung7_presence.m

@@ -0,0 +1,36 @@
+% 1.
+peppers = rgb2gray(imread('peppers.png'));
+peppers_smooth = imgaussfilt(peppers, 3);
+peppers_fft = fft2(peppers);
+peppers_smooth_fft = fft2(peppers_smooth);
+
+sum_peppers = sum(peppers(:));
+first_el = peppers_fft(1, 1);
+
+peppers_fftshift = fftshift(log(abs(peppers_fft)));
+peppers_smooth_fftshift = fftshift(log(abs(peppers_smooth_fft)));
+
+%figure (1), imshow(peppers);
+%figure (2), imshow(peppers_smooth);
+%figure (3), imshow (log(abs(peppers_fft)), []);
+%figure (4), imshow (log(abs(peppers_smooth_fft)), []);
+%figure (5), imshow(peppers_fftshift, []);
+%figure (6), imshow(peppers_smooth_fftshift, []);
+%figure (7), imshow(fftshift(peppers))
+
+%---------
+tissue = rgb2gray(imread('tissue.png'));
+tissue_fft = fft2(tissue);
+tissue_fft_processed = log(abs(tissue_fft));
+tissue_fft_shifted_processed = fftshift(tissue_fft_processed);
+
+figure (8), imshow(tissue);
+figure (9), imshow(tissue_fft_shifted_processed, []);
+
+test = imread('testpat1.png');
+test_fft = fft2(test);
+test_fft_processed = log(abs(test_fft));
+test_fft_shifted_processed = fftshift(test_fft_processed);
+
+figure (10), imshow(test);
+figure (11), imshow(test_fft_shifted_processed , []);

bv/uebung8.txt

@@ -0,0 +1,129 @@
+1.
+                  ------
+                  | 1  |
+--------------    ------
+| 1 | -2 | 1 |  + | -2 |
+--------------    ------
+                  | 1  |
+                  ------
+
+The image has to be padded by 2 rows of zeros. The result of the correlation
+follows:
+
+-------------
+| 0 | 1 | 0 |
+-------------
+| 1 |-4 | 1 |
+-------------
+| 0 | 1 | 0 |
+-------------
+
+The resulting filter is the Laplacian filter. 
+
+
+2.
+
+The Prewitt edge detector for vertical edges follows:
+
+-------------
+|-1 | 0 | 1 |
+-------------
+|-1 | 0 | 1 |
+-------------
+|-1 | 0 | 1 |
+-------------
+
+The image of the exercise follows with 1 specifying white and 0 black.
+
+-------------------------
+| 0 | 0 | 0 | 1 | 1 | 1 |
+-------------------------
+| 0 | 0 | 0 | 1 | 1 | 1 |
+-------------------------
+| 0 | 0 | 0 | 1 | 1 | 1 |
+-------------------------
+| 0 | 0 | 0 | 1 | 1 | 1 |
+-------------------------
+| 0 | 0 | 0 | 1 | 1 | 1 |
+-------------------------
+| 0 | 0 | 0 | 1 | 1 | 1 |
+-------------------------
+
+The image has to be padded with 1 row and column of zeros to have a same size
+result image. After that the convolution is applied. The padded image follows:
+
+---------------------------------
+| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+---------------------------------
+| 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
+---------------------------------
+| 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
+---------------------------------
+| 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
+---------------------------------
+| 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
+---------------------------------
+| 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
+---------------------------------
+| 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0 |
+---------------------------------
+| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+---------------------------------
+
+The result of the convolution follows (without scalar product):
+
+
+---------------------------
+| 0 | 0 | -2 | -2 | 0 | 2 |
+---------------------------
+| 0 | 0 | -3 | -3 | 0 | 3 |
+---------------------------
+| 0 | 0 | -3 | -3 | 0 | 3 |
+---------------------------
+| 0 | 0 | -3 | -3 | 0 | 3 |
+---------------------------
+| 0 | 0 | -3 | -3 | 0 | 3 |
+---------------------------
+| 0 | 0 | -2 | -2 | 0 | 2 |
+---------------------------
+
+When the non zero values are replaced by ones, this is the result:
+
+
+-------------------------
+| 0 | 0 | 1 | 1 | 0 | 1 |
+-------------------------
+| 0 | 0 | 1 | 1 | 0 | 1 |
+-------------------------
+| 0 | 0 | 1 | 1 | 0 | 1 |
+-------------------------
+| 0 | 0 | 1 | 1 | 0 | 1 |
+-------------------------
+| 0 | 0 | 1 | 1 | 0 | 1 |
+-------------------------
+| 0 | 0 | 1 | 1 | 0 | 1 |
+-------------------------
+
+3.
+
+-----
+| 1 |
+-----     --------------
+| 2 |  *  | -1 | 0 | 1 |
+-----     --------------
+| 1 |
+-----
+
+To accurately process this convolution the image has to be padded by 2 columns
+of zeros.
+
+The result of the convolution follows:
+--------------
+| -1 | 0 | 1 |
+--------------
+| -2 | 0 | 2 |
+--------------
+| -1 | 0 | 1 |
+--------------
+
+This resulting filter is called Sobel edge detector for horizontal edges.

bv/uebung8_presence.m

@@ -0,0 +1,42 @@
+cameraman = imread('cameraman.tif');
+cam_fft = fft2(cameraman);
+%figure, imshow(log(abs(fftshift(cam_fft))), []);
+
+[m, n] = size(cameraman);
+mask = zeros(m, n);
+rm = round(m/2) + 1;
+rn = round(n/2) + 1;
+maskSize = 25;
+mask(rm - maskSize : rm + maskSize, rn - maskSize : rn + maskSize) = 1;
+mask = logical(mask);
+figure (1), imshow(mask);
+
+lowPass = fftshift(cam_fft) .* mask;
+figure (2), imshow(log(abs(lowPass)), []);
+maskHigh = ~mask;
+highPass = fftshift(cam_fft) .* maskHigh;
+figure (3), imshow(log(abs(highPass)), []);
+
+new = ifft2(fftshift(lowPass));
+new_high = ifft2(fftshift(highPass));
+figure (4), imshow(new, []);
+figure (5), imshow(new_high, []);
+new2 = new + new_high;
+figure (6), imshow(new2, []);
+
+%
+circuit = imread('circuit.tif');
+v_filter = [-1;1];
+h_filter = [-1 1];
+circuit_v = imfilter(circuit, v_filter);
+circuit_h = imfilter(circuit, h_filter);
+figure (7), imshow(circuit);
+figure (8), imshow(circuit_v, []);
+figure (9), imshow(circuit_h, []);
+
+%
+coins = imread('coins.png');
+filter = [0 1 0;1 -4 1; 0 1 0];
+coins_filtered = imfilter(coins, filter);
+figure (10), imshow(coins);
+figure (11), imshow(coins_filtered);

bv/uebung9.m

@@ -0,0 +1,24 @@
+% 4.
+coins = imread('coins.png');
+edge_01 = edge(coins, 'Canny', 0.1);
+edge_02 = edge(coins, 'Canny', 0.2);
+edge_05 = edge(coins, 'Canny', 0.5);
+edge_075 = edge(coins, 'Canny', 0.75);
+edge_08 = edge(coins, 'Canny', 0.8);
+subplot(1, 5, 1);
+imshow(edge_01);
+subplot(1, 5, 2);
+imshow(edge_02);
+subplot(1, 5, 3);
+imshow(edge_05);
+subplot(1, 5, 4);
+imshow(edge_075);
+subplot(1, 5, 5);
+imshow(edge_08);
+
+% With the threshold 0.5 only the outer edges of the
+% coins are still detected. With higher thresholds some
+% coins disappear completely while 0.1 shows almost every
+% line - including those on the coins.
+
+% 5.

bv/uebung9.txt

@@ -0,0 +1,215 @@
+1.
+
+a + b)
+x2y2:
+g_x = L(3,2) - L(1,2) = -1
+g_y = L(2,3) - L(2,1) = 1
+gradient = [-1,1]T
+theta(2,2) = arctan(-1/1) = -0.7854
+m(2,2) = sqrt((-1)^2 + 1^2) = sqrt(2)
+
+x2y4:
+g_x = L(3,4) - L(1,4) = 0
+g_y = L(2,5) - L(2,3) = 0
+gradient = [0,0]T
+theta(2,4) = arctan(0/0) = NaN
+m(2,4) = sqrt(0)
+
+x2y6:
+g_x = L(3,6) - L(1,6) = 0
+g_y = L(2,7) - L(2,5) = 0
+gradient = [0,0]T
+theta(2,6) = arctan(0/0) = NaN
+m(2,6) = sqrt(0)
+
+x2y8:
+g_x = L(3,8) - L(1,8) = 0
+g_y = L(2,9) - L(2,7) = 0
+gradient = [0,0]T
+theta(2,8) = arctan(0/0) = NaN
+m(2,8) = sqrt(0)
+
+x2y10:
+g_x = L(3,10) - L(1,10) = 0
+g_y = L(2,11) - L(2,9) = 0
+gradient = [0,0]T
+theta(2,10) = arctan(0/0) = NaN
+m(2,10) = sqrt(0)
+
+x4y2:
+g_x = L(5,2) - L(3,2) = 0
+g_y = L(4,3) - L(4,1) = 0
+gradient = [0,0]T
+theta(4,2) = arctan(0/0) = NaN
+m(4,2) = sqrt(0)
+
+x4y4:
+g_x = L(5,4) - L(3,4) = -1
+g_y = L(4,5) - L(4,3) = 1
+gradient = [-1,1]T
+theta(4,4) = arctan(-1/1) = -0.7854
+m(4,4) = sqrt((-1)^2 + 1^2) = sqrt(2)
+
+x4y6:
+g_x = L(5,6) - L(3,6) = 0
+g_y = L(4,7) - L(4,5) = 0
+gradient = [0,0]T
+theta(4,6) = arctan(0/0) = NaN
+m(4,6) = sqrt(0)
+
+x4y8:
+g_x = L(5,8) - L(3,8) = -1
+g_y = L(4,9) - L(4,7) = 0
+gradient = [-1,0]T
+theta(4,8) = arctan(-1/0) = NaN
+m(4,8) = sqrt((-1)^2) = sqrt(1) = 1
+
+x4y10:
+g_x = L(5,10) - L(3,10) = 0
+g_y = L(4,11) - L(4,9) = 0
+gradient = [0,0]T
+theta(4,10) = arctan(0/0) = NaN
+m(4,10) = sqrt(0)
+
+x6y2:
+g_x = L(7,2) - L(5,2) = 0
+g_y = L(6,3) - L(6,1) = 0
+gradient = [0,0]T
+theta(6,2) = arctan(0/0) = NaN
+m(6,2) = sqrt(0)
+
+x6y4:
+g_x = L(7,4) - L(5,4) = 0
+g_y = L(6,5) - L(6,3) = 0
+gradient = [0,0]T
+theta(6,4) = arctan(0/0) = NaN
+m(6,4) = sqrt(0)
+
+x6y6:
+g_x = L(7,6) - L(5,6) = -1
+g_y = L(6,7) - L(6,5) = 0
+gradient = [-1,0]T
+theta(6,6) = arctan(-1/0) = NaN
+m(6,6) = sqrt((-1)^2) = sqrt(1) = 1
+
+x6y8:
+g_x = L(7,8) - L(5,8) = 0
+g_y = L(6,9) - L(6,7) = 0
+gradient = [0,0]T
+theta(6,8) = arctan(0/0) = NaN
+m(6,8) = sqrt(0)
+
+x6y10:
+g_x = L(7,10) - L(5,10) = -1
+g_y = L(6,11) - L(6,9) = 1
+gradient = [-1,1]T
+theta(6,10) = arctan(-1/1) = -0.7854
+m(6,10) = sqrt((-1)^2 + 1^2) = sqrt(2)
+
+x8y2:
+g_x = L(9,2) - L(7,2) = 0
+g_y = L(8,3) - L(8,1) = 0
+gradient = [0,0]T
+theta(8,2) = arctan(0/0) = NaN
+m(8,2) = sqrt(0)
+
+x8y4:
+g_x = L(9,4) - L(7,4) = 0
+g_y = L(8,5) - L(8,3) = 0
+gradient = [0,0]T
+theta(8,4) = arctan(0/0) = NaN
+m(8,4) = sqrt(0)
+
+x8y6:
+g_x = L(9,6) - L(7,6) = 0
+g_y = L(8,7) - L(8,5) = 0
+gradient = [0,0]T
+theta(8,6) = arctan(0/0) = NaN
+m(8,6) = sqrt(0)
+
+x8y8:
+g_x = L(9,8) - L(7,8) = 0
+g_y = L(8,9) - L(8,7) = 0
+gradient = [0,0]T
+theta(8,8) = arctan(0/0) = NaN
+m(8,8) = sqrt(0)
+
+x8y10:
+g_x = L(9,10) - L(7,10) = 0
+g_y = L(8,11) - L(8,9) = 0
+gradient = [0,0]T
+theta(8,10) = arctan(0/0) = NaN
+m(8,10) = sqrt(0)
+
+x10y2:
+g_x = L(11,2) - L(9,2) = 0
+g_y = L(10,3) - L(10,1) = 0
+gradient = [0,0]T
+theta(10,2) = arctan(0/0) = NaN
+m(10,2) = sqrt(0)
+
+x10y4:
+g_x = L(11,4) - L(9,4) = 0
+g_y = L(10,5) - L(10,3) = 0
+gradient = [0,0]T
+theta(10,4) = arctan(0/0) = NaN
+m(10,4) = sqrt(0)
+
+x10y6:
+g_x = L(11,6) - L(9,6) = 0
+g_y = L(10,7) - L(10,5) = 0
+gradient = [0,0]T
+theta(10,6) = arctan(0/0) = NaN
+m(10,6) = sqrt(0)
+
+x10y8:
+g_x = L(11,8) - L(9,8) = 0
+g_y = L(10,9) - L(10,7) = 0
+gradient = [0,0]T
+theta(10,8) = arctan(0/0) = NaN
+m(10,8) = sqrt(0)
+
+x10y10:
+g_x = L(11,10) - L(9,10) = 0
+g_y = L(10,11) - L(10,9) = 0
+gradient = [0,0]T
+theta(10,10) = arctan(0/0) = NaN
+m(10,10) = sqrt(0)
+
+2.
+theta = 45
+p = 50 * cos(45) + 100 * sin(45) ~ 35,36 + 70,71 = 106,07
+
+theta = -45
+p = 50 * cos(-45) + 100 * sin(-45) ~ 35,36 - 70,71 = -35,35
+
+3.
+point 2 - horizontal
+theta = 0
+p = 0 * cos(0) + 100 * sin(0) = 0
+
+point 2 - vertical
+theta = 90 or theta = -90
+p = 0 * cos(90) + 100 * sin(90) = 100
+or
+p = 0 * cos(-90) + 100 * sin(-90) = -100
+
+point 3 - horizontal
+theta = 0
+p = 50 * cos(0) + 50 * sin(0) = 50
+
+point 3 - vertical
+theta = 90 or theta = -90
+p = 50 * cos(90) + 50 * sin(90) -50
+or
+p = 50* cos(-90) + 50 * sin(-90) = -50
+
+point 5 - horizontal
+theta = 0
+p = 100 * cos(0) + 100 * sin(0) = 100
+
+point 5 - vertical
+theta = 90 or theta = -90
+p = 100 * cos(90) + 100 * sin(90) = 100
+or
+p = 100 * cos(-90) + 100 * sin(-90) = -100

bv/uebung9_presence.m

@@ -0,0 +1,26 @@
+RGB = imread('gantrycrane.png');
+I  = rgb2gray(RGB); % convert to intensity
+BW = edge(I,'canny'); % extract edges
+[H,T,R] = hough(BW,'RhoResolution',0.5,'Theta',-90:0.5:89.5);
+
+% display the original image
+subplot(2,1,1);
+imshow(RGB);
+title('gantrycrane.png');
+
+% display the hough matrix
+subplot(2,1,2);
+imshow(imadjust(mat2gray(H)),'XData',T,'YData',R,...
+       'InitialMagnification','fit');
+title('Hough transform of gantrycrane.png');
+xlabel('\theta'), ylabel('\rho');
+axis on, axis normal, hold on;
+colormap(hot);
+
+peaks = houghpeaks(H, 50, 'Threshold', 30);
+figure, imshow(I), hold on
+lines = houghlines(BW, T, R, peaks, 'FillGap', 5, 'MinLength', 15);
+for i = 1 : length(lines)
+    xy = [lines(i).point1; lines(i).point2];
+    plot(xy(:,1), xy(:,2), 'LineWidth', 1, 'Color', 'r');
+end

bv/variance.m

@@ -0,0 +1,31 @@
+function [v] = variance( image )
+%VARIANCE Calculates the variance of an image
+
+    if isinteger(image) 
+        error(message('MATLAB:var:integerClass'));
+    end
+
+    % prepare some values needed for both mean and variance
+    n = 0;
+    mean = 0.0;
+    M2 = 0.0;
+    s = size(image);
+    rows = s(1);
+    cols = s(2);
+     
+    for x = 1:cols
+        for y = 1:rows
+            n = n + 1;
+            delta = image(y, x) - mean;
+            mean = mean + delta/n;
+            M2 = M2 + delta*(image(y,x) - mean);
+        end
+    end
+    
+    if n < 2
+        v = float('nan');
+    else
+        v = M2 / (n - 1);
+    end
+end
+

ccv/saliency/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.5)
+project(saliency)
+
+set(CMAKE_CXX_STANDARD 11)
+
+find_package( OpenCV REQUIRED )
+
+add_executable(saliency laplacian_pyramid.cpp oriented_pyramid.cpp fusion.cpp gauss_pyramid.cpp lab_pyramid.cpp main.cpp)
+target_link_libraries(saliency ${OpenCV_LIBS})

ccv/saliency/eval.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+# Modify the following variables to match your configuration.
+
+# The path where ground truth binary masks are
+GT_PATH=/home/jim/git-repos/uni/ccv/saliency/binarymasks/
+# The path where saliency maps computed by your system are
+SAL_PATH=/home/jim/git-repos/uni/ccv/saliency/saliency_maps/
+# The location of the saliency evaluation tool
+EVAL_TOOL=/home/jim/git-repos/uni/ccv/saliency/SaliencyEvaluationTool/SaliencyEvaluationTool.jar
+# The path where to write results to
+RES_PATH=/home/jim/git-repos/uni/ccv/saliency/results
+
+# This ensures the results directory exists
+#mkdir -p "${RES_PATH}"
+
+# Run the evaluation script using paths defined above
+java -jar ${EVAL_TOOL} pathGT="${GT_PATH}" pathSM="${SAL_PATH}" pathResult="${RES_PATH}"

ccv/saliency/fusion.cpp

@@ -0,0 +1,64 @@
+#include <opencv2/opencv.hpp>
+#include "includes/fusion.h"
+
+/**
+ * Returns the mean fusion.
+ *
+ * @param feature_maps vector of feature maps
+ * @return conspicuity map
+ */
+cv::Mat mean_fusion_generic(const std::vector<cv::Mat> feature_maps) {
+  unsigned long number_of_features = feature_maps.size();
+  cv::Mat sum_of_features;
+  double max = -1;
+  bool first_run = true;
+  for (auto& f : feature_maps) {
+    if (first_run) {
+      sum_of_features = f.clone();
+      first_run = false;
+    }
+    else {
+      sum_of_features = sum_of_features + f;
+    }
+    double max_value;
+    cv::minMaxLoc(f, nullptr, &max_value);
+    if (max_value >= max) {
+      max = max_value;
+    }
+  }
+  cv::Mat C = 1./number_of_features * sum_of_features;
+  cv::normalize(C, C, 0, max, cv::NORM_MINMAX, -1);
+
+  return C.clone();
+}
+
+/**
+ * Returns the max fusion.
+ *
+ * @param feature_maps vector of feature maps
+ * @return conspicuity map
+ */
+cv::Mat max_fusion_generic(const std::vector<cv::Mat> feature_maps) {
+  cv::Mat C;
+  bool first_value = true;
+
+  double max = -1;
+  for (auto& f : feature_maps) {
+    double max_value;
+    cv::minMaxLoc(f, nullptr, &max_value);
+    if (max_value >= max) {
+      max = max_value;
+    }
+
+    if (first_value) {
+      C = f.clone();
+      first_value = false;
+    }
+    else {
+      C = cv::max(C, f);
+    }
+  }
+  cv::normalize(C, C, 0, max, cv::NORM_MINMAX, -1);
+
+  return C.clone();
+}

ccv/saliency/gauss_pyramid.cpp

@@ -0,0 +1,35 @@
+#include "includes/gauss_pyramid.h"
+
+gauss_pyramid::gauss_pyramid() {}
+
+gauss_pyramid::gauss_pyramid(const cv::Mat img, float sigma, int number_of_layers)
+{
+  cv::Mat blurredImage;
+  cv::Mat resizedImage = img.clone();
+  for (int i = 0; i < number_of_layers; i++)
+  {
+    cv::GaussianBlur(resizedImage, blurredImage, cv::Size(0, 0), sigma, sigma, cv::BORDER_REPLICATE);
+    _layers.push_back(blurredImage.clone());
+    cv::resize(blurredImage, resizedImage, cv::Size(), 0.5, 0.5, cv::INTER_NEAREST);
+  }
+}
+
+cv::Mat gauss_pyramid::get(int layer) const
+{
+  return _layers.at((unsigned long) layer);
+}
+
+cv::Mat gauss_pyramid::get(int layer)
+{
+  return _layers.at((unsigned long) layer);
+}
+
+unsigned long gauss_pyramid::get_number_of_layers() const
+{
+  return _layers.size();
+}
+
+unsigned long gauss_pyramid::get_number_of_layers()
+{
+  return _layers.size();
+}

ccv/saliency/includes/fusion.h

@@ -0,0 +1,7 @@
+#ifndef SHEET6_FUSION_H
+#define SHEET6_FUSION_H
+
+cv::Mat mean_fusion_generic(const std::vector<cv::Mat> feature_maps);
+cv::Mat max_fusion_generic(const std::vector<cv::Mat> feature_maps);
+
+#endif //SHEET6_FUSION_H

ccv/saliency/includes/gauss_pyramid.h

@@ -0,0 +1,20 @@
+#ifndef SHEET3_GAUSS_PYRAMID_H
+#define SHEET3_GAUSS_PYRAMID_H
+
+#include <opencv2/opencv.hpp>
+
+class gauss_pyramid
+{
+private:
+    std::vector<cv::Mat> _layers;
+public:
+    gauss_pyramid();
+    gauss_pyramid(const cv::Mat img, float sigma, int number_of_layers);
+    cv::Mat get(int layer) const;
+    cv::Mat get(int layer);
+    unsigned long get_number_of_layers() const;
+    unsigned long get_number_of_layers();
+};
+
+
+#endif //SHEET3_GAUSS_PYRAMID_H

ccv/saliency/includes/lab_pyramid.h

@@ -0,0 +1,137 @@
+#ifndef SHEET3_LAB_PYRAMID_H
+#define SHEET3_LAB_PYRAMID_H
+
+#include <opencv2/opencv.hpp>
+#include "gauss_pyramid.h"
+
+class lab_pyramid {
+private:
+    cv::Mat _inputImage_lab;
+    cv::Mat _inputImage_float;
+    cv::Mat _imageChannels[3];
+    gauss_pyramid _pyramids[3];
+    // contrast maps
+    static std::vector<cv::Mat> _cs_contrast_l;
+    static std::vector<cv::Mat> _sc_contrast_l;
+    static std::vector<cv::Mat> _cs_contrast_a;
+    static std::vector<cv::Mat> _sc_contrast_a;
+    static std::vector<cv::Mat> _cs_contrast_b;
+    static std::vector<cv::Mat> _sc_contrast_b;
+    // feature maps
+    static std::vector<cv::Mat> _F_l;
+    static std::vector<cv::Mat> _F_a;
+    static std::vector<cv::Mat> _F_b;
+    static cv::Mat _cs_F_l;
+    static cv::Mat _sc_F_l;
+    static cv::Mat _cs_F_a;
+    static cv::Mat _cs_F_b;
+    static cv::Mat _sc_F_a;
+    static cv::Mat _sc_F_b;
+    // conspicuity maps
+    static cv::Mat _C_l;
+    static cv::Mat _C_a;
+    static cv::Mat _C_b;
+    // number of layers
+    static int _number_of_layers;
+public:
+    const static int COLOR_L = 0;
+    const static int COLOR_A = 1;
+    const static int COLOR_B = 2;
+
+    /**
+     * Initializes a LAB pyramid.
+     *
+     * @param image_filename the filename of the image that should be used
+     */
+    lab_pyramid(cv::String image_filename);
+
+    /**
+     * Initializes a LAB pyramid.
+     *
+     * @param image the image that should be used
+     */
+    lab_pyramid(cv::Mat image);
+
+    /**
+     * Creates the gaussian pyramids for all channels with the given number of layers each.
+     *
+     * @param sigma the sigma for the gaussian pyramids
+     * @param number_of_layers number of layers for gaussian pyramid
+     */
+    void create_pyramids(float sigma, int number_of_layers);
+
+    /**
+     * Before this method can be called, pyramids have to be created via create_pyramids.
+     *
+     * @param channel the channel you want to get (COLOR_L, COLOR_A or COLOR_B)
+     * @return the gaussian_pyramid for the given channel
+     */
+    gauss_pyramid get_pyramid(int channel);
+
+    /**
+     * Before this method can be called, pyramids have to be created via create_pyramids.
+     *
+     * @param channel the channel you want to get (COLOR_L, COLOR_A or COLOR_B)
+     * @return the gaussian_pyramid for the given channel
+     */
+    gauss_pyramid get_pyramid(int channel) const;
+
+    /**
+     * Visualizes the gaussian pyramids.
+     *
+     * @param center center pyramid
+     * @param surround surround pyramid
+     */
+    void static visualize_gaussian_pyrs(const lab_pyramid center, const lab_pyramid surround);
+
+    /**
+     * Computes the center-surround and surround-center contrasts and stores them for later use.
+     *
+     * @param center the center pyramid
+     * @param surround the surround pyramid
+     * @param number_of_layers the number of layers used to create the two pyramids
+     */
+    void static compute_dog(const lab_pyramid center, const lab_pyramid surround, int number_of_layers);
+
+    /**
+     * Visualizes the center-surround and surround-center contrasts. They have to be computed first.
+     */
+    void static visualize_dog();
+
+    /**
+     * Takes the scale images, adds them up and returns the result.
+     *
+     * @param scale_images the scale images
+     * @return the sum of the scale images
+     */
+    cv::Mat static across_scale_addition(const std::vector<cv::Mat> &scale_images);
+
+    /**
+     * Computes the feature maps.
+     * Has to be called after compute_dog.
+     */
+    void static compute_feature_maps();
+
+    /**
+     * Computes the conspicuity maps.
+     * Has to be called after compute_feature_maps.
+     */
+    void static compute_conspicuity_maps();
+
+    /**
+     * Before this method can be called, the conspicuity maps must be computed via compute_conspicuity_maps.
+     *
+     * @param channel the channel you want to get (COLOR_L, COLOR_A, COLOR_B)
+     * @return the conspicuity map for the given channel
+     */
+    cv::Mat static get_conspicuity_map(int channel);
+
+    /**
+     * Visualizes the feature maps.
+     * Has to be called after compute_feature_maps.
+     */
+    void static visualize_feature_maps();
+};
+
+
+#endif //SHEET3_LAB_PYRAMID_H

ccv/saliency/includes/laplacian_pyramid.h

@@ -0,0 +1,33 @@
+#ifndef SHEET5_LAPLACIAN_PYRAMID_H
+#define SHEET5_LAPLACIAN_PYRAMID_H
+
+#include <opencv2/opencv.hpp>
+#include "gauss_pyramid.h"
+
+class laplacian_pyramid {
+private:
+    std::vector<cv::Mat> _layers;
+public:
+    /**
+     * Initializes the laplacian pyramid.
+     * @param pyramid the gaussian pyramid
+     * @param sigma the blur factor
+     */
+    laplacian_pyramid(const gauss_pyramid& pyramid, float sigma);
+
+    /**
+     * Returns the number of layers.
+     * @return
+     */
+    unsigned long get_number_of_layers() const;
+
+    /**
+     * Returns the pyramid element at given layer.
+     * @param layer the requested pyramid layer
+     * @return pyramid layer
+     */
+    cv::Mat get(int layer) const;
+};
+
+
+#endif //SHEET5_LAPLACIAN_PYRAMID_H

ccv/saliency/includes/oriented_pyramid.h

@@ -0,0 +1,64 @@
+#ifndef SHEET5_ORIENTED_PYRAMID_H
+#define SHEET5_ORIENTED_PYRAMID_H
+
+#include <opencv2/opencv.hpp>
+#include "laplacian_pyramid.h"
+
+class oriented_pyramid {
+private:
+    std::vector<std::vector<cv::Mat>> _orientation_maps;
+    std::vector<cv::Mat> _gabor_filters;
+    std::vector<cv::Mat> _feature_maps;
+    cv::Mat _C;
+
+    /**
+     * Initializes the Gabor filters.
+     * @param num_orientations the number of orientations to use
+     * @param size the size of the Gabor filter
+     * @param wavelength the wavelength
+     * @param standard_deviation the standard deviation
+     */
+    void initialize_gabor_filters(float num_orientations, int size, double wavelength, double standard_deviation);
+public:
+    /**
+     * Initializes the oriented pyramid.
+     * @param pyramid the laplacian pyramid
+     * @param num_orientations the number of Gabor filters to apply
+     * @param size the size of the Gabor filter
+     * @param wavelength the wavelength
+     * @param standard_deviation the standard deviation
+     */
+    oriented_pyramid(const laplacian_pyramid& pyramid, int num_orientations, int size,
+                     double wavelength, double standard_deviation);
+
+    /**
+     * Computes the feature maps.
+     */
+    void compute_feature_maps();
+
+    /**
+     * Computes the conspicuity map.
+     */
+    void compute_conspicuity_map();
+
+    /**
+     * Returns the conspicuity map.
+     * Has to be called after compute_conspicuity_map.
+     *
+     * @return conspicuity map
+     */
+    cv::Mat get_conspicuity_map();
+
+    /**
+     * Returns the feature map for the nth orientation.
+     *
+     * compute_feature_maps must be called first.
+     *
+     * @param orientation the nth orientation
+     * @return the feature map
+     */
+    cv::Mat get_feature_map(unsigned long orientation);
+};
+
+
+#endif //SHEET5_ORIENTED_PYRAMID_H

ccv/saliency/lab_pyramid.cpp

@@ -0,0 +1,235 @@
+#include "includes/lab_pyramid.h"
+#include "includes/fusion.h"
+
+// number of layers
+int lab_pyramid::_number_of_layers = 0;
+// contrast maps
+std::vector<cv::Mat> lab_pyramid::_cs_contrast_l = std::vector<cv::Mat>();
+std::vector<cv::Mat> lab_pyramid::_sc_contrast_l = std::vector<cv::Mat>();
+std::vector<cv::Mat> lab_pyramid::_cs_contrast_a = std::vector<cv::Mat>();
+std::vector<cv::Mat> lab_pyramid::_sc_contrast_a = std::vector<cv::Mat>();
+std::vector<cv::Mat> lab_pyramid::_cs_contrast_b = std::vector<cv::Mat>();
+std::vector<cv::Mat> lab_pyramid::_sc_contrast_b = std::vector<cv::Mat>();
+// feature maps
+std::vector<cv::Mat> lab_pyramid::_F_l= std::vector<cv::Mat>();
+std::vector<cv::Mat> lab_pyramid::_F_a= std::vector<cv::Mat>();
+std::vector<cv::Mat> lab_pyramid::_F_b= std::vector<cv::Mat>();
+cv::Mat lab_pyramid::_cs_F_l;
+cv::Mat lab_pyramid::_sc_F_l;
+cv::Mat lab_pyramid::_cs_F_a;
+cv::Mat lab_pyramid::_sc_F_a;
+cv::Mat lab_pyramid::_cs_F_b;
+cv::Mat lab_pyramid::_sc_F_b;
+// conspicuity maps
+cv::Mat lab_pyramid::_C_l;
+cv::Mat lab_pyramid::_C_a;
+cv::Mat lab_pyramid::_C_b;
+
+lab_pyramid::lab_pyramid(cv::String image_filename) {
+  cv::Mat image_rgb = cv::imread(image_filename, cv::IMREAD_COLOR);
+  cv::cvtColor(image_rgb, _inputImage_lab, cv::COLOR_BGR2Lab);
+  cv::split(_inputImage_lab ,_imageChannels);
+};
+
+lab_pyramid::lab_pyramid(const cv::Mat image) {
+  image.convertTo(_inputImage_float, CV_32F);
+  _inputImage_float *= 1./255;
+  cv::cvtColor(_inputImage_float, _inputImage_lab, cv::COLOR_BGR2Lab);
+  cv::split(_inputImage_lab, _imageChannels);
+}
+
+void lab_pyramid::create_pyramids(float sigma, int number_of_layers)
+{
+  _pyramids[COLOR_L] = gauss_pyramid(_imageChannels[COLOR_L], sigma, number_of_layers);
+  _pyramids[COLOR_A] = gauss_pyramid(_imageChannels[COLOR_A], sigma, number_of_layers);
+  _pyramids[COLOR_B] = gauss_pyramid(_imageChannels[COLOR_B], sigma, number_of_layers);
+}
+
+gauss_pyramid lab_pyramid::get_pyramid(int channel)
+{
+  switch (channel)
+  {
+    case COLOR_L:
+      return _pyramids[COLOR_L];
+    case COLOR_A:
+      return _pyramids[COLOR_A];
+    case COLOR_B:
+      return _pyramids[COLOR_B];
+    default:
+      throw std::invalid_argument( "received invalid channel value, use COLOR_L, COLOR_A or COLOR_B" );
+  }
+}
+
+gauss_pyramid lab_pyramid::get_pyramid(int channel) const
+{
+  switch (channel)
+  {
+    case COLOR_L:
+      return _pyramids[COLOR_L];
+    case COLOR_A:
+      return _pyramids[COLOR_A];
+    case COLOR_B:
+      return _pyramids[COLOR_B];
+    default:
+      throw std::invalid_argument( "received invalid channel value, use COLOR_L, COLOR_A or COLOR_B" );
+  }
+}
+
+void lab_pyramid::compute_dog(const lab_pyramid center, const lab_pyramid surround, int number_of_layers) {
+  _number_of_layers = number_of_layers;
+
+  // L channel
+  gauss_pyramid center_l = center.get_pyramid(COLOR_L);
+  gauss_pyramid surround_l = surround.get_pyramid(COLOR_L);
+
+  // A channel
+  gauss_pyramid center_a = center.get_pyramid(COLOR_A);
+  gauss_pyramid surround_a = surround.get_pyramid(COLOR_A);
+
+  // A channel
+  gauss_pyramid center_b = center.get_pyramid(COLOR_B);
+  gauss_pyramid surround_b = surround.get_pyramid(COLOR_B);
+
+  for (int layer = 0; layer < number_of_layers; layer++) {
+    // L channel
+    cv::Mat center_layer_mat_L = center_l.get(layer);
+    cv::Mat surround_layer_mat_L = surround_l.get(layer);
+    cv::Mat dog_raw_cs_L = center_layer_mat_L - surround_layer_mat_L;
+    cv::Mat dog_final_cs_L;
+    cv::Mat dog_final_sc_L;
+    cv::threshold(dog_raw_cs_L, dog_final_cs_L, 0, 1, cv::THRESH_TOZERO);
+    _cs_contrast_l.push_back(dog_final_cs_L.clone());
+    cv::Mat dog_raw_sc_L = surround_layer_mat_L - center_layer_mat_L;
+    cv::threshold(dog_raw_sc_L, dog_final_sc_L, 0, 1, cv::THRESH_TOZERO);
+    _sc_contrast_l.push_back(dog_final_sc_L.clone());
+
+    // A channel
+    cv::Mat center_layer_mat_a = center_a.get(layer);
+    cv::Mat surround_layer_mat_a = surround_a.get(layer);
+    cv::Mat dog_raw_cs_a = center_layer_mat_a - surround_layer_mat_a;
+    cv::Mat dog_final_cs_a;
+    cv::Mat dog_final_sc_a;
+    cv::threshold(dog_raw_cs_a, dog_final_cs_a, 0, 1, cv::THRESH_TOZERO);
+    _cs_contrast_a.push_back(dog_final_cs_a.clone());
+    cv::Mat dog_raw_sc_a = surround_layer_mat_a - center_layer_mat_a;
+    cv::threshold(dog_raw_sc_a, dog_final_sc_a, 0, 1, cv::THRESH_TOZERO);
+    _sc_contrast_a.push_back(dog_final_sc_a.clone());
+
+    // B channel
+    cv::Mat center_layer_mat_b = center_b.get(layer);
+    cv::Mat surround_layer_mat_b = surround_b.get(layer);
+    cv::Mat dog_raw_cs_b = center_layer_mat_b - surround_layer_mat_b;
+    cv::Mat dog_final_cs_b;
+    cv::Mat dog_final_sc_b;
+    cv::threshold(dog_raw_cs_b, dog_final_cs_b, 0, 1, cv::THRESH_TOZERO);
+    _cs_contrast_b.push_back(dog_final_cs_b.clone());
+    cv::Mat dog_raw_sc_b = surround_layer_mat_b - center_layer_mat_b;
+    cv::threshold(dog_raw_sc_b, dog_final_sc_b, 0, 1, cv::THRESH_TOZERO);
+    _sc_contrast_b.push_back(dog_final_sc_b.clone());
+  }
+}
+
+void lab_pyramid::compute_feature_maps() {
+  _cs_F_l = across_scale_addition(_cs_contrast_l);
+  _sc_F_l = across_scale_addition(_sc_contrast_l);
+  _F_l.push_back(_cs_F_l);
+  _F_l.push_back(_sc_F_l);
+  _cs_F_a = across_scale_addition(_cs_contrast_a);
+  _sc_F_a = across_scale_addition(_sc_contrast_a);
+  _F_a.push_back(_cs_F_a);
+  _F_a.push_back(_sc_F_a);
+  _cs_F_b = across_scale_addition(_cs_contrast_b);
+  _sc_F_b = across_scale_addition(_sc_contrast_b);
+  _F_b.push_back(_cs_F_b);
+  _F_b.push_back(_sc_F_b);
+}
+
+void lab_pyramid::compute_conspicuity_maps() {
+  _C_l = mean_fusion_generic(_F_l);
+  _C_a = mean_fusion_generic(_F_a);
+  _C_b = mean_fusion_generic(_F_b);
+}
+
+cv::Mat lab_pyramid::get_conspicuity_map(int channel) {
+  switch (channel)
+  {
+    case COLOR_L:
+      return _C_l;
+    case COLOR_A:
+      return _C_a;
+    case COLOR_B:
+      return _C_b;
+    default:
+      throw std::invalid_argument( "received invalid channel value, use COLOR_L, COLOR_A or COLOR_B" );
+  }
+}
+
+cv::Mat lab_pyramid::across_scale_addition(const std::vector<cv::Mat> &scale_images) {
+  cv::Mat result = scale_images.front();
+  cv::Size original_size = scale_images.front().size();
+  for (unsigned long i = 1; i < scale_images.size(); i++) {
+    cv::Mat resized_image;
+    cv::resize(scale_images.at(i), resized_image, original_size, 0, 0, cv::INTER_CUBIC);
+    result += resized_image;
+  }
+  return result;
+}
+
+void lab_pyramid::visualize_dog() {
+  for (unsigned long layer = 0; layer < _number_of_layers; layer++) {
+    cv::namedWindow("CS L");
+    cv::imshow("CS L", _cs_contrast_l.at(layer));
+    cv::namedWindow("SC L");
+    cv::imshow("SC L", _sc_contrast_l.at(layer));
+    cv::namedWindow("CS A");
+    cv::imshow("CS A", _cs_contrast_a.at(layer));
+    cv::namedWindow("SC A");
+    cv::imshow("SC A", _sc_contrast_a.at(layer));
+    cv::namedWindow("CS B");
+    cv::imshow("CS B", _cs_contrast_b.at(layer));
+    cv::namedWindow("SC B");
+    cv::imshow("SC B", _sc_contrast_b.at(layer));
+    cv::waitKey(0);
+  }
+}
+
+void lab_pyramid::visualize_gaussian_pyrs(const lab_pyramid center, const lab_pyramid surround) {
+  gauss_pyramid l_c = center.get_pyramid(COLOR_L);
+  gauss_pyramid l_s = surround.get_pyramid(COLOR_L);
+  gauss_pyramid a_c = center.get_pyramid(COLOR_A);
+  gauss_pyramid a_s = surround.get_pyramid(COLOR_A);
+  gauss_pyramid b_c = center.get_pyramid(COLOR_B);
+  gauss_pyramid b_s = surround.get_pyramid(COLOR_B);
+  int number_of_layers = (int) l_c.get_number_of_layers();
+  for (int layer = 0; layer < number_of_layers; layer++) {
+    cv::namedWindow("L c");
+    cv::imshow("L c", l_c.get(layer) * 1./255);
+    cv::namedWindow("L s");
+    cv::imshow("L s", l_s.get(layer) * 1./255);
+    cv::namedWindow("A c");
+    cv::imshow("A c", a_c.get(layer) * 1./255);
+    cv::namedWindow("A s");
+    cv::imshow("A s", a_s.get(layer) * 1./255);
+    cv::namedWindow("B c");
+    cv::imshow("B c", b_c.get(layer) * 1./255);
+    cv::namedWindow("B s");
+    cv::imshow("B s", b_s.get(layer) * 1./255);
+    cv::waitKey(0);
+  }
+}
+
+void lab_pyramid::visualize_feature_maps() {
+  cv::namedWindow("CS F L");
+  cv::imshow("CS F L", _cs_F_l);
+  cv::namedWindow("CS F L");
+  cv::imshow("SC F L", _sc_F_l);
+  cv::namedWindow("CS F A");
+  cv::imshow("CS F A", _cs_F_a);
+  cv::namedWindow("SC F A");
+  cv::imshow("SC F A", _sc_F_a);
+  cv::namedWindow("CS F B");
+  cv::imshow("CS F B", _cs_F_b);
+  cv::namedWindow("CS F B");
+  cv::imshow("SC F B", _sc_F_b);
+  cv::waitKey(0);
+}

ccv/saliency/laplacian_pyramid.cpp

@@ -0,0 +1,20 @@
+#include "includes/laplacian_pyramid.h"
+
+laplacian_pyramid::laplacian_pyramid(const gauss_pyramid &pyramid, float sigma) {
+  _layers = std::vector<cv::Mat>();
+  unsigned long number_of_layers = pyramid.get_number_of_layers();
+  for (int i = 0; i < number_of_layers; i++) {
+    cv::Mat blurred;
+    cv::GaussianBlur(pyramid.get(i), blurred, cv::Size(), sigma, sigma, cv::BORDER_CONSTANT);
+    cv::Mat laplacian = pyramid.get(i) - blurred;
+    _layers.push_back(laplacian.clone());
+  }
+}
+
+cv::Mat laplacian_pyramid::get(int layer) const {
+  return _layers.at((unsigned long) layer);
+}
+
+unsigned long laplacian_pyramid::get_number_of_layers() const {
+  return _layers.size();
+}

ccv/saliency/main.cpp

@@ -0,0 +1,79 @@
+#include <opencv2/opencv.hpp>
+
+#include "includes/lab_pyramid.h"
+#include "includes/fusion.h"
+#include "includes/laplacian_pyramid.h"
+#include "includes/oriented_pyramid.h"
+
+/**
+ * Entry point of program
+ * @param argc number of arguments
+ * @param argv CLI arguments, 0: name of program, 1: input file name, 2: output file name, 3: flag for usage of orientation
+ * @return status code (0: everything OK, -1: not right amount of arguments)
+ */
+int main(int argc, char** argv) {
+  if (argc != 4) {
+    printf("usage: <input file name> <output file name> <use orientation>\n");
+    return -1;
+  }
+
+  // read image
+  cv::Mat image = cv::imread(argv[1], cv::ImreadModes::IMREAD_COLOR);
+  bool use_orientation = (strcmp(argv[3], "1") == 0);
+
+  // tweakable factors
+  int layers = 4;
+  float sigma_center = 3;
+  float sigma_surround = 13;
+
+  float sigma_laplacian = 4;
+  int number_orientations = 4;
+  int gabor_size = 7;
+  double wavelength = 5;
+  double standard_deviation = 5;
+
+  // create LAB pyramids
+  lab_pyramid lab_pyr_center = lab_pyramid(image);
+  lab_pyr_center.create_pyramids(sigma_center, layers);
+  lab_pyramid lab_pyr_surround = lab_pyramid(image);
+  lab_pyr_surround.create_pyramids(sigma_surround, layers);
+  // create laplacian pyramid
+  gauss_pyramid c_pyr_L = lab_pyr_center.get_pyramid(lab_pyramid::COLOR_L);
+  laplacian_pyramid laplacian_pyr = laplacian_pyramid(c_pyr_L, sigma_laplacian);
+  // create orientation pyramid
+  oriented_pyramid oriented_pyr = oriented_pyramid(laplacian_pyr, number_orientations, gabor_size, wavelength,
+                                                   standard_deviation);
+
+  // create contrast maps
+  lab_pyramid::compute_dog(lab_pyr_center, lab_pyr_surround, layers);
+  // create feature maps
+  lab_pyramid::compute_feature_maps();
+  if (use_orientation) {
+    oriented_pyr.compute_feature_maps();
+  }
+  // create conspicuity maps
+  lab_pyramid::compute_conspicuity_maps();
+  if (use_orientation) {
+    oriented_pyr.compute_conspicuity_map();
+  }
+  // get conspicuity maps
+  std::vector<cv::Mat> conspicuity_maps = std::vector<cv::Mat>();
+  conspicuity_maps.push_back(lab_pyramid::get_conspicuity_map(lab_pyramid::COLOR_L));
+  conspicuity_maps.push_back(lab_pyramid::get_conspicuity_map(lab_pyramid::COLOR_A));
+  conspicuity_maps.push_back(lab_pyramid::get_conspicuity_map(lab_pyramid::COLOR_B));
+  if (use_orientation) {
+    conspicuity_maps.push_back(oriented_pyr.get_conspicuity_map());
+  }
+  // get saliency map
+  cv::Mat saliency = mean_fusion_generic(conspicuity_maps);
+  cv::normalize(saliency, saliency, 0, 255, cv::NORM_MINMAX, -1);
+
+  // convert saliency map to correct output format
+  cv::Mat output_image;
+  saliency.convertTo(output_image, CV_8UC1);
+
+  // write output
+  cv::imwrite(argv[2], output_image);
+
+  return 0;
+}

ccv/saliency/oriented_pyramid.cpp

@@ -0,0 +1,68 @@
+#include "includes/oriented_pyramid.h"
+#include "includes/fusion.h"
+
+oriented_pyramid::oriented_pyramid(const laplacian_pyramid &pyramid, int num_orientations, int size,
+                                   double wavelength, double standard_deviation) {
+  _gabor_filters = std::vector<cv::Mat>();
+  _orientation_maps = std::vector<std::vector<cv::Mat>>();
+  _feature_maps = std::vector<cv::Mat>();
+
+  initialize_gabor_filters(num_orientations, size, wavelength, standard_deviation);
+  unsigned long number_of_layers = pyramid.get_number_of_layers();
+  for (unsigned long i = 0; i < num_orientations; i++) {
+    std::vector<cv::Mat> orientation_vector = std::vector<cv::Mat>();
+    for (int layer = 0; layer < number_of_layers; layer++) {
+      cv::Mat filtered_image;
+      cv::filter2D(pyramid.get(layer), filtered_image, -1, _gabor_filters.at(i), cv::Point(-1, -1), 0, cv::BORDER_CONSTANT);
+      orientation_vector.push_back(filtered_image.clone());
+    }
+    _orientation_maps.push_back(orientation_vector);
+  }
+
+}
+
+void oriented_pyramid::initialize_gabor_filters(float num_orientations, int size,
+                                                double wavelength, double standard_deviation) {
+  cv::Size size_obj = cv::Size(size, size);
+
+  double start_level = num_orientations / 2.0;
+  for (double level = start_level; level >= 0; level--) {
+    _gabor_filters.push_back(cv::getGaborKernel(size_obj, standard_deviation, (level/num_orientations) * CV_PI, wavelength,
+                                                1, 0, CV_32F));
+  }
+
+  double end_level = start_level;
+  start_level = num_orientations - 1;
+
+  for (double level = start_level; level > end_level; level--) {
+    _gabor_filters.push_back(cv::getGaborKernel(size_obj, standard_deviation, (level/num_orientations) * CV_PI, wavelength,
+                                                1, 0, CV_32F));
+  }
+}
+
+void oriented_pyramid::compute_feature_maps() {
+  unsigned long num_orientations = _orientation_maps.size();
+  for (unsigned long i = 0; i < num_orientations; i++) {
+    cv::Mat feature_map = (cv::Mat &&) _orientation_maps.at(i).front();
+    cv::Size original_size = feature_map.size();
+    unsigned long num_layers = _orientation_maps.at(i).size();
+    for (unsigned long layer = 1; layer < num_layers; layer++) {
+      cv::Mat resized_image;
+      cv::resize(_orientation_maps.at(i).at(layer), resized_image, original_size, 0, 0, cv::INTER_CUBIC);
+      feature_map += resized_image;
+    }
+    _feature_maps.push_back(feature_map.clone());
+  }
+}
+
+void oriented_pyramid::compute_conspicuity_map() {
+  _C = max_fusion_generic(_feature_maps);
+}
+
+cv::Mat oriented_pyramid::get_conspicuity_map() {
+  return _C;
+}
+
+cv::Mat oriented_pyramid::get_feature_map(unsigned long orientation) {
+  return _feature_maps.at(orientation).clone();
+}

ccv/saliency/results/result_mean.txt

@@ -0,0 +1,260 @@
+# This file shows results of an evaluation of saliencymaps as described in
+# R. Achanta, S. Hemami, F. Estrada and S. Süsstrunk, Frequency-tuned Salient Region Detection, IEEE International Conference on Computer Vision and Pattern Recognition (CVPR), 2009.
+#
+# threshold mean_precision mean_recall
+0 0.1989 1.000 
+1 0.1989 1.000 
+2 0.1989 1.000 
+3 0.1989 1.000 
+4 0.1989 1.000 
+5 0.1989 1.000 
+6 0.1989 1.000 
+7 0.1989 1.000 
+8 0.1989 1.000 
+9 0.1989 1.000 
+10 0.1989 1.000 
+11 0.1989 1.000 
+12 0.1989 1.000 
+13 0.1989 1.000 
+14 0.1990 1.000 
+15 0.1990 1.000 
+16 0.1990 1.000 
+17 0.1990 1.000 
+18 0.1990 1.000 
+19 0.1990 1.000 
+20 0.1990 1.000 
+21 0.1990 1.000 
+22 0.1990 1.000 
+23 0.1993 1.000 
+24 0.1993 1.000 
+25 0.1993 1.000 
+26 0.1993 1.000 
+27 0.1993 1.000 
+28 0.1993 1.000 
+29 0.1996 1.000 
+30 0.1996 1.000 
+31 0.1996 1.000 
+32 0.1996 1.000 
+33 0.1996 1.000 
+34 0.1996 1.000 
+35 0.2001 1.000 
+36 0.2001 1.000 
+37 0.2001 1.000 
+38 0.2001 1.000 
+39 0.2007 1.000 
+40 0.2007 1.000 
+41 0.2007 1.000 
+42 0.2007 1.000 
+43 0.2014 1.000 
+44 0.2014 1.000 
+45 0.2014 1.000 
+46 0.2014 1.000 
+47 0.2022 1.000 
+48 0.2022 1.000 
+49 0.2022 1.000 
+50 0.2022 1.000 
+51 0.2032 0.9999 
+52 0.2032 0.9999 
+53 0.2032 0.9999 
+54 0.2043 0.9999 
+55 0.2043 0.9999 
+56 0.2043 0.9999 
+57 0.2056 0.9999 
+58 0.2056 0.9999 
+59 0.2056 0.9999 
+60 0.2070 0.9998 
+61 0.2070 0.9998 
+62 0.2085 0.9998 
+63 0.2085 0.9998 
+64 0.2085 0.9998 
+65 0.2101 0.9997 
+66 0.2101 0.9997 
+67 0.2120 0.9996 
+68 0.2120 0.9996 
+69 0.2120 0.9996 
+70 0.2139 0.9995 
+71 0.2139 0.9995 
+72 0.2160 0.9994 
+73 0.2160 0.9994 
+74 0.2182 0.9992 
+75 0.2182 0.9992 
+76 0.2205 0.9991 
+77 0.2205 0.9991 
+78 0.2229 0.9989 
+79 0.2229 0.9989 
+80 0.2255 0.9987 
+81 0.2255 0.9987 
+82 0.2282 0.9985 
+83 0.2282 0.9985 
+84 0.2310 0.9982 
+85 0.2310 0.9982 
+86 0.2340 0.9980 
+87 0.2371 0.9977 
+88 0.2371 0.9977 
+89 0.2402 0.9974 
+90 0.2402 0.9974 
+91 0.2435 0.9970 
+92 0.2435 0.9970 
+93 0.2469 0.9966 
+94 0.2503 0.9962 
+95 0.2503 0.9962 
+96 0.2539 0.9957 
+97 0.2577 0.9952 
+98 0.2577 0.9952 
+99 0.2616 0.9946 
+100 0.2655 0.9939 
+101 0.2655 0.9939 
+102 0.2696 0.9932 
+103 0.2739 0.9925 
+104 0.2739 0.9925 
+105 0.2783 0.9917 
+106 0.2828 0.9909 
+107 0.2873 0.9900 
+108 0.2873 0.9900 
+109 0.2920 0.9891 
+110 0.2969 0.9881 
+111 0.3018 0.9871 
+112 0.3018 0.9871 
+113 0.3069 0.9862 
+114 0.3122 0.9851 
+115 0.3176 0.9840 
+116 0.3231 0.9828 
+117 0.3231 0.9828 
+118 0.3287 0.9815 
+119 0.3344 0.9802 
+120 0.3402 0.9789 
+121 0.3461 0.9775 
+122 0.3520 0.9761 
+123 0.3580 0.9745 
+124 0.3580 0.9745 
+125 0.3640 0.9729 
+126 0.3702 0.9712 
+127 0.3766 0.9695 
+128 0.3830 0.9676 
+129 0.3895 0.9658 
+130 0.3961 0.9639 
+131 0.4027 0.9619 
+132 0.4094 0.9599 
+133 0.4162 0.9579 
+134 0.4230 0.9558 
+135 0.4299 0.9536 
+136 0.4369 0.9514 
+137 0.4439 0.9491 
+138 0.4509 0.9467 
+139 0.4580 0.9443 
+140 0.4651 0.9418 
+141 0.4722 0.9392 
+142 0.4793 0.9366 
+143 0.4864 0.9338 
+144 0.4936 0.9310 
+145 0.5008 0.9281 
+146 0.5080 0.9252 
+147 0.5152 0.9222 
+148 0.5224 0.9191 
+149 0.5368 0.9128 
+150 0.5438 0.9094 
+151 0.5510 0.9061 
+152 0.5581 0.9026 
+153 0.5652 0.8992 
+154 0.5723 0.8956 
+155 0.5793 0.8920 
+156 0.5932 0.8846 
+157 0.5999 0.8808 
+158 0.6066 0.8770 
+159 0.6131 0.8730 
+160 0.6258 0.8649 
+161 0.6320 0.8608 
+162 0.6382 0.8565 
+163 0.6444 0.8523 
+164 0.6565 0.8435 
+165 0.6623 0.8390 
+166 0.6681 0.8345 
+167 0.6738 0.8298 
+168 0.6849 0.8203 
+169 0.6903 0.8154 
+170 0.6955 0.8105 
+171 0.7058 0.8004 
+172 0.7107 0.7953 
+173 0.7156 0.7900 
+174 0.7250 0.7794 
+175 0.7295 0.7741 
+176 0.7383 0.7632 
+177 0.7425 0.7576 
+178 0.7467 0.7519 
+179 0.7549 0.7403 
+180 0.7590 0.7343 
+181 0.7667 0.7222 
+182 0.7705 0.7161 
+183 0.7778 0.7036 
+184 0.7814 0.6973 
+185 0.7849 0.6911 
+186 0.7920 0.6785 
+187 0.7955 0.6722 
+188 0.8023 0.6594 
+189 0.8057 0.6531 
+190 0.8123 0.6404 
+191 0.8188 0.6273 
+192 0.8220 0.6207 
+193 0.8279 0.6074 
+194 0.8307 0.6007 
+195 0.8359 0.5870 
+196 0.8385 0.5800 
+197 0.8432 0.5658 
+198 0.8475 0.5513 
+199 0.8495 0.5440 
+200 0.8535 0.5293 
+201 0.8569 0.5146 
+202 0.8586 0.5073 
+203 0.8619 0.4923 
+204 0.8649 0.4772 
+205 0.8663 0.4696 
+206 0.8691 0.4544 
+207 0.8717 0.4392 
+208 0.8729 0.4316 
+209 0.8754 0.4165 
+210 0.8778 0.4013 
+211 0.8800 0.3861 
+212 0.8811 0.3784 
+213 0.8833 0.3631 
+214 0.8856 0.3481 
+215 0.8877 0.3332 
+216 0.8896 0.3185 
+217 0.8913 0.3037 
+218 0.8921 0.2964 
+219 0.8938 0.2819 
+220 0.8954 0.2676 
+221 0.8968 0.2534 
+222 0.8981 0.2392 
+223 0.8992 0.2252 
+224 0.9001 0.2116 
+225 0.9010 0.1983 
+226 0.9014 0.1918 
+227 0.9023 0.1792 
+228 0.9031 0.1673 
+229 0.9038 0.1558 
+230 0.9044 0.1449 
+231 0.9053 0.1347 
+232 0.9065 0.1250 
+233 0.9072 0.1155 
+234 0.9076 0.1066 
+235 0.9075 0.09809 
+236 0.9067 0.08995 
+237 0.9066 0.08229 
+238 0.9063 0.07512 
+239 0.9052 0.06512 
+240 0.9051 0.05904 
+241 0.9048 0.05330 
+242 0.9047 0.04790 
+243 0.9043 0.04277 
+244 0.9036 0.03787 
+245 0.9017 0.03327 
+246 0.9011 0.02900 
+247 0.9004 0.02321 
+248 0.8996 0.01976 
+249 0.8990 0.01643 
+250 0.8983 0.01345 
+251 0.8964 0.01070 
+252 0.8951 0.006874 
+253 0.8944 0.004407 
+254 0.8948 0.002368 
+255 0.8955 0.0008420 

ccv/saliency/results_0/result_mean.txt

@@ -0,0 +1,260 @@
+# This file shows results of an evaluation of saliencymaps as described in
+# R. Achanta, S. Hemami, F. Estrada and S. Süsstrunk, Frequency-tuned Salient Region Detection, IEEE International Conference on Computer Vision and Pattern Recognition (CVPR), 2009.
+#
+# threshold mean_precision mean_recall
+0 0.1989 1.000 
+1 0.1990 1.000 
+2 0.1990 1.000 
+3 0.1990 1.000 
+4 0.1990 1.000 
+5 0.1990 1.000 
+6 0.1990 1.000 
+7 0.1990 1.000 
+8 0.1990 1.000 
+9 0.1990 1.000 
+10 0.1990 1.000 
+11 0.1990 1.000 
+12 0.1990 1.000 
+13 0.1990 1.000 
+14 0.1995 1.000 
+15 0.1995 1.000 
+16 0.1995 1.000 
+17 0.1995 1.000 
+18 0.1995 1.000 
+19 0.1995 1.000 
+20 0.1995 1.000 
+21 0.1995 1.000 
+22 0.1995 1.000 
+23 0.2010 0.9999 
+24 0.2010 0.9999 
+25 0.2010 0.9999 
+26 0.2010 0.9999 
+27 0.2010 0.9999 
+28 0.2010 0.9999 
+29 0.2039 0.9996 
+30 0.2039 0.9996 
+31 0.2039 0.9996 
+32 0.2039 0.9996 
+33 0.2039 0.9996 
+34 0.2039 0.9996 
+35 0.2078 0.9989 
+36 0.2078 0.9989 
+37 0.2078 0.9989 
+38 0.2078 0.9989 
+39 0.2124 0.9976 
+40 0.2124 0.9976 
+41 0.2124 0.9976 
+42 0.2124 0.9976 
+43 0.2176 0.9955 
+44 0.2176 0.9955 
+45 0.2176 0.9955 
+46 0.2176 0.9955 
+47 0.2232 0.9923 
+48 0.2232 0.9923 
+49 0.2232 0.9923 
+50 0.2232 0.9923 
+51 0.2290 0.9880 
+52 0.2290 0.9880 
+53 0.2290 0.9880 
+54 0.2352 0.9829 
+55 0.2352 0.9829 
+56 0.2352 0.9829 
+57 0.2415 0.9766 
+58 0.2415 0.9766 
+59 0.2415 0.9766 
+60 0.2480 0.9695 
+61 0.2480 0.9695 
+62 0.2544 0.9612 
+63 0.2544 0.9612 
+64 0.2544 0.9612 
+65 0.2607 0.9520 
+66 0.2607 0.9520 
+67 0.2669 0.9415 
+68 0.2669 0.9415 
+69 0.2669 0.9415 
+70 0.2729 0.9295 
+71 0.2729 0.9295 
+72 0.2788 0.9169 
+73 0.2788 0.9169 
+74 0.2846 0.9036 
+75 0.2846 0.9036 
+76 0.2901 0.8895 
+77 0.2901 0.8895 
+78 0.2951 0.8742 
+79 0.2951 0.8742 
+80 0.2996 0.8577 
+81 0.2996 0.8577 
+82 0.3036 0.8406 
+83 0.3036 0.8406 
+84 0.3073 0.8230 
+85 0.3073 0.8230 
+86 0.3106 0.8050 
+87 0.3135 0.7866 
+88 0.3135 0.7866 
+89 0.3160 0.7680 
+90 0.3160 0.7680 
+91 0.3182 0.7494 
+92 0.3182 0.7494 
+93 0.3200 0.7305 
+94 0.3213 0.7114 
+95 0.3213 0.7114 
+96 0.3222 0.6922 
+97 0.3226 0.6727 
+98 0.3226 0.6727 
+99 0.3225 0.6528 
+100 0.3220 0.6329 
+101 0.3220 0.6329 
+102 0.3212 0.6133 
+103 0.3199 0.5939 
+104 0.3199 0.5939 
+105 0.3184 0.5750 
+106 0.3166 0.5562 
+107 0.3146 0.5381 
+108 0.3146 0.5381 
+109 0.3123 0.5203 
+110 0.3099 0.5034 
+111 0.3073 0.4870 
+112 0.3073 0.4870 
+113 0.3046 0.4713 
+114 0.3019 0.4563 
+115 0.2991 0.4418 
+116 0.2963 0.4280 
+117 0.2963 0.4280 
+118 0.2935 0.4149 
+119 0.2907 0.4023 
+120 0.2878 0.3902 
+121 0.2849 0.3787 
+122 0.2820 0.3677 
+123 0.2790 0.3571 
+124 0.2790 0.3571 
+125 0.2760 0.3471 
+126 0.2729 0.3375 
+127 0.2698 0.3283 
+128 0.2669 0.3196 
+129 0.2641 0.3113 
+130 0.2613 0.3035 
+131 0.2587 0.2960 
+132 0.2562 0.2890 
+133 0.2538 0.2823 
+134 0.2514 0.2759 
+135 0.2489 0.2697 
+136 0.2464 0.2636 
+137 0.2439 0.2578 
+138 0.2415 0.2522 
+139 0.2393 0.2470 
+140 0.2373 0.2419 
+141 0.2352 0.2370 
+142 0.2331 0.2322 
+143 0.2312 0.2275 
+144 0.2294 0.2229 
+145 0.2276 0.2185 
+146 0.2253 0.2142 
+147 0.2237 0.2099 
+148 0.2223 0.2057 
+149 0.2190 0.1975 
+150 0.2173 0.1935 
+151 0.2156 0.1895 
+152 0.2136 0.1855 
+153 0.2118 0.1816 
+154 0.2098 0.1778 
+155 0.2076 0.1740 
+156 0.2034 0.1667 
+157 0.2015 0.1632 
+158 0.1995 0.1599 
+159 0.1975 0.1566 
+160 0.1933 0.1500 
+161 0.1910 0.1468 
+162 0.1888 0.1437 
+163 0.1863 0.1405 
+164 0.1814 0.1345 
+165 0.1779 0.1315 
+166 0.1749 0.1286 
+167 0.1722 0.1256 
+168 0.1675 0.1199 
+169 0.1653 0.1171 
+170 0.1631 0.1145 
+171 0.1586 0.1092 
+172 0.1564 0.1065 
+173 0.1540 0.1039 
+174 0.1491 0.09858 
+175 0.1466 0.09600 
+176 0.1419 0.09108 
+177 0.1396 0.08870 
+178 0.1373 0.08638 
+179 0.1325 0.08195 
+180 0.1303 0.07978 
+181 0.1221 0.07562 
+182 0.1201 0.07368 
+183 0.1165 0.06990 
+184 0.1146 0.06801 
+185 0.1124 0.06611 
+186 0.1078 0.06242 
+187 0.1060 0.06064 
+188 0.1023 0.05715 
+189 0.1007 0.05543 
+190 0.09753 0.05219 
+191 0.09483 0.04900 
+192 0.09532 0.04744 
+193 0.09214 0.04427 
+194 0.09048 0.04273 
+195 0.08333 0.03976 
+196 0.08207 0.03828 
+197 0.07784 0.03544 
+198 0.07242 0.03277 
+199 0.07039 0.03153 
+200 0.06594 0.02924 
+201 0.06261 0.02716 
+202 0.06121 0.02613 
+203 0.05835 0.02422 
+204 0.05104 0.02242 
+205 0.04961 0.02154 
+206 0.04582 0.01982 
+207 0.04319 0.01821 
+208 0.04197 0.01746 
+209 0.03967 0.01601 
+210 0.03758 0.01470 
+211 0.03557 0.01353 
+212 0.03466 0.01299 
+213 0.03275 0.01189 
+214 0.03092 0.01086 
+215 0.02517 0.009886 
+216 0.02347 0.009019 
+217 0.02173 0.008174 
+218 0.02082 0.007748 
+219 0.01921 0.006984 
+220 0.01760 0.006288 
+221 0.01622 0.005647 
+222 0.01498 0.005039 
+223 0.01375 0.004458 
+224 0.01266 0.003923 
+225 0.01167 0.003448 
+226 0.01119 0.003227 
+227 0.01026 0.002811 
+228 0.009419 0.002440 
+229 0.008637 0.002107 
+230 0.007970 0.001804 
+231 0.007432 0.001576 
+232 0.007010 0.001395 
+233 0.006617 0.001221 
+234 0.006284 0.001079 
+235 0.005975 0.0009486 
+236 0.005714 0.0008240 
+237 0.005476 0.0007225 
+238 0.005244 0.0006360 
+239 0.004883 0.0005227 
+240 0.004704 0.0004684 
+241 0.004557 0.0004215 
+242 0.004457 0.0003841 
+243 0.004374 0.0003530 
+244 0.004282 0.0003197 
+245 0.004190 0.0002827 
+246 0.004089 0.0002464 
+247 0.003977 0.0002030 
+248 0.003929 0.0001812 
+249 0.003860 0.0001587 
+250 0.003800 0.0001406 
+251 0.003774 0.0001290 
+252 0.003751 0.0001180 
+253 0.003738 0.0001123 
+254 0.003736 0.0001076 
+255 0.003739 0.0001019 

ccv/saliency/results_1/result_mean.txt

@@ -0,0 +1,260 @@
+# This file shows results of an evaluation of saliencymaps as described in
+# R. Achanta, S. Hemami, F. Estrada and S. Süsstrunk, Frequency-tuned Salient Region Detection, IEEE International Conference on Computer Vision and Pattern Recognition (CVPR), 2009.
+#
+# threshold mean_precision mean_recall
+0 0.1989 1.000 
+1 0.1994 1.000 
+2 0.1994 1.000 
+3 0.1994 1.000 
+4 0.1994 1.000 
+5 0.1994 1.000 
+6 0.1994 1.000 
+7 0.1994 1.000 
+8 0.1994 1.000 
+9 0.1994 1.000 
+10 0.1994 1.000 
+11 0.1994 1.000 
+12 0.1994 1.000 
+13 0.1994 1.000 
+14 0.2027 1.000 
+15 0.2027 1.000 
+16 0.2027 1.000 
+17 0.2027 1.000 
+18 0.2027 1.000 
+19 0.2027 1.000 
+20 0.2027 1.000 
+21 0.2027 1.000 
+22 0.2027 1.000 
+23 0.2085 0.9998 
+24 0.2085 0.9998 
+25 0.2085 0.9998 
+26 0.2085 0.9998 
+27 0.2085 0.9998 
+28 0.2085 0.9998 
+29 0.2160 0.9993 
+30 0.2160 0.9993 
+31 0.2160 0.9993 
+32 0.2160 0.9993 
+33 0.2160 0.9993 
+34 0.2160 0.9993 
+35 0.2253 0.9983 
+36 0.2253 0.9983 
+37 0.2253 0.9983 
+38 0.2253 0.9983 
+39 0.2364 0.9966 
+40 0.2364 0.9966 
+41 0.2364 0.9966 
+42 0.2364 0.9966 
+43 0.2495 0.9940 
+44 0.2495 0.9940 
+45 0.2495 0.9940 
+46 0.2495 0.9940 
+47 0.2645 0.9902 
+48 0.2645 0.9902 
+49 0.2645 0.9902 
+50 0.2645 0.9902 
+51 0.2814 0.9850 
+52 0.2814 0.9850 
+53 0.2814 0.9850 
+54 0.2997 0.9781 
+55 0.2997 0.9781 
+56 0.2997 0.9781 
+57 0.3196 0.9697 
+58 0.3196 0.9697 
+59 0.3196 0.9697 
+60 0.3406 0.9594 
+61 0.3406 0.9594 
+62 0.3624 0.9475 
+63 0.3624 0.9475 
+64 0.3624 0.9475 
+65 0.3850 0.9341 
+66 0.3850 0.9341 
+67 0.4084 0.9190 
+68 0.4084 0.9190 
+69 0.4084 0.9190 
+70 0.4327 0.9025 
+71 0.4327 0.9025 
+72 0.4575 0.8849 
+73 0.4575 0.8849 
+74 0.4830 0.8659 
+75 0.4830 0.8659 
+76 0.5083 0.8454 
+77 0.5083 0.8454 
+78 0.5335 0.8235 
+79 0.5335 0.8235 
+80 0.5583 0.8003 
+81 0.5583 0.8003 
+82 0.5827 0.7768 
+83 0.5827 0.7768 
+84 0.6057 0.7526 
+85 0.6057 0.7526 
+86 0.6272 0.7276 
+87 0.6479 0.7020 
+88 0.6479 0.7020 
+89 0.6665 0.6758 
+90 0.6665 0.6758 
+91 0.6834 0.6495 
+92 0.6834 0.6495 
+93 0.6989 0.6227 
+94 0.7152 0.5954 
+95 0.7152 0.5954 
+96 0.7293 0.5680 
+97 0.7341 0.5401 
+98 0.7341 0.5401 
+99 0.7457 0.5125 
+100 0.7556 0.4851 
+101 0.7556 0.4851 
+102 0.7641 0.4583 
+103 0.7719 0.4320 
+104 0.7719 0.4320 
+105 0.7749 0.4068 
+106 0.7816 0.3824 
+107 0.7885 0.3585 
+108 0.7885 0.3585 
+109 0.7910 0.3349 
+110 0.7970 0.3117 
+111 0.8036 0.2893 
+112 0.8036 0.2893 
+113 0.8044 0.2680 
+114 0.8059 0.2477 
+115 0.8098 0.2284 
+116 0.7974 0.2100 
+117 0.7974 0.2100 
+118 0.7907 0.1929 
+119 0.7832 0.1764 
+120 0.7773 0.1610 
+121 0.7585 0.1471 
+122 0.7478 0.1341 
+123 0.7211 0.1220 
+124 0.7211 0.1220 
+125 0.7023 0.1104 
+126 0.6731 0.09981 
+127 0.6650 0.08986 
+128 0.6415 0.08053 
+129 0.6207 0.07185 
+130 0.6115 0.06379 
+131 0.5821 0.05638 
+132 0.5494 0.04991 
+133 0.5180 0.04407 
+134 0.4956 0.03875 
+135 0.4683 0.03425 
+136 0.4451 0.03033 
+137 0.4103 0.02693 
+138 0.3940 0.02399 
+139 0.3538 0.02146 
+140 0.3060 0.01925 
+141 0.2665 0.01734 
+142 0.2385 0.01560 
+143 0.2187 0.01400 
+144 0.2159 0.01254 
+145 0.1938 0.01135 
+146 0.1741 0.01028 
+147 0.1618 0.009347 
+148 0.1452 0.008531 
+149 0.1155 0.007042 
+150 0.1143 0.006452 
+151 0.1019 0.005904 
+152 0.09032 0.005338 
+153 0.07338 0.004777 
+154 0.06947 0.004218 
+155 0.06948 0.003705 
+156 0.04997 0.002711 
+157 0.04216 0.002285 
+158 0.03829 0.001918 
+159 0.03834 0.001625 
+160 0.02684 0.001183 
+161 0.02697 0.0009914 
+162 0.02712 0.0008137 
+163 0.02338 0.0006682 
+164 0.02344 0.0004428 
+165 0.01953 0.0003665 
+166 0.01563 0.0003229 
+167 0.01172 0.0002907 
+168 0.007813 0.0002362 
+169 0.007813 0.0002196 
+170 0.007813 0.0001995 
+171 0.007813 0.0001575 
+172 0.007813 0.0001427 
+173 0.007813 0.0001233 
+174 0.003906 9.333e-05 
+175 0.003906 8.022e-05 
+176 0.003906 4.929e-05 
+177 0.003906 3.461e-05 
+178 0.003906 2.097e-05 
+179 0.000 0.000 
+180 0.000 0.000 
+181 0.000 0.000 
+182 0.000 0.000 
+183 0.000 0.000 
+184 0.000 0.000 
+185 0.000 0.000 
+186 0.000 0.000 
+187 0.000 0.000 
+188 0.000 0.000 
+189 0.000 0.000 
+190 0.000 0.000 
+191 0.000 0.000 
+192 0.000 0.000 
+193 0.000 0.000 
+194 0.000 0.000 
+195 0.000 0.000 
+196 0.000 0.000 
+197 0.000 0.000 
+198 0.000 0.000 
+199 0.000 0.000 
+200 0.000 0.000 
+201 0.000 0.000 
+202 0.000 0.000 
+203 0.000 0.000 
+204 0.000 0.000 
+205 0.000 0.000 
+206 0.000 0.000 
+207 0.000 0.000 
+208 0.000 0.000 
+209 0.000 0.000 
+210 0.000 0.000 
+211 0.000 0.000 
+212 0.000 0.000 
+213 0.000 0.000 
+214 0.000 0.000 
+215 0.000 0.000 
+216 0.000 0.000 
+217 0.000 0.000 
+218 0.000 0.000 
+219 0.000 0.000 
+220 0.000 0.000 
+221 0.000 0.000 
+222 0.000 0.000 
+223 0.000 0.000 
+224 0.000 0.000 
+225 0.000 0.000 
+226 0.000 0.000 
+227 0.000 0.000 
+228 0.000 0.000 
+229 0.000 0.000 
+230 0.000 0.000 
+231 0.000 0.000 
+232 0.000 0.000 
+233 0.000 0.000 
+234 0.000 0.000 
+235 0.000 0.000 
+236 0.000 0.000 
+237 0.000 0.000 
+238 0.000 0.000 
+239 0.000 0.000 
+240 0.000 0.000 
+241 0.000 0.000 
+242 0.000 0.000 
+243 0.000 0.000 
+244 0.000 0.000 
+245 0.000 0.000 
+246 0.000 0.000 
+247 0.000 0.000 
+248 0.000 0.000 
+249 0.000 0.000 
+250 0.000 0.000 
+251 0.000 0.000 
+252 0.000 0.000 
+253 0.000 0.000 
+254 0.000 0.000 
+255 0.000 0.000 

ccv/saliency/results_2/result_mean.txt

@@ -0,0 +1,260 @@
+# This file shows results of an evaluation of saliencymaps as described in
+# R. Achanta, S. Hemami, F. Estrada and S. Süsstrunk, Frequency-tuned Salient Region Detection, IEEE International Conference on Computer Vision and Pattern Recognition (CVPR), 2009.
+#
+# threshold mean_precision mean_recall
+0 0.1989 1.000 
+1 0.1989 1.000 
+2 0.1989 1.000 
+3 0.1989 1.000 
+4 0.1989 1.000 
+5 0.1989 1.000 
+6 0.1989 1.000 
+7 0.1989 1.000 
+8 0.1989 1.000 
+9 0.1989 1.000 
+10 0.1989 1.000 
+11 0.1989 1.000 
+12 0.1989 1.000 
+13 0.1989 1.000 
+14 0.1991 1.000 
+15 0.1991 1.000 
+16 0.1991 1.000 
+17 0.1991 1.000 
+18 0.1991 1.000 
+19 0.1991 1.000 
+20 0.1991 1.000 
+21 0.1991 1.000 
+22 0.1991 1.000 
+23 0.1995 1.000 
+24 0.1995 1.000 
+25 0.1995 1.000 
+26 0.1995 1.000 
+27 0.1995 1.000 
+28 0.1995 1.000 
+29 0.2001 1.000 
+30 0.2001 1.000 
+31 0.2001 1.000 
+32 0.2001 1.000 
+33 0.2001 1.000 
+34 0.2001 1.000 
+35 0.2008 1.000 
+36 0.2008 1.000 
+37 0.2008 1.000 
+38 0.2008 1.000 
+39 0.2016 1.000 
+40 0.2016 1.000 
+41 0.2016 1.000 
+42 0.2016 1.000 
+43 0.2027 1.000 
+44 0.2027 1.000 
+45 0.2027 1.000 
+46 0.2027 1.000 
+47 0.2038 1.000 
+48 0.2038 1.000 
+49 0.2038 1.000 
+50 0.2038 1.000 
+51 0.2051 1.000 
+52 0.2051 1.000 
+53 0.2051 1.000 
+54 0.2065 0.9999 
+55 0.2065 0.9999 
+56 0.2065 0.9999 
+57 0.2080 0.9999 
+58 0.2080 0.9999 
+59 0.2080 0.9999 
+60 0.2097 0.9999 
+61 0.2097 0.9999 
+62 0.2114 0.9999 
+63 0.2114 0.9999 
+64 0.2114 0.9999 
+65 0.2133 0.9998 
+66 0.2133 0.9998 
+67 0.2154 0.9998 
+68 0.2154 0.9998 
+69 0.2154 0.9998 
+70 0.2175 0.9997 
+71 0.2175 0.9997 
+72 0.2197 0.9996 
+73 0.2197 0.9996 
+74 0.2220 0.9995 
+75 0.2220 0.9995 
+76 0.2244 0.9993 
+77 0.2244 0.9993 
+78 0.2269 0.9992 
+79 0.2269 0.9992 
+80 0.2294 0.9990 
+81 0.2294 0.9990 
+82 0.2321 0.9988 
+83 0.2321 0.9988 
+84 0.2349 0.9985 
+85 0.2349 0.9985 
+86 0.2378 0.9983 
+87 0.2409 0.9980 
+88 0.2409 0.9980 
+89 0.2441 0.9976 
+90 0.2441 0.9976 
+91 0.2474 0.9972 
+92 0.2474 0.9972 
+93 0.2507 0.9968 
+94 0.2542 0.9963 
+95 0.2542 0.9963 
+96 0.2577 0.9958 
+97 0.2614 0.9952 
+98 0.2614 0.9952 
+99 0.2652 0.9945 
+100 0.2691 0.9938 
+101 0.2691 0.9938 
+102 0.2730 0.9930 
+103 0.2771 0.9921 
+104 0.2771 0.9921 
+105 0.2813 0.9911 
+106 0.2857 0.9901 
+107 0.2900 0.9890 
+108 0.2900 0.9890 
+109 0.2946 0.9879 
+110 0.2993 0.9866 
+111 0.3040 0.9854 
+112 0.3040 0.9854 
+113 0.3089 0.9839 
+114 0.3139 0.9825 
+115 0.3189 0.9809 
+116 0.3240 0.9793 
+117 0.3240 0.9793 
+118 0.3292 0.9777 
+119 0.3346 0.9760 
+120 0.3400 0.9742 
+121 0.3455 0.9724 
+122 0.3511 0.9706 
+123 0.3569 0.9686 
+124 0.3569 0.9686 
+125 0.3627 0.9666 
+126 0.3686 0.9646 
+127 0.3747 0.9624 
+128 0.3808 0.9603 
+129 0.3870 0.9580 
+130 0.3932 0.9557 
+131 0.3996 0.9533 
+132 0.4061 0.9508 
+133 0.4126 0.9482 
+134 0.4191 0.9456 
+135 0.4257 0.9429 
+136 0.4324 0.9400 
+137 0.4391 0.9371 
+138 0.4459 0.9341 
+139 0.4526 0.9309 
+140 0.4594 0.9277 
+141 0.4661 0.9244 
+142 0.4729 0.9210 
+143 0.4797 0.9176 
+144 0.4865 0.9140 
+145 0.4933 0.9103 
+146 0.5001 0.9066 
+147 0.5069 0.9028 
+148 0.5137 0.8989 
+149 0.5271 0.8906 
+150 0.5339 0.8863 
+151 0.5405 0.8819 
+152 0.5471 0.8775 
+153 0.5537 0.8729 
+154 0.5603 0.8684 
+155 0.5668 0.8637 
+156 0.5797 0.8540 
+157 0.5860 0.8490 
+158 0.5923 0.8439 
+159 0.5985 0.8389 
+160 0.6108 0.8284 
+161 0.6169 0.8230 
+162 0.6230 0.8176 
+163 0.6291 0.8121 
+164 0.6411 0.8009 
+165 0.6469 0.7951 
+166 0.6527 0.7892 
+167 0.6583 0.7832 
+168 0.6694 0.7710 
+169 0.6748 0.7648 
+170 0.6801 0.7586 
+171 0.6905 0.7457 
+172 0.6954 0.7392 
+173 0.7003 0.7325 
+174 0.7098 0.7188 
+175 0.7143 0.7118 
+176 0.7230 0.6974 
+177 0.7272 0.6902 
+178 0.7313 0.6828 
+179 0.7393 0.6677 
+180 0.7432 0.6601 
+181 0.7508 0.6447 
+182 0.7544 0.6370 
+183 0.7617 0.6213 
+184 0.7653 0.6134 
+185 0.7688 0.6055 
+186 0.7755 0.5895 
+187 0.7787 0.5813 
+188 0.7849 0.5650 
+189 0.7878 0.5568 
+190 0.7932 0.5402 
+191 0.7982 0.5234 
+192 0.8004 0.5149 
+193 0.8049 0.4981 
+194 0.8070 0.4896 
+195 0.8110 0.4728 
+196 0.8128 0.4643 
+197 0.8160 0.4473 
+198 0.8194 0.4305 
+199 0.8211 0.4223 
+200 0.8242 0.4057 
+201 0.8273 0.3893 
+202 0.8288 0.3810 
+203 0.8314 0.3644 
+204 0.8339 0.3481 
+205 0.8350 0.3401 
+206 0.8373 0.3243 
+207 0.8392 0.3089 
+208 0.8401 0.3014 
+209 0.8416 0.2866 
+210 0.8434 0.2725 
+211 0.8451 0.2586 
+212 0.8460 0.2518 
+213 0.8474 0.2386 
+214 0.8494 0.2259 
+215 0.8513 0.2138 
+216 0.8529 0.2023 
+217 0.8546 0.1912 
+218 0.8554 0.1858 
+219 0.8571 0.1752 
+220 0.8590 0.1651 
+221 0.8609 0.1553 
+222 0.8620 0.1461 
+223 0.8633 0.1371 
+224 0.8646 0.1285 
+225 0.8661 0.1202 
+226 0.8669 0.1162 
+227 0.8683 0.1085 
+228 0.8692 0.1011 
+229 0.8704 0.09405 
+230 0.8717 0.08729 
+231 0.8726 0.08097 
+232 0.8734 0.07490 
+233 0.8734 0.06913 
+234 0.8732 0.06368 
+235 0.8718 0.05852 
+236 0.8700 0.05363 
+237 0.8686 0.04907 
+238 0.8671 0.04482 
+239 0.8646 0.03888 
+240 0.8630 0.03522 
+241 0.8604 0.03175 
+242 0.8597 0.02854 
+243 0.8593 0.02549 
+244 0.8590 0.02264 
+245 0.8581 0.01990 
+246 0.8561 0.01733 
+247 0.8547 0.01369 
+248 0.8530 0.01148 
+249 0.8504 0.009392 
+250 0.8486 0.007355 
+251 0.8489 0.005578 
+252 0.8459 0.003268 
+253 0.8451 0.001962 
+254 0.8415 0.001033 
+255 0.8397 0.0003618 

ccv/saliency/results_3/result_mean.txt

@@ -0,0 +1,260 @@
+# This file shows results of an evaluation of saliencymaps as described in
+# R. Achanta, S. Hemami, F. Estrada and S. Süsstrunk, Frequency-tuned Salient Region Detection, IEEE International Conference on Computer Vision and Pattern Recognition (CVPR), 2009.
+#
+# threshold mean_precision mean_recall
+0 0.1989 1.000 
+1 0.1989 1.000 
+2 0.1989 1.000 
+3 0.1989 1.000 
+4 0.1989 1.000 
+5 0.1989 1.000 
+6 0.1989 1.000 
+7 0.1989 1.000 
+8 0.1989 1.000 
+9 0.1989 1.000 
+10 0.1989 1.000 
+11 0.1989 1.000 
+12 0.1989 1.000 
+13 0.1989 1.000 
+14 0.1990 1.000 
+15 0.1990 1.000 
+16 0.1990 1.000 
+17 0.1990 1.000 
+18 0.1990 1.000 
+19 0.1990 1.000 
+20 0.1990 1.000 
+21 0.1990 1.000 
+22 0.1990 1.000 
+23 0.1993 1.000 
+24 0.1993 1.000 
+25 0.1993 1.000 
+26 0.1993 1.000 
+27 0.1993 1.000 
+28 0.1993 1.000 
+29 0.1996 1.000 
+30 0.1996 1.000 
+31 0.1996 1.000 
+32 0.1996 1.000 
+33 0.1996 1.000 
+34 0.1996 1.000 
+35 0.2001 1.000 
+36 0.2001 1.000 
+37 0.2001 1.000 
+38 0.2001 1.000 
+39 0.2007 1.000 
+40 0.2007 1.000 
+41 0.2007 1.000 
+42 0.2007 1.000 
+43 0.2014 1.000 
+44 0.2014 1.000 
+45 0.2014 1.000 
+46 0.2014 1.000 
+47 0.2022 1.000 
+48 0.2022 1.000 
+49 0.2022 1.000 
+50 0.2022 1.000 
+51 0.2032 0.9999 
+52 0.2032 0.9999 
+53 0.2032 0.9999 
+54 0.2043 0.9999 
+55 0.2043 0.9999 
+56 0.2043 0.9999 
+57 0.2056 0.9999 
+58 0.2056 0.9999 
+59 0.2056 0.9999 
+60 0.2070 0.9998 
+61 0.2070 0.9998 
+62 0.2085 0.9998 
+63 0.2085 0.9998 
+64 0.2085 0.9998 
+65 0.2101 0.9997 
+66 0.2101 0.9997 
+67 0.2120 0.9996 
+68 0.2120 0.9996 
+69 0.2120 0.9996 
+70 0.2139 0.9995 
+71 0.2139 0.9995 
+72 0.2160 0.9994 
+73 0.2160 0.9994 
+74 0.2182 0.9992 
+75 0.2182 0.9992 
+76 0.2205 0.9991 
+77 0.2205 0.9991 
+78 0.2229 0.9989 
+79 0.2229 0.9989 
+80 0.2255 0.9987 
+81 0.2255 0.9987 
+82 0.2282 0.9985 
+83 0.2282 0.9985 
+84 0.2310 0.9982 
+85 0.2310 0.9982 
+86 0.2340 0.9980 
+87 0.2371 0.9977 
+88 0.2371 0.9977 
+89 0.2402 0.9974 
+90 0.2402 0.9974 
+91 0.2435 0.9970 
+92 0.2435 0.9970 
+93 0.2469 0.9966 
+94 0.2503 0.9962 
+95 0.2503 0.9962 
+96 0.2539 0.9957 
+97 0.2577 0.9952 
+98 0.2577 0.9952 
+99 0.2616 0.9946 
+100 0.2655 0.9939 
+101 0.2655 0.9939 
+102 0.2696 0.9932 
+103 0.2739 0.9925 
+104 0.2739 0.9925 
+105 0.2783 0.9917 
+106 0.2828 0.9909 
+107 0.2873 0.9900 
+108 0.2873 0.9900 
+109 0.2920 0.9891 
+110 0.2969 0.9881 
+111 0.3018 0.9871 
+112 0.3018 0.9871 
+113 0.3069 0.9862 
+114 0.3122 0.9851 
+115 0.3176 0.9840 
+116 0.3231 0.9828 
+117 0.3231 0.9828 
+118 0.3287 0.9815 
+119 0.3344 0.9802 
+120 0.3402 0.9789 
+121 0.3461 0.9775 
+122 0.3520 0.9761 
+123 0.3580 0.9745 
+124 0.3580 0.9745 
+125 0.3640 0.9729 
+126 0.3702 0.9712 
+127 0.3766 0.9695 
+128 0.3830 0.9676 
+129 0.3895 0.9658 
+130 0.3961 0.9639 
+131 0.4027 0.9619 
+132 0.4094 0.9599 
+133 0.4162 0.9579 
+134 0.4230 0.9558 
+135 0.4299 0.9536 
+136 0.4369 0.9514 
+137 0.4439 0.9491 
+138 0.4509 0.9467 
+139 0.4580 0.9443 
+140 0.4651 0.9418 
+141 0.4722 0.9392 
+142 0.4793 0.9366 
+143 0.4864 0.9338 
+144 0.4936 0.9310 
+145 0.5008 0.9281 
+146 0.5080 0.9252 
+147 0.5152 0.9222 
+148 0.5224 0.9191 
+149 0.5368 0.9128 
+150 0.5438 0.9094 
+151 0.5510 0.9061 
+152 0.5581 0.9026 
+153 0.5652 0.8992 
+154 0.5723 0.8956 
+155 0.5793 0.8920 
+156 0.5932 0.8846 
+157 0.5999 0.8808 
+158 0.6066 0.8770 
+159 0.6131 0.8730 
+160 0.6258 0.8649 
+161 0.6320 0.8608 
+162 0.6382 0.8565 
+163 0.6444 0.8523 
+164 0.6565 0.8435 
+165 0.6623 0.8390 
+166 0.6681 0.8345 
+167 0.6738 0.8298 
+168 0.6849 0.8203 
+169 0.6903 0.8154 
+170 0.6955 0.8105 
+171 0.7058 0.8004 
+172 0.7107 0.7953 
+173 0.7156 0.7900 
+174 0.7250 0.7794 
+175 0.7295 0.7741 
+176 0.7383 0.7632 
+177 0.7425 0.7576 
+178 0.7467 0.7519 
+179 0.7549 0.7403 
+180 0.7590 0.7343 
+181 0.7667 0.7222 
+182 0.7705 0.7161 
+183 0.7778 0.7036 
+184 0.7814 0.6973 
+185 0.7849 0.6911 
+186 0.7920 0.6785 
+187 0.7955 0.6722 
+188 0.8023 0.6594 
+189 0.8057 0.6531 
+190 0.8123 0.6404 
+191 0.8188 0.6273 
+192 0.8220 0.6207 
+193 0.8279 0.6074 
+194 0.8307 0.6007 
+195 0.8359 0.5870 
+196 0.8385 0.5800 
+197 0.8432 0.5658 
+198 0.8475 0.5513 
+199 0.8495 0.5440 
+200 0.8535 0.5293 
+201 0.8569 0.5146 
+202 0.8586 0.5073 
+203 0.8619 0.4923 
+204 0.8649 0.4772 
+205 0.8663 0.4696 
+206 0.8691 0.4544 
+207 0.8717 0.4392 
+208 0.8729 0.4316 
+209 0.8754 0.4165 
+210 0.8778 0.4013 
+211 0.8800 0.3861 
+212 0.8811 0.3784 
+213 0.8833 0.3631 
+214 0.8856 0.3481 
+215 0.8877 0.3332 
+216 0.8896 0.3185 
+217 0.8913 0.3037 
+218 0.8921 0.2964 
+219 0.8938 0.2819 
+220 0.8954 0.2676 
+221 0.8968 0.2534 
+222 0.8981 0.2392 
+223 0.8992 0.2252 
+224 0.9001 0.2116 
+225 0.9010 0.1983 
+226 0.9014 0.1918 
+227 0.9023 0.1792 
+228 0.9031 0.1673 
+229 0.9038 0.1558 
+230 0.9044 0.1449 
+231 0.9053 0.1347 
+232 0.9065 0.1250 
+233 0.9072 0.1155 
+234 0.9076 0.1066 
+235 0.9075 0.09809 
+236 0.9067 0.08995 
+237 0.9066 0.08229 
+238 0.9063 0.07512 
+239 0.9052 0.06512 
+240 0.9051 0.05904 
+241 0.9048 0.05330 
+242 0.9047 0.04790 
+243 0.9043 0.04277 
+244 0.9036 0.03787 
+245 0.9017 0.03327 
+246 0.9011 0.02900 
+247 0.9004 0.02321 
+248 0.8996 0.01976 
+249 0.8990 0.01643 
+250 0.8983 0.01345 
+251 0.8964 0.01070 
+252 0.8951 0.006874 
+253 0.8944 0.004407 
+254 0.8948 0.002368 
+255 0.8955 0.0008420 

ccv/saliency/tools/batch_saliency.py

@@ -0,0 +1,27 @@
+import argparse
+import os
+import subprocess
+
+
+def batch():
+    """
+    Performs a batch call to the saliency system.
+    """
+    parser = argparse.ArgumentParser(description="Calls the saliency system")
+    parser.add_argument("input", metavar="input", type=str, help="The directory of the input images.")
+    parser.add_argument("output", metavar="output", type=str, help="The directory of the saliency maps.")
+    parser.add_argument("saliency", metavar="saliency", type=str, help="The path to the saliency tool.")
+    
+    args = parser.parse_args()
+    input_dir = os.fsencode(args.input)
+    
+    for file in os.listdir(input_dir):
+        filename = os.fsdecode(file)
+        base_filename, ext = os.path.splitext(filename)
+        input_filename = os.path.join(args.input, filename)
+        output_filename = os.path.join(args.output, base_filename + "_saliency.png")
+        subprocess.run([args.saliency, input_filename, output_filename, "0"], stderr=subprocess.PIPE, check=True)
+        
+    
+if __name__ == "__main__":
+    batch()

ccv/sheet1/CMakeLists.txt

@@ -0,0 +1,5 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+project(sheet1)
+
+add_subdirectory(basics)
+add_subdirectory(opencv)

ccv/sheet1/basics/AskInteger.cpp

@@ -0,0 +1,25 @@
+//
+// Created by jim on 4/4/17.
+//
+#include <iostream>
+using namespace std;
+
+int main()
+{
+  int input;
+  cout << "Bitte geben Sie eine Zahl ein." << endl;
+  cin >> input;
+  if (input > 9)
+  {
+    cout << input << " ist größer gleich 10." << endl;
+  }
+  else if (input >= 0)
+  {
+    cout << input << " liegt zwischen einschließlich 0 und 9." << endl;
+  }
+  else
+  {
+    cout << input << " ist negativ." << endl;
+  }
+  return 0;
+}

ccv/sheet1/basics/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_library(Rectangle Rectangle.cpp)
+add_executable(main main.cpp)
+target_link_libraries(main Rectangle)
+add_executable(hello hello.cpp)
+add_executable(AskInteger AskInteger.cpp)

ccv/sheet1/basics/Rectangle.cpp

@@ -0,0 +1,17 @@
+//
+// Created by jim on 4/4/17.
+//
+#include <iostream>
+#include "Rectangle.h"
+using namespace std;
+
+Rectangle::Rectangle(unsigned int width, unsigned int height)
+{
+  this->width = width;
+  this->height = height;
+}
+
+unsigned int Rectangle::area()
+{
+  cout << this->width * this->height << endl;
+}

ccv/sheet1/basics/Rectangle.h

@@ -0,0 +1,19 @@
+//
+// Created by jim on 4/4/17.
+//
+
+#ifndef SHEET1_RECTANGLE_H
+#define SHEET1_RECTANGLE_H
+
+class Rectangle
+{
+private:
+    unsigned int width;
+    unsigned int height;
+
+public:
+    Rectangle(unsigned int, unsigned int);
+    unsigned int area();
+};
+
+#endif //SHEET1_RECTANGLE_H

ccv/sheet1/basics/hello.cpp

@@ -0,0 +1,12 @@
+//
+// Created by jim on 4/4/17.
+//
+#include <iostream>
+#include <string>
+using namespace std;
+
+int main()
+{
+  std::cout << "Hello world!";
+  return 0;
+}

ccv/sheet1/basics/main.cpp

@@ -0,0 +1,11 @@
+//
+// Created by jim on 4/4/17.
+//
+#include "Rectangle.h"
+
+int main()
+{
+  Rectangle rec = Rectangle(20, 10);
+  rec.area();
+  return 0;
+}

ccv/sheet1/opencv/CMakeLists.txt

@@ -0,0 +1,5 @@
+find_package( OpenCV REQUIRED )
+add_executable(displayImage displayImage.cpp)
+add_executable(loadModifySave loadModifySaveImage.cpp)
+target_link_libraries( displayImage ${OpenCV_LIBS} )
+target_link_libraries( loadModifySave ${OpenCV_LIBS} )

ccv/sheet1/opencv/displayImage.cpp

@@ -0,0 +1,31 @@
+//
+// Created by jim on 4/4/17.
+//
+#include <stdio.h>
+#include <opencv2/opencv.hpp>
+
+using namespace cv;
+
+int main(int argc, char** argv )
+{
+  if ( argc != 2 )
+  {
+    printf("usage: DisplayImage.out <Image_Path>\n");
+    return -1;
+  }
+
+  Mat image;
+  image = imread( argv[1], 1 );
+
+  if ( !image.data )
+  {
+    printf("No image data \n");
+    return -1;
+  }
+  namedWindow("Display Image", WINDOW_AUTOSIZE );
+  imshow("Display Image", image);
+
+  waitKey(0);
+
+  return 0;
+}

ccv/sheet1/opencv/loadModifySaveImage.cpp

@@ -0,0 +1,35 @@
+//
+// Created by jim on 4/7/17.
+//
+#include <opencv2/opencv.hpp>
+
+using namespace cv;
+
+int main( int argc, char** argv )
+{
+  char* imageName = argv[1];
+
+  Mat image;
+  image = imread( imageName, 1 );
+
+  if( argc != 2 || !image.data )
+  {
+    printf( " No image data \n " );
+    return -1;
+  }
+
+  Mat gray_image;
+  cvtColor( image, gray_image, CV_BGR2GRAY );
+
+  imwrite( "Gray_Image.jpg", gray_image );
+
+  namedWindow( imageName, CV_WINDOW_NORMAL );
+  namedWindow( "Gray image", CV_WINDOW_NORMAL);
+
+  imshow( imageName, image );
+  imshow( "Gray image", gray_image );
+
+  waitKey(0);
+
+  return 0;
+}

ccv/sheet2/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.5)
+project(sheet2)
+
+set(CMAKE_CXX_STANDARD 11)
+
+find_package( OpenCV REQUIRED )
+
+add_executable(sheet2 main.cpp)
+target_link_libraries(sheet2 ${OpenCV_LIBS})

ccv/sheet2/main.cpp

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <opencv2/opencv.hpp>
+
+int main()
+{
+  // exercise 1
+  float g[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+  cv::Mat M(4, 4, CV_8UC1, g);
+  std::cout << M << std::endl << std::endl;
+  // exercise 2
+  M.at<uchar>(1, 2) = 100;
+  std::cout << M << std::endl << std::endl;
+  // exercise 3
+  std::cout << "The elements of the matrix: ";
+  for (int row = 0; row < M.rows; ++row)
+  {
+    for (int col = 0; col < M.cols; ++col)
+    {
+      if (row != 0 || col != 0)
+      {
+        std::cout << ",";
+      }
+      std::cout << " " << static_cast<int>(M.at<uchar>(row, col));
+    }
+  }
+  std::cout << std::endl << std::endl;
+  //exercise 4
+  cv::Mat K(M);
+  K.at<uchar>(1, 2) = 200;
+  std::cout << "M: " << M << std::endl << "K: " << K << std::endl << std::endl;
+  //exercise 5
+  cv::Mat B = cv::Mat(400, 400, CV_8UC3, cv::Scalar(255, 0, 0));
+  cv::namedWindow("Display Image", cv::WINDOW_FULLSCREEN);
+  cv::imshow("Display Image", B);
+  cv::waitKey(0);
+  return 0;
+}
+

ccv/sheet3/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.5)
+project(sheet3)
+
+set(CMAKE_CXX_STANDARD 11)
+
+find_package( OpenCV REQUIRED )
+
+add_executable(sheet3 main.cpp)
+add_executable(sheet3-exercise1 exercise1.cpp)
+add_executable(sheet3-exercise3 exercise3.cpp)
+add_executable(sheet3-exercise4 gauss_pyramid.cpp lab_pyramid.cpp exercise4.cpp)
+target_link_libraries(sheet3 ${OpenCV_LIBS})
+target_link_libraries(sheet3-exercise1 ${OpenCV_LIBS})
+target_link_libraries(sheet3-exercise3 ${OpenCV_LIBS})
+target_link_libraries(sheet3-exercise4 ${OpenCV_LIBS})

ccv/sheet3/exercise1.cpp

@@ -0,0 +1,44 @@
+#include <opencv2/opencv.hpp>
+
+int main(int argc, char** argv ) {
+// exercise 1
+
+// matrix M
+  float m[] = {1.0, 1.0, 1.0, 1.0, 2.0, 1.0, 1.0, 1.0, 1.0};
+  cv::Mat M(3, 3, CV_32FC1, m);
+// gaussian filter kernel
+  float g[] = {1, 2, 1, 2, 4, 2, 1, 2, 1};
+  cv::Mat G(3, 3, CV_32FC1, g);
+  G = G * 0.0625;
+// output G
+  std::cout << G << std::endl << std::endl;
+
+// convolve 1.
+  cv::Mat M_1;
+  cv::filter2D(M, M_1, -1, G, cv::Point(-1, -1), 0, cv::BORDER_CONSTANT);
+// output M_1
+  std::cout << M_1 << std::endl << std::endl;
+
+// convolve 2.
+  float g_1[] = {1, 2, 1};
+  cv::Mat G_1(1, 3, CV_32FC1, g_1);
+  G_1 = G_1 * 0.25;
+  float g_2[] = {1, 2, 1};
+  cv::Mat G_2(3, 1, CV_32FC1, g_2);
+  G_2 = G_2 * 0.25;
+// output G_1, G_2
+  std::cout << G_1 << std::endl << std::endl;
+  std::cout << G_2 << std::endl << std::endl;
+
+  cv::Mat M_2;
+  cv::Mat M_3;
+  cv::filter2D(M, M_2, -1, G_1, cv::Point(-1, -1), 0, cv::BORDER_CONSTANT);
+  cv::filter2D(M_2, M_3, -1, G_2, cv::Point(-1, -1), 0, cv::BORDER_CONSTANT);
+// output M_3
+  std::cout << M_3 << std::endl << std::endl;
+
+// convolve 3.
+  cv::Mat M_4;
+  cv::GaussianBlur(M, M_4, cv::Size(3, 3), 0, 0, cv::BORDER_CONSTANT);
+  std::cout << M_4 << std::endl << std::endl;
+}

ccv/sheet3/exercise3.cpp

@@ -0,0 +1,66 @@
+#include <opencv2/opencv.hpp>
+
+int main(int argc, char** argv ) {
+  if ( argc != 2 )
+  {
+    printf("usage: <Image_Path>\n");
+    return -1;
+  }
+
+  cv::Mat image;
+  image = cv::imread(argv[1], cv::ImreadModes::IMREAD_COLOR);
+  cv::Mat image_gray;
+  cv::cvtColor(image, image_gray, cv::COLOR_BGR2GRAY);
+  cv::Mat image_float;
+  image_gray.convertTo(image_float, CV_32F);
+  cv::Mat image_write;
+
+  cv::Mat G_1;
+  cv::Mat G_2;
+  cv::GaussianBlur(image_float, G_1, cv::Size(3, 3), 3, 3, cv::BORDER_CONSTANT);
+  cv::GaussianBlur(image_float, G_2, cv::Size(3, 3), 11, 11, cv::BORDER_CONSTANT);
+  cv::Mat image_filtered = G_1 - G_2;
+
+  cv::imshow("Filtered (3 - 11)", image_filtered);
+  image_write = image_filtered * 255;
+  cv::imwrite("Filter-3-11.jpg", image_write);
+  cv::waitKey(0);
+
+  cv::GaussianBlur(image_float, G_1, cv::Size(3, 3), 3, 3, cv::BORDER_CONSTANT);
+  cv::GaussianBlur(image_float, G_2, cv::Size(3, 3), 7, 7, cv::BORDER_CONSTANT);
+  image_filtered = G_1 - G_2;
+
+  cv::imshow("Filtered (3 - 7)", image_filtered);
+  image_write = image_filtered * 255;
+  cv::imwrite("Filter-3-7.jpg", image_write);
+  cv::waitKey(0);
+
+  cv::GaussianBlur(image_float, G_1, cv::Size(3, 3), 5, 5, cv::BORDER_CONSTANT);
+  cv::GaussianBlur(image_float, G_2, cv::Size(3, 3), 7, 7, cv::BORDER_CONSTANT);
+  image_filtered = G_1 - G_2;
+
+  cv::imshow("Filtered (5 - 7)", image_filtered);
+  image_write = image_filtered * 255;
+  cv::imwrite("Filter-5-7.jpg", image_write);
+  cv::waitKey(0);
+
+  cv::GaussianBlur(image_float, G_1, cv::Size(3, 3), 11, 11, cv::BORDER_CONSTANT);
+  cv::GaussianBlur(image_float, G_2, cv::Size(3, 3), 3, 3, cv::BORDER_CONSTANT);
+  image_filtered = G_1 - G_2;
+  image_float.convertTo(image_gray, CV_8U);
+
+  cv::imshow("Filtered (11 - 3)", image_filtered);
+  image_write = image_filtered * 255;
+  cv::imwrite("Filter-11-3.jpg", image_write);
+  cv::waitKey(0);
+
+  cv::GaussianBlur(image_float, G_1, cv::Size(3, 3), 9, 9, cv::BORDER_CONSTANT);
+  cv::GaussianBlur(image_float, G_2, cv::Size(3, 3), 5, 5, cv::BORDER_CONSTANT);
+  image_filtered = G_1 - G_2;
+
+  cv::imshow("Filtered (9 - 5)", image_filtered);
+  image_write = image_filtered * 255;
+  cv::imwrite("Filter-9-5.jpg", image_write);
+  cv::waitKey(0);
+}
+

ccv/sheet3/exercise4.cpp

@@ -0,0 +1,35 @@
+#include "lab_pyramid.h"
+
+int main(int argc, char** argv ) {
+  if ( argc != 2 )
+  {
+    printf("usage: <Image_Path>\n");
+    return -1;
+  }
+
+  lab_pyramid pyramid = lab_pyramid(argv[1]);
+  const int number_of_layers = 5;
+  pyramid.create_pyramids(number_of_layers);
+  gauss_pyramid l_pyr = pyramid.get_pyramid(lab_pyramid::COLOR_L);
+  gauss_pyramid a_pyr = pyramid.get_pyramid(lab_pyramid::COLOR_A);
+  gauss_pyramid b_pyr = pyramid.get_pyramid(lab_pyramid::COLOR_B);
+
+  for (int i = 0; i < number_of_layers; i++)
+  {
+    cv::imshow("Channel: L, Layer:" + std::to_string(i), l_pyr.get(i));
+    cv::waitKey(0);
+  }
+
+  for (int i = 0; i < number_of_layers; i++)
+  {
+    cv::imshow("Channel: A, Layer:" + std::to_string(i), a_pyr.get(i));
+    cv::waitKey(0);
+  }
+
+  for (int i = 0; i < number_of_layers; i++)
+  {
+    cv::imshow("Channel: B, Layer:" + std::to_string(i), b_pyr.get(i));
+    cv::waitKey(0);
+  }
+  return 0;
+}

ccv/sheet3/gauss_pyramid.cpp

@@ -0,0 +1,21 @@
+#include "gauss_pyramid.h"
+
+gauss_pyramid::gauss_pyramid() {}
+
+gauss_pyramid::gauss_pyramid(cv::Mat img, int number_of_layers)
+{
+  _layers.push_back(img);
+  cv::Mat blurredImage;
+  cv::Mat resizedImage = img;
+  for (int i = 1; i < number_of_layers; i++)
+  {
+    cv::GaussianBlur(resizedImage, blurredImage, cv::Size(5, 5), 0, 0, cv::BORDER_CONSTANT);
+    cv::resize(blurredImage, resizedImage, cv::Size(), 0.5, 0.5, cv::INTER_NEAREST);
+    _layers.push_back(resizedImage);
+  }
+}
+
+cv::Mat gauss_pyramid::get(int layer)
+{
+  return _layers.at((unsigned long) layer);
+}

ccv/sheet3/gauss_pyramid.h

@@ -0,0 +1,17 @@
+#ifndef SHEET3_GAUSS_PYRAMID_H
+#define SHEET3_GAUSS_PYRAMID_H
+
+#include <opencv2/opencv.hpp>
+
+class gauss_pyramid
+{
+private:
+    std::vector<cv::Mat> _layers;
+public:
+    gauss_pyramid();
+    gauss_pyramid(cv::Mat img, int number_of_layers);
+    cv::Mat get(int layer);
+};
+
+
+#endif //SHEET3_GAUSS_PYRAMID_H

ccv/sheet3/lab_pyramid.cpp

@@ -0,0 +1,29 @@
+#include "lab_pyramid.h"
+
+lab_pyramid::lab_pyramid(cv::String image_filename) {
+  cv::Mat image_rgb = cv::imread(image_filename, cv::IMREAD_COLOR);
+  cv::cvtColor(image_rgb, _inputImage_lab, cv::COLOR_RGB2Lab);
+  cv::split(_inputImage_lab ,_imageChannels);
+};
+
+void lab_pyramid::create_pyramids(int number_of_layers)
+{
+  _pyramids[COLOR_L] = gauss_pyramid(_imageChannels[COLOR_L], number_of_layers);
+  _pyramids[COLOR_A] = gauss_pyramid(_imageChannels[COLOR_A], number_of_layers);
+  _pyramids[COLOR_B] = gauss_pyramid(_imageChannels[COLOR_B], number_of_layers);
+}
+
+gauss_pyramid lab_pyramid::get_pyramid(int channel)
+{
+  switch (channel)
+  {
+    case COLOR_L:
+      return _pyramids[COLOR_L];
+    case COLOR_A:
+      return _pyramids[COLOR_A];
+    case COLOR_B:
+      return _pyramids[COLOR_B];
+    default:
+      throw std::invalid_argument( "received invalid channel value, use COLOR_L, COLOR_A or COLOR_B" );
+  }
+}

ccv/sheet3/lab_pyramid.h

@@ -0,0 +1,41 @@
+#ifndef SHEET3_LAB_PYRAMID_H
+#define SHEET3_LAB_PYRAMID_H
+
+#include <opencv2/opencv.hpp>
+#include "gauss_pyramid.h"
+
+class lab_pyramid {
+private:
+    cv::Mat _inputImage_lab;
+    cv::Mat _imageChannels[3];
+    gauss_pyramid _pyramids[3];
+public:
+    const static int COLOR_L = 0;
+    const static int COLOR_A = 1;
+    const static int COLOR_B = 2;
+
+    /**
+     * Initializes a LAB pyramid.
+     *
+     * @param image_filename the filename of the image that should be used
+     */
+    lab_pyramid(cv::String image_filename);
+
+    /**
+     * Creates the gaussian pyramids for all channels with the given number of layers each.
+     *
+     * @param number_of_layers number of layers for gaussian pyramid
+     */
+    void create_pyramids(int number_of_layers);
+
+    /**
+     * Before this method can be called, pyramids have to be created via create_pyramids.
+     *
+     * @param channel the channel you want to get (COLOR_L, COLOR_A or COLOR_B)
+     * @return the gaussian_pyramid for the given channel
+     */
+    gauss_pyramid get_pyramid(int channel);
+};
+
+
+#endif //SHEET3_LAB_PYRAMID_H

ccv/sheet3/main.cpp

@@ -0,0 +1,24 @@
+#include <opencv2/opencv.hpp>
+
+int main(int argc, char** argv ) {
+  if ( argc != 2 )
+  {
+    printf("usage: main.out <Image_Path>\n");
+    return -1;
+  }
+
+  // exercise 2
+  cv::Mat image;
+  image = cv::imread(argv[1], cv::ImreadModes::IMREAD_COLOR);
+  int kmax = 50;
+  cv::Mat Matrix_convoluted;
+  for (int k = 3; k < kmax; k+=2) {
+    cv::GaussianBlur(image, Matrix_convoluted, cv::Size(k, k), 0, 0, cv::BORDER_CONSTANT);
+    std::string imageName = "Kernel (";
+    imageName = imageName + std::to_string(k) + ", " + std::to_string(k) + ")";
+    cv::imshow(imageName, Matrix_convoluted);
+    cv::waitKey(500);
+  }
+
+  return 0;
+}

ccv/sheet4/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.5)
+project(sheet4)
+
+set(CMAKE_CXX_STANDARD 11)
+
+find_package( OpenCV REQUIRED )
+
+add_executable(sheet4 gauss_pyramid.cpp lab_pyramid.cpp main.cpp)
+target_link_libraries(sheet4 ${OpenCV_LIBS})

ccv/sheet4/gauss_pyramid.cpp

@@ -0,0 +1,25 @@
+#include "gauss_pyramid.h"
+
+gauss_pyramid::gauss_pyramid() {}
+
+gauss_pyramid::gauss_pyramid(cv::Mat img, float sigma, int number_of_layers)
+{
+  cv::Mat blurredImage;
+  cv::Mat resizedImage = img.clone();
+  for (int i = 0; i < number_of_layers; i++)
+  {
+    cv::GaussianBlur(resizedImage, blurredImage, cv::Size(0, 0), sigma, sigma, cv::BORDER_REPLICATE);
+    _layers.push_back(blurredImage.clone());
+    cv::resize(blurredImage, resizedImage, cv::Size(), 0.5, 0.5, cv::INTER_NEAREST);
+  }
+}
+
+cv::Mat gauss_pyramid::get(int layer)
+{
+  return _layers.at((unsigned long) layer);
+}
+
+unsigned long gauss_pyramid::get_number_of_layers()
+{
+  return _layers.size();
+}