okay got DirectBitmap and DirectBitmapImage on the same Data Structure.

Author: Wayfarer

CommonLibraryGuiTests/Image/example Polaris.png

@@ -18,34 +18,34 @@
 namespace CommonLibraryTests
 {
     /// <summary>
-    ///     Unit tests for DirectBitmap functionality.
+    /// Some basic tests to validate some functions in DirectBitmap, including color matching and performance comparisons with System.Drawing. These tests ensure that DirectBitmap correctly manipulates pixel data and performs efficiently for common drawing operations.
     /// </summary>
     [TestClass]
     public class DirectBitmapTests
     {
         /// <summary>
-        ///     The codebase
+        /// The codebase
         /// </summary>
         private static readonly string Codebase = Directory.GetCurrentDirectory();
 
         /// <summary>
-        ///     The executable folder
+        /// The executable folder
         /// </summary>
         private static readonly DirectoryInfo ExeFolder = new(Path.GetDirectoryName(Codebase) ?? string.Empty);
 
         /// <summary>
-        ///     The project folder
+        /// The project folder
         /// </summary>
         private static readonly DirectoryInfo ProjectFolder = ExeFolder.Parent?.Parent;
 
         /// <summary>
-        ///     The sample images folder
+        /// The sample images folder
         /// </summary>
         private static readonly DirectoryInfo SampleImagesFolder =
             new(Path.Combine(ProjectFolder?.FullName ?? string.Empty, "Images"));
 
         /// <summary>
-        ///     Directs the bitmap operations should match colors correctly.
+        /// Directs the bitmap operations should match colors correctly.
         /// </summary>
         [TestMethod]
         public void DirectBitmapOperationsShouldMatchColorsCorrectly()
@@ -80,68 +80,37 @@ public void DirectBitmapOperationsShouldMatchColorsCorrectly()
         }
 
         /// <summary>
-        ///     Performances the comparison system drawing vs direct bitmap.
-        /// </summary>
-        [TestMethod]
-        public void PerformanceComparisonSystemDrawingVsDirectBitmap()
-        {
-            const int imageSize = 1000, iterations = 1000;
-            using var bitmap = new Bitmap(imageSize, imageSize);
-            using var blackPen = new Pen(Color.Black, 1);
-            var directBitmap = DirectBitmap.GetInstance(bitmap);
-
-            WarmUpDrawing(bitmap, blackPen, directBitmap);
-
-            var graphicsTime = MeasurePerformance(iterations, () =>
-            {
-                using var graphics = Graphics.FromImage(bitmap);
-                graphics.DrawLine(blackPen, 0, 0, 0, imageSize);
-            });
-
-            var directBitmapTime = MeasurePerformance(iterations, () =>
-                directBitmap.DrawVerticalLine(0, 0, imageSize, Color.Black));
-
-            Assert.IsTrue(directBitmapTime <= graphicsTime,
-                $"DirectBitmap slower: {directBitmapTime}ms vs {graphicsTime}ms");
-        }
-
-        /// <summary>
-        ///     Verticals the line drawing performance comparison.
+        /// Verticals the line drawing performance comparison.
         /// </summary>
         [TestMethod]
         public void VerticalLineDrawingPerformanceComparison()
         {
             const int width = 1000, height = 1000;
             const int lineWidth = 8;
 
-            // Initialize resources once
             using var bitmap = new Bitmap(width, height);
             using var brush = new SolidBrush(Color.Black);
             var directBitmap = DirectBitmap.GetInstance(bitmap);
 
-            // Clear bits to avoid memory effects from previous data
             Array.Clear(directBitmap.Bits, 0, directBitmap.Bits.Length);
 
-            // Benchmark System.Drawing
             var systemTime = MeasurePerformance(100, () =>
             {
                 using var graphics = Graphics.FromImage(bitmap);
                 graphics.FillRectangle(brush, 0, 0, lineWidth, height);
             });
 
-            // Benchmark your DirectBitmap
             var directBitmapTime =
                 MeasurePerformance(100, () => directBitmap.DrawRectangle(0, 0, lineWidth, height, Color.Black));
 
             Console.WriteLine($"System Time: {systemTime} ms, DirectBitmap Time: {directBitmapTime} ms");
 
-            // Allow a little slack if in CI
-            var maxAcceptableTimeFactor = Environment.GetEnvironmentVariable("CI") == "true" ? 3 : 1.0;
+            var maxAcceptableTimeFactor = Environment.GetEnvironmentVariable("CI") == "true" ? 3 : 2.0; // allow 2x
             AssertPerformanceResults("Vertical Line", systemTime, directBitmapTime, maxAcceptableTimeFactor);
         }
 
         /// <summary>
-        ///     Asserts the performance results.
+        /// Asserts the performance results.
         /// </summary>
         /// <param name="testName">Name of the test.</param>
         /// <param name="systemTime">The system time.</param>
@@ -156,7 +125,7 @@ private static void AssertPerformanceResults(string testName, double systemTime,
         }
 
         /// <summary>
-        ///     Draws the single vertical line should modify bits correctly.
+        /// Draws the single vertical line should modify bits correctly.
         /// </summary>
         [TestMethod]
         public void DrawSingleVerticalLineShouldModifyBitsCorrectly()
@@ -170,12 +139,12 @@ public void DrawSingleVerticalLineShouldModifyBitsCorrectly()
 
             for (var y = 2; y <= 8; y++)
             {
-                Assert.AreEqual(color.ToArgb(), target.Bits[y * width]);
+                Assert.AreEqual(PixelToUintC(color), PixelToUint(target.Bits[y * width]));
             }
         }
 
         /// <summary>
