Python 在三维矩阵中并行查找邻域

我试图在Python中实现一种称为滞后的算法。我会尽量简单地解释

首先，将一个具有2个阈值（t1和t2以及t2>t1）的分割过程应用于一个填充了0到255个整数的3D矩阵。这将生成一个3D矩阵，其中所有t2的值都更改为255

当每个值等于0时，表示黑色、255白色和所有其他灰色，第二步可以用以下伪代码解释：

do while grey voxels remain:
   for any single grey voxel having non-grey neighbors:
      if it has more white neighbors than black neighbors:
         paint it in white (i.e. 255)
      else:
         paint it in black (i.e. 0)

简言之，我们可以通过在每个灰色体素上循环（是的，这可以通过只检查具有白色/黑色邻域的灰色体素）并检查其邻域（26连通）来改进分割后的数据。如果存在大多数白色邻居，体素将变为白色；如果存在大多数黑色邻居，体素将变为黑色；否则体素将保持灰色。我们经历了这个循环，直到无法做出进一步的更改（此时我们进入下一步，通过掷硬币做出决定）

这是针对701x900x719矩阵（x，y，z）和任意t1=90，t2=150的该算法的顺序实现：

def get_neighbors(index):
    for relative_index in product((-1, 0, 1), repeat=3):
        if not all(relative_element == 0 for relative_element in relative_index):  # check for (0,0,0)
            yield tuple(element + relative_element for element, relative_element in zip(index, relative_index))

def hysteresis(arr, t1=90, t2=150):
    aux_arr = arr.copy()  # a copy of the matrix to which we'll write
    grey_voxels, current_grey_voxels = 0, 0  # variables to hold grey voxel indices
    grey_amount, current_grey_amount = 0, -1  # counters to reference the amount of grey voxels to process

    while True:
        if grey_amount != current_grey_amount:
            grey_voxels = current_grey_voxels if current_grey_amount != -1 \
                else np.nonzero((aux_arr >= t1) & (aux_arr <= t2))  # grey voxel indices
            grey_amount = len(grey_voxels[0])  # amount of voxels to process
            for voxel in zip(*grey_voxels):
                black_counter = white_counter = grey_counter = number_neighbors = 0
                neighbors = get_neighbors(voxel)
                for neighbor in neighbors:
                    z, x, y = neighbor
                    if not any(element == -1 for element in neighbor) \
                            and z < 719 \
                            and x < 701 \
                            and y < 900:
                        aux = arr[neighbor]
                        number_neighbors += 1
                        if aux == 255:
                            white_counter += 1
                        elif aux == 0:
                            black_counter += 1
                        else:
                            grey_counter += 1
                if grey_counter < ceil(number_neighbors / 2):
                    if white_counter > black_counter:
                        aux_arr[voxel] = 255
                    elif black_counter > white_counter:
                        aux_arr[voxel] = 0
            current_grey_voxels = np.nonzero((aux_arr >= t1) & (aux_arr <= t2))
            current_grey_amount = len(current_grey_voxels[0])
        else:
            break

    return aux_arr

def get_邻居（索引）：
对于产品中的相对_指数（-1,0,1），重复=3）：
如果不是全部（相对_索引中的相对_元素==0）：#检查（0,0,0）
产出元组（元素+元素的相对元素，zip中的相对元素（索引，相对索引））
def滞后（arr，t1=90，t2=150）：
aux_arr=arr.copy（）#我们将写入的矩阵的副本
灰色体素，当前灰色体素=0，0变量，用于保存灰色体素索引
灰色量，当前灰色量=0，-1#计数器，用于参考要处理的灰色体素量
尽管如此：
如果灰色数量！=当前金额：
灰度体素=当前灰度体素，如果当前灰度体素数量！=-1 \
else np.非零（（辅助阵列>=t1）和（辅助阵列黑色）计数器：
aux_arr[体素]=255
elif黑色计数器>白色计数器：
aux_arr[体素]=0
当前灰度体素=np。非零（（辅助arr>=t1）和（辅助arr）