Spherical Geodesic Bounds and a k-Circle Coverage Formulation

Abstract

In this article, we introduce analogues of classic Euclidean bounds, including spherical caps, geodesic axis-aligned bounding boxes (AABBs), geodesic oriented bounding boxes (OBBs), and geodesic k-discrete oriented polytopes (k-DOPs). We also formulate k-circle coverage, a union of variable-radius caps solved by a binary integer program over candidates generated from Discrete Global Grid System (DGGS)-based rasterization. As all constructions run directly on the spherical surface, $S^2$, they preserve geodesic distances and avoid projection distortion. We benchmark these methods on seven country boundary polygons consisting of thousands of points, and report construction time, memory, tightness, and query throughput. Results show our analytic geodesic bounds deliver orders of magnitude improvements over exact tests, with trade-offs in tightness: spherical caps are fastest but loosest; geodesic OBBs are a strong balance; geodesic k-DOPs consistently have the tightest bounds. k-circle coverage has spherical cap query speed while also having locally adaptive fits; construction time increases with DGGS resolution. Altogether, these bounds specific to the sphere provide practical, conservative filters for globe-scale Digital Earth queries.

1. Introduction

In geometric processing, geospatial queries, and rendering, bounding shapes are used as simplified proxies to encapsulate complex objects. By filtering out intricate geometric operations during collision detection or spatial indexing, these proxies significantly reduce computational overhead [1]. Bounding shapes have been studied extensively in both 2D and 3D Euclidean spaces [1,2,3]. For example, a typical collision-detection pipeline first checks whether the objects’ bounding shapes intersect. If the bounding shapes do not intersect, the more precise collision tests can be skipped, significantly improving the efficiency of the collision detection process [1]. In Geographical Information Systems (GIS), bounding shapes form the foundation of spatial indexing and broad-phase filtering, rapidly rejecting non-overlapping features before costly geodesic predicates are evaluated. This approach enables efficient handling of common geospatial tasks without excessive computational overhead.

The ideal bounding shape must balance tightness (conforming closely to the geometry) and simplicity (minimizing memory and computational cost) [1]. In 2D, classic bounding shapes include circles, axis-aligned bounding boxes (AABBs), oriented bounding boxes (OBBs), and k-discrete oriented polytopes (k-DOPs) [1,2], each offering trade-offs in computational cost, memory usage, and tightness of fit.

In spite of the abundant literature on the construction of bounding shapes in 2D and 3D Euclidean spaces [1,3,4,5,6], a considerable gap remains in developing bounding shapes defined directly on the globe as a spherical surface. Many GIS and graphics pipelines perform broad-phase indexing and culling in a planar space (e.g., storing geometries in projected coordinates) because these structures are fast and widely supported. However, any planar projection introduces systematic distortions in distance and area [7,8,9], since mappings from the sphere to the plane are not isometric (they do not map distances and angles exactly). These distortions bias intersection tests unless computationally expensive corrections are applied. Moreover, such methods can be computationally slower depending on the type of projection applied, such as area-preserving projections [7,10]. Our work addresses this by developing bounding shapes within the spherical domain, specifically for large-scale vector data in Digital Earth frameworks [11].

Geospatial vector data often contain thousands or even millions of spatial features, making fast and efficient query handling essential for scalable analysis. For example, when managing the geographic boundaries of large regions, such as countries or provinces, bounding shapes enable rapid retrieval of all relevant spatial features within these areas. Our goal is to provide rapid spatial query evaluations, significantly improving performance in large-scale geospatial datasets.

In this paper, we introduce novel geodesic analogues of the basic Euclidean bounding shapes. We evaluate complex geospatial polygons under a variety of metrics, including construction time, memory usage, tightness, point-in-polygon test, and polygon–polygon intersection time. Our experiments show that the circle, represented as a spherical cap in spherical geometry, produces the fastest intersection test and the least memory usage of the bounding shapes constructed. Geodesic k-DOPs consistently achieve the tightest bounds. While geodesic OBBs offer a decent trade-off between performance and tightness, geodesic AABBs consistently underperform due to their inflexible alignment with defined coordinate axes. The consequence is severe distortion, making geodesic AABBs an unsuitable choice for bounding shapes on the sphere. Unfortunately, all these polytope-like bounds generally remain too slow at test time for the point-in-polygon and polygon–polygon intersection tests. On the sphere, a cap is defined by a centre and angular radius, so intersection reduces to a single dot-product threshold, whereas axis-aligned or other polygons require multiple great-circle half-space tests with extra normalization, which are inherently more complex than on the plane.

To overcome these limitations, we propose k-circle coverage.

In this work, we reformulate the original variable-radius covering problem (which exhibits combinatorial explosion as the number of subsets grows [12]) into a binary integer linear program (BILP). Complex polygons are approximated using a set of multiple optimally located variable-radius spherical caps in order to attain significantly more accurate coverage. The main challenge is finding the best number, location, and size of circles to tightly fit complex shapes. We employ the Discrete Global Grid System (DGGS) for discretization, turning the continuous problem into a discrete one. Our approach draws inspiration from the classic set-cover problems and recent developments in multi-circle coverings on the plane [12,13,14], but we adapt them to geodesic domains.

We found that k-circle coverage outperforms traditional geodesic bounding shapes and offers tighter bounds for complex geospatial objects. It is also compatible with rejection-based filtering in our tests. From a computational perspective, point-in-polygon and polygon–polygon intersection calculations were significantly faster than the preliminary DGGS-based pre-processing phase. Nonetheless, our method remains compatible with DGGS for hierarchical indexing or cascaded filtering when required.

In summary, this paper offers:

• Geodesic bounding shapes on spherical surfaces ($S^2$): Formal definitions, analysis, and linear-time constructions for spherical caps, geodesic AABB/OBB, and geodesic k-DOPs.
• k-circle coverage: Introduction of k-circle coverage on the sphere and a novel DGGS-discretized, BILP-solved union-of-caps with conservative coverage guarantees on sampled vertices.
• Efficient predicates: Constant- or near-constant-time point-in-polygon and polygon–polygon intersection tests tailored to $S^2$, suitable for broad-phase culling.
• Comprehensive evaluation: Empirical analysis of time, memory, tightness, and throughput on six real polygons (3k–12k vertices) with a reproducible setup.

2. Background and Prior Work

This section contextualizes the theoretical and methodological foundations of this study. We review bounding shapes implementations in classic Euclidean forms to neural bounding implementations that leverage learning-based models, and examine how bounding shapes have been integrated into spatial indexing schemes such as R-trees, S2, and H3. We also describe the shortcomings of projection-based methods that approximate spherical data using planar methods and describe the Digital Earth paradigm of DGGS and summarize its approach to discretization, indexing, and query primitives that we later use as a benchmark model of our comparisons. Finally, we summarize the mathematical concepts in spherical geometry that underlie our geodesic constructions.

2.1. Approaches to Bounding Shapes

In local-scale GIS contexts, planar bounding boxes typically suffice because projection-induced distortions are minimal. At global scales, however, these distortions become non-negligible, making it necessary to use geodesic lines on the Earth’s curvature. While many projections can still yield topologically valid bounds away from singularities (locations where the map projection is undefined, e.g., the poles in many projections), they can degrade tightness and increase computational cost. These global use cases motivate the construction of spherical bounding shapes.

One simple approach to define spatial computations on a spherical surface is to project the spherical dataset into the Euclidean domain through map projections [15]. Here, we compute bounding shapes in flat space with conventional methods before inverse-projecting back to the sphere. Possible projections in Digital Earth paradigms include gnomonic or Snyder projections [7], or the exponential map [16,17]. However, such projections inevitably introduce distortions in the final bounding shapes, especially near the poles or along coordinate axes. Illustrations of these distortions are shown in Figure 1, applied to a dataset that represents the boundary of Australia.

Another approach is to use 3D bounding boxes in their original Euclidean domain for spherical datasets [1]. Although simple to construct, these volumes often include large regions of empty space when the data is restricted to the surface of the sphere. Latitude–longitude boxes [18] are also commonly used, but their edges consist of small-circle arcs (parallels) and great-circle arcs (meridians). A nontrivial challenge arises when extending latitude–longitude boxes into OBB or k-DOP counterparts, as the edge directions are no longer constrained to constant latitude or longitude. In practice, this often introduces complex rhumb (loxodromic) lines, which are not geodesics except along the equator and meridians, and complicate both the representation and the algorithms that operate on the shape.

2.2. Analytic Bounding Shapes

Classic Euclidean bounding shapes such as minimum bounding circles [6,19], axis-aligned bounding boxes (AABBs) [1,20], oriented bounding boxes (OBBs) [1,2,5], and k-discrete oriented polytopes (k-DOPs) [1,4,5] offer well-established trade-offs between computational efficiency and geometric tightness. While bounding circles and AABBs are inexpensive to construct and query, they often suffer from excessive empty space and orientation bias, leading to high false-positive rates. OBBs and k-DOPs mitigate this by aligning with the dataset’s variance or utilizing multiple orientations, yielding tighter bounds at the cost of increased construction complexity and storage. Furthermore, rigid Euclidean constructs like AABBs rely on uniform metrics that do not naturally translate to spherical space.

To overcome the limitations of forcing a complex object into a single, global primitive, our k-circle coverage models a polygon as a union of localized spherical caps. Motivated by classical variable-radius covering problems in planar geometry [12], this flexible, feature-adaptive approach has not been previously extended to the sphere.

2.3. Learning-Based Bounding Shapes

Recent neural approaches have proposed learning bounding shapes directly, replacing analytic primitives with classifiers or implicit fields that label points in ${\mathbb{R}}^d$ (or on $S^2$) as inside or outside [21,22,23,24,25,26]. These methods can lower false positives in specific benchmarks by tailoring decision limits to a given object and query distribution. However, for our geospatial setting, this strategy is disproportionate to the problem. First, learned bounds are typically specialized: each object class, query type (ray–shape intersection vs. point containment), and domain (planar vs. spherical) tends to require a distinct network, each with non-trivial training time, tuning, and dataset construction.

More critically, most current learning-based bounds lack formal guarantees of conservativeness (i.e., containing all the points). Zero false-negative behaviour is typically supported empirically (e.g., through Monte Carlo sampling) rather than by proofs of coverage [21]. This limitation is particularly problematic for GIS frameworks that depend on strict correctness, as even a single missed point (i.e., a false negative) violates the core purpose of a bounding shape as a rejection test.

