Image Convolution with callback function in python

Question

我想遍历 python 中二进制图像的像素，并根据周围的像素邻域设置像素值。 与卷积类似，但我想创建一种使用自定义 function 设置中心像素值的方法，而不是将中心像素设置为邻域算术平均值的普通卷积。

本质上，我想创建一个 function 来执行以下操作：

def convolve(img, conv_function = lambda subImg: np.mean(subImg)):
  newImage = emptyImage
  for nxn_window in img:
    newImage[center_pixel] = conv_function(nxn_window)
  return newImage

目前我有一个解决方案，但它很慢：

#B is the structuing array or convolution window/kernel
def convolve(func):
  def wrapper(img, B):
    #get dimensions of img
    length, width = len(img), len(img[0])

    #half width and length of dimensions
    hw = (int)((len(B) - 1) / 2)
    hh = (int)((len(B[0]) - 1) / 2)

    #convert to npArray for fast operations
    B = np.array(B)

    #initialize empty return image
    retVal = np.zeros([length, width])

    #start loop over the values where the convolution window has a neighborhood 
    for row in range(hh, length - hh):
        for pixel in range(hw, width - hw):
            #window as subarray of pixels
            window = [arr[pixel-hh:pixel+hh+1]
                           for arr in img[row-hw:row+hw+1]]
            retVal[row][pixel] = func(window, B)

    return retVal
  return wrapper

然后用这个 function 作为装饰器

# dilation
@convolve
def __add__(img, B):
    return np.mean(np.logical_and(img, B)) > 0

# erosion
@convolve
def __sub__(img, B):
    return np.mean(np.logical_and(img, B)) == 1

是否有提供这种类型的 function 的库，或者是否有更好的方法可以遍历图像？

Answer 1

这是一个想法：为每个像素分配一个数组及其邻域，然后简单地将您的自定义 function 应用于扩展图像。 它会很快但会消耗更多 memory（memory 的倍数；如果您的 B.shape 是 (3, 3) 那么您将需要 9 倍的内存）。 尝试这个：

import numpy as np

def convolve2(func):
    def conv(image, kernel):
        """ Apply given filter on an image """
        k = kernel.shape[0]  # which is assumed equal to kernel.shape[1]
        width = k//2  # note that width == 1 for k == 3 but also width == 1 for k == 2
        a = framed(image, width)  # create a frame around an image to compensate for kernel overlap when shifting
        b = np.empty(image.shape + kernel.shape)  # add two more dimensions for each pixel's neighbourhood
        di, dj = image.shape[:2]  # will be used as delta for slicing
        # add the neighbourhood ('kernel size') to each pixel in preparation for the final step 
        # in other words: slide the image along the kernel rather than sliding the kernel along the image
        for i in range(k):
            for j in range(k):
                b[..., i, j] = a[i:i+di, j:j+dj]
        # apply the desired function
        return func(b, kernel)
    return conv
    

def framed(image, width):
    a = np.zeros(np.array(image.shape) + [2 * width, 2 * width])  # only add the frame to the first two dimensions
    a[width:-width, width:-width] = image  # place the image centered inside the frame
    return a

我使用了 512x512 像素的灰度图像和 3x3 的滤镜进行测试：

embossing_kernel = np.array([
    [-2, -1, 0],
    [-1, 1, 1],
    [0, 1, 2]
])

@convolve2
def filter2(img, B):
    return np.sum(img * B, axis=(2,3))

@convolve2
def __add2__(img, B):
    return np.mean(np.logical_and(img, B), axis=(2,3)) > 0

# image_gray is a 2D grayscale image (not color/RGB)
b = filter2(image_gray, embossing_kernel)

为了与我使用的卷积进行比较：

@convolve
def filter(img, B):
    return np.sum(img * B)

@convolve
def __add__(img, B):
    return np.mean(np.logical_and(img, B)) > 0

b = filter2(image_gray, embossing_kernel)

convolve的时间是 4.3 s， convolve2在我的机器上是 0.05 s。

在我的例子中，自定义 function 需要指定要操作的轴，即保存邻域数据的附加维度。 也许斧头也可以避免，但我没试过。

注意：这适用于 2D 图像（灰度）（正如您询问的二进制图像），但可以轻松扩展到 3D（彩色）图像。 在您的情况下，您可能会摆脱框架（或用零或一个填充它，例如，在重复应用该功能的情况下）。

如果 memory 是一个问题，您可能想要适应我在此处发布的卷积的快速实现： https://stackoverflow.com/a/74288118/20188124 。