Space subdivision to speed-up convex hull construction in E3

This study examines various algorithms for computing the convex hull of a set of n points in a d-dimensional space. Convex hulls are fundamental in computational geometry and are applied in computer graphics, pattern recognition, and computational biology. Such convex hulls can also be useful in symmetry problems. For instance, when points are arranged symmetrically, the convex hull is also likely to be symmetrically shaped, which can be useful for object recognition in computer vision or pattern recognition. The focus is primarily on two-dimensional algorithms, including well-known methods like Gift Wrapping, Graham Scan, Divide and Conquer, QuickHull, TORCH, Kirkpatrick–Sediel, and Chan’s algorithms. These algorithms vary in terms of time complexity and scalability to higher dimensions. This study is extended to three-dimensional convex hull algorithms, such as NAW, randomized insertion, and parallelized versions, such as CudaHull and CudaChain. This study aimed to elucidate the operational principles, step-by-step procedures, and comparative time complexities of each algorithm. The implementation in Python facilitates a detailed comparison of the algorithmic performance through stepwise analysis and graphical outputs. The ultimate goal is to provide insights into the strengths and weaknesses of each algorithm under various scenarios, thereby offering a comprehensive guide for practical implementation.

A parallel algorithm is presented for computing the convex hull of a set ofn points in the plane. The algorithm usesn1−e processors, 0<e<1, and runs inO(ne logh) time, whereh is the number of edges on the convex hull, for a total cost ofO (n logh). This performance matches that of the best currently known sequential convex hull algorithm. In addition, sinceh≤n, the algorithm is worst-case optimal in view of the Ω (n logn) worst-case lower bound on sequential convex hull computation. It is also shown that the convex hull algorithm leads to a parallel sorting algorithm whose total cost isO(n logn), which is optimal.

An approximate algorithm for computing multidimensional convex hulls

PurposeThis study aims to introduce the fast reactive tree (FRT*) algorithm for enhancing replanning speed and reducing the overall cost of navigation in unknown dynamic environments.Design/methodology/approachFRT* comprises four key components: inverted tree build, convex hull construction, dead nodes inform activation and lazy-rewiring replanning. First, an initial path is found from the inverted tree where the valid structure is preserved to minimise re-exploration areas during the replanning phase. As the robot encounters environment changes, convex hulls are extracted to sparsely describe impacted areas. Next, the growth direction of the modified tree is biased by the inform activation of dead nodes to avoid unnecessary exploration. In the replanning phase, the tree structure is optimized using the proposed lazy-rewiring replanning to find a high-quality path with low computation burden.FindingsA series of comprehensive simulation experiments demonstrate that the proposed FRT* algorithm can efficiently replan short-cost feasible paths in unknown dynamic environments. The differential wheeled mobile robot with varying reference linear velocities is used to validate the effectiveness and adaptability of the proposed strategy in real word scenarios. Furthermore, ablation studies are conducted to analyze the significance of the key components of FRT*.Originality/valueThe proposed FRT* algorithm introduces a novel approach to addressing the challenges of navigation in unknown dynamic environments. This capability allows mobile robots to safely and efficiently navigate through unknown and dynamic environments, making the method highly applicable to real-world scenarios.

Heuristic and evolutionary algorithms are proposed to solve challenging real-world optimization problems. In the evolutionary community, many benchmark problems for empirical evaluations of algorithms have been proposed. One of the most important classes of test problems is the class of convex functions, particularly the d-dimensional sphere function. However, the convex function type is somewhat limited. In principle, one can select a set of convex basis functions and use operations that preserve convexity to generate a family of convex functions. This method will inevitably introduce bias in favor of the basis functions. In this paper, the problem is solved by employing insights from computational geometry, which gives the first-ever general-purpose multi-dimensional convex landscape generator. The new proposed generator has the advantage of being generic, which means that it has no bias toward a specific analytical function. A set of N random d-dimensional points is generated for the construction of a d-dimensional convex hull. The upper part of the convex hull is removed by considering the normal of the polygons. The remaining part defines a convex function. It is shown that the complexity of constructing the function is O(Md3), where M is the number of polygons of the convex function. For the method to work as a benchmark function, queries of an arbitrary (d−1) dimensional input are generated, and the generator has to return the value of the convex function. The complexity of answering the query is O(Md). The convexity of the function from the generator is verified with a nonconvex ratio test. The performance of the generator is also evaluated using the Broyden–Fletcher–Goldfarb–Shanno (BFGS) gradient descent algorithm. The source code of the generator is available.

