Implementation of 2D Convolution in C

Question

This is the function I have written for 2D Convolution in C:

typedef struct PGMImage{
    int w;
    int h;
    int* data;
}GrayImage;

GrayImage Convolution2D(GrayImage image,GrayImage kernel){
    int aH,aW,bW,bH,r,c,x,y,xx,yy,X,Y;
    int temp = 0;
    GrayImage conv;
    CreateGrayImage(&conv,image.w,image.h);
    aH = image.h;
    aW = image.w;
    bH = kernel.h;
    bW = kernel.w;
    if(aW < bW || aH < bH){
        fprintf(stderr,"Image cannot have smaller dimensions than the blur kernel");
    }

    for(r = aH-1;r >= 0;r--){
        for(c = aW-1;c >= 0;c--){
            temp = 0;
            for(y = bH-1;y >= 0;y--){
                yy = bH - y -1;
                for(x = bW-1;x >= 0;x--){
                    xx = bW - x - 1;
                    X = c + (x - (bW/2));
                    Y = r + (y - (bH/2));
                    if(X >= 0 && X < aW && Y >= 0 && Y < aH){
                        temp += ((kernel.data[(yy*bW)+xx])*(image.data[(Y*aW)+X]));
                    }
                }
            }
            conv.data[(r*aW)+c] = temp;
        }
    }
    return conv;
}

I reproduced this function in Matlab and found that it overestimates the values for certain pixels as compared to the regular 2D Convolution function in Matlab (conv2D). I can't figure out where I am going wrong with the logic. Please help.

EDIT: Here's the stock image I am using (512*512): https://drive.google.com/file/d/0B3qeTSY-DQRvdWxCZWw5RExiSjQ/view?usp=sharing

Here's the kernel (3*3): https://drive.google.com/file/d/0B3qeTSY-DQRvdlQzamcyVmtLVW8/view?usp=sharing

On using the above function I get

46465 46456 46564
45891 46137 46158
45781 46149 46030

But Matlab's conv2 gives me

46596 46618 46627
46073 46400 46149
45951 46226 46153

for the same pixels (rows:239-241,col:316:318)

This is the Matlab code I am using to compare the values:

pgm_img = imread('path\to\lena512.pgm');
kernel = imread('path\to\test_kernel.pgm');
sz_img = size(pgm_img);
sz_ker = size(kernel);
conv = conv2(double(pgm_img),double(kernel),'same');
pgm_img = padarray(pgm_img,floor(0.5*sz_ker),'both');
convolve = zeros(sz_img);
for i=floor(0.5*sz_ker(1))+1:floor(0.5*sz_ker(1))+sz_img(1)
    for j=floor(0.5*sz_ker(2))+1:floor(0.5*sz_ker(2))+sz_img(2)
        startX = j - floor(sz_ker(2)/2);
        startY = i - floor(sz_ker(1)/2);
        endX = j + floor(sz_ker(2)/2);
        endY = i + floor(sz_ker(1)/2);
        block = pgm_img(startY:endY,startX:endX);
        prod = double(block).*double(kernel);
        convolve(i-floor(0.5*sz_ker(1)),j-floor(0.5*sz_ker(2))) = sum(sum(prod));
    end
end
disp(conv(239:241,316:318));
disp(convolve(239:241,316:318));

Please give a minimal reproducible example which allows us to reproduce your issue. What image and kernel do you use and where do you get wrong values? — Daniel
We all get the problem with proprietary imagery. Can you run your program on a generic stock image and point us to that instead? — Mad Physicist
Seriously, try some smaller example. With such lagre data I would never spot the mistake. — Daniel

Dima Dima · Accepted Answer · 2016-03-08T12:44:49

One obvious difference is that your c code uses ints, while the matlab code uses doubles. Change your c code to use doubles, and see if the results are still different.

Implementation of 2D Convolution in C

2 Answers