Computational Geometry

Published by Elsevier
Online ISSN: 0925-7721
Publications
Article
Many properties of finite point sets only depend on the relative position of the points, e.g., on the order type of the set. However, many fundamental algorithms in computational geometry rely on coordinate representations. This includes the straightforward algorithms for finding a halving line for a given planar point set, as well as finding a point on the convex hull, both in linear time. In his monograph Axioms and Hulls, Knuth asks whether these problems can be solved in linear time in a more abstract setting, given only the orientation of each point triple, i.e., the set's chirotope, as a source of information. We answer this question in the affirmative. More precisely, we can find a halving line through any given point, as well as the vertices of the convex hull edges that are intersected by the supporting line of any two given points of the set in linear time. We first give a proof for sets realizable in the Euclidean plane and then extend the result to non-realizable abstract order types.
 
Blocking a black point by placing two white points in its Voronoi cell.
A (14,5,6)-cut and the retriangulated subset. (Colored vertices are shown (half) encircled For the complete color version in this figure, the reader is referred to the web version of this article.)
The two cases for a convex set: removing an ear (a), and removing an inner triangle with two incident ears (b). (Colored vertices are shown (half) encircled and colored edges are marked with an “x”. For the complete color version in this figure, the reader is referred to the web version of this article.)
Euros proving a lower bound of n white points.
Article
Given a set B of n black points in general position, we say that a set of white points W blocks B if in the Delaunay triangulation of [Formula: see text] there is no edge connecting two black points. We give the following bounds for the size of the smallest set W blocking B: (i) [Formula: see text] white points are always sufficient to block a set of n black points, (ii) if B is in convex position, [Formula: see text] white points are always sufficient to block it, and (iii) at least [Formula: see text] white points are always necessary to block a set of n black points.
 
Article
We study the problem how to draw a planar graph crossing-free such that every vertex is incident to an angle greater than π. In general a plane straight-line drawing cannot guarantee this property. We present algorithms which construct such drawings with either tangent-continuous biarcs or quadratic Bézier curves (parabolic arcs), even if the positions of the vertices are predefined by a given plane straight-line drawing of the graph. Moreover, the graph can be drawn with circular arcs if the vertices can be placed arbitrarily. The topic is related to non-crossing drawings of multigraphs and vertex labeling.
 
Conference Paper
A number of rendering algorithms in computer graphics sort three-dimensional objects by depth and assume that there is no cycle that makes the sorting impossible. One way to resolve the problem caused by cycles is to cut the objects into smaller pieces. The problem of estimating how many such cuts are always sufficient is addressed. A few related algorithmic and combinatorial geometry problems are considered
 
Conference Paper
The construction of shape spaces is studied from a mathematical and a computational viewpoint. A program is outlined, reducing the problem to four tasks: the representation of geometry, the canonical deformation of geometry, the measuring of distance in shape space, and the selection of base shapes. The technical part of the paper focuses on the second task: the specification of a deformation mixing two or more shapes in continuously changing proportions
 
Article
Goodman and Pollack have asked to estimate the probabilities of order types by using a uniformly distributed random generator on the unit interval. We provide solutions to this question, and we apply these methods for estimating the probability for various combinatorial types of polytopes with up to 8 points in dimension 3. Our investigation also confirms a classification result in oriented matroid theory (Bokowski and Richter-Gebert).
 
Article
There are many problems in computational geometry for which the best know algorithms take time Θ(n2) (or more) in the worst case while only very low lower bounds are known. In this paper we describe a large class of problems for which we prove that they are all at least as difficult as the following base problem 3sum: Given a set S of n integers, are there three elements of S that sum up to 0. We call such problems 3sum-hard. The best known algorithm for the base problem takes Θ(n2) time. The class of 3sum-hard problems includes problems like: Given a set of lines in the plane, are there three that meet in a point?; or: Given a set of triangles in the plane, does their union have a hole? Also certain visibility and motion planning problems are shown to be in the class. Although this does not prove a lower bound for these problems, there is no hope of obtaining o(n2) solutions for them unless we can improve the solution for the base problem.
 