These trade-offs motivate our use of analytic, geodesic bounding shapes with demonstrable containment on $S^2$. Our implementations rely on closed-form algorithms, are easily reproducible, and offer strict no-false-negative guarantees by construction. We find in practice that they offer sufficient pruning efficiency without the expensive training, ambiguity, and validation problems in these learning-based approaches.

2.4. Bounding Shapes in Other Spatial Frameworks

Most spatial frameworks employ a filter-and-refine strategy: inexpensive bounding shapes accelerate queries by discarding non-overlapping candidates before expensive exact geometry tests are performed.

The R-tree family [27] packs spatial objects in a height-balanced tree whose nodes hold minimum bounding rectangles (MBRs). Query performance heavily depends on the quality of these bounds. Variants such as the R*-tree [28], Hilbert R-tree [29], and SR-tree [30] improve clustering, reduce overlap, or combine multiple bounding shapes (e.g., rectangles and spheres). Collectively, these trees demonstrate that bounding shape quality—tightness, orientation, adaptability to variation in the data—is a significant factor in index efficiency.

For global-scale applications, planar projections introduce severe distortion. Systems such as Google’s S2 Geometry Library [31] and Uber’s H3 system [32] instead use hierarchical spherical grids. S2 subdivides a cube projected onto the sphere into spherical quadrilaterals, while H3 uses a hexagonal tesselation derived from a base icosahedron. In both cases, fixed-resolution cells act as coarse filters during query traversal.

Our approach diverges from these hierarchies by focusing on feature-adaptive bounds defined continuously on $S^2$. This allows them to rotate and align specifically with the principal axes of the input geometry, offering arbitrary precision independent of a grid resolution. Furthermore, our k-circle coverage formulation introduces a hybrid novelty: it leverages the discrete nature of DGGS for tractable candidate generation (solving the coverage location problem) but outputs a continuous union-of-caps representation. This decouples the runtime query phase from the grid hierarchy, enabling constant-time intersection tests that do not require traversing a cell tree or managing discrete cell collections.

2.5. Spherical Geometry

This section establishes the notation and core concepts of spherical geometry, which we use through Section 3 and Section 4, and the analyses that follow.

Points on the unit sphere $S^2$ are represented as unit vectors $p=(x,y,z)$ in three-dimensional Euclidean space ${\mathbb{R}}^3$:

$$S^2=\left\{p=(x,y,z)\in {\mathbb{R}}^3|\parallel p\parallel =1\right\}.$$

A great circle is the intersection of the unit sphere $S^2$ with any plane that passes through the origin. On the sphere, geodesics are exactly great circles—the shortest path between any two of its points lies entirely on the circle itself. Consequently, all geodesics on $S^2$ are great circles. The geodesic distance between two points $p_1$ and $p_2$ on the sphere is defined as the central angle $\gamma$ between them:

$$d(p_1,p_2)=\gamma =arccos(p_1·p_2).$$

This metric accounts for the curvature of the sphere and is essential for accurate geodesic bounding shape computations [33].

Finding a point set’s angular extents along prescribed orientations is a fundamental step in the construction of geodesic bounding shapes in Section 3. Choose an orthonormal pair $\{\mathbf{u},\mathbf{v}\}\subset {\mathbb{R}}^3$ that spans the target great-circle plane, whose normal is $\mathbf{n}=\mathbf{u}\times \mathbf{v}$. Project each point $p\in S^2$ onto this plane and measure its oriented central angle

$${\theta }_i=atan2\left(p·\mathbf{v},p·\mathbf{u}\right)\in (-\pi ,\pi ].$$

Each value ${\theta }_i$ is the signed arc-length (in radians) from the reference axis $\mathbf{u}$ to the projection of p onto the great-circle plane, measured counter-clockwise about the normal $\mathbf{n}$.

A spherical lune is the intersection of two hemispheres whose boundary arcs meet along a pair of antipodal points. Fix two distinct great-circle planes through the origin with unit normals ${\mathbf{n}}_1,{\mathbf{n}}_2\in {\mathbb{R}}^3$. Each plane subdivides the sphere into hemispheres with outward normals $\pm {\mathbf{n}}_1$ and $\pm {\mathbf{n}}_2$. A spherical lune is formed by intersecting one hemisphere from each plane; its pole directions are

$$\pm {\displaystyle \frac{{\mathbf{n}}_1\times {\mathbf{n}}_2}{\parallel {\mathbf{n}}_1\times {\mathbf{n}}_2\parallel }}.$$

Informally, it is the football-shaped patch “wedged” between two great-circle half-arcs that share common endpoints. An example is illustrated in Figure 2, where the shaded blue region denotes the smaller lune bounded by the red and blue great circles. Spherical lunes will reappear throughout the paper, as many of these bounding shapes on $S^2$ can be expressed succinctly as intersections of spherical lunes.

2.6. Multi-Disk Covering in the Plane

Early planar coverage models, such as the Location Set Covering Problem and the Maximal Covering Location Problem [34,35,36,37], assumed fixed-radius disks to cover points of interest. Subsequent generalizations explored variable radii, initially optimizing a single global radius parameter [38,39], and later allowing independent radius selection for each disk to better adapt to spatial demand [40,41,42,43].

The most direct precursor to our approach is the Variable Radius Covering Problem introduced by Berman et al. [12]. In its discrete form, the decision-maker selects both the number of disks and their variable radii to completely cover all points of interest at a minimal total cost. By restricting candidate locations to precise sites, Berman et al. framed this flexibility as a mixed-integer programming problem, balancing smaller, cheaper disks against fewer, larger ones.

Crucially, all of these classical models operate strictly within Euclidean geometry. We adapt this discrete variable-radius template to formulate our novel k-circle coverage on the unit sphere. In our approach, candidate disk centres are restricted to DGGS refinement vertices, ensuring the resulting spherical caps align with and collectively cover the polygon’s DGGS rasterization. We retain the binary-integer framework to enforce a maximum budget of k caps, but rather than assigning an explicit cost to radius size, we fix each chosen radius to the minimum value required for local containment and strictly penalize the enclosure of non-polygon cells. All distance and coverage predicates are evaluated directly on $S^2$.

2.7. Discrete Global Grid System (DGGS)

Discrete Global Grid Systems (DGGSs) partition the Earth’s surface into hierarchical, multi-resolution cells through the recursive refinement of a base polyhedron [9,11,44,45,46]. By utilizing geodesic great-circle arcs, these grids provide topologically consistent, uniform coverage that conforms directly to the sphere, avoiding the severe planar projection distortions that occur at global scales. A visualization of the refinement process of an icosahedral geodesic DGGS from resolution 0 to 5 is shown in Figure 3. In this paper, we leverage a geodesic DGGS to discretize the continuous k-circle coverage problem into a tractable grid-based formulation.

To generate candidate bounding caps, spherical polygons are first rasterized into DGGS cells. Each polygon vertex is identified within a specific triangular base-cell of the high-resolution polyhedral proxy. The geometry is then mapped onto the planar face using a piecewise gnomonic projection, which preserves geodesic edges as straight lines to allow for efficient planar computation. As each polygon edge is processed, the polygon is rasterized by encoding all DGGS cells that either contain its vertices or intersect its edges. This approach respects spherical geometry, minimizes distortion, and allows for the constant-time encoding required to build the discrete candidate set for our high-resolution Digital Earth platforms [45].

3. Constructing Geodesic Bounding Shapes

Throughout this section, we assume the input to each bounding shape construction is a finite set of points

$$P=\{p_1,\dots ,p_n\}\subset S^2$$

represented as unit vectors in ${\mathbb{R}}^3$. Each $p_i$ denotes either a vertex of a spherical polygon or an element of a point cloud sampled on the unit sphere. The memory structure of all bounding shape classes follows the data representations recommended in [1]. Memory use remains low across all bounds, with spherical caps smallest, AABBs and OBBs slightly larger, and k–DOPs scaling linearly with k yet staying lightweight when directions are shared. For a visual comparison of all bounding shapes on the same dataset (Mainland Australia), see Figure 4; we will refer to it throughout this section.

3.1. Minimum Spherical Cap

A spherical cap is the region of the unit sphere $S^2$ defined by a centre $u\in S^2$ and a dot-product threshold $t\in [-1,1]$, namely

$$\mathsf{Cap}(u,t)=\{p\in S^2\mid u·p\ge t\},$$

which corresponds to all points lying within a central angle $\theta =arccos\left(t\right)$ of the apex direction u. The goal of this construction is to compute the smallest such cap that encloses a given point set $P=\{p_1,\dots ,p_n\}\subset S^2$. Figure 5 illustrates this geometric definition, showing how the angle $\theta$ and threshold t determine the boundary of the cap.

Our algorithm leverages a well-established Euclidean strategy—computing the minimum enclosing ball in ${\mathbb{R}}^3$—as a proxy for spherical cap construction. We interpret the unit vectors $p_i$ as points in ${\mathbb{R}}^3$ and apply Welzl’s algorithm for the smallest enclosing ball [19]. As part of the process to ensure expected linear time, the point set is shuffled once using a fixed pseudorandom generator. Welzl’s algorithm then returns a unique minimal Euclidean sphere $B(C,r_{\mathrm{euc}})$ centred at $C\in {\mathbb{R}}^3$ with radius $r_{\mathrm{euc}}$ that contains all points of P.

To convert this Euclidean ball to a spherical cap, we first compute the norm $\parallel C\parallel$. If this norm is negligibly small, the centre is effectively the origin of the unit sphere, meaning the input points are widely distributed and all directions are acceptable. The cap in this case shrinks to the whole sphere. Otherwise, we normalize the centre to obtain the cap axis $u=C/\parallel C\parallel \in S^2$. Solving for $u·p$ on the boundary yields:

$$t={\displaystyle \frac{1-r_{\mathrm{euc}}^2+{\parallel C\parallel }^2}{2\parallel C\parallel }},$$

which ensures that $u·p\ge t$ for all $p\in P$, and is tight for any support points that lie exactly on the boundary of the Euclidean ball. This yields the spherical cap that minimally encloses the input points, as illustrated in Figure 6.

The cap is stored compactly as the pair $(u,t)$, taking only 32 bytes in double-precision floating point—a scalar for each of the three values in the unit vector u and a scalar threshold quantity t. The complexity is overall $\mathcal{O}\left(n\right)$ with $\mathcal{O}\left(1\right)$ auxiliary memory. This conversion is numerically stable provided the inputs are in double precision. Degenerate configurations (e.g., nearly hemispherical or antipodal inputs) are handled by treating small $\parallel \mathbf{C}\parallel$ as the full-sphere case.

