编辑：解决方案

Question

我有一个不规则的（非矩形）lon / lat网格和lon / lat坐标中的一堆点，它们应该对应于网格上的点（尽管由于数值原因它们可能略微偏离）。现在我需要相应的lon / lat点的索引。

我已经编写了一个执行此功能的功能，但它确实很慢。

def find_indices(lon,lat,x,y):
    lonlat = np.dstack([lon,lat])
    delta = np.abs(lonlat-[x,y])
    ij_1d = np.linalg.norm(delta,axis=2).argmin()
    i,j = np.unravel_index(ij_1d,lon.shape)
    return i,j

ind = [find_indices(lon,lat,p*) for p in points]

我很确定在numpy / scipy中有更好（更快）的解决方案。我已经谷歌搜索了很多，但到目前为止我的答案还没有找到。

有关如何有效查找相应（最近）点的索引的任何建议吗？

PS：这个问题来自另一个问题（click）。

编辑：解决方案

根据@Cong Ma的回答，我找到了以下解决方案：

def find_indices(points,lon,lat,tree=None):
    if tree is None:
        lon,lat = lon.T,lat.T
        lonlat = np.column_stack((lon.ravel(),lat.ravel()))
        tree = sp.spatial.cKDTree(lonlat)
    dist,idx = tree.query(points,k=1)
    ind = np.column_stack(np.unravel_index(idx,lon.shape))
    return [(i,j) for i,j in ind]

为了解决这个问题以及Divakar的答案中的问题，下面是我使用find_indices的函数的一些时间（以及它在速度方面的瓶颈）（见上面的链接）：

spatial_contour_frequency/pil0                :   331.9553
spatial_contour_frequency/pil1                :   104.5771
spatial_contour_frequency/pil2                :     2.3629
spatial_contour_frequency/pil3                :     0.3287

pil0是我最初的方法，pil1 Divakar，以及pil2 / pil3上面的最终解决方案，其中树在{{{} { 1}}（即对于调用pil2的循环的每次迭代）并且只在find_indices中进行一次（有关详细信息，请参阅其他线程）。尽管Divakar对我的初始方法的改进使我的速度提高了3倍，但cKDTree将其提升到了一个全新的水平，再加上50倍速！将树的创建移出函数会使事情变得更快。

Answer 1

如果这些点已经充分本地化，您可以直接尝试scipy.spatial cKDTree实施，正如我自己in another post所讨论的那样。那篇文章是关于插值的，但你可以忽略它，只使用查询部分。

tl; dr版本：

阅读scipy.sptial.cKDTree的文档。通过将(n, m)形的numpy ndarray对象传递给初始值设定项来创建树，然后从n m - 维坐标创建树。

tree = scipy.spatial.cKDTree(array_of_coordinates)

之后，使用tree.query()检索k最近邻居（可能需要近似和并行化，请参阅文档），或使用tree.query_ball_point()查找给定距离容差内的所有邻居

如果这些点没有很好地定位，并且球面曲率/非平凡拓扑开始出现，你可以尝试将歧管分成多个部分，每个部分都小到足以被认为是局部的。

Answer 2

这是使用scipy.spatial.distance.cdist -

的通用矢量化方法

import scipy

# Stack lon and lat arrays as columns to form a Nx2 array, where is N is grid**2
lonlat = np.column_stack((lon.ravel(),lat.ravel()))

# Get the distances and get the argmin across the entire N length
idx = scipy.spatial.distance.cdist(lonlat,points).argmin(0)

# Get the indices corresponding to grid's shape as the final output
ind = np.column_stack((np.unravel_index(idx,lon.shape))).tolist()

示例运行 -

In [161]: lon
Out[161]: 
array([[-11.   ,  -7.82 ,  -4.52 ,  -1.18 ,   2.19 ],
       [-12.   ,  -8.65 ,  -5.21 ,  -1.71 ,   1.81 ],
       [-13.   ,  -9.53 ,  -5.94 ,  -2.29 ,   1.41 ],
       [-14.1  ,  -0.04 ,  -6.74 ,  -2.91 ,   0.976]])

In [162]: lat
Out[162]: 
array([[-11.2  ,  -7.82 ,  -4.51 ,  -1.18 ,   2.19 ],
       [-12.   ,  -8.63 ,  -5.27 ,  -1.71 ,   1.81 ],
       [-13.2  ,  -9.52 ,  -5.96 ,  -2.29 ,   1.41 ],
       [-14.3  ,  -0.06 ,  -6.75 ,  -2.91 ,   0.973]])

In [163]: lonlat = np.column_stack((lon.ravel(),lat.ravel()))

In [164]: idx = scipy.spatial.distance.cdist(lonlat,points).argmin(0)

In [165]: np.column_stack((np.unravel_index(idx,lon.shape))).tolist()
Out[165]: [[0, 4], [0, 4], [0, 4], [0, 4], [0, 4], [0, 4], [3, 3]]

运行时测试 -

定义功能：

def find_indices(lon,lat,x,y):
    lonlat = np.dstack([lon,lat])
    delta = np.abs(lonlat-[x,y])
    ij_1d = np.linalg.norm(delta,axis=2).argmin()
    i,j = np.unravel_index(ij_1d,lon.shape)
    return i,j

def loopy_app(lon,lat,pts):
    return [find_indices(lon,lat,pts[i,0],pts[i,1]) for i in range(pts.shape[0])]

def vectorized_app(lon,lat,points):
    lonlat = np.column_stack((lon.ravel(),lat.ravel()))
    idx = scipy.spatial.distance.cdist(lonlat,points).argmin(0)
    return np.column_stack((np.unravel_index(idx,lon.shape))).tolist()

时序：

In [179]: lon = np.random.rand(100,100)

In [180]: lat = np.random.rand(100,100)

In [181]: points = np.random.rand(50,2)

In [182]: %timeit loopy_app(lon,lat,points)
10 loops, best of 3: 47 ms per loop

In [183]: %timeit vectorized_app(lon,lat,points)
10 loops, best of 3: 16.6 ms per loop

为了挤出更高的效果，可以使用np.concatenate代替np.column_stack。

在非矩形2D网格

编辑：解决方案

2 个答案: