Нахождение разницы между двумя значениями в массиве NumPy

Question

У меня есть пустой список, который я инициирую (my_array = [] и имеет форму (0,)), затем я добавляю к нему элементы wm и hm примерно так (r - это каскад с форматом - [ [300 240 22 22]]):

my_array=[]
for (x, y, w, h) in r:
    wm=int(x+ (w/2.))
    hm=int(y+ (h/2.))
    my_array.append([numpy.float32(wm), numpy.float32(hm)])
return numpy.array(my_array)

Этот код производит:

wm element       the hm element
[[270.01 303.43] [310.17 306.37]] # second to last row
[[269.82 303.38] [310.99 306.86]] # the last row
the shape of the returned array is (2,2) and is dtype:float32

...

Теперь проблема в том, что, когда я пытался добавить 303.43, теоретически это было бы [-2] [1], но индекс 303.38. это нормально, но мне также нужно индексировать 303,43.

Я обнаружил, что первый [] индексирует либо элемент wm [0], либо hm [1], затем второй [] индексирует один из двух столбцов значений внутри каждого элемента
Например, [0] [- 1] индексирует элемент wm [0] и последнюю строку [-1]. Я хочу также проиндексировать вторую последнюю строку и попытался [0] [- 2], но это не сработало так, как задумано (это индексировал 269,82).

Поэтому я попытался [0] [1] [- 2], но это не сработало из-за IndexError: недопустимый индекс для скалярной переменной.

Все, что я хочу сделать, - это найти разницу между последней и второй и последней строкой для 2 столбцов в элементе wm (поэтому в приведенном выше примере это будет 269.82-270.1 = -0.19 и 303.38-303.43 = - 0,05). Индексация не работает. Так есть ли способ обойти эту проблему?

Answer 1

Делая 3 значения 'r':

In [798]: r=np.array([[300, 240, 22, 22]])+np.array([[0],[2],[3]])              
In [799]: r                                                                     
Out[799]: 
array([[300, 240,  22,  22],
       [302, 242,  24,  24],
       [303, 243,  25,  25]])

ваш цикл создает:

In [800]: my_array=[] 
     ...: for (x, y, w, h) in r: 
     ...:     wm=int(x+ (w/2.)) 
     ...:     hm=int(y+ (h/2.)) 
     ...:     my_array.append([numpy.float32(wm), numpy.float32(hm)]) 
     ...:                                                                       
In [801]: my_array                                                              
Out[801]: [[311.0, 251.0], [314.0, 254.0], [315.0, 255.0]]

В виде массива:

In [802]: arr = np.array(my_array)                                              
In [803]: arr                                                                   
Out[803]: 
array([[311., 251.],
       [314., 254.],
       [315., 255.]], dtype=float32)

2-й до последней строки

In [804]: arr[-2,:]                                                             
Out[804]: array([314., 254.], dtype=float32)

последний ряд:

In [805]: arr[-1,:]                                                             
Out[805]: array([315., 255.], dtype=float32)

Их разница:

In [806]: arr[-2,:]-arr[-1,:]                                                   
Out[806]: array([-1., -1.], dtype=float32)

первый столбец:

In [807]: arr[:,0]                                                              
Out[807]: array([311., 314., 315.], dtype=float32)

2-й столбец

In [808]: arr[:,1]                                                              
Out[808]: array([251., 254., 255.], dtype=float32)

Смотрите ваш предыдущий вопрос для получения аналогичного ответа:

Индексирование добавленных элементов из массива python

Answer 2

Я не смог воспроизвести ваш массив, но, учитывая ваш (очень запутанный) вопрос, я считаю, что следующее будет делать то, что вы просите в конце:

Это должно дать вам 269.82-270.1=-0.19

my_array[0][-2]-my_array[0][0]

и это должно дать вам 303.38-303.43=-0.05

my_array[0][-1]-my_array[0][1]

В общем, я считаю, что вы индексируете свой массив my_array следующим образом:

               wm element                       the hm element
[[my_array[0][0]   my_array[0][1]]   [my_array[1][0] my_array[1][1]]] # second to last row
[[my_array[0][-2]  my_array[0][-1]]  [my_array[1][-2] my_array[1][-1]]] # the last row

В вашем конкретном случаеЭлемент от второго к последнему также является третьим, поэтому вы можете индексировать их как my_array[0][2] вместо my_array[0][-2] и my_array[1][2] вместо my_array[1][-2]