A spherical cap is defined by one dot-product inequality and is thus the simplest bounding primitive in $S^2$. This makes the structure particularly well-adapted to coarse filtering or to preliminary pruning phases. However, because the cap is radially symmetric, it may not capture elongated or skewed point distributions efficiently.

3.2. Geodesic AABB

The geodesic AABB construction begins by establishing a fixed orthonormal frame using two basis vectors:

$${\mathbf{e}}_1={(0,1,0)}^{\mathsf{T}},{\mathbf{e}}_2={(0,0,1)}^{\mathsf{T}},$$

and completes a right-handed frame with

$${\mathbf{e}}_3={(1,0,0)}^{\mathsf{T}}={\mathbf{e}}_1\times {\mathbf{e}}_2.$$

All angular measurements are taken with respect to this frame; no run-time rotation of the coordinate system is required.

For each input vertex $p_i\in P\subset S^2$, we compute two signed angles with atan2:

$${\theta }_i=atan2(p_i·{\mathbf{e}}_3,p_i·{\mathbf{e}}_2),{\varphi }_i=atan2(p_i·{\mathbf{e}}_3,p_i·{\mathbf{e}}_1).$$

Their extrema at these angles:

$${\theta }_{min},{\theta }_{max},{\varphi }_{min},{\varphi }_{max},$$

determine four great-circle half-spaces.

The two $\theta$ half-spaces form a longitude-style lune $L_{\theta }$, while the two $\varphi$ half-spaces form an independent latitude-style lune $L_{\varphi }$. Four lines are formed by intersecting the half-spaces, each of which can point in two opposite directions. For each boundary plane, we retain the orientation that encloses all input points.

Since the axes are fixed to the meridian planes, edges converge to skew ‘kite’ corners. The footprint grows especially for oblique or high-latitude shapes and into the antimeridian. By fixed orientation, we mean that the principal axes remain constant during computation. This constraint often leads to looser encodings compared to geodesic OBB or geodesic k-DOP counterparts which adapt their orientation for tighter fits.

The memory usage consists of storing only the minimum and maximum corner directions, each costing $2\times 3\times 8=48$ bytes. Construction requires a single pass over P, i.e., linear time, $\mathcal{O}\left(n\right)$.

3.3. Geodesic OBB

The geodesic OBB generalizes the axis-aligned construction by rotating the frame to match the principal components of the input data.

We begin by computing the covariance matrix of the point set and extracting its eigenvectors. The two corresponding to the largest eigenvalues define the principal directions we need. Let ${\mathbf{u}}_1$ and ${\mathbf{u}}_2$ denote these dominant directions. Complete a right-handed triad with ${\mathbf{u}}_3={\mathbf{u}}_1\times {\mathbf{u}}_2.$

For each vertex $p_i$, we compute the two signed angles that define perpendicular lunes:

$${\theta }_i=atan2(p_i·{\mathbf{u}}_3,p_i·{\mathbf{u}}_2),{\varphi }_i=atan2(p_i·{\mathbf{u}}_3,p_i·{\mathbf{u}}_1).$$

Their extrema ${\theta }_{min},{\theta }_{max},{\varphi }_{min},{\varphi }_{max}$ determine two perpendicular spherical lunes, exactly as in the geodesic AABB case but now aligned with the principal component frame. The resulting bounding directions are returned and denoted as

$$v_1,v_2,v_3,v_4.$$

Since principal component analysis aligns the box frame to the dataset’s principal directions, the angular half-extents around each axis are balanced. At the sphere, every corner is the point of intersection between some great-circle edge (rotated longitude constant) and some small-circle edge (rotated latitude constant); in terms of the half-extents as $\theta$ and $\varphi$, the dihedral angle between the supporting great-circle planes at the corner is

$$\alpha =arccos\left(cos\theta cos\varphi \right),$$

which approaches ${90}^{\circ }$ for balanced, large extents. Intersecting the half-spaces gives four lines, each of which can point in two opposite directions. We keep the orientation that still encloses the original geometry—specifically, the direction that points roughly the same way as the average of all edge normals—so we end up with the correct four lines and discard their antipodal counterparts.

The data structure stores the centre $3\times 8=24$ bytes, two principal components $2\times 3\times 8=48$ bytes, and two half extents $2\times 8=16$ bytes, occupying 88 bytes. Computing the $3\times 3$ covariance matrix is $\mathcal{O}\left(n\right)$, the full eigendecomposition is constant-time with respect to n, and every subsequent step is $\mathcal{O}\left(n\right)$ or better, so the overall cost remains linear in the input size.

3.4. Geodesic k-DOP

Unlike the planar k-DOP, our PCA-aligned geodesic k-DOP generalizes the geodesic OBB, intersecting k great-circle half-spaces grouped into $k/2$ orientation pairs. We take $k=2N$ with $N\ge 2$, and select N principal unit directions

$${\mathbf{d}}_1,\dots ,{\mathbf{d}}_N\in S^2$$

that fix the orientation of the faces.

For each orientation i, we store two hemispherical half-spaces with great-circle boundaries whose poles

$${\mathbf{n}}_i^{-},{\mathbf{n}}_i^{+}\in S^2$$

are arranged symmetrically about ${\mathbf{d}}_i$. Their intersection forms a spherical lune that bounds the data along orientation i.

The geodesic k-DOP is the intersection of these N lunes, i.e., of all k half-spaces, yielding a convex spherical polygon with at most k edges or vertices. For visual examples at multiple k, see Figure 4 (rows 2–3: 4-DOP, 8-DOP, 16-DOP, 32-DOP, 64-DOP, 256-DOP).

Setting $N=2$ (so $k=4$) recovers the geodesic OBB. If the orientations are fixed to the canonical basis, the construction reduces to the geodesic AABB.

The implementation follows the principal-component strategy of the OBB and then recursively bisects the quadrant spanned by the two leading eigenvectors. After computing the covariance matrix of the sample, we take the two leading eigenvectors ${\mathbf{u}}_1$ and ${\mathbf{u}}_2$, regarding them as an orthonormal basis of the plane that best fits the data. Inside that plane, we draw N equally spaced directions at angles

$${\theta }_j=j\pi /N,j=0,\dots ,N-1,$$

giving primary directions

$${\mathbf{d}}_j=cos{\theta }_j{\mathbf{u}}_1+sin{\theta }_j{\mathbf{u}}_2.$$

Each ${\mathbf{d}}_j$ defines a great-circle slab, together with its antipode $-{\mathbf{d}}_j$. The antipodes are stored because they bound the opposite faces but do not count against the quota of N distinct axes. Thus, the k-DOP uses the $2N$ normals

$$\{\pm {\mathbf{d}}_0,\dots ,\pm {\mathbf{d}}_{N-1}\},$$

providing a uniform angular sampling around the principal plane. The result is a cyclically ordered list $\pm {\mathbf{d}}_1,\dots ,\pm {\mathbf{d}}_N$ lying in the plane spanned by ${\mathbf{u}}_1$ and ${\mathbf{u}}_2$. The third axis

$${\mathbf{u}}_3={\mathbf{u}}_1\times {\mathbf{u}}_2$$

remains orthogonal to that plane and is reused locally inside each lune, as in the OBB. For every pair $({\mathbf{d}}_i,{\mathbf{d}}_{i+1})$, we define the right-handed triad

$$\mathbf{a}={\mathbf{d}}_i,\mathbf{b}={\mathbf{d}}_{i+1},\mathbf{c}=\mathbf{a}\times \mathbf{b}.$$

Each vertex p yields two signed angles:

$$\theta \left(p\right)=atan2\left(p·\mathbf{c},p·\mathbf{b}\right),\varphi \left(p\right)=atan2\left(p·\mathbf{c},p·\mathbf{a}\right),$$

whose extrema

$${\theta }_{min}^{\left(i\right)},{\theta }_{max}^{\left(i\right)},{\varphi }_{min}^{\left(i\right)},{\varphi }_{max}^{\left(i\right)}$$

define four great-circle normals exactly as in the AABB:

$${\mathbf{n}}_{{\theta }_{min}}^{\left(i\right)}=cos{\theta }_{min}^{\left(i\right)}\mathbf{c}-sin{\theta }_{min}^{\left(i\right)}\mathbf{b},\dots$$

We collect the $4N$ oriented planes into a list

$$\mathcal{P}={\{{\Pi }_j=(\mathbf{0},{\mathbf{n}}_j)\}}_{j=1}^{4N},$$

where each plane ${\Pi }_j$ is defined by its normal vector ${\mathbf{n}}_j$ and passes through the origin. For every unordered pair $({\Pi }_a,{\Pi }_b)\in \mathcal{P}$, their intersection line L is computed. The ray along L pointing toward $\mathbf{p}$ is retained if and only if it lies within the positive half-space of all planes in $\mathcal{P}$. This procedure yields at most k geodesic vertices that form a convex, simple, spherical polygon.

The memory usage consists of storing $k/2$ centres ${\displaystyle \frac{k}{2}}\times 3\times 8=12k$, k directions $k\times 3\times 8=24k$, and k half extents $k\times 8=8k$, occupying $44k$ bytes. For the common $k=8(N=4)$ case, this totals 344 bytes, which is still smaller than the raw vertex list it encloses.

Building the covariance matrix, sweeping the k directions, and collecting the extrema each require a single pass over the n vertices. Thus, the running time is $\mathcal{O}(n+k^2)$, where the $k^2$ term comes from the all-pairs plane intersections (typically negligible for $k\le 32$). See Algorithm 1 for the complexity breakdown. All auxiliary containers are bounded by $k^2$ elements, giving $\mathcal{O}\left(k^2\right)$ extra memory.

Algorithm 1 Build Geodesic k-DOP on $S^2$

Input: Point set $P=\left\{p_i\right\}\subset S^2$, even $k=2N(N\ge 2)$ Output: Convex spherical k-DOP (planes and vertex list); for $k=4$ this is the geodesic OBB

