Showing papers presented at "Symposium on Computational Geometry in 1988"

Applications of random sampling in computational geometry, II

Abstract: Random sampling is used for several new geometric algorithms. The algorithms are “Las Vegas,” and their expected bounds are with respect to the random behavior of the algorithms. One algorithm reports all the intersecting pairs of a set of line segments in the plane, and requires O(A + n log n) expected time, where A is the size of the answer, the number of intersecting pairs reported. The algorithm requires O(n) space in the worst case. Another algorithm computes the convex hull of a point set in E3 in O(n log A) expected time, where n is the number of points and A is the number of points on the surface of the hull. A simple Las Vegas algorithm triangulates simple polygons in O(n log log n) expected time. Algorithms for half-space range reporting are also given. In addition, this paper gives asymptotically tight bounds for a combinatorial quantity of interest in discrete and computational geometry, related to halfspace partitions of point sets.

Motion planning in the presence of movable obstacles

Abstract: Motion planning algorithms have generally dealt with motion in a static environment, or more recently, with motion in an environment that changes in a known manner. We consider the problem of finding collision-free motions in a changeable environment. That is, we wish to find a motion for an object where the object is permitted to move some of the obstacles. In such an environment the final positions of the movable obstacles may or may not be part of the goal. In the case where the final positions of the obstacles are unspecified, the motion planning problem is shown to be NP-hard. An algorithm that runs in O(n2logn) time after O(n3log2n) preprocessing time is presented when the object to be moved is polygonal and there is only one movable polygonal obstacle in a polygonal environment of complexity O(n). In the case where the final positions of the obstacles are specified the general problem is shown to be PSPACE-hard and an algorithm is given when there is one movable obstacle with the same preprocessing time as the previous algorithm but with O(n2) query time.

New methods for computing visibility graphs

Abstract: Let S be a set of n non-intersecting line segments in the plane The visibility graph GS of S is the graph that has the endpoints of the segments in S as nodes and in which two nodes are adjacent whenever they can “see” each other (ie, the open line segment joining them is disjoint from all segments or is contained in a segment) Two new methods are presented to construct GS Both methods are very simple to implement The first method is based on a new solution to the following problem: given a set of points, for each point sort the other points around it by angle It runs in time O(n2) The second method uses the fact that visibility graphs often are sparse and runs in time O(m log n) where m is the number of edges in GS Both methods use only Ogr;(n) storage

Clustering algorithms based on minimum and maximum spanning trees

Abstract: We consider clustering problems under two different optimization criteria. One is to minimize the maximum intracluster distance (diameter), and the other is to maximize the minimum intercluster distance. In particular, we present an algorithm which partitions a set S of n points in the plane into two subsets so that their larger diameter is minimized in time O(n log n) and space O(n). Another algorithm with the same bounds computes a k-partition of S for any k so that the minimum intercluster distance is maximized. In both instances it is first shown that an optimal parition is determined by either a maximum or minimum spanning tree of S.

A geometric consistency theorem for a symbolic perturbation scheme

Abstract: In a previous paper, we introduced a generic solution to the problem of data degeneracy in geometric algorithms. The scheme is simple to use: algorithms qualifying under our requirements just have to use a prescribed blackbox for polynomial evaluation in order to achieve a symbolic perturbation of data. In this paper, we introduce the concept of an infinitesimal perturbation and show that our method is consistent relative to such perturbations.

Partition trees for triangle counting and other range searching problems

Abstract: The range searching problems which allow partition trees where every query enters only a sublinear number of nodes are characterized as those with finite Vapnik - Chervonenk is dimension.The concrete combinatorial bounds obtained imply—among others — that every set of n points in the planecan be stored in an O(n) space data structure which allows triangle counting queries in O(√n· log3n) time, andcan be stored in an O(n · log n) space data structure which allows disk counting queries in O(√n· log3n) time; the preprocessing time for the data structures is polynomial. Recent results by Chazelle entail that these bounds for space and query time are optimal up to polylog — factors.

Simulation of simplicity: a technique to cope with degenerate cases in geometric algorithms

Abstract: This paper describes a general purpose programming technique, called the Simulation of Simplicity, which can be used to cope with degenerate input data for geometric algorithms. It relieves the programmer from the task to provide a consistent treatment for every single special case that can occur. The programs that use the technique tend to be considerably smaller and more robust than those obtained without using it. We believe that this technique will become a standard tool in writing geometric software.

Towards implementing robust geometric computations

Abstract: Computational geometry has the unique opportunity to bridge the sharp gap between theoretical and applied computer science. Indeed, practical computations with geometric objects are of intense interest to a wide range of applied work including computer aided design, robotics, mathematics, engineering, etc. At the same time, these computations pose many challenging problems of considerable theoretical depth and interest.

