Planar Convex Hull Research Articles

Minirobots Moving at Different Partial Speeds

In this paper, we present the mathematical point of view of our research group regarding the multi-robot systems evolving in a multi-temporal way. We solve the minimum multi-time volume problem as optimal control problem for a group of planar micro-robots moving in the same direction at different partial speeds. We are motivated to solve this problem because a similar minimum-time optimal control problem is now in vogue for micro-scale and nano-scale robotic systems. Applying the (weak and strong) multi-time maximum principle, we obtain necessary conditions for optimality and that are used to guess a candidate control policy. The complexity of finding this policy for arbitrary initial conditions is dominated by the computation of a planar convex hull. We pointed this idea by applying the technique of multi-time Hamilton-Jacobi-Bellman PDE. Our results can be extended to consider obstacle avoidance by explicit parameterization of all possible optimal control policies.

Two Approaches to Building Time-Windowed Geometric Data Structures

Given a set of geometric objects each associated with a time value, we wish to determine whether a given property is true for a subset of those objects whose time values fall within a query time window. We call such problems time-windowed decision problems, and they have been the subject of much recent attention, for instance studied by Bokal et al. (in: Proceedings of the 31st International Symposium on Computational Geometry (SoCG), pp 240–254, 2015). In this paper, we present new approaches to this class of problems that are conceptually simpler than Bokal et al. ’s, and also lead to faster algorithms. For instance, we present algorithms for preprocessing for both the time-windowed 2D diameter decision problem and the time-windowed 2D convex hull area decision problem in $$O(n \log n)$$ time, improving Bokal et al. ’s $$O(n \log ^2 n)$$ and $$O(n \log n \log \log n)$$ solutions respectively. Our first approach is to reduce time-windowed decision problems to a generalized range successor problem, which we solve using a novel way to search range trees. Our other approach is to use dynamic data structures directly, taking advantage of a new observation that the total number of combinatorial changes to a planar convex hull is linear for any FIFO update sequence, in which deletions occur in the same order as insertions. We also apply these approaches to obtain the first $$O(n\, \mathrm{polylog}\, n)$$ algorithms for the time-windowed 3D diameter decision and 2D orthogonal segment intersection detection problems.

Development of a library of feature fitting algorithms for CMMs

Conformance of a manufactured feature to the applied geometric tolerances is done by analyzing the point cloud that is measured on the feature. To that end, a geometric feature is fitted to the point cloud and the results are assessed to see whether the fitted feature lies within the specified tolerance limits or not. Coordinate Measuring Machines (CMMs) use feature fitting algorithms that incorporate least square estimates as a basis for obtaining minimum, maximum, and zone fits. However, it is well known that results obtained from different vendors for the same data set often do not agree. This may be because of different interpretations of the GD&T standards, or the use of least squares algorithms as the basis for all fitting. Therefore, a reference or normative comprehensive library of algorithms addressing the fitting procedure (all datums, targets) for every tolerance class is needed. The library is specific to feature fitting for tolerance verification. This paper addresses linear, planar, circular, and cylindrical features only. This set of algorithms described conforms to the international Standards for GD&T. In order to reduce the number of points to be analyzed, and to identify the possible candidate points for linear, circular and planar features, 2D and 3D convex hulls are used. For minimum, maximum, and Chebyshev cylinders, geometric search algorithms are used. Algorithms are divided into three major categories: least square, unconstrained, and constrained fits.

Convex hull of n planar Brownian paths: an exact formula for the average number of edges

We establish an exact formula for the average number of edges appearing on the boundary of the global convex hull of n independent Brownian paths in the plane. This requires the introduction of a counting criterion which amounts to ‘cutting off’ edges that are, in a specific sense, small. The main argument consists in a mapping between planar Brownian convex hulls and configurations of constrained, independent linear Brownian motions. This new formula is confirmed by retrieving an existing exact result on the average perimeter of the boundary of Brownian convex hulls in the plane.

