Introduction

Convex hull computation is a fundamental operation in computational geometry, with applications in robotics, computer graphics, data visualisation, archaeology, linear programming and biology [1]. In practice, convex hull computation often appears as one stage in a larger pipeline, and the input frequently contains many interior points that never contribute to the hull. Therefore, it is common to apply geometric filtering prior to exact hull construction in order to reduce input size and improve overall performance.

In applications with dynamic and real-time data, such as collision detection, live object tracking, and sensor data processing, points may arrive continuously as a high-speed stream. For these systems, efficient online filtering methods that operate in a single pass and guarantee convex hull equivalence are particularly valuable. When reductions are substantial, filtering can yield end-to-end performance improvements of several times compared to direct hull construction. Thus, streaming algorithms are an important component of modern geometric processing systems [2].

A practical convex hull filter must satisfy three core requirements. First, it must preserve correctness by retaining all true hull vertices; discarding even a single extreme point invalidates the result. Second, it must achieve useful and quantifiable reduction in the candidate set size, otherwise the overhead of filtering outweighs its benefit. Third, it must operate efficiently under streaming constraints, ideally in linear time with manageable memory overhead. These requirements are reflected throughout the literature on convex hull preprocessing and streaming computation [2–4], yet many existing methods satisfy only a subset of them.

Classical geometric filtering techniques, such as the Akl–Toussaint heuristic [5], are typically presented as offline preprocessing steps applied to a complete point set. These methods rely on fixed directional extrema and static inner polygons, and are not naturally suited to unordered streaming input. Several authors have proposed alternative geometric pruning strategies to accelerate convex hull computation [3,6,7], but these approaches generally assume offline access to the data or rely on global geometric structure.

Streaming convex hull construction has also been studied in more formal streaming and external-memory models [2,8]. These methods aim to maintain or approximate the hull itself under strict memory and pass constraints. In contrast, the present work focuses on conservative input reduction: exact hull construction is deliberately deferred, and the streaming algorithm is required only to retain all points that may contribute to the hull.

In this paper, we derive a streaming, certificate-based reduction for convex hull preservation. The method is motivated by geometric invariants used in incremental convex hull maintenance, but does not attempt to maintain a correct hull online. Instead, we identify which aspects of incremental hull logic can be safely relaxed while preserving correctness. The resulting algorithm discards only points that are certified interior to the hull, retains all potential hull vertices, and operates in a single streaming pass with only local geometric operations.

Concretely, we first present a correctness-preserving reformulation of incremental convex hull maintenance for unordered streaming input, expressed in terms of upper and lower x-monotone chains [9]. This formulation is used solely as a conceptual scaffold and is not claimed as a novel convex hull algorithm. We then introduce a principled relaxation of this exact pipeline into a conservative geometric filter. The relaxation weakens online enforcement of convexity and ordering discipline while preserving geometric predicates, safety rules, and streaming constraints. Temporary geometric inconsistency is permitted, but a strict containment invariant is maintained, ensuring that the exact convex hull is preserved after final refinement.

The main contribution of this work is therefore a correctness-preserving streaming geometric filter derived as a relaxation of incremental convex hull maintenance. The filter does not rely on fixed directions, static inner polygons, global sorting, or multi-pass processing. Experimental evaluation on synthetic datasets demonstrates that the method achieves substantial reduction in practice, typically retaining between 5% and 11% of the input points under random arrival order. As expected for any one-pass streaming filter, adversarial arrival orders can suppress rejection and result in no reduction; however, correctness is preserved in all cases.

1. Preliminaries: Convex hulls and streaming setting

1.1 Problem formulation

Let be a finite sequence of planar points presented as a stream in arbitrary order. For each , let

denote the processed prefix, with . Let CH(X) denote the convex hull of a finite point set .

The objective of the proposed reduction is to construct, in a single streaming pass, a retained subset such that

while ideally in typical cases.

The reduction must satisfy the following constraints:

1. Streaming constraint: Each point is processed exactly once in arrival order.
2. Single-pass operation: No global reordering or multi-pass processing is allowed.
3. Correctness guarantee: No point may be discarded unless it is certified to lie in the convex hull of previously retained points.