1: // Principal frame 2: $\Sigma \leftarrow {\displaystyle \frac{1}{\left|P\right|}}{\sum }_i{p}_i{p}_i^{\top }$ 3: $(u_1,u_2,u_3)\leftarrow$ eigenvectors of $\Sigma$ with $u_3=u_1\times u_2$ 4: // Sample N directions in the $u_1$–$u_2$ plane 5: for $j=0$ to $N-1$ do 6:       ${\theta }_j\leftarrow j\pi /N$,    $d_j\leftarrow cos{\theta }_j{u}_1+sin{\theta }_j{u}_2$ 7: end for 8: $D\leftarrow {\{\pm d_j\}}_{j=0}^{N-1}$                                     ▹k oriented axes 9: // For each axis, take angular extrema to form great-circle slabs 10: $P_{\mathrm{planes}}\leftarrow \varnothing$ 11: for$d\in D$do 12:       $c\leftarrow d\times u_3$                                     ▹right-handed triad $(d,u_3,c)$ 13:       ${\theta }_i\leftarrow atan2(p_i·u_3,p_i·d)$ for all i 14:       $({\theta }_{min},{\theta }_{max})\leftarrow ({min}_i{\theta }_i,{max}_i{\theta }_i)$ 15:       Add planes with unit normals $n_{min}=cos\left({\theta }_{min}\right)u_3-sin\left({\theta }_{min}\right)d$ and $n_{max}=cos\left({\theta }_{max}\right)u_3-sin\left({\theta }_{max}\right)d$ to $P_{\mathrm{planes}}$ on $S^2$. 16: end for 17: // Intersect slabs; keep rays that satisfy all half-spaces 18: $V\leftarrow \varnothing$ 19: for all unordered pairs $({\Pi }_a,{\Pi }_b)\subset P_{\mathrm{planes}}$ do 20:       $L\leftarrow {\Pi }_a\cap {\Pi }_b$                                    ▹great-circle line 21:       for the two antipodal ray directions on L do 22:             if direction lies in positive half-space of every $\Pi \in P_{\mathrm{planes}}$ then 23:               $V\leftarrow V\cup \left\{\mathrm{direction}\right\}$ 24:             end if 25:       end for 26: end for 27: Order V cyclically; return $\{P_{\mathrm{planes}},V\}$ Cost:$O\left(\right|P|+k^2)$ time, $O\left(k^2\right)$ aux. memory.

3.5. Bounding Shape Analysis

We evaluate the performance and quality of our proposed geodesic bounding shapes with several factors: construction time, query performance, spatial coverage, and memory usage. We conducted our experiments on real world spherical polygon datasets to ascertain the performance of our bounding shapes. We defer full, in-depth benchmarking on multiple complex spherical polygons to Section 5. In this section, we present a single case study on the national boundary of Australia, a single polygon with 9462 vertices. Representative outputs are shown in Figure 4. All experiments were executed on a 64-bit Ubuntu 24.04.1 LTS system with an Intel^® Core™ i7-14650HX CPU.

3.5.1. Construction Time

The construction benchmarks for Australia are shown in

Table 1. Metrics for Mainland Australia (9462 vertices) geodesic bounding shapes on the unit sphere. Relative area is normalized to the true polygon area.

Bounding Shape	Area (sr)	Relative Area	Construction Time (ms)	Self-Intersection Time (ns)	PiP Time (ns)
Original	0.187572	1.000	–	261,362,000	36,041.29
Spherical Cap	0.313453	1.671	0.223	3.01	1.08
AABB	0.382726	2.040	0.271	98.25	67.24
OBB	0.346305	1.846	0.254	82.07	48.19
4-DOP	0.276265	1.473	1.731	149.24	59.62
8-DOP	0.244650	1.304	3.304	178.40	87.99
16-DOP	0.239673	1.278	6.520	430.10	139.13
32-DOP	0.237537	1.266	12.970	451.84	202.08
64-DOP	0.236380	1.260	25.870	544.78	259.41

. Among the simple polygons, the geodesic OBB is the most efficient to construct, thanks to its alignment with the data’s major directions. It is built in a single pass over the vertices with a small constant factor. In contrast, the geodesic AABB requires additional projections and, as a result, is typically slower than the OBB in our implementation, despite also being a single-pass $\mathcal{O}\left(n\right)$ method. The spherical cap, while still expected to operate in linear time, carries a slightly higher constant factor due to the enclosing-ball routine. Geodesic k-DOPs tighten monotonically as k increases, and their build time scales roughly linearly with the number of directions (i.e., $\mathcal{O}\left(kn\right)$). Low k (e.g., 4–16) adds only modest overhead relative to OBB, whereas higher k trades more build time for tighter bounds.

Overall, these analytic constructions are linear in the number of vertices; they differ primarily in constant factors and reveal a clear trade-off between build cost and tightness.

3.5.2. Bounding Shape Tightness

We quantify tightness as the area ratio $A_{\mathrm{bound}}/A_{\mathrm{poly}}$, as shown in Table 1. The geodesic k-DOPs become progressively tighter as the number of directions k increases. In practice, values in the range from 16 to 32 offer a good balance, with returns diminishing thereafter. A good middle option is provided by the geodesic OBB. They are consistently tighter than geodesic AABBs and less prone to global axis alignment. Conversely, geodesic AABBs are very dependent on the orientation of the meridians, so poorly aligned they can end up with extraneous coverage. Finally, the spherical cap is the loosest of all, relying on a single-parameter radius and therefore trading extreme simplicity for tightness. For this dataset, it is tighter than both the AABB and OBB but remains looser than the k-DOPs, reflecting the inherent trade-off between simplicity and tightness.

3.5.3. Polygon Intersection Query Time

Table 1 shows mean bound–bound intersection times for the Mainland Australia polygon. For each bounding shape type (spherical cap, AABB, OBB, and various k-DOPs), we intersect its bound with the antipodal copy of that same bound (i.e., the original bound reflected through the origin). Since these bounds are smaller than a hemisphere, the bound and its antipode are guaranteed to be disjoint, avoiding trivial self-overlaps and forcing a full traversal of edge–edge checks.

The spherical cap is the fastest by far, effectively constant at the machine scale due to its single dot-product threshold calculation. Geodesic AABB and OBB follow closely, both reducing to a handful of plane or interval tests with fixed overhead (hundreds of nanoseconds on our hardware). Geodesic k-DOPs scale roughly linearly with the number of directions k (i.e., $\mathcal{O}\left(k\right)$ half-space checks); even at $k=64$, they remain within the low-microsecond regime.

Given that these bounds serve only as a coarse filter before exact polygon–polygon refinement, the intersection costs reported in the table are negligible compared to the exact polygon check (∼261 ms). Construction is a one-time preprocessing step, so its cost can be ignored at query time. In this setting, spherical caps are extremely promising, essentially reducing the intersection to a simple dot-product check, with a miniscule memory representation. This makes them ideal as a first-pass coarse check, either as an aggressive prefilter to reject most non-intersecting candidates or as the opening stage in a cascaded filtering pipeline.

3.5.4. Point-in-Polygon (PiP) Query

Table 1 reports average PiP query times for 100,000 random points on the unit sphere.

As with intersection queries, spherical caps are by far the fastest, since membership reduces to a single angular threshold check. Geodesic OBBs and AABBs also provide moderate query times, with OBBs slightly better due to stronger geometric alignment. Geodesic k-DOPs scale with the number of directions k, but also yield the best selectivity for complex polygons. Exact PiP queries on the raw polygon are orders of magnitude slower, underscoring the substantial efficiency gains from our bounding shape-based filtering.

4. Constructing $\mathit{k}$-Circle Coverage

While spherical caps offer exceptionally fast query checks (via a single dot-product threshold), their single-cap bounds are comparatively loose. k–DOPs tighten the footprint, but their test cost grows with k. Our objective is to achieve the query efficiency characteristic of spherical caps while retaining the tightness of higher k-DOPs. To achieve this, we introduce k-circle coverage: a compact union of spherical caps strategically chosen to cover the geocoded polygon.

In continuous form, the k-circle coverage problem asks for cap centres $u_j\in S^2$ and angular radii ${\theta }_j$ (for $j=1,\dots ,k$) that minimize a measure of the total cap area while ensuring that the target polygon $P\subset S^2$ (an example is shown in Figure 7a) is fully contained within the union

$$P\subseteq \bigcup _{j=1}^k\mathsf{Cap}(u_j,cos{\theta }_j).$$

Optimizing the sizes and locations of multiple caps directly on the continuous sphere is computationally intractable. Because a cap’s ideal radius is tightly coupled to its location, the problem is highly non-linear. Furthermore, choosing the optimal combination of caps introduces the same combinatorial difficulty found in classic set-covering problems.

To make this solvable, we adopt a discrete formulation based on the DGGS framework. The sphere is quantized into a fixed-resolution grid of equal-area cells, and the polygon P is represented as a finite set of DGGS cells. A finite set of candidate caps—each defined by a P vertex as its centre and a radius equal to the angular distance from that vertex to another cell vertex—is precomputed. The optimization then selects a subset of these candidates to cover all cells belonging to P. This yields a Binary Integer Linear Programming (BILP) formulation, where each binary variable indicates whether a candidate cap is active. The objective minimizes their total footprint, subject to full-coverage constraints over the polygon’s cells.

This discretized BILP formulation preserves the essential structure of the continuous problem while making it computationally solvable with modern integer programming solvers. The model’s complexity depends on the number of candidate caps and the DGGS resolution: finer resolutions increase the number of cells and constraints, while coarser ones trade precision for efficiency. Conceptually, this process transforms the continuous geometric covering problem into a structured combinatorial optimization, as illustrated in Figure 7.

The resulting k-circle coverage bounding shape approximates complex geospatial polygons by optimally selecting and combining spherical caps from the candidate set to tightly encapsulate the original geometry.

Initially, the input polygon vertices, represented as unit vectors, are indexed into arrays to enable efficient numerical access. Using our DGGS geocoding pipeline (cf. Section 2.7), each $p_i$ is first mapped to its containing base-cell and then to a refined cell index at some resolution w, which allows us to rapidly identify, for each candidate cap centre, the set of polygon vertices it might cover.

We generate a set of N candidate caps by choosing

$$\{q_j\in S^2\mid j=1, \dots , N\}$$

to be the DGGS cell vertices at resolution w, and, for each vertex $q_j$, we compute a sorted list of potential radii:

$$R_j=\left\{dist(q_j,p_i)\mid i=1, \dots , M\right\},$$

where each $p_i$ is a polygon vertex.

We define one binary decision variable per candidate cap:

$$x_j=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}\mathrm{cap}{C}_j\mathrm{is}\mathrm{selected},\hfill \\ 0,\hfill & \mathrm{otherwise},\hfill \end{array}\right.j=1, \dots , J.$$

These are the J decision variables; this means we pick cap j or we do not.

The objective of our optimization model is to minimize:

$$\underset{x}{min}\sum _{j=1}^J{c}_j{x}_j,$$

where $c_j$ is the number of non-polygon (“extra”) points contained in cap $C_j$. It selects a k-subset of caps that covers the polygon while minimizing spillover—i.e., the total number of points outside the polygon that the chosen caps also cover.

The optimization is subject to two key constraints:

Coverage constraint:

$$\sum _{j:p_i\in C_j}{x}_j\ge 1,i=1, \dots , M.$$

