Python 填充遮罩框架中的孔/块

我想根据某些标准来填补我的蒙面图像中的“漏洞”。我有以下原始

帧

：

接下来，我在这个框架上应用一个遮罩，它给出了被遮罩的

：


现在，我想将帧划分为16x16个块。为了定义
块（x，y）
，我们在垂直和水平方向的第x和第y块中定义了一组像素。
如果块中黑色像素的百分比大于（小于）

而不是

0.5

，则块被定义为

非字段（字段）

。代码如下所示：

def blocked_img(img, x_pixels, y_pixels):
   blocked = img.copy()
   gray = cv2.cvtColor(blocked, cv2.COLOR_BGR2GRAY)

   for x in range(0, blocked.shape[1], x_pixels):
      for y in range(0, blocked.shape[0], y_pixels):
         block = gray[y:y+y_pixels, x:x+x_pixels]
         if (cv2.countNonZero(block) / block.size) < 0.5:
            # non-field
            cv2.rectangle(blocked, (x, y), (x+x_pixels, y+y_pixels), (0,255,255), 2)
         else:
            # field
            break

    return blocked

因此，我使用以下方法调用函数

blocked\u img

：

blocked = blocked_img(masked, 80, 45)     #  divide by 16

输出被阻塞，如下所示：

def blocked_img(img, x_pixels, y_pixels):
   blocked = img.copy()
   gray = cv2.cvtColor(blocked, cv2.COLOR_BGR2GRAY)

   for x in range(0, blocked.shape[1], x_pixels):
      for y in range(0, blocked.shape[0], y_pixels):
         block = gray[y:y+y_pixels, x:x+x_pixels]
         if (cv2.countNonZero(block) / block.size) < 0.5:
            # non-field
            cv2.rectangle(blocked, (x, y), (x+x_pixels, y+y_pixels), (0,255,255), 2)
         else:
            # field
            break

    return blocked

目前，我的代码是这样写的：一旦未达到

0.5阈值

，它就会循环到下一列。可以看出，在右边的列中，这种方法不会产生理想的结果，因为它过早地停止（精确地说是第9、11、12、13、16列）

如果以下两项中的一项已就位，我希望在列中继续循环：

• 如果前一块为非字段且[下一块为非字段或下一块为非字段]，则当前块为非字段
• 如果[previous_previous block为non field或previous block为non field]且下一块为non field，则当前块为non field

重写

   block(x,y) = 1 if [block(x-1,y) = 1 and {block(x+1,y) = 1 or block(x+2,y) = 1}] or [{block(x-2, y) = 1 or block(x-1, y) = 1} and block(x+1, y) = 1]       # where 1 = non-field

---

你知道我如何在代码中包含这个吗？提前谢谢

我建议在你的区块中循环多次。我是这样想的-