The reduction therefore acts as a conservative geometric filter whose sole correctness requirement is hull preservation. Exact hull computation is applied only once, after streaming, to the final retained set R.

Throughout this work, we consider a streaming input model in which points of P arrive sequentially in an arbitrary, unordered fashion. The algorithm processes each point in a single pass and maintains only limited auxiliary state. No assumptions are made about the distribution, ordering, or geometric regularity of the input points.

Given an input set P and a retained subset , we say that R preserves the convex hull of P if

In this context, a reduction is considered safe if it discards only points that are guaranteed not to be vertices of the convex hull.

The objective of the proposed method is not to construct or maintain the convex hull explicitly during streaming, but rather to identify and discard points that can be certified as interior with respect to CH(P), while retaining all points that may potentially contribute to the hull. As a consequence, the retained set R may contain interior points, but must contain all hull vertices of P.

No claims regarding optimality, efficiency of hull construction, or asymptotic speedup of convex hull algorithms are made at this stage. The focus of this section is solely to establish notation, assumptions, and the correctness criterion used throughout the paper. We now briefly review geometric invariants commonly used in incremental convex hull maintenance, which provide the conceptual foundation for the reduction proposed in this work. These invariants are discussed solely to motivate the design of safe certificates and do not imply that an exact convex hull is maintained during streaming.

The underlying ideal objective is to minimise the retained set subject to exact hull preservation and one-pass streaming constraints; the proposed method is a safe conservative approximation to that constrained reduction problem.

2. From hull invariants to safe reduction

The online hull construction described in the previous section provides a natural foundation for filtering, but its strict enforcement of convexity is unnecessarily strong for our purpose. We do not need to maintain an exact hull during processing; we only need to guarantee that true hull vertices are never discarded. This observation leads to a deliberate relaxation of the algorithm.

3. Hull preservation guarantee

For each , let denote the retained set after processing the first k points, with . We write x(q) and y(q) for the coordinates of a point .

Envelope segments and sandwich certificates.

After processing the prefix P_k−1, the algorithm maintains an upper envelope U_k−1 and a lower envelope L_k−1. Both are x-monotone polygonal chains whose vertices belong to R_k−1.

Let the incoming point be p_k = (x_k, y_k). An upper supporting segment for p_k is a segment joining two consecutive vertices a,b of U_k−1 such that

Similarly, a lower supporting segment for p_k is a segment joining two consecutive vertices c,d of such that

Whenever such segments exist, let and denote the unique points on those segments with

We say that p_k satisfies the sandwich certificate if

Equivalently, p_k lies strictly below the upper supporting segment and strictly above the lower supporting segment at the common abscissa x_k.

The algorithm discards p_k only when both an upper supporting segment and a lower supporting segment exist and the sandwich certificate holds. Otherwise, p_k is retained. If x_k coincides with an envelope vertex shared by two adjacent segments, either incident segment may be used; the correctness argument is unchanged.

Lemma 1 (Certificate implies convex-hull membership). If p_k is discarded at step k, then

More precisely, if and are the supporting segments used in the sandwich certificate for p_k, then

Proof. Since p_k is discarded, by definition there exist an upper supporting segment of U_k−1 and a lower supporting segment of whose horizontal projections contain x_k. Let and be the points with . The sandwich certificate gives

Because u and ℓ have the same x-coordinate as p_k, the point p_k lies on the vertical segment joining ℓ and u. Hence there exists such that

Since , there exists such that

Similarly, since , there exists such that

Substituting these expressions into the previous equation yields

which is a convex combination of a,b,c,d. Therefore

because .□

Lemma 2 (Prefix hull invariant). For every ,

Proof. We argue by induction on k.

For k = 0, both P₀ and R₀ are empty, so the claim is trivial.

Assume that

holds for some k ≥ 1. We show that it also holds for k.

Case 1: p_k is retained. Then

Hence, using the induction hypothesis,

Case 2: p_k is discarded. Then

By Lemma 1,

Using the induction hypothesis,

because adjoining a point already contained in the convex hull does not change that hull.

Thus the claim holds in both cases, completing the induction. □

Theorem 3 (Hull Preservation). Let P be a finite planar point set processed by the proposed streaming reduction, and let R denote the final retained set. Then

