Programmkomponenten + Ablauf finalized

.vscode/ltex.dictionary.de-AT.txt

@@ -45,3 +45,6 @@ Processor
 Delegates
 Processors
 EvaluationProcessor
+ReportGenerator
+ReportGenerator-Frameworks
+ReportGenerators

chapters/c30_konzept/vergleich/metriken.tex

@@ -34,7 +34,7 @@ Um also ein umfassendes Bild von der Genauigkeit des Texterkennungssystems zu er
 
 \subsubsection{Character Error Rate}
 
-Die Character Error Rate (CER) beschreibt die Anzeahl der falsch erkannten oder fehlenden Zeichen im Vergleich zu einem Referenzwort. Je niedriger die CER, desto genauer ist der OCR-Vorgang. Um die CER zu berechnen, bildet man die Summe aller notwendigen Ersetzungen, Entfernungen und Einfügungen, um aus dem erkannten Wort die Referenz bilden zu können und teilt sie durch die Anzahl an Zeichen im Referenzwort.
+Die Character Error Rate (CER) beschreibt die Anzahl der falsch erkannten oder fehlenden Zeichen im Vergleich zu einem Referenzwort. Je niedriger die CER, desto genauer ist der OCR-Vorgang. Um die CER zu berechnen, bildet man die Summe aller notwendigen Ersetzungen, Entfernungen und Einfügungen, um aus dem erkannten Wort die Referenz bilden zu können und teilt sie durch die Anzahl an Zeichen im Referenzwort.
 
 \subsubsubsection{Berechnung}
 

chapters/c40_durchführung/implementierung.tex

@@ -132,6 +132,11 @@ Angefangen mit einem Ausgangsbild, welches über die Softwarebibliothek Magick.N
 
 Wurde der übergebene Screenshot vom Texterkennungssystem verarbeitet, müssen nun die Ergebnisse gefiltert werden. Dazu werden zunächst die Metadaten der einzelnen Wörter betrachtet und alle Elemente mit einer Confidence unter einem Schwellenwert von 50\% verworfen. Danach werden die erkannten Texte mittels der \csharp-Funktion ToLower() normalisiert und anschließend auf Duplikate untersucht. Sind alle Duplikate verworfen, werden die Wörter schlussendlich mittels sprachabhängigen Regular Expressions -- in diesem Fall gibt es gemäß den Annahmen in \autoref{annahmen_mehrsprachigkeit} einen Sprachfilter für Englisch und Deutsch -- gefiltert.
 
+\subsubsection{Automatische Berichterstellung}
+\label{components_reportgenerator}
+
+Mithilfe des ReportGenerator-Frameworks wird die automatische Berichterstellung für unterschiedlichste Ausgabeformate abstrahiert. Durch die mitgelieferten Schnittstellendefinitionen ist es möglich, eigene Ausgabeformate zu definieren und den Funktionsumfang des ReportGenerators, wie beispielsweise das Erstellen von Tabellen oder das Anlegen und Überschriften, an die jeweilige Syntax und Dokumentstruktur anzupassen.
+
 \subsection{Programmablauf}
 
 Die prototypische Implementierung besteht neben den oben genannten Komponenten aus einem ausführbaren Kommandozeilenprogramm zur Texterkennung und einem Programm zum Vergleich der Ergebnisse mit den manuell verschlagworteten Soll-Daten.
@@ -145,22 +150,22 @@ Alle relevanten Daten werden in entsprechenden Ausgabeverzeichnissen festgehalte
 Zu Beginn der Ausführung des Kommandozeilenprogramms wird für jedes zu verarbeitende Bild abhängig von den definierten Schwellenwertverfahren eine Reihe von Prozessoren angelegt. Dazu wurde der statische Teil der Bildverarbeitungskette gemäß \autoref{processor_chain_image} innerhalb der "EvaluationProcessor" Klasse definiert. Lediglich die zu evaluierenden Prozessoren für die jeweiligen Schwellwertverfahren können außerhalb der klasse dynamisch definiert werden. Der EvaluationProcessor legt die erzeugten Ergebnisdaten, bestehend aus den gefundenen Wörtern und zugehörigen Metadaten wie die Confidence, auf Dateiebene ab. Um überprüfen zu können, welches Bild schlussendlich an das Texterkennungssystem übergeben wurde, werden auch die verarbeiteten Bilder nach der Binarisierung gespeichert.
 
 \begin{CsCode}[numbers=none]
