set to correct image version

Author: LoneWandererProductions

Imaging/Cif.cs

@@ -439,4 +439,4 @@ private static Dictionary<Color, SortedSet<int>> SortDct(Dictionary<Color, Sorte
         return value.OrderByDescending(kv => kv.Value.Count)
             .ToDictionary(kv => kv.Key, kv => kv.Value);
     }
-}
+}

Imaging/CifImageData.cs

@@ -95,4 +95,4 @@ private static (int? Start, int? End)? GetStartEndPoint(IReadOnlyList<string> ls
 
         return checkStart && checkEnd ? (start, end) : null;
     }
-}
+}

Imaging/CifMetadata.cs

@@ -62,4 +62,4 @@ public sealed class CifMetadata
     ///     The check sum.
     /// </value>
     public int CheckSum { get; set; }
-}
+}

Imaging/CifProcessing.cs

@@ -231,4 +231,4 @@ internal static List<List<string>> GenerateCsvCompressed(int imageHeight, int im
 
         return master;
     }
-}
+}

Imaging/ColorHsv.cs

@@ -97,7 +97,9 @@ public sealed class ColorHsv : IEquatable<ColorHsv>, IComparable<ColorHsv>
         /// <summary>
         /// Prevents a default instance of the <see cref="ColorHsv"/> class from being created.
         /// </summary>
-        private ColorHsv() { } // internal factory use
+        private ColorHsv()
+        {
+        } // internal factory use
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ColorHsv"/> class.
@@ -174,10 +176,10 @@ public static ColorHsv FromHex(string hex, int a = 255)
         /// <returns>Color HSV object.</returns>
         public static ColorHsv FromArgbInt(int argb)
         {
-            int a = (argb >> 24) & 0xFF;
-            int r = (argb >> 16) & 0xFF;
-            int g = (argb >> 8) & 0xFF;
-            int b = argb & 0xFF;
+            var a = (argb >> 24) & 0xFF;
+            var r = (argb >> 16) & 0xFF;
+            var g = (argb >> 8) & 0xFF;
+            var b = argb & 0xFF;
 
             return FromRgb(r, g, b, a);
         }
@@ -231,7 +233,7 @@ public override bool Equals(object obj)
         /// Returns a hash code for this instance.
         /// </summary>
         /// <returns>
-        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
         /// </returns>
         public override int GetHashCode()
             => HashCode.Combine(R, G, B, A);
@@ -304,13 +306,13 @@ public int CompareTo(ColorHsv? other)
         /// </summary>
         private void ToHsv()
         {
-            double r = R / 255d;
-            double g = G / 255d;
-            double b = B / 255d;
+            var r = R / 255d;
+            var g = G / 255d;
+            var b = B / 255d;
 
-            double max = Math.Max(r, Math.Max(g, b));
-            double min = Math.Min(r, Math.Min(g, b));
-            double delta = max - min;
+            var max = Math.Max(r, Math.Max(g, b));
+            var min = Math.Min(r, Math.Min(g, b));
+            var delta = max - min;
 
             // Hue
             if (delta == 0)
@@ -334,9 +336,9 @@ private void ToHsv()
         /// </summary>
         private void ToRgb()
         {
-            double c = V * S;
-            double x = c * (1 - Math.Abs((H / 60 % 2) - 1));
-            double m = V - c;
+            var c = V * S;
+            var x = c * (1 - Math.Abs((H / 60 % 2) - 1));
+            var m = V - c;
 
             double r = 0, g = 0, b = 0;
 
@@ -417,4 +419,4 @@ private static void ValidateHsv(double h, double s, double v, int a)
             if (a < 0 || a > 255) throw new ArgumentOutOfRangeException("Alpha must be 0–255");
         }
     }
-}
+}

Imaging/CustomImageFormat.cs

@@ -93,4 +93,4 @@ public void GenerateCifCompressedFromBitmap(Bitmap image, string path)
         var lst = CifProcessing.GenerateCsvCompressed(image.Height, image.Width, imageFormat);
         CsvHandler.WriteCsv(path, lst);
     }
-}
+}

