Showing papers on "Computational geometry published in 1993"

Volume graphics

Abstract: Volume graphics, which employs a volume buffer of voxels for 3D scene representation, is discussed. Volume graphics offers advantages over surface graphics: it is viewpoint independent, insensitive to scene and object complexity, and suitable for the representation of sampled and simulated data sets. Moreover, geometric objects can be mixed with these data sets. Volume graphics supports the visualization of internal structures and lends itself to the realization of block operations, constructive solid geometry modeling, irregular voxel sizes, and hierarchical representation. The problems associated with the volume buffer representation (such as discreteness, memory size, processing time, and loss of geometric representation) are discussed. >

The Parti-Game Algorithm for Variable Resolution Reinforcement Learning in Multidimensional State-Spaces

Abstract: Parti-game is a new algorithm for learning feasible trajectories to goal regions in high dimensional continuous state-spaces In high dimensions it is essential that neither planning nor exploration occurs uniformly over a state-space Parti-game maintains a decision-tree partitioning of state-space and applies techniques from game-theory and computational geometry to efficiently and adaptively concentrate high resolution only on critical areas The current version of the algorithm is designed to find feasible paths or trajectories to goal regions in high dimensional spaces Future versions will be designed to find a solution that optimizes a real-valued criterion Many simulated problems have been tested, ranging from two-dimensional to nine-dimensional state-spaces, including mazes, path planning, non-linear dynamics, and planar snake robots in restricted spaces In all cases, a good solution is found in less than ten trials and a few minutes

External-memory computational geometry

Abstract: In this paper we give new techniques for designing efficient algorithms for computational geometry problems that are too large to be solved in internal memory. We use these techniques to develop optimal and practical algorithms for a number of important large-scale problems. We discuss our algorithms primarily in the context of single processor/single disk machines, a domain in which they are not only the first known optimal results but also of tremendous practical value. Our methods also produce the first known optimal algorithms for a wide range of two-level and hierarchical multilevel memory models, including parallel models. The algorithms are optimal both in terms of I/O cost and internal computation. >

Interactive collision detection

Abstract: Collision detection and response can make a virtual-reality application seem more believable. Unfortunately, existing collision-detection algorithms are too slow for interactive use. The authors present a new algorithm that is not only fast but also interruptible, allowing an application to trade quality for more speed. The algorithm uses simple four-dimensional geometry to approximate motion, and sets of spheres to approximate three-dimensional surfaces. The algorithm allows a sample application to run five to seven times faster than it runs with existing algorithms. >

Four results on randomized incremental constructions

Abstract: We prove four results on randomized incremental constructions (RICs): an analysis of the expected behavior under insertion and deletions, a fully dynamic data structure for convex hull maintenance in arbitrary dimensions, a tail estimate for the space complexity of RICs, a lower bound on the complexity of a game related to RICs.

Global visibility algorithms for illumination computations

Abstract: The most expensive geometric operation in image synthesis is visibility determination. Classically this is solved with hidden surface removal algorithms that render only the parts of the scene visible from a point. Global illumination calculations, however, may require information between any two points in the scene. This paper describes global visibility algorithms that preprocess polygon databases in order to accelerate visibility determination during illumination calculations. These algorithms are sensitive to the output complexity in visibility space; that is, how many pairs of objects are mutually visible. Furthermore, the algorithms are incremental so that they work well with progressive refinement and hierarchical methods of image synthesis. The algorithms are conservative, but exact; that is, when they return visibility predicates they can be proved true. However sometimes they do not return either totally visible or totally invisible, but partially visible, even though in the same situation a better algorithm might return the exact answer. In this paper we describe the algorithms and their implementation, and show that, in a scene with low average visual complexity, they can dramatically accelerate conventional radiosity programs. CR Categories and Subject Descriptors: I.3.5 [Computational Geometry and Object Modeling]: Geometric Algorithms, Languages, and Systems; I.3.7 [Computer Graphics]: ThreeDimensional Graphics and Realism Radiosity; J.2 [Physical Sciences and Engineering]: Engineering. Additional Key Words: Hidden surface removal, visibility space, radiosity, global illumination, algorithmic triage.

Darboux frames, snakes, and super-quadrics: geometry from the bottom up

Abstract: A representational and a computational model for deriving 3-D articulated volumetric descriptions of objects from laser rangefinder data is described. This method is purely bottom up: it relies on general assumptions cast in terms of differential geometry. Darboux frames, snakes, and superquadrics form the basis of this representation, and curvature consistency provides the computational framework. The organization is hierarchical. Darboux frames are used to describe the local surface, whereas snakes are used to interpolate between features, particularly those that serve to partition a surface into its constituent parts. Superquadrics are used to characterize the 3-D shape of each surface partition. The result is a set of connected volumetric primitives that serve to describe the overall shape of an object. Examples that show how the approach performs on data acquired with a laser rangefinder are included. >