Proof. Apply Lemma 2 with k=n. □

4. Streaming reduction algorithm

Algorithm 1 summarises the proposed streaming reduction. The algorithm processes points in a single pass, maintaining relaxed upper and lower envelopes. Points are discarded only when a local sandwich certificate proves they lie strictly between the envelopes. All other points are retained in a candidate set for final refinement.

Algorithm 1 Relaxed Streaming Convex Hull Filter

Require: Stream of points

Ensure: Candidate set R preserving CH(P)

1:             ▷ (Upper envelope (x-monotone))

2:             ▷ (Lower envelope (x-monotone))

3:             ▷ (Retained candidate points)

4: for each incoming point p do            ▷ (— Rejection test —)

5:   if p has supporting segments in both envelopes and satisfies the sandwich certificate then

6:     continue            ▷ (Discard p (certified interior))

7:   end if

8:               ▷ (Retain point) ▷ (— Selective insertion into envelopes —)

9:   if p expands the upper envelope U then

10:     Insert p into U by x-coordinate

11:     Perform at most one local convexity repair

12:   end if

13:   if p expands the lower envelope L then

14:     Insert p into L by x-coordinate

15:     Perform at most one local convexity repair

16:   end if

17: end for

18: return R

5. Application context

Large-scale geometric processing pipelines frequently operate under streaming or memory-constrained conditions. Examples include LiDAR acquisition, real-time mapping, edge-device spatial sensing, and incremental surface reconstruction from point clouds [12]. Convex hull computation also plays a role in quantitative morphology and biological shape analysis. For example, convex hull volume has been used to study scaling relationships between body mass and skeletal geometry in primates and other vertebrates [1]. Such applications highlight the importance of efficient hull computation in scientific workflows involving large datasets.

In such settings, full convex hull construction may serve as a preprocessing step for downstream tasks, including:

• surface triangulation,
• outlier rejection,
• boundary detection,
• spatial partitioning and meshing,
• geometric summarisation.

Reducing the candidate set prior to hull construction can decrease memory usage and improve computational efficiency, particularly when data arrive incrementally or cannot be stored in full.

Unlike classical batch filters, the proposed method operates in streaming mode and therefore aligns naturally with pipelines where points are processed as they are acquired. Its conservative design ensures that downstream hull-dependent computations remain exact.

6. Experimental evaluation

This section presents an empirical evaluation of the relaxed streaming convex hull filter. The experiments serve two complementary purposes. First, we characterise the behavioural properties of the filter under controlled geometric and arrival-order variations. Second, we evaluate its large-scale reduction efficiency and runtime performance relative to classical pre-filtering heuristics.

The objective is to characterise practical performance under realistic streaming conditions rather than to optimise asymptotic bounds.

6.1 Reduction under random arrival

Fig 1 shows the mean reduction ratio under random arrival order for seven representative point distributions.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 1. Mean reduction ratio (r/n) achieved by the relaxed streaming convex hull filter under random arrival order, averaged over 20 independent runs.

Results are shown for seven geometric point distributions. Strong reduction is observed for most distributions, while no reduction occurs for the superellipse distribution due to its geometric ambiguity near the hull.

https://doi.org/10.1371/journal.pone.0349577.g001

For most distributions, the filter achieves substantial reduction, retaining between 5% and 11% of the input points on average. Strong reduction is observed for uniform, Gaussian, banana-shaped, and clustered distributions. The annulus distribution exhibits moderate reduction, reflecting the higher proportion of points near the true hull boundary.

In contrast, the superellipse distribution exhibits no reduction. This behaviour is geometrically expected: sharp corners and extended flat regions generate many points that are locally consistent with being hull vertices. The conservative design of the streaming filter therefore retains these points rather than discarding them without sufficient local certification.

These results demonstrate that the method is effective under typical geometric conditions while remaining structurally conservative in ambiguous near-hull regimes.

6.2 Order sensitivity

Fig 2 illustrates the sensitivity of the relaxed streaming filter to arrival order for uniform and Gaussian distributions.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 2. Sensitivity of the relaxed streaming convex hull filter to arrival order.

