Handbook of Discrete and Computational Geometry, Second Edition

Finding nearest neighbors in high-dimensional spaces is a fundamental operation in many multimedia retrieval applications. Exact tree-based indexing approaches are known to suffer from the notorious curse of dimensionality for high-dimensional data. Approximate searching techniques sacrifice some accuracy while returning good enough results for faster performance. Locality Sensitive Hashing (LSH) is a very popular technique for finding approximate nearest neighbors in high-dimensional spaces. Apart from providing theoretical guarantees on the query results, one of the main benefits of LSH techniques is their good scalability to large datasets because they are external memory based. The most dominant costs for existing LSH techniques are the algorithm time and the index I/Os required to find candidate points. Existing works do not compare both of these dominant costs in their evaluation. In this experimental survey paper, we show the impact of both these costs on the overall performance of the LSH technique. We compare three state-of-the-art techniques on four real-world datasets, and show that, in contrast to recent works, C2LSH is still the state-of-the-art algorithm in terms of performance while achieving similar accuracy as its recent competitors.

Polyhedral and Algebraic Methods in Computational Geometry provides a thorough introduction into algorithmic geometry and its applications. It presents its primary topics from the viewpoints of discrete, convex and elementary algebraic geometry. The first part of the book studies classical problems and techniques that refer to polyhedral structures. The authors include a study on algorithms for computing convex hulls as well as the construction of Voronoi diagrams and Delone triangulations. The second part of the book develops the primary concepts of (non-linear) computational algebraic geometry. Here, the book looks at Grbner bases and solving systems of polynomial equations. The theory is illustrated by applications in computer graphics, curve reconstruction and robotics. Throughout the book, interconnections between computational geometry and other disciplines (such as algebraic geometry, optimization and numerical mathematics) are established. Polyhedral and Algebraic Methods in Computational Geometry is directed towards advanced undergraduates in mathematics and computer science, as well as towards engineering students who are interested in the applications of computational geometry.

For the performance of geographic information systems, it has been widely recognized that efficient data structures and algorithms supporting proximity based access to spatial data are a crucial ingredient. Because of that, in the last years, a lot of data structures for storage of multidimensional non-point objects have been proposed in the literature (for an overview see our tutorial introduction in this volume). Almost all of these approaches are made to support queries based on spatial neighborhood of objects, so-called proximity queries. Common examples of such proximity queries are range queries, returning all objects intersecting a given (rectangular) region, or nearest neighbor queries, determining the object nearest to a given point. But a geographic or cartographic information system should also support queries that do not exclusively refer to the spatial neighborhood of objects. For example, different versions of spatial data must be organized such that proximity queries to any version of the data can be answered efficiently. Or, given a set of object classes, a spatial query that involves an arbitrary combination of these classes should also be supported. Because of the growing size of data sets to be handled in geographic information systems, an appropriate data organisation to support such and several other application-specific queries becomes more and more important. In this paper, we will present two approaches for access structures supporting the two types of queries mentioned above. Handling of versioned, spatial data is the topic of Section 2, while Section 3 discusses queries on some classes selected from the set of object classes stored in a geographic information system.

