2D numpy ndarrays的交叉点

我有两个numpy数组是OpenCV凸包，我想检查相交而不创建循环或创建图像并对它们执行numpy.bitwise_and，两者在Python中都很慢。阵列看起来像这样：

[[[x1 y1]] 
[[x2 y2]] 
[[x3 y3]] 
... 
[[xn yn]]]

考虑[[X1 Y1]]为一个单独的元件，我想在两个numpy的ndarrays之间执行交叉点。我怎样才能做到这一点？我发现了几个类似性质的问题，但我无法从那里找出解决方案。

在此先感谢！

来源

2012-02-13 Subhamoy Sengupta

所以这是我做了什么，以完成这项工作：

import Polygon, numpy 

# Here I extracted and combined some contours and created a convex hull from it. 
# Now I wanna check whether a contour acquired differently intersects with this hull or not. 

for contour in contours: # The result of cv2.findContours is a list of contours 
    contour1 = contour.flatten() 
    contour1 = numpy.reshape(contour1, (int(contour1.shape[0]/2),-1)) 
    poly1 = Polygon.Polygon(contour1) 

    hull = hull.flatten() # This is the hull is previously constructued 
    hull = numpy.reshape(hull, (int(hull.shape[0]/2),-1)) 
    poly2 = Polygon.Polygon(hull) 

    if (poly1 & poly2).area()<= some_max_val: 
     some_operations

我不得不使用for循环，这完全看起来有点乏味，虽然它给了我预期的结果。任何更好的方法将不胜感激！

来源

2012-02-14 21:12:38

可以使用http://pypi.python.org/pypi/Polygon/2.0.4，这里有一个例子：

>>> import Polygon 
>>> a = Polygon.Polygon([(0,0),(1,0),(0,1)]) 
>>> b = Polygon.Polygon([(0.3,0.3), (0.3, 0.6), (0.6, 0.3)]) 
>>> a & b 
Polygon: 
    <0:Contour: [0:0.60, 0.30] [1:0.30, 0.30] [2:0.30, 0.60]>

要转换cv2.findContours到多边形点格式的结果，您可以：

points1 = contours[0].reshape(-1,2)

这将形状从转换（N，1）到（N，2）

以下是完整示例：

import Polygon 
import cv2 
import numpy as np 
from scipy.misc import bytescale 

y, x = np.ogrid[-2:2:100j, -2:2:100j] 

f1 = bytescale(np.exp(-x**2 - y**2), low=0, high=255) 
f2 = bytescale(np.exp(-(x+1)**2 - y**2), low=0, high=255) 


c1, hierarchy = cv2.findContours((f1>120).astype(np.uint8), 
             cv2.cv.CV_RETR_EXTERNAL, 
             cv2.CHAIN_APPROX_SIMPLE) 

c2, hierarchy = cv2.findContours((f2>120).astype(np.uint8), 
             cv2.cv.CV_RETR_EXTERNAL, 
             cv2.CHAIN_APPROX_SIMPLE) 


points1 = c1[0].reshape(-1,2) # convert shape (n, 1, 2) to (n, 2) 
points2 = c2[0].reshape(-1,2) 

import pylab as pl 
poly1 = pl.Polygon(points1, color="blue", alpha=0.5) 
poly2 = pl.Polygon(points2, color="red", alpha=0.5) 
pl.figure(figsize=(8,3)) 
ax = pl.subplot(121) 
ax.add_artist(poly1) 
ax.add_artist(poly2) 
pl.xlim(0, 100) 
pl.ylim(0, 100) 

a = Polygon.Polygon(points1) 
b = Polygon.Polygon(points2) 
intersect = a&b # calculate the intersect polygon 

poly3 = pl.Polygon(intersect[0], color="green") # intersect[0] are the points of the polygon 
ax = pl.subplot(122) 
ax.add_artist(poly3) 
pl.xlim(0, 100) 
pl.ylim(0, 100) 
pl.show()

输出：

enter image description here

来源

2012-02-14 01:19:22 HYRY

这种方法真的很快吗？我需要在捕获时检查每个帧的相交情况，并且系统资源不是很高。 – 2012-02-14 08:32:35