Mean reduction ratio (r/n) is shown for uniform and Gaussian point distributions under five arrival orders. Substantial reduction is achieved under random arrival, partial reduction under zigzag order, and no reduction under monotone arrival orders. In all cases, exact hull preservation is maintained.

https://doi.org/10.1371/journal.pone.0349577.g002

Under random arrival, strong reduction is consistently achieved. Under zigzag order, partial reduction remains possible, indicating robustness to moderately adversarial streaming patterns. However, for monotone arrival orders (sorted or reverse-sorted by x, and sorted by y), the filter performs no rejection and retains all points.

This behaviour reflects a structural limitation of single-pass streaming filters: when early points dominate envelope expansion, later points cannot be certified as interior using only local sandwich information. Importantly, correctness is preserved in all cases. The absence of rejection under monotone order therefore represents a conservative failure mode rather than an incorrect one.

These experiments clarify the operational envelope of the method and make explicit the trade-off between streaming constraints and rejection capability.

6.3 Large-scale comparison with the Akl–Toussaint heuristic

The preceding experiments characterise the structural behaviour of the relaxed streaming filter under controlled geometric and arrival-order variations. We now turn to a complementary question: how does the proposed method compare, in large-scale settings, to classical hull pre-filtering heuristics?

Among existing techniques, the Akl–Toussaint heuristic is a well-known and widely used pre-processing step for convex hull computation. It removes interior points by discarding those lying inside an extremal polygon constructed from a small set of boundary directions. Unlike the proposed method, however, it is not designed for one-pass streaming operation and assumes full access to the input set.

We evaluate both methods under identical large-scale conditions. The comparison focuses on reduction ratio and total runtime relative to full hull computation, while recognising that the relaxed filter is explicitly designed for streaming environments rather than batch preprocessing.

This comparison quantifies the practical trade-offs between streaming capability and classical batch-based reduction strategies.

6.3.1 Experimental setup.

All experiments were run in Python on an Apple laptop equipped with an M4 processor using double-precision arithmetic. Runtime measurements were obtained using time.perf_counter(), averaged over 20 independent trials. Each configuration includes a warm-up phase prior to timing to reduce interpreter and caching effects. For the NYC Taxi experiments, results are reported as mean ± standard deviation over 3 repetitions.

Convex hull computation uses a standard monotone chain implementation applied:

1. Directly to the full input set (baseline),
2. After filtering with the relaxed streaming method,
3. After filtering with the Akl–Toussaint heuristic.

We report total runtime (filter + hull) and compute speedup relative to full hull construction.

6.3.2 Baseline: Akl–Toussaint heuristic.

As a classical convex hull pre-filter, we implement the Akl–Toussaint heuristic, which constructs a convex polygon from extremal x and y coordinates and discards points strictly inside this polygon. This method is widely cited in computational geometry as a linear-time hull reduction heuristic.

All implementations preserve exact hull correctness. No hull mismatches were observed in any experiment.

6.3.3 Point distributions.

We consider four representative geometric distributions:

1. Uniform distribution in the unit square,
2. Isotropic Gaussian distribution,
3. Uniform distribution in the unit disk,
4. Superellipse distribution with sharp corners.

These distributions span easy, typical, and near-adversarial geometric regimes.

Experiments were conducted for

6.3.4 Reduction efficiency.

Fig 3 illustrates the runtime speedup relative to full hull construction for the Gaussian distribution.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 3. Speedup achieved due to the reduction of points by relaxed streaming convex hull filter and Akl–Toussaint heuristic, averaged over 20 independent runs.

Results are shown for a Gaussian distribution over a sweep of n from 10K to 1M points.

https://doi.org/10.1371/journal.pone.0349577.g003

For random distributions (Gaussian, disk, square), the relaxed filter retains a rapidly decreasing fraction of points as n increases, typically below 0.1% at n = 10⁶. In contrast, the Akl–Toussaint heuristic retains a constant fraction for uniform square inputs and a small but non-negligible fraction for Gaussian inputs.

For the superellipse distribution, nearly all points lie close to the true hull boundary. Both filters retain most points in this case, demonstrating conservative behaviour under hull-dominated inputs.

6.3.5 Runtime performance.

Table 1 summarises results at n = 10⁶.

Download:

• PNG
  larger image
• TIFF
  original image

