3

I am looking for a reasonably efficient algorithm (and likely associated data structure) to accomplish the following in a reasonably low dimension (d<10; generally d=2 or 3):

Given a set of (potentially-overlapping!) spheres and a fixed bounding box, I wish to be able to:

  1. Query for the point within said bounding box that is farthest from any sphere.
    1. If there are multiple such points, an arbitrary choice is fine.
    2. A point within a sphere is at zero distance (that is, these are balls not hollow spheres.)
    3. If every point is within at least one sphere, erroring out here, or at 2.1., or returning an arbitrary point, are all fine.
    4. Ideally I am looking for an exact (up to numerical error) solution; a convergent approximation with error bounds is workable.
  2. Add new spheres to the set.
    1. If every point is now within at least one sphere, erroring out here or at 1.3. is fine.

Doing some initial preprocessing is fine.

(Note that the spheres can overlap, and can have varying radii.)

(Fixed bounding box, fixed bounding sphere, or simply an implicit convex hull. Any are workable, whichever is easiest.)

At a first glance this is deceptively similar to the Largest Empty Sphere problem (for which you can accomplish the above with a Veronoi diagram and some processing), however the change from "points to avoid" to "spheres to avoid" stops this from working and I haven't been able to figure out a straightforward extension.

Another approach that seems to work is to just repeatedly run the Largest Empty Sphere problem, starting with points to avoid at the center point of every sphere and each iteration adding the closest point across all spheres to the resulting current solution to the set of points to avoid, however this is expensive and doesn't have an obvious error bound.

Ditto, I look at this problem and go "this looks like the sort of thing you ought to be able to massage a BSP tree into doing", but most BSP algorithms I've seen tend more to be focused on nearest point, not farthest.

Spektre
  • 49,595
  • 11
  • 110
  • 380
TLW
  • 1,373
  • 9
  • 22
  • what do you consider `reasonably efficient algorithm` ? what is the bound complexity of iterations if `n` is dimensionality and `m` number of balls? I would start with making BBOX surface map (squaremap, cubemap ...) with some not big resolution where the min distance to any ball will be stored (which can be computed iteratively for each new ball) handle that as a map, find surface "pixel" with max distance and recursively check that area until target precision is shit. Of coarse this can miss the best answer if initial resoluiton is too low – Spektre Apr 27 '21 at 08:55
  • Also the BBOX is fully enclosing the balls or they can intersect ? – Spektre Apr 27 '21 at 08:56
  • 1
    It seems like you could apply the standard Largest Empty Sphere approach, but substituting an additively weighted VD for the normal VD. – Sneftel Apr 27 '21 at 12:11
  • Consider a weighted Voronoi diagram. –  Apr 27 '21 at 17:43
  • > Consider a weighted Voronoi diagram. Thanks for the pointer! An additively weighted Voronoi diagram does give you the points to check. Unfortunately, _constructing_ said diagram is expensive, and taking a cursory look I can't find any references on incremental construction of weighted Voronoi diagrams in d>2... Suggestions? – TLW Apr 27 '21 at 23:17

0 Answers0