我对python很陌生，并且在将算法的一部分对准化时遇到了问题。 考虑一个输入图像，该图像需要在像素级别上以某种方式成为阈值。由于该算法仅考虑特定区域来计算阈值，因此我想在单独的线程/进程中运行图像的每个块。这就是我被困住的地方。我找不到这些线程在同一图像上工作的方法，或者如何将结果合并到新图像中。 由于我通常来自Java世界，因此我通常会与不想干扰其他线程的问题作斗争。因此，我只是尝试将图像传递给每个进程。
def thresholding(img):
stepSize = int(img.shape[0] / 10)
futures = []
with ProcessPoolExecutor(max_workers=4) as e:
for y in range(0, img.shape[0], stepSize):
for x in range(0, img.shape[1], stepSize):
futures.append(e.submit(thresholdThread, y, x, img))
concurrent.futures.wait(futures)
return img
def thresholdThread(y, x, img):
window_size = int(img.shape[0] / 10)
window_shape = (window_size, window_size)
window = img[y:y + window_shape[1], x:x + window_shape[0]]
upper_bound, lower_bound, avg = getThresholdBounds(window, 0.6)
for y_2 in range(0, window.shape[0]):
for x_2 in range(0, window.shape[1]):
tmp = img[y + y_2, x + x_2]
img[y + y_2, x + x_2] = tmp if (tmp >= upper_bound or tmp <= lower_bound) else avg
return str(avg)
据我了解，python 这是行不通的，因为每个进程都有自己的img副本。但是由于 img 是来自 numpy 的浮点数类型，我不知道我是否以及如何使用此处描述的共享对象。
仅供参考：我正在使用python 3.6.9。我确实知道 3.7 已经发布，但是再次安装所有东西以便我可以使用 spyder 和 openCV 并不是那么容易。
您没有利用任何可以显着减少处理时间的 Numpy 矢量化技术。我假设这就是您要对图像的窗口/块进行多进程操作的原因 - 我不知道 Docker 是什么，所以我不知道这是否是您多进程方法中的一个因素。
这是一个矢量化解决方案，但需要注意的是，它可能从操作中排除了底部和右侧边缘像素。 如果这是不可接受的，则无需进一步阅读。
示例中右边缘和下边缘窗口的大小很可能与其他窗口不同。看起来你任意选择了十个因子来分割你的图像 - 如果十是一个任意选择，你可以很容易地优化底部和右侧边缘增量 - 我将在答案末尾发布该功能。
图像需要重新塑造成补丁以矢量化操作。我sklearn.feature_extraction.image._extract_patches使用了sklearn函数，因为它很方便并且允许创建非重叠补丁(这似乎是您想要的(。请注意下划线前缀 - 这曾经是一个公开的函数，image.extract_patches，但已被弃用。该函数使用numpy.lib.stride_tricks.as_strided- 可能只reshape数组，但我还没有尝试过。
设置
import numpy as np
from sklearn.feature_extraction import image
img = np.arange(4864*3546*3).reshape(4864,3546,3)
# all shape dimensions in the following example derived from img's shape
定义图块大小(请参阅下面的opt_size(并重塑图像。
hsize, h_remainder, h_windows = opt_size(img.shape[0])
wsize, w_remainder, w_windows = opt_size(img.shape[1])
# rgb - not designed for rgba
if img.ndim == 3:
patch_shape = (hsize,wsize,img.shape[-1])
else:
patch_shape = (hsize,wsize)
patches = image._extract_patches(img,patch_shape=patch_shape,
extraction_step=patch_shape)
patches = patches.squeeze()
patches是原始数组的视图，对它的更改将在原始数组中看到。它的形状是(8, 9, 608, 394, 3)有8x9，(608,394,3)窗户/补丁。
查找每个面块的上限和下限;将每个像素与其面块的边界进行比较;提取位于其边界之间且需要更改的每个像素的索引。
lower = patches.min((2,3)) * .6
lower = lower[...,None,None,:]
upper = patches.max((2,3)) * .6
upper = upper[...,None,None,:]
indices = np.logical_and(patches > lower, patches < upper).nonzero()
找到每个面块的平均值，然后更改所需的像素值，
avg = patches.mean((2,3)) # shape (8,9,3)
patches[indices] = avg[indices[0],indices[1],indices[-1]]
一切组合在一起的功能
def g(img, opt_shape=False):
original_shape = img.shape
# determine patch shape
if opt_shape:
hsize, h_remainder, h_windows = opt_size(img.shape[0])
wsize, w_remainder, w_windows = opt_size(img.shape[1])
else:
patch_size = img.shape[0] // 10
hsize, wsize = patch_size,patch_size
# constraint checking here(?) for
# number of windows,
# orphaned pixels
if img.ndim == 3:
patch_shape = (hsize,wsize,img.shape[-1])
else:
patch_shape = (hsize,wsize)
patches = image._extract_patches(img,patch_shape=patch_shape,
extraction_step=patch_shape)
#squeeze??
patches = patches.squeeze()
#assume color (h,w,3)
lower = patches.min((2,3)) * .6
lower = lower[...,None,None,:]
upper = patches.max((2,3)) * .6
upper = upper[...,None,None,:]
indices = np.logical_and(patches > lower, patches < upper).nonzero()
avg = patches.mean((2,3))
## del lower, upper, mask
patches[indices] = avg[indices[0],indices[1],indices[-1]]
def opt_size(size):
'''Maximize number of windows, minimize loss at the edge
size -> int
Number of "windows" constrained to 4-10
Returns (int,int,int)
size in pixels,
loss in pixels,
number of windows
'''
size = [(divmod(size,n),n) for n in range(4,11)]
n_windows = 0
remainder = 99
patch_size = 0
for ((p,r),n) in size:
if r <= remainder and n > n_windows:
remainder = r
n_windows = n
patch_size = p
return patch_size, remainder, n_windows
针对您的幼稚过程进行了测试 - 我希望我正确执行了它。与 4864x3546 彩色图像相比，大约提高了 35 倍。 可能会有进一步的优化，也许一些向导会发表评论。
使用块因子 10 进行测试：
#yours
def f(img):
window_size = int(img.shape[0] / 10)
window_shape = (window_size, window_size)
for y in range(0, img.shape[0], window_size):
for x in range(0, img.shape[1], window_size):
window = img[y:y + window_shape[1], x:x + window_shape[0]]
upper_bound = window.max((0,1)) * .6
lower_bound = window.min((0,1)) * .6
avg = window.mean((0,1))
for y_2 in range(0, window.shape[0]):
for x_2 in range(0, window.shape[1]):
tmp = img[y + y_2, x + x_2]
indices = np.logical_and(tmp < upper_bound,tmp > lower_bound)
tmp[indices] = avg[indices]
img0 = np.arange(4864*3546*3).reshape(4864,3546,3)
#get everything the same shape
size = img0.shape[0] // 10
h,w = size*10, size * (img0.shape[1]//size)
img1 = img0[:h,:w].copy()
img2 = img1.copy()
assert np.all(np.logical_and(img1==img2,img2==img0[:h,:w]))
f(img1) # ~44 seconds
g(img2) # ~1.2 seconds
assert(np.all(img1==img2))
if not np.all(img2==img0[:h,:w]):
pass
else:
raise Exception('did not change')
indices是一个索引数组。 它是一个数组元组，每个维度一个。indices[0][0],indices[1][0],indices[2][0]将是 3D 数组中一个元素的索引。完整的元组可用于索引数组的多个元素。
>>> indices
(array([1, 0, 2]), array([1, 0, 0]), array([1, 1, 1]))
>>> list(zip(*indices))
[(1, 1, 1), (0, 0, 1), (2, 0, 1)]
>>> arr = np.arange(27).reshape(3,3,3)
>>> arr[1,1,1], arr[0,0,1],arr[2,0,2]
(13, 1, 20)
>>> arr[indices]
array([13, 1, 19])
# arr[indices] <-> np.array([arr[1,1,1],arr[0,0,1],arr[2,0,1]])
np.logical_and(patches > lower, patches < upper)返回一个布尔数组，nonzero()返回值为True的所有元素的索引。