Minimum-Time Optimal Control of Many Robots that Move in the Same Direction at Different Speeds

In this paper, we solve the minimum-time optimal control problem for a group of robots that can move at different speeds but that must all move in the same direction. We are motivated to solve this problem because constraints of this sort are common in micro-scale and nano-scale robotic systems. By application of the minimum principle, we obtain necessary conditions for optimality and use them to guess a candidate control policy. By showing that the corresponding value function is a viscosity solution to the Hamilton-Jacobi-Bellman equation, we verify that our guess is optimal. The complexity of finding this policy for arbitrary initial conditions is only quasilinear in the number of robots, and in fact is dominated by the computation of a planar convex hull. We extend this result to consider obstacle avoidance by explicit parameterization of all possible optimal control policies, and show examples in simulation.

Adaptive Algorithms for Planar Convex Hull Problems

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 rearrangement) problems of arrays, and define the “presortedness” as a distance from the input array to the desired output array. We call an algorithm adaptiveif 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 output-sensitive algorithm for the planar convex hull problem. To further pursue the possibility of adaptive computational geometry, we also consider constructing a kd-tree.

Convex hull properties and algorithms

Convex hull (CH) is widely used in computer graphic, image processing, CAD/CAM, and pattern recognition. We investigate CH properties and derive new properties: (1) CH vertices’ coordinates monotonically increase or decrease, (2) The edge slopes monotonically decrease. Using these properties, we proposed two algorithms, i.e., CH algorithm for planar point set, and CH algorithm for two available CHs. The main ideas of the proposed algorithms are as follows. A planar point set is divided into several subsets by the extreme points, and vertices in these subsets are then separately calculated. During the computation, the CH properties are used to eliminate concave points. This can reduce the computational cost and then improves the speed. Our first algorithm can extract CH with O ( n log n ) time, which is the lower bound of planar CH extraction, and the second algorithm can obtain CH with O ( m + n ) time at the worst case.

FLOATING-POINT ARITHMETIC FOR COMPUTATIONAL GEOMETRY PROBLEMS WITH UNCERTAIN DATA

It has been suggested in the literature that ordinary finite-precision floating-point arithmetic is inadequate for geometric computation, and that researchers in numerical analysis may believe that the difficulties of error in geometric computation can be overcome by simple approaches. It is the purpose of this paper to show that these suggestions, based on an example showing failure of a certain algorithm for computing planar convex hulls, are misleading, and why this is so.It is first shown how the now-classical backward error analysis can be applied in the area of computational geometry. This analysis is relevant in the context of uncertain data, which may well be the practical context for computational-geometry algorithms such as, say, those for computing convex hulls. The exposition will illustrate the fact that the backward error analysis does not pretend to overcome the problem of finite precision: it merely provides a way to distinguish those algorithms that overcome the problem to whatever extent it is possible to do so.It is then shown that often the situation in computational geometry is exactly parallel to other areas, such as the numerical solution of linear equations, or the algebraic eigenvalue problem. Indeed, the example mentioned can be viewed simply as an example of the use of an unstable algorithm, for a problem for which computational geometry has already discovered provably stable algorithms.Finally, the paper discusses the implications of these analyses for applications in three-dimensional solid modeling. This is done by considering a problem defined in terms of a simple extension of the planar convex-hull algorithm, namely, the verification of the well-formedness of extruded objects. A brief discussion concerning more difficult problems in solid modeling is also included.

A new algorithm for computing the convex hull of a planar point set

When the edges of a convex polygon are traversed along one direction, the interior of the convex polygon is always on the same side of the edges. Based on this characteristic of convex polygons, a new algorithm for computing the convex hull of a simple polygon is proposed in this paper, which is then extended to a new algorithm for computing the convex hull of a planar point set. First, the extreme points of the planar point set are found, and the subsets of point candidate for vertex of the convex hull between extreme points are obtained. Then, the ordered convex hull point sequences between extreme points are constructed separately and concatenated by removing redundant extreme points to get the convex hull. The time complexity of the new planar convex hull algorithm is O(nlogh), which is equal to the time complexity of the best output-sensitive planar convex hull algorithms. Compared with the algorithm having the same complexity, the new algorithm is much faster.

