305 research outputs found
Computational Geometry Column 42
A compendium of thirty previously published open problems in computational
geometry is presented.Comment: 7 pages; 72 reference
Ear-clipping Based Algorithms of Generating High-quality Polygon Triangulation
A basic and an improved ear clipping based algorithm for triangulating simple
polygons and polygons with holes are presented. In the basic version, the ear
with smallest interior angle is always selected to be cut in order to create
fewer sliver triangles. To reduce sliver triangles in further, a bound of angle
is set to determine whether a newly formed triangle has sharp angles, and edge
swapping is accepted when the triangle is sharp. To apply the two algorithms on
polygons with holes, "Bridge" edges are created to transform a polygon with
holes to a degenerate polygon which can be triangulated by the two algorithms.
Applications show that the basic algorithm can avoid creating sliver triangles
and obtain better triangulations than the traditional ear clipping algorithm,
and the improved algorithm can in further reduce sliver triangles effectively.
Both of the algorithms run in O(n2) time and O(n) space.Comment: Proceedings of the 2012 International Conference on Information
Technology and Software Engineering Lecture Notes in Electrical Engineering
Volume 212, 2013, pp 979-98
Linear-Time Algorithms for Geometric Graphs with Sublinearly Many Edge Crossings
We provide linear-time algorithms for geometric graphs with sublinearly many
crossings. That is, we provide algorithms running in O(n) time on connected
geometric graphs having n vertices and k crossings, where k is smaller than n
by an iterated logarithmic factor. Specific problems we study include Voronoi
diagrams and single-source shortest paths. Our algorithms all run in linear
time in the standard comparison-based computational model; hence, we make no
assumptions about the distribution or bit complexities of edge weights, nor do
we utilize unusual bit-level operations on memory words. Instead, our
algorithms are based on a planarization method that "zeroes in" on edge
crossings, together with methods for extending planar separator decompositions
to geometric graphs with sublinearly many crossings. Incidentally, our
planarization algorithm also solves an open computational geometry problem of
Chazelle for triangulating a self-intersecting polygonal chain having n
segments and k crossings in linear time, for the case when k is sublinear in n
by an iterated logarithmic factor.Comment: Expanded version of a paper appearing at the 20th ACM-SIAM Symposium
on Discrete Algorithms (SODA09
A Contribution to Triangulation Algorithms for Simple Polygons
Decomposing simple polygon into simpler components is one of the basic tasks in computational geometry and its applications. The most important simple polygon decomposition is triangulation. The known algorithms for polygon triangulation can be classified into three groups: algorithms based on diagonal inserting, algorithms based on Delaunay triangulation, and the algorithms using Steiner points. The paper briefly explains the most popular algorithms from each group and summarizes the common features of the groups. After that four algorithms based on diagonals insertion are tested: a recursive diagonal inserting algorithm, an ear cutting algorithm, Kong’s Graham scan algorithm, and Seidel’s randomized incremental algorithm. An analysis concerning speed, the quality of the output triangles and the ability to handle holes is done at the end
Space-Time Trade-offs for Stack-Based Algorithms
In memory-constrained algorithms we have read-only access to the input, and
the number of additional variables is limited. In this paper we introduce the
compressed stack technique, a method that allows to transform algorithms whose
space bottleneck is a stack into memory-constrained algorithms. Given an
algorithm \alg\ that runs in O(n) time using variables, we can
modify it so that it runs in time using a workspace of O(s)
variables (for any ) or time using variables (for any ). We also show how the technique
can be applied to solve various geometric problems, namely computing the convex
hull of a simple polygon, a triangulation of a monotone polygon, the shortest
path between two points inside a monotone polygon, 1-dimensional pyramid
approximation of a 1-dimensional vector, and the visibility profile of a point
inside a simple polygon. Our approach exceeds or matches the best-known results
for these problems in constant-workspace models (when they exist), and gives
the first trade-off between the size of the workspace and running time. To the
best of our knowledge, this is the first general framework for obtaining
memory-constrained algorithms
- …