Representing geometric structures ind dimensions: Topology and order

Abstract: This work investigates data structures for representing and manipulatingd-dimensional geometric objects for arbitraryd ? 1. A class of geometric objects is defined, the "subdividedd-manifolds," which is large enough to encompass many applications. A new representation is given for such objects, the "cell-tuple structure," which provides direct access to topological structure, ordering information among cells, the topological dual, and boundaries. The cell-tuple structure gives a simple, uniform representation of subdivided manifolds which unifies the existing work in the field and provides intuitive clarity in all dimensions. The dual subdivision, and boundaries, are represented consistently. This work has direct applications in solid modeling, computer graphics, and computational geometry.

Surface-to-surface intersections

Abstract: Techniques for computing intersections of algebraic surfaces with piecewise rational polynomial parametric surface patches and intersections of two piecewise rational polynomial parametric surface patches are discussed. The techniques are classified using four categories-lattice evolution methods, marching methods, subdivision methods, and analytic methods-and their principal features are discussed. It is shown that some of these methods also apply to the general parametric surface-intersection problem. >

Geometric optimization

Abstract: An algorithm is presented which describes an application independent method for reducing the number of polygonal primitives required to faithfully represent an object. Reducing polygon count without a corresponding reduction in object detail is important for: achieving interactive frame rates in scientific visualization, reducing mass storage requirements, and facilitating the transmission of large, multi-timestep geometric data sets. This paper shows how coplanar and nearly coplanar polygons can be merged into larger complex polygons and re-triangulated into fewer simple polygons than originally required. The notable contributions of this paper are: (1) a method for quickly grouping polygons into nearly coplanar sets, (2) a fast approach for merging coplanar polygon sets and, (3) a simple, robust triangulation method for polygons created by 1 and 2. The central idea of the algorithm is the notion of treating polygonal data as a collection of segments and removing redundant segments to quickly form polygon hulls which represent the merged coplanar sets. >

Backwards Analysis of Randomized Geometric Algorithms

Abstract: The theme of this chapter is a rather simple method that has proved very potent in the analysis of the expected performance of various randomized algorithms and data structures in computational geometry. The method can be described as “analyze a randomized algorithm as if it were running backwards in time, from output to input.” We apply this type of analysis to a variety of algorithms, old and new, and obtain solutions with optimal or near optimal expected performance for a plethora of problems in computational geometry, such as computing Delaunay triangulations of convex polygons, computing convex hulls of point sets in the plane or in higher dimensions, sorting, intersecting line segments, linear programming with a fixed number of variables, and others.

Allowable Sequences and Order Types in Discrete and Computational Geometry

Abstract: The allowable sequence associated to a configuration of points was first developed by the authors in order to investigate what combinatorial structure lay behind the Erdős-Szekeres conjecture (that any 2 n-2 + 1 points in general position in the plane contain among them n points which are in convex position) Though allowable sequences did not lead to any progress on this ancient problem, there did emerge an object that had considerable intrinsic interest, that turned out to be related to some other well-studied structures such as pseudoline arrangements and oriented matroids, and that had as well a combinatorial simplicity and suggestiveness which turned out to be effective in the solution of several other classical problems These connections and applications are discussed in Sections 2, 3, and 4 of this paper

Scalable parallel computational geometry for coarse grained multicomputers

Abstract: We study scalable parallel computational geometry algorithms for the coarse grained multicomputer model: p processors solving a problem on n data items, were each processor has O(n/p)≫O(1) local memory and all processors are connected via some arbitrary interconnection network (e.g. mesh, hypercube, fat tree). We present O(Tsequential/p+Ts(n, p)) time scalable parallel algorithms for several computational geometry problems. Ts(n, p) refers to the time of a global sort operation. Our results are independent of the multicomputer’s interconnection network. Their time complexities become optimal when Tsequential/p dominates Ts(n, p) or when Ts(n, p) is optimal. This is the case for several standard architectures, including meshes and hypercubes, and a wide range of ratios n/p that include many of the currently available machine configurations. Our methods also have some important practical advantages: For interprocessor communication, they use only a small fixed number of one global routing operation, global sort, and all other programming is in the sequential domain. Furthermore, our algorithms use only a small number of very large messages, which greatly reduces the overhead for the communication protocol between processors. (Note however, that our time complexities account for the lengths of messages.) Experiments show that our methods are easy to implement and give good timing results.