Euclidean position in Euclidean 2-orbifolds

Intuitively, a set of sites on a surface is in Euclidean position if points are so close to each other that planar algorithms can be easily adapted in order to solve most of the classical problems in Computational Geometry. In this work we formalize a definition of the term “Euclidean position” for a relevant class of metric spaces, the Euclidean 2-orbifolds, and present methods to compute whether a set of sites has this property. We also show the relation between the convex hull of a point set in Euclidean position on a Euclidean 2-orbifold and the planar convex hull of the inverse image (via the quotient map) of the set.

Dynamic planar convex hull operations in near-logarithmic amortized time

We give a data structure that allows arbitrary insertions and deletions on a planar point set P and supports basic queries on the convex hull of P , such as membership and tangent-finding. Updates take O (log 1+ε n ) amori tzed time and queries take O (log n time each, where n is the maximum size of P and ε is any fixed positive constant. For some advanced queries such as bridge-finding, both our bounds increase to O (log 3/2 n ). The only previous fully dynamic solution was by Overmars and van Leeuwen from 1981 and required O (log 2 n ) time per update and O (log n ) time per query.

Shortest Path Geometric Rounding

Exact implementations of algorithms of computational geometry are subject to exponential growth in running time and space. In particular, coordinate bit-complexity can grow exponentially when algorithms are cascaded : the output of one algorithm becomes the input to the next. Cascading is a significant problem in practice. We propose a geometric rounding technique: shortest path rounding . Shortest path rounding trades accuracy for space and time and eliminates the exponential cost introduced by cascading. It can be applied to all algorithms which operate on planar polygonal regions, for example, set operations, transformations, convex hull, triangulation, and Minkowski sum. Unlike other geometric rounding techniques, shortest path rounding can round vertices to arbitrary lattices, even in polar coordinates, as long as the rounding cells are connected. (Other rounding techniques can only round to the integer grid.) On the integer grid, shortest path rounding introduces less combinatorial change and geometric error than the other rounding methods. Three algorithms are given for shortest path rounding, one of which we have used in industrial application software since 1992. In combination with recent advances in exact floating point evaluation of numerical primitives, shortest path geometric rounding yields a practical solution to numerical issues in computational geometry. Geometric algorithms can be implemented exactly on floating point input coordinates; the exact output coordinates can be rounded to accurate floating point approximations; and the cost of each arithmetic operation is only a little more than if it were implemented as a single hardware floating point operation.

On a Simple, Practical, Optimal, Output-Sensitive Randomized Planar Convex Hull Algorithm

In this paper we present a truly practical and provably optimalO(nlogh) time output-sensitive algorithm for the planar convex hull problem. The basic algorithm is similar to the algorithm presented by2, where the median-finding step is replaced by an approximate median. We analyze two such schemes and show that for both methods, the algorithm runs in expectedO(nlogh) time. We further show that the probability of deviation from expected running time approaches 0 rapidly with increasing values ofnandhfor any input. Our experiments suggest that this algorithm is a practical alternative to the worst-caseO(nlogn) algorithms such as Graham's and is especially faster for small output-sizes. Our approach bears some resemblance to a recent algorithm of13, but our analysis is substantially different.

Optimal, output-sensitive algorithms for constructing planar hulls in parallel

In this paper we focus on the problem of designing very fast parallel algorithms for the planar convex hull problem that achieve the optimal O( nlog H) work-bound for input size n and output size H. Our algorithms are designed for the arbitrary CRCW PRAM model. We first describe a very simple O(log nlog H) time optimal deterministic algorithm for the planar hulls which is an improvement over the previously known Ω( log 2n) time algorithm for small outputs. For larger values of H, we can achieve a running time of O(log nloglog n) steps with optimal work. We also present a fast randomized algorithm that runs in expected time O(log H·loglog n) and does optimal O( nlog H) work. For logH = Ω( loglogn) , we can achieve the optimal running time of O(log H) while simultaneously keeping the work optimal. When log H is o(log n), our results improve upon the previously best known Θ(log n) expected time randomized algorithm of Ghouse and Goodrich. The randomized algorithms do not assume any input distribution and the running times hold with high probability.

Fast randomized parallel methods for planar convex hull construction

We present a number of efficient parallel algorithms for constructing 2-dimensional convex hulls on a randomized CRCW PRAM. Specifically, we show how to build the convex hull of n presorted points in the plane in O(1) time using O( n log n) work, with n-exponential probability, or, alternately, in O( log ∗ n) time using O( n) work, with n-exponential probability. We also show how to find the convex hull of n unsorted planar points in O(log n) time using O( n log h) work, with n-exponential probability, where h is the number of edges in the convex hull ( h is O( n), but can be as small as O(1)). Our algorithm for unsorted inputs depends on the use of new in-place procedures, that is, procedures that are defined on a subset of elements in the input and that work without reordering the input. In order to achieve our n-exponential confidence bounds we use a new parallel technique called failure sweeping.

PLANAR CONVEX HULL ALGORITHMS ON LINEAR ARRAYS

This paper presents two planar convex hull algorithms on linear array. The First algorithm is for the case such that n ≤ p, where n and p are the number of points in S and the number of processors, respectively. The algorithm runs in O(n) which is optimal. The second algorithm is designed for a general case such that n > p. The algorithm runs in O((n/p) log(n/p)) time, which is also optimal. Both algorithms have been extended to d-dimensional mesh-connected array with O(d2n1/d ) in time for the case such as n > p and p 1/ >> 2, which are both optimal.

Applications of a semi-dynamic convex hull algorithm

We obtain new results for manipulating and searching semi-dynamic planar convex hulls (subject to deletions only), and apply them to derive improved bounds for two problems in geometry and scheduling. The new convex hull results are logarithmic time bounds for set splitting and for finding a tangent when the two convex hulls are not linearly separated. Using these results, we solve the following two problems optimally inO(n logn) time: (1) [matching] givenn red points andn blue points in the plane, find a matching of red and blue points (by line segments) in which no two edges cross, and (2) [scheduling] givenn jobs with due dates, linear penalties for late completion, and a single machine on which to process them, find a schedule of jobs that minimizes the maximum penalty.

Iterative algorithms for the planar convex hull problem on mesh-connected arrays

Algorithms are presented which solve the planar convex hull problem on a variety of mesh-connected arrays of processors without using recursion or divide-and-conquer techniques. The algorithms for one-way iterative arrays, one-way linear cellular arrays, and two-way linear cellular arrays all operate in time O( n). The algorithm for a two-way d-dimensional cellular array operates in time O(n 1 d ) . These algorithms are optimal for their arrays. The last algorithm can be used on an O( n) processor hypercube with a time complexity of O(log 2 n). We also show how these algorithms can be adapted to fully dynamic implementations with optimal throughput and turn-around. We believe that these algorithms may have performance advantages over existing parallel divide-and-conquer algorithms for planar convex hull.

Distributed algorithm for the planar convex hull problem

The problem of computing the convex hull of a set of vectors in the two-dimensional plane is considered from the point of view of parallel implementation on transputer networks. A parallel algorithm is described, time and evaluated against functionally equivalent single processor code. The results of these numerical experiments are presented and discussed.

Planar Convex Hull Algorithms in Theory and Practice

AbstractSequential and parallel planar convex hull algorithms, their applications and some of the problems encountered on implementations are described. Details of Pascal implementations are given for three of the sequential algorithms: Graham's, Floyd‐Eddy and the Approximation method. The programs are compared experimentally.