diff --git a/Fazeli_Shahroudi-Sepehr-Mastersthesis.tex b/Fazeli_Shahroudi-Sepehr-Mastersthesis.tex
index d943d75ba113592c22cb33dba92c01e0f5564aff..2b1444fbe94ed2f166f0828824a54081859415d4 100644
--- a/Fazeli_Shahroudi-Sepehr-Mastersthesis.tex
+++ b/Fazeli_Shahroudi-Sepehr-Mastersthesis.tex
@@ -19,6 +19,7 @@
\usepackage[T1]{fontenc}
\usepackage{textcomp}
\usepackage{enumitem}
+\usepackage{multirow}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newcommand{\thesistitleDE}{Vergleichende Evaluierung von Bildverarbeitungsbibliotheken für industrielle Anwendungen bei Dassault Systems}
\newcommand{\thesistitleEN}{Comparative Evaluation of Image Processing Libraries for Industrial Applications at Dassault Systems}
@@ -32,9 +33,9 @@
\newcommand{\degree}{Master of Engineering (M.Eng.)}
% \let\oldsection\section
% \renewcommand{\section}{\clearpage\oldsection}
-\let\oldlongtable\longtable
-\let\endoldlongtable\endlongtable
-\renewcommand{\endlongtable}{\endoldlongtable\clearpage}
+% \let\oldlongtable\longtable
+% \let\endoldlongtable\endlongtable
+% \renewcommand{\endlongtable}{\endoldlongtable\clearpage}
% \let\oldsubsection\subsection
% \renewcommand{\subsection}{\clearpage\oldsubsection}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/chapters/4-Results.tex b/chapters/4-Results.tex
index 9027f95055791f9dec0230f95867d5210280aeca..cded2edf3a7077f4e5e854918b192dcd212d9120 100644
--- a/chapters/4-Results.tex
+++ b/chapters/4-Results.tex
@@ -1,86 +1,18 @@
\chapter{Results}
-Below is a draft Results chapter that states the answers to your research question and summarizes the generated data from the investigation. The text includes written paragraphs, tables, and references to graphical representations (provided in the appendix) without additional discussion or interpretation.
-\section{Answer to the Research Question}
+This chapter presents our findings from the benchmarking experiments conducted to evaluate the performance of alternative image processing libraries. The results include quantitative data on image conversion and pixel iteration times, as well as memory consumption for each library or combination tested. The data generated will be used to answer the research question and support the hypotheses formulated in the previous chapters. The benchmarking approach consisted of running two primary tests on each library: an image conversion test that measured the time taken to load, process, and save images, and a pixel iteration test that recorded the time required to process every pixel in an image for a grayscale conversion. These experiments were performed in a controlled environment, with warm-up iterations included to reduce the impact of initial overhead. Memory consumption was tracked alongside processing times using BenchmarkDotNet, thereby offering a complete picture of both speed and resource utilization.\\
-The research question was: \textit{Which alternative to ImageSharp provides the required image processing performance while reducing cost?}
-\textbf{Answer:} The experimental results demonstrate that a combination of Emgu CV for complex image processing tasks (such as pixel manipulation and iteration) and SkiaSharp for image conversion offers the best performance and cost advantages compared to ImageSharp and other alternatives.
+%%[PLACEHOLDER: a media summarizing benchmarking methodology]
-\section{Benchmarking Data Generated}
+Before discussing the results in detail, it is important to review the benchmarking design. In this study, each library was tested under the same conditions: the same input image was used, a fixed number of warm-up iterations were performed to reduce the effects of just-in-time compilation and caching, and finally, 100 main iterations were executed to ensure reliable statistics. For the image conversion test, the time measured was the duration needed to load a JPEG image, convert it to PNG, and save it back to disk. In the pixel iteration test, the focus was on recording the time required to access and change each pixel for producing a grayscale version of the image.
-Two primary performance metrics were measured:
-\begin{itemize}
- \item \textbf{Image Conversion Time:} The time taken to load an image, convert its format (from JPG to PNG), and save the resulting image.
- \item \textbf{Pixel Iteration Time:} The time required to load an image and iterate through every pixel while performing a simple operation (grayscale conversion).
-\end{itemize}
+Memory diagnostics were captured concurrently, with particular attention to allocated memory and garbage collection events. This dual approach ensured that our results were not solely focused on speed but also took into account the resource efficiency of each solution.
-\subsection{Image Conversion Benchmark Results}
-The following table shows the measured image conversion times (in milliseconds) for each evaluated library or combination:
+%%[PLACEHOLDER: a media Diagram of benchmarking process] or reference to it
-\begin{table}[h!]
-\centering
-\begin{tabular}{|l|c|}
-\hline
-\textbf{Library Combination} & \textbf{Image Conversion Time (ms)} \\ \hline
-ImageSharp & 2754 \\ \hline
-OpenCvSharp + SkiaSharp & 539 \\ \hline
-Magick.NET + MagicScaler & 4333 \\ \hline
-Emgu CV + Structure.Sketching & 490 \\ \hline
-\end{tabular}
-\caption{Image Conversion Benchmark Results}
-\end{table}
-
-\subsection{Pixel Iteration Benchmark Results}
-
-The pixel iteration benchmark yielded the following measurements (ms):
-
-\begin{table}[h!]
-\centering
-\begin{tabular}{|l|c|c|c|}
-\hline
-\textbf{Library Combination} & \textbf{Warm-Up Time (ms)} & \textbf{Average Time Excluding Warm-Up (ms)} & \textbf{Total Time Including Warm-Up (ms)} \\ \hline
-ImageSharp & 755 & 117.06 & 12461 \\ \hline
-OpenCvSharp + SkiaSharp & 813 & 159.44 & 16757 \\ \hline
-Magick.NET + MagicScaler & 12149 & 2054.18 & 217567 \\ \hline
-Emgu CV + Structure.Sketching & 1118 & 118.87 & 13005 \\ \hline
-\end{tabular}
-\caption{Benchmarking Data: Warm-Up and Average Times}
-\end{table}
-
-\subsection{Memory Benchmarking Results}
-
-Memory allocation during image conversion and pixel iteration was also measured using BenchmarkDotNet. The key results are summarized as follows:
-
-\begin{itemize}
- \item \textbf{Image Conversion:}
- \begin{itemize}
- \item \textit{ImageSharp:} achieved an average conversion time of 63.97 ms with approximately 58 KB of memory allocated.
- \item \textit{ImageSharp:} required 475.71 ms and allocated approximately 5.67 MB.
- \item \textit{Emgu CV:} used 52.53 ms with minimal memory usage (approximately 0.00068 MB).
- \end{itemize}
- \item \textbf{Pixel Iteration:}
- \begin{itemize}
- \item \textit{Emgu CV:} recorded an average time of 85.49 ms with a higher memory allocation (~170 MB).
- \item \textit{ImageSharp:} took 86.56 ms while consuming about 20 KB.
- \item \textit{SkiaSharp:} showed a conversion time of 2.82 s and allocated approximately 384 MB.
- \end{itemize}
-\end{itemize}
-
-\section{Data Summary and Support for Hypotheses}
-
-The data generated indicate that:
-- For image conversion, Emgu CV combined with Structure.Sketching (or alternatively, OpenCvSharp + SkiaSharp) delivers significantly lower processing times (490–539 ms) compared to ImageSharp (2754 ms) and Magick.NET + MagicScaler (4333 ms).
-- For pixel iteration, Emgu CV + Structure.Sketching achieved an average time of 118.87 ms, which is comparable to ImageSharp’s 117.06 ms and superior to OpenCvSharp + SkiaSharp (159.44 ms) and Magick.NET + MagicScaler (2054.18 ms).
-
-In addition, the memory benchmarks confirm that SkiaSharp excels in low memory allocation for image conversion, while Emgu CV, despite higher memory usage in pixel iteration, provides the fastest performance for complex operations.
-
-\subsection{Data Generated:}
-\begin{itemize}
- \item Numerical timing values (in milliseconds) for both image conversion and pixel iteration tests.
- \item Memory allocation figures (in MB or KB) for the same operations.
- \item The results were also visualized in graphs and detailed tables (see Figures X–Y and Tables 1–3 in the Appendix).
-\end{itemize}
-
-\subsection{Support for Hypotheses:}
-The numerical data fully support the hypothesis that combining Emgu CV (for processing-intensive tasks) with SkiaSharp (for efficient image conversion) offers a superior alternative to ImageSharp in terms of performance and cost. The lower processing times and reduced licensing fees directly answer the research question.
+\input{sections/Chapter-4-sections/Image_conversion_benchmark_results.tex}
+\input{sections/Chapter-4-sections/Pixel_iteration_benchmark_results.tex}
+\input{sections/Chapter-4-sections/Memory_benchmark_results.tex}
+\input{sections/Chapter-4-sections/Analysis_and_Interpretation_of_Results.tex}
+\input{sections/Chapter-4-sections/Summary.tex}
diff --git a/media/log_1.png b/media/log_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..a20192457906a80c72671b727271fbdd019264bd
Binary files /dev/null and b/media/log_1.png differ
diff --git a/media/log_2.png b/media/log_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..13e0227b42a7f1297b686a53151b9cf77a125c31
Binary files /dev/null and b/media/log_2.png differ
diff --git a/sections/Chapter-4-sections/evaluation-of-alternatives-in-go.tex b/outdated/evaluation-of-alternatives-in-go.tex
similarity index 100%
rename from sections/Chapter-4-sections/evaluation-of-alternatives-in-go.tex
rename to outdated/evaluation-of-alternatives-in-go.tex
diff --git a/sections/Chapter-4-sections/evaluation-of-alternatives.tex b/outdated/evaluation-of-alternatives.tex
similarity index 100%
rename from sections/Chapter-4-sections/evaluation-of-alternatives.tex
rename to outdated/evaluation-of-alternatives.tex
diff --git a/sections/Chapter-4-sections/suggestions.tex b/outdated/suggestions.tex
similarity index 100%
rename from sections/Chapter-4-sections/suggestions.tex
rename to outdated/suggestions.tex
diff --git a/sections/Chapter-4-sections/Analysis_and_Interpretation_of_Results.tex b/sections/Chapter-4-sections/Analysis_and_Interpretation_of_Results.tex
new file mode 100644
index 0000000000000000000000000000000000000000..d893d9cf32c6401530449c375c702d461bf8dc57
--- /dev/null
+++ b/sections/Chapter-4-sections/Analysis_and_Interpretation_of_Results.tex
@@ -0,0 +1,47 @@
+\section{Analysis and Interpretation of Results}
+
+As the final benchmarking results were collected and plotted, the emerging trends provided critical insights into the efficiency of various image processing libraries. The raw numerical data from our benchmarking suite provided an answer to the research question, but a deeper interpretation of these results allowed us to refine our understanding of the trade-offs and strengths of each alternative. This section explores the relationship between speed and memory usage, compares the empirical findings with theoretical expectations, and discusses the implications for real-world applications.
+
+\subsection{Comparison of Performance Trends}
+
+The performance hierarchy observed in the benchmarking results closely aligns with expectations based on each library’s internal architecture. Libraries such as OpenCvSharp and Emgu CV, both built upon OpenCV’s optimized C++ backend, showcased superior execution times for image conversion tasks. This efficiency is largely attributed to OpenCV’s reliance on low-level SIMD (Single Instruction, Multiple Data) optimizations and hardware-accelerated processing paths.
+
+Conversely, ImageSharp—despite its clean API and pure C\# implementation—demonstrated significantly higher processing times, reinforcing the general principle that managed code introduces overhead compared to native libraries. While ImageSharp remains a viable option for applications prioritizing ease of use and portability over raw performance, the performance disparity is undeniable.
+
+Magick.NET, though powerful and highly flexible in terms of format support, performed noticeably worse in pixel iteration tasks. This result was somewhat anticipated due to the internal structure of ImageMagick, which prioritizes format conversions and high-quality rendering over raw pixel access speed. The excessive processing times observed in the Magick.NET pixel iteration benchmark further support the hypothesis that it is not optimized for this type of operation.
+
+The trends in memory consumption were particularly revealing. While OpenCvSharp + SkiaSharp exhibited minimal memory allocation, Emgu CV+Structure.Sketching, despite its processing speed, required substantially higher memory overhead. This observation is consistent with Emgu CV’s underlying OpenCV core, which relies on large temporary buffers and matrix structures for intermediate computations. In contrast, ImageSharp demonstrated exceptional memory efficiency during pixel iteration but was significantly slower, suggesting that its architecture prioritizes memory conservation over execution speed.
+
+\subsection{Trade-Offs Between Speed and Memory Usage}
+
+The relationship between speed and memory consumption is a recurring theme in performance optimization. Our results underscore that achieving optimal speed often comes at the cost of increased memory usage. Emgu CV+Structure.Sketching exemplifies this trade-off: while its pixel iteration speed was among the best recorded, it consumed significantly more RAM than ImageSharp.
+
+The implications of these trade-offs depend heavily on the intended application. For environments where processing speed is paramount—such as real-time video processing or AI-powered image enhancement—Emgu CV’s increased memory footprint may be an acceptable compromise. However, in resource-constrained applications (e.g., embedded systems, mobile devices, or cloud-based deployments with strict memory limits), a lower-memory alternative like ImageSharp may be more suitable despite its lower speed.
+
+\setlength{\columnWidth}{0.10\textwidth}
+\begin{longtable}{|>{\raggedright\arraybackslash}p{0.26\textwidth}|>{\raggedright\arraybackslash}p{0.43\textwidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|}
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Task} & \textbf{Speed} & \textbf{Memory Usage} \\
+\hline
+\endfirsthead
+
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Task} & \textbf{Speed} & \textbf{Memory Usage} \\
+\hline
+\endhead
+
+\multirow{2}{*}{\textbf{ImageSharp}} & Image Conversion & Slow & Low \\
+\cline{2-4}
+ & Pixel Iteration & Fast & Low \\
+\hline
+\multirow{2}{*}{\shortstack{\textbf{Emgu CV + SkiaSharp}}} & Image Conversion (SkiaSharp) & Fast & Low \\
+\cline{2-4}
+ & Pixel Iteration (Emgu CV) & Fast & High \\
+\hline
+\caption{Speed vs. Memory Usage Trade-Offs}
+\label{tab:speed-memory-trade-offs}
+\end{longtable}
+
+One particularly interesting finding was that OpenCvSharp+SkiaSharp consistently delivered both high speed and low memory usage for image conversion. This anomaly suggests that this combination strikes an optimal balance, leveraging OpenCV’s native optimizations while maintaining a lightweight footprint in memory. The fact that this hybrid approach outperformed even standalone OpenCV libraries further supports the notion that combining high-performance native libraries with efficient rendering engines can yield superior results.
\ No newline at end of file
diff --git a/sections/Chapter-4-sections/Image_conversion_benchmark_results.tex b/sections/Chapter-4-sections/Image_conversion_benchmark_results.tex
new file mode 100644
index 0000000000000000000000000000000000000000..a8d3df3d0b772f133d6691eece89dbb25e52b6c8
--- /dev/null
+++ b/sections/Chapter-4-sections/Image_conversion_benchmark_results.tex
@@ -0,0 +1,42 @@
+\section{Image Conversion Benchmark Results}
+
+The image conversion benchmark was performed using ImageSharp and Magick.NET as well as SkiaSharp and Structure.Sketching which were the chosen libraries in their combinations with OpenCvSharp and Emgu CV, respectively for the conversion task. Using the same 4k resolution image, the benchmark measured the time taken to convert the image from JPEG to PNG format. Comparing the results of these libraries provides insights into their performance and efficiency in application scenarios where rapid image conversion is required—such as real-time image processing pipelines or high-volume batch processing environments. The data thus answer one of our central question to which library can provide significantly faster image conversion, thereby supporting the hypothesis discussed in earlier chapters.
+
+ImageSharp recorded an average conversion time of approximately 2,754 milliseconds. In contrast, the combination of OpenCvSharp with SkiaSharp delivered an average conversion time of only 539 milliseconds. Similarly, Emgu CV integrated with Structure.Sketching achieved an average time of 490 milliseconds, while Magick.NET paired registered an average conversion time of 4,333 milliseconds.
+
+\newlength{\columnWidth}
+\setlength{\columnWidth}{0.19\textwidth}
+\vspace{0.5cm}
+\begin{longtable}{|>{\raggedright\arraybackslash}p{0.40\textwidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|}
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Warm-Up Time (ms)} & \textbf{Avg. Time Excl. Warm-Up (ms)} & \textbf{Total Time Incl. Warm-Up (ms)} \\
+\hline
+\endfirsthead
+
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Warm-Up Time (ms)} & \textbf{Avg. Time Excl. Warm-Up (ms)} & \textbf{Total Time Incl. Warm-Up (ms)} \\
+\hline
+\endhead
+
+\textbf{ImageSharp} & 2754 & 480.86 & 50840 \\\hline
+\textbf{OpenCvSharp + SkiaSharp} & 539 & 100.31 & 10570 \\\hline
+\textbf{Magick.NET} & 4333 & 845.46 & 88879 \\\hline
+\textbf{Emgu CV + Structure.Sketching} & 490 & 59.43 & 6433 \\\hline
+
+\caption{Image Conversion Benchmark Results}
+\label{tab:image-conversion-results}
+\end{longtable}
+
+The table above, is the final dataset that been constructed by merging multiple Excel files produced by the framework described in the Implementation chapter. These results shows lightweight libraries such as SkiaSharp and Structure.Sketching outperforming ImageSharp and Magick.NET in terms of image conversion time. The data also reveals that Emgu CV with Structure.Sketching is the most efficient combination for image conversion, with the lowest average time of 490 milliseconds. but on the other hand, ImageSharp and Magick.NET are significantly slower, with average times of 2,754 and 4,333 milliseconds, respectively.
+
+
+\includegraphics[width=5in]{media/log_1.png}
+\captionof{figure}{Performance Comparison - Image Conversion (log scale)}
+\label{fig:image-conversion}
+\vspace{0.5cm}
+
+
+To visually encapsulate these findings, The graph illustrate the conversion times across the tested libraries, which clearly shows that the conversion times for OpenCvSharp+SkiaSharp and Emgu CV+Structure.Sketching are clustered at the lower end of the spectrum, while ImageSharp’s results are significantly higher. This visual evidence reinforces the numerical data and provides an immediate, intuitive understanding of the performance differences. And the log scale was used to better represent the data, as the differences between total time which is the sum of warm-up and average time, are significant. This three color graph can aid in comparing the performance of the libraries in different scenarios, such as real-time image processing or batch conversion tasks in one glance.
+
diff --git a/sections/Chapter-4-sections/Memory_benchmark_results.tex b/sections/Chapter-4-sections/Memory_benchmark_results.tex
new file mode 100644
index 0000000000000000000000000000000000000000..55d967a32becc9b05daadd78a9922d284066d016
--- /dev/null
+++ b/sections/Chapter-4-sections/Memory_benchmark_results.tex
@@ -0,0 +1,62 @@
+\section{Memory Benchmarking Results}
+
+In parallel with the time benchmarks, memory consumption was a critical parameter in our evaluation. For the image conversion tasks, SkiaSharp, as part of the OpenCvSharp+SkiaSharp configuration, exhibited the lowest memory allocation, with values approximating 58 KB. ImageSharp, in comparison, required about 5.67 MB, which is substantially higher. In the context of pixel iteration, the memory profiles were similarly divergent. ImageSharp was extremely efficient in this regard, consuming roughly 20 KB on average, whereas Emgu CV + Structure.Sketching, despite its fast processing times, utilized around 170 MB of memory.
+
+\setlength{\columnWidth}{0.22\textwidth}
+\begin{longtable}{|>{\raggedright\arraybackslash}p{0.20\textwidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|}
+
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Allocated Memory} & \textbf{Gen0/Gen1/Gen2 Collections} \\
+\hline
+\endfirsthead
+
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Allocated Memory} & \textbf{Gen0/Gen1/Gen2 Collections} \\
+\hline
+\endhead
+
+\textbf{EmguCV} & 0.00068 MB (712 bytes) & - / - / - \\
+\hline
+\textbf{ImageSharp} & 5.67 MB (5,805.41 KB) & 1,000 / 1,000 / 1,000 \\
+\hline
+\textbf{SkiaSharp} & 0.05612 MB (58,864 bytes) & - / - / - \\
+\hline
+
+\caption{Memory Benchmarking Results for Image Conversion}
+\label{tab:memory-results-image-conversion}
+\end{longtable}
+
+The table above summarizes the memory benchmarking results for image conversion. It is evident that ImageSharp has the highest memory allocation, with approximately 5.67 MB, while SkiaSharp has the lowest, with only 58 KB. Emgu CV falls in between, with a memory allocation of 0.00068 MB. These figures provide a clear indication of the memory efficiency of each library for image conversion tasks.\\
+
+The large memory footprint of Emgu CV during pixel iteration is a noteworthy trade-off. While its performance in terms of speed is excellent, the high memory consumption must be considered when deploying the solution in memory-constrained environments. The benchmarking data collected here is critical because it provides a balanced view—speed alone does not define an optimal library, but rather the ratio of processing time to memory usage does. For a clear summary of these findings, the below table provides a concise overview of the memory metrics for each library configuration.
+
+
+\begin{longtable}{|>{\raggedright\arraybackslash}p{0.20\textwidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|}
+
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Allocated Memory} & \textbf{Gen0/Gen1/Gen2 Collections} \\
+\hline
+\endfirsthead
+
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Allocated Memory} & \textbf{Gen0/Gen1/Gen2 Collections} \\
+\hline
+\endhead
+
+\textbf{EmguCV} & 170.00 MB (177,976,185 bytes) & 33,142 / 1,571 / 1,571 \\
+\hline
+\textbf{ImageSharp} & 0.01932 MB (20.26 KB) & - / - / - \\
+\hline
+\textbf{SkiaSharp} & 384.00 MB (403,300,552 bytes) & 85 / - / - \\
+\hline
+
+\caption{Memory Benchmarking Results for Pixel Iteration}
+\label{tab:memory-results-pixel-iteration}
+\end{longtable}
+
+
+The table indicates that while Emgu CV+Structure.Sketching is extremely fast for pixel iteration, its memory consumption is substantially higher compared to ImageSharp and the OpenCvSharp+SkiaSharp combination. Emgu CV has the highest memory allocation, with approximately 170 MB, while ImageSharp has the lowest, with only 20 KB. SkiaSharp falls in between, with a memory allocation of 384 MB. These figures provide a clear indication of the memory efficiency of each library for pixel iteration tasks. Such data are instrumental in shaping our final recommendation.
diff --git a/sections/Chapter-4-sections/Pixel_iteration_benchmark_results.tex b/sections/Chapter-4-sections/Pixel_iteration_benchmark_results.tex
new file mode 100644
index 0000000000000000000000000000000000000000..f5ca0c68b9a63a8de55a76d3a5a04582b8b70ad2
--- /dev/null
+++ b/sections/Chapter-4-sections/Pixel_iteration_benchmark_results.tex
@@ -0,0 +1,39 @@
+\section{Pixel Iteration Benchmark Results}
+
+On the other hand, the pixel iteration benchmark aimed to assess the libraries’ abilities to process each pixel of an image. For ImageSharp, the warm-up phase for pixel iteration took an average of 755 milliseconds, with the main iteration averaging 117.06 milliseconds per cycle and a cumulative total of 12,461 milliseconds over 100 iterations. The performance landscape changed when we observed the results for Magick.NET. This configuration recorded a warm-up time of approximately 12,149 milliseconds, and the main iterations averaged 2,054.18 milliseconds, resulting in an astronomical total of 217,567 milliseconds.
+
+As discussed earlier, OpenCvSharp and Emgu CV were the chosen libraries in their combinations with SkiaSharp and Structure.Sketching, respectively for the pixel iteration task. The results of these tests provide insights into the performance of these libraries in scenarios where pixel-level operations are required, such as image processing algorithms or computer vision applications. The performance landscape changed when we observed the results for OpenCvSharp. This configuration recorded a warm-up time of approximately 813 milliseconds, and the main iterations averaged 159.44 milliseconds, resulting in a total of 16,757 milliseconds. In contrast, Emgu CV delivered impressive results with a warm-up time of 1,118 milliseconds and an average main iteration time of 118.87 milliseconds, culminating in a total of 13,005 milliseconds.
+
+
+\begin{longtable}{|>{\raggedright\arraybackslash}p{0.40\textwidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|}
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Warm-Up Time (ms)} & \textbf{Avg. Time Excl. Warm-Up (ms)} & \textbf{Total Time Incl. Warm-Up (ms)} \\
+\hline
+\endfirsthead
+
+\hline
+\rowcolor{purple!30}
+\textbf{Library} & \textbf{Warm-Up Time (ms)} & \textbf{Avg. Time Excl. Warm-Up (ms)} & \textbf{Total Time Incl. Warm-Up (ms)} \\
+\hline
+\endhead
+
+\textbf{ImageSharp} & 755 & 117.06 & 12461 \\\hline
+\textbf{OpenCvSharp + SkiaSharp} & 813 & 159.44 & 16757 \\\hline
+\textbf{Magick.NET} & 12149 & 2054.18 & 217567 \\\hline
+\textbf{Emgu CV + Structure.Sketching} & 1118 & 118.87 & 13005 \\\hline
+
+\caption{Pixel Iteration Benchmark Results}
+\end{longtable}
+
+The table above summarizes the pixel iteration benchmark results, highlighting the warm-up and average times for each library combination. The data clearly show that Emgu CV is the most efficient library for pixel iteration, with the lowest average time of 118.87 milliseconds. ImageSharp and OpenCvSharp follow closely behind, with average times of 117.06 and 159.44 milliseconds, respectively. In contrast, Magick.NET is significantly slower, with an average time of 2,054.18 milliseconds.
+
+Graphical depictions further highlight these performance differences.
+
+\includegraphics[width=5in]{media/log_2.png}
+\captionof{figure}{Pixel Iteration Benchmark Results}
+\label{fig:pixel-iteration}
+
+The disparity between these figures is telling. While Magick.NET excels in some aspects of image conversion, it appears less suited for tasks involving pixel-by-pixel iteration, given the significantly higher processing times. On the other hand, Emgu CV and ImageSharp produce comparable main iteration times; however, when considering the overall picture, the lower cumulative times of Emgu CV make it a more appealing choice for pixel-level operations.
+
+The visual comparisons elucidate that while ImageSharp and Emgu CV+Structure.Sketching are closely matched in main iteration performance, the excessive warm-up and overall times associated with Magick.NET underscore its limitations for this specific task.
diff --git a/sections/Chapter-4-sections/Summary.tex b/sections/Chapter-4-sections/Summary.tex
new file mode 100644
index 0000000000000000000000000000000000000000..80e818b10c9507ceadd34526a5b227b5a6f94187
--- /dev/null
+++ b/sections/Chapter-4-sections/Summary.tex
@@ -0,0 +1,3 @@
+\section{Summary}
+
+The benchmarking results provide a comprehensive overview of the performance and efficiency of the image processing libraries tested. The data clearly show that Emgu CV + Structure.Sketching is the most efficient combination for image conversion, with the lowest average time of 490 milliseconds. In contrast, ImageSharp and Magick.NET are significantly slower, with average times of 2,754 and 4,333 milliseconds, respectively. For pixel iteration, Emgu CV+Structure.Sketching is again the most efficient, with the lowest average time of 118.87 milliseconds. ImageSharp and OpenCvSharp+SkiaSharp follow closely behind, with average times of 117.06 and 159.44 milliseconds, respectively. In contrast, Magick.NET is significantly slower, with an average time of 2,054.18 milliseconds. The memory benchmarking results further highlight the efficiency of ImageSharp and SkiaSharp in terms of memory consumption, with Emgu CV exhibiting higher memory usage. These findings provide valuable insights into the performance characteristics of each library and will inform our final recommendations for image processing tasks.
\ No newline at end of file