DOCSLIB.ORG

Convex Hull Algorithms Christian Atwater Levente Dojcsak

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Convex Hull Algorithms Christian Atwater Levente Dojcsak Convex Hull Algorithms Christian Atwater Levente Dojcsak CS581 Algorithms April 7, 2020 Test Questions 1. Which algorithm was published first, Jarvis March or Graham Scan? 2. When is the Jarvis March faster than O(n log n) algorithms like the Graham Scan? 3. What is a convex hull called in n dimensions? About Me - Christian Atwater From Knoxville Went to University of Alabama for undergrad Math, CS double major About Me - Christian Atwater Traveled some Best place I’ve been to is Switzerland Like to run, play sports, bass guitar About Me - Levente Dojcsak • From: Forró, Hungary • PhD Student (Math → CS) • Got Married 1 Year Ago • Lived in Hungary, Michigan, St. Louis, Chicago, Knoxville • Favorite Place I’ve Lived: Chicago • Love to Cook • Hobbies: Magic the Gathering, Pokemon Go About Me - Levente Dojcsak Outline Overview History Algorithm 1: Jarvis March Algorithm 2: Graham Scan Implementation Applications Open Issues References Discussion Overview • Topic in Computational Geometry • Given a set of finite points in n-dimensional space, we want to find a convex hull of the set. • Convex Set: A subset of Euclidean space (Rn), such that a line connecting any two points within the set is contained entirely in the subset. • Focus: Two dimensional space (R2). • Convex Hull: List of vertices ordered along the boundary of a set that contains all of the points of the set according to the above definition. • Mathematical definition: The convex hull of a set M, is the minimal convex set containing M. Overview (cont.) Convex Concave Overview (cont.) • Example of Convex vs. Concave Hull Overview (cont.) • Existence of a unique and minimal Convex Hull is guaranteed. • Simple (non-mathematical) proof: Take any set of points and think of them as spikes in the ground. Then stretch a rubber band around the outside of the spikes so that all of the spikes are inside of the rubber band. • Must have a right turn around each point. History • Newton Polygon: Given a set of points from an nth degree polynomial, a Newton Polygon is the lower half of the Convex hull of the set of points. In general, it’s a way to find a convex set for a polynomial. • First mentioned in a letter from Isaac Newton to Henry Oldenburg in 1676. • Example: History • Modern algorithms were developed in the 1970’s. • Often called the first published modern algorithm designed to find Convex Hulls in 2 dimensions is the Jarvis March (1973). • It’s not actually the first algorithm, Graham’s Scan was actually published a year earlier in 1972, but the Jarvis March is the simplest so often comes first in the literature. • Designed by R. (Ray) A. Jarvis - Australian National University. • Not the first mention of convex hulls. Referred to as convex hulls, convex envelopes, or convex closures. The term convex hull was first used by Garrett Birkhoff in 1935. Types of Algorithms • We can divide algorithms into two types of problems: • The points of the finite input set are known. • The points of the finite input set are generated/deleted dynamically as the algorithm is running. Types of Algorithms • Graham Scan (1972) - Sort by angle measures • Jarvis March (1973, Gift Wrapping) - Wrap the set CW/CCW • Divide and Conquer (1977) • Quickhull (1977/1978) - Divide and conquer by splitting the set using the farthest available points • Other Algorithms - Chan’s Algorithm (1996) is one of the current best 2D algorithms. Combination of multiple simpler algorithms. Types of Algorithms (Complexity) Time complexity of algorithms is measured in the number of vertices n and the number of hull vertices h. • Jarvis March = O(nh) • Graham Scan = O(n log n) • Quickhull = O(n log n) → O(n2) worst case • Divide & Conquer = O (n log n) • Best algorithms = O (n log h) Algorithm I - Jarvis March (2D) Also known as the Gift Wrapping Algorithm. One of the first modern algorithms for finding Convex Hulls, published in 1973. Designed by R. (Ray) A. Jarvis - Australian National University. Algorithm Outline: • Take as input a set of points S, and begin with an empty ordered hull set H = ∅. • Take the leftmost point in S and put it in the set H. • Pick a second point in S and draw a line between the two points. • Iterate through the remaining points in S until you find the leftmost line. All points in the set S are to the right of the line. Put the point in the set H. • Repeat the last two steps until you reach the starting hull point. Step 1: Pick the leftmost point Step 2: Pick the “leftmost line” Step 2: Pick the “leftmost line” Step 3: Repeat Step 3: Repeat Step 3: Repeat Step 3: Repeat Step 3: Repeat Step 3: Repeat Step 3: Repeat until you add p0 Algorithm I - Jarvis March (2D) • Multiple Leftmost Points - Add all leftmost points. Starting point is the lowest point since we are calculating clockwise. • Calculating the “Leftmost Line”: • Minimum Exterior Angle / Maximum Interior Angle • Smallest right turn. Calculate the resulting vector and then the cross product. Negative cross product = counter-clockwise / left turn. Positive cross product = clockwise / right turn. • Cross product of new possible vectors. Always take positive cross product. • Collinear Points (zero cross product) - Add all collinear points. Calculate the magnitude of the vectors and add them from smallest to largest. Summary of Jarvis March • Time Complexity: Iterate through the set |S|=n, as many times as you have hull points |H|=h. Therefore, the time complexity is O(nh). Worst Case Complexity: If |H|=n, then O(n2). • Space Complexity: O(n) • Can be expanded to multiple dimensions. In 3 dimensions: • Pick 3 points that form a face and act as a leftmost plane. • Pick half planes in a similar fashion to picking leftmost lines. Algorithm II - Graham Scan Published in 1972 by Ronald Graham, one year before the Jarvis March. Ronald Graham has an Erdős number = 1 More complex than the Jarvis March, but has a much better worst case time complexity. Average Case Time Complexity = O(n log n) Can be improved even further by pre-sorting to get O(n) complexity. Algorithm Outline: • Take as input a set of points S, and begin with an empty stack H. • Take the lowest point in S, call it p0, and add it to the stack H. • Take a horizontal line L through p0 and sort the set S by the angle from L. • Push points onto the stack if they make a left turn from the previous point. • Pop the previous point from the stack if the next point would make a right turn. Step 1: Pick the lowest point ● ● ● ● ● ● ● ● ● ● P0 STACK Step 2: Sort the points by angles p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● ● p3 ● p2 ● p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● ● p3 ● p2 ● P1 (left) p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● ● p3 ● P2 (left) p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● ● P3 (left) p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● (P4) (right) ● P3 (pop) p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● ● --- p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● ● P4 (left) p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● P5 (left) ● P4 p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● P6 (left) ● P5 ● P4 p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● (P7) (right) p9 ● P6 (pop) ● P5 ● P4 p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● --- ● P5 ● P4 p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● (P7) (right) ● P5 (pop) ● P4 p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● --- ● P4 p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Step 3: Push points onto the stack Pop on a right turn p7 ● p4 ● p8 ● p10 p5 ● p9 ● ● P7 (left) ● P4 p3 ● P2 p2 ● P1 p11 p6 ● P0 STACK p1 Summary of Graham Scan • Multiple Lowest Points - Pick the leftmost point first. • Sorting Multiple Equal Angles - Pick the point that is farthest from P0. • Time Complexity: O(n log n) If the set is pre-sorted (by angle or vertices) complexity is O(n). • Generally faster than Jarvis March. Jarvis’s is faster if h < log n. • Space Complexity: O(n) • Cannot be expanded to multiple dimensions. • Chan’s Algorithm - Combination of Graham Scan, or another O(n log n) algorithm, with the Jarvis March Implementation Implemented Gram Scan, QuickHull, and Jarvis March Written in Webgl and javascript Live Demo Applications • Driving Sensors: Calculate the convex hull of a car to avoid obstacles.
Load more