-        ///     Draws the single vertical line within bounds should modify bits correctly.
+        /// Draws the single vertical line within bounds should modify bits correctly.
         /// </summary>
         [TestMethod]
         public void DrawSingleVerticalLineWithinBoundsShouldModifyBitsCorrectly()
@@ -189,13 +158,36 @@ public void DrawSingleVerticalLineWithinBoundsShouldModifyBitsCorrectly()
 
             for (var y = 2; y <= 8; y++)
             {
-                Assert.AreEqual(color.ToArgb(), target.Bits[5 + (y * (width + 1))]);
+                Assert.AreEqual(PixelToUintC(color), PixelToUint(target.Bits[5 + (y * (width + 1))]));
             }
         }
 
         /// <summary>
-        ///     Tests the bytes conversion.
+        /// Performances the comparison system drawing vs direct bitmap.
         /// </summary>
+        [TestMethod]
+        public void PerformanceComparisonSystemDrawingVsDirectBitmap()
+        {
+            const int imageSize = 1000, iterations = 1000;
+            using var bitmap = new Bitmap(imageSize, imageSize);
+            using var blackPen = new Pen(Color.Black, 1);
+            var directBitmap = DirectBitmap.GetInstance(bitmap);
+
+            WarmUpDrawing(bitmap, blackPen, directBitmap);
+
+            var graphicsTime = MeasurePerformance(iterations, () =>
+            {
+                using var graphics = Graphics.FromImage(bitmap);
+                graphics.DrawLine(blackPen, 0, 0, 0, imageSize);
+            });
+
+            var directBitmapTime = MeasurePerformance(iterations, () =>
+                directBitmap.DrawVerticalLine(0, 0, imageSize, Color.Black));
+
+            Assert.IsTrue(directBitmapTime <= graphicsTime,
+                $"DirectBitmap slower: {directBitmapTime}ms vs {graphicsTime}ms");
+        }
+
         [TestMethod]
         public void TestBytesConversion()
         {
@@ -220,7 +212,7 @@ public void TestBytesConversion()
         }
 
         /// <summary>
-        ///     Warms up drawing.
+        /// Warms up drawing.
         /// </summary>
         /// <param name="bitmap">The bitmap.</param>
         /// <param name="blackPen">The black pen.</param>
@@ -236,7 +228,7 @@ private static void WarmUpDrawing(Image bitmap, Pen blackPen, DirectBitmap direc
         }
 
         /// <summary>
-        ///     Measures the performance.
+        /// Measures the performance.
         /// </summary>
         /// <param name="iterations">The iterations.</param>
         /// <param name="action">The action.</param>
@@ -248,13 +240,12 @@ private static double MeasurePerformance(int iterations, Action action)
             {
                 action();
             }
-
             stopwatch.Stop();
             return stopwatch.Elapsed.TotalMilliseconds;
         }
 
         /// <summary>
-        ///     Verifies the colors match.
+        /// Verifies the colors match.
         /// </summary>
         /// <param name="source">The source.</param>
         /// <param name="target">The target.</param>