The workshop Discrete Differential Geometry , organized by Alexander I. Bobenko (Berlin), Richard W. Kenyon (Vancouver), John M. Sullivan (Berlin) and Günter M. Ziegler (Berlin), was held March 5th to March 11th, 2006. The meeting was very well attended, with almost 50 participants, from as far away as Australia and China. Discrete differential geometry is a new and active mathematical terrain where differential geometry (providing the classical theory for smooth manifolds) and discrete geometry (concerned with polytopes, simplicial complexes, etc.) meet and interact. Problems of discrete differential geometry also naturally appear in (and are relevant for) other areas of mathematics. Moreover, the process of discretizing notions, problems and methods from the smooth theory often brings out new connections and interrelations between different areas. The workshop at Oberwolfach brought together researchers with a wide variety of backgrounds, including of course discrete geometry and differential geometry, but also integrable systems, combinatorics, mathematical physics and geometry processing. The exchange of ideas among different subfields helped to build new bridges between these mathematical communities. Discrete differential geometry can be said to have arisen from the observation that when a notion from smooth geometry (such as the notion of a minimal surface) is discretized “properly”, the discrete objects are not merely approximations of the smooth ones, but have special properties of their own which make them form in some sense a coherent entity by themselves. The discrete theory would seem to be the more fundamental one: The smooth theory can always be recovered as a limit, while there seems to be no natural way to predict from the smooth theory which discretizations will have the nicest properties. One case where these ideas seem particularly well-developed is for geometries described by integrable systems. The notion of a discrete integrable system as given by consistency on a cubic lattice has already shed new light on classical, smooth integrable systems. Another theme which arose repeatedly during the workshop was that of circle patterns and sphere packings. These can be used to discretize conformal maps, isothermic surfaces, and elastic bending energy. Since a computer works with discrete representations of data, it is no surprise that many of the applications of discrete differential geometry are found within computer science, particularly in the areas of computational geometry, graphics and geometry processing. The workshop brought theoreticians together with people interested in these and other applications.

With the rapid growth of free form architectures, the demand for architectural geometry technologies increases dramatically in recent years. Architectural geometry contains knowledge highly relevant to computer graphics and geometry especially discrete differential geometry. In addition, architectural geometry provides new context for some well-established concepts and brings new challenges and new objectives. In this dissertation, we tackle four challenges in architectural geometry. These four proposed solutions cover various processes including architecture maintenance, architecture construction, architecture texture mapping and architecture decoration. In Chapter 4, we present a data model synchronization method that preserves semantic information across editing operations relying only on geometry, UV mappings, and materials. This enables easy integration of existing and future 3D editing techniques with rich data models. The method links the original data model to the edited geometry using point set registration, recovering the existing information based on spatial and UV search methods, and automatically labels the newly created geometry. The implementation synchronized changes in the 3D geometry with a CityGML data model. In Chapter 5, we present a simple yet effective method for constructing 3D self-supporting surfaces with planar quadrilateral (PQ) elements. Starting with a self-supporting surface in triangle mesh, we first compute the principal curvatures and directions of each triangular face using a new approach, yielding more accurate results than existing methods. Then, we smooth the principal direction field to reduce the number of singularities and partition all faces into two groups in terms of principal curvature difference. For each face with small curvature difference, we compute a stretch matrix that turns the principal directions into a pair of conjugate directions. Finally, applying a mixed-integer programming solver to the mixed principal and conjugate direction field, we obtain a planar quadrilateral mesh. Experimental results show that our method is computationally efficient and can yield high-quality PQ meshes that well approximate the geometry of the input surfaces and maintain their self-supporting properties. In Chapter 6, we present a simple and robust algorithm to compute quad layout. We first propose an interpolation strategy to find tracing directions for singularities: given a singularity with index k (which is a multiple of 1/4), there are exactly 4-4k searching directions produced. We then trace integral curves with a rounding strategy to encourage them to go through mesh vertices, which can effectively reduce the number of short segments. Finally, we partition the triangle mesh along the integral curves to extract the quadrilateral patches. Our method does not require any numerical solver and is easy to implement and computationally efficient. Computational results show that our results have consistently fewer quad patches than those of the existing methods. For models with rich geometric details, our method can save up to 50\% patches in the quad layout. In Chapter 7, we present research in contrast-enhanced high-relief modeling. We present a simple and effective method to generate contrast-enhanced high-reliefs. Our key idea is a depth compression function with only two variables for 3D models. In this function, normals and mean curvatures are utilized to enhance the contrast of the resulting high-reliefs. To calculate the two variables in depth compression function, we construct an optimization framework with two objectives, volume minimization and contrast maximization. The variables are obtained when the two terms reach a balance point. Our method narrows down the solution space to only two variables and is easy to implement and produces good-quality high-reliefs. We show results on a range of real 3D models including real-world and synthetic models. In summary, we present four algorithms in architectural geometry. These solutions cover many applications including semantic information update, free form surface construction, surface parameterization and architecture surface decoration. We demonstrate the effectiveness of the proposed methods through extensive evaluation and comparison with the state-of-the-art methods.