Article
It is shown that in any polygonal art gallery of n sides it is possible to place ⌊n/3⌋ point guards whose range of vision is 180° so that every interior point of the gallery can be seen by at least one of them. The guards can be stationed at any point of the art gallery. This settles an open problem posed by J. Urrutia.
 
Article
We present an efficient algorithm for finding k nearest neighbors of a query line segment among a set of points distributed arbitrarily on a two dimensional plane. Along the way to finding this algorithm, we have obtained an improved triangular range searching technique in 2D. Given a set of n points, we preprocess them to create a data structure using O(n2) time and space, such that given a triangular query region Δ, the number of points inside Δ can be reported in O(logn) time. Finally, this triangular range counting technique is used for finding k nearest neighbors of a query straight line segment in O(log2n+k) time.
 
Article
This paper describes a new computational geometry technique, almost-Delaunay simplices, that was implemented for 3D points using CGAL. Almost-Delaunay simplices capture possible sets of Delaunay neighbors in the presence of a bounded perturbation, and give a framework for nearest neighbor analysis in imprecise point sets such as protein structures. The use of CGAL helps us tune our implementation so that it is reasonably fast and also performs robust computation for all inputs, and also lets us distribute our technique to potential users in a portable, reusable and extensible form. The implementation, available on http://www.cs.unc.edu/~debug/software is faster and more memory efficient than our prototype MATLAB implementation, and enables us to scale our neighbor analysis to large sets of protein structures, each with 100–3000 residues.
 
Article
It is well known that the complexity, i.e. the number of vertices, edges and faces, of the 3-dimensional Voronoi diagram of n points can be as bad as Θ(n2). It is also known that if the points are chosen Independently Identically Distributed uniformly from a 3-dimensional region such as a cube or sphere, then the expected complexity falls to O(n). In this paper we introduce the problem of analyzing what occurs if the points are chosen from a 2-dimensional region in 3-dimensional space. As an example, we examine the situation when the points are drawn from a Poisson distribution with rate n on the surface of a convex polytope. We prove that, in this case, the expected complexity of the resulting Voronoi diagram is O(n).
 
Article
A line ℓ is called a stabbling line for a set of convex polyhedra in 3 if it intersects every polyhedron of . This paper presents an upper bound of O(n3log n) on the complexity of the space of stabbling lines for , where n is the number of edges in the polyhedra of . We solve a more general problem that counts the number of faces in a set of convex polyhedra, which are implicitly defined by a set of half-spaces and a set of hyperplanes. We show that the former problem is a special case of the latter problem. We also apply this technique to obtain an upper bound on the number of distinct faces that ever appear on the intersection of a set of half-spaces as we insert or delete half-spaces dynamically.
 
Article
Nef polyhedra in d-dimensional space are the closure of half-spaces under boolean set operations. In consequence, they can represent non-manifold situations, open and closed sets, mixed-dimensional complexes, and they are closed under all boolean and topological operations, such as complement and boundary. They were introduced by W. Nef in his seminal 1978 book on polyhedra. The generality of Nef complexes is essential for some applications.In this paper, we present a new data structure for the boundary representation of three-dimensional Nef polyhedra and efficient algorithms for boolean operations. We use exact arithmetic to avoid well-known problems with floating-point arithmetic and handle all degeneracies. Furthermore, we present important optimizations for the algorithms, and evaluate this optimized implementation with extensive experiments. The experiments supplement the theoretical runtime analysis and illustrate the effectiveness of our optimizations. We compare our implementation with the Acis CAD kernel. Acis is mostly faster, by a factor up to six. There are examples on which Acis fails.The implementation was released as Open Source in the Computational Geometry Algorithm Library (Cgal) release 3.1 in December 2004.
 
Article
In this paper we study various geometric predicates for determining the existence of and categorizing the configurations of lines in 3D that are transversal to lines or segments. We compute the degrees of standard procedures of evaluating these predicates. The degrees of some of these procedures are surprisingly high (up to 168), which may explain why computing line transversals with finite-precision floating-point arithmetic is prone to error. Our results suggest the need to explore alternatives to the standard methods of computing these quantities.
 
