два массива numpy удовлетворяют разным условиям

Question

Конкретный вопрос: у меня есть двоичное изображение.Теперь я хотел бы получить индексы пикселей, чтобы они попадали в конкретную область.Поэтому сначала я беру nonzeroPixel = nonzero(img) и получаю их значения x и y (то есть координаты) на Py=np.array(nonzeroPixel[0]) и Px=np.array(nonzeroPixel[1]).Скажем, область прямоугольника, в которую я ожидаю их попадания, равна x in (10,20) и y in (30,40). Мой вопрос: как получить индексы пикселей, попадающих в эту область прямоугольника?Что означает 10<Px<20 && 30<Py<40.

Я пытался np.where((Py >= 30) & (Py < 40) & (Px >= 10) & (Px < 20)), но я думаю, что он работает только для одного массива?

Вот возможное решение, но я не знаю, какую функцию numpy он использует.

good_pixel_index = ((Py > 30) & (Py < 40) & (Px > 10) &  (Px < 20)).nonzero()[0]

Любые мысли будут оценены

Answer 1

Чтобы сделать конкретный пример:

In [168]: img = np.random.randint(0,2,(10,10))                                  
In [169]: img                                                                   
Out[169]: 
array([[1, 1, 1, 1, 0, 1, 1, 1, 0, 1],
       [0, 0, 1, 0, 1, 0, 0, 1, 1, 1],
       [1, 0, 0, 1, 0, 1, 1, 1, 0, 1],
       [0, 1, 0, 0, 1, 0, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 1, 0, 0, 1, 0],
       [0, 0, 0, 1, 0, 0, 0, 1, 0, 1],
       [1, 1, 1, 0, 1, 1, 1, 0, 1, 1],
       [1, 1, 0, 1, 0, 1, 1, 1, 1, 1],
       [1, 1, 0, 1, 1, 1, 0, 1, 1, 0],
       [0, 1, 0, 0, 1, 1, 1, 1, 0, 0]])
In [170]: idx = np.nonzero(img)                                                 
In [171]: idx                                                                   
Out[171]: 
(array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
        3, 4, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7,
        7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9]),
 array([0, 1, 2, 3, 5, 6, 7, 9, 2, 4, 7, 8, 9, 0, 3, 5, 6, 7, 9, 1, 4, 6,
        7, 2, 3, 4, 5, 8, 3, 7, 9, 0, 1, 2, 4, 5, 6, 8, 9, 0, 1, 3, 5, 6,
        7, 8, 9, 0, 1, 3, 4, 5, 7, 8, 1, 4, 5, 6, 7]))
In [172]: jdx = np.nonzero((idx[0]>=3)&(idx[0]<=8)&(idx[1]>4)&(idx[1]<9))       
In [173]: jdx                                                                   
Out[173]: (array([21, 22, 26, 27, 29, 35, 36, 37, 42, 43, 44, 45, 51, 52, 53]),)
In [174]: idx1 = (idx[0][jdx],idx[1][jdx])                                      
In [175]: idx1                                                                  
Out[175]: 
(array([3, 3, 4, 4, 5, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8]),
 array([6, 7, 5, 8, 7, 5, 6, 8, 5, 6, 7, 8, 5, 7, 8]))
In [176]: img[idx1]                                                             
Out[176]: array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])

И чтобы лучше визуализировать, какие точки мы выбрали:

In [177]: img[idx1] = 2                                                         
In [178]: img                                                                   
Out[178]: 
array([[1, 1, 1, 1, 0, 1, 1, 1, 0, 1],
       [0, 0, 1, 0, 1, 0, 0, 1, 1, 1],
       [1, 0, 0, 1, 0, 1, 1, 1, 0, 1],
       [0, 1, 0, 0, 1, 0, 2, 2, 0, 0],
       [0, 0, 1, 1, 1, 2, 0, 0, 2, 0],
       [0, 0, 0, 1, 0, 0, 0, 2, 0, 1],
       [1, 1, 1, 0, 1, 2, 2, 0, 2, 1],
       [1, 1, 0, 1, 0, 2, 2, 2, 2, 1],
       [1, 1, 0, 1, 1, 2, 0, 2, 2, 0],
       [0, 1, 0, 0, 1, 1, 1, 1, 0, 0]])

In [180]: img[3:9, 5:9]                                                         
Out[180]: 
array([[0, 2, 2, 0],
       [2, 0, 0, 2],
       [0, 0, 2, 0],
       [2, 2, 0, 2],
       [2, 2, 2, 2],
       [2, 0, 2, 2]])

In [182]: np.argwhere(img[3:9, 5:9])   # transpose of `nonzero`                                            
Out[182]: 
array([[0, 1],
       [0, 2],
       [1, 0],
       ...
       [5, 2],
       [5, 3]])

Применение среза среза, как предлагает @roganjosh, воссоздает idx1массивы:

In [183]: np.argwhere(img[3:9, 5:9])+[3,5]                                      
Out[183]: 
array([[3, 6],
       [3, 7],
       [4, 5],
       [4, 8],
       [5, 7],
       [6, 5],
       [6, 6],
       [6, 8],
       [7, 5],
       [7, 6],
       [7, 7],
       [7, 8],
       [8, 5],
       [8, 7],
       [8, 8]])

Я не думаю, что имеет значение, какой маршрут вы выберете.

Answer 2

Вы можете сделать это с кусочками, а не np.where.

import numpy as np

# Make some fake 100x100 data
arr = np.random.randint(0, 2, 10000).reshape(100, 100)

# Select the correct slice (rows, columns)
print(arr[30:40, 10:20])

# Find the indices of the slice that aren't zero
ones = arr[30:40, 10:20].nonzero()

# Bump up the indices by the starting value of the slice
x_coords = ones[0] + 30
y_coords = ones[1] + 10