This paper has two goals. First, we point out that most problems in computational geometry in fact have fast parallel algorithms (that is, in NC*) by reduction to the cell decomposition result of Kozen and Yap. We illustrate this using a new notion of generalized Voronoi diagrams that subsumes all known instances. While the existence of NC* algorithms for computational geometry is theoretically significant, it leaves much to be desired for specific problems. Therefore, the second part of the paper surveys some recent results in a fast growing list of parallel algorithms for computational geometry.

We summarize the results of the First Yaroslavl Summer School on Discrete and Computational Geometry and asses its future perspectives.

Tracing a ray through a scene and finding the closest intersection with the scene geometry is a fundamental operation in computer graphics. During the last two decades, significant efforts have been made to accelerate this operation, with interactive ray tracing as one of the major driving forces. At the heart of a fast method for intersecting a scene with a ray lies the acceleration structure. Many different acceleration structures exist, but research has focused almost exclusively on a few well-tried and well-established techniques: regular and hierarchical grids, bounding volume hierarchies and kd-trees. Spectacular advances have been made, which have contributed significantly to making interactive ray tracing a possibility. However, despite the success of these acceleration structures, several problems remain open. Handling deforming and dynamic geometry still poses significant challenges, and the local vs. global complexity of acceleration structures is still not entirely understood. One therefore wonders whether other acceleration structures, that leave the beaten path of efficient grids, bounding volume hierarchies and kd-trees, can provide viable alternatives.Next to computer graphics, the ray shooting problem is also studied in computational geometry. Ray shooting queries against a large collection of polyhedra are answered by tracing the ray through a simplicial complex such as a constrained tetrahedralization. This is a well-known technique, see e.g. the chapter Ray shooting and lines in space by Pellegrini in Handbook of Discrete and Computational Geometry. However, relevant work in computational geometry is usually theoretical, and practical implementations and experimental results are typically not available.In this work we explore the idea of accelerating the operation of intersecting a scene with a ray using constrained tetrahedralizations. This is illustrated in figure 1. A constrained tetrahedralization of a scene is a tetrahedralization that respects the faces of the scene geometry. The closest intersection of a ray with a scene is found by traversing this tetrahedralization along the ray, one tetrahedron at a time, until a constrained face is encountered. We show that constrained tetrahedralizations are a viable alternative to state-of-the-art acceleration structures, such as kd-trees, and that constrained tetrahedralizations have a number of interesting and unique properties that set them apart from traditional acceleration structures. Constrained tetrahedralizations are not hierarchical yet adaptive; the complexity of traversing them is a function of local geometric complexity rather than global geometric complexity; constrained tetrahedralizations support deforming geometry without any effort (see figure 2); and they have the potential to unify several data structures currently used in global illumination.Although constrained tetrahedralizations are not a silver bullet, and although they are in general not yet faster than the most optimized kd-trees, constrained tetrahedralizations offer several new perspectives on acceleration structures for ray tracing and deserve attention.

The landing site decision has direct relation to the safety of a spacecraft. This paper presents the use of computational geometry (CG) and genetic algorithm (GA) in the landing site selection. In order to describe the obstacles, we use computational geometry to compute the minimum enclosing circles and ellipses. Taking the obstacles as discrete circles and ellipses, we use the genetic algorithm to simplify and to solve the difficult problem of finding the largest empty circle (LEC) in circles and ellipses for the spacecraft landing on the surface. The results of tests on the solution procedure are presented.

Distributed computation of the knn graph for large high-dimensional point sets