Convex hulls, oracles, and homology

Advances in sensors and cameras allow current research in convex hull algorithms to focus on defining methods capable of processing a big set of points. Typically, in most of these algorithms, the orientation function needs around five sums and two multiplications. In this paper, we propose SymmetricHull, a novel algorithm that, unlike the related ones, only performs two comparisons per point, discarding points with a low probability of belonging to the convex hull. Our algorithm takes advantage of the symmetric geometry of convex hulls in 2D spaces and relies on the convexity principle to get convex hulls, without needing further calculations. Our experiments show that SymmetricHull achieves good results, in terms of time and number of necessary operations, resulting especially efficient with sets of points between \(10^4\) and \(10^7\). Given that our datasets are organized by quadrants, the features of our algorithm can be summarized as follows: (1) a fast point discard based on known points with a good chance to be part of the convex hull, (2) a lexicographic sort of points with a high probability of belonging to the convex hull, and (3) a simple slope analysis to verify whether a point is within the convex hull or not.

Traditional geometric algorithms are often presented as if input imprecision does not exist, even though it is often unavoidable. We argue that in some cases, it may be desirable for geometric algorithms to treat this imprecision as an explicit component of the input, and to reflect this imprecision in the output. Starting with three problems from computational geometry whose inputs are planar point sets (Voronoi diagrams, convex hulls, and smallest bounding discs), we recast these as problems where each input point’s location is imprecise, but known to lie within a particular region of uncertainty. Where algorithms to solve each of the original problems produce a single geometric object as output, the algorithms that we present typically produce either guaranteed or possible output objects. A guaranteed object represents qualities that can be guaranteed for every point set that is consistent with the uncertain regions, and a possible object represents qualities that exist for at least one such point set. By dealing with input imprecision explicitly, these guaranteed and possible objects can represent a more accurate view of what can be reliably inferred from the input data.

A 2-D parallel convex hull algorithm with optimal communication phases

We present parallel computational geometry algorithms that are scalable, architecture independent, easy to implement, and have, with high probability, an optimal time complexity for uniformly distributed random input data. Our methods apply to multicomputers with arbitrary interconnection network or bus system. The following problems are studied in this paper: (1) lower envelope of line segments, (2) visibility of parallelepipeds, (3) convex hull, (4) maximal elements, (5) Voronoi diagram, (6) all-nearest neighbors, (7) largest empty circle, and (8) largest empty hyperrectangle. Problems 2-8 are studied for d-dimensional space, d=O(1). We implemented and tested the lower envelope algorithm and convex hull algorithm (for d=3 and d=4) on a CM5. The results indicate that our methods are of considerable practical relevance. >

Hyperspectral unmixing is a process of decomposing the hyperspectral data cube into endmember signatures and their corresponding abundance maps. For the unmixing results to be completely interpretable, the number of materials (or endmembers) present in that area should be known a priori, which however is unknown in practice. In this work, we use hyperspectral data geometry and successive endmember estimation strategy of an endmember extraction algorithm (EEA) to develop two novel algorithms for estimating the number of endmembers, namely geometry based estimation of number of endmembers - convex hull (GENE-CH) algorithm and affine hull (GENE-AH) algorithm. The proposed GENE algorithms estimate the number of endmembers by using Neyman-Pearson hypothesis testing over the endmembers sequentially estimated by an EEA until the estimate of the number of endmembers is obtained. Monte- Carlo simulations demonstrate the efficacy of the proposed GENE algorithms, compared to some existing benchmark methods for estimating number of endmembers.

