Alpha now uses FastBitmap

Former-commit-id: 7c2d70dc94c67c84b48084480a776f3b2d4ec6fe
Former-commit-id: 71a7b03cfb9c3e4754e1ffb4a12bd9d7e5b1eb8a

src/ImageProcessor/Imaging/Formats/PngFormat.cs

@@ -101,8 +101,8 @@ namespace ImageProcessor.Imaging.Formats
             if (this.IsIndexed)
             {
                 // The Wu Quantizer expects a 32bbp image.
-                //if (Image.GetPixelFormatSize(image.PixelFormat) != 32)
+                if (Image.GetPixelFormatSize(image.PixelFormat) != 32)
-                //{
+                {
 
                     Bitmap clone = new Bitmap(image.Width, image.Height, PixelFormat.Format32bppPArgb);
                     clone.SetResolution(image.HorizontalResolution, image.VerticalResolution);
@@ -118,11 +118,11 @@ namespace ImageProcessor.Imaging.Formats
                     image = new WuQuantizer().QuantizeImage(clone);
 
                     // image = new OctreeQuantizer(255, 8).Quantize(image);
-                //}
+                }
-                //else
+                else
-                //{
+                {
-                //    image = new WuQuantizer().QuantizeImage((Bitmap)image);
+                    image = new WuQuantizer().QuantizeImage((Bitmap)image);
-                //}
+                }
             }
 
             return base.Save(path, image);

src/ImageProcessor/Imaging/Helpers/Adjustments.cs

@@ -13,6 +13,9 @@ namespace ImageProcessor.Imaging.Helpers
     using System;
     using System.Drawing;
     using System.Drawing.Imaging;
+    using System.Threading.Tasks;
+
+    using ImageProcessor.Imaging.Colors;
 
     /// <summary>
     /// Provides reusable adjustment methods to apply to images.
@@ -43,27 +46,30 @@ namespace ImageProcessor.Imaging.Helpers
                 throw new ArgumentOutOfRangeException("percentage", "Percentage should be between 0 and 100.");
             }
 
-            Rectangle bounds = rectangle.HasValue ? rectangle.Value : new Rectangle(0, 0, source.Width, source.Height);
+            float factor = (float)percentage / 100;
-
+            int width = source.Width;
-            ColorMatrix colorMatrix = new ColorMatrix();
+            int height = source.Height;
-            colorMatrix.Matrix00 = colorMatrix.Matrix11 = colorMatrix.Matrix22 = colorMatrix.Matrix44 = 1;
-            colorMatrix.Matrix33 = (float)percentage / 100;
 
-            Bitmap alpha = new Bitmap(source.Width, source.Height);
+            // Traditional examples using a color matrix alter the rgb values also.
-            alpha.SetResolution(source.HorizontalResolution, source.VerticalResolution);
+            using (FastBitmap bitmap = new FastBitmap(source))
-
-            using (Graphics graphics = Graphics.FromImage(alpha))
             {
-                graphics.Clear(Color.Transparent);
+                // Loop through the pixels.
-                using (ImageAttributes imageAttributes = new ImageAttributes())
+                Parallel.For(
+                    0,
+                    height,
+                    y =>
                     {
-                    imageAttributes.SetColorMatrix(colorMatrix);
+                        for (int x = 0; x < width; x++)
-                    graphics.DrawImage(source, bounds, 0, 0, source.Width, source.Height, GraphicsUnit.Pixel, imageAttributes);
+                        {
+                            // ReSharper disable AccessToDisposedClosure
+                            Color color = bitmap.GetPixel(x, y);
+                            bitmap.SetPixel(x, y, Color.FromArgb(Convert.ToInt32(color.A * factor), color.R, color.G, color.B));
+                            // ReSharper restore AccessToDisposedClosure
                         }
+                    });
             }
 
-            source.Dispose();
+            return (Bitmap)source;
-            return alpha;
         }
 
         /// <summary>

src/ImageProcessor/Imaging/Quantizers/WuQuantizer/ColorMoment.cs

@@ -1,8 +1,7 @@
-//using System.Runtime.CompilerServices;
+
-
 namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
 {
-    struct ColorMoment
+    internal struct ColorMoment
     {
         public long Alpha;
         public long Red;
@@ -44,7 +43,6 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
             return c1;
         }
 
-        //[MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Add(Pixel p)
         {
             byte pAlpha = p.Alpha;
@@ -59,7 +57,6 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
             Moment += pAlpha * pAlpha + pRed * pRed + pGreen * pGreen + pBlue * pBlue;
         }
 
-        //[MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void AddFast(ref ColorMoment c2)
         {
             Alpha += c2.Alpha;
@@ -77,12 +74,12 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
 
         public long WeightedDistance()
         {
-            return Amplitude() / Weight;
+            return this.Amplitude() / this.Weight;
         }
 
         public float Variance()
         {
-            var result = Moment - (float)Amplitude() / Weight;
+            float result = this.Moment - ((float)this.Amplitude() / this.Weight);
             return float.IsNaN(result) ? 0.0f : result;
         }
     }

src/ImageProcessor/Imaging/Quantizers/WuQuantizer/WuQuantizer.cs

@@ -8,8 +8,8 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
     {
         private static IEnumerable<byte[]> IndexedPixels(ImageBuffer image, Pixel[] lookups, int alphaThreshold, PaletteColorHistory[] paletteHistogram)
         {
-            var lineIndexes = new byte[image.Image.Width];
+            byte[] lineIndexes = new byte[image.Image.Width];
-            var lookup = new PaletteLookup(lookups);
+            PaletteLookup lookup = new PaletteLookup(lookups);
             foreach (var pixelLine in image.PixelLines)
             {
                 for (int pixelIndex = 0; pixelIndex < pixelLine.Length; pixelIndex++)
@@ -21,8 +21,10 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
                         bestMatch = lookup.GetPaletteIndex(pixel);
                         paletteHistogram[bestMatch].AddPixel(pixel);
                     }
+
                     lineIndexes[pixelIndex] = bestMatch;
                 }
+
                 yield return lineIndexes;
             }
         }