Recommended publications
  • Gscan: Accelerating Graham Scan on The
    gScan:AcceleratingGrahamScanontheGPU Gang Mei Institute of Earth and Environmental Science, University of Freiburg Albertstr.23B, D-79104, Freiburg im Breisgau, Germany E-mail: [email protected] Abstract This paper presents a fast implementation of the Graham scan on the GPU. The proposed algorithm is composed of two stages: (1) two rounds of preprocessing performed on the GPU and (2) the finalization of finding the convex hull on the CPU. We first discard the interior points that locate inside a quadrilateral formed by four extreme points, sort the remaining points according to the angles, and then divide them into the left and the right regions. For each region, we perform a second round of filtering using the proposed preprocessing approach to discard the interior points in further. We finally obtain the expected convex hull by calculating the convex hull of the remaining points on the CPU. We directly employ the parallel sorting, reduction, and partitioning provided by the library Thrust for better efficiency and simplicity. Experimental results show that our implementation achieves 6x ~ 7x speedups over the Qhull implementation for 20M points. Keywords: GPU, CUDA, Convex Hull, Graham Scan, Divide-and-Conquer, Data Dependency 1.Introduction Given a set of planar points S, the 2D convex hull problem is to find the smallest polygon that contains all the points in S. This problem is a fundamental issue in computer science and has been studied extensively. Several classic convex hull algorithms have been proposed [1-7]; most of them run in O(nlogn) time. Among them, the Graham scan algorithm [1] is the first practical convex hull algorithm, while QuickHull [7] is the most efficient and popular one in practice.
    [Show full text]
  • Geometric Algorithms
    Geometric Algorithms primitive operations convex hull closest pair voronoi diagram References: Algorithms in C (2nd edition), Chapters 24-25 http://www.cs.princeton.edu/introalgsds/71primitives http://www.cs.princeton.edu/introalgsds/72hull 1 Geometric Algorithms Applications. • Data mining. • VLSI design. • Computer vision. • Mathematical models. • Astronomical simulation. • Geographic information systems. airflow around an aircraft wing • Computer graphics (movies, games, virtual reality). • Models of physical world (maps, architecture, medical imaging). Reference: http://www.ics.uci.edu/~eppstein/geom.html History. • Ancient mathematical foundations. • Most geometric algorithms less than 25 years old. 2 primitive operations convex hull closest pair voronoi diagram 3 Geometric Primitives Point: two numbers (x, y). any line not through origin Line: two numbers a and b [ax + by = 1] Line segment: two points. Polygon: sequence of points. Primitive operations. • Is a point inside a polygon? • Compare slopes of two lines. • Distance between two points. • Do two line segments intersect? Given three points p , p , p , is p -p -p a counterclockwise turn? • 1 2 3 1 2 3 Other geometric shapes. • Triangle, rectangle, circle, sphere, cone, … • 3D and higher dimensions sometimes more complicated. 4 Intuition Warning: intuition may be misleading. • Humans have spatial intuition in 2D and 3D. • Computers do not. • Neither has good intuition in higher dimensions! Is a given polygon simple? no crossings 1 6 5 8 7 2 7 8 6 4 2 1 1 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 2 18 4 18 4 19 4 19 4 20 3 20 3 20 1 10 3 7 2 8 8 3 4 6 5 15 1 11 3 14 2 16 we think of this algorithm sees this 5 Polygon Inside, Outside Jordan curve theorem.
    [Show full text]
  • Optimal Output-Sensitive Convex Hull Algorithms in Two and Three Dimensions*
    Discrete Comput Geom 16:361-368 (1996) GeometryDiscrete & Computational ~) 1996Springer-Verlag New YorkInc. Optimal Output-Sensitive Convex Hull Algorithms in Two and Three Dimensions* T. M. Chan Department of Computer Science, University of British Columbia, Vancouver, British Columbia, Canada V6T 1Z4 Abstract. We present simple output-sensitive algorithms that construct the convex hull of a set of n points in two or three dimensions in worst-case optimal O (n log h) time and O(n) space, where h denotes the number of vertices of the convex hull. 1. Introduction Given a set P ofn points in the Euclidean plane E 2 or Euclidean space E 3, we consider the problem of computing the convex hull of P, cony(P), which is defined as the smallest convex set containing P. The convex hull problem has received considerable attention in computational geometry [11], [21], [23], [25]. In E 2 an algorithm known as Graham's scan [15] achieves O(n logn) rtmning time, and in E 3 an algorithm by Preparata and Hong [24] has the same complexity. These algorithms are optimal in the worst case, but if h, the number of hull vertices, is small, then it is possible to obtain better time bounds. For example, in E 2, a simple algorithm called Jarvis's march [ 19] can construct the convex hull in O(nh) time. This bound was later improved to O(nlogh) by an algorithm due to Kirkpatrick and Seidel [20], who also provided a matching lower bound; a simplification of their algorithm has been recently reported by Chan et al.
    [Show full text]
  • A Framework for Multi-Core Implementations of Divide and Conquer Algorithms and Its Application to the Convex Hull Problem ∗
    CCCG 2008, Montr´eal, Qu´ebec, August 13–15, 2008 A Framework for Multi-Core Implementations of Divide and Conquer Algorithms and its Application to the Convex Hull Problem ∗ Stefan N¨aher Daniel Schmitt † Abstract 2 Divide and Conquer Algorithms We present a framework for multi-core implementations Divide and conquer algorithms solve problems by di- of divide and conquer algorithms and show its efficiency viding them into subproblems, solving each subprob- and ease of use by applying it to the fundamental geo- lem recursively and merging the corresponding results metric problem of computing the convex hull of a point to a complete solution. All subproblems have exactly set. We concentrate on the Quickhull algorithm intro- the same structure as the original problem and can be duced in [2]. In general the framework can easily be solved independently from each other, and so can eas- used for any D&C-algorithm. It is only required that ily be distributed over a number of parallel processes the algorithm is implemented by a C++ class imple- or threads. This is probably the most straightforward menting the job-interface introduced in section 3 of this parallelization strategy. However, in general it can not paper. be guaranteed that always enough subproblems exist, which leads to non-optimal speedups. This is in partic- 1 Introduction ular true for the first divide step and the final merging step but is also a problem in cases where the recur- Performance gain in computing is no longer achieved sion tree is unbalanced such that the number of open by increasing cpu clock rates but by multiple cpu cores sub-problems is smaller than the number of available working on shared memory and a common cache.
    [Show full text]
  • Convex Hull in 3 Dimensions
    CONVEX HULL IN 3 DIMENSIONS PETR FELKEL FEL CTU PRAGUE [email protected] https://cw.felk.cvut.cz/doku.php/courses/a4m39vg/start Based on [Berg], [Preparata], [Rourke] and [Boissonnat] Version from 16.11.2017 Talk overview Upper bounds for convex hull in 2D and 3D Other criteria for CH algorithm classification Recapitulation of CH algorithms Terminology refresh Convex hull in 3D – Terminology – Algorithms • Gift wrapping • D&C Merge • Randomized Incremental www.cguu.com www.cguu.com Computational geometry (2 / 41) Upper bounds for Convex hull algorithms O(n) for sorted points and for simple polygon 2 3 O(n log n) in E ,E with sorting – insensitive about output O(n h), O(n logh), h is number of CH facets – output sensitive –O(n2) or O(n logn) for n ~ h O(log n) for new point insertion in realtime algs. => O(n log n) for n-points O(log n) search where to insert Computational geometry (3 / 41) Other criteria for CH algorithm classification Optimality – depends on data order (or distribution) In the worst case x In the expected case Output sensitivity – depends on the result ~ O(f(h)) Extendable to higher dimensions? Off-line versus on-line – Off-line – all points available, preprocessing for search speedup – On-line – stream of points, new point pi on demand, just one new point at a time, CH valid for {p1,p2 ,…, pi } – Real-time – points come as they “want” (come not faster than optimal constant O(log n) inter-arrival delay) Parallelizable x serial Dynamic – points can be deleted Deterministic x approximate (lecture 13) Computational
    [Show full text]
  • An Overview of Computational Geometry
    An Overview of Computational Geometry Alex Scheffelin Contents 1 Abstract 2 2 Introduction 3 2.1 Basic Definitions . .3 3 Floating Point Error 4 3.1 Imprecision in Floating Point Operations . .4 3.2 Precision in the Calculation of the Area of a Polygon . .5 4 Speed 7 4.1 Big O Notation . .7 4.2 A More Efficient Algorithm to Calculate Intersections of Lines . .8 4.3 Recap on Speed . 15 5 How Can Pure Mathematics Influence Computational Geometry? 16 5.1 Point in Polygon Calculation . 16 5.2 Why Do We Care? . 19 6 Convex Hull Algorithms 19 6.1 What is a Convex Hull . 19 6.2 The Jarvis March Algorithm . 19 6.3 The Graham Scan Algorithm . 21 6.4 Other Efficient Algorithms . 22 6.5 Generalizations to the Convex Hull . 23 7 Conclusion 23 1 1 Abstract Computational geometry is an applied math field which can be described as the intersection of geometry and computer science. It has many real world applications, including in 3D mod- elling programs, graphics processing, etc. We will provide an overview of the methodology of computational geometry in the limited case of 2D objects, culminating in the discussion of the construction of convex hulls, a type of polygon in the plane which is determined by a set of points. Along the way we will try to explain some unique difficulties one faces when using a computer to compute things, and attempt to highlight the methods of proof used. 2 2 Introduction 2.1 Basic Definitions I will define a few geometric objects, and give example about how one might represent them in a computer.
    [Show full text]
  • An Algorithm for Finding Convex Hulls of Planar Point Sets
    An Algorithm for Finding Convex Hulls of Planar Point Sets Gang Mei, John C.Tipper Nengxiong Xu Institut für Geowissenschaften – Geologie School of Engineering and Technology Albert-Ludwigs-Universität Freiburg China University of Geosciences (Beijing) Freiburg im Breisgau, Germany Beijing, China {gang.mei, john.tipper}@geologie.uni-freiburg.de [email protected] Abstract —This paper presents an alternate choice of computing Liu and Wang [13] propose a reliable and effective CH the convex hulls (CHs) for planar point sets. We firstly discard algorithm based on a technique named Principle Component the interior points and then sort the remaining vertices by x- / y- Analysis for preprocessing the planar point set. A fast CH coordinates separately, and later create a group of quadrilaterals algorithm with maximum inscribed circle affine transformation (e-Quads) recursively according to the sequences of the sorted is developed in [14]; and another two quite fast algorithms are lists of points. Finally, the desired CH is built based on a simple both designed based on GPU [15, 16]. polygon derived from all e-Quads. Besides the preprocessing for original planar point sets, this algorithm has another mechanism In this paper, we present an alternate algorithm to produce of discarding interior point when form e-Quads and assemble the the convex hull for points in the plane. The main ideas of the simple polygon. Compared with three popular CH algorithms, proposed algorithms are as follows. A planar point set is firstly the proposed algorithm can generate CHs faster than the three preprocessed by discarding its interior points; secondly the but has a penalty in space cost.
    [Show full text]
  • Frequently Asked Questions in Polyhedral Computation
    Frequently Asked Questions in Polyhedral Computation http://www.ifor.math.ethz.ch/~fukuda/polyfaq/polyfaq.html Komei Fukuda Swiss Federal Institute of Technology Lausanne and Zurich, Switzerland [email protected] Version June 18, 2004 Contents 1 What is Polyhedral Computation FAQ? 2 2 Convex Polyhedron 3 2.1 What is convex polytope/polyhedron? . 3 2.2 What are the faces of a convex polytope/polyhedron? . 3 2.3 What is the face lattice of a convex polytope . 4 2.4 What is a dual of a convex polytope? . 4 2.5 What is simplex? . 4 2.6 What is cube/hypercube/cross polytope? . 5 2.7 What is simple/simplicial polytope? . 5 2.8 What is 0-1 polytope? . 5 2.9 What is the best upper bound of the numbers of k-dimensional faces of a d- polytope with n vertices? . 5 2.10 What is convex hull? What is the convex hull problem? . 6 2.11 What is the Minkowski-Weyl theorem for convex polyhedra? . 6 2.12 What is the vertex enumeration problem, and what is the facet enumeration problem? . 7 1 2.13 How can one enumerate all faces of a convex polyhedron? . 7 2.14 What computer models are appropriate for the polyhedral computation? . 8 2.15 How do we measure the complexity of a convex hull algorithm? . 8 2.16 How many facets does the average polytope with n vertices in Rd have? . 9 2.17 How many facets can a 0-1 polytope with n vertices in Rd have? . 10 2.18 How hard is it to verify that an H-polyhedron PH and a V-polyhedron PV are equal? .
    [Show full text]
  • Algorithms for Computing Convex Hulls Using Linear Programming Bo Mortensen, 20073241
    Algorithms for Computing Convex Hulls Using Linear Programming Bo Mortensen, 20073241 Master's Thesis, Computer Science February 2015 Advisor: Peyman Afshani Advisor: Gerth Stølting Brodal AARHUS AU UNIVERSITY DEPARTMENT OF COMPUTER SCIENCE ii ABSTRACT The computation of convex hulls is a major field of study in computa- tional geometry, with applications in many areas: from mathematical optimization, to pattern matching and image processing. Therefore, a large amount of research has gone into developing more efficient algorithms for solving the convex hull problem. This thesis tests and compares different methods of computing the convex hull of a set of points, both in 2D and 3D. It further shows if using linear programming techniques can help improve the running times of the theoretically fastest of these algorithms. It also presents a method for increasing the efficiency of multiple linear programming queries on the same constraint set. In 2D, the convex hull algorithms include an incremental approach, an intuitive gift wrapping algorithm, and an advanced algorithm us- ing a variant of the divide-and-conquer approach called marriage- before-conquest. The thesis also compares the effect of substituting one of the more time-consuming subroutines of the marriage-before- conquest algorithm, with linear programming. An extension of the gift wrapping algorithm into 3D is presented and tested, along with a description of an algorithm for using linear programming to compute convex hulls in 3D. Results of various tests are presented and compared with theoreti- cal predictions. These results show that in some cases, the marriage- before-conquest algorithm is faster than the other algorithms, but when the hull size is a large part of the input, the incremental convex hull algorithm is faster.
    [Show full text]
  • Convex Hull in Higher Dimensions
    Comp 163: Computational Geometry Professor Diane Souvaine Tufts University, Spring 2005 1991 Scribe: Gabor M. Czako, 1990 Scribe: Sesh Venugopal, 2004 Scrib Higher Dimensional Convex Hull Algorithms 1 Convex hulls 1.0.1 Definitions The following definitions will be used throughout. Define • Sd:Ad-Simplex The simplest convex polytope in Rd.Ad-simplex is always the convex hull of some d + 1 affinely independent points. For example, a line segment is a 1 − simplex i.e., the smallest convex subspace which con- tains two points. A triangle is a 2 − simplex and a tetrahedron is a 3 − simplex. • P: A Simplicial Polytope. A polytope where each facet is a d − 1 simplex. By our assumption, a convex hull in 3-D has triangular facets and in 4-D, a convex hull has tetrahedral facets. •P: number of facets of Pi • F : a facet of P • R:aridgeofF • G:afaceofP d+1 • fj(Pi ): The number of j-faces of P .Notethatfj(Sd)=C(j+1). 1.0.2 An Upper Bound on Time Complexity: Cyclic Polytope d 1 2 d Consider the curve Md in R defined as x(t)=(t ,t , ..., t ), t ∈ R.LetH be the hyperplane defined as a0 + a1x1 + a2x2 + ... + adxd = 0. The intersection 2 d of Md and H is the set of points that satisfy a0 + a1t + a2t + ...adt =0. This polynomial has at most d real roots and therefore d real solutions. → H intersects Md in at most d points. This brings us to the following definition: A convex polytope in Rd is a cyclic polytope if it is the convex hull of a 1 set of at least d +1pointsonMd.
    [Show full text]
  • Algorithms and Software
    Project number IST-25582 CGL Computational Geometric Learning High Dimensional Predicates: Algorithms and Software STREP Information Society Technologies Period covered: November 1, 2011 { October 31, 2012 Date of preparation: October 12, 2012 Date of revision: October 12, 2012 Start date of project: November 1, 2010 Duration: 3 years Project coordinator name: Joachim Giesen (FSU) Project coordinator organisation: Friedrich-Schiller-Universit¨atJena Jena, Germany High Dimensional Predicates: Algorithms and Software Ioannis Z. Emiris∗ Vissarion Fisikopoulos∗ Luis Pe~naranda∗∗ October 12, 2012 Abstract Determinant predicates are the core procedures in many important geometric algorithms, such as convex hull computations and point location. As the dimension of the computation space grows, a higher percentage of the computation time is consumed by these predicates. We study the sequences of determinants that appear in geometric algorithms. We use dynamic determinant algorithms to speed-up the computation of each predicate by using information from previously computed predicates. We propose two dynamic determinant algorithms with quadratic complexity when em- ployed in convex hull computations, and with linear complexity when used in point location problems. Moreover, we implement them and perform an experimental analysis. Our imple- mentations are based on CGAL and can be easily integrated. They outperform the state- of-the-art determinant and convex hull implementations in most of the tested scenarios, as well as giving a speed-up of 78 times in point location problems. Another contribution focuses on hashing (minors of) determinantal predicates when com- puting regular triangulations, which accelerates execution up to 100 times when computing resultant polytopes. This has been implemented and submitted to CGAL.
    [Show full text]
  • E Convex Hulls
    CS 373 Non-Lecture E: Convex Hulls Fall 2002 E Convex Hulls E.1 Definitions We are given a set P of n points in the plane. We want to compute something called the convex hull of P . Intuitively, the convex hull is what you get by driving a nail into the plane at each point and then wrapping a piece of string around the nails. More formally, the convex hull is the smallest convex polygon containing the points: • polygon: A region of the plane bounded by a cycle of line segments, called edges, joined end-to-end in a cycle. Points where two successive edges meet are called vertices. • convex: For any two points p; q inside the polygon, the line segment pq is completely inside the polygon. • smallest: Any convex proper subset of the convex hull excludes at least one point in P . This implies that every vertex of the convex hull is a point in P . We can also define the convex hull as the largest convex polygon whose vertices are all points in P , or the unique convex polygon that contains P and whose vertices are all points in P . Notice that P might have interior points that are not vertices of the convex hull. A set of points and its convex hull. Convex hull vertices are black; interior points are white. Just to make things concrete, we will represent the points in P by their Cartesian coordinates, in two arrays X[1 :: n] and Y [1 :: n]. We will represent the convex hull as a circular linked list of vertices in counterclockwise order.
    [Show full text]