This enforces that every polygon point is covered by at least one cap.

Cap constraint:

$$\sum _{j=1}^J{x}_j\le k.$$

This limits the total number of selected caps to at most k.

This BILP problem is solved using GLPK’s branch-and-cut algorithm [47]. The optimal selection of spherical caps is extracted from the solution, yielding a highly tight and accurate approximation of the original polygonal geometry.

Feasibility is defined point-wise on the DGGS cells, not on the continuous surface area. Let $\mathsf{\Omega }\subset S^2$ be the target region and let ${\mathcal{X}}_r=\left\{x_i\right\}$ denote the set of representative DGGS points at resolution r that index the geocoded polygon representation. A k-circle solution ${\left\{(c_j,{\rho }_j)\right\}}_{j=1}^k$ is feasible if and only if every DGGS vertex of the polygon lies inside at least one cap:

$$\forall x\in {\mathcal{X}}_r\exists j\in \{1, \dots , k\}:x·c_j\ge cos{\rho }_j.$$

Figure 7d illustrates a feasible output of this optimization, in which the selected k-circle configuration fully covers all DGGS vertices of the target region. Algorithm 2 details the discrete construction and selection pipeline, including candidate generation, incidence precomputation, and the BILP used to choose at most k caps. Because ${\mathcal{X}}_r$ provides a discrete sampling of $\mathsf{\Omega }$, a feasible solution does not guarantee perfect agreement with the continuous boundary. At coarse resolutions this typically shows up in two ways. First, there may be tiny uncovered gaps between DGGS sample points, even though all sampled points are still contained. Second, the caps may spill slightly beyond $\mathsf{\Omega }$ along the boundary in order to include cells marked as interior. Both effects are controlled and shrink away as the resolution increases or when a small amount of radius padding is applied, as shown in the first row of Figure 8 at resolutions 3, 4, and 5.

Algorithm 2 Build k-Circle Coverage

Input: Polygon DGGS cell-vertices $P\subset S^2$; all-sphere DGGS vertices S; target k Output: Selected caps ${\mathcal{C}}^{★}=\left\{(q,\rho )\right\}$ with $\left|{\mathcal{C}}^{★}\right|=k$

1: // Early exits 2: if$\left|P\right|=0$or$k\le 0$then$$return$\varnothing$ 3: end if 4: // Candidate centres and radii 5: $\mathcal{C}\leftarrow \varnothing$ 6: for$q\in P$do 7:       $R\left(q\right)\leftarrow \mathrm{sorted}\{arccos(q·p):p\in P\}$                           ▹ do not unique() radii 8:       for $\rho \in R\left(q\right)$ do 9:    $\mathcal{C}\leftarrow \mathcal{C}\cup \left\{\right(q,\rho \left)\right\}$ 10:     end for 11: end for 12: // Coverage and cost precomputation 13: $U\leftarrow S\setminus P$                         ▹ non-polygon DGGS vertices for overflow counting 14: Build incidence $A_{i,j}=1$ iff $p_i\in P$ lies inside cap $c_j=(q_j,{\rho }_j)$; else 0 15: For each cap $c_j$, compute ${\mathtt{extraCount}}_j\leftarrow \left|\{u\in U:u\mathrm{is}\mathrm{inside}{c}_j\}\right|$ 16: Variables: $x_j\in \{0,1\}$ for each $c_j\in \mathcal{C}$ 17: Objective: minimize $\sum _j{\mathtt{extraCount}}_j{x}_j$ 18: Constraints: 19:     ${\sum }_j{A}_{i,j}{x}_j\ge 1,\forall i$                                    ▹ cover every $p_i\in P$ 20:     ${\sum }_j{x}_j\le k$                                           ▹ at most k caps 21: Solve; extract ${\mathcal{C}}^{★}=\{c_j:x_j=1\}$

4.1. Evaluation of k-Circle Coverage

We evaluate the performance of k-circle coverage using the metrics introduced in Section 3 (construction time, query efficiency, coverage quality, and memory footprint). The corresponding benchmarks for this evaluation are summarized in

Table 2. k-circle coverage metrics for Australia. Relative area is normalized to the true polygon area (0.187572 sr).

Resolution	Circles (k)	Area (sr)	Relative Area	Construction Time (ms)	Self-Intersection Time (ns)	PiP Time (ns)
3	3	0.383	2.041	33.23	62.02	19.97
3	4	0.378	2.015	29.40	114.35	25.14
3	5	0.359	1.914	29.83	184.83	33.00
4	3	0.313	1.669	2369.27	64.89	20.29
4	4	0.301	1.605	2894.22	121.49	26.66
4	5	0.287	1.530	2755.41	185.30	30.78
5	3	0.273	1.457	220,309.59	66.85	20.56
5	4	0.265	1.412	190,139.17	125.18	28.17
5	5	0.258	1.376	209,812.85	183.04	34.43

. A more detailed analysis, including methodology and per-shape micro-benchmarks, appears in Section 5.

4.1.1. Construction Time

Across our Australia runs, higher resolutions sharply increase the number of candidate caps, inflating the BILP with additional columns and coverage rows. Therefore, branch-and-cut time rises steeply. At a fixed resolution, build time changes only slightly across k (e.g., k = 3 …5). Interestingly, in some cases, adding more circles can even speed up the solver. Sometimes a larger k runs slightly faster than a smaller one (e.g., k = 5 vs. k = 4). This is a discrete solver effect: the additional cap tightens coverage, reduces conflict, strengthens the LP relaxation, and allows the branch-and-cut procedure to prune earlier. As a result, the search tree shrinks and a small net speedup can occur, even with one more variable.

Since k-circle bounds are typically preprocessed, the experiments offer practical guidelines. First, construction should be performed in advance at the highest practical DGGS resolution and cached for reuse. Second, the number of caps k should remain relatively small (typically 3 to 5 caps) to balance tightness, preprocessing cost, and cache size. Third, pruning the candidate pool—by eliminating duplicates, localizing the search region, and restricting radius selections to polygon vertices—is effective for controlling model size without reducing coverage.

4.1.2. Limitations and Mitigations of Discrete Coverage

A critical distinction in our k-circle formulation is the reliance on discrete sampling. The BILP constraints guarantee coverage only for the finite set of DGGS cell vertices $X_r$, not for the continuous boundary $\partial P$. This introduces two geometric limitations.

First, at coarse resolutions, small sampling gaps may occur. A geodesic polygon edge connecting two covered sample points may extend slightly outside the union of caps if the cap curvature is high relative to the sampling density. This effect diminishes as DGGS resolution increases.

Second, strict continuous conservativeness would require enlarging each radius by a small padding term bounded by the DGGS cell diameter. We do not apply explicit padding; instead, we rely on high-resolution rasterization and a small numerical tolerance during radius selection.

A direct method to ensure strict continuous conservativeness is to enlarge the selected cap radii. Specifically, if a cap is solved with radius r, it can be inflated to $r+d$, where d is the maximum DGGS cell diameter at the current resolution.

This modification is mathematically sound because the BILP constraints already guarantee that at least one vertex of every cell representing the geocoded polygon is contained within the original union of caps. Let p denote such a vertex for a partially covered cell, and let x be any point within that cell. Since d represents the maximum possible geodesic distance between any point x in the cell and p, the triangle inequality ensures that

$$d(x,q_j)\le d(x,p)+d(p,q_j)\le d+r,$$

where $q_j$ is the centre of the cap.

Consequently, inflating the cap radius to $r+d$ guarantees that the entire geometric footprint of each DGGS cell—and therefore the continuous boundary $\partial P$—is fully covered. While this modification restores a strict no-false-negative guarantee, it increases the total bounding area slightly. However, as the DGGS resolution increases, the cell diameter d approaches zero, and the inflated bound converges to the original solution (see Figure 9).

4.1.3. Bounding Tightness

The union areas for the k-circle coverage of Australia were numerically computed via high-density Monte Carlo sampling (true area $0.188$ sr).

Higher DGGS resolutions result in noticeably tighter bounds in the union area. Moving from resolution 3 to resolution 4 reduces the area by ∼0.07–0.08 sr across k. We also see that larger k values cause the union area to be more compact at a fixed resolution. This is due to the extra flexibility of multiple caps in following the boundary more closely. Each added cap can help trim excess area, resulting in a tighter bound. Some overestimation is inherent to the DGGS coverage process, which inflates the polygon by treating entire cells as inside once their centres are marked. Moreover, our objective penalizes extra covered cells rather than cap area, and the reported metric is the union of caps (not the intersection with the polygon), so any excess area is counted directly. As a result, all values stay above the true polygon area of $0.188$ sr.

These effects diminish with higher DGGS resolution and modest radius padding, so the bound converges toward the true polygon area in practice.

4.1.4. Polygon Intersection Query Time

Concretely, we intersect the k-circle coverage of the polygon with the k-circle coverage of its antipode (the original reflected through the origin). Like the process in Section 3.5.3, this guarantees a full, non-trivial intersection test—no self-overlap shortcuts—so every edge/arc check is exercised. We observe sub-microsecond throughput across settings (all below 0.2 μs, e.g., 0.062–0.185 μs), with cost dominated by per-cap dot-product checks. Cost grows near-linearly with k: at fixed resolution, intersection time increases proportionally to the number of cap pairs (res 3: 0.062 → 0.184 μs from $k=3 \to 5$; res 4: 0.064 → 0.185 μs), consistent with up to $k^2$ candidate checks but moderated by early exits and radius bounds. Query cost is essentially resolution-insensitive once a covering is built (res 3 vs. res 4 differ by only a few nanoseconds at the same k).

In a bounding-shape filter-and-refine pipeline, these sub-microsecond tests make k-circle coverage a great first rejection check. Their computational cost is negligible compared to the exact polygon–polygon checks that can take hundreds of milliseconds to execute.

4.1.5. Point-in-Polygon Query

We observe a similar microbenchmark pattern to our previous queries: tens of nanoseconds per query, dominated by a small number of fixed half-space tests. Nonetheless, runtime increases modestly with larger k, reflecting extra dot products and comparisons per cap with good branch prediction and cache locality. Once a covering is built, DGGS resolution has negligible effect on PiP cost (res 3 vs. res 4 differ by ∼1–2 ns at each k).

In a streaming context, this translates to ∼30–50 million PiP queries per core per second (from 33 ns to 20 ns/op). The takeaway is the same: push complexity into the offline build; at runtime, k-circle PiP remains fast and predictable, suitable as a first-pass filter in a refine pipeline.

4.1.6. Memory Usage