An efficient output-sensitive hidden surface removal algorithm and its parallelization

Abstract: In this paper we present an algorithm for hidden surface removal for a class of polyhedral surfaces which have a property that they can be ordered relatively quickly like the terrain maps A distinguishing feature of this algorithm is that its running time is sensitive to the actual size of the visible image rather than the total number of intersections in the image plane which can be much larger than the visible image The time complexity of this algorithm is O((k +n)lognloglogn) where n and k are respectively the input and the output sizes Thus, in a significant number of situations this will be faster than the worst case optimal algorithms which have running time O(n2) irrespective of the output size (where as the output size k is O(n2) only in the worst case) We also present a parallel algorithm based on a similar approach which runs in time O(log4(n+k)) using O((n + k)/log(n+k)) processors in a CREW PRAM model All our bounds are obtained using ammortized analysis

Efficient algorithms for Euclidean shortest path and visibility problems with polygonal obstacles

Abstract: The problem of determining the Euclidean shortest path between two points in the presence of m simple polygonal obstacles is studied. An O( m2 logn + nlogn ) algorithm is developed, where n is the total number of points in the obstacles. A simple O(E+T) algorithm for determining the visibility graph is also shown, where E is the number of visibility edges and T is the time for triangulating the point set. This is extended to a O(Es + nlogn) algorithm for the shortest path problem where Es is bounded by m2.

On planning assemblies

Abstract: This paper concerns the problem of assembling composite objects. We study the problem on two fronts; Firstly we study the complexity of deciding the existence of an assembly sequence and show that this is PSPACE-hard in general. Secondly we define a new measure of complexity, one that attempts to measure the minimum number of hands required to assemble a given composite. We analyze various classes of composite objects with respect to this measure.

Recipes for geometry and numerical analysis - Part I: an empirical study

Abstract: Geometric computations, like all numerical procedures, are extremely prone to roundoff error. However, virtually none of the numerical analysis literature directly applies to geometric calculations. Even for line intersection, the most basic geometric operation, there is no robust and efficient algorithm. Compounding the difficulties, many geometric algorithms perform iterations of calculations reusing previously computed data. In this paper, we explore some of the main issues in geometric computations and the methods that have been proposed to handle roundoff errors. In particular, we focus on one method and apply it to a general iterative intersection problem. Our initial results seem promising and will hopefully lead to robust solutions for more complex problems of computational geometry.

Algorithms for diametral pairs and convex hulls that are optimal, randomized, and incremental

Abstract: We give a simple algorithmic technique for building geometric structures. The technique is randomized and incremental. As an application, we give an algorithm of this kind for computing the intersection of a set of halfspaces in three dimensions. (This intersection problem is linear-time equivalent to the computation of the convex hull of a point set.) The algorithm requires O(n log n) expected time, where the expectation is over the random behavior of the algorithm. A similar algorithm can be used to determine the intersection of a set of unit balls in E3, the problem of spherical intersection. This problem arises in the computation of the diameter of a point set in E3. For a set S of n points, the diameter of S is the greatest distance between two points in S. We give a randomized reduction from the problem of determining the diameter to the problem of computing spherical intersections, resulting in a Las Vegas algorithm for the diameter requiring O(n log n) expected time. The best algorithms previously known for this problem have worst-case time bounds no better than O(n √n log n) [Agg].

Optimal parallel algorithms for polygon and point-set problems

Abstract: In this paper we give parallel algorithms for a number of problems defined on polygons and point sets. All of our algorithms have optimal T(n) *P(n) products, where T(n) is the time complexity and P(n) is the number of processors used, and are for the EREW PRAM or CREW PRAM models. In addition, our algorithms provide parallel analogues to well known phenomena from sequential computational geometry, such as the fact that problems for polygons can oftentimes be solved more efficiently that point-set problems, and that one can solve nearest-neighbor problems without explicitly constructing a Voronoi diagram.

Arrangements of lines in 3-space: a data structure with applications

Abstract: Let an arrangement of blue lines in 3-space be fixed, and imagine a movable red line entangled in the arrangement. We show an O(n4a(n)) algorithm for building a data structure that permits enumeration of mutually inaccessible classes of such red lines, where a(n) is the inverse Ackermann function. The core of the algorithm is a construction of O(n2) 2-D arrangement of hyperbolas, each in O(n2a(n)) time.The algorithm is applied to stabbing 3-polytopes, enumerating pairwise-visible face pairs, enumerating 2-D projections of convex 4-polytopes, and other problems, resulting in O(n4a(n)) algorithms in each case.