Delaunay triangulation using a uniform grid

Abstract: An algorithm for triangulating 2-D data points that is based on a uniform grid structure and a triangulation strategy that builds triangles in a circular fashion is discussed. The triangulation strategy lets the algorithm eliminate points from the internal data structure and decreases the time used to find points to form triangles, given an edge. The algorithm has a tested linear time complexity that significantly improves on that of other methods. As a by-product, the algorithm produces the convex hull of the data set at no extra cost. Two ways to compute the convex hull using the algorithm are presented. The first is based on the edge list and the second is based on the grid structure. >

Implicit curves and surfaces in CAGD

Abstract: The role of implicit curves and surfaces in computer-aided geometric design (CAGD) are described. The ways in which the study of implicit algebraic curves and surfaces draws on algebraic geometry are reviewed. The implicitization of parametric curves and surfaces, parameterization of implicits, and techniques used to circumvent conversions between implicit and parametric representations are discussed. >

Generalized intersection searching problems

Abstract: A new class of geometric intersection searching problems is introduced, which generalizes previously-considered intersection searching problems and is rich in applications. In a standard intersection searching problem, a set S of n geometric objects is to be preprocessed so that the objects that are intersected by a query object q can be reported efficiently. In a generalized problem, the objects in S come aggregated in disjoint groups and what is of interest are the groups, not the objects, that are intersected by q. Although this problem can be solved easily by using an algorithm for the standard problem, the query time can be Ω(n) even though the output size is just O(1). In this paper, algorithms with efficient, output-size-sensitive query times are presented for the generalized versions of a number of intersection searching problems, including: interval intersection searching, orthogonal segment intersection searching, orthogonal range searching, point enclosure searching, rectangle intersection searching, and segment intersection searching. In addition, the algorithms are also space-efficient.

On ray shooting in convex polytopes

Abstract: LetP be a convex polytope withn facets in the Euclidean space of a (small) fixed dimensiond. We consider themembership problem forP (given a query point, decide whether it lies inP) and theray shooting problem inP (given a query ray originating insideP, determine the first facet ofP hit by it). It was shown in [AM2] that a data structure for the membership problem satisfying certain mild assumptions can also be used for the ray shooting problem, with a logarithmic overhead in query time. Here we show that some specific data structures for the membership problem can be used for ray shooting in a more direct way, reducing the overhead in the query time and eliminating the use of parametric search. We also describe an improved static solution for the membership problem, approaching the conjectured lower bounds more tightly.

Ray Shooting, Depth Orders and Hidden Surface Removal

Abstract: Computational geometry and computer graphics.- Preliminaries.- A general strategy.- Ray shooting from a fixed point.- Ray shooting into a fixed direction.- Ray shooting with arbitrary rays.- Conclusions.- Depth orders in the plane.- Depth orders in three dimensions.- Conclusions.- Non-intersecting polyhedra.- Intersecting polyhedra.- Dynamization.- Conclusions.

Language-free layout analysis

Abstract: A system for isolating blocks, lines, words, and symbols within images of machine-printed textual documents that is, to a large existent, independent of language and writing system is described. This is achieved by exploiting a small number of nearly universal typesetting and layout conventions. The system does not require prior knowledge of page orientation (module 90/spl deg/), and copes well with nonzero skew and shear angles (within 10/spl deg/). Also it locates blocks of text without reliance on detailed a priori layout models, and in spite of unknown or mixed horizontal and vertical text-line orientations. Within blocks, it infers text-line orientation and isolates lines, without knowledge of the language, symbol set, text sizes, or the number of text lines. Segmentation into words and symbols, and determination of reading order, normally require some knowledge of the language: this is held to minimum by relying on shape-driven algorithms. The underlying algorithms are based on Fourier theory, digital signal processing, computational geometry, and statistical decision theory. Most of the computation occurs within algorithms that possess unambiguous semantics (that is, heuristics are kept to a minimum). The effectiveness of the method on English, Japanese, Hebrew, Thai, and Korean documents is discussed. >

Fundamental algorithms for the star and pancake interconnection networks with applications to computational geometry

Abstract: The star and pancake networks were recently proposed as attractive alternatives to the hypercube topology for interconnecting processors in a parallel computer. However, few parallel algorithms are known for these networks. In this paper, we present several data communication schemes and basic algorithms for these two networks. These algorithms are then used to develop parallel solutions to various computational geometric problems on both networks. Computational geometry is just one area where the algorithms proposed here can be applied. Indeed, we believe that these algorithms are interesting and important in their own right and are fundamental to the design of solutions on the star and pancake networks to a host of other problems. © 1993 by John Wiley & Sons, Inc.