The memory footprint of k-circle coverage scales with k, with runtime storage taking $O\left(k\right)$ space. A cap is a simple representation: a unit centre $q\in S^2$ and angular radius $\rho$. On typical double-precision implementations, three floats/doubles for q and one for $\rho$ total just a few dozen bytes per cap. The candidate caches and the BILP model grow rapidly with the resolution of the DGGS and the permissible radii, but this excess memory does not affect query performance once the optimal caps have been determined.

In practice, we can set k to a modest value (typically 3 to 5) and save the finer DGGS resolutions for pre-processing. Therefore, our k caps are resolution-agnostic, narrowing the union-area gap and positioning them as a strong geodesic bounding shape for global filter-and-refine. Once constructed, the runtime representation is independent of resolution.

5. Experiments and Evaluation

To assess the utility of these geodesic bounds for filter-and-refine pipelines, we conduct a series of controlled experiments against DGGS ground truth on the unit sphere, measuring construction time, query time (bound–bound and point-in-polygon filtering), coverage tightness, and memory footprint. We vary k where applicable (for k–DOPs and k-circle coverage), adjust DGGS resolution, and repeat runs to stabilize the averages. To avoid trivial overlaps and force a full edge check, we intersect each bound with its antipodal copy. This yields a clean, comparable view of speed, tightness, and space across shapes and settings.

We use publicly available political boundary data to generate geodesic multi-polygons on the unit sphere ($S^2$) representing national boundaries. Our polygons have the following numbers of vertices: Australia has 9462, Brazil has 9154, France has 3097, India has 6761, Spain has 2158, the United States has 12,505, and Norway has 7911. These high-fidelity shapes represent true queries in real-world geospatial applications, and allow us to formally analyze our bounding shape methods.

Our experiments ran on a 64-bit Ubuntu 24.04.1 LTS machine powered by an Intel Core i7-14650HX CPU. All exact queries are converted to a planar framework using a gnomonic projection of the spherical geometry. This projection maps great-circle arcs into straight lines and simplifies polygon–polygon and point-in-polygon queries using standard planar algorithms. We found that this approach is faster than computing directly on the sphere, because it eliminates costly trigonometric calculations. The gnomonic projection is valid only when the point being projected lies within the visible hemisphere. If the geometry is very large or lies near the antipodal region of the sphere, we either subdivide it into smaller local frames or fall back to the native $S^2$ primitive. To account for system jitter and ensure statistical stability, all reported timing benchmarks represent the average of 100 repeated trials; observed run-to-run variability was consistently negligible (standard deviation $<2\%$ of the mean) across all test cases.

5.1. Construction Time

Table 3. Construction time of the geodesic bounding shapes (ms).

Shape	Australia	Brazil	France	India	Spain	USA	Norway
DGGS (res 3)	166.40	191.59	33.81	101.61	24.74	218.00	83.61
DGGS (res 4)	287.69	336.94	45.89	166.64	33.79	385.66	112.46
Spherical Cap	0.223	0.213	0.094	0.144	0.075	0.227	0.128
AABB	0.271	0.245	0.090	0.183	0.054	0.274	0.278
OBB	0.253	0.219	0.076	0.177	0.051	0.273	0.236
4-DOP	1.73	1.63	0.545	1.17	0.372	1.98	1.665
8-DOP	3.30	3.16	1.05	2.22	0.721	4.07	3.231
16-DOP	6.52	6.15	2.07	4.38	1.42	7.64	6.371
32-DOP	13.21	12.04	4.07	8.80	2.77	15.47	12.661
64-DOP	25.87	23.79	7.86	17.28	5.53	30.15	25.225
3-Circle (res 3)	33.23	66.15	1.16	7.12	1.15	34.40	1.122
4-Circle (res 3)	29.40	48.63	1.07	6.54	1.12	33.45	1.104
5-Circle (res 3)	29.83	48.09	1.08	6.34	1.14	32.08	1.105
3-Circle (res 4)	2369.267	3748.734	8.48	285.91	8.21	3572.416	8.982
4-Circle (res 4)	2824.220	3975.213	8.78	270.57	7.58	3595.068	1120.35
5-Circle (res 4)	2755.414	3992.173	8.22	278.76	7.53	3964.833	1121.27

reports the construction time (in milliseconds) for various bounding shapes across several polygons representing countries.

The efficiency of methods like the minimum spherical cap, geodesic AABB, and geodesic OBB is apparent, taking only fractions of a millisecond. The more complex geodesic k-DOPs were calculated in a few milliseconds, with the time growing linearly with k. For example, 4–DOP took approximately 1 ms, 8–DOP ∼3 ms, up to 64–DOP still only ∼25–30 ms for the largest polygon, USA. These construction times are negligible due to simple computations, often involving only one pass through vertices or solving a small fixed-size sub-problem. The geodesic OBB was especially quick, in all instances faster than the geodesic AABB in construction time. The geodesic AABB needed extra projections to reliably capture extremes, and thus incurred extra overhead.

DGGS rasterization is a one-time cost in the tens to hundreds of milliseconds. We see that converting a complex polygon into DGGS cells had a noticeable cost (for example 166 ms for Australia at resolution 3, and up to 386 ms for USA at resolution 4, as shown in the first two rows of the table). DGGS plays two roles in our study. First, for the k-circle coverage, it serves as a discretization step (geocoding) and is therefore part of that method’s preprocessing—not the k-circle construction time itself. Second, DGGS rasterization can also be used as a standalone bounding approach. For completeness, we list the shared DGGS rasterization time in the table to provide context, but we do not charge it to each bounding polytope, and we exclude it from the reported k-circle construction time.

In contrast, k-circle spherical cap covers are significantly more expensive, and increase with the DGGS resolution level. At a coarse resolution (resolution 3), selecting 3 to 5 spherical caps to cover the polygon was on the order of tens of milliseconds for the largest countries (∼33 ms for Australia with 3 caps, ∼66 ms for Brazil with 3 caps), and under 2 ms for smaller countries such as France or Spain. Increasing the resolution to 4 led to a significant increase in optimization time for large, complex shapes: Australia’s 3-cap cover at res 4 took $6.3\times {10}^3$ ms (≈6.3 s) versus 33 ms at res 3. USA and Brazil showed similar increases into the multiseconds. In contrast, France and Spain, due to their smaller area, remained fast even at res 4 (∼8–9 ms), and India was intermediate (∼286 ms for a 3-cap solution), reflecting its moderate complexity.

Our limited experimentation shows that BILP solution time does not increase monotonically as the number of caps (k) increases. For example, for Australia at resolution 4, k = 3 took the longest, approximately 6.3 s, but increasing k to 4 reduced the time down to about 2.8 s, and k = 5 resulted in a time of around 2.76 s. This occurs because a tight cover with too few caps forces a large branch-and-bound search, whereas relaxing the cap budget slightly expands the feasible region and shrinks the integrality gap, allowing faster pruning.

In practice, it is advantageous to choose the coarsest DGGS resolution that meets accuracy, and a small cap count k that balances tightness against solver effort. From our experiments, a cap count of k = 4 or 5 provided a good balance between tighter coverage and solver time.

5.2. BILP Scalability and Complexity

The computational cost of the k-circle construction is dominated by the BILP solver, which exhibits non-linear scaling relative to the discretization parameters. The dimension of the constraint matrix is determined by $M\times N$, where M is the number of polygon vertices (constraints) and N is the number of candidate grid centres (decision variables). Since N grows roughly by a constant refinement factor per level in DGGS resolution, moving from resolution 3 to 4 significantly expands the search space, causing the construction times to jump from milliseconds to seconds (as seen in Table 3)

Furthermore, solver performance is sensitive to the tightness of the covering constraint k. Counter-intuitively, smaller values of k (e.g., $k=3$) often incur higher computational costs than slightly larger values (e.g., $k=5$). In tightly constrained regimes, the feasible region is small, forcing the branch-and-cut algorithm to explore a deeper search tree to prove optimality or find a valid integer solution. Relaxing k increases the density of valid solutions, frequently allowing the solver to prune branches earlier. Thus, while the theoretical worst-case complexity of BILP is NP-hard, practical runtime is driven primarily by the resolution-dependent matrix size and the integrality gap of the specific coverage instance.

5.3. Accuracy Metrics and Discretization Bias

To quantify the tightness of our bounding volumes, we utilize the area ratio metric, defined as:

$$\lambda ={\displaystyle \frac{\mathrm{Area}\left(\mathcal{B}\right)}{\mathrm{Area}\left(\mathcal{P}\right)}}$$

where $\mathcal{B}$ is the surface area of the bounding volume and $\mathcal{P}$ is the geodesic surface area of the original polygon, both measured in steradians ($sr$). A ratio of $\lambda =1.0$ indicates a perfect fit (zero wasted space), while higher values indicate looser bounds.

It is important to note that for the DGGS-based hulls and k-circle coverages, the reported area includes a systematic discretization bias. Because the DGGS rasterization is conservative—selecting any cell that intersects the polygon boundary—the resulting cell union naturally overestimates the true polygon area by a margin proportional to the boundary length and the cell resolution. Consequently, the area ratios for these discrete methods serve as an upper bound on their tightness rather than an exact geometric measure.

5.4. Bounding Tightness

Table 4. Bounding tightness of geodesic bounding shapes for seven countries. Each entry reports the bounding shape area in steradians, with ratio to the true polygon area in parentheses.

