advertisement

Technical Notes Programming Techniques and Data Structures Fig. 1. A Point Set and its Convex Hull. M . Douglas Mcllroy* Editor Approximation Algorithms for Convex Hulls LL/ Jon Louis Bentley and Mark G. Faust Carnegie-Mellon University Franco P. Preparata University of Illinois at Urbana-Champaign The problem of constructing the convex hull of a finite point set in a Euclidean space arises in many applications. In this paper we study a set of algorithms for constructing approximate convex hulls. We show that an E-approximate hull of N points in the plane can be constructed in O(n + I/e) time. The planar algorithm has been implemented and is very fast on point sets that arise in practice. The method can be generalized to compute hulls of point sets in higher dimensional spaces. CR Categories and Subject Descriptors: F.2.2 [Analysis of Algorithms and Problem Complexity]: Nonnumerical Algorithms and Problems--geometricalproblems and computations; G.2.1 [Discrete Mathematics]: Com- binatorics--combinatorial algorithms. General Terms: Algorithms, Design Additional Key Words and Phrases: convex hulls, approximation algorithms I. Introduction The convex hull of a point set in Euclidean d-space is defined to be the smallest convex set containing the points; a set of points in the plane and its convex hull are illustrated in Figure 1. Because it is a precise characterization of the boundary of a point set, the convex hull is used in many applications; for example, Shamos [8] discusses its use in such areas as robust estimation, Chebyshev approximation, least-squares isotonic regression, and clustering. In addition to its inherent uses, computation of the convex hull also arises as an interThis research was supported in part by the Office of Naval Research under Contract N00014-76-C-0370, in part by the National Science Foundation under Grant MCS-78-13642, and in part by the Joint Service Electronics Program under Contract N00014-79-C-0424. Authors' Present Addresses: Jon Louis Bentley and Mark G. Faust, Departments of Computer Science and Mathematics, Carnegie-Mellon University, Pittsburgh, PA 15213; Franco P. Preparata, Coordinated Science Laboratory, University of Illinois at Urbana-Champaign, Urbana, IL 61801. * Former editor of Programming Techniques and Data Structures of which Ellis Horowitz is the current editor. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific permission. © 1982 ACM 0001-0782/82/0100--0064 $00.75. 64 mediate step in many problems in computational geometry. For all these reasons, the computation of the convex hull of a finite point set is an interesting algorithmic problem. Much work has recently been devoted to algorithms for computing convex hulls. Graham [4] proposed the first algorithm for computing the hull of n planar points in O(n lg n) worst-case time. (A number of different worst-case algorithms have since been proposed for this problem; see [8].) Preparata and Hong [7] later gave an algorithm for computing the hull of n points in 3-space in O(n lg n) worst-case time. Shamos [8] was the first to show an f~(n lg n) lower bound on the problem of computing the polygon that is the edge of the planar convex hull; his proof makes crucial use of the fact that the vertices of the polygon must appear in sorted order. Yao [10] later achieved a much stronger result showing that merely identifying the extremal points of the hull requires f~(n lg n) time. Because these lower and upper bounds together establish the worst-case complexity of the problem to within a constant factor, researchers have concentrated on other aspects of the problem. A particularly interesting problem is the expected complexity of computing convex hulls. Bentley and Shamos [1] showed that the hull of n points in 2-space or 3-space could be computed in linear time for a large class of probability distributions. Devroye [3] extended their technique to a linear-time algorithm in d-space but for a much smaller class of distributions. Many other aspects of convex hulls have been discussed in the literature. Preparata [6], for example, discusses a real-time on-line algorithm for constructing planar hulls. In this paper we take an approach to the problem of computing convex hulls that has not been explored in any of the above papers. Specifically, we will investigate the problem of computing an approximate convex hull. Our algorithm runs in worst-case time linear in the number of input points, and computes an approximation that is arbitrarily close to the true hull. This algorithm is useful for applications that must have rapid solutions, even at the expense of accuracy. Thus the algorithm is particularly appropriate, for example, in statistical applications where observations are not exact but are known to a well-defined precision; there is no reason to spend a great deal of time getting an accurate answer if that accuracy is not really present in the underlying data! Communications of the ACM January 1982 Volume 25 Number 1 Our technique is illustrated in the planar case in Sec. 2, and we examine applications of the algorithm to a number of problems in planar computational geometry in Sec. 3. Extension of these methods to higher dimensions is then discussed in Sec. 4, and conclusions are offered in Sec. 5. Fig. 2. The Planar Approximate Hull Algorithm. (a) Place points in bin. (b) Find extremes in bins. (c) Build hull of extremes. (a) • 2. The Planar Algorithm In this section we study an algorithm for computing an approximate convex hull of a planar point set. The basic idea of the algorithm is simple: we judiciously sample some subset of the points and then use the convex hull of the sample as an approximation to the convex hull of the points. The particular sampling scheme that we use is illustrated in Figure 2. The first step of our algorithm is to find the minimum and the maximum values in the x dimension, and then divide the area between them into k equally spaced strips; see Figure 2(a). Next, for each strip, we find the two points in that strip with minimum and maximum y value (we call this set of points S); see Figure 2(b). We also include in S the points with extreme x values, and if there are several points with extreme x values, we include both their maximum and minimum by y value; there are therefore a maximum of 2k + 4 points in S. Finally, we construct the convex hull of S, and use that as the approximate hull of the set; see Figure 2(c). Note that the resulting hull is indeed only an approximation; one of the points of the set lies outside it. The method that we just sketched informally is easy to implement as a computer program. Finding the minimum and maximum x values is trivial, and the k-strips are implemented as a (k + 2) element array (the zeroth and (k + 1)st elements of the array contain only the points with minimum ~ind maximum x value and are present primarily as a programming convenience.) To see in which strip a particular point falls, we subtract the minimum x value from the point's x value, multiply that difference by the scaling factor of l / k times the difference of the x extremes and take the floor of the product as the strip number. To find the minimum and maximum in each strip, we iterate through the point set, and for each point check to see if it exceeds either the current maximum or minimum in the strip, and, if so, update a value in the array. We then use one of the convex hull algorithms described by Shamos [8] to compute the hull of S. (The most natural algorithm for this problem is a modified version of Graham's [4] algorithm which scans in right-to-left rather than counter-clockwise order.) The performance of this program is easy to analyze. The space that it takes is proportional to k (if we assume the input points are already present.) Finding the minimum and maximum x values requires 8(n) time, and initializing the array can be accomplished in O(k) time. Finding the extremes in each strip requires 8(n) time, 65 Q (b) r I i" "I *-I • I (c) and the convex hull of S can be found in O(k) time (because the, at most, 2k + 4 points in S are already sorted by x value.) The running time of the entire program is therefore O(n + k). We have just shown that we can rapidly construct some approximation to the hull, but before we can use it we must be precise about how accurate an approximation it is. One fact is easy to observe: because it uses only points in the input set as hull points, it is a conservative approximation in the sense that every point within the approximate hull is also within the true hull. We must now answer the question, "how far can a point be outside the approximate hull if it is inside the true hull?" Note that the maximum distance is realized by one of the points in the input set. Let us assume that the distance between the minimum and maximum x values is unity; this implies that the width of each strip is 1/k. It is now easy to prove the following fact. Communications of the ACM January 1982 Volume 25 Number 1 Fact 1. Any point P in the point set that is not inside the approximate convex hull is within distance l / k of the hull. values of the points in S need not be stored), and has an error radius of l/2k, rather than 1/k. To prove this, consider the strip in which P falls. Because P is outside the approximate hull, it cannot have either the minimum or maximum y value of points in the strip; P's y value must therefore lie between these two extremes. Now draw a horizontal line from P to the hull; since the strip is l / k wide, this line can be at most that long, and the fact holds. This approximation error analysis can be used in either an absolute or a relative sense. If one wishes to have an approximation accurate to within x units, then one can use strips of width x. For a relative error analysis, we can study the ratio of the error induced by the approximation to the true diameter 1 of the point set, which we will denote by D. We will see in the next section that this is a natural measure of relative error. Note that D is at least as great as the two points furthest apart in the x dimension. We can now use Fact 1 (which assumed that the distance between x extremes is unity) to prove the following. 3. Applications of the Planar Algorithm Fact 2. The relative error of a k-strip approximation is at most 1/k. That is, anypoint in thepoint set that is not inside the approximate hull is within distance D / k of the hull, where D is the diameter of the point set. This fact is an immediate consequence of Fact 1. We will investigate the use of this relative error approximation in the next section. The strip method of this section can be used to yield various approximations. The approximation we just described yields an approximate hull that is a subset of the true hull, but it is not hard to modify it to yield a superset of the true hull. To do this, we just "move the x value" of every maximal point P to be outermost in its strip (i.e., away from the point realizing the maximum y value in the point set if P is the maximum point in its strip, and similarly for the minimum points.) This can be viewed as covering the points in each strip with a rectangle whose left and right sides are those of the strip and whose top and bottom are given by the minimum and maximum points. The approximate hull is then taken to be the convex hull of these covering rectangles. Because the rectangles contain all the points in their strips, the approximate convex hull properly contains the true convex hull. An error analysis similar to that above shows that any point in the approximate hull but not in the true hull must be within distance l / k of the true hull. Yet another variation of the strip approach is to "align" all points to be in the center of their respective strip. The resulting hull is then provably neither a superset nor a subset of the true hull. This method, however, is easier to program, more storage-efficient (since the x i The diameter of a point set is defmed as the m a x i m u m distance between any two points in the set, and is realized by two points on the convex hull of the set (see [8].) 66 In the last section we studied the approximation algorithm for convex hulls in an abstract setting; in this section we study its application in a more concrete context. Specifically, we study a number of computational problems that can be quickly solved by using our approximation algorithm as though it produced the exact hull. The first problem that we will examine is that of computing the diameter of a planar point set. It is easy to prove that the diameter is realized by two points on the convex hull, and Shamos [8] has shown that, given the hull, the diameter can be found in time linear in the number of hull points. We can readily employ our approximate hull algorithm in this context: we first find the approximate hull, and then use its diameter as an approximation to the diameter of the entire set. This requires O(N + k) time for constructing the approximate hull and O(k) time for finding its diameter, for a total of O(N + k) time. • To measure the efficacy of the approximation, let us assume that we did not find the true diameter D (which is realized by two points outside the approximate convex hull) but rather that we found the approximate diameter A, where A < D. By Fact 2, we know that both of the points realizing the true diameter are within distance D / k of the approximate hull. Applying this observation and the triangle inequality twice, we know that D <_A + 2D/k, which implies that D - A <_ 2D/k. We will take as a measure of our approximation the ratio of the difference of the approximate and the true diameters to the true diameter, which is (D - A ) / D <_ 2/k, from the above equation. Thus we know that the approximate diameter produced by this method is a lower bound on the true diameter, and not more than 2D/k less than the true. We can therefore compute E-approximate diameters in O(n + l/e) time and O(l/e) storage. To illustrate the approximate diameter algorithm, we consider the problem of finding the diameter of a point set to within one percent accuracy. For this accuracy, we let k be 200, giving a maximum of 404 points in the 200 strips. A Pascal program implementing the algorithm found the approximate diameter of a 25,000 element point set in 600 milliseconds of PDP-KL10 time. By way of comparison, a carefully coded Pascal program that finds the diameter by computing all ( 2 ) interpoint distances and taking the maximum required approxiCommunications of the A C M January 1982 Volume 25 Number 1 mately an hour and a half of CPU time. The diameter approximation algorithm we have just seen produces a lower bound on the true diameter by exhibiting two points in the set with distance provably close to the true diameter. In some applications, it might be more desirable to have an upper bound on the diameter, and this can be easily achieved by the method described at the end o f Sec. 2. (This involves moving each point "outward" in its strip, away from the point realizing minimum or maximum y value.) Finally, an approximation that is neither an upper nor lower bound but is within 1/k relative accuracy can be found by using only k strips and "placing" each point at the center of its cell. This approach is especially appealing in applications because the x values of the sample points need not be stored (reducing the storage required from approximately 4k reals to 2k reals.) Two algorithms for computing approximate diameter that are substantially different than the above have been given by Brown [2, Sec. 6.1]. His algorithms are based on geometric transforms and require the computation of trigonometric functions. For a given sample size, his approach yields a slight increase in accuracy over ours, but at a substantial increase in the constant factor of the run time. We turn now from the diameter problem to the problem of convex hull searching. Precisely, we are given a planar set of points and must organize it so that we can quickly tell whether a new point is inside or outside the convex hull of the set. We will investigate an approximation algorithm for convex hull searching that returns one of the three answers "yes, the point is definitely inside the hull," "no, the point is definitely outside the hull," or "I do not know whether the point is inside or outside the hull, but it is within E of the hull boundary." Our first algorithm is based on the approximate hull algorithm that builds a subset of the true hull. We construct the hull as before, in O(n + k) time. Consider now the shape of the intersection of the approximate hull and any particular vertical strip used to make the hull; the top of the strip is bounded by one or two lines, as is the bottom. We can therefore describe either the top or the bottom by at most four reals (giving the values of the two y intercepts, and the possible point at which the value changes.) To perform a hull search for point P, we first locate the strip in which it lies in constant time by subtracting, multiplying, and taking the floor function. We then use the stored values to see if it lies within the approximate hull, and if so, we correctly report that the point is inside the true hull. If it is further from the hull than the guaranteed error radius, then we correctly report that the point is outside the hull. If neither of these conditions holds then we respond that we do not know whether the point is inside or outside the hull. This method requires O(n + k) time to organize the set and constant time to answer a query. (Note that just as in the case of computing diameter, we could use other approximations to the hull.) As a final application o f these approximation techniques, we mention the problem of computing allfurthest neighbors in a point set. Specifically, for each point in the set we must tell which point in the set is furthest from it. Since such a furthest neighbor must be a convex hull point, given an approximate convex hull of k points we can locate the approximate furthest neighbor of a new point in lg k time. 2 This method gives us the theoretical result that we can find all furthest neighbors in a set in O[(n + k) lg k] time, with each reported neighbor within D/k o f the true furthest neighbor, where D is the diameter of the point set. 67 Communications of the ACM 4. Extensions to Higher Dimensions In previous sections we have studied approximation algorithms for planar convex hulls; in this section we turn our attention to convex hulls in d-space, where d > 2. We first study the case that d = 3, and then consider greater values of d. Our algorithm for computing an approximate convex hull of a set of points in 3-space is an extension of the planar algorithm described in Sec. 2. An initial sampling pass finds the minimum and maximum values in both the x and the y dimensions; the resulting rectangle is then partitioned into (at most) a (k + 2) × (k + 2) grid o f squares with lines parallel to the x and y axes. (We use k of the squares in each dimension for "real" points in squares, and the two squares on the end for the extreme values.) Note that one of the dimensions can be less than k + 2 if the point set does not happen to occupy a square region. In each square of the grid we find the points with minimum and maximum z values; the resuiting set o f points, called S, consists of at most 2(k + 2) 2 points. Finally, we construct the convex hull of S and use it as the approximate hull of the original set. The hull is constructed using Preparata and Hong's [7] general hull algorithm for point sets in 3-space. Notice the striking difference with respect to the two-dimensional method, where we were able to take advantage of the known ordering of the points in the x dimension: we do not exploit the grid structure of the points to yield a faster algorithm, but rather use a general algorithm. An intriguing question is whether the regular placement of the points of S in a two-dimensional grid can be used to obtain an algorithm more efficient than the general one. The analysis of the three-dimensional algorithm is somewhat different than that of the two-dimensional algorithm. The set S can be found in time O(n+ k 2) but computing the convex hull of S using the general algorithm requires time O(k 2 lg k 2) rather than O(k 2) since we are unable to exploit any natural ordering of the grid points as we were in the two-dimensional case. Thus, the We are using here the fact that a set of M points can be processed in O(M lg M) time to yield a furthest-neighborsearch time of O(lg M). Such an algorithm uses the furthest neighbor graph as discussed in [8, Sec. 6.6] and the searching algorithm of Lipton and Tarjan [5]. January 1982 Volume 25 Number 1 total running time of the algorithm is O(n + k 2 lg k). Using Preparata and Hong's algorithm, the storage space is O(k 2) beyond the space used for the n input points. To determine the efficacy of the method, take as unity the larger of the x or y span of the originally given points in S. Since the diagonal of a grid cell has length 2~/2/k, this value is an upper bound of the distance from the approximate hull to any point in the original set that is external to the hull. As in Sec. 3 this bound can be used in either an absolute or relative sense. As before, the approximate convex hull found by this method is a conservative one; other types of approximation are possible, by obvious generalizations of the cases discussed in Sec. 2. We now turn our attention to applications of this method. A simple way to find an approximate diameter computes all pairs of diameters in S and returns the maximum; this gives a O(n + k 4) approximate diameter algorithm. Unfortunately, the best of the known general algorithms for computing the diameter of a three-dimensional set of M points [9] runs in time O[(M lg M)ls], and thus yields an O[n + (k 2 lg k) 18] approximate diameter algorithm. Here again, it remains an intriguing question whether the regular grid spacing of the approximate hull points can be exploited in some way to obtain a more efficient diameter algorithm. A similarly disappointing conclusion is reached with regard to the hull searching problem. Indeed, all that can be said in general is that the polyhedral surface defining the hull is a triangulation of a set of grid points. It follows that some cells of this grid may intersect as many as O(k 2) faces of the polyhedron, so that no apparent advantage originates from locating a target point in a cell of the grid. It appears therefore that hull searching must be solved by the standard technique, which transforms the problem under consideration to a planar point location and is solved in O(lg k) time (see, for example, Lipton and Tarjan [5].) Note that although lg k time is high compared to the constant time of planar approximate hull searching, it can be very small compared to lg N. The method that we have described to compute approximate hulls in 2- and 3-space can easily be extended to higher dimensions. In d-space we project the d-dimensional point set onto a (d - 1)-dimensional array of (d - 1) cubes with (at most) k + 2 cubes in each dimension. The approximate hull is constructed from the set S of minimum and maximum points in each grid cell, which is bounded above in size by 2(k + 2)d-1 points. Any point inside the set yet outside the approximate hull is at most distance (d - l)~/2/k from the hull, assuming unity as the maximum distance between coordinate extremes. Note that a major drawback of this approach is that S can be very large; we will consider the case of ensuring one percent accuracy for a set of points in 4space. We must have (4 - 1)~/2/k < 0.01, so k _ 173. Because the size of S is 2(k + 2) 3, it contains approximately 1.04 × 107 points! 68 5. Conclusions We have discussed an approach to computing convex hulls of point sets that quickly computes approximate hulls of controlled accuracy. Precisely, the accuracy of the result can be made to grow quickly with the expended computational work. The approach yields efficient planar algorithms for hull construction, diameter finding, and hull searching that are quite practical. These algorithms are also novel in a theoretical context; few approximate algorithms have been studied for problems known to require polynomial worst-case time. A limitation of the approach is that it fails to yield algorithms of comparable efficiency and simplicity in three and higher dimensions. In this connection, there remain some intriguing open problems regarding point sets that project onto grids. Is the construction of the convex hull of a three-dimensional point set that projects to a rectangular grid easier than the general case? Are such sets easier for the determination of the diameter, or for the problem of hull searching? In addition to the particular problems we have studied, the more general contribution of this paper is the entire approach of giving approximate answers. The technique we used to achieve an approximate answer is straightforward and applicable in many contexts: we solve a smaller problem comprised of a judiciously chosen sample of the input. The number of points in the sample controls the accuracy of the approximation, and the way the sample is selected controls the type of approximation (i.e., liberal or conservative.) These methods can prove to be a useful tool for practicing programmers. Acknowledgment. The authors would like to thank M.I. Shamos for suggesting the idea of approximation algorithms for the problems discussed in this paper. Received 4/80; revised 10/80; accepted 6/81 References !. Bentley, J.L. and Shamos, M.I. Divide and conquer for linear expected time. Information Processing Lett. 7, 2, (Feb. 1978), 87-91. 2. Brown, K. Q. Geometric transforms for fast geometric algorithms. Ph.D. Thesis, Carnegie-Mellon University, December 1979. Carnegie-Mellon Computer Science Tech. Rept. CMU-CS-80101. 3. Devroye, L. A note on finding convex hulls via maximal vectors. Information Processing Letts. 11, 1, 53-56. 4. Graham, R.L. An efficient algorithm for determining the convex hull of a finite planar set. Information Processing Lett. 1, 132-133. 5. Lipton, R.J. and Tarjan, R.E. Application of a planar separator theorem. 18th Syrup. Foundations of Computer Science (Oct. 1977), IEEE, pp. 162-170. 6. Preparata, F.P. An optimal real-time algorithm for convex hulls. Comm. ACM 22, 7, (July 1979). 402-405. 7. Preparata, F.P. and Hong, S.J. Convex hulls of finite sets in two and three dimensions. Comm. ACM 20, 2, (Feb. 1977), 87-93. 8. Shamos, M.I. Computational geometry. Unpublished Ph.D. Thesis, Yale University (May 1978), New Haven, Connecticut. 9. Yao, A.C. On constructing minimum spanning trees in kdimensional space and related problems. Stanford University Computer Science Department Report STAN-CS-77-642, (Dec. 1977). 10. Yao, A. C. A lower bound to finding convex hulls. Stanford University Computer Science Department Report STAN-CS-79-733, (April 1979). Communications of the ACM January 1982 Volume 25 Number 1