How to properly divide a task of editing bitmap for parallel processing for filter

Question

I'm currently in the development phase of a photoconverter program and in the process of developing a blur filter. At the initial stages of prototyping this feature, i devised a algorithm in which I had an accumulator for each color channel and add all the pixels in a radius of the target pixel. Afterwards the program would divide the accum by the amount of pixels read(not counting those offscreen). At first I thought this would be fine but when it started to work, I had the problem of this filter taking an hour to render with this being the result at the lowest setting. So I opted to utilize parallel processing in C# to make this process much easier and faster to run. With the boost of speed came the cost of the image becoming very glitched out. Here's the image before, and Here's the image afterwards

This is the code I wrote for the filter

public static DirectBitmap NewBlur (DirectBitmap image, int radius)
        {
            int sectorDiam = 128;
            DirectBitmap newimage = image;
            List<Rectangle> renderSectors = new List<Rectangle>();
            Rectangle rect;
            for (int x = 0; x < (image.Width / sectorDiam); x++)
            {
                int xwidth = sectorDiam;
                for (int y = 0; y < (image.Height / sectorDiam); y++)
                {
                    int yheight = sectorDiam;
                    rect = new Rectangle(x * sectorDiam, y * sectorDiam, xwidth, yheight);
                    renderSectors.Add(rect);
                }
            }
            var Picrect = new Rectangle(0, 0, image.Width, image.Height);
            var data = image.Bitmap.LockBits(Picrect, ImageLockMode.ReadWrite, image.Bitmap.PixelFormat);
            var depth = Bitmap.GetPixelFormatSize(data.PixelFormat) / 8; //bytes per pixel
            var buffer = new byte[data.Width * data.Height * depth];
            Marshal.Copy(data.Scan0, buffer, 0, buffer.Length);
            Parallel.ForEach(renderSectors, sector =>
            {
                BlurSection(buffer, sector, Picrect, radius, image.Width, image.Height, depth);
            }
            );
            Marshal.Copy(buffer, 0, data.Scan0, buffer.Length);
            image.Bitmap.UnlockBits(data);

            return image;
        }

And here's the method for each section of the image to be blurred.

public static void BlurSection(byte[] buffer, Rectangle blurSector, Rectangle bitmaprect, int radius, int width, int height, int depth)
        {

            int[] Accum = new int[4];
            for (int x = blurSector.X; x < blurSector.Width+ blurSector.X; x++)
            {
                for (int y = blurSector.Y; y < blurSector.Height + blurSector.Y; y++)
                {
                    Accum[0] = 0;
                    Accum[1] = 0;
                    Accum[2] = 0;
                    Accum[3] = 0;

                    for (int i = -radius; i <= radius; i++)
                    {
                        for (int j = -radius; j <= radius; j++)
                        {
                            var offset = 0;
                            offset = (((y+j) * width) + (x+i)) * depth;
                            if (bitmaprect.Contains(new Point(x + i, y + j))){
                                Accum[0] += buffer[offset + 0];
                                Accum[1] += buffer[offset + 1];
                                Accum[2] += buffer[offset + 2];
                                Accum[3]++;
                            }
                        }
                    }
                    Accum[0] = Accum[0] / Accum[3];
                    if (Accum[0] > 255)
                    {
                        Accum[0] = 255;
                    }
                    Accum[1] = Accum[1] / Accum[3];
                    if (Accum[1] > 255)
                    {
                        Accum[1] = 255;
                    }
                    Accum[2] = Accum[2] / Accum[3];
                    if (Accum[2] > 255)
                    {
                        Accum[2] = 255;
                    }
                    var newoffset = ((y * width) + (x * depth*2));
                    buffer[newoffset + 0] = (byte)Accum[0];
                    buffer[newoffset + 1] = (byte)Accum[1];
                    buffer[newoffset + 2] = (byte)Accum[2];
                }
            }
        }

It's also worth noting that I'm using a Bitmap class to make access to pixel data much easier, the "DirectBitmap" you can find here: https://stackoverflow.com/a/34801225/15473435. Is there anything that I'm missing or not aware of that's causing this algorithm not to function?