Shape	Australia	Brazil	France	India	Spain	USA	Norway
True Polygon	0.188	0.208	0.0132	0.0776	0.0122	0.195	0.00740
Min-Circle	0.313 (1.666)	0.409 (1.966)	0.0226 (1.712)	0.206 (2.654)	0.0248 (2.033)	0.426 (2.185)	0.0613 (8.284)
AABB	0.383 (2.040)	0.434 (2.108)	0.235 (17.76)	0.225 (2.304)	0.205 (16.90)	0.384 (1.969)	0.0828 (11.20)
OBB	0.346 (1.846)	0.444 (2.133)	0.0250 (1.131)	0.195 (2.506)	0.0219 (1.061)	0.325 (1.664)	0.0217 (2.93)
4-DOP	0.276 (1.473)	0.325 (1.563)	0.0191 (1.441)	0.147 (1.891)	0.0177 (1.047)	0.302 (1.055)	0.0197 (2.67)
8-DOP	0.245 (1.305)	0.296 (1.422)	0.0183 (1.379)	0.132 (1.704)	0.0155 (1.359)	0.286 (1.469)	0.0190 (2.57)
16-DOP	0.240 (1.278)	0.290 (1.394)	0.0178 (1.340)	0.130 (1.674)	0.0155 (1.271)	0.278 (1.422)	0.0183 (2.47)
32-DOP	0.238 (1.266)	0.288 (1.381)	0.0175 (1.322)	0.129 (1.667)	0.0153 (1.262)	0.269 (1.380)	0.0175 (2.37)
64-DOP	0.236 (1.260)	0.285 (1.370)	0.0174 (1.315)	0.128 (1.651)	0.0152 (1.249)	0.266 (1.365)	0.0169 (2.28)
3-Circle (res 3)	0.383 (2.04)	0.477 (2.29)	0.0689 (5.21)	0.226 (2.91)	0.0533 (4.38)	0.388 (1.99)	0.0737 (9.96)
4-Circle (res 3)	0.378 (2.01)	0.445 (2.14)	0.0689 (5.21)	0.199 (2.56)	0.0533 (4.38)	0.367 (1.88)	0.0737 (9.96)
5-Circle (res 3)	0.359 (1.91)	0.426 (2.05)	0.0689 (5.21)	0.175 (2.25)	0.0533 (4.38)	0.354 (1.81)	0.0737 (9.96)
3-Circle (res 4)	0.313 (1.67)	0.381 (1.83)	0.0354 (2.67)	0.179 (2.31)	0.0433 (3.56)	0.336 (1.72)	0.0368 (4.98)
4-Circle (res 4)	0.301 (1.60)	0.341 (1.64)	0.0354 (2.67)	0.161 (2.07)	0.0351 (2.89)	0.314 (1.61)	0.0378 (5.11)
5-Circle (res 4)	0.287 (1.53)	0.325 (1.56)	0.0313 (2.37)	0.153 (1.97)	0.0330 (2.71)	0.305 (1.56)	0.0352 (4.75)
DGGS (res 3)	0.269 (1.435)	0.306 (1.468)	0.0418 (3.160)	0.139 (1.791)	0.0399 (3.282)	0.282 (1.446)	0.0404 (5.46)
DGGS (res 4)	0.236 (1.259)	0.261 (1.254)	0.0249 (1.884)	0.116 (1.490)	0.0216 (1.772)	0.246 (1.261)	0.0208 (2.81)

summarizes the tightness results, comparing each polygon’s area to the area of various geodesic bounding shapes.

Applying DGGS rasterization to encapsulate the polygon (union of fixed-resolution triangular cells that span the shape) provided competitive tightness for resolutions 3 and 4. At resolution 4, the hulls based on DGGS obtained area ratios in the order of 1.25–1.9, similar to mid/high-k DOPs. We anticipate that higher-resolution DGGS will produce even tighter bounding shapes. This method naturally aligns with tiling or raster-based pipelines, fitting nicely with even concave polygons.

The tightest analytic bounding shape is the geodesic k-DOP, created as the intersection of half-space pairs along k chosen orientations. Increasing k yields a monotonically tighter fit.

In most cases, geodesic OBBs achieved tighter bounds than geodesic AABBs across all our examples. This improvement was especially apparent for countries whose extents are misaligned with the defined coordinate meridians. The geodesic AABB over-covers when the region is tilted, since the box must include empty corner wedges. At higher latitudes, meridians converge, so covering a slanted footprint needs a wider longitude span, inflating area roughly with longitude width times the difference of the sines of the bounding latitudes. If the region crosses the dateline or has separated lobes, the unwrapped longitude span can be much longer than the true width. Norway serves as a primary example of a complex, elongated land area; the extreme over-coverage of its fixed-axis bounds compared to the localized fitting of k-circle coverage is visually demonstrated in Figure 10. These effects appear in Table 4: France’s, Spain’s, and Norway’s geodesic AABBs are substantially larger than their true areas, with inflation factors of approximately $17.8\times$, $16.9\times$, and $11.2\times$, respectively. In contrast, their geodesic OBBs are much tighter, at about $1.13\times$, $1.06\times$, and $2.93\times$ the true area.

Using a single minimum spherical cap creates the loosest bounds among the geodesic bounding shapes. In our results, its area was about $1.7\times$ to $2.7\times$ the polygon area. This is expected; except for nearly circular regions, a single spherical cap generally covers substantially more area than even an axis-aligned box.

At coarse DGGS resolutions (i.e., resolution 3), the k-circle cover compounds two layers of over-coverage. The DGGS hull already over-covers the polygon, and the subsequent union of circles must cover that hull. This often makes multiple low-resolution circles cover an area larger than a single minimum spherical cap. In Table 4, France and Spain at resolution 3 are clear cases: about $5.2\times$ and $4.4\times$ for 3-Circle versus roughly $1.7\times$ and $2.0\times$ for the cap. As the resolution increases, the DGGS hull tracks the boundary more closely and the circles can tuck in, so the over-coverage drops (France to about $2.7\times$ at resolution 4; India to about $2.0$–$2.3\times$). A few broad, compact shapes can rival or even outperform the cap even at low resolution (USA at resolution 3 is about $1.99\times$ versus a $2.18\times$ cap), but the general trend is that higher DGGS resolution and more circles reduce the excess area.

Approximating a complex geospatial polygon as the union of k small circles provides intermediate tightness at higher DGGS resolutions. Using more circles and higher resolution significantly improved the tightness of approximation. For example, at resolution 4 (a finer partition of the sphere), a 5-Circle cover was much tighter than at resolution 3, and increasing from 3 to 5 circles further reduced the extra area. Higher DGGS resolutions refine the underlying discretization, allowing the circles to better conform to curved boundaries and reduce over-coverage. However, even with these improvements, the multi-circle approach remained looser than high k-DOPs on our dataset, which is expected given its reliance on DGGS rasterization to abstract the original continuous problem.

5.5. Polygon–Polygon Intersection

Polygon–polygon intersection is an important operation when both objects are dynamic (i.e., two moving regions, or for broad-phase collision detection between geospatial objects).

For this query, we use a local gnomonic mapping. Given two geodesic polygons, we compute their unit centroids and locate the projection chart at the normalized mean of these centroids to equalize distortion. We then construct a local tangent-frame at this centre and gnomonically project both vertex loops into 2D. Intersection is determined in the planar domain after gnomonic projection. We perform an exhaustive edge–edge sweep that compares every segment of one polygon with every segment of the other and return immediately if a crossing is detected. If no intersection is found, we perform a containment test by ray casting from a representative vertex of one polygon against the other, then repeat in the opposite direction. To determine inclusion, we then apply the even–odd rule [48]. The per-pair projection frame can be reused across several queries; worst-case cost is $O\left(\right|E_A\left|\right|E_B\left|\right)$ for projection plus $O\left(\right|E\left|\right)$ per containment check. This approach assumes that both polygon faces lie within projection’s horizon; for very large or widely separated inputs, we tile the surface or revert to exact spherical predicates.

Here, we measure the per-pair cost of bounding-shape intersection predicate. If the bounding shapes intersect, an exact geodesic polygon–polygon intersection would then be performed (which is orders of magnitude slower than any bounding shape test).

Table 5. Polygon–polygon intersection query time (ns).

Shape	Australia	Brazil	France	India	Spain	USA	Norway
True Polygon	$2.62\times {10}^8$	$2.34\times {10}^8$	$2.77\times {10}^7$	$1.34\times {10}^8$	$1.33\times {10}^7$	$4.45\times {10}^8$	$1.76\times {10}^8$
Min-Circle	3.01	2.96	3.01	3.48	2.93	4.32	4.59
AABB	98.25	79.84	80.99	89.97	93.99	82.28	77.90
OBB	82.07	106.49	96.59	82.87	132.82	79.55	93.38
4-DOP	149.24	106.97	137.92	121.12	139.68	133.11	116.55
8-DOP	178.40	172.78	223.40	187.56	179.22	209.46	221.78
16-DOP	430.10	256.77	280.48	245.21	249.26	231.83	303.48
32-DOP	451.84	389.67	407.14	453.78	333.18	633.15	732.86
64-DOP	544.78	449.06	557.54	555.87	675.16	340.59	525.22
3-Circle (res 3)	27.89	26.62	28.35	27.90	28.81	27.39	28.59
4-Circle (res 3)	55.82	53.70	27.93	55.58	28.39	54.50	28.03
5-Circle (res 3)	92.67	87.68	27.65	93.15	28.57	92.88	27.86
3-Circle (res 4)	26.78	27.94	27.90	26.53	28.44	27.62	27.54
4-Circle (res 4)	54.83	52.94	57.13	53.33	55.83	52.57	53.92
5-Circle (res 4)	88.11	89.95	94.37	93.76	92.41	88.91	90.08
DGGS (res 3)	$9.46\times {10}^4$	$9.49\times {10}^4$	$9.73\times {10}^4$	$9.69\times {10}^4$	$9.88\times {10}^4$	$9.68\times {10}^4$	$9.79\times {10}^4$
DGGS (res 4)	$4.02\times {10}^5$	$3.94\times {10}^5$	$3.93\times {10}^5$	$4.01\times {10}^5$	$3.99\times {10}^5$	$3.87\times {10}^5$	$4.12\times {10}^5$

reports the average time per intersection test (in nanoseconds), the achievable query throughput (operations per second), and total runtime.

A single minimum spherical cap can be queried for intersection with another cap using just one great-circle distance computation and a radius comparison. This makes it extremely fast on the order of only a few nanoseconds per test.

In our implementation, OBB intersection tests were slightly faster than AABB tests. Both reduce to a small number of half-space checks; however, the OBB’s principal-axis alignment led to fewer near-degenerate interval cases and more stable branch behaviour. In our experiments, the geodesic OBB consistently offered better culling efficiency and higher throughput than the geodesic AABB.

For a geodesic k-DOP, we create a stronger representation of the polygon when increasing the number of directions, at the cost of more computations per test. As expected, increasing k increases the number of edges on the polytope. In our results, per-test cost scaled roughly linearly with k: 4-DOP tests were on the order of tens of nanoseconds, 8-DOP around $2\times$ that, up to 64-DOP at a few hundred nanoseconds. Regardless of the extremely fast query times, the trend is clear: increasing the number of directions yields tighter bounding shapes and fewer false positives (see Table 4).

The performance of collision detection depends not only on the speed of the test but also on how often it avoids the costly exact polygon–polygon intersection. In cases where exact intersection is extremely expensive (complex polygons), or where many pairs are tested with only a few actual collisions, a tighter-fitting geodesic shape can drastically improve throughput by culling non-colliding pairs early. In our study, methods like the geodesic OBB and moderate geodesic k-DOPs (8 or 16 directions) offered an excellent balance.