Table 1. Mean retained ratio and speedup at n = 10⁶ (20 trials).

https://doi.org/10.1371/journal.pone.0349577.t001

For Gaussian inputs, the relaxed filter achieves nearly 2× speedup over full hull construction at n = 10⁶, with low variance across trials. The Akl–Toussaint heuristic provides moderate improvement for Gaussian data but little to no improvement for uniform square distributions.

In the superellipse case, where most points lie near the hull, both methods exhibit reduced speedup, reflecting the limited opportunity for safe interior certification. Importantly, correctness is preserved in all cases.

6.3.6 Reduction behaviour.

Under random and chronological arrival, the streaming filter consistently reduced the candidate set size, retaining a small fraction of interior points while preserving all hull vertices. Reduction ratios remained stable as n increased, indicating scalability under clustered real-world spatial distributions. As expected, under longitude-sorted arrival order, little or no reduction occurred, confirming sensitivity to adversarial monotone streams.

6.3.7 Observations.

Across all experiments, the following consistent patterns are observed:

• Exact hull preservation is maintained in all trials.
• The relaxed filter achieves strong reduction for random distributions, with retained fraction decreasing as n increases.
• The Akl–Toussaint heuristic retains a constant fraction for uniform distributions.
• Runtime speedup scales with reduction efficiency.
• Performance degrades gracefully under hull-dominated inputs.

These results indicate that the proposed method functions as an effective conservative streaming filter that provides substantial practical acceleration under typical geometric conditions while maintaining transparency regarding its limitations.

6.4 Evaluation on real-world GPS data

To evaluate performance under realistic spatial distributions, we conducted experiments using publicly available New York City Taxi & Limousine Commission (TLC) trip data (March–May 2025) [13]. From each record, the pickup longitude and latitude were extracted to form two-dimensional point sets. Records with missing or invalid coordinates were discarded. The resulting datasets contain millions of spatial samples exhibiting strong clustering, directional structure, and sparse geographic outliers.

For scalability analysis, we considered subsamples of size

Each subsample was evaluated under three arrival orders:

• Chronological order (natural streaming order),
• Random shuffle,
• Longitude-sorted order (adversarial monotone order).

For each configuration, we measured:

• Reduction ratio r/n after streaming filtering,
• Total runtime of full hull computation,
• Runtime of Akl–Toussaint filtering followed by hull construction,
• Runtime of the proposed streaming filter followed by hull construction.

Exact hull preservation was verified by comparing the vertex sets of the hull computed on the full dataset and on the filtered candidate set. No discrepancies were observed in any experiment.

Table 2 summarises performance on the NYC Taxi dataset under random arrival order. The relaxed streaming filter achieves substantial reduction, with the retention ratio decreasing from 1.19 × 10⁻³ at n = 50,000 to 1.25 × 10⁻⁴ at n = 500,000. In contrast, the Akl–Toussaint heuristic retains approximately 5% of input points across all tested sizes. This difference translates into measurable runtime gains: at n = 500,000, the relaxed filter achieves a 1.63× speedup relative to computing the full hull directly, compared to 1.31× for Akl–Toussaint. The standard deviations are small for the relaxed filter across all tested sizes, indicating stable reduction and runtime behaviour under repeated random shuffling. Notably, the reduction strength of the relaxed filter improves with increasing n, whereas Akl–Toussaint exhibits near-constant retention.

Download:

• PNG
  larger image
• TIFF
  original image

Table 2. Performance comparison on the NYC Taxi dataset under random arrival order. Values are reported as mean ± standard deviation over 3 repetitions. Retention ratio denotes r/n. Speedup is measured relative to computing the full hull directly.

https://doi.org/10.1371/journal.pone.0349577.t002

Absolute wall-clock timings for the NYC Taxi experiments are provided in Supporting Information (S1 Table).

Reproducibility

All code required to reproduce the experiments and figures in this paper is publicly available at https://github.com/oswcad/streaming-hull-filter. Permanent archived snapshots of the software and dataset are available at Zenodo: Software, DOI https://doi.org/10.5281/zenodo.19496559; Dataset, DOI https://doi.org/10.5281/zenodo.19497433. The repository includes scripts for synthetic data generation, experimental evaluation, figure production, and retrieval and preprocessing of the public NYC TLC datasets used in the real-world experiments.