当我尝试从opencv轮廓或凸包创建多边形时，这是我得到的错误： 'cPolygon.Error：操作的多边形或轮廓无效' 您指定的格式不是我拥有的格式（显示在我原来的帖子中）。我认为可能需要进行一些修改，但无法想象如何完成。 – 2012-02-14 10:37:58

请发布一些示例数据。 – HYRY 2012-02-14 11:30:08

可以使用阵列的视图作为一个单一的尺寸与intersect1d函数是这样的：

def multidim_intersect(arr1, arr2): 
    arr1_view = arr1.view([('',arr1.dtype)]*arr1.shape[1]) 
    arr2_view = arr2.view([('',arr2.dtype)]*arr2.shape[1]) 
    intersected = numpy.intersect1d(arr1_view, arr2_view) 
    return intersected.view(arr1.dtype).reshape(-1, arr1.shape[1])

这在每个阵列的视图，改变每行到一个值的元组。然后执行交集，并将结果更改回原始格式。下面是使用它的一个例子：

test_arr1 = numpy.array([[0, 2], 
         [1, 3], 
         [4, 5], 
         [0, 2]]) 

test_arr2 = numpy.array([[1, 2], 
         [0, 2], 
         [3, 1], 
         [1, 3]]) 

print multidim_intersect(test_arr1, test_arr2)

此打印：

[[0 2] 
[1 3]]

来源

2012-02-14 03:22:02 jterrace

非常感谢您的回应！如果外围的所有点都在numpy数组中，这将是完美的。但是，在凸包中，我认为只有几点作为指导。但是在这种情况下，交叉点就是两个区域的共同价值，这在numpy数组本身内可能并不常见。我刚刚阅读我的帖子，并意识到我没有提到这一点。我为此感到抱歉。 – 2012-02-14 08:26:29

当我将视图应用于自己的numpy时，它看起来像这样： [[[（x1，）（y1，）]] [[（x2，）（y2，）]] ... [[（xn，）（YN）]]] 而我们真正需要的是这样的： [（X1，Y1），（X2，Y2），（X3，Y3），...，（XN，YN）] 任何想法？ – 2012-02-14 10:59:44

由于某种原因您是否只有一个额外的轴？你可以用''test_arr1.reshape（len（test_arr1），2）''来重新初始化它吗？这将避免副本。 – jterrace 2012-02-14 14:13:19

通过jiterrace的回答

我碰到这个帖子附带Udacity deep learning class(工作试图找到训练和测试数据之间的重叠），同时启发。

我对“视图”不熟悉，发现语法有点难以理解，当我尝试与在“表”中思考的朋友进行交流时可能也是如此。我的方法基本上是将形状（N，X，Y）的状态平坦化/重塑为形状（N，X * Y，1）。

print(train_dataset.shape) 
print(test_dataset.shape) 
#(200000L, 28L, 28L) 
#(10000L, 28L, 28L)

1）。INNER JOIN（容易理解，缓慢）

%%timeit -n 1 -r 1 
def multidim_intersect_df(arr1, arr2): 
    p1 = pd.DataFrame([r.flatten() for r in arr1]).drop_duplicates() 
    p2 = pd.DataFrame([r.flatten() for r in arr2]).drop_duplicates() 
    res = p1.merge(p2) 
    return res 
inters_df = multidim_intersect_df(train_dataset, test_dataset) 
print(inters_df.shape) 
#(1153, 784) 
#1 loop, best of 1: 2min 56s per loop

2）。 SET INTERSECTION（快速）

%%timeit -n 1 -r 1 
def multidim_intersect(arr1, arr2): 
    arr1_new = arr1.reshape((-1, arr1.shape[1]*arr1.shape[2])) # -1 means row counts are inferred from other dimensions 
    arr2_new = arr2.reshape((-1, arr2.shape[1]*arr2.shape[2])) 
    intersected = set(map(tuple, arr1_new)).intersection(set(map(tuple, arr2_new))) # list is not hashable, go tuple 
    return list(intersected) # in shape of (N, 28*28) 

inters = multidim_intersect(train_dataset, test_dataset) 
print(len(inters)) 
# 1153 
#1 loop, best of 1: 34.6 s per loop

来源

2017-06-02 18:32:26

2D numpy ndarrays的交叉点

回答

相关问题