在numpy 2D矩阵中计算“孔”

Question

Given a 2D matrix of 1s and 0s, for eg -

array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
       [0, 1, 1, 0, 0, 1, 0, 1, 0, 1],
       [1, 1, 0, 0, 1, 1, 0, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 0, 1, 0, 0],
       [1, 0, 0, 0, 1, 0, 1, 1, 0, 0],
       [1, 0, 0, 0, 1, 0, 1, 1, 1, 0],
       [1, 0, 0, 0, 1, 1, 0, 1, 1, 0]])

1 indicates a block, and 0 indicates empty space. I wish to calculate the number of wells , and their accumulated depth .

A well exists when a column is shorter than both its adjacent columns, borders are assumed to be filled with blocks (1s). For eg, padding the borders, the array becomes:

array([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1],
       [1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
       [1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1],
       [1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1],
       [1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1],
       [1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1],
       [1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1]])

• The number of wells is 3 ( Column 1, 4, and (9,10) ).

• The depth of a well is min(height(col_to_left), height(col_to_right)) - height(well_col) .
  So, in this case, the depths are [1, 1, 7] . And therefore the accumulated depth is 1+1+7= 9 .

How would I go about finding this? I want to avoid using loops.

Answer 1

You can use argmax to get the positions of the first one in each column.

# find absolute depths
d = X.argmax(0)
# correct columns that are all zero
v = np.take_along_axis(X, d[None], 0)
d[v[0]==0] = len(X)
# pad and compute the col to next col changes
d = np.diff(np.concatenate([[0], d, [0]]))
# exclude no change
chng, = np.where(d)
# find down changes
dwn = d[chng]>0
# wells are where we go down and the next non zero change is up
well = dwn[:-1]&~dwn[1:]
# map back to unfiltered indices for left and right walls
l, r = chng[:-1][well], chng[1:][well]
wells = np.c_[l+1, r]
wells
# array([[ 1,  1],
#       [ 4,  4],
#       [ 9, 10]])
# retrieve relative depths
depths = np.minimum(d[l], -d[r])
depths
# array([1, 1, 7])