Smoothing a 2-D Numpy Array with a Kernel

问题

Suppose I have an (m x n) 2-d numpy array that are just 0's and 1's. I want to "smooth" the array by running, for example, a 3x3 kernel over the array and taking the majority value within that kernel. For values at the edges, I would just ignore the "missing" values.

For example, let's say the array looked like

import numpy as np

x = np.array([[1, 0, 0, 0, 0, 0, 1, 0],
              [0, 0, 0, 0, 0, 0, 0, 0],
              [0, 0, 1, 1, 1, 1, 1, 0],
              [0, 0, 1, 1, 0, 1, 1, 0],
              [0, 0, 1, 0, 1, 1, 1, 0],
              [0, 1, 1, 1, 1, 0, 1, 0],
              [0, 0, 1, 1, 1, 1, 1, 0],
              [0, 0, 0, 0, 0, 0, 0, 0]])

Starting at the top left "1", a 3 x 3 kernel centered at the first top left element, would be missing the first row and first column. The way I want to treat that is just ignore that and consider the remaining 2 x 2 matrix:

1 0
0 0

In this case, the majority value is 0, so set that element to 0. Repeating this for all elements, the resulting 2-d array I would want is:

0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 1 1 1 1 0
0 0 1 1 1 1 1 0
0 0 1 1 1 1 1 0
0 0 1 1 1 1 1 0
0 0 1 1 1 1 0 0
0 0 0 0 0 0 0 0

How do I accomplish this?

回答1:

You can use skimage.filters.rank.majority to assign to each value the most occuring one within its neighborhood. The 3x3 kernel can be defined using skimage.morphology.square:

from skimage.filters.rank import majority
from skimage.morphology import square

majority(x.astype('uint8'), square(3))

array([[0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 1, 1, 0],
       [0, 0, 1, 1, 1, 1, 1, 0],
       [0, 0, 1, 1, 1, 1, 1, 0],
       [0, 0, 1, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)

Note: You'll need the latest stable version of scikit-image for majority. More here

回答2:

I ended up doing something like this (which is based off of How do I use scipy.ndimage.filters.gereric_filter?):

import scipy.ndimage.filters
import scipy.stats as scs


def filter_most_common_element(a, w_k=np.ones(shape=(3, 3))):
    """
    Creating a function for scipy.ndimage.generic_filter.

    See https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.generic_filter.html for more information
    on generic filters. 

    This filter takes a kernel of np.ones() to find the most common element in the array.
    Based off of https://stackoverflow.com/questions/61197364/smoothing-a-2-d-numpy-array-with-a-kernel
    """
    a = a.reshape(w_k.shape)
    a = np.multiply(a, w_k)

    # See https://docs.scipy.org/doc/scipy-0.19.0/reference/generated/scipy.stats.mode.html
    most_common_element = scs.mode(a, axis=None)[0][0]
    return most_common_element

x = np.array([[1, 0, 0, 0, 0, 0, 1, 0],
              [0, 0, 0, 0, 0, 0, 0, 0],
              [0, 0, 1, 1, 1, 1, 1, 0],
              [0, 0, 1, 1, 0, 1, 1, 0],
              [0, 0, 1, 0, 1, 1, 1, 0],
              [0, 1, 1, 1, 1, 0, 1, 0],
              [0, 0, 1, 1, 1, 1, 1, 0],
              [0, 0, 0, 0, 0, 0, 0, 0]])

out = scipy.ndimage.filters.generic_filter(x, filter_most_common_element, footprint=np.ones((3,3)),mode='constant',cval=0.0)

out

array([[0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 1, 1, 0],
       [0, 0, 1, 1, 1, 1, 1, 0],
       [0, 0, 1, 1, 1, 1, 1, 0],
       [0, 0, 1, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0]])

来源：https://stackoverflow.com/questions/61197364/smoothing-a-2-d-numpy-array-with-a-kernel

标签

python

numpy

convolution