def blocked_img(img, x_pixels, y_pixels):
   blocked = img.copy()
   blocks = np.zeros((blocked.shape[1]//x_pixels,blocked.shape[0]//y_pixels)) ##array to keep track of blocks status
   gray = cv2.cvtColor(blocked, cv2.COLOR_BGR2GRAY)
   prev_num_blocks = np.sum(blocks)
   for x in range(0, blocked.shape[1], x_pixels):
      for y in range(0, blocked.shape[0], y_pixels):
         block = gray[y:y+y_pixels, x:x+x_pixels]
         if (cv2.countNonZero(block) / block.size) < 0.5:
            # non-field
            cv2.rectangle(blocked, (x, y), (x+x_pixels, y+y_pixels), (0,255,255), 2)
            blocks[x,y] = 1
         else:
            # field
            continue

while (np.sum(blocks)>prev_num_blocks): ##keep going unless no change occurs in prev loop
for x in range(2, blocks.shape[0]-2, x_pixels):
  for y in range(2, blocks.shape[1]-2, y_pixels):
      ###the advance update rule here
      if (.....):
          blocks[x,y]=1
          cv2.rectangle(blocked,...) ##recreate the rect indices using the x,y

return blocked

def blocked_img（img，x_像素，y_像素）：
blocked=img.copy（）
blocks=np.zero（（blocked.shape[1]//x_像素，blocked.shape[0]//y_像素））##数组以跟踪块的状态
灰色=cv2.CVT颜色（分块，cv2.COLOR\u BGR2GRAY）
prev_num_blocks=np.sum（块）
对于范围内的x（0，分块。形状[1]，x_像素）：
对于范围内的y（0，分块。形状[0]，y_像素）：
块=灰色[y:y+y_像素，x:x+x_像素]
如果（cv2.countNonZero（块）/块大小）<0.5：
#非场
cv2.矩形（分块，（x，y），（x+x_像素，y+y_像素），（0255255），2）
块[x，y]=1
其他：
#场
持续
while（np.sum（blocks）>prev_num_blocks）：##除非prev循环中没有变化，否则继续进行
对于范围内的x（2，块形状[0]-2，x_像素）：
对于范围内的y（2，块形状[1]-2，y_像素）：
###这里有提前更新规则
如果（…）：
块[x，y]=1
cv2.矩形（分块，…）35;#使用x，y重新创建矩形索引
回程阻塞

在我看来，while循环是周期1中块状态变为非字段时需要的，它会影响列中它前面的块，因为它成为其他块的下一个块和下一个块

这可能不是最有效的方法，但肯定会收敛并退出while循环。

def blocked\u img（img，x\u像素，y\u像素）：
def blocked_img(img, x_pixels, y_pixels):

   blocked = img.copy()
   gray = cv2.cvtColor(blocked, cv2.COLOR_BGR2GRAY)

   for x in range(0, blocked.shape[1], x_pixels):
      for y in range(0, blocked.shape[0], y_pixels):
         block = gray[y:y+y_pixels, x:x+x_pixels]
         next_block = gray[y+y_pixels:y+(2*y_pixels), x:x+x_pixels]
         next_next_block = gray[y+(2*y_pixels):y+(3*y_pixels), x:x+x_pixels]
         if (cv2.countNonZero(block) / block.size) < 0.75:
            # non-field
            cv2.rectangle(blocked, (x, y), (x+x_pixels, y+y_pixels), (0,0,0), -1)
         else:
            if ((cv2.countNonZero(next_block) / block.size) < 0.75) or ((cv2.countNonZero(next_next_block) / block.size) < 0.75):
               # non-field
               cv2.rectangle(blocked, (x, y), (x+x_pixels, y+y_pixels), (0,0,0), -1)
            else:
               # field
               break
return blocked

blocked=img.copy（）
灰色=cv2.CVT颜色（分块，cv2.COLOR\u BGR2GRAY）
对于范围内的x（0，分块。形状[1]，x_像素）：
对于范围内的y（0，分块。形状[0]，y_像素）：
块=灰色[y:y+y_像素，x:x+x_像素]
下一块=灰色[y+y像素：y+（2*y像素），x:x+x像素]
next_next_block=灰色[y+（2*y_像素）：y+（3*y_像素），x:x+x_像素]
如果（cv2.countNonZero（块）/块大小）<0.75：
#非场
cv2.矩形（分块，（x，y），（x+x_像素，y+y_像素），（0,0,0），-1）
其他：
如果（（cv2.countNonZero（下一个块）/块大小）<0.75）或（（cv2.countNonZero（下一个块）/块大小）<0.75）：
#非场
cv2.矩形（分块，（x，y），（x+x_像素，y+y_像素），（0,0,0），-1）
其他：
#场
打破
回程阻塞

---

我不确定这是否是最快的方法？

嘿，Kartik，谢谢你花时间回答我的问题。理想情况下，我希望使用代码进行实时处理，所以老实说，第二个循环是不可取的！