3

in a nutshell: I need a fast(precompiled) function like filter2d from OpenCV with double type output. Not integer.

Detail: I have numpy array which store the monochrome image from OpenCV.

I need to calculate the mean values of matrix for some square (for example) kernel like this:

kernel size = (3,3)

input array:

[[13 10 10 10]
 [12 10 10  8]
 [ 9  9  9  9]
 [ 9 10 10  9]]

output array:

[[ 10.22222222   9.44444444]
 [  9.77777778   9.33333333]]

For example: 10.22222 = (13+10+10+12+10+10+9+9+9)/9

I write this function:

def smooth_filt(src,area_x,area_y):
    y,x = src.shape
    x_lim = int(area_x/2)
    y_lim = int(area_y/2)
    result = np.zeros((y-2*y_lim,x-2*x_lim), dtype=np.float64)

    for x_i in range(x_lim,x-x_lim):
        for y_i in range(y_lim,y-y_lim):
            result[y_i-y_lim, x_i-x_lim] = np.mean(src[y_i-y_lim:y_i+area_y-y_lim,x_i-x_lim:x_i+area_x-x_lim])
    return result

But this is not fast enough.

Please tell me if there is a faster way to calculate this.

Answer: I check all methods. You can see the code: http://pastebin.com/y5dEVbzX

And decide that blur is most powerful method it is almost independent on kernel size.

The graph of one image processing with different methods. testing set is 298 images. enter image description here

Konstantin Purtov
  • 799
  • 1
  • 11
  • 19
  • 1
    You can use a convolution matrix with only coefficients equal to 1/9 and then sum the result to get the mean – Pierre Feb 02 '16 at 10:49

4 Answers4

5

Calculating the average in blocks is simply convolving the image with a constant kernel. You can use the scipy.signal.convolve2d for this:

from scipy.signal import convolve2d
kernel = np.ones((3,3)) / 9.
out = convolve2d(img, kernel, mode='valid')

The mode='valid' argument is required to only get the part of the result that you are interested in.

Hannes Ovrén
  • 21,229
  • 9
  • 65
  • 75
3

Take a look at scipy.signal.convolve2d. It's pretty straightforward:

import numpy as np
import scipy.signal as ss

data = np.array([[13, 10, 10, 10],
                 [12, 10, 10,  8],
                 [ 9,  9,  9,  9],
                 [ 9, 10, 10,  9]])
kernel = np.ones((3,3))
kernel /= kernel.size

ss.convolve2d(data, kernel, mode='valid')

this gives

array([[ 10.22222222,   9.44444444],
       [  9.77777778,   9.33333333]])
Jan Christoph Terasa
  • 5,781
  • 24
  • 34
3

If you interested in OpenCV solution: function which you need is cv2.blur. For most of cases it must works faster than convolution, since it has separate optimization for normalized kernels (sum of coefficient is equal to 1). 

blurred = cv2.blur(img,(3,3))

See nice tutorial about smoothing here.

akarsakov
  • 2,134
  • 4
  • 21
  • 26
1

You can exploit integral function, that calculates the sum of values from (0,0) to (i,j) elements.

Using these integral images, you can calculate sum, mean, and standard deviation over a specific up-right or rotated rectangular region of the image in a constant time

If "kernel" size is constant M, multiply resulting integral matrix by 1/M^2 to simplify mean calculation.

To get sum in some window (x1,y1)-(x2,y2), just find

S((x1,y1)-(x2,y2)) = I(x1,y1) + I(x2,y2) - I(x1,y2) - I(x2,y1)

pseudocode:

integral(src, sum)
multvalue = 1/(kernelsize*kernelsize)
sum = sum * multvalue
for every (x = 0..n-kernelsize-1, y = 0..n-kernelsize-1)
   mean[x,y] =  sum[x,              y] 
              + sum[x + kernelsize, y + kernelsize] 
              - sum[x,              y + kernelsize] 
              - sum[x + kernelsize, y]
MBo
  • 77,366
  • 5
  • 53
  • 86
  • Interesting solution. If you can - please provide more detail( I talk about code) – Konstantin Purtov Feb 02 '16 at 12:02
  • I don't know Python enough - see straightforward pseudocode – MBo Feb 02 '16 at 12:27
  • Is suspect that time is so large (100x) due to slow matrix access methods here: `means[x,y] = src_integral[x,y] ...`. (Inbuilt functions like `blur` have direct access in C-code) – MBo Feb 03 '16 at 07:45