public void Test_Bgr32()
        {
            string[] hexValues = new[] { "FF0000", "FF00", "FF" };
            for (int i = 0; i < 3; i++)
            {
                int x = i == 0 ? 1 : 0;
                int y = i == 1 ? 1 : 0;
                int z = i == 2 ? 1 : 0;

                var testPixel = new Bgr32(x, y, z);

                Assert.Equal($"Bgr32({z}, {y}, {x})", testPixel.ToString());

                var destPixel = new ImageSharp.PixelFormats.Rgba32(0);
                testPixel.ToRgba32(ref destPixel);

                Assert.Equal(hexValues[i], testPixel.PackedValue.ToString("X"));

                Assert.Equal(i == 0 ? 255 : 0, destPixel.R);
                Assert.Equal(i == 1 ? 255 : 0, destPixel.G);
                Assert.Equal(i == 2 ? 255 : 0, destPixel.B);
                Assert.Equal(255, destPixel.A);

                var vector4 = testPixel.ToVector4();
                testPixel.FromVector4(vector4);
                Assert.Equal(testPixel.ToVector4(), vector4);
            }
        }
Пример #2
0
        /// <summary>
        ///     BoxBlurHorizontal is a private helper method for the BoxBlur, only for IFastBitmaps with alpha channel
        /// </summary>
        /// <param name="unmanagedBitmap">UnmanagedBitmap</param>
        /// <param name="range">Range must be odd!</param>
        private static void BoxBlurHorizontal(UnmanagedBitmap <Bgr32> unmanagedBitmap, int range)
        {
            var halfRange = range / 2;

            Parallel.For(0, unmanagedBitmap.Height, y =>
            {
                unsafe {
                    var rgb32             = unmanagedBitmap[y];
                    Span <Bgr32> averages = stackalloc Bgr32[range];
                    var r    = 0;
                    var g    = 0;
                    var b    = 0;
                    var hits = halfRange;
                    for (var x = 0; x < halfRange; x++)
                    {
                        ref Bgr32 color = ref rgb32[x];

                        r += color.R;
                        g += color.G;
                        b += color.B;
                    }
                    for (var x = 0; x < unmanagedBitmap.Width; x++)
                    {
                        var leftSide = x - halfRange - 1;
                        if (leftSide >= 0)
                        {
                            // Get value at the left side of range
                            ref Bgr32 color = ref rgb32[leftSide];
                            r -= color.R;
                            g -= color.G;
                            b -= color.B;
                            hits--;
                        }

                        var rightSide = x + halfRange;
                        if (rightSide < unmanagedBitmap.Width)
                        {
                            ref Bgr32 color = ref rgb32[rightSide];
                            r += color.R;
                            g += color.G;
                            b += color.B;
                            hits++;
                        }

                        ref Bgr32 average = ref averages[x % range];
                        average.R         = (byte)(r / hits);
                        average.G         = (byte)(g / hits);
                        average.B         = (byte)(b / hits);

                        if (leftSide >= 0)
                        {
                            // Now we can write the value from the calculated avarages
                            var readLocation = (leftSide % range);

                            rgb32[leftSide] = averages[readLocation];
                        }
                    }