Calculate mean across area in a 2D array

__author__ = 'gelez [email protected]'

import os
import cv2
import time
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import convolve2d



def get_files_in_folder(folder):
    imagespaths = []
    for fl in os.listdir(folder):
        if fl.endswith(".png"):
            imagespaths.append(str(fl))
    imagespaths.sort()
    return imagespaths

def smooth_filt(src,area_size):
    y, x = src.shape
    x_lim = int(area_size[0]/2)
    y_lim = int(area_size[1]/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_size[1]-y_lim,x_i-x_lim:x_i+area_size[0]-x_lim])

    return result

def method1(src,kernel):
    return convolve2d(src, kernel, mode='valid')

def method2(src,kernel):
    src = src.astype(np.float64)
    result = cv2.blur(src, kernel)
    return result

def method3(src,kernel):
    src_integral = cv2.integral(src)

    multvalue = 1.0/(kernel[0]*kernel[1])
    src_integral = src_integral * multvalue

    array_kernel = src.shape
    means_size_x = array_kernel[0] - kernel[0] + 1
    means_size_y = array_kernel[1] - kernel[1] + 1
    means = np.zeros((means_size_x, means_size_y))

    for x in range(means_size_x):
        for y in range(means_size_y):
            means[x,y] = src_integral[x,y] + src_integral[x + kernel[0], y + kernel[1]] \
                - src_integral[x,y + kernel[1]] - src_integral[x + kernel[0],y]
    return means


if __name__ == "__main__":
    images_folder = "D:/video_data/video/2mintest/camera2mintest"
    kernel = (3, 3)
    convolve_kernel = np.ones(kernel)/(kernel[0]*kernel[1])

    images_paths = get_files_in_folder(images_folder)

    #compare results
    # test_arr = np.ones((5, 5))
    # test_arr = cv2.integral(test_arr)

    # test_arr = np.array([[1,2,3,4,5,6,7,8,9],
    #                      [0.5,10,12,0.5,10,12,0.5,10,12],
    #                      [15,10.5,3,15,10.5,3,15,10.5,3],
    #                      [15,10.5,3,15,10.5,3,15,10.5,3],
    #                      [15,10.5,3,15,10.5,3,15,10.5,3],
    #                      [0.5,10,12,0.5,10,12,0.5,10,12],
    #                      [0.5,10,12,0.5,10,12,0.5,10,12],
    #                      [1,2,3,4,5,6,7,8,9],
    #                      [1,2,3,4,5,6,7,8,9]])
    # print "method1"
    # method1_result = method1(test_arr, convolve_kernel)
    # print method1_result
    # print method1_result.shape
    # print "method2"
    # method2_result = method2(test_arr,kernel)
    # print method2_result
    # print method2_result.shape
    # print "method3"
    # method3_result = method3(test_arr,kernel)
    # print method3_result
    # print method3_result.shape

    method1_times = []
    for i in range(len(images_paths)):
        image = cv2.imread(images_folder + '/' + images_paths[i])
        b_image = image[:, :, 0]
        start_time = time.time()
        result = method1(b_image, convolve_kernel)
        time_interval = time.time()-start_time
        method1_times.append(time_interval)
    print "method1 ok"
    method2_times = []
    for i in range(len(images_paths)):
        image = cv2.imread(images_folder + '/' + images_paths[i])
        b_image = image[:, :, 0]
        start_time = time.time()
        result = method2(b_image, kernel)
        time_interval = time.time()-start_time
        method2_times.append(time_interval)
    print "method2 ok"
    method3_times = []
    for i in range(len(images_paths)):
        image = cv2.imread(images_folder + '/' + images_paths[i])
        b_image = image[:, :, 0]
        start_time = time.time()
        result = method3(b_image, kernel)
        time_interval = time.time()-start_time
        method3_times.append(time_interval)
    print "method3 ok"

    plt.figure(figsize=(10, 8))
    plt.subplot(311)
    plt.hist(np.array(method1_times), 20)
    plt.ylabel("convolve2d",size = 20)

    plt.subplot(312)
    plt.hist(np.array(method2_times), 20)
    plt.ylabel("blur",size = 20)

    plt.subplot(313)
    plt.hist(np.array(method3_times), 20)
    plt.ylabel("integral",size = 20)
    plt.xlabel("sec",size = 20)

    plt.savefig("D:/out.png", dpi=80)
    plt.show()