In our baseline implementation, DGGS intersection reduces to set intersection over rasterized cell IDs at a fixed resolution and checks whether the two sets share any elements. In practice, this involves rasterizing both polygons to cell IDs at the chosen resolution, putting the resulting lists into a canonical order (or constructing ordered/hash sets), and then performing a set-intersection scan to detect any common cells. This baseline is enough for our purposes; however, hierarchical methods and certain indexing techniques can further reduce scans and improve performance. The dominant cost is touching and comparing many cell identifiers: cell counts grow quickly with resolution and boundary length, the access pattern is memory-bound with poor locality, and in the common non-overlap case, the algorithm must still examine nearly all elements of both sets before termination. In contrast, the other bounding shape tests project both inputs into a single local chart and operate on a handful of edges or caps with tight arithmetic kernels and frequent early exits. The result is 3–4 orders of magnitude faster than exact polygon–polygon intersection on our datasets, while DGGS pays for exactness via large-set construction and membership testing.

Even the slowest bounding-shape test (e.g., a 64-DOP) took on the order of ${10}^{-7}$ s per pair in our measurements; still significantly faster than performing a precise geodesic intersection of two complex polygons. Thus, any of these bounding shapes significantly reduces computation by efficiently filtering out most non-intersecting cases. By combining a fast bounding shape stage with an optimized exact intersection step, our pipeline achieves real-time collision queries even for very complex spherical polygons.

5.6. Point-in-Polygon Query Time

For geodesic BVs, our point-in-polygon test reduces containment to a planar query through a local gnomonic mapping. We first choose a stable projection frame centred at the polygon’s centroid $\mathbf{c}$ and construct an orthonormal tangent basis $(\mathbf{e},\mathbf{n})$ by crossing $\mathbf{c}$ with a non-degenerate reference axis. Because gnomonic projection maps great-circle arcs to straight line segments, projecting the polytope’s vertex loop and the query point into this plane yields a standard 2D polygon. We then apply an even–odd ray-casting count across the k projected edges; an odd number signifies containment, while an even number signifies exclusion [48]. Once we precompute the local frame for each polytope, we obtain an $O\left(k\right)$ PiP test that preserves concavity and geodesic boundary structures, as long as the polytope lies within a horizon of projection (for very large scales we tile or default back to exact spherical predicates).

When querying dynamic objects, such as streaming GPS points, cursor/raycast hits, or simulation particles against a static polygon, a PiP test is performed.

Table 6. Point-in-polygon (PiP) query time (ns).

Shape	Australia	Brazil	France	India	Spain	USA	Norway
True Polygon	36,041.29	33,517.75	10,218.15	22,785.04	6981.03	48,907.45	30,366.07
Spherical Cap	1.08	1.05	1.06	1.04	1.06	1.02	1.06
AABB	67.24	65.60	65.78	65.90	66.74	64.06	65.91
OBB	48.19	46.08	45.18	45.40	47.47	46.71	47.61
4-DOP	59.62	58.00	56.90	57.81	57.67	56.93	58.77
8-DOP	87.99	85.06	83.32	85.96	86.71	81.26	87.50
16-DOP	139.13	119.78	123.46	131.45	117.07	106.83	133.55
32-DOP	202.08	167.32	177.11	177.00	141.47	147.26	183.90
64-DOP	259.41	193.78	241.30	222.55	163.06	184.85	226.35
3-Circle (res 3)	20.31	19.42	20.06	19.80	20.21	19.64	20.27
4-Circle (res 3)	27.32	25.54	19.91	26.22	20.12	25.46	20.37
5-Circle (res 3)	33.80	31.56	20.21	33.45	20.12	32.05	19.81
3-Circle (res 4)	20.22	19.44	20.12	19.83	19.90	19.61	20.00
4-Circle (res 4)	27.18	26.03	27.11	26.55	26.67	25.99	26.56
5-Circle (res 4)	34.85	31.98	34.27	37.28	37.47	32.75	33.44
DGGS (res 3)	38.99	38.10	42.18	38.19	39.09	40.64	46.89
DGGS (res 4)	39.10	38.15	42.59	38.22	38.24	42.13	48.09

showcases the per-point query time (in nanoseconds) for different bounding shapes constructed. The first row shows the cost of an exact spherical PiP test, which is orders of magnitude larger (tens of thousands of nanoseconds per point) than any bounding test. This contrast underscores the value of the two-stage query strategy that is at the heart of a bounding shape’s purpose.

Among bounding shapes, spherical caps provide the fastest conservative test, requiring essentially a single dot product and comparison per point on the order of a few nanoseconds per query. This minimal overhead makes spherical caps ideal for very high-throughput data streams where most points lie outside the region of interest. Geodesic AABBs and OBBs also offer very low per-point costs on the order of a few tens of nanoseconds. However, geodesic OBBs usually align better with the object’s orientation, rejecting more non-member points than AABBs, reducing the number of points that fall through to the expensive exact PiP stage. As shown in Table 4, geodesic OBBs provide stronger culling than geodesic AABBs and improve throughput despite their slightly higher per-check cost.

For k-discrete oriented polytopes (k-DOPs), the table shows that the cost per point increases as k grows (e.g., 4-DOP tests are faster than 8-DOP, which are faster than 16-DOP, and so on). Each additional half-space in a k-DOP adds an extra plane comparison, so higher-k polytopes perform more computations per test. For approximating the polygon intersection problem, larger values of k yield a tighter bounding shape that more closely approximates the true polygon shape. This introduces a trade-off that increasing k results in a higher computational cost per point, but it has the potential to significantly reduce the frequency of full polygon checks. The optimal choice of k depends on the acceptable balance between per-test overhead and the cost of the exact PiP, and the distribution of query points.

For multi-circle bounds, the cost of containment is very efficient—19–37 nanoseconds—and shows a different performance profile which appears relatively insensitive to the particular dataset or polygon complexity. Regardless of the shape (among those tested), 3 to 5 spherical circles at resolution 3 or 4 provided a quick containment test with only minor variations in timing. Multi-circle tests run in just tens of nanoseconds and offer fairly consistent results across different types of shapes.

5.7. Sensitivity to DGGS Discretization

As shown in Table 5 and Table 6, query times for smaller geometries (e.g., France, Spain) exhibit irregular behaviour at coarse DGGS resolution (resolution 3), occasionally decreasing as k increases. This non-monotonic scaling arises from discretization effects. At resolution 3, the DGGS cell diameter is large relative to the polygon size, yielding a sparse set of candidate centres. Small changes in k can therefore lead to significant reconfigurations of the selected caps rather than incremental refinements.

At higher resolution (resolution 4), the grid density better approximates the continuous boundary. The resulting cap configurations are more stable, and query time scales predictably with k, dominated by the linear number of dot-product checks.

5.8. Integration into Hierarchical Spatial Indexes

The geodesic bounds presented here are designed to function as replacements for planar primitives in standard spatial access methods. In tree-based structures such as sphere-adapted R-trees, replacing MBRs with k-circle coverage, geodesic OBBs or k-DOPs reduce the volume of the search nodes, significantly pruning the traversal tree and minimizing false positive overlaps during descent.

For DGGS frameworks such as Google S2 or Uber H3, our bounds can serve as an additional culling layer. While these systems index geometry using covering cells, exact point-in-polygon tests at the leaf level remain costly for complex boundaries. By storing a compact k-circle coverage or spherical cap alongside each leaf cell ID, the framework can perform a small, fixed number of dot products that are independent of polygon complexity, before accessing the complete high-resolution geometry. This utilizes grid-based spatial hashing with analytic bounding tests for efficient query-stage filtering.

5.9. Memory Usage

Memory usage (double precision on a 64-bit system) favours spherical caps as the most compact representation (32 bytes each). Geodesic AABBs require 48 bytes, while geodesic OBBs use 88 bytes in our layout (often rounded to 96 bytes in practice due to 16-byte struct padding). Geodesic k–DOPs scale linearly with k. In our self-contained layout, they occupy $44k$ bytes; when directions are fixed globally (shared lookup table), the per-instance storage drops to only the $2k$ scalar bounds only (the k minima and k maxima), i.e., $16k$ bytes. With shared k-DOP directions, per-instance memory is $16k$ bytes for the k min and k max scalars. A full summary of memory requirements across all bounding shapes is provided in

Table 7. Memory requirements of geodesic bounding shapes (double precision, 64-bit system).

Bounding Shape	Bytes	Stored Parameters
Spherical Cap	32	Axis $u\in {\mathbb{R}}^3$ (24 B) + threshold t (8 B)
Geodesic AABB	48	Two corner unit vectors (2 × 3 doubles)
Geodesic OBB	88	Centre (24 B) + 2 principal axes (48 B) + half extents (16 B)
Geodesic k-DOP	$44k$	$k/2$ centres (12k B) + k directions (24k B) + k half extents (8k B)
k-Circle Coverage	$32k$	k spherical caps, each 32 B (axis + threshold)

.

6. Conclusions and Future Work

In this paper, we introduced geodesic analogues of popular Euclidean bounding shapes and demonstrated their advantages for global spatial filtering. We constructed minimum spherical caps, geodesic AABBs, OBBs, and k–DOPs. Considering the robustness of spherical cap queries, we further introduced an optimization-driven k-circle coverage technique that approximates complex polygons using a small set of variable-radius caps. Experiments with real-world national boundary datasets showed that all proposed geodesic bounding shapes are quick to construct, compact to store, and capable of accelerating spatial queries by orders of magnitude on the unit sphere.

These results also reveal clear trade-offs: spherical caps provide the simplest and fastest containment tests but the loosest fits; geodesic OBBs offer a strong balance between tightness and efficiency; and k–DOPs yield the tightest analytical bounds. The k-circle coverage further increases selectivity by fitting each polygon with a small set of caps, achieving near-polygon tightness at query speeds comparable to a single-cap test.

Despite these encouraging results, our work has several limitations. We focused on an idealized unit sphere and did not consider ellipsoidal Earth models (such as WGS84), dynamic geometry updates, or highly intricate polygonal shapes. Moreover, all k-circle coverage solutions covered slightly more area than necessary because of the DGGS rasterization on which they are based.

Future work will involve refining the k-circle optimization and broadening the approach in a number of directions. We will build adaptive multi-resolution coverage strategies that adapt the number of caps to local polygon complexity and consider other global grid discretizations (like equal-area DGGS schemes) for candidate cap generation. We would also like to generalize our approach to more realistic Earth models (by employing an ellipsoidal model like WGS84) and more complex polygon types (with holes). Ultimately, improving computational efficiency through parallel or GPU execution and deriving theoretical guarantees on approximation quality and false-positive rates are valuable areas for future work.