An efficient algorithm for finding the CSG representation of a simple polygon

Abstract: Modeling two-dimensional and three-dimensional objects is an important theme in computer graphics. Two main types of models are used in both cases: boundary representations, which represent the surface of an object explicitly but represent its interior only implicitly, and constructive solid geometry representations, which model a complex object, surface and interior together, as a boolean combination of simpler objects. Because neither representation is good for all applications, conversion between the two is often necessary. We consider the problem of converting boundary representations of polyhedral objects into constructive solid geometry (CSG) representations. The CSG representations for a polyhedronP are based on the half-spaces supporting the faces ofP. For certain kinds of polyhedra this problem is equivalent to the corresponding problem for simple polygons in the plane. We give a new proof that the interior of each simple polygon can be represented by a monotone boolean formula based on the half-planes supporting the sides of the polygon and using each such half-plane only once. Our main contribution is an efficient and practicalO(n logn) algorithm for doing this boundary-to-CSG conversion for a simple polygon ofn sides. We also prove that such nice formulae do not always exist for general polyhedra in three dimensions.

Geometric partitioning made easier, even in parallel

Abstract: We present a simple approach for constructing geometric partitions in a way that is easy to apply to new problems. We avoid the use of VC-dimension arguments, and, instead, base our arguments on a notion we call the scaffold dimension, which subsumes the VC-dimension and is simpler to apply. We show how to easily construct (1/r)-nets and (1/r)-approximations for range spaces with bounded scaffold dimension, which immediately implies simple algorithms for constructing (1/r)-cuttings (by straight-forward recursive subdivision methods). More significant than simply being a conceptual simplification of previous approaches, however, is that our methods lead to asymptotically faster and more-efficient EREW PRAM parallel algorithms for a number of computational geometry problems, including the development of the first optimal-work NC algorithm for the well-known 3-dimensional convex hull problem, which solves an open problem of Amato and Preparata. Interestingly, our approach also yields a faster sequential algorithm for the distance selection problem, by the parametric searching paradigm, which solves an open problem posed by Agarwal, Aronov, Sharir, and Suri, and reiterated by Dickerson and Drysdale.

Singularities and Topological Aspects in Nonholonomic Motion Planning

Abstract: Motion planning is an already old and classical problem in Robotics. A few years ago a new instance of this problem has appeared in the literature : motion planning for nonholonomic systems. While useful tools in motion planning come from Computer Science and Mathematics (Computational Geometry, Real Algebraic Geometry), nonholonomic motion planning needs some Control Theory and more Mathematics (Differential Geometry).

Ray shooting on triangles in 3-space

Abstract: We present a uniform approach to problems involving lines in 3-space. This approach is based on mapping lines inR3 into points and hyperplanes in five-dimensional projective space (Plucker space). We obtain new results on the following problems: 1. Preprocessn triangles so as to answer efficiently the query: “Given a ray, which is the first triangle hit?” (Ray- shooting problem). We discuss the ray-shooting problem for both disjoint and nondisjoint triangles. 2. Construct the intersection of two nonconvex polyhedra in an output sensitive way with asubquadratic overhead term. 3. Construct the arrangement ofn intersecting triangles in 3-space in an output-sensitive way, with asubquadratic overhead term. 4. Efficiently detect the first face hit by any ray in a set of axis-oriented polyhedra. 5. Preprocessn lines (segments) so as to answer efficiently the query “Given two lines, is it possible to move one into the other without crossing any of the initial lines (segments)?” (Isotopy problem). If the movement is possible produce an explicit representation of it.

An incremental algorithm for constructing shortest watchman routes

Abstract: The problem of finding the shortest watchman route in a simple polygon P through a point s on its boundary is considered. A route is a watchman route if every point inside P can be seen from at least one point along the route. We present an incremental algorithm that constructs the shortest watchman route in O(n3) time for a simple polygon with n edges. This improves the previous O(n4) bound.

Computing a face in an arrangement of line segments and related problems

Abstract: This paper presents a randomized incremental algorithm for computing a single face in an arrangement of n line segments in the plane that is fairly simple to implement. The expected running time of the algorithm is $O(n\alpha (n)\log n)$. The analysis of the algorithm uses a novel approach that generalizes and extends the Clarkson–Shor analysis technique [in Discrete Comput. Geom., 4 (1989), pp. 387–421]. A few extensions of the technique, obtaining efficient randomized incremental algorithms for constructing the entire arrangement of a collection of line segments and for computing a single face in an arrangement of Jordan arcs are also presented.