diff --git a/Fazeli_Shahroudi-Sepehr-Mastersthesis.tex b/Fazeli_Shahroudi-Sepehr-Mastersthesis.tex
index a2f84ba185ee5e6e3b6d06e2e3bb5e2b4bd53862..81be48e84aa1ea5a5f5a76df0aacca9282f414b9 100644
--- a/Fazeli_Shahroudi-Sepehr-Mastersthesis.tex
+++ b/Fazeli_Shahroudi-Sepehr-Mastersthesis.tex
@@ -20,6 +20,7 @@
 \usepackage{textcomp}
 \usepackage{enumitem}
 \usepackage{multirow}
+\usepackage{cellspace}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \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}
diff --git a/media/log_1.png b/media/log_1.png
index 2a8d041c24a4d8d896d3f55215f7023cc6d3a283..087bd570b8a69ade29327455f4bb1da1743474a9 100644
Binary files a/media/log_1.png and b/media/log_1.png differ
diff --git a/media/log_2.png b/media/log_2.png
index 69cb6070dfc76c3f43d59a6eb29a1cb7704aeeb8..339f01b095d068365aa58473730ec85821d0ec99 100644
Binary files a/media/log_2.png and b/media/log_2.png differ
diff --git a/sections/Chapter-4-sections/Analysis_and_Interpretation_of_Results.tex b/sections/Chapter-4-sections/Analysis_and_Interpretation_of_Results.tex
index d893d9cf32c6401530449c375c702d461bf8dc57..b97725bafb0f94474005efa8d5f9206a1ff9ab24 100644
--- a/sections/Chapter-4-sections/Analysis_and_Interpretation_of_Results.tex
+++ b/sections/Chapter-4-sections/Analysis_and_Interpretation_of_Results.tex
@@ -4,13 +4,13 @@ As the final benchmarking results were collected and plotted, the emerging trend
 
 \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.
+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 pixel iteration 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.
+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. In memory-constrained environments, the trade-off between speed and memory usage should be carefully considered as ImageSharp’s memory efficiency may outweigh its slower execution times. ImageSharp remains a viable option for applications prioritizing ease of use and portability over raw performance or in scenarios where memory conservation is critical.
 
-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.
+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. However, its range of features and extensive format support make it a compelling choice for applications requiring advanced image processing capabilities.
 
-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.
+The trends in memory consumption were particularly revealing. In the image conversion test, SkiaSharp exhibited the lowest memory usage, also demonstrating competitive processing times. This result is consistent with SkiaSharp’s reputation for being lightweight and efficient, making it an excellent choice for applications need high performance and low memory overhead. In the pixel iteration test, Emgu CV memory usage was significantly higher than ImageSharp, highlighting the trade-off between speed and memory efficiency. This finding underscores the importance of selecting the right library based on the specific requirements of the application. 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}
 
@@ -18,8 +18,9 @@ The relationship between speed and memory consumption is a recurring theme in pe
 
 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.
 
+\renewcommand{\arraystretch}{1.5}
 \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}|}
+\begin{longtable}{|>{\raggedright\arraybackslash}p{0.26\textwidth}|>{\raggedright\arraybackslash}p{0.23\textwidth}|>{\raggedright\arraybackslash}p{\columnWidth}|>{\raggedright\arraybackslash}p{\columnWidth}|}
 \hline
 \rowcolor{purple!30}
 \textbf{Library} & \textbf{Task} & \textbf{Speed} & \textbf{Memory Usage} \\
@@ -36,12 +37,14 @@ The implications of these trade-offs depend heavily on the intended application.
 \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 \\
+\textbf{Emgu CV} & Pixel Iteration & Fast & High \\
+\hline
+\textbf{SkiaSharp} & Image Conversion & Fast & Low \\
 \hline
-\caption{Speed vs. Memory Usage Trade-Offs}
+
+\caption{Table of Speed and Memory Trade-Offs for Image Processing Libraries, the fast/slow and high/low are relative to the other libraries.}
 \label{tab:speed-memory-trade-offs}
 \end{longtable}
