如何有效计算环形空间中的距离？

Question

I have game window of size 640 by 480 and it is populated by particles, but when a particle goes off to one side, it wraps around to the other (ie it is a toroid).

I want to calculate the distance between each particle, since this will be used to apply different forces to each particle.

At first I looped through each pair of particles, and then rescaled everything so that the first particle in pair was centered and then calculated the distance to the second particle, but this was extremely slow to run.

Then I found some functions in scipy.spatial.distance that allow me to calculate the distance between all points very quickly, but the only problem is that it doesn't take into account the wrap around.

Here is my current code

from scipy.spatial.distance import pdist, squareform
...
distance = squareform(pdist([(p.x, p.y) for p in particles]))

This works for particles near the center, but if one particle is at (1, 320) and the other particle is at (639, 320), then it calculates their distance as 638 instead of 2. It doesn't take into account the wrap.

Is there a different function I can use, or some transformation I can apply before/after to take into account the wrap?

Answer 1

You can compute the smaller of the x and y differences (the in-window difference versus the edge-crossing distance) like this:

game_width = 640
game_height = 480

def smaller_xy(point1, point2):

    xdiff = abs(point1.x - point2.x)
    if xdiff > (game_width / 2):
        xdiff = game_width - xdiff

    ydiff = abs(point1.y - point2.y)
    if ydiff > (game_height / 2):
        ydiff = game_height - ydiff

    return xdiff, ydiff

That is, if the in-window distance in the x or y directions is greater than half the size of the window in that direction, it's better to go off the edge -- and in that case the distance will be the window size in that direction minus the original in-window distance.

Obviously, once you have the x and y separations you can compute the distance between the points as:

import math

small_x, small_y = smaller_xy(p1, p2)
least_distance = math.sqrt(small_x**2 + small_y**2)

However, depending on how your force calculation is defined, you might find that all you really need is the square of the distance (just ( small_x**2 + small_y**2 )) and therefore you can avoid the work of finding the sqrt .

To get this plumbed into scipy.pdist , note that pdist can be called with a function argument in addition to the points, as:

Y = pdist(X, func)

This is the last form of invocation shown in the description of pdist at https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.pdist.html#scipy.spatial.distance.pdist

You should be able to use that feature to cause pdist to to build its distances-between-all-pairs-of-points matrix on the basis of distances calculated by a callback function that applies the smaller_xy computation.

Answer 2

Let's imagine you replicate four boards above, below, left, and right to the original board, and also the particles on the original board onto the new boards. Let's also mark the particles.

Denote the N particles on the original board o(i) , i running from 1 and N . a(i) for the particles on the replicated board above. b(i) , l(i) , r(i) for below, left, and right respectively.

For all distinct i and j , you need to find distances between o(i) and o(j) , o(i) and a(j) , etc, etc. There are 5x5 = 25 distances to compute for each pair of i and j . Once you have all these distances, take the minimum for each pair, that's your distance for i and j .

I was thinking there may be ways to prune the computation. But my thinking is you would need to at least compute distances between particles to the boarders and compare that with distances on original board. That is an overhead as well.