The complexity of planar compliant motion planning under uncertainty

Abstract: We consider the computational complexity of planning compliant motions in the plane, given geometric bounds on the uncertainty in sensing and control. We can give efficient algorithms for generating and verifying compliant motion strategies that are guaranteed to succeed as long as the sensing and control uncertainties lie within the specified bounds. We also consider the case where a compliant motion plan is required to succeed over some parametric family of geometries. While these problems are known to be intractable in 3D, we identify tractable subclasses in the plane.

Path planning in 0/1/ weighted regions with applications

Abstract: We consider the terrain navigation problem in a two-dimensional polygonal subdivision consisting of obstacles, “free” regions (in which one can travel at no cost), and regions in which cost is proportional to distance traveled. This problem is a special case of the weighted region problem and is a generalization of the well-known planar shortest path problem in the presence of obstacles. We present an O(n2) exact algorithm for this problem and faster algorithms for the cases of convex free regions and/or obstacles. We generalize our algorithm to allow arbitrary weights on the edges of the subdivision. In addition, we present algorithms to solve a variety of important applications: (1) an O(n2W) algorithm for finding lexicographically shortest paths in weighted regions (with W different weights); (2) an O(k2n2) algorithm for planning least-risk paths in a simple polygon that contains k line-of-sight threats (this becomes O(k4n4) in polygons with holes); and (3) an O(k2n3) algorithm for finding least-risk watchman routes in simple rectilinear polygons (a watchman route is such that each point in the polygon is visible from at least one point along the route).

Hidden surface removal for rectangles

Abstract: A simple but important special case of the hidden surface removal problem is one in which the scene consists of n rectangles with sides parallel to the x and y-axes, with viewpoint at z = ∞ (that is, an orthographic projection). This special case has application to overlapping windows. An algorithm with running time O(n log n log log n + k log n) is given for static scenes, where k is the number of line segments in the output. Algorithms are given for a dynamic setting (that is, rectangles may be inserted and deleted) that take time O(log2n log log n + k log2n) per insert or delete, where k is now the number of visible line segments that change (appear or disappear). Algorithms for point location in the visible scene are also given.

A fast Las Vegas algorithm for triangulating a simple polygon

Abstract: We present an algorithm that triangulates a simple polygon on n vertices in O(n log*n) expected time. The algorithm uses random sampling on the input, and its running time does not depend on any assumptions about a probability distribution from which the polygon is drawn.

On continuous Homotopic one layer routing

Abstract: We give an O(n3·log n) time and O(n3) space algorithm for the continuous homotopic one layer routing problem. The main contribution is an extension of the sweep paradigm to a universal cover space of the plane.

The complexity of many faces in arrangements of lines of segments

Abstract: We show that the total number of edges of m faces of an arrangement of n lines in the plane is O(m2/3-dn2/3+2d + n), for any d > 0. The proof takes an algorithmic approach, that is, we describe an algorithm for the calculation of these m faces and derive the upper bound from the analysis of the algorithm. The algorithm uses randomization and, with high probability, its time complexity is within a log2n factor of the above bound. If instead of lines we have an arrangement of n line segments, then the maximum number of edges of m faces is Ogr;(m2/3-dn2/3+2d + na(n)logm), for any d > 0, where a(n) is the functional inverse of Ackermann's function. We give a (randomized) algorithm that produces these faces and, with high probability, takes time that is within a log2n factor of the combinatorial bound.

Algorithms for vertical and orthogonal L1 linear approximation of points

Abstract: This paper presents algorithms for approximating a set of n points by a linear function, or a line, that minimizes the L1 norm of vertical and orthogonal distances. The algorithms find exact solutions based upon geometric properties of the problems as opposed to approximate solutions based upon existing numerical techniques. The algorithmic complexity of these problems appears not to have been investigated before our work in [9], although O(n3) naive algorithms can be easily obtained based on some simple characteristics of optimal L1 solutions. In this paper, an O(n) optimal time algorithm for the weighted vertical L1 problem is presented. The algorithm is based upon a modified multi-dimensional search technique which extends the applicability of the basic technique to a wider class of problems. An O(n1.5 log2n) algorithm is presented for the unweighted orthogonal problem, and an O(n2) algorithm is presented for the weighted problem. An O(n log n) lower bound for the orthogonal L1 problem is shown under a certain model of computation. Also, the complexity of solving the orthogonal L1 problem is related to the construction of the k-belt of an arrangement of lines.

Covering orthogonal polygons with star polygons: the perfect graph approach

