C# Convolution filter for any size matrix (1x1, 3x3, 5x5, ...) not fully applied

Question

I'm making a convolution filter for my project and I managed to make it for any size of matrix but as it gets bigger I noticed that not all bits are changed. Here are the pictures showing the problem:

First one is the original Filter: Blur 9x9

Filter: EdgeDetection 9x9:

As you can see, there is a little stripe that is never changed and as the matrix gets bigger, the stripe also gets bigger (in 3x3 it wasn't visible)

My convolution matrix class:

    public class ConvMatrix
{
    public int Factor = 1;
    public int Height, Width;
    public int Offset = 0;
    public int[,] Arr;

    //later I assign functions to set these variables
    ...
}

The filter function:

    Bitmap Conv3x3(Bitmap b, ConvMatrix m)
{
    if (0 == m.Factor)
        return b;

    Bitmap bSrc = (Bitmap)b.Clone();
    BitmapData bmData = b.LockBits(new Rectangle(0, 0, b.Width, b.Height),
                        ImageLockMode.ReadWrite,
                        PixelFormat.Format24bppRgb);
    BitmapData bmSrc = bSrc.LockBits(new Rectangle(0, 0, bSrc.Width, bSrc.Height),
                       ImageLockMode.ReadWrite,
                       PixelFormat.Format24bppRgb);
    int stride = bmData.Stride;

    System.IntPtr Scan0 = bmData.Scan0;
    System.IntPtr SrcScan0 = bmSrc.Scan0;

        unsafe
        {
            byte* p = (byte*)(void*)Scan0;
            byte* pSrc = (byte*)(void*)SrcScan0;
            int nOffset = stride - b.Width * m.Width;
            int nWidth = b.Width - (m.Size-1);
            int nHeight = b.Height - (m.Size-2);

            int nPixel = 0;

            for (int y = 0; y < nHeight; y++)
            {
                for (int x = 0; x < nWidth; x++)
                {
                    for (int r = 0; r < m.Height; r++)
                    {
                        nPixel = 0;
                        for (int i = 0; i < m.Width; i++)
                            for (int j = 0; j < m.Height; j++)
                            {
                                nPixel += (pSrc[(m.Width * (i + 1)) - 1 - r + stride * j] * m.Arr[j, i]);
                            }

                        nPixel /= m.Factor;
                        nPixel += m.Offset;

                        if (nPixel < 0) nPixel = 0;
                        if (nPixel > 255) nPixel = 255;
                        p[(m.Width * (m.Height / 2 + 1)) - 1 - r + stride * (m.Height / 2)] = (byte)nPixel;
                    }
                    p += m.Width;
                    pSrc += m.Width;
                }
                p += nOffset;
                pSrc += nOffset;
            }
        }

    b.UnlockBits(bmData);
    bSrc.UnlockBits(bmSrc);
    return b;
}

Please help

Answer 1

The problem is that your code explicitly stops short of the edges. The calculation for the limits for your outer loops (nWidth and nHeight) shouldn't involve the size of the matrix, they should be equal to the size of your bitmap.

When you do this, if you imagine what happens when you lay the center point of your matrix over each pixel in this case (because you need to read from all sizes of the pixel) the matrix will partially be outside of the image near the edges.

There are a few approaches as to what to do near the edges, but a reasonable one is to clamp the coordinates to the edges. I.e. when you would end up reading a pixel from outside the bitmap, just get the nearest pixel from the edge (size or corner).

I also don't understand why you need five loops - you seem to be looping through the height of the matrix twice. That doesn't look right. All in all the general structure should be something like this:

for (int y = 0; y < bitmap.Height; y++) {
  for (int x = 0; x < bitmap.Width; x++) {
    int sum = 0;

    for (int matrixY = -matrix.Height/2; matrixY < matrix.Height/2; matrixY++)
      for (int matrixX = -matrix.Width/2; matrixX < matrix.Width/2; matrixX++) {
        // these coordinates will be outside the bitmap near all edges
        int sourceX = x + matrixX;
        int sourceY = y + matrixY;
        
        if (sourceX < 0)
          sourceX = 0;

        if (sourceX >= bitmap.Width)
          sourceX = bitmap.Width - 1;
        
        if (sourceY < 0)
          sourceY = 0;

        if (sourceY >= bitmap.Height)
          sourceY = bitmap.Height - 1;
        
        sum += source[sourceX, sourceY];
      }
    }

    // factor and clamp sum
    
    destination[x, y] = sum;
  }
}

You might need an extra loop to handle each color channel which need to be processed separately. I couldn't immediately see where in your code you might be doing that from all the cryptic variables.