We consider a collectionH ofn hyperplanes in Ed (where the dimensiond is fixed). An ?-cutting forH is a collection of (possibly unbounded)d-dimensional simplices with disjoint interors, which cover all Ed and such that the interior of any simplex is intersected by at most?n hyperplanes ofH. We give a deterministic algorithm for finding a (1/r)-cutting withO(rd) simplices (which is asymptotically optimal). Forr≤n1??, where ?>0 is arbitrary but fixed, the running time of this algorithm isO(n(logn)O(1)rd?1). In the plane we achieve a time boundO(nr) forr≤n1??, which is optimal if we also want to compute the collection of lines intersecting each simplex of the cutting. This improves a result of Agarwal, and gives a conceptually simpler algorithm. For ann point setX⊆Ed and a parameterr, we can deterministically compute a (1/r)-net of sizeO(rlogr) for the range space (X, {X ? R; R is a simplex}), In timeO(n(logn)O(1)rd?1+rO(1)). The size of the (1/r)-net matches the best known existence result. By a simple transformation, this allows us to find ?-nets for other range spaces usually encountered in computational geometry. These results have numerous applications for derandomizing algorithms in computational geometry without affecting their running time significantly.

Enhancements to array processors in the form of broadcast buses have been proposed for improving the speeds of algorithms in linear algebra, image processing and computational geometry. In this paper, we consider certain practical issues in such arrays which include fewer processors connected to the broadcast buses and finite time, namely log N time for broadcasting data to N processors. We propose a modified broadcast bus VLSI architecture which consists of a √N × √N mesh connected structure and a hierarchy of broadcast buses in each row and in each column such that every bus has k PE's. That is, in any row or column, in the first level there are \(\frac{{\sqrt N }}{k}\)buses with groups of k PE's connected to each bus. One PE from each of this group is connected to second level of buses in a similar manner. This is recursively done until there are only k PE's left which are connected by a broadcast bus. With this architecture, maximum, minimum, or sum of N values can be found in O(log N), median row of a binary picture in O(log N), shortest distance between two points in O(log N). This architecture is well suited for parallel processing of applications in Linear Algebra, Image Processing, Computational Geometry and Numerical Computations. These restricted connections to buses reduces the I/O ports significantly, and therefore, is more suitable for VLSI implementation.

Solid modelling and computational geometry are based on classical topology and geometry in which the basic predicates and operations, such as membership, subset inclusion, union and intersection, are not continuous and therefore not computable. But a sound computational framework for solids and geometry can only be built in a framework with computable predicates and operations. In practice, correctness of algorithms in computational geometry is usually proved using the unrealistic Real RAM machine model of computation, which allows comparison of real numbers, with the undesirable result that correct algorithms, when implemented, turn into unreliable programs. Here, we use a domain-theoretic approach to recursive analysis to develop the basis of an e3ective and realistic framework for solid modelling. This framework is equipped with a well de5ned and realistic notion of computability which re6ects the observable properties of real solids. The basic predicates and operations on solids are computable in this model which admits regular and non-regular sets and supports a design methodology for actual robust algorithms. Moreover, the model is able to capture the uncertainties of input data in actual CAD situations. c 2002 Elsevier Science B.V. All rights reserved.

Ruler of the Plane is a set of games illustrating concepts from combinatorial and computational geometry. The games are based on the art gallery problem, ham-sandwich cuts, the Voronoi game, and geometric network connectivity problems like the Euclidean minimum spanning tree and traveling salesperson problem.

The Automata Processor was designed for string-pattern matching. In this paper, we showcase its use to execute integer and floating-point comparisons and apply the same to accelerate interval stabbing queries. An interval stabbing query determines which of the intervals in a set overlap a query point. Such queries are often used in computational geometry, pattern matching, database management systems, and geographic information systems. The check for each interval is programmed as a single automaton and multiple automata are executed in parallel to provide significant performance gains. While handling 32-bit integers or single-precision floating-point numbers, up to 2.75 trillion comparisons can be executed per second, whereas 0.79 trillion comparisons per second can be completed for 64-bit integers or double-precision floating-point numbers. Additionally, our solution leaves the intervals in the set unordered; allowing addition or deletion of an interval in constant time. This is not possible for contemporary solutions wherein the intervals are ordered, making the query times faster, but making the updating of intervals complex. Our automata designs exemplify techniques that maximize resource utilization and minimize performance bottlenecks, which may be useful to future application developers on this processor. Their modular design allows them to become constituent parts of larger automata, where the numerical comparisons are part of the overall pattern matching operation. We have validated the designs on hardware, and the routines to generate the necessary automata and execute them on the AP will be made available as software libraries shortly.