特定点的图像卷积
Image convolution at specific points
scipy（或其他类似的库）是否有一种方法可以仅在某些所需的点处使用给定的内核对图像进行卷积？
我正在寻找类似的东西：
ndimage.convolve(image, kernel, mask=mask)
其中mask包含True（或1）每当需要应用内核时，False（或0）否则。
编辑：示例 python 代码执行我正在尝试执行的操作（但不比使用 scipy 的整个图像卷积更快）：
def kernel_responses(im, kernel, mask=None, flatten=True):
if mask is None:
mask = np.ones(im.shape[:2], dtype=np.bool)
ks = kernel.shape[0]//2
data = np.pad(im, ks, mode='reflect')
y, x = np.where(mask)
responses = np.empty(y.shape[0], float)
for k, (i, j) in enumerate(zip(y, x)):
responses[k] = (data[i:i+ks*2+1, j:j+ks*2+1] * kernel).sum()
if flatten:
return responses
result = np.zeros(im.shape[:2], dtype=float)
result[y, x] = responses
return result
上面的代码在 wrap 边界条件下完成了工作，但是内部循环在 python 中，因此很慢。我想知道是否已经在 scipy/opencv/skimage.
中实现了一些更快的东西
我不知道有任何函数可以完全满足您的要求。如果您没有提供要卷积的点掩码，而是提供了一个点列表，例如。 [(7, 7), (100, 100)] 那么它可能就像获取适当的图像补丁一样简单（比如与您提供的内核大小相同），对图像补丁和内核进行卷积，然后插入回原始图像。
这是一个编码示例，希望它足够接近您可以轻松修改：
[编辑：我注意到我在填充和补丁算法中有几个错误。以前，您无法与边界上的一个点（比如 (0, 0)）进行卷积，我将填充加倍，修正了一些算法，现在一切都很好。]
import cv2
import numpy as np
from scipy import ndimage
from matplotlib import pyplot as plt
def image_convolve_mask(image, list_points, kernel):
# list_points ex. [(7, 7), (100, 100)]
# assuming kernels of dims 2n+1 x 2n+1
rows, cols = image.shape
k_rows, k_cols = kernel.shape
r_pad = int(k_rows/2)
c_pad = int(k_cols/2)
# zero-pad the image in case desired point is close to border
padded_image = np.zeros((rows + 2*k_rows, cols + 2*k_cols))
# set the original image in the center
padded_image[k_rows: rows + k_rows, k_cols: cols + k_cols] = image
# should you prefer to use np.pad:
# padded_image = np.pad(image, (k_rows, k_cols), 'constant', constant_values=(0, 0))
for p in list_points:
# extract pertinent patch from image
# arbitrarily choosing the patch as same size as the kernel; change as needed
patch = padded_image[p[0] + k_rows - r_pad: p[0] + 2*k_rows - r_pad, p[1] + k_cols - c_pad: p[1] + 2*k_cols - c_pad]
# here use whatever function for convolution; I prefer cv2filter2D()
# commented out is another option
# conv = ndimage.convolve(patch, kernel, mode='constant', cval=0.0)
conv = cv2.filter2D(patch, -1, kernel)
# set the convolved patch back in to the image
padded_image[p[0] + k_rows - r_pad: p[0] + 2*k_rows - r_pad, p[1] + k_cols - c_pad: p[1] + 2*k_cols - c_pad] = conv
return padded_image[k_rows: rows + k_rows, k_cols: cols + k_cols]
现在在图像上试用：
penguins = cv2.imread('penguins.png', 0)
kernel = np.ones((5,5),np.float32)/25
# kernel = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], np.float32)
conv_image = image_convolve_mask(penguins, [(7, 7), (36, 192), (48, 207)], kernel)
plt.imshow(conv_image, cmap = 'gray', interpolation = 'bicubic')
plt.xticks([]), plt.yticks([])
plt.show()
我应用了一个 5x5 的盒子平滑器，并不能真正看到像素 (7, 7) 周围有任何变化，但我选择了另外两个点作为最左边的两个企鹅喙的尖端。所以你可以看到平滑的补丁。
这是一张 lena512 图像，有 21 个卷积点（时间：0.006177 秒）。
[编辑 2：使用掩码生成行、列元组列表以输入函数的示例。]
mask = np.eye(512)
k = np.ones((25, 25), np.float32)/625
list_mask = zip(np.where(mask==1)[0], np.where(mask==1)[1])
tic = time.time()
conv_image = image_convolve_mask(lena, list_mask, k)
print 'time: ', time.time()-tic # 0.08136 sec
您可以使用以下代码片段。如果你的掩码足够密集，它可能不会那么低效。
def mask_conv(img, kernel, mask):
out = filters.convolve(img, kernel)
return np.where(mask, out, img)
一些示例代码
from skimage import data, draw, io, color
from scipy.ndimage import filters
import numpy as np
def mask_conv(img, kernel, mask):
out = filters.convolve(img, kernel)
return np.where(mask, out, img)
img = data.camera()
mask = np.zeros_like(img, dtype=np.bool)
kernel = np.ones((9,9))/100
circle = draw.circle(300, 350, 100)
mask[circle] = True
out = mask_conv(img, kernel, mask)
io.imshow(out)
io.show()
我知道我是在回应我自己的回答，我希望下面的代码有进一步的改进，或者它可能对其他用户有用。
下面的代码是 cython/python 实现：
PYTHON:
def py_convolve(im, kernel, points):
ks = kernel.shape[0]//2
data = np.pad(im, ks, mode='constant', constant_values=0)
return cy_convolve(data, kernel, points)
赛通：
import numpy as np
cimport cython
@cython.boundscheck(False)
def cy_convolve(unsigned char[:, ::1] im, double[:, ::1] kernel, Py_ssize_t[:, ::1] points):
cdef Py_ssize_t i, j, y, x, n, ks = kernel.shape[0]
cdef Py_ssize_t npoints = points.shape[0]
cdef double[::1] responses = np.zeros(npoints, dtype='f8')
for n in range(npoints):
y = points[n, 0]
x = points[n, 1]
for i in range(ks):
for j in range(ks):
responses[n] += im[y+i, x+j] * kernel[i, j]
return np.asarray(responses)
与其他方法的比较
下表显示了4种方法的评价：
- 题中我的python方法
- 来自@Vighnesh Birodkar 的方法
- 与scipy
完成图像卷积
- 我的 python/cython 实现在此 post
每一行按顺序对应于 3 个不同图像的方法（coins、camera 和 lena 分别来自 skimage.data）和每一列对应于计算内核响应的不同点数（以百分比表示 "calculate response in x% of the points of the image"）。
为了计算少于 50% 个点的内核响应，我的实现比对整个图像进行卷积更快，但在其他方面并不快..
编辑：用于测试的内核 windows 是 5x5 uniform windows (np.ones((5,5))).
['303x384'] 1% 2% 5% 10% 20% 50%
1 4.97 9.58 24.32 48.28 100.39 245.77
2 7.60 15.09 37.42 75.17 150.09 375.60
3 3.05 2.99 3.04 2.88 2.96 2.98
4 0.17 0.22 0.38 0.60 1.10 2.49
['512x512'] 1% 2% 5% 10% 20% 50%
1 10.68 21.87 55.47 109.16 223.58 543.73
2 17.90 34.59 86.02 171.20 345.46 858.24
3 6.52 6.53 6.74 6.63 6.43 6.60
4 0.31 0.43 0.78 1.34 2.73 6.82
['512x512'] 1% 2% 5% 10% 20% 50%
1 13.21 21.45 54.98 110.80 217.11 554.96
2 19.55 34.78 87.09 172.33 344.58 893.02
3 6.87 6.82 7.00 6.60 6.64 7.71
4 0.35 0.47 0.87 1.57 2.47 6.07
注意：时间在 ms.
scipy（或其他类似的库）是否有一种方法可以仅在某些所需的点处使用给定的内核对图像进行卷积？
我正在寻找类似的东西：
ndimage.convolve(image, kernel, mask=mask)
其中mask包含True（或1）每当需要应用内核时，False（或0）否则。
编辑：示例 python 代码执行我正在尝试执行的操作（但不比使用 scipy 的整个图像卷积更快）：
def kernel_responses(im, kernel, mask=None, flatten=True):
if mask is None:
mask = np.ones(im.shape[:2], dtype=np.bool)
ks = kernel.shape[0]//2
data = np.pad(im, ks, mode='reflect')
y, x = np.where(mask)
responses = np.empty(y.shape[0], float)
for k, (i, j) in enumerate(zip(y, x)):
responses[k] = (data[i:i+ks*2+1, j:j+ks*2+1] * kernel).sum()
if flatten:
return responses
result = np.zeros(im.shape[:2], dtype=float)
result[y, x] = responses
return result
上面的代码在 wrap 边界条件下完成了工作，但是内部循环在 python 中，因此很慢。我想知道是否已经在 scipy/opencv/skimage.
我不知道有任何函数可以完全满足您的要求。如果您没有提供要卷积的点掩码，而是提供了一个点列表，例如。 [(7, 7), (100, 100)] 那么它可能就像获取适当的图像补丁一样简单（比如与您提供的内核大小相同），对图像补丁和内核进行卷积，然后插入回原始图像。
这是一个编码示例，希望它足够接近您可以轻松修改：
[编辑：我注意到我在填充和补丁算法中有几个错误。以前，您无法与边界上的一个点（比如 (0, 0)）进行卷积，我将填充加倍，修正了一些算法，现在一切都很好。]
import cv2
import numpy as np
from scipy import ndimage
from matplotlib import pyplot as plt
def image_convolve_mask(image, list_points, kernel):
# list_points ex. [(7, 7), (100, 100)]
# assuming kernels of dims 2n+1 x 2n+1
rows, cols = image.shape
k_rows, k_cols = kernel.shape
r_pad = int(k_rows/2)
c_pad = int(k_cols/2)
# zero-pad the image in case desired point is close to border
padded_image = np.zeros((rows + 2*k_rows, cols + 2*k_cols))
# set the original image in the center
padded_image[k_rows: rows + k_rows, k_cols: cols + k_cols] = image
# should you prefer to use np.pad:
# padded_image = np.pad(image, (k_rows, k_cols), 'constant', constant_values=(0, 0))
for p in list_points:
# extract pertinent patch from image
# arbitrarily choosing the patch as same size as the kernel; change as needed
patch = padded_image[p[0] + k_rows - r_pad: p[0] + 2*k_rows - r_pad, p[1] + k_cols - c_pad: p[1] + 2*k_cols - c_pad]
# here use whatever function for convolution; I prefer cv2filter2D()
# commented out is another option
# conv = ndimage.convolve(patch, kernel, mode='constant', cval=0.0)
conv = cv2.filter2D(patch, -1, kernel)
# set the convolved patch back in to the image
padded_image[p[0] + k_rows - r_pad: p[0] + 2*k_rows - r_pad, p[1] + k_cols - c_pad: p[1] + 2*k_cols - c_pad] = conv
return padded_image[k_rows: rows + k_rows, k_cols: cols + k_cols]
现在在图像上试用：
penguins = cv2.imread('penguins.png', 0)
kernel = np.ones((5,5),np.float32)/25
# kernel = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], np.float32)
conv_image = image_convolve_mask(penguins, [(7, 7), (36, 192), (48, 207)], kernel)
plt.imshow(conv_image, cmap = 'gray', interpolation = 'bicubic')
plt.xticks([]), plt.yticks([])
plt.show()
我应用了一个 5x5 的盒子平滑器，并不能真正看到像素 (7, 7) 周围有任何变化，但我选择了另外两个点作为最左边的两个企鹅喙的尖端。所以你可以看到平滑的补丁。
这是一张 lena512 图像，有 21 个卷积点（时间：0.006177 秒）。
[编辑 2：使用掩码生成行、列元组列表以输入函数的示例。]
mask = np.eye(512)
k = np.ones((25, 25), np.float32)/625
list_mask = zip(np.where(mask==1)[0], np.where(mask==1)[1])
tic = time.time()
conv_image = image_convolve_mask(lena, list_mask, k)
print 'time: ', time.time()-tic # 0.08136 sec
您可以使用以下代码片段。如果你的掩码足够密集，它可能不会那么低效。
def mask_conv(img, kernel, mask):
out = filters.convolve(img, kernel)
return np.where(mask, out, img)
一些示例代码
from skimage import data, draw, io, color
from scipy.ndimage import filters
import numpy as np
def mask_conv(img, kernel, mask):
out = filters.convolve(img, kernel)
return np.where(mask, out, img)
img = data.camera()
mask = np.zeros_like(img, dtype=np.bool)
kernel = np.ones((9,9))/100
circle = draw.circle(300, 350, 100)
mask[circle] = True
out = mask_conv(img, kernel, mask)
io.imshow(out)
io.show()
我知道我是在回应我自己的回答，我希望下面的代码有进一步的改进，或者它可能对其他用户有用。
下面的代码是 cython/python 实现：
PYTHON:
def py_convolve(im, kernel, points):
ks = kernel.shape[0]//2
data = np.pad(im, ks, mode='constant', constant_values=0)
return cy_convolve(data, kernel, points)
赛通：
import numpy as np
cimport cython
@cython.boundscheck(False)
def cy_convolve(unsigned char[:, ::1] im, double[:, ::1] kernel, Py_ssize_t[:, ::1] points):
cdef Py_ssize_t i, j, y, x, n, ks = kernel.shape[0]
cdef Py_ssize_t npoints = points.shape[0]
cdef double[::1] responses = np.zeros(npoints, dtype='f8')
for n in range(npoints):
y = points[n, 0]
x = points[n, 1]
for i in range(ks):
for j in range(ks):
responses[n] += im[y+i, x+j] * kernel[i, j]
return np.asarray(responses)
与其他方法的比较
下表显示了4种方法的评价：
- 题中我的python方法
- 来自@Vighnesh Birodkar 的方法
- 与scipy 完成图像卷积
- 我的 python/cython 实现在此 post
每一行按顺序对应于 3 个不同图像的方法（coins、camera 和 lena 分别来自 skimage.data）和每一列对应于计算内核响应的不同点数（以百分比表示 "calculate response in x% of the points of the image"）。
为了计算少于 50% 个点的内核响应，我的实现比对整个图像进行卷积更快，但在其他方面并不快..
编辑：用于测试的内核 windows 是 5x5 uniform windows (np.ones((5,5))).
['303x384'] 1% 2% 5% 10% 20% 50%
1 4.97 9.58 24.32 48.28 100.39 245.77
2 7.60 15.09 37.42 75.17 150.09 375.60
3 3.05 2.99 3.04 2.88 2.96 2.98
4 0.17 0.22 0.38 0.60 1.10 2.49
['512x512'] 1% 2% 5% 10% 20% 50%
1 10.68 21.87 55.47 109.16 223.58 543.73
2 17.90 34.59 86.02 171.20 345.46 858.24
3 6.52 6.53 6.74 6.63 6.43 6.60
4 0.31 0.43 0.78 1.34 2.73 6.82
['512x512'] 1% 2% 5% 10% 20% 50%
1 13.21 21.45 54.98 110.80 217.11 554.96
2 19.55 34.78 87.09 172.33 344.58 893.02
3 6.87 6.82 7.00 6.60 6.64 7.71
4 0.35 0.47 0.87 1.57 2.47 6.07
注意：时间在 ms.