Detecting a radius based on coordinates?

So you are saying you need the smallest sphere that fully encloses an object from a given point inside the model?

All you need to do for that is loop through all of the points and find the point that has the furthest distance from the center. That distance is the radius of the sphere.

Simply take the points with the smallest "Pythagorean" distance. If you perform this regularly, a data structure like a KDTree may be of use for some speed ups.

Also, when finding the point furthest away, compare squared distances (skip the square root) and just do a full distance calculation once for the vertex furthest away.

Let's restate the problem a little more precisely: Given a set of N points in R^3, find the smallest sphere that contains all of them. Since you don't know what the center might be, the problem is a little trickier than finding the point farthest away.

The basic algorithm that comes to mind takes time O(N^5) to run. The solution sphere will either touch two points (which will be diametrically opposed), or three points (which will be on the same plane as the center of the sphere) or four points. So loop over all the pairs, triplets and quartets of points, find the minimum sphere that contains them and see if all the other points are in there too.

You can probably do better than this by starting with a sphere large enough to hold all the points and shrinking it "appropriately", depending on how many points of contact you currently have. I think this method should take time O(N), but it could be tricky to implement.

If you're happy with a loose fit, a quick method is to calculate the 3d bounding box that contains all points (by examining the min and max values for X,Y,Z of each of the points of the model), and then calculate the distance d from the centre of that bounding box to one of the corners. The resulting sphere, centred at the bounding box centre with radius d, contains all the points of the model.

A visual example in 2 dimensions:

[attachment=12241:circle-calculation.png]

Note: This technique will almost always generate a non-optimal bounding sphere, which you can see from the diagram, (there is a reasonable margin between the actual points and the calculated circle/sphere). Depending on how you want to use the sphere this may make this technique unsuitable. Though this has the advantage of requiring only 1 distance calculation, which makes it pretty fast.

If you need a tight fit, then something like what Alvaro is alluding to is what you're after.

You can probably do better than this by starting with a sphere large enough to hold all the points and shrinking it "appropriately", depending on how many points of contact you currently have. I think this method should take time O(N), but it could be tricky to implement.

I don't think that it's possible to do it in O(n) time for dimensions larger than 1 (I think that it's possible to construct a reduction from the diameter problem to the CH problem, but I'm not 100% sure about this). On the other hand an O(n*log(k)) implementation is possible (n is the number of vertices and k is the number of vertices on the convex hull), though it's not that trivial.

[quote name='Álvaro' timestamp='1352762067' post='5000371']You can probably do better than this by starting with a sphere large enough to hold all the points and shrinking it "appropriately", depending on how many points of contact you currently have. I think this method should take time O(N), but it could be tricky to implement.

I don't think that it's possible to do it in O(n) time for dimensions larger than 1 (I think that it's possible to construct a reduction from the diameter problem to the CH problem, but I'm not 100% sure about this). On the other hand an O(n*log(k)) implementation is possible (n is the number of vertices and k is the number of vertices on the convex hull), though it's not that trivial.
[/quote]

Yes, you are right. The method I was thinking of is not O(n), but something like O(n*log(n)) or O(n*log(k)). I have to think the details through before I can be sure.

It seems I was wrong. This problem can be solved in linear expected time.
This simple (general position) algorithm should do the trick:


FindMinSphere(S, origSphereVerts)
1. sphereVerts = origSphereVerts, remainingVerts = empty
2. for each i[k] in random pi(1,2,...,length(S))
2.1 if S[i[k]] is not contained in the sphere spanned by sphereVerts
2.1.1 sphereVerts = FindMinSphere(remainingVerts, EliminateExtraVertex(origSphereVerts + S[i[k]]))
2.2 remainingVerts += S[i[k]]
3. return sphereVerts

EliminateExtraVertex(S)
1. X=S
2. if length(S)==5
2.1 X = from the 5 possible spheres in X choose the one that contains all five points
3. return X