Faster output-sensitive parallel algorithms for 3D convex hulls and vector maxima

Given a set Σ of spheres in Ed, with d≥3 and d odd, having a fixed number of m distinct radii ρ1,ρ2,...,ρm, we show that the worst-case combinatorial complexity of the convex hull CHd(Σ) of Σ is Θ(Σ{1≤i≠j≤m}ninj⌊ d/2 ⌋), where ni is the number of spheres in Σ with radius ρi. Our bound refines the worst-case upper and lower bounds on the worst-case combinatorial complexity of CHd(Σ) for all odd d≥3.To prove the lower bound, we construct a set of Θ(n1+n2) spheres in Ed, with d≥3 odd, where ni spheres have radius ρi, i=1,2, and ρ_2≠ρ1, such that their convex hull has combinatorial complexity Ω(n1n2⌊ d/2 ⌋+n2n1⌊ d/2 ⌋). Our construction is then generalized to the case where the spheres have m≥3 distinct radii.For the upper bound, we reduce the sphere convex hull problem to the problem of computing the worst-case combinatorial complexity of the convex hull of a set of m d-dimensional convex polytopes lying on m parallel hyperplanes in Ed+1, where d≥3 odd, a problem which is of independent interest. More precisely, we show that the worst-case combinatorial complexity of the convex hull of a set P{1,P2,...,Pm} of m d-dimensional convex polytopes lying on m parallel hyperplanes of Ed+1 is O(Σ1≤i≠j≤mninj⌊ d/2 ⌋), where ni is the number of vertices of Pi. This bound is an improvement over the worst-case bound on the combinatorial complexity of the convex hull of a point set where we impose no restriction on the points' configuration; using the lower bound construction for the sphere convex hull problem, it is also shown to be tight for all odd d≥3.Finally: (1) we briefly discuss how to compute convex hulls of spheres with a fixed number of distinct radii, or convex hulls of a fixed number of polytopes lying on parallel hyperplanes; (2) we show how our tight bounds for the parallel polytope convex hull problem, yield tight bounds on the combinatorial complexity of the Minkowski sum of two convex polytopes in Ed; and (3) we state some open problems and directions for future work.

There are many space subdivision and space partitioning techniques used in many algorithms to speed up computations. They mostly rely on orthogonal space subdivision, resp. using hierarchical data structures, e.g. BSP trees, quadtrees, octrees, kd-trees, bounding volume hierarchies etc. However in some applications a non-orthogonal space subdivision can offer new ways for actual speed up. In the case of convex polygon in E2 a simple Point-in-Polygon test is of the O(N) complexity and the optimal algorithm is of O(log N) computational complexity. In the E3 case, the complexity is O(N) even for the convex polyhedron as no ordering is defined.New Point-in-Convex Polygon and Point-in-Convex Polyhedron algorithms are presented based on space subdivision in the preprocessing stage resulting to O(1) run-time complexity. The presented approach is simple to implement. Due to the principle of duality, dual problems, e.g. line-convex polygon, line clipping, can be solved in a similarly.

A new algorithm for the determination of the relative convex hull in the plane of a simple polygon A with respect to another simple polygon B which contains A, is proposed. The relative convex hull is also known as geodesic convex hull, and the problem of its determination in the plane is equivalent to find the shortest curve among all Jordan curves lying in the difference set of B and A and encircling A. Algorithms solving this problem known from Computational Geometry are based on the triangulation or similar decomposition of that difference set. The algorithm presented here does not use such decomposition, but it supposes that A and B are given as ordered sequences of vertices. The algorithm is based on convex hull calculations of A and B and of smaller polygons and polylines, it produces the output list of vertices of the relative convex hull from the sequence of vertices of the convex hull of A.