Python：二进制二维数组中的轮廓

Question

I would like to in a simplest possible way (without million checking of boundaries of image) get the contour, with the width of n pixels going into the positive area, from the binary 2D array.

Example:

img = np.array([
               [0, 0, 0, 1, 1, 1, 1, 1, 0],
               [0, 1, 1, 1, 1, 1, 1, 1, 1],
               [0, 1, 1, 1, 0, 0, 0, 0, 0],
               ])

For calling with eg width = 1. Pixels are positive if img[i,j]==1 and any neighbour (img[i+1,j], img[i-1,j], img[i,j-1], img[i,j+1]) is 0.

contour1 = get_countor(img, width = 1)
contour1 = ([
               [0, 0, 0, 1, 0, 0, 0, 1, 0],
               [0, 1, 1, 0, 1, 1, 1, 1, 1],
               [0, 1, 0, 1, 0, 0, 0, 0, 0],
            ])

or calling with eg width = 2. All pixels from width = 1 are positive as well as the ones that satisfy img[i, j] == 1 and for which with 2 indices away (euclidian distance) exists a pixel with value 0.

contour2 = get_countor(img, width = 2)
contour2 = ([
               [0, 0, 0, 1, 1, 1, 1, 1, 0],
               [0, 1, 1, 1, 1, 1, 1, 1, 1],
               [0, 1, 1, 1, 0, 0, 0, 0, 0],
            ]) 

Thank you for your help.

Answer 1

Not the exact answer for this question, but sharing a simple way to draw contours in images; for folks that are just looking for that.

from PIL import Image
from PIL import ImageFilter
import numpy as np


def draw_contour(img, mask, contour_width, contour_color):
    """Draw contour on a pillow image from a numpy 2D mask."""
    contour = Image.fromarray(mask)
    contour = contour.resize(img.size)
    contour = contour.filter(ImageFilter.FIND_EDGES)
    contour = np.array(contour)

    # make sure borders are not drawn
    contour[[0, -1], :] = 0
    contour[:, [0, -1]] = 0

    # use a gaussian to define the contour width
    radius = contour_width / 10
    contour = Image.fromarray(contour)
    contour = contour.filter(ImageFilter.GaussianBlur(radius=radius))
    contour = np.array(contour) > 0
    contour = np.dstack((contour, contour, contour))

    # color the contour
    ret = np.array(img) * np.invert(contour)
    if contour_color != 'black':
        color = Image.new(img.mode, img.size, contour_color)
        ret += np.array(color) * contour

    return Image.fromarray(ret)

Check this test output:

I wrote this solution whilst working for this PR .

Answer 2

import numpy as np
import pandas as pd
import random

df = pd.DataFrame([], columns=[0,1,2,3,4,5,6,7,8,9])

for i in np.arange(10):
    df.loc[len(df)] = np.random.randint(0,2,10)

df = df.astype(bool)

contour = df & ((df-df.shift(-1, axis=0).fillna(1))|(df-df.shift(1,axis=0).fillna(1))|(df-df.shift(-1,axis=1).fillna(1))|(df-df.shift(1,axis=1).fillna(1)))

---

outputs:

df:

contour:

hope this helps

Answer 3

I think what you're looking for is scipy.misc.imfilter(img, "find_edges") .

Given a binary array img this will produce an array with 0 and 255 , so you'll need to divide by 255. As I see it, the filter with width=2 is obtained by applying the filter with width=1 another time, so at the end your function could look like

def get_countor(img, width = 1):
    for i in range(width):
        img = scipy.misc.imfilter(img, "find_edges")/255
    return img