+\renewcommand{\arraystretch}{1.0}
 
 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
index a8d3df3d0b772f133d6691eece89dbb25e52b6c8..d30092ce97ced2473496abc53c942063796cd377 100644
--- a/sections/Chapter-4-sections/Image_conversion_benchmark_results.tex
+++ b/sections/Chapter-4-sections/Image_conversion_benchmark_results.tex
@@ -2,12 +2,13 @@
 
 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.
+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 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}|}
+\renewcommand{\arraystretch}{2}
+\begin{longtable}{|>{\raggedright\arraybackslash}p{0.25\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)} \\
@@ -25,18 +26,19 @@ ImageSharp recorded an average conversion time of approximately 2,754 millisecon
 \textbf{Magick.NET} & 4333 & 845.46 & 88879 \\\hline
 \textbf{Emgu CV + Structure.Sketching} & 490 & 59.43 & 6433 \\\hline
 
-\caption{Image Conversion Benchmark Results}
+\caption{The Image Conversion Benchmark Results in milliseconds, showing the warm-up time, average time excluding warm-up, and total time including warm-up for each library or combination.}
 \label{tab:image-conversion-results}
 \end{longtable}
+\renewcommand{\arraystretch}{1.0}
 
-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}
-
+The table \ref{tab:image-conversion-results}, 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. On the other hand, ImageSharp and Magick.NET are significantly slower, with average times of 2,754 and 4,333 milliseconds, respectively.
 
-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.
+To visually summarize these findings, Figure \ref{fig:image-conversion} presents a bar chart that depicts the conversion times across the evaluated libraries. The graph clearly demonstrates that the conversion times for the OpenCvSharp+SkiaSharp and Emgu CV+Structure.Sketching combinations are positioned at the lower end of the performance spectrum, while ImageSharp exhibits considerably higher times. A logarithmic scale has been employed to effectively represent the significant differences in total times—comprising both the warm-up periods and the average conversion times. This three-color graphical representation enables a thorough comparison of library performance in various contexts, such as real-time image processing and batch conversion tasks, thereby reinforcing the quantitative analysis presented earlier.
 
+\begin{center}
+    \includegraphics[width=5in]{media/log_1.png}
+    \captionof{figure}{Bar chart showing the Image Conversion Benchmark Results in milliseconds, with a logarithmic scale to highlight the differences in total times. x-axis represents the libraries or combinations, while y-axis shows the time in milliseconds.}
+    \label{fig:image-conversion}
+    \vspace{0.5cm}
+\end{center}
+\vspace{-3em}
diff --git a/sections/Chapter-4-sections/Memory_benchmark_results.tex b/sections/Chapter-4-sections/Memory_benchmark_results.tex
index 55d967a32becc9b05daadd78a9922d284066d016..1b62ea6c75d560d0cb668d5ec5a5066e6872a490 100644
--- a/sections/Chapter-4-sections/Memory_benchmark_results.tex
+++ b/sections/Chapter-4-sections/Memory_benchmark_results.tex
@@ -1,6 +1,6 @@
 \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.
+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, that performed exceptionally well in terms of speed for pixel iteration, in memory terms, was less efficient. It consumed around 170 MB of memory, which is significantly higher than the other libraries tested. SkiaSharp,
 
 \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}|}
@@ -24,13 +24,13 @@ In parallel with the time benchmarks, memory consumption was a critical paramete
 \textbf{SkiaSharp} & 0.05612 MB (58,864 bytes) & - / - / - \\
 \hline
 
-\caption{Memory Benchmarking Results for Image Conversion}
+\caption{Memory benchmarking results for the image conversion task, detailing the allocated memory (in MB) along with the associated Gen0, Gen1, and Gen2 garbage collection counts.}
 \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 table \ref{tab:memory-results-image-conversion} 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. 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. Garbage collection counts are also included to provide additional context on the memory management behavior of each library. Gen0, Gen1, and Gen2 collections means the number of times each generation was collected during the benchmarking process. These metrics are essential for understanding how each library manages memory and how it impacts performance.
 