Imaging/DirectBitmap.cs

@@ -698,4 +698,4 @@ private void Dispose(bool disposing)
         // Finalizer calls Dispose(false)
         Dispose(false);
     }
-}
+}

Imaging/DirectBitmapImage.cs

@@ -123,14 +123,14 @@ public void SetPixelsUnsafe(IEnumerable<PixelData> pixels)
         unsafe
         {
             var buffer = (byte*)_bitmap.BackBuffer.ToPointer();
-            int stride = _bitmap.BackBufferStride;
+            var stride = _bitmap.BackBufferStride;
 
             foreach (var pixel in pixels)
             {
                 if (pixel.X < 0 || pixel.X >= Width || pixel.Y < 0 || pixel.Y >= Height)
                     continue;
 
-                int offset = pixel.Y * stride + pixel.X * 4;
+                var offset = pixel.Y * stride + pixel.X * 4;
                 buffer[offset + 0] = pixel.B;
                 buffer[offset + 1] = pixel.G;
                 buffer[offset + 2] = pixel.R;
@@ -139,7 +139,6 @@ public void SetPixelsUnsafe(IEnumerable<PixelData> pixels)
                 Bits[pixel.Y * Width + pixel.X] =
                     (uint)(pixel.A << 24 | pixel.R << 16 | pixel.G << 8 | pixel.B);
             }
-
         }
 
         _bitmap.AddDirtyRect(new Int32Rect(0, 0, Width, Height));
