Задумал я сделать игрушку. День 3.

    public static class GaussianBlur
    {
        /// <summary>
        /// Gaussian blur.
        /// Complexity O(n) (where n = amount of pixels * channels)
        /// w - width of image (is not multiplied on bpp)
        /// h - height of image
        /// sigma - sigma of Gaussian
        /// bpp - bytes per pixel (i.e. bpp=4 for ARGB)
        /// </summary>
        public static void GaussBlur_4(byte[] originalImage, byte[] blurImage, int w, int h, double sigma, int bpp = 1) 
        {
            var bxs = GetBoxesForGauss(sigma, 3);
            BoxBlur_4(originalImage, blurImage, w, h, (int)((bxs[0] - 1) / 2f), bpp);
            BoxBlur_4(originalImage, blurImage, w, h, (int)((bxs[1] - 1) / 2f), bpp);
            BoxBlur_4(originalImage, blurImage, w, h, (int)((bxs[2] - 1) / 2f), bpp);
        }
 
        /// <summary>
        /// Box blur.
        /// Complexity O(n) (where n = amount of pixels * channels)
        /// w - width of image (is not multiplied on bpp)
        /// h - height of image
        /// r - radius of blur
        /// bpp - bytes per pixel (i.e. bpp=4 for ARGB)
        /// </summary>
        public static void BoxBlur_4(byte[] originalImage, byte[] blurImage, int w, int h, int r, int bpp = 1)
        {
            Array.Copy(originalImage, blurImage, originalImage.Length);
            BoxBlurH_4(blurImage, originalImage, w, h, r, bpp);
            BoxBlurT_4(originalImage, blurImage, w, h, r, bpp);
        }
 
        //Returns array of box-radiuses for Gauss convolution
        static double[] GetBoxesForGauss(double sigma, int n)  // standard deviation, number of boxes
        {
            var wIdeal = Math.Sqrt((12 * sigma * sigma / n) + 1);  // Ideal averaging filter width 
            var wl = (int)Math.Floor(wIdeal);
            if (wl % 2 == 0) wl--;
            var wu = wl + 2;
 
            var mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
            var m = Math.Round(mIdeal);
            // var sigmaActual = Math.sqrt( (m*wl*wl + (n-m)*wu*wu - n)/12 );
 
            var sizes = new double[n];
            for (var i = 0; i < n; i++)
                sizes[i] = i < m ? wl : wu;
            return sizes;
        }
 
        //Horizontal convolution with accumulator
        static void BoxBlurH_4(byte[] originalImage, byte[] blurImage, int w, int h, int r, int bpp)
        {
            int to = w - r;
 
            double iarr = 1d / (r + r + 1);
            for (int iBpp = 0; iBpp < bpp; iBpp++ )
            for (int i = 0; i < h; i++)
            {
                int ti = i * w * bpp + iBpp, li = ti, ri = ti + r * bpp;
                byte fv = originalImage[ti], lv = originalImage[ti + w - bpp];
                double val = (r + 1) * fv;
 
                for (int j = 0; j < r; j++) val += originalImage[ti + j*bpp];
                for (int j = 0; j <= r; j++)
                {
                    val += originalImage[ri] - fv;
                    blurImage[ti] = (byte)Math.Round(val * iarr);
                    ri += bpp;
                    ti += bpp;
                }
 
                for (int j = r + 1; j < to; j++)
                {
                    val += originalImage[ri] - originalImage[li];
                    blurImage[ti] = (byte)Math.Round(val * iarr);
                    ri += bpp;
                    li += bpp;
                    ti += bpp;
                }
 
                for (int j = w - r; j < w; j++)
                {
                    val += lv - originalImage[li];
                    blurImage[ti] = (byte)Math.Round(val * iarr);
                    li += bpp;
                    ti += bpp;
                }
            }
        }
 
        //Vertical(or total) convolution with accumulator
        static void BoxBlurT_4(byte[] originalImage, byte[] blurImage, int w, int h, int r, int bpp)
        {
            w = w * bpp;
 
            double iarr = 1d / (r + r + 1);
            for (int i = 0; i < w; i++)
            {
                int ti = i, li = ti, ri = ti + r * w;
                byte fv = originalImage[ti], lv = originalImage[ti + w * (h - 1)];
                double val = (r + 1) * fv;
 
                for (int j = 0; j < r; j++) val += originalImage[ti + j * w];
                for (int j = 0; j <= r; j++)
                {
                    val += originalImage[ri] - fv;
                    blurImage[ti] = (byte)Math.Round(val * iarr); 
                    ri += w; ti += w;
                }
 
                int to = h - r;
 
                for (int j = r + 1; j < to; j++)
                {
                    val += originalImage[ri] - originalImage[li];
                    blurImage[ti] = (byte)Math.Round(val * iarr); 
                    li += w; ri += w; ti += w;
                }
 
                for (int j = h - r; j < h; j++)
                {
                    val += lv - originalImage[li]; 
                    blurImage[ti] = (byte)Math.Round(val * iarr); 
                    li += w; ti += w;
                }
            }
        }
    }

    public static class GaussianBlurUnsafe
    {
        /// <summary>
        /// Gaussian blur.
        /// Complexity O(n) (where n = amount of pixels * channels)
        /// w - width of image (is not multiplied on bpp)
        /// h - height of image
        /// sigma - sigma of Gaussian
        /// bpp - bytes per pixel (i.e. bpp=4 for ARGB)
        /// </summary>
        public static void GaussBlur_4(byte[] originalImage, byte[] blurImage, int w, int h, double sigma, int bpp = 1) 
        {
            var bxs = GetBoxesForGauss(sigma, 3);
            BoxBlur_4(originalImage, blurImage, w, h, (int)((bxs[0] - 1) / 2f), bpp);
            BoxBlur_4(originalImage, blurImage, w, h, (int)((bxs[1] - 1) / 2f), bpp);
            BoxBlur_4(originalImage, blurImage, w, h, (int)((bxs[2] - 1) / 2f), bpp);
        }
 
        /// <summary>
        /// Box blur.
        /// Complexity O(n) (where n = amount of pixels * channels)
        /// w - width of image (is not multiplied on bpp)
        /// h - height of image
        /// r - radius of blur
        /// bpp - bytes per pixel (i.e. bpp=4 for ARGB)
        /// </summary>
        public static void BoxBlur_4(byte[] originalImage, byte[] blurImage, int w, int h, int r, int bpp = 1)
        {
            Array.Copy(originalImage, blurImage, originalImage.Length);
            BoxBlurH_4(blurImage, originalImage, w, h, r, bpp);
            BoxBlurT_4(originalImage, blurImage, w, h, r, bpp);
        }
 
        //Returns array of box-radiuses for Gauss convolution
        static double[] GetBoxesForGauss(double sigma, int n)  // standard deviation, number of boxes
        {
            var wIdeal = Math.Sqrt((12 * sigma * sigma / n) + 1);  // Ideal averaging filter width 
            var wl = (int)Math.Floor(wIdeal);
            if (wl % 2 == 0) wl--;
            var wu = wl + 2;
 
            var mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
            var m = Math.Round(mIdeal);
            // var sigmaActual = Math.sqrt( (m*wl*wl + (n-m)*wu*wu - n)/12 );
 
            var sizes = new double[n];
            for (var i = 0; i < n; i++)
                sizes[i] = i < m ? wl : wu;
            return sizes;
        }
 
        //Horizontal convolution with accumulator
        static unsafe void BoxBlurH_4(byte[] originalImage, byte[] blurImage, int w, int h, int r, int bpp)
        {
            int to = w - r;
            double iarr = 1d / (r + r + 1);
 
            fixed (byte* originalPtr = originalImage)
            fixed (byte* blurPtr = blurImage)
            for (int iBpp = 0; iBpp < bpp; iBpp++ )
            for (int i = 0; i < h; i++)
            {
                byte* ti = originalPtr + i * w * bpp + iBpp, li = ti, ri = ti + r * bpp;
                byte* blurTi = blurPtr + i * w * bpp + iBpp;
                byte fv = *ti, lv = *(ti + w * bpp - bpp);
                double val = (r + 1) * fv;
 
                for (int j = 0; j < r; j++) val += *(ti + j*bpp);
                for (int j = 0; j <= r; j++)
                {
                    val += *ri - fv;
                    *blurTi = (byte)Math.Round(val * iarr);
                    ri += bpp;
                    blurTi += bpp;
                }
 
                for (int j = r + 1; j < to; j++)
                {
                    val += *ri - *li;
                    *blurTi = (byte)Math.Round(val * iarr);
                    ri += bpp;
                    li += bpp;
                    blurTi += bpp;
                }
 
                for (int j = w - r; j < w; j++)
                {
                    val += lv - *li;
                    *blurTi = (byte)Math.Round(val * iarr);
                    li += bpp;
                    blurTi += bpp;
                }
            }
        }
 
        //Vertical(or total) convolution with accumulator
        static unsafe void BoxBlurT_4(byte[] originalImage, byte[] blurImage, int w, int h, int r, int bpp)
        {
            w = w * bpp;
            int to = h - r;
            double iarr = 1d / (r + r + 1);
 
            fixed (byte* originalPtr = originalImage)
            fixed (byte* blurPtr = blurImage)
            for (int i = 0; i < w; i++)
            {
                byte* ti = originalPtr + i, li = ti, ri = ti + r * w;
                byte* blurTi = blurPtr + i;
                byte fv = *ti, lv = *(ti + w * (h - 1));
                double val = (r + 1) * fv;
 
                for (int j = 0; j < r; j++) val += *(ti + j * w);
                for (int j = 0; j <= r; j++)
                {
                    val += *ri - fv;
                    *blurTi = (byte)Math.Round(val * iarr);
                    ri += w; 
                    blurTi += w;
                }
 
                for (int j = r + 1; j < to; j++)
                {
                    val += *ri - *li;
                    *blurTi = (byte)Math.Round(val * iarr);
                    li += w; 
                    ri += w; 
                    blurTi += w;
                }
 
                for (int j = h - r; j < h; j++)
                {
                    val += lv - *li;
                    *blurTi = (byte)Math.Round(val * iarr);
                    li += w; 
                    blurTi += w;
                }
            }
        }
    }

        unsafe void Blur(byte[] array, byte[] output)
        {
            const int stride = Sandbox.WIDTH * BPP;
 
            fixed (byte* pInStart = @array)
            fixed (byte* pOutStart = @output)
            {
                //очищаем верхнюю и нижнюю границы (цвет  - Teal)
                var p1 = pOutStart;
                var p2 = pOutStart + stride * (Sandbox.HEIGHT - 1);
 
                for (int x = stride / BPP; x > 0; x--)
                {
                    *p1 = 24; p1++;
                    *p1 = 24; p1++;
                    *p1 = 0; p1++;
                    *p1 = 255; p1++;
 
                    *p2 = 24; p2++;
                    *p2 = 24; p2++;
                    *p2 = 0; p2++;
                    *p2 = 255; p2++;
                }
 
                var finish = pInStart + array.Length - stride - BPP;
                var pIn = pInStart + stride;
                var pOut = pOutStart + stride + BPP;
 
                //размываем
                while (pIn < finish)
                {
                    *pOut = (byte)((*pIn + *(pIn - stride + BPP) + *(pIn + 2 * BPP) + *(pIn + stride + BPP)) >> 2);
                    pOut++; pIn++;
 
                    *pOut = (byte)((*pIn + *(pIn - stride + BPP) + *(pIn + 2 * BPP) + *(pIn + stride + BPP)) >> 2);
                    pOut++; pIn++;
 
                    *pOut = (byte)((*pIn + *(pIn - stride + BPP) + *(pIn + 2 * BPP) + *(pIn + stride + BPP)) >> 2);
                    pOut++; pIn++;
 
                    pOut++; pIn++;
                }
            }
        }