Results 1  10
of
23
SpaceEfficient Algorithms for Computing the Convex Hull of a Simple Polygonal Line in Linear Time
"... We present spaceefficient algorithms for computing the convex hull of a simple polygonal line inplace, in linear time. It turns out that the problem is as hard as stable partition, i.e., if there were a truly simple solution then stable partition would also have a truly simple solution, and vice v ..."
Abstract

Cited by 17 (3 self)
 Add to MetaCart
We present spaceefficient algorithms for computing the convex hull of a simple polygonal line inplace, in linear time. It turns out that the problem is as hard as stable partition, i.e., if there were a truly simple solution then stable partition would also have a truly simple solution, and vice versa. Nevertheless, we present a simple selfcontained solution that uses O(log n) 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, then the problem admits a very simple solution which does not call for stable partitioning at all.
Inplace algorithms for computing (layers of) maxima
 In: Proceedings of the 10th Scandinavian Workshop on Algorithm Theory (SWAT ’06
, 2006
"... Abstract. We describe spaceefficient algorithms for solving problems related to finding maxima among points in two and three dimensions. Our algorithms run in optimal O(n log n) time and occupy only constant extra space in addition to the space needed for representing the input. 1 ..."
Abstract

Cited by 10 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We describe spaceefficient algorithms for solving problems related to finding maxima among points in two and three dimensions. Our algorithms run in optimal O(n log n) time and occupy only constant extra space in addition to the space needed for representing the input. 1
Linesegment intersection made inplace
, 2007
"... We present a spaceefficient algorithm for reporting all k intersections induced by a set of n line segments in the plane. Our algorithm is an inplace variant of Balaban’s algorithm and, in the worst case, runs in O(n log2 n+k) time using O(1) extra words of memory in addition to the space used f ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
We present a spaceefficient algorithm for reporting all k intersections induced by a set of n line segments in the plane. Our algorithm is an inplace variant of Balaban’s algorithm and, in the worst case, runs in O(n log2 n+k) time using O(1) extra words of memory in addition to the space used for the input to the algorithm.
Speculative Parallelization of a Randomized Incremental Convex Hull Algorithm
 Proc. Int’l Workshop Computational Geometry and Applications
, 2004
"... Abstract. Finding the fastest algorithm to solve a problem is one of the main issues in Computational Geometry. Focusing only on worst case analysis or asymptotic computations leads to the development of complex data structures or hard to implement algorithms. Randomized algorithms appear in this sc ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
(Show Context)
Abstract. Finding the fastest algorithm to solve a problem is one of the main issues in Computational Geometry. Focusing only on worst case analysis or asymptotic computations leads to the development of complex data structures or hard to implement algorithms. Randomized algorithms appear in this scenario as a very useful tool in order to obtain easier implementations within a good expected time bound. However, parallel implementations of these algorithms are hard to develop and require an indepth understanding of the language, the compiler and the underlying parallel computer architecture. In this paper we show how we can use speculative parallelization techniques to execute in parallel iterative algorithms such as randomized incremental constructions. In this paper we focus on the convex hull problem, and show that, using our speculative parallelization engine, the sequential algorithm can be automatically executed in parallel, obtaining speedups with as little as four processors, and reaching 5.15x speedup with 28 processors. 1
SpaceEfficient Algorithms for Klee’s Measure Problem
, 2005
"... We give spaceefficient geometric algorithms for three related problems. Given a set of n axisaligned rectangles in the plane, we calculate the area covered by the union of these rectangles (Klee’s measure problem) in O(n 3/2 log n) time with O(√n) extra space. If the input can be destroyed and the ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
We give spaceefficient geometric algorithms for three related problems. Given a set of n axisaligned rectangles in the plane, we calculate the area covered by the union of these rectangles (Klee’s measure problem) in O(n 3/2 log n) time with O(√n) extra space. If the input can be destroyed and there are no degenerate cases and input coordinates are all integers, we can solve Klee’s measure problem in O(n log² n) time with O(log² n) extra space. Given a set of n points in the plane, we find the axisaligned unit square that covers the maximum number of points in O(n log³ n) time with O(log² n) extra space.
MemoryConstrained Algorithms for Simple Polygons
, 2011
"... A constantworkspace algorithm has readonly access to an input array and may use only O(1) additional words of O(log n) bits, where n is the size of the input. We show that we can find a triangulation of a plane straightline graph with n vertices in O(n²) time. We also consider preprocessing a sim ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
A constantworkspace algorithm has readonly access to an input array and may use only O(1) additional words of O(log n) bits, where n is the size of the input. We show that we can find a triangulation of a plane straightline graph with n vertices in O(n²) time. We also consider preprocessing a simple ngon, which is given by the ordered sequence of its vertices, for shortest path queries when the space constraint is relaxed to allow s words of working space. After a preprocessing of O(n²) time, we are able to solve shortest path queries between any two points inside the polygon in O(n²/s) time.
InPlace 2d Nearest Neighbor Search
, 2007
"... Abstract We revisit a classic problem in computational geometry: preprocessing a planar npoint set to answer nearest neighbor queries. In SoCG 2004, Br"onnimann, Chan, and Chen showed that it is possible to design an efficient data structure that takes no extra space at all other than the ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
Abstract We revisit a classic problem in computational geometry: preprocessing a planar npoint set to answer nearest neighbor queries. In SoCG 2004, Br&quot;onnimann, Chan, and Chen showed that it is possible to design an efficient data structure that takes no extra space at all other than the input array holding a permutation of the points. The best query time known for such &quot;inplace data structures &quot; is O(log 2 n). In this paper, we break the O(log 2 n) barrier by providing a method that answers nearest neighbor queries in time O((log n) log3=2 2 log log n) = O(log
Adaptive Algorithms for Planar Convex Hull Problems?
"... Abstract. We study problems in computational geometry from the viewpoint of adaptive algorithms. Adaptive algorithms have been extensively studied for the sorting problem, and in this paper we generalize the framework to geometric problems. To this end, we think of geometric problems as permutation ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
Abstract. We study problems in computational geometry from the viewpoint of adaptive algorithms. Adaptive algorithms have been extensively studied for the sorting problem, and in this paper we generalize the framework to geometric problems. To this end, we think of geometric problems as permutation (or rearranging) problems of arrays, and define the “presortedness ” as a distance from the input array to the desired output array. We call an algorithm adaptive if it runs faster when a given input array is closer to the desired output, and furthermore it does not make use of any information of the presortedness. As a case study, we look into the planar convex hull problem for which we discover two natural formulations as permutation problems. An interesting phenomenon that we prove is that for one formulation the problem can be solved adaptively, but for the other formulation no adaptive algorithm can be better than an optimal outputsensitive algorithm for the planar convex hull problem. 1
A Fast Convex Hull Algorithm for Binary Image
 Informatica Journal, Guangxi
, 2010
"... Convex hull is widely used in computer graphic, image processing, CAD/CAM and pattern recognition. In this work, we derive some new convex hull properties and then propose a fast algorithm based on these new properties to extract convex hull of the object in binary image. It is achieved by computing ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Convex hull is widely used in computer graphic, image processing, CAD/CAM and pattern recognition. In this work, we derive some new convex hull properties and then propose a fast algorithm based on these new properties to extract convex hull of the object in binary image. It is achieved by computing the extreme points, dividing the binary image into several regions, scanning the regions existing vertices dynamically, calculating the monotone segments, and merging these calculated segments. Theoretical analyses show that the proposed algorithm has low complexities of time and space. Povzetek: Predstavljen je nov algoritem za obdelavo binarnih slik.
InPlace Randomized Slope Selection
"... Abstract. Slope selection is a wellknown algorithmic tool used in the context of computing robust estimators for fitting a line to a collection P of n points in the plane. We demonstrate that it is possible to perform slope selection in expected O(n log n) time using only constant extra space in ad ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Slope selection is a wellknown algorithmic tool used in the context of computing robust estimators for fitting a line to a collection P of n points in the plane. We demonstrate that it is possible to perform slope selection in expected O(n log n) time using only constant extra space in addition to the space needed for representing the input. Our solution is based upon a spaceefficient variant of Matouˇsek’s randomized interpolation search, and we believe that the techniques developed in this paper will prove helpful in the design of spaceefficient randomized algorithms using samples. To underline this, we also sketch how to compute the repeated median line estimator in an inplace setting. 1