逐行用另一个ndarray过滤numpy ndarray

Question

I have 2 numpy ndarray

The first contain x and y values :

xy_arr = [[ 736190.125         1130.        ]
 [ 736190.16666667    1130.        ]
 [ 736190.20833333    1130.        ]
...,
 [ 736190.375         1140.        ]
 [ 736190.41666667    1140.        ]
 [ 736190.45833333    1140.        ]
 [ 736190.5           1140.        ]]

the second have xy and index values and is much bigger than the first:

xyind_arr = [[  7.35964000e+05   1.02000000e+03   0.00000000e+00]
 [  7.35964042e+05   1.02000000e+03   1.00000000e+00]
 [  7.35964083e+05   1.02000000e+03   2.00000000e+00]
 ..., 
 [  7.36613397e+05   1.09500000e+03   3.07730000e+04]
 [  7.36613404e+05   1.10000000e+03   3.07740000e+04]
 [  7.36613411e+05   1.10500000e+03   3.07750000e+04]]

I want to keep all rows of the xyind_arr where values are same in xy_arr like :

(xyind_arr[:,0] == xy_arr[:,0]) and (xyind_arr[:,1] == xy_arr[:,1])

My code :

sub_array = xyind_arr[((xyind_arr[:, 0] == xy_arr[:, 0]) &
                       (xyind_arr[:, 1] == xy_arr[:, 1]))]

Only work if the xy_array have one element. For example :

import numpy as np

xy_arr = np.array([[56, 400]])
xyind_arr = np.array([[5, 6, 0],[8, 12, 1],[9, 17, 2],[56, 400, 3],[23, 89, 4]])

sub_array = xyind_arr[((xyind_arr[:, 0] == xy_arr[:, 0]) &
                       (xyind_arr[:, 1] == xy_arr[:, 1]))]

print(sub_array)

result OK :

[[ 56 400   3]]

But with

xy_arr = np.array([[5, 6],[8, 12],[23, 89]])

The result is

[]

And I expected

[[5, 6, 0],[8, 12, 1],[23, 89, 4]]

Is there any clean numpy method to obtain this filtered sub array ?

---

Edit :

Finally I let down the numpy solution and use the python set() :

    xy_arr_set = set(map(tuple, xy_arr))
    xyind_arr_set = set(map(tuple, xyind_arr))
    for x, y, ind in xyind_arr_set:
        if (x,y) in xy_arr_set:
            "do what i need"

Answer 1

There is numpy.isin but it tests only against a scalar array; there is no tuple-comparison in it. You could use this method to find all rows of Array1 where the 0th column entry is in 0th column of Array2, and also the 1st column entry is in 1st column of Array2. But this is different from your task, because there is no guarantee that both 0th and 1st entry were found in the same row of Array2.

Since xyind_arr is much larger, I think it should be acceptable to loop over the smaller array xy_arr , applying one of the xy_arr filters at a time, and concatenate the results. For this to work, the rows of xy_arr must be unique, so better check that first:

xy_arr = np.unique(xy_arr, axis=0)    
sub_array = np.concatenate([xyind_arr[(xyind_arr[:, 0] == xy_arr[k, 0]) &
                            (xyind_arr[:, 1] == xy_arr[k, 1])]
                            for k in np.arange(xy_arr.shape[0])], axis=0) 

Note: the order of rows will not be preserved.