Discussion

The experimental results confirm that the proposed filter occupies a distinct position among convex hull preprocessing techniques. Unlike classical batch algorithms and extremal-based heuristics such as Akl–Toussaint, the method operates strictly in streaming mode while preserving exact hull correctness.

Across both synthetic distributions and the large-scale NYC taxi dataset, the filter consistently reduces the candidate set substantially under random and chronological arrival. On real-world taxi data comprising up to 5 × 10⁵ points, the retained fraction drops below 0.02% under random order, compared to approximately 5% for Akl–Toussaint. This reduction translates directly into measurable runtime gains, with observed end-to-end speedups of approximately 1.6× relative to full hull construction, and consistent improvement over the Akl heuristic in typical (non-adversarial) orderings.

The sensitivity analysis clarifies the structural limits of conservative streaming filters. Monotone orderings reduce rejection capability because early envelope growth restricts interior certification; however, correctness is never compromised. Importantly, the taxi dataset experiments demonstrate that natural arrival patterns (chronological trip order) behave similarly to random order rather than adversarial constructions, indicating that the worst-case behaviour is unlikely in practical data streams.

From a theoretical standpoint, the local sandwich certificate distinguishes the method from extremal-based filtering: interior rejection is certified incrementally without global extrema or multiple passes. To the best of our knowledge, no prior convex hull filter combines (i) strict one-pass streaming operation, (ii) formal proof of exact hull preservation, and (iii) empirical characterisation across both synthetic and real large-scale datasets including order sensitivity.

These results suggest that the filter is particularly suited to streaming geometric pipelines, memory-constrained processing, and incremental spatial analytics where batch preprocessing is infeasible. Future work may investigate adaptive certificates that mitigate order sensitivity while maintaining conservative guarantees, as well as extension to higher-dimensional streaming hull construction.

7. Related work

Convex hull computation is a classical problem in computational geometry, with well-known optimal algorithms achieving time in the algebraic decision tree model [10]. Graham scan, divide-and-conquer methods, and incremental algorithms form the traditional algorithmic foundation [14].

Conclusion

We have presented a conservative one-pass streaming convex hull filter that reduces the candidate set prior to exact hull construction while guaranteeing exact hull preservation. Unlike classical batch algorithms and pre-filtering heuristics that require global access to the dataset, the proposed method operates strictly in streaming mode: each point is processed once in arrival order, and no reconstruction of the full point set is required during filtering.

The method is based on a local sandwich certificate that permits interior-point rejection using only incremental convex envelope information. We provided a formal proof that no true hull vertex is discarded, ensuring that CH(R) = CH(P) for all inputs.

Within the broader convex hull literature, classical and output-sensitive algorithms achieve optimal asymptotic bounds in batch settings, and the Akl–Toussaint heuristic performs effective global pre-filtering. In contrast, this work addresses conservative filtering under strict streaming constraints. To the best of our knowledge, no previously published method combines one-pass operation, exact hull preservation, formal correctness guarantees, and empirical characterisation of arrival-order sensitivity in this setting.

Empirically, substantial reduction is observed under typical random arrival across synthetic and real-world datasets, including large-scale NYC taxi data, leading to measurable runtime improvements relative to both full hull construction and the Akl–Toussaint heuristic at increasing scale. As expected, adversarial monotone arrival suppresses rejection, reflecting intrinsic limitations of local streaming certificates rather than algorithmic failure. In all cases, exact hull correctness is maintained.

These results position the proposed filter as a practical preprocessing component for streaming and memory-constrained geometric pipelines, including point cloud processing and incremental spatial analytics. Future work may explore adaptive certificates that increase robustness to adversarial orderings while preserving conservative guarantees, as well as extensions to higher dimensions.

Supporting information

Acknowledgments

The author used ChatGPT (OpenAI) as an assistive tool for language refinement, stylistic refinement, and clarification of presentation. The AI tool was not used to generate scientific results, proofs, algorithms, experimental data, or interpretations. All technical content, experimental design, and conclusions were developed and verified by the author, who reviewed and validated all AI-assisted text for accuracy and consistency.