Accord.Imaging.Filters.FastBoxBlur.HorizontalBoxBlur C# (CSharp) Method

HorizontalBoxBlur() static private method

static private HorizontalBoxBlur ( UnmanagedImage &image, Rectangle rect, IntRange kernelSizeRange ) : void
image UnmanagedImage
rect System.Drawing.Rectangle
kernelSizeRange IntRange
return void
        static unsafe void HorizontalBoxBlur(ref UnmanagedImage image, Rectangle rect, IntRange kernelSizeRange)
        {
            var pixelSize = ((image.PixelFormat == PixelFormat.Format8bppIndexed) ||
                (image.PixelFormat == PixelFormat.Format16bppGrayScale)) ? 1 : 3;

            var startY = rect.Top;
            var stopY = startY + rect.Height;

            var startX = rect.Left * pixelSize;
            var stopX = startX + rect.Width * pixelSize;

            var basePtr = (byte*)image.ImageData.ToPointer();

            if ((image.PixelFormat == PixelFormat.Format8bppIndexed) ||
                (image.PixelFormat == PixelFormat.Format24bppRgb))
            {
                var offset = image.Stride - (stopX - startX);

                // align pointer to the first pixel to process
                var ptr = basePtr + (startY * image.Stride + rect.Left * pixelSize);

                for (var y = startY; y < stopY; y++)
                {
                    for (var x = startX; x < stopX; x++, ptr++)
                    {
                        var sum = 0;

                        for (var xFilter = kernelSizeRange.Min; xFilter < kernelSizeRange.Max; xFilter++)
                        {
                            var xBound = x / pixelSize + xFilter;

                            //Only if in bounds
                            if (xBound < 0 || xBound >= image.Width) continue;

                            sum += ptr[xFilter * pixelSize];
                        }
                        *ptr = (byte)(sum / kernelSizeRange.Length);
                    }
                    ptr += offset;
                }

            }
            else
            {
                var stride = image.Stride;

                // align pointer to the first pixel to process
                basePtr += (startY * image.Stride + rect.Left * pixelSize * 2);

                for (var y = startY; y < stopY; y++)
                {
                    var ptr = (ushort*)(basePtr);

                    for (var x = startX; x < stopX; x++, ptr++)
                    {
                        var sum = 0;

                        for (var xFilter = kernelSizeRange.Min; xFilter < kernelSizeRange.Max; xFilter++)
                        {
                            var xBound = x / pixelSize + xFilter;

                            //Only if in bounds
                            if (xBound < 0 || xBound >= image.Width) continue;

                            sum += ptr[xFilter * pixelSize];
                        }

                        *ptr = (ushort)(sum / kernelSizeRange.Length);
                    }
                    basePtr += stride;
                }
            }

        }
        static unsafe void VerticalBoxBlur(ref UnmanagedImage image, Rectangle rect, IntRange kernelSizeRange)