Python - 计算两个点列表（坐标）的最小欧氏距离

Question

I have two lists of n shape and each point will be compared(euclidean distance) to each point of the second list and then the minimum distance will be chosen, example:

A: [(1,1),(2,1),(3,1)]

B: [(2,2),(3,3)]

The output will be 3 distances:

min((1,1) -> (2,2), (1,1) -> (3,3)),

min( (2,1) -> (2,2), (2,1) -> (3,3) ),

min ( (3,1) -> (2,2), (3,1) -> (3,3) )

-> euclidean distance

The difficult part is to make an efficient code.

Answer 1

Here is a sample code that may help:

from scipy.spatial import distance

A = [(1,1),(2,1),(3,1)]
B = [(2,2),(3,3)]

min_dist = []
for a in A:
    dist = []
    for b in B:
        dist.append(distance.euclidean(a,b))
    min_dist.append(min(dist))

>> min_dist
>> [1.4142135623730951, 1.0, 1.4142135623730951]

I am using scipy library for this. It is also possible using numpy.linalg.norm . Does this approach work for you?

HTH.

Answer 2

I found a way, I don't know if someone can make it more efficiently,

import numpy as np
from scipy.spatial import distance

s1 = np.array([(0,0), (0,1), (1,0), (1,1)])
s2 = np.array([(3,2), (1,9)])
print(distance.cdist(s1,s2).min(axis=1))
# array([3.60555128, 3.16227766, 2.82842712, 2.23606798]) 

Answer 3

Depends on what you mean by "efficient." If you have sizable lists and you are going to be doing a lot of comparisons, you should just look for the minimum squared distance, which is much faster to compute because you avoid the square root operation. This is a standard hack when working with euclidean distances.

If in the end, you want the actual euclidean distance, then take the square root.

Consider:

import numpy as np

A = [(1, 1), (2, 1), (3, 1)]
B = [(2, 2), (3, 3)]

# compare each point in A to all points in B, return the shortest distance

for pt in A:
    min_sq_dist = min( (pt[0] - t[0])**2 + (pt[1] - t[1])**2 for t in B )
    print(np.sqrt(min_sq_dist))

Output:

1.4142135623730951
1.0
1.4142135623730951

What's the big difference? The code above computes 3 square roots. The naive approach computes 6 (|{B}| times as many)