在二维 NumPy 数组中查找重叠矩形的中心

Question

I have a 2D NumPy array with several potentially overlapping rectangles of variable size. How can I compute the coordinates of the centers of each rectangle? In the attached image, my objective is to compute the coordinates of the red dots.

The array is all zeros, except for the pixels that indicate the rectangle borders, which have value one. In the example image, the black pixels have value zero, and the white pixels have value one.

Answer 1

Search the image row by row, starting from the (0, 0) corner. The first nonzero pixel that you encounter must be the top left corner of a rectangle. Follow the pixels to the right until you hit the top right corner, then down, then left, and finally up again. If you end up at the same pixel as where you started, it was a full rectangle.

Keep track of all pixels that were identified as being part of a rectangle, so that you won't trace them again.

Edit: A requirement for this algorithm is that the corners of different rectangles don't touch each other. With 3-pixel-wide borders, the algorithm will trace the outer pixels of the rectangle. It will also attempt to trace the two 1-pixel wide rectangles inside the outer one, but these are discarded.

import numpy as np
import matplotlib.pyplot as plt

def search_rectangles(img):
    """Search rectangles in 2D boolean image array.
    
    Return: rectangles - array shape (n, 3, 2) for n rectangles.
       rectangles[i, 0, :] represents the top left corner [i, j]
       recnangles[i, 1, :] represents the bottom right corner [i, j]
       rectangles[i, 2, :] represents the center (rounded as integer).
    """
    
    seen = np.zeros_like(img, dtype=np.bool)
    ny, nx = img.shape
    rectangles = []
    
    for i in range(ny):
        for j in range(nx):
            if img[i, j] == 0 or seen[i, j]:
                continue
            # new rectangle pixel; assume it's the top left corner.
            # follow it clockwise.
            didjs = [(0, 1), (1, 0), (0, -1), (-1, 0)]
            ii, jj = i, j
            corners = np.array([[i, j], [-1, -1], [-1, -1]])
            for k, (di, dj) in enumerate(didjs):
                if k == 2:
                    # opposite corner
                    corners[1, :] = [ii, jj]
                while img[ii+di, jj+dj]:
                    ii += di
                    jj += dj
                    seen[ii, jj] = True
            if (ii, jj) == (i, j):
                corners[2, :] = np.around(corners[:2, :].mean(axis=1))
                rectangles.append(corners)
    
    return np.array(rectangles)

def draw_rectangle(img, i0, i1, j0, j1):
    """Draw rectangle with 3px border width."""
    img[i0:i1+1, j0:j0+3] = 1
    img[i0:i1+1, j1-2:j1+1] = 1
    img[i0:i0+3, j0:j1+1] = 1
    img[i1-2:i1+1, j0:j1+1] = 1


# test case
img = np.zeros((100, 150), dtype=np.uint8)
draw_rectangle(img, 10, 40, 20, 50)
draw_rectangle(img, 15, 34, 25, 44)
draw_rectangle(img, 20, 70, 70, 90)
draw_rectangle(img, 50, 90, 75, 120)

plt.close('all')
plt.imshow(img)
print(search_rectangles(img))

Output:

[[[ 10  20]
  [ 40  50]
  [ 15  45]]

 [[ 15  25]
  [ 34  44]
  [ 20  39]]

 [[ 20  70]
  [ 70  90]
  [ 45  80]]

 [[ 50  75]
  [ 90 120]
  [ 62 105]]]

Answer 2

It depends on the information you have.

If you have the coordinates of the bottom left and top right corners, then the center will be the average between the two.

If you have one corner and the dimensions, then you can just move from the corner to the center using half the dimensions.

import numpy as np

# Bottom left and top right
bl = np.array([1, 0])
tr = np.array([2, 1])

center = np.mean((bl, tr), axis = 0)

# Bottom left corner and dimensions

bl = np.array([1, 0])
dimensions = np.array([1, 1])

center = bl + 0.5 * dimensions