@@ -43,6 +45,7 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
             {
                 palette.Entries[paletteColorIndex] = paletteHistogram[paletteColorIndex].ToNormalizedColor();
             }
+
             return palette;
         }
     }

src/ImageProcessor/Imaging/Quantizers/WuQuantizer/WuQuantizerBase.cs

@@ -46,32 +46,35 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
             var buffer = new ImageBuffer(image);
 
             if (histogram == null)
+            {
                 histogram = new Histogram();
+            }
             else
+            {
                 histogram.Clear();
+            }
 
             BuildHistogram(histogram, buffer, alphaThreshold, alphaFader);
             CalculateMoments(histogram.Moments);
             var cubes = SplitData(ref maxColors, histogram.Moments);
             var lookups = BuildLookups(cubes, histogram.Moments);
-            return GetQuantizedImage(buffer, maxColors, lookups, alphaThreshold);
+            return this.GetQuantizedImage(buffer, maxColors, lookups, alphaThreshold);
         }
 
         private static void BuildHistogram(Histogram histogram, ImageBuffer sourceImage, int alphaThreshold, int alphaFader)
         {
-            var moments = histogram.Moments;
+            ColorMoment[,,,] moments = histogram.Moments;
 
-            foreach(var pixelLine in sourceImage.PixelLines)
+            foreach (Pixel[] pixelLine in sourceImage.PixelLines)
             {
-                for (int pixelIndex = 0; pixelIndex < pixelLine.Length; pixelIndex++)
+                foreach (Pixel pixel in pixelLine)
                 {
-                    Pixel pixel = pixelLine[pixelIndex];
                     byte pixelAlpha = pixel.Alpha;
                     if (pixelAlpha >= alphaThreshold)
                     {
                         if (pixelAlpha < 255)
                         {
-                            var alpha = pixel.Alpha + (pixel.Alpha % alphaFader);
+                            int alpha = pixel.Alpha + (pixel.Alpha % alphaFader);
                             pixelAlpha = (byte)(alpha > 255 ? 255 : alpha);
                         }
 
@@ -91,17 +94,17 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
 
         private static void CalculateMoments(ColorMoment[, , ,] moments)
         {
-            var xarea = new ColorMoment[SideSize, SideSize];
+            ColorMoment[,] xarea = new ColorMoment[SideSize, SideSize];
-            var area = new ColorMoment[SideSize];
+            ColorMoment[] area = new ColorMoment[SideSize];
-            for (var alphaIndex = 1; alphaIndex < SideSize; alphaIndex++)
+            for (int alphaIndex = 1; alphaIndex < SideSize; alphaIndex++)
             {
-                for (var redIndex = 1; redIndex < SideSize; redIndex++)
+                for (int redIndex = 1; redIndex < SideSize; redIndex++)
                 {
                     Array.Clear(area, 0, area.Length);
-                    for (var greenIndex = 1; greenIndex < SideSize; greenIndex++)
+                    for (int greenIndex = 1; greenIndex < SideSize; greenIndex++)
                     {
-                        var line = new ColorMoment();
+                        ColorMoment line = new ColorMoment();
-                        for (var blueIndex = 1; blueIndex < SideSize; blueIndex++)
+                        for (int blueIndex = 1; blueIndex < SideSize; blueIndex++)
                         {
                             line.AddFast(ref moments[alphaIndex, redIndex, greenIndex, blueIndex]);
                             area[blueIndex].AddFast(ref line);
@@ -220,10 +223,13 @@ namespace ImageProcessor.Imaging.Quantizers.WuQuantizer
             var result = 0.0f;
             byte? cutPoint = null;
 
-            for (var position = first; position < last; ++position)
+            for (byte position = first; position < last; ++position)
+            {
+                ColorMoment half = bottom + Top(cube, direction, position, moments);
+                if (half.Weight == 0)
                 {
-                var half = bottom + Top(cube, direction, position, moments);
+                    continue;
-                if (half.Weight == 0) continue;
+                }
 
                 var temp = half.WeightedDistance();