-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.
+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, table \ref{tab:memory-results-pixel-iteration} 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}|}
@@ -54,9 +54,8 @@ The large memory footprint of Emgu CV during pixel iteration is a noteworthy tra
 \textbf{SkiaSharp} & 384.00 MB (403,300,552 bytes) & 85 / - / - \\
 \hline
 
-\caption{Memory Benchmarking Results for Pixel Iteration}
+\caption{Memory Benchmarking Results for Pixel Iteration Task, detailing the allocated memory (in MB) along with the associated Gen0, Gen1, and Gen2 garbage collection counts.}
 \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.
+The table \ref{tab:memory-results-pixel-iteration} indicates that while SkiaSharp has the highest memory allocation for pixel iteration of approximately 384 MB, ImageSharp is the most memory-efficient, with a memory allocation of 0.01932 MB. Emgu CV falls in between, with a memory allocation of 170 MB. These figures provide a clear indication of the memory efficiency of each library for pixel iteration tasks. Garbage collection counts are also included to provide additional context on the memory management behavior of each library. Gen0, Gen1, and Gen2 collections means the number of times each generation was collected during the benchmarking process. this means that the garbage collector had to run 33,142 times for Gen0, 1,571 times for Gen1, and 1,571 times for Gen2. 
\ No newline at end of file
diff --git a/sections/Chapter-4-sections/Pixel_iteration_benchmark_results.tex b/sections/Chapter-4-sections/Pixel_iteration_benchmark_results.tex
index f5ca0c68b9a63a8de55a76d3a5a04582b8b70ad2..023b869f258d423e858668c5c499b03de9409c83 100644
--- a/sections/Chapter-4-sections/Pixel_iteration_benchmark_results.tex
+++ b/sections/Chapter-4-sections/Pixel_iteration_benchmark_results.tex
@@ -1,11 +1,9 @@
 \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. 
+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. 
 
-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}|}
+\renewcommand{\arraystretch}{2}
+\begin{longtable}{|>{\raggedright\arraybackslash}p{0.25\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)} \\
@@ -23,17 +21,20 @@ As discussed earlier, OpenCvSharp and Emgu CV were the chosen libraries in their
 \textbf{Magick.NET} & 12149 & 2054.18 & 217567 \\\hline
 \textbf{Emgu CV + Structure.Sketching} & 1118 & 118.87 & 13005 \\\hline
 
-\caption{Pixel Iteration Benchmark Results}
+\caption{Pixel Iteration Benchmark Results in milliseconds, showing the warm-up time, average time excluding warm-up, and total time including warm-up for each library or combination.}
+\label{tab:pixel-iteration}
 \end{longtable}
+\renewcommand{\arraystretch}{1.0}
 
-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.
+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.
 
-Graphical depictions further highlight these performance differences. 
+The table \ref{tab:pixel-iteration} 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 \ref{fig:pixel-iteration} depictions further highlight these performance differences. 
 
 \includegraphics[width=5in]{media/log_2.png}
-\captionof{figure}{Pixel Iteration Benchmark Results}
+\captionof{figure}{Bar chart showing the Pixel Iteration Benchmark Results in milliseconds, with a logarithmic scale to highlight the differences in total times. x-axis represents the libraries or combinations, while y-axis shows the time in milliseconds.}
 \label{fig:pixel-iteration}
+\vspace{1em}
 
-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 disparity between these figures \ref{fig:pixel-iteration} 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
index 80e818b10c9507ceadd34526a5b227b5a6f94187..dacda5a30438ece033737062e3522544f437cbfc 100644
--- a/sections/Chapter-4-sections/Summary.tex
+++ b/sections/Chapter-4-sections/Summary.tex
@@ -1,3 +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
+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. Developers can use these findings to select the most suitable library for their particular needs based on their specific requirements and constraints regarding speed and resource utilization. 
\ No newline at end of file