Why filter2D in OpenCV gives different results than imfilter in Matlab? - matlab

Question

I have an original image:
I then read it, create a PSF, and blur it in Matlab:
lenawords1=imread('lenawords.bmp');
%create PSF
sigma=6;
PSFgauss=fspecial('gaussian', 8*sigma+1, sigma);
%blur it
lenablur1=imfilter(lenawords1, PSFgauss, 'conv');
lenablurgray1=mat2gray(lenablur1);
PSFgauss1 = PSFgauss/max(PSFgauss(:));
and I saved the blurred image:
imwrite(lenablurgray1, 'lenablur.bmp');
imwrite(PSFgauss1, 'PSFgauss.bmp');
Their values in Matlab and OpenCV match.
Matlab:
disp(lenablurgray1(91:93, 71:75)*256)
142.2222 147.9111 153.6000 159.2889 164.9778
153.6000 164.9778 170.6667 176.3556 176.3556
164.9778 176.3556 182.0444 187.7333 187.7333
disp(PSFgauss1(24:26, 24:26)*256)
248.9867 252.4690 248.9867
252.4690 256.0000 252.4690
248.9867 252.4690 248.9867
OpenCV:
Mat img = imread("lenablur.bmp");
cvtColor(img, img, cv::COLOR_BGR2GRAY);
cv::Mat kernel = imread("PSFgauss.bmp");
cvtColor(kernel, kernel, cv::COLOR_BGR2GRAY);
for (int r = 90; r < 93; r++) {
for (int c = 70; c < 75; c++) {
cout << (int)img.at<uchar>(r, c) << " ";
}
cout << endl;
}
142 147 153 159 164
153 164 ...
164 ...
cout << "PSF" << endl;
for (int r = 23; r < 26; r++) {
for (int c = 23; c < 26; c++) {
cout << (int)kernel.at<uchar>(r, c) << " ";
}
cout << endl;
}
248 251 248
251 255 251
248 251 248
However, the values from filter2D in OpenCV and imfilter in Matlab do not match:
Matlab:
conv1=imfilter(lenablurgray1, PSFgauss1, 'conv');
disp(conv1(91:93, 71:75))
91.8094 96.1109 99.8904 103.1280 105.8210
97.3049 101.7757 105.6828 109.0073 111.7486
102.0122 106.5953 110.5755 113.9353 116.6769
OpenCV:
Mat conv1;
filter2D(img, conv1, img.depth(), kernel, Point(-1, -1), 0,
BORDER_REFLECT);
for (int r = 90; r < 93; r++) {
for (int c = 70; c < 75; c++) {
cout << (int)conv1.at<uchar>(r, c) << " ";
}
cout << endl;
}
255 255 255 255 255
255 255 255 255 255
255 255 255 255 255
Why are the filter2D values wrong?
EDIT2:
cv::Mat kernel = imread("PSFgauss.bmp");
cvtColor(kernel, kernel, cv::COLOR_BGR2GRAY);
kernel.convertTo(kernel, CV_64F);
cv::Scalar kernelsum= cv::sum(kernel);
divide(kernel, kernelsum, kernel);
filter2D(img, conv1, img.depth(), kernel, Point(-1, -1), 0, BORDER_REFLECT);
for (int r = 90; r < 93; r++) {
for (int c = 70; c < 75; c++) {
cout << (int)conv1.at<uchar>(r, c) << " ";
}
gives
103 108 112 116 119
109 ..
115 ..
which matches the Matlab values of conv1 when multiplied by the factor 1.133
disp(conv1(91:93, 71:75) * 1.133)
104.0201 108.8937 113.1758 116.8441 119.8952
110.2464 115.3118 119.7386 123.5053 126.6112
115.5798 120.7725 125.2820 129.0887 132.1950
However, the values differ when I divide img by conv1:
Matlab:
conv2 = lenablurgray1./conv1
disp(conv2(91:93, 71:75))
0.0061 0.0060 0.0060 0.0060 0.0061
0.0062 0.0063 0.0063 0.0063 0.0062
0.0063 0.0065 0.0064 0.0064 0.0063
OpenCV:
Mat conv2;
divide(img, conv1, conv2);
for (int r = 90; r < 93; r++) {
for (int c = 70; c < 75; c++) {
cout << (int)conv2.at<uchar>(r, c) << " ";
}
cout << endl;
}
1 1 1 1 1
1 1 ...
1 ...
why is this?

Answer 1

When you do
lenablur1 = imfilter(lenawords1, PSFgauss, 'conv');
in MATLAB, PSFgauss is normalized. That means that its values sum up to 1:
sum(PSFgauss(:)) == 1.0 % or at least it should be very close
Next, you scale it so its maximum value is 1, so that you can save it as a BMP file. This additionally causes rounding of the values to 256 distinct integers.
Then, in OpenCV, you read in the kernel using imread("PSFgauss.bmp"), and convert back to a grey-value image. This results in a kernel that has integer values in the range [0,255]. In particular, it is not normalized.
What happens then in the convolution is that you multiply each kernel element by an image pixel, and sum up all the values to produce one output value. If the kernel is normalized, this amounts to a weighted averaging. If the kernel is not normalized, the mean image intensity will not be preserved. Since the kernel here has values much larger than it originally had, the output values will be much larger than those of the input image. Because the input image is an 8-bit unsigned integer, and OpenCV uses saturated addition, the operation results in the value 255 for every pixel.
In mathematical notation, in MATLAB you do
g = f * k
(* is convolution, f is the image, k is the kernel). In OpenCV you do
g' = f * Ck
(where C is a constant approximately equal to 255/max(PSFgauss(:), which is the factor by which the kernel was multiplied during the transition from MATLAB to OpenCV).
Thus, dividing by C should bring the kernel back in the state it was when you used it for convolving in MATLAB. But note that the rounding effect you will not be able to remove.
The simplest way of deriving C in OpenCV is to divide kernel by its sum:
kernel.convertTo(kernel, CV_64F);
kernel /= cv::sum(kernel);