-private static IEnumerable<EvaluationProcessor> MakeThresholdVariations()
-{
-  for (int i = 4; i <= 24; i += 4)
+  private static IEnumerable<EvaluationProcessor> MakeThresholdVariations()
   {
-    yield return new(new ThresholdAdaptiveProcessor(i));
-  }
+      for (int i = 4; i <= 24; i += 4)
+      {
+          yield return new(new ThresholdAdaptiveProcessor(i));
+        }
 
-  for (int i = 20; i <= 80; i += 10)
-  {
-    yield return new(new ThresholdProcessor(i));
-  }
+      for (int i = 20; i <= 80; i += 10)
+      {
+          yield return new(new ThresholdProcessor(i));
+        }
 
-  yield return new(new AutoThresholdProcessor(AutoThresholdMethod.Kapur));
-  yield return new(new AutoThresholdProcessor(AutoThresholdMethod.OTSU));
-  yield return new(new AutoThresholdProcessor(AutoThresholdMethod.Triangle));
-}
+      yield return new(new AutoThresholdProcessor(AutoThresholdMethod.Kapur));
+      yield return new(new AutoThresholdProcessor(AutoThresholdMethod.OTSU));
+      yield return new(new AutoThresholdProcessor(AutoThresholdMethod.Triangle));
+    }
 \end{CsCode}
 \label{program:program_processor_definition}
 \captionof{program}{Auszug aus Datei "Program.cs": Definition der Thresholding Prozessoren}
@@ -169,12 +174,48 @@ Ist die Erstellung der Bildbearbeitungsprozessoren abgeschlossen, wird jeder ein
 
 \subsubsection{Vergleich mit Soll-Daten}
 
-Wurde die 
+Wurden die in den jeweiligen Screenshots erkannten Textdaten abgelegt, werden diese Daten im zweiten Kommandozeilenprogramm "ReportGenerator" nun mit den manuell verschlagworteten Daten verglichen und die Ergebnisse in einen Bericht (\engl{Report}) gespeichert.
 
-% TODO
-TODO: Beschreibung der Schlüsselkomponenten für den programmatischen Vergleich mit den Soll-Daten
+Als zentrale Komponente für den Vergleich spielt die Berechnung der in \autoref{metriken} erklärten Metriken eine wesentliche Rolle. Wie in Programm \ref{program:distance_levenshtein} ersichtlich, wird die Distanz zwischen zwei \csharp-Enumerables, seien es zwei Strings oder zwei Listen, über das Verfahren nach Levenshtein berechnet.
 
-\subsubsection{Automatische Berichterstellung}
+\begin{CsCode}[numbers=none]
+public static double GetDistance<T>(T reference, T? hypothesis)
+where T : IEnumerable
+  {
+    var refArr = reference.Cast<object>().ToArray();
+    var hypArr = hypothesis?.Cast<object>().ToArray() ?? Array.Empty<object>();
 
-% TODO
-TODO: Beschreibung der Schlüsselkomponenten für die automatische Report-Erstellung
+    var distance = new int[refArr.Length + 1, hypArr.Length + 1];
+
+    for (var x = 0; x <= refArr.Length; x++)
+    {
+        distance[x, 0] = x;
+      }
+
+    for (var y = 0; y <= hypArr.Length; y++)
+    {
+        distance[0, y] = y;
+      }
+
+    for (var x = 0; x < refArr.Length; x++)
+    {
+        for (var y = 0; y < hypArr.Length; y++)
+        {
+            var cost = Equals(refArr[x], hypArr[y]) ? 0 : 1;
+
+            var c1 = distance[x, y] + cost; // Bottom left
+
+            var c2 = distance[x, y + 1] + 1; // Top left
+            var c3 = distance[x + 1, y] + 1; // Bottom right
+
+            distance[x + 1, y + 1] = Min(c1, c2, c3); // Top right
+          }
+      }
+
+    return distance[refArr.Length, hypArr.Length];
+  }
+\end{CsCode}
+\label{program:distance_levenshtein}
+\captionof{program}{Auszug aus Datei "Calculator.cs": Berechnung der Levenshtein-Distanz}
+
+Nach der Ermittlung der jeweiligen Distanzen auf Wort- \bzw Bildbasis werden sie mit den jeweiligen Ursprungsbildern, Prozessoren und den verwendeten Algorithmen in Bezug gesetzt. Die so aufbereiteten Ergebnisse werden anschließend an den ReportGenerator übergeben und in einen Bericht zusammengefasst.