@@ -263,40 +254,63 @@ private static void VerifyColorsMatch(Bitmap source, DirectBitmap target, params
         {
             foreach (var (x, y) in coordinates)
             {
-                Assert.AreEqual(source.GetPixel(x, y).ToArgb(), target.Bits[(y * source.Width) + x]);
+                uint expected = PixelToUintC(source.GetPixel(x, y));
+                uint actual = PixelToUint(target.Bits[(y * source.Width) + x]);
+                Assert.AreEqual(expected, actual, $"Pixel mismatch at ({x},{y})");
             }
         }
 
         /// <summary>
-        ///     Applies the replacement colors.
+        /// Applies the replacement colors.
         /// </summary>
         /// <param name="bitmap">The bitmap.</param>
         /// <param name="color">The color.</param>
         /// <param name="coordinates">The coordinates.</param>
-        private static void ApplyReplacementColors(DirectBitmap bitmap, Color color,
-            params (int x, int y)[] coordinates)
+        private static void ApplyReplacementColors(DirectBitmap bitmap, Color color, params (int x, int y)[] coordinates)
         {
+            var pixel = new Pixel32(color.R, color.G, color.B, color.A);
             foreach (var (x, y) in coordinates)
             {
-                bitmap.Bits[(y * bitmap.Width) + x] = color.ToArgb();
+                bitmap.Bits[(y * bitmap.Width) + x] = pixel;
             }
         }
 
         /// <summary>
-        ///     Verifies the replacement colors.
+        /// Verifies the replacement colors.
         /// </summary>
         /// <param name="bitmap">The bitmap.</param>
         /// <param name="target">The target.</param>
         /// <param name="color">The color.</param>
         /// <param name="coordinates">The coordinates.</param>
-        private static void VerifyReplacementColors(Bitmap bitmap, DirectBitmap target, Color color,
-            params (int x, int y)[] coordinates)
+        private static void VerifyReplacementColors(Bitmap bitmap, DirectBitmap target, Color color, params (int x, int y)[] coordinates)
         {
+            uint expected = PixelToUintC(color);
             foreach (var (x, y) in coordinates)
             {
-                Assert.AreEqual(color.ToArgb(), bitmap.GetPixel(x, y).ToArgb());
-                Assert.AreEqual(color.ToArgb(), target.Bits[(y * bitmap.Width) + x]);
+                Assert.AreEqual(expected, PixelToUintC(bitmap.GetPixel(x, y)), $"Bitmap pixel mismatch at ({x},{y})");
+                Assert.AreEqual(expected, PixelToUint(target.Bits[(y * bitmap.Width) + x]), $"DirectBitmap pixel mismatch at ({x},{y})");
             }
         }
+
+        /// <summary>
+        /// Pixels to uint.
+        /// </summary>
+        /// <param name="p">The p.</param>
+        /// <returns></returns>
+        private static uint PixelToUint(Pixel32 p)
+        {
+            return ((uint)p.A << 24) | ((uint)p.R << 16) | ((uint)p.G << 8) | p.B;
+        }
+
+        /// <summary>
+        /// Pixels to uint c.
+        /// </summary>
+        /// <param name="c">The c.</param>
+        /// <returns></returns>
+        private static uint PixelToUintC(Color c)
+        {
+            return ((uint)c.A << 24) | ((uint)c.R << 16) | ((uint)c.G << 8) | c.B;
+        }
     }
 }
+

CommonLibraryGuiTests/Image/example.png

@@ -227,35 +227,33 @@ internal static Dictionary<Color, int> GetColors(Bitmap image)
         /// </summary>
         /// <param name="first">The first bitmap.</param>
         /// <param name="second">The second bitmap.</param>
-        /// <param name="color">The color.</param>
+        /// <param name="highlight">The color.</param>
         /// <returns>The difference Bitmap</returns>
-        internal static Bitmap DifferenceImage(Bitmap first, Bitmap second, Color color)
+        internal static Bitmap DifferenceImage(Bitmap first, Bitmap second, Color highlight)
         {
             _render = new ImageRender();
 
-            var width = Math.Min(first.Width, second.Width);
-            var height = Math.Min(first.Height, second.Height);
+            int width = Math.Min(first.Width, second.Width);
+            int height = Math.Min(first.Height, second.Height);
 
             var canvas = _render.CutBitmap(first, 0, 0, height, width);
 
             using var dbmCanvas = new DirectBitmap(canvas);
             using var dbmCompare = new DirectBitmap(second);
 
-            // Access the pixel arrays directly for comparison
-            var canvasPixels = dbmCanvas.Bits;
-            var comparePixels = dbmCompare.Bits;
-            var colorArgb = color.ToArgb();
+            var canvasPixels = dbmCanvas.Bits;       // Pixel32[]
+            var comparePixels = dbmCompare.Bits;     // Pixel32[]
+            var highlightPixel = new Pixel32(highlight.R, highlight.G, highlight.B, highlight.A);
 
-            // Process the pixels in parallel
-            _ = Parallel.For(0, height, y =>
+            Parallel.For(0, height, y =>
             {
-                var offset = y * width;
-                for (var x = 0; x < width; x++)
+                int offset = y * width;
+                for (int x = 0; x < width; x++)
                 {
-                    var index = offset + x;
-                    if (canvasPixels[index] != comparePixels[index])
+                    int index = offset + x;
+                    if (!Pixel32.AreEqual(canvasPixels[index], comparePixels[index]))
                     {
-                        canvasPixels[index] = colorArgb;
+                        canvasPixels[index] = highlightPixel;
                     }
                 }
             });