Article
Let T be a set of n triangles in three-dimensional space, let s be a line segment, and let t be a triangle, both disjoint from T. We consider the subdivision of T based on (in)visibility from s; this is the visibility map of the segment s with respect to T. The visibility map of the triangle t is defined analogously. We look at two different notions of visibility: strong (complete) visibility, and weak (partial) visibility. The trivial Ω(n2) lower bound for the combinatorial complexity of the strong visibility map of both s and t is almost tight: we prove an O(n2α(n)) upper bound for both structures, where α(n) is the extremely slowly increasing inverse Ackermann function. Furthermore, we prove that the weak visibility map of s has complexity Θ(n5), and the weak visibility map of t has complexity Θ(n7). If T is a polyhedral terrain, the complexity of the weak visibility map is Ω(n4) and O(n5), both for a segment and a triangle. We also present efficient algorithms to compute all discussed structures.
 
Article
In this paper, we study a sweeping algorithm for computing the arrangement of a set of quadrics in R3. We define a “trapezoidal” decomposition in the sweeping plane, and we study the evolution of this subdivision during the sweep. A key point of this algorithm is the manipulation of algebraic numbers. In this perspective, we put a large emphasis on the use of algebraic tools, needed to compute the arrangement, including Sturm sequences and Rational Univariate Representation of the roots of a multivariate polynomial system.
 
Article
This paper investigates the basic problem of computing crossing-free straight-line 3D grid drawings of graphs such that the overall volume is small. Motivated by their relevance in the literature, we focus on families of graphs having constant queue number and on k-trees. We present algorithms that compute drawings of these families of graphs on 3D grids consisting of a constant number of parallel lines and such that the overall volume is linear. Lower bounds on the number of such grid lines are also provided. Our results extend and improve similar ones already described in the literature.
 
