Sum of the cells around a single cell in a matrix with python

Question

I have two matrices: in "matrix" there are 0 and 1. In "matrix_2" I would like to sum the cells around the single cell. For example:

matrix =
[[0 0 0 0 0 1 1 0 0 0]
[0 0 0 0 0 1 1 0 0 0]
[1 1 1 0 1 1 0 1 0 0]
[0 0 1 1 1 1 0 1 0 0]
[0 0 1 1 1 1 1 0 0 0]
[0 0 0 0 1 0 0 0 0 0]]

And

matrix_2 =
[[0 0 0 0 0 4 4 0 0 0]
[0 0 0 0 0 6 6 0 0 0]
[2 4 4 0 6 6 0 3 0 0]
[0 0 6 8 8 7 0 3 0 0]
[0 0 4 7 7 6 4 0 0 0]
[0 0 0 0 4 0 0 0 0 0]]

In this case, matrix_2 computes the sum of the cell and the cells immediately around.

matrix_2 = np.zeros((y_segment, x_segment), dtype=int)
for y_matrix in xrange(0, y_segment, 1):
    for x_matrix in xrange(0, x_segment, 1):
        if matrix[y_matrix][x_matrix] != 0:
            if 0 < x_matrix < x_segment - 1 and 0 < y_matrix < y_segment - 1:
                # print "y_matrix: " + str(y_matrix) + ", x_matrix: " + str(x_matrix)
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix-1][x_matrix] + \
                                           matrix[y_matrix-1][x_matrix-1] + matrix[y_matrix-1][x_matrix+1] + \
                                           matrix[y_matrix+1][x_matrix-1] + matrix[y_matrix+1][x_matrix] + \
                                           matrix[y_matrix+1][x_matrix+1] + matrix[y_matrix][x_matrix-1] + \
                                           matrix[y_matrix][x_matrix+1]
            if x_matrix == 0 and y_matrix == 0:  # 1
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix][x_matrix+1] + \
                                           matrix[y_matrix+1][x_matrix+1] + matrix[y_matrix+1][x_matrix]
            if x_matrix == 0 and y_matrix == y_segment-1:  # 10
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix - 1][x_matrix] + \
                                           matrix[y_matrix - 1][x_matrix + 1] + matrix[y_matrix][x_matrix + 1]
            if x_matrix == x_segment-1 and y_matrix == y_segment-1:  # 12
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix - 1][x_matrix] + \
                                           matrix[y_matrix][x_matrix - 1] + matrix[y_matrix - 1][x_matrix - 1]
            if x_matrix == x_segment-1 and y_matrix == 0:  # 3
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix][x_matrix-1] + \
                                           matrix[y_matrix + 1][x_matrix - 1] + matrix[y_matrix + 1][x_matrix]
            if x_matrix == 0 and y_matrix != 0 and y_matrix != y_segment-1:
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix-1][x_matrix] + \
                                               matrix[y_matrix-1][x_matrix+1] + matrix[y_matrix+1][x_matrix] + \
                                               matrix[y_matrix+1][x_matrix+1] + matrix[y_matrix][x_matrix+1]
            if x_matrix == x_segment-1 and y_matrix != 0 and y_matrix != y_segment-1:
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix - 1][x_matrix] + \
                                           matrix[y_matrix - 1][x_matrix - 1] + matrix[y_matrix + 1][x_matrix] + \
                                           matrix[y_matrix + 1][x_matrix - 1] + matrix[y_matrix][x_matrix - 1]
            if y_matrix == 0 and x_matrix != 0 and x_matrix != x_segment-1:
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix][x_matrix + 1] + \
                                           matrix[y_matrix][x_matrix - 1] + matrix[y_matrix + 1][x_matrix] + \
                                           matrix[y_matrix + 1][x_matrix + 1] + matrix[y_matrix + 1][x_matrix - 1]
            if y_matrix == y_segment-1 and x_matrix != 0 and x_matrix != x_segment-1:
                matrix_2[y_matrix][x_matrix] = matrix[y_matrix][x_matrix] + matrix[y_matrix][x_matrix + 1] + \
                                           matrix[y_matrix][x_matrix - 1] + matrix[y_matrix - 1][x_matrix] + \
                                           matrix[y_matrix - 1][x_matrix + 1] + matrix[y_matrix - 1][x_matrix - 1]

But know I would like to compute the sum of the 9x9 cells around my cell. Is there a function for that? Because for sure my code is not well written and it will be very long. Thank you.

Answer 1

Using convolution

kernel

size=3
kernel = np.ones((size,size))

array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

calculation

result = signal.convolve(matrix, kernel, method='direct').astype(int)

array([[0, 0, 0, 0, 0, 1, 2, 2, 1, 0, 0, 0],
        [0, 0, 0, 0, 0, 2, 4, 4, 2, 0, 0, 0],
        [1, 2, 3, 2, 2, 4, 6, 6, 3, 1, 0, 0],
        [1, 2, 4, 4, 5, 6, 6, 6, 3, 2, 0, 0],
        [1, 2, 5, 6, 8, 8, 7, 6, 3, 2, 0, 0],
        [0, 0, 2, 4, 7, 7, 6, 4, 2, 1, 0, 0],
        [0, 0, 1, 2, 4, 4, 4, 2, 1, 0, 0, 0],
        [0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0]])

trimming

This adds the outer layers too, so you need to trim these

result_trimmed = result[(size-1)//2:-(size-1)//2,(size-1)//2:-(size-1)//2]

array([[0, 0, 0, 0, 2, 4, 4, 2, 0, 0],
       [2, 3, 2, 2, 4, 6, 6, 3, 1, 0],
       [2, 4, 4, 5, 6, 6, 6, 3, 2, 0],
       [2, 5, 6, 8, 8, 7, 6, 3, 2, 0],
       [0, 2, 4, 7, 7, 6, 4, 2, 1, 0],
       [0, 1, 2, 4, 4, 4, 2, 1, 0, 0]])

Pure python

This does the same as the scipy alternative

from itertools import product
def convolution(matrix, size):
    if size % 2 != 1:
        ValueError('`size` must be an odd integer')
    h, w = (len(matrix), max(len(row) for row in matrix), )
#     print(w, h)
    result = [[0] * w for _ in range(h)]
    for x, y in product(range(w), range(h)):
#         print(x, y)
        y_min, y_max = max(0, y - size // 2), min(h, y + size // 2 + 1)
        x_min, x_max = max(0, x - size // 2), min(w, x + size // 2 + 1)
#         print(matrix[y][x], x_min, x_max, y_min, y_max)
        rows = matrix[y_min: y_max]
        result[y][x] = sum(sum(row[x_min: x_max]) for row in rows)
    return result

OP's matrix2

If that is the result the OP expects, this can be achieved by

numpy method:

assuming matrix is the np.array form of the initial matrix

np.where(matrix != 0, result_trimmed, 0)

array([[0, 0, 0, 0, 0, 4, 4, 0, 0, 0],
       [0, 0, 0, 0, 0, 6, 6, 0, 0, 0],
       [2, 4, 4, 0, 6, 6, 0, 3, 0, 0],
       [0, 0, 6, 8, 8, 7, 0, 3, 0, 0],
       [0, 0, 4, 7, 7, 6, 4, 0, 0, 0],
       [0, 0, 0, 0, 4, 0, 0, 0, 0, 0]])

native python

Add 2 lines in the inner loop:

...
    for x, y in product(range(w), range(h)):
        if matrix[y][x] == 0:
            continue
...