@@ -152,16 +151,16 @@ public void SetPixelsUnsafe(IEnumerable<PixelData> pixels)
     /// <param name="color">The color to fill with.</param>
     public unsafe void FillSimd(Color color)
     {
-        uint packed = (uint)(color.A << 24 | color.R << 16 | color.G << 8 | color.B);
+        var packed = (uint)(color.A << 24 | color.R << 16 | color.G << 8 | color.B);
         _bitmap.Lock();
 
-        uint* ptr = (uint*)_bitmap.BackBuffer.ToPointer();
-        int len = Bits.Length;
-        int vecSize = Vector<uint>.Count;
-        int i = 0;
+        var ptr = (uint*)_bitmap.BackBuffer.ToPointer();
+        var len = Bits.Length;
+        var vecSize = Vector<uint>.Count;
+        var i = 0;
 
         // SIMD bulk fill
-        Vector<uint> v = new Vector<uint>(packed);
+        var v = new Vector<uint>(packed);
         for (; i <= len - vecSize; i += vecSize)
             v.CopyTo(Bits, i);
 
@@ -202,9 +201,9 @@ public void ApplyColorMatrix(float[][] matrix)
         // We reuse output array to avoid allocations when repeating effects
         var pixels = new (int x, int y, Color color)[Bits.Length];
 
-        for (int i = 0; i < Bits.Length; i++)
+        for (var i = 0; i < Bits.Length; i++)
         {
-            uint argb = Bits[i];
+            var argb = Bits[i];
 
             // Manual unpack (fastest + identical)
             float r = (byte)(argb >> 16);
@@ -213,16 +212,16 @@ public void ApplyColorMatrix(float[][] matrix)
             float a = (byte)(argb >> 24);
 
             // Ordered multiply like WinForms (NOT SIMD parallel)
-            float rr = r * m00 + g * m01 + b * m02 + a * m03;
-            float gg = r * m10 + g * m11 + b * m12 + a * m13;
-            float bb = r * m20 + g * m21 + b * m22 + a * m23;
-            float aa = r * m30 + g * m31 + b * m32 + a * m33;
+            var rr = r * m00 + g * m01 + b * m02 + a * m03;
+            var gg = r * m10 + g * m11 + b * m12 + a * m13;
+            var bb = r * m20 + g * m21 + b * m22 + a * m23;
+            var aa = r * m30 + g * m31 + b * m32 + a * m33;
 
             // Same exact truncation as WinForms (NOT Math.Round)
-            byte R = (byte)(rr < 0f ? 0f : (rr > 255f ? 255f : rr));
-            byte G = (byte)(gg < 0f ? 0f : (gg > 255f ? 255f : gg));
-            byte B = (byte)(bb < 0f ? 0f : (bb > 255f ? 255f : bb));
-            byte A = (byte)(aa < 0f ? 0f : (aa > 255f ? 255f : aa));
+            var R = (byte)(rr < 0f ? 0f : (rr > 255f ? 255f : rr));
+            var G = (byte)(gg < 0f ? 0f : (gg > 255f ? 255f : gg));
+            var B = (byte)(bb < 0f ? 0f : (bb > 255f ? 255f : bb));
+            var A = (byte)(aa < 0f ? 0f : (aa > 255f ? 255f : aa));
 
             // Save (no packing yet)
             pixels[i] = (i % Width, i / Width, Color.FromArgb(A, R, G, B));
@@ -264,22 +263,22 @@ public void BlendSimd(uint[] src)
         if (src == null || src.Length != Bits.Length)
             throw new ArgumentException("Source must match image size");
 
-        int len = Bits.Length;
+        var len = Bits.Length;
 
-        for (int i = 0; i < len; i++)
+        for (var i = 0; i < len; i++)
         {
-            uint s = src[i];
+            var s = src[i];
             if ((s >> 24) == 0)
                 continue; // fully transparent, skip completely
 
-            uint d = Bits[i];
+            var d = Bits[i];
 
             // Load BGRA from packed uint into float components
             var sf = new Vector4(
-                (s >> 16) & 255,  // R
-                (s >> 8) & 255,  // G
-                (s) & 255,  // B
-                (s >> 24) & 255   // A
+                (s >> 16) & 255, // R
+                (s >> 8) & 255, // G
+                (s) & 255, // B
+                (s >> 24) & 255 // A
             );
 
             var df = new Vector4(
@@ -289,12 +288,12 @@ public void BlendSimd(uint[] src)
                 (d >> 24) & 255
             );
 
-            float a = sf.W * (1f / 255f);
+            var a = sf.W * (1f / 255f);
             if (a <= 0.0001f)
                 continue; // ignore near-transparent pixels
 
             // SIMD blend: Dst = Src * a + Dst * (1−a)
-            Vector4 r = sf * a + df * (1f - a);
+            var r = sf * a + df * (1f - a);
 
             // Clamp and repack BGRA
             Bits[i] =
@@ -319,8 +318,8 @@ public unsafe void SetPixelsSimd(IEnumerable<(int x, int y, Color color)> pixels
         foreach (var (x, y, c) in pixels)
         {
             if ((uint)x >= Width || (uint)y >= Height) continue;
-            uint packed = (uint)(c.A << 24 | c.R << 16 | c.G << 8 | c.B);
-            int index = x + y * Width;
+            var packed = (uint)(c.A << 24 | c.R << 16 | c.G << 8 | c.B);
+            var index = x + y * Width;
             ptr[index] = packed;
             Bits[index] = packed;
         }
@@ -368,10 +367,11 @@ public void UpdateBitmapFromBits()
         _bitmap.Lock();
         unsafe
         {
-            void* src = (void*)_bitsHandle.AddrOfPinnedObject();
-            void* dst = (void*)_bitmap.BackBuffer;
+            var src = (void*)_bitsHandle.AddrOfPinnedObject();
+            var dst = (void*)_bitmap.BackBuffer;
             Buffer.MemoryCopy(src, dst, Bits.Length * sizeof(uint), Bits.Length * sizeof(uint));
         }
+
         _bitmap.AddDirtyRect(new Int32Rect(0, 0, Width, Height));
         _bitmap.Unlock();
     }
@@ -403,4 +403,4 @@ private void Dispose(bool disposing)
     {
         Dispose(false);
     }
-}
+}

Imaging/Enums/FiltersType.cs

@@ -155,4 +155,4 @@ public enum FiltersType
     ///     The pencil sketch effect
     /// </summary>
     PencilSketchEffect = 26
-}
+}

Imaging/Enums/MaskShape.cs

@@ -29,4 +29,4 @@ public enum MaskShape
     ///     The polygon
     /// </summary>
     Polygon = 2
-}
+}