Conference Paper
We study the problem of how to obtain an integer realization of a 3d polytope when an integer realization of its dual polytope is given. We focus on grid embeddings with small coordinates and develop novel techniques based on Colin de Verdi\`ere matrices and the Maxwell-Cremona lifting method. We show that every truncated 3d polytope with n vertices can be realized on a grid of size O(n^44). Moreover, for every simplicial 3d polytope with maximal vertex degree {\Delta} and vertices placed on an L x L x L grid, a dual polytope can be realized on an integer grid of size L^O({\Delta}). This implies that for a class C of simplicial 3d polytopes with bounded vertex degree and polynomial size grid embedding, the dual polytopes of C can be realized on a polynomial size grid as well.
 
Article
We prove that, in all dimensions d⩾4, every simple open polygonal chain and every tree may be straightened, and every simple closed polygonal chain may be convexified. These reconfigurations can be achieved by algorithms that use polynomial time in the number of vertices, and result in a polynomial number of “moves”. These results contrast to those known for d=2, where trees can “lock”, and for d=3, where open and closed chains can lock.
 
Article
Range searching is a well known problem in the area of geometric data structures. We consider this problem in the context of approximation, where an approximation parameter ε>0 is provided. Most prior work on this problem has focused on the case of relative errors, where each range shape R is bounded, and points within distance ε⋅diam(R) of the range's boundary may or may not be included. We consider a different approximation model, called the absolute model, in which points within distance ε of the range's boundary may or may not be included, regardless of the diameter of the range. We consider range spaces consisting of halfspaces, Euclidean balls, simplices, axis-aligned rectangles, and general convex bodies. We consider a variety of problem formulations, including range searching under general commutative semigroups, idempotent semigroups, groups, and range emptiness. We show how idempotence can be used to improve not only approximate, but also exact halfspace range searching. Our data structures are much simpler than both their exact and relative model counterparts, and so are amenable to efficient implementation.
 
Chapter
The simple abstract Voronoi diagram in 3-space is introduced as an abstraction of the usual Euclidean Voronoi diagram. We show that the three-dimensional simple abstract Voronoi diagram of n sites can be computed in O(n 2) expected time using O(n 2) expected space by a randomized algorithm.
 
Article
A convex geometry is a combinatorial abstract model introduced by Edelman and Jamison which captures a combinatorial essence of “convexity” shared by some objects including finite point sets, partially ordered sets, trees, rooted graphs. In this paper, we introduce a generalized convex shelling, and show that every convex geometry can be represented as a generalized convex shelling. This is “the representation theorem for convex geometries” analogous to “the representation theorem for oriented matroids” by Folkman and Lawrence. An important feature is that our representation theorem is affine-geometric while that for oriented matroids is topological. Thus our representation theorem indicates the intrinsic simplicity of convex geometries, and opens a new research direction in the theory of convex geometries.
 
Article
Shape deformation refers to the continuous change of one geometric object to another. We develop a software tool for planning, analyzing and visualizing deformations between two shapes in . The deformation is generated automatically without any user intervention or specification of feature correspondences. A unique property of the tool is the explicit availability of a two-dimensional shape space, which can be used for designing the deformation either automatically by following constraints and objectives or manually by drawing deformation paths.
 
Article
Deciding whether the union of two convex polyhedra is itself a convex polyhedron is a basic problem in polyhedral computations; having important applications in the field of constrained control and in the synthesis, analysis, verification and optimization of hardware and software systems. In such application fields though, general convex polyhedra are just one among many, so-called, numerical abstractions, which range from restricted families of (not necessarily closed) convex polyhedra to non-convex geometrical objects. We thus tackle the problem from an abstract point of view: for a wide range of numerical abstractions that can be modeled as bounded join-semilattices—that is, partial orders where any finite set of elements has a least upper bound—we show necessary and sufficient conditions for the equivalence between the lattice-theoretic join and the set-theoretic union. For the case of closed convex polyhedra—which, as far as we know, is the only one already studied in the literature—we improve upon the state-of-the-art by providing a new algorithm with a better worst-case complexity. The results and algorithms presented for the other numerical abstractions are new to this paper. All the algorithms have been implemented, experimentally validated, and made available in the Parma Polyhedra Library.
 
Article
For a given polygonal chain, we study the min-# problem, which consists of finding an approximate and ordered subchain with a minimum number of vertices under a given approximation criterion. We propose the first near-linear time algorithm for the min-# problem that ensures optimality in the number of vertices and that retains the shape of the input polygonal chain at the same time. Previous algorithms with near-linear time performance produced geometrical inconsistencies and former methods used to preserve the features of the original chain required a quadratic time complexity. When we set the approximation error equal to the pixel pitch, our simplification criterion guarantees that the rendering of the simplification lies at most half a pixel away from the original chain, contrary to other methods that do not offer a direct control over the rendering. Thus, we avoid producing visible topological inconsistencies. Moreover, our method is based on basic data structures, which leads to a simple and efficient implementation.
 
Article
It is shown that there exists a dihedral acute triangulation of the three-dimensional cube. The method of constructing the acute triangulation is described, and symmetries of the triangulation are discussed. Comment: Minor edits for journal version. Added some material to the introduction
 
Article
We show it is possible to tile three-dimensional space using only tetrahedra with acute dihedral angles. We present several constructions to achieve this, including one in which all dihedral angles are less than 74.21°, and another which tiles a slab in space.
 
Article
Geometric algorithms are based on geometric objects such as points, lines and circles. The term kernel refers to a collection of representations for constant-size geometric objects and operations on these representations. This paper describes how such a geometry kernel can be designed and implemented in C++, having special emphasis on adaptability, extensibility and efficiency. We achieve these goals following the generic programming paradigm and using templates as our tools. These ideas are realized and tested in Cgal, the Computational Geometry Algorithms Library, see http://www.cgal.org/.
 
Article
Spacetime-discontinuous Galerkin (SDG) finite element methods are used to solve hyperbolic spacetime partial differential equations (PDEs) to accurately model wave propagation phenomena arising in important applications in science and engineering. Tent Pitcher is a specialized algorithm, invented by Üngör and Sheffer (2000) and extended by Erickson et al. (2005) to construct an unstructured simplicial -dimensional spacetime mesh over an arbitrary d-dimensional space domain. Tent Pitcher is an advancing front algorithm that incrementally adds groups of elements to the evolving spacetime mesh. It supports an accurate, local, and parallelizable solution strategy by interleaving mesh generation with an SDG solver. When solving nonlinear PDEs, previous versions of Tent Pitcher must make conservative worst-case assumptions about the physical parameters which limit the duration of spacetime elements. Thus, these algorithms create a mesh with many more elements than necessary. In this paper, we extend Tent Pitcher to give the first spacetime meshing algorithm suitable for efficient simulation of nonlinear phenomena using SDG methods. We adapt the duration of spacetime elements to changing physical parameters due to nonlinear response. Given a triangulated 2-dimensional Euclidean space domain M corresponding to time and initial and boundary conditions of the underlying hyperbolic spacetime PDE, we construct an unstructured tetrahedral mesh in the spacetime domain . For every target time , our algorithm meshes the spacetime volume with a bounded number of non-degenerate tetrahedra. A recent extension of Tent Pitcher due to Abedi et al. (2004) adapts the spatial size of spacetime elements in 2D × time to a posteriori estimates of numerical error. Our extension of Tent Pitcher retains the ability to perform adaptive refinement and coarsening of the mesh. We thus obtain the first adaptive nonlinear Tent Pitcher algorithm to build spacetime meshes in 2D × time.
 
Article
We propose a new definition of fatness of geometric objects and compare it with alternative definitions. We show that, under some realistic assumptions, the complexity of the free space for a robot, with any fixed number of degrees of freedom moving in a d-dimensional Euclidean workspace with fat obstacles, is linear in the number of obstacles. The complexity of motion planning algorithms depends on the complexity of the robot's free space, and theoretically, the complexity of the free space can be very high. Thus, our result opens the way to devising provable efficient motion planning algorithms in certain realistic settings.
 
Conference Paper
We consider right angle crossing (RAC) drawings of graphs in which the edges are represented by polygonal arcs and any two edges can cross only at a right angle. We show that if a graph with n vertices admits a RAC drawing with at most 1 bend or 2 bends per edge, then the number of edges is at most 6.5n and 74.2n, respectively. This is a strengthening of a recent result of Didimo et al..
 
Article
We introduce a family of directed geometric graphs, denoted $\paz$, that depend on two parameters $\lambda$ and $\theta$. For $0\leq \theta<\frac{\pi}{2}$ and ${1/2} < \lambda < 1$, the $\paz$ graph is a strong $t$-spanner, with $t=\frac{1}{(1-\lambda)\cos\theta}$. The out-degree of a node in the $\paz$ graph is at most $\lfloor2\pi/\min(\theta, \arccos\frac{1}{2\lambda})\rfloor$. Moreover, we show that routing can be achieved locally on $\paz$. Next, we show that all strong $t$-spanners are also $t$-spanners of the unit disk graph. Simulations for various values of the parameters $\lambda$ and $\theta$ indicate that for random point sets, the spanning ratio of $\paz$ is better than the proven theoretical bounds.
 
Article
Arrangements of planar curves are fundamental structures in computational geometry. Recently, the arrangement package of Cgal, the Computational Geometry Algorithms Library, has been redesigned and re-implemented exploiting several advanced programming techniques. The resulting software package, which constructs and maintains planar arrangements, is easier to use, to extend, and to adapt to a variety of applications. It is more efficient space- and time-wise, and more robust. The implementation is complete in the sense that it handles degenerate input, and it produces exact results. In this paper we describe how various programming techniques were used to accomplish specific tasks within the context of computational geometry in general and arrangements in particular. These tasks are exemplified by several applications, whose robust implementation is based on the arrangement package. Together with a set of benchmarks they assured the successful application of the various programming techniques.
 
Article
We study the predicates involved in an efficient dynamic algorithm for computing the Apollonius diagram in the plane, also known as the additively weighted Voronoi diagram. We present a complete algorithmic analysis of these predicates, some of which are reduced to simpler and more easily computed primitives. This gives rise to an exact and efficient implementation of the algorithm, that handles all special cases. Among our tools we distinguish an inversion transformation and an infinitesimal perturbation for handling degeneracies.The implementation of the predicates requires certain algebraic operations. In studying the latter, we aim at minimizing the algebraic degree of the predicates and the number of arithmetic operations; this twofold optimization corresponds to reducing bit complexity. The proposed algorithms are based on static Sturm sequences. Multivariate resultants provide a deeper understanding of the predicates and are compared against our methods. We expect that our algebraic techniques are sufficiently powerful and general to be applied to a number of analogous geometric problems on curved objects. Their efficiency, and that of the overall implementation, are illustrated by a series of numerical experiments. Our approach can be immediately extended to the incremental construction of abstract Voronoi diagrams for various classes of objects.
 
Article
An algorithm is proposed for the simultaneous computation of all Minkowski functionals (except for the volume) of sets from the convex ring in Rd discretized with respect to a given regular lattice. For this purpose, a polyhedral approximation is used to reconstruct their boundary structure. In the planar case d=2, the performance and precision of the algorithm is studied on various examples of particular polyconvex sets. The algorithm is implemented in Java for two different approximation systems. The results of numerical experiments are compared with those obtained by other methods known in the literature.
 
Article
We present an extensive experimental study comparing the performance of four algorithms for the following orthogonal segment intersection problem: given a set of horizontal and vertical line segments in the plane, report all intersecting horizontal-vertical pairs. The problem has important applications in VLSI layout and graphics, which are large-scale in nature. The algorithms under evaluation are our implementations of distribution sweep and three variations of plane sweep. Distribution sweep is specifically designed for the situations in which the problem is too large to be solved in internal memory, and theoretically has optimal I/O cost. Plane sweep is a well-known and powerful technique in computational geometry, and is optimal for this particular problem in terms of internal computation. The three variations of plane sweep differ by the sorting methods (external versus internal sorting) used in the preprocessing phase and the dynamic data structures (B-tree versus 2-3-4-tree) used in the sweeping phase. We generate the test data by three programs that use a random number generator while producing some interesting properties that are predicted by our theoretical analysis. The sizes of the test data range from 250 thousand segments to 2.5 million segments. The experiments provide detailed quantitative evaluation of the performance of the four algorithms, and the observed behavior of the algorithms is consistent with their theoretical properties. This is, to the best of our knowledge, the first experimental algorithmic study comparing the practical performance between external-memory algorithms and conventional algorithms with large-scale test data.
 
Article
We present algorithms for five interdistance enumeration problems that take as input a set S of n points in Rd (for a fixed but arbitrary dimension d) and as output enumerate pairs of points in S satisfying various conditions. We present: an O(n log n + k) time and O(n) space algorithm that takes as additional input a distance δ and outputs all k pairs of points in S separated by a distance of δ or less; an O(n log n + k log k) time and O(n + k) space algorithm that enumerates in non-decreasing order the k closest pairs of points in S; an O(n log n + k) time algorithm for the same problem without any order restrictions; an O(nk log n) time and O(n) space algorithm that enumerates in nondecreasing order the nk pairs representing the k nearest neighbors of each point in S; and an O(n log n + kn) time algorithm for the same problem without any order restrictions. The algorithms combine a modification of the planar approach of Dickerson, Drysdale, and Sack [11] with the method of Bern, Eppstein, and Gilbert [3] for augmenting a point set to have a linear size bounded degree Delaunay triangulation. Thus, in addition to providing new solutions to these problems, the paper also shows how the Delaunay triangulation can be used as the underlying data structure in a unified approach to proximity problems even in higher dimensions.
 
Conference Paper
Inspired by air traffic control and other applications where moving objects have to be labeled, we consider the following (static) point labeling problem: given a set P of n points in the plane and labels that are unit squares, place a label with each point in P in such a way that the number of free labels (labels not intersecting any other label) is maximized. We develop efficient constant-factor approximation algorithms for this problem, as well as PTASs, for various label-placement models.
 
Conference Paper
We give efficient algorithms for constructing a bridge between two convex regions in a fixed dimensional space so that the diameter of the bridged region is minimized. If both the set of vertices and the set of halfspaces defining the facets of the convex regions are given, we have an optimal linear time randomized algorithm. In only vertices are given, we give a subquadratic time algorithm, and if only halfspaces are given, we give a quadratic time algorithm.
 
Article
Zonoid depth is a definition of data depth proposed by Dyckerhoff et al. [R. Dyckerhoff, G. Koshevoy, K. Mosler, Zonoid data depth: Theory and computation, in: A. Prat (Ed.), COMPSTAT 1996—Proceedings in Computational Statistics, Physica-Verlag, Heidelberg, August 1996, pp. 235–240]. Efficient algorithms for solving several computational problems related to zonoid depth in 2-dimensional (bivariate) data sets are studied. These include algorithms for computing a zonoid depth map, computing a zonoid depth contour, and computing the zonoid depth of a point.
 
Article
The article is devoted to mathematical models and practical algorithms for solving the cutting and packing (C&P) problem. We review and further enhance the main tool of our studies – phi-functions. Those are constructed here for 2D and 3D objects (unlike other standard tools, such as No-Fit Polygons, which are restricted to the 2D geometry). We also demonstrate that in many realistic cases the phi-functions can be described by quite simple formulas without radicals and other complications. Lastly, a general solution strategy using the phi-functions is outlined and illustrated by several 2D and 3D examples.
 
Article
Delaunay refinement is a technique for generating unstructured meshes of triangles for use in interpolation, the finite element method, and the finite volume method. In theory and practice, meshes produced by Delaunay refinement satisfy guaranteed bounds on angles, edge lengths, the number of triangles, and the grading of triangles from small to large sizes. This article presents an intuitive framework for analyzing Delaunay refinement algorithms that unifies the pioneering mesh generation algorithms of L. Paul Chew and Jim Ruppert, improves the algorithms in several minor ways, and most importantly, helps to solve the difficult problem of meshing nonmanifold domains with small angles.Although small angles inherent in the input geometry cannot be removed, one would like to triangulate a domain without creating any new small angles. Unfortunately, this problem is not always soluble. A compromise is necessary. A Delaunay refinement algorithm is presented that can create a mesh in which most angles are 30° or greater and no angle is smaller than arcsin[(, where φ⩽60°is the smallest angle separating two segments of the input domain. New angles smaller than 30° appear only near input angles smaller than 60°. In practice, the algorithm's performance is better than these bounds suggest.Another new result is that Ruppert's analysis technique can be used to reanalyze one of Chew's algorithms. Chew proved that his algorithm produces no angle smaller than 30° (barring small input angles), but without any guarantees on grading or number of triangles. He conjectures that his algorithm offers such guarantees. His conjecture is conditionally confirmed here: if the angle bound is relaxed to less than 26.5°, Chew's algorithm produces meshes (of domains without small input angles) that are nicely graded and size-optimal.
 
Article
We show that, for any fixed constant k⩾3, the sum of the distances between all pairs of vertices of an abstract graph with n vertices and treewidth at most k can be computed in O(nlogk−1n) time.We also show that, for any fixed constant k⩾2, the dilation of a geometric graph (i.e., a graph drawn in the plane with straight-line segments) with n vertices and treewidth at most k can be computed in O(nlogk+1n) expected time. The dilation (or stretch-factor) of a geometric graph is defined as the largest ratio, taken over all pairs of vertices, between the distance measured along the graph and the Euclidean distance.The algorithms for both problems are based on the same principle: data structures for orthogonal range searching in bounded dimension provide a compact representation of distances in abstract graphs of bounded treewidth.
 
Article
We present space-efficient algorithms for computing the convex hull of a simple polygonal line in-place, in linear time. It turns out that the problem is as hard as in-place stable partition, i.e., if there were a truly simple solution then in-place stable partition would also have a truly simple solution, and vice versa. Nevertheless, we present a simple self-contained solution that uses O(logn) space, and indicate how to improve it to O(1) space with the same techniques used for stable partition. If the points inside the convex hull can be discarded, then there is a truly simple solution that uses a single call to stable partition, and even that call can be spared if only extreme points are desired (and not their order). If the polygonal line is closed, the problem admits a very simple solution which does not call for stable partitioning at all.
 
Article
Given a set S of n points in , the Oja depth of a point θ is the sum of the areas of all triangles formed by θ and two elements of S. A point in with minimum depth is an Oja median. We show how an Oja median may be computed in O(nlog3n) time. In addition, we present an algorithm for computing the Fermat–Torricelli points of n lines in O(n) time. These points minimize the sum of weighted distances to the lines. Finally, we propose an algorithm which computes the simplicial median of S in O(n4) time. This median is a point in which is contained in the most triangles formed by elements of S.
 
Article
We consider the problem of positioning text or symbol labels associated with graphical features of two dimensional maps (geographical or technical) or drawings. In many practical applications each graphical feature may have more than one label. The need for assigning multiple labels is necessary to display different attributes of an object. Even though many algorithms exist for the labeling problem, very little work has been directed towards positioning multiple labels per graphical feature in a map or drawing. We refer to this problem as the Multiple Label Placement (MLP) problem. In this paper we present a model and expand the rules that govern a good assignment of several labels per graphical feature. In addition we introduce techniques to solve this problem. We have applied these techniques to drawings of graphs, and we present very encouraging experimental results.
 
Article
We introduce boundary labeling, a new model for labeling point sites with large labels. According to the boundary-labeling model, labels are placed around an axis-parallel rectangle that contains the point sites, each label is connected to its corresponding site through a polygonal line called leader, and no two leaders intersect. Although boundary labeling is commonly used, e.g., for technical drawings and illustrations in medical atlases, this problem has not yet been studied in the literature. The problem is interesting in that it is a mixture of a label-placement and a graph-drawing problem.In this paper we investigate several variants of the boundary-labeling problem. We consider labels of identical or different size, straight-line or rectilinear leaders, fixed or sliding ports for attaching leaders to sites and attaching labels to one, two or all four sides of the bounding rectangle. For any variant of the boundary labeling model, we aim at highly esthetical placements of labels and leaders. We present simple and efficient algorithms that minimize the total leader length or, in the case of rectilinear leaders, the total number of bends.
 
Article
We present I/O-efficient algorithms for computing planar Steiner spanners for point sets and sets of polygonal obstacles in the plane.
 
Article
Several data presentation problems involve drawing graphs so that they are easy to read and understand. Examples include circuit schematics and software engineering diagrams. In this paper we present a bibliographic survey on algorithms whose goal is to produce aesthetically pleasing drawings of graphs. Research on this topic is spread over the broad spectrum of Computer Science. This bibliography constitutes an attempt to encompass both theoretical and application oriented papers from disparate areas.
 
Chapter
Consider a set of geometric objects, such as points or axes-parallel hyperrectangles in ℝd, that move with constant but possibly different velocities along linear trajectories. Efficient algorithms are presented for several problems defined on such objects, such as determining whether any two objects ever collide and computing the minimum inter-point separation or minimum diameter that ever occurs. In particular, two open problems from the literature are solved: Deciding in o(n 2) time if there is a collision in a set of n moving points in ℝ2, where the points move at constant but possibly different velocities, and the analogous problem for detecting a red-blue collision between sets of red and blue moving points. The strategy used involves reducing the given problem on moving objects to a different problem on a set of static objects, and then solving the latter problem using techniques based on sweeping, orthogonal range searching, simplex composition, and parametric search.
 
Top-cited authors
Prosenjit Bose
  • Carleton University
Jonathan Shewchuk
  • University of California, Berkeley
Ioannis G. Tollis
  • University of Crete
Joseph S. B. Mitchell
  • Stony Brook University
Peter Eades
  • The University of Sydney