Abstract: We consider the problem of covering simple orthogonal polygons with star polygons. A star polygon contains a point p, such that for every point q in the star polygon, there is an orthogonally convex polygon containing p and q.In general, orthogonal polygons can have concavities (dents) with four possible orientations. In this case, we show that the polygon covering problem can be reduced to the problem of covering a weakly triangulated graph with a minimum number of cliques. We thus obtain a O (n10) algorithm. Since weakly triangulated graphs are perfect, we also obtain an interesting duality relationship.In the case where the polygon has at most three dent orientations, we show that the polygon covering problem can be reduced to the problem of covering a triangulated (chordal) graph with a minimum number of cliques. This gives us an O (n3) algorithm.

Polyhedral line transversals in space

Abstract: Algorithms are developed for determining if a set of polyhedral objects inR3 can be intersected by a common transversal (stabbing) line. It can be determined inO(n logn) time if a set ofn line segments in space has a line transversal, and such a transversal can be found in the same time bound. For a set of polyhedra with a total ofn vertices, we give anO(n4 logn) algorithm for determining the existence of, and computing, a line transversal. Helly-type theorems for lines and segments are also given. In particular, it is shown that if every six of a set of lines in space are intersected by a common transversal, then the entire set has a common transversal.

On maximum flows in polyhedral domains

Abstract: We introduce a new class of problems concerned with the computation of maximum flows through two-dimensional polyhedral domains. Given a polyhedral space (e.g., a simple polygon with holes), we want to find the maximum “flow” from a source edge to a sink edge. Flow is defined to be a divergence-free vector field on the interior of the domain, and capacity constraints are specified by giving the maximum magnitude of the flow vector at any point. Strang proved that max flow equals min cut; we address the problem of constructing min cuts and max flows. We give polynomial-time algorithms for maximum flow from a source edge to a sink edge through a simple polygon with uniform capacity constraint (with or without holes), maximum flow through a simple polygon from many sources to many sinks, and maximum flow through weighted polygonal regions. Central to our methodology is the intimate connection between the max-flow problem and its dual, the min-cut problem. We show how the continuous Dijkstra paradigm of solving shortest paths problems corresponds to a continuous version of Berge's algorithm for computation of maximum flow in a planar network.

Computing Euclidean maximum spanning trees

Abstract: An algorithm is presented for finding a maximum-weight spanning tree of a set of n points in the Euclidean plane, where the weight of an edge (pi, pj) equals the Euclidean distance between the points pi and pj. The algorithm runs in time O (n logn) and requires O (n) space. If the points are vertices of a convex polygon (given in order along the boundary), then our algorithm requires only a linear amount of time and space. These bounds are the best possible in the algebraic computation-tree model. We also establish various properties of maximum spanning trees that can be exploited to solve other geometric problems.

Searching for empty convex polygons

Abstract: A key problem in computational geometry is the identification of subsets of a point set having particular properties. We study this problem for the properties of convexity and emptiness. We show that finding empty triangles is related to the problem of determining pairs of vertices that see each other in a star-shaped polygon. A linear time algorithm for this problem which is of independent interest yields an optimal algorithm for finding all empty triangles. This result is then extended to an algorithm for finding empty convex r-gons (r > 3) and for determining a largest empty convex subset. Finally, extensions to higher dimensions are mentioned.

Analysis of a simple yet efficient convex hull algorithm

Abstract: This paper is concerned with a simple, rather intuitive preprocessing step that is likely to improve the average-case performance of any convex hull algorithm. For n points randomly distributed in the unit square, we show that a simple linear pass through the points can eliminate all but O(√n) of the points by showing that a simple superset of the remaining points has size c√n + o(√n). We give a full implementation of the method, which should be useful in any practical application for finding convex hulls. Most of the paper is concerned with an analysis of the number of points eliminated by the procedure, including derivation of an exact expression for c. Extensions to higher dimensions are also considered.

Skewed projections with an application to line stabbing in R3

Abstract: A new geometrical transform, skewed-projection, is introduced. This transform is applied to design a new algorithm for a common transversal problem for families of polyhedra in R3. The time and space analysis, using Davenport-Schinzel sequences, is given.

The design of LINETOOL, a geometric editor

Abstract: We describe the design of LINETOOL, a geometric editor. Researchers in the areas of computational geometry, robotics and algebraic computation need a graphical editor for composing geometric objects which does more than simply turn pixels on and off on the screen. This system will be a tool to help researchers make and demolish conjectures, and to experiment with ideas. Our editor will allow users to define geometric scenes by declaring geometric objects built up from constants, dependent and independent variables, and geometric constraints. The system will solve for the constraints, and display the resulting scene. The user may then make queries about spatial relationships between components of geometric objects in the scene, which will be answered correctly, that is, without errors due to numerical approximations.