sync back some improvements.

Author: LoneWandererProductions

Imaging/ImageExtension.cs

@@ -22,16 +22,17 @@ namespace Imaging;
 public static class ImageExtension
 {
     /// <summary>
-    ///     Extension Method
-    ///     Converts Bitmap to BitmapImage.
+    /// Extension Method
+    /// Converts Bitmap to BitmapImage.
     /// </summary>
     /// <param name="bmp">The Bitmap.</param>
+    /// <param name="lossless">if set to <c>true</c> [lossless].</param>
     /// <returns>
-    ///     A BitmapImage
+    /// A BitmapImage
     /// </returns>
-    public static BitmapImage ToBitmapImage(this Bitmap bmp)
+    public static BitmapImage ToBitmapImage(this Bitmap bmp, bool lossless = false)
     {
-        return ImageStreamMedia.BitmapToBitmapImage(bmp);
+        return ImageStreamMedia.BitmapToBitmapImage(bmp, lossless);
     }
 
     /// <summary>
@@ -89,4 +90,4 @@ public static float[] ConvertColorToOpenGlFormat(this Color color)
             color.A / 255.0f // Alpha
         };
     }
-}
+}

Imaging/ImageRender.cs

@@ -358,16 +358,17 @@ public BitmapImage GetBitmapImageFileStream(string path, int width, int height)
 
     /// <inheritdoc />
     /// <summary>
-    ///     Converts to bitmap image.
+    /// Bitmaps to bitmap image.
     /// </summary>
-    /// <param name="image">The bitmap.</param>
-    /// The Image as
-    /// <see cref="BitmapImage" />
-    /// .
+    /// <param name="image">The image.</param>
+    /// <param name="lossless">if set to <c>true</c> [lossless].</param>
+    /// <returns>
+    /// The Image as <see cref="BitmapImage" />.
+    /// </returns>
     /// <exception cref="ArgumentNullException"></exception>
-    public BitmapImage BitmapToBitmapImage(Bitmap image)
+    public BitmapImage BitmapToBitmapImage(Bitmap image, bool lossless = false)
     {
-        return ImageStreamMedia.BitmapToBitmapImage(image);
+        return ImageStreamMedia.BitmapToBitmapImage(image, lossless);
     }
 
     /// <inheritdoc />
@@ -850,4 +851,4 @@ public string BitmapImageToBase64(BitmapImage bitmapImage)
     {
         return Helpers.ImageConverter.BitmapImageToBase64(bitmapImage);
     }
-}
+}

Imaging/ImageStreamMedia.cs

@@ -7,18 +7,20 @@
  * SOURCE:      https://lodev.org/cgtutor/floodfill.html
  */
 
+using Imaging.Helpers;
 using System;
 using System.Diagnostics;
 using System.Drawing;
 using System.Drawing.Imaging;
 using System.IO;
+using System.Windows;
+using System.Windows.Media;
 using System.Windows.Media.Imaging;
-using Imaging.Helpers;
 
 namespace Imaging;
 
 /// <summary>
-///     Handle the more newer wpf Libraries
+/// Handle the more newer wpf Libraries
 /// </summary>
 public static class ImageStreamMedia
 {
@@ -140,52 +142,122 @@ internal static Bitmap BitmapImageToBitmap(BitmapImage image)
     }
 
     /// <summary>
-    ///     Converts to bitmap image.
-    ///     https://stackoverflow.com/questions/5199205/how-do-i-rotate-image-then-move-to-the-top-left-0-0-without-cutting-off-the-imag/5200280#5200280
+    /// Converts to bitmap image.
+    /// https://stackoverflow.com/questions/5199205/how-do-i-rotate-image-then-move-to-the-top-left-0-0-without-cutting-off-the-imag/5200280#5200280
     /// </summary>
     /// <param name="image">The bitmap.</param>
+    /// <param name="lossless">if set to <c>true</c> [lossless].</param>
+    /// <returns>BitmpaImage from Bitmap</returns>
+    /// <exception cref="ArgumentNullException">if Image is null</exception>
     /// The Image as
     /// <see cref="BitmapImage" />
     /// .
-    /// <exception cref="ArgumentNullException">if Image is null</exception>
-    internal static BitmapImage BitmapToBitmapImage(Bitmap image)
+    internal static BitmapImage BitmapToBitmapImage(Bitmap image, bool lossless = false)
     {
+        if (!lossless)
+            return FastConvert(image);
+
         ImageHelper.ValidateImage(nameof(BitmapToBitmapImage), image);
 
-        Bitmap tempImage = null;
+        Bitmap processed = image;
+        Bitmap? tempImage = null;
 
-        // Convert the image to Format32bppArgb if necessary
-        if (image.PixelFormat != PixelFormat.Format32bppArgb)
+        // Normalize to 32bppArgb if needed
+        if (image.PixelFormat != System.Drawing.Imaging.PixelFormat.Format32bppArgb)
         {
-            tempImage = new Bitmap(image.Width, image.Height, PixelFormat.Format32bppArgb);
+            tempImage = new Bitmap(image.Width, image.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+
             using (var g = Graphics.FromImage(tempImage))
-            {
                 g.DrawImage(image, 0, 0);
-            }
 
-            image = tempImage;
+            processed = tempImage;
         }
 
         try
         {
-            // Create a memory stream and save the image in a compatible format (e.g., PNG)
-            using var memoryStream = new MemoryStream();
-            image.Save(memoryStream, ImageFormat.Png);
-            memoryStream.Position = 0;
-
-            // Create a BitmapImage from the memory stream
-            var bitmapImage = new BitmapImage();
-            bitmapImage.BeginInit();
-            bitmapImage.StreamSource = memoryStream;
-            bitmapImage.CacheOption = BitmapCacheOption.OnLoad; // Ensures full load and availability
-            bitmapImage.EndInit();
-            bitmapImage.Freeze(); // Makes it thread-safe and ready for WPF usage
-
-            return bitmapImage;
+            using var ms = new MemoryStream();
+            processed.Save(ms, ImageFormat.Png);
+            ms.Position = 0;
+
+            var bmp = new BitmapImage();
+            bmp.BeginInit();
+            bmp.StreamSource = ms;
+            bmp.CacheOption = BitmapCacheOption.OnLoad;
+            bmp.EndInit();
+            bmp.Freeze();
+
+            return bmp;
         }
         finally
         {
-            tempImage?.Dispose(); // Dispose of the temporary image if created
+            tempImage?.Dispose();
         }
     }
-}
+
+    /// <summary>
+    /// Fasts the convert.
+    /// </summary>
+    /// <param name="bmp">The BMP.</param>
+    /// <returns>BitmapImage from Bitmap.</returns>
+    private static BitmapImage FastConvert(Bitmap bmp)
+    {
+        // Ensure 32bpp ARGB
+        if (bmp.PixelFormat != System.Drawing.Imaging.PixelFormat.Format32bppArgb)
+        {
+            var converted = new Bitmap(bmp.Width, bmp.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+            using var g = Graphics.FromImage(converted);
+            g.DrawImage(bmp, 0, 0);
+            bmp = converted;
+        }
+
+        var rect = new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height);
+        var bmpData = bmp.LockBits(rect, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+
+        try
+        {
+            // WPF erwartet Int32Rect und PixelFormats.Bgra32
+            var wbRect = new Int32Rect(0, 0, bmp.Width, bmp.Height);
+
+            var wb = new WriteableBitmap(
+                bmp.Width,
+                bmp.Height,
+                96, 96,
+                PixelFormats.Bgra32,
+                null);
+
+            // Verwende die IntPtr-Überladung: WritePixels(Int32Rect, IntPtr buffer, int bufferSize, int stride)
+            wb.WritePixels(wbRect, bmpData.Scan0, Math.Abs(bmpData.Stride) * bmp.Height, Math.Abs(bmpData.Stride));
+            wb.Freeze();
+
+            return WriteableBitmapToBitmapImage(wb);
+        }
+        finally
+        {
+            bmp.UnlockBits(bmpData);
+        }
+    }
+
+    /// <summary>
+    /// Writeables the bitmap to bitmap image.
+    /// </summary>
+    /// <param name="wb">The wb.</param>
+    /// <returns>BitmapImage from Bitmap.</returns>
+    private static BitmapImage WriteableBitmapToBitmapImage(WriteableBitmap wb)
+    {
+        var encoder = new JpegBitmapEncoder(); // MUCH faster than PNG
+        encoder.QualityLevel = 100;            // visually lossless
+
+        using var ms = new MemoryStream();
+        encoder.Frames.Add(BitmapFrame.Create(wb));
+        encoder.Save(ms);
+        ms.Position = 0;
+
+        var bmp = new BitmapImage();
+        bmp.BeginInit();
+        bmp.CacheOption = BitmapCacheOption.OnLoad;
+        bmp.StreamSource = ms;
+        bmp.EndInit();
+        bmp.Freeze();
+        return bmp;
+    }
+}

Imaging/Interfaces/IImageRender.cs

@@ -252,22 +252,24 @@ Bitmap CutBitmap(Bitmap image, int width, int height, MaskShape shape, object sh
     /// <exception cref="IOException">Error while we try to access the File</exception>
     BitmapImage GetBitmapImageFileStream(string path, int width, int height);
 
+
     /// <summary>
-    ///     Converts to bitmap image.
+    /// Bitmaps to bitmap image.
     /// </summary>
-    /// <param name="image">The bitmap.</param>
-    /// The Image as
-    /// <see cref="BitmapImage" />
-    /// .
+    /// <param name="image">The image.</param>
+    /// <param name="lossless">if set to <c>true</c> [lossless].</param>
+    /// <returns>
+    /// The Image as <see cref="BitmapImage" />.
+    /// </returns>
     /// <exception cref="ArgumentNullException"></exception>
-    BitmapImage BitmapToBitmapImage(Bitmap image);
+    BitmapImage BitmapToBitmapImage(Bitmap image, bool lossless = false);
 
     /// <summary>
-    ///     Bitmaps the image  bitmap.
+    /// Bitmaps the image  bitmap.
     /// </summary>
     /// <param name="image">The bitmap image.</param>
     /// <returns>
-    ///     The Image as <see cref="Bitmap" />.
+    /// The Image as <see cref="Bitmap" />.
     /// </returns>
     /// <exception cref="ArgumentNullException"></exception>
     Bitmap BitmapImageToBitmap(BitmapImage image);
@@ -574,4 +576,4 @@ Bitmap FillAreaWithColor(
     /// <param name="bitmapImage">The bitmap image.</param>
     /// <returns>Image as string</returns>
     string BitmapImageToBase64(BitmapImage bitmapImage);
-}
+}