REVIEW 4 major objections 4 minor
Event Driven Clustering Algorithm
T0 review · 4 major / 4 minor · reviewed 2026-08-03 · deepseek-v4-flash
Pith's one-line read The paper claims event clusters in event camera data can be detected one event at a time, in O(n) time, independent of sensor resolution.
desk verdict A clearly described event-clustering algorithm with a plausible idea, but the central O(n) resolution-independence claim is unproven and the empirical support is a single qualitative demo. read the letter →
The pith
A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.
The reading
What carries the argument
The mechanism is a set of dynamic arrays indexed by pixel coordinates: TimeSurface stores the timestamp of the last event at each pixel; PointerX/PointerY store the coordinates of the root of the cluster to which each pixel currently belongs; and grade/pixels/ClusterBegin/ClusterEnd/ClusterId/Compatibility track the size, extent, and identity of each cluster at its root. The decision rule for each event is to look only at the (2d+1)^2 pixels in its spatial neighborhood, select the one with the most recent event that is still within δ, and either attach the event to that pixel's cluster or, if that pixel currently points to no cluster, create a new cluster rooted at that pixel. This local rul
What would settle it
Synthesize an event stream in which a new event has two d-neighbor components, both with events within δ but at different temporal distances; the algorithm will attach to the closer one. Implement the graph definition with all possible tie-break choices and list all qualifying roots. If any tie-breaking yields a root that the algorithm does not, the equivalence claim is refuted. Separately, to test the pixel-independence claim, run the algorithm on a fixed event stream while increasing the pixel array size and measure end-to-end wall time, including any array initialization; if initialization
Extended reading notes
Core claim
The central claim is that a local, one-pass decision rule can reproduce the clusters defined by a global graph-theoretic construction. For each new event, the algorithm updates a per-pixel time surface and pointer arrays, checks whether the event's own pixel points to an active cluster, and otherwise scans the d-neighborhood for the most recent event within δ. It attaches the new event to that neighbor's cluster, or starts a new cluster rooted at the neighbor. Because every decision uses only O(1) memory and O(d^2) time per event, the total complexity is O(n), independent of the number of pixels; and because thresholds are checked incrementally, qualifying roots appear in the output as soon
Load-bearing premise
The algorithm's local rule — always attach to the closest qualifying event — is assumed, without proof, to produce exactly the same set of cluster roots as the graph-theoretic definition that permits arbitrary attachment when several components qualify; if this equivalence fails, the output can miss or invent roots.
Editorial extensions
If this is right
- Real-time detection on megapixel event cameras becomes feasible, because per-event work is constant and does not grow with the number of pixels.
- The algorithm reports a cluster root immediately when the n-event/m-pixel thresholds are crossed, so a detector can react while the cluster is still forming.
- The root-only output is a compact representation (root timestamp, root coordinates, last-event timestamp, event count, pixel count) well-suited for downstream tracking or classification.
- The cluster bodies can be reconstructed along the event loop without changing the O(n) complexity, if an application needs them.
- The demonstration on a 100 Hz incandescent lamp signal shows the algorithm recovers the root of every period's positive-event cluster, supporting its intended use for periodic or small-signal detection.
Reading between the lines
- The paper asserts, but does not prove, that the deterministic closest-event attachment rule yields the same cluster roots as the graph definition, which allows arbitrary attachment; a constructed event stream with two competing components could expose a divergence.
- The claimed independence from pixel count assumes the r×s dynamic arrays are initialized lazily or that initialization cost is excluded; as described, zero-initializing arrays of 1M pixels would itself take O(r·s) time.
- The root-first output suggests a natural interface to event-based SLAM and tracking: a root timestamp can serve as a stable key for associating clusters over time.
- The same one-pass local-decision structure could extend to 3D event streams from depth sensors, with the neighborhood redefined accordingly.
Editorial analysis
A structured set of objections, weighed in public.
Referee Report
Summary. The paper defines event clusters as connected components of a graph whose vertices are events and whose edges connect an event either to an event at the same pixel or to an event within a d-pixel neighborhood, with temporal constraints controlled by a parameter δ. It then proposes an asynchronous, single-pass algorithm that maintains per-pixel pointer arrays and time surfaces, and claims that the algorithm finds the roots of all clusters exceeding size thresholds (n events, m pixels) in Θ(N) time, independent of the sensor's pixel resolution. The demonstration is a qualitative 3D plot of clusters from a lamp signal, using data from the authors' prior work.
Significance. If the claims are correct, the algorithm would be an interesting contribution: a simple, event-by-event, constant-memory-per-pixel clustering method with linear time in the number of events and no dependence on sensor resolution would be practically useful for event-camera detection. The idea of using time surfaces and per-pixel pointers to maintain cluster roots without reprocessing past events is appealing. However, the paper currently provides no machine-checked proofs, no quantitative evaluation, and no benchmark, so the significance rests entirely on the correctness and complexity assertions, which are not adequately supported.
major comments (4)
- [§3.2 and abstract] The headline claim of Θ(N) complexity independent of sensor resolution is not supported by the algorithm as specified. §3.2 lists eight r×s arrays, each with a concrete initial value. If these arrays are allocated and initialized before the event loop, the cost is Θ(rs), which depends directly on the sensor dimensions. For sparse recordings (N << rs), this initialization dominates and the claimed resolution independence fails. The paper does not specify lazy initialization, generation counters, or any other mechanism that would avoid touching every array entry. This is not a presentation issue; it directly contradicts the central claim of the abstract and §5. The authors must either specify a lazy-initialization scheme and prove its cost, or revise the complexity claim to account for Θ(rs) initialization.
- [§2 and §3.3] The equivalence between the graph-theoretic clustering of §2 and the local decision rule of §3.3 is asserted with 'it is easy to see' but never proved. The graph construction allows an arbitrary choice when several d-neighbor components satisfy the temporal condition, while the algorithm deterministically chooses the closest (minimum temporal distance) neighbor. These two rules can lead to different cluster memberships and root sets, so the output of the algorithm is not automatically the same as the roots of the graph-defined clusters. The authors should either prove that the root set is invariant under the arbitrary choice, or define a deterministic graph construction that exactly matches the algorithm and prove the equivalence by induction.
- [§4] The experimental demonstration is purely qualitative. It uses a recording from the authors' own prior paper [7], has no baseline, no quantitative comparison, no runtime measurements, and no sensitivity analysis for the parameters δ, d, n, and m. Given that the paper's main contribution is the complexity and resolution-independence claims, the demonstration should include measurements on synthetic and real data with varying N and varying sensor resolution, and a comparison against the graph construction of §2 or against existing event-clustering methods. Without such evidence, the practical claims are unsubstantiated.
- [§5] Even the event-loop complexity is not formally analyzed. The per-event work includes a search over all (2d+1)^2 neighbors, which is O(d^2) per event and O(N) only for fixed d. The paper should state this explicitly and provide a clear accounting of all operations, including the output list updates, to justify the Θ(N) claim.
minor comments (4)
- [General] The abstract contains a typo: 'enjoysalinearcomplexity' should be 'enjoys a linear complexity'. Similar spacing issues appear in the introduction.
- [§3.2] The table of arrays is useful, but it would be clearer to list which arrays are indexed by root coordinates and which by pixel coordinates; currently the roles of 'grade', 'pixels', 'ClusterBegin', and 'ClusterEnd' are explained only later in the green-box descriptions.
- [§2] The phrase 'it is easy to see' before the polyforest claim is informal. A short argument (each vertex has at most one incoming edge) would make the paper self-contained.
- [References] References [14] and [24] appear to describe the same work with slightly different titles; the authors should check whether these are duplicates and consolidate if appropriate.
Circularity Check
No material circularity; self-citations are not load-bearing.
full rationale
The paper's central claims are an O(N) event-loop runtime and an output of roots defined in Section 2. Nothing in Section 3 is fitted: the constants δ, d, n, m are user-set parameters, and the output rows are direct bookkeeping of grade/pixels counters. The only use of the authors' own prior work is the demonstration data in Section 4 ('we took the signal from a previous work of the authors [7]'); this is illustrative, not a premise of the complexity or correctness argument. No uniqueness theorem is imported from prior papers; the uniqueness remark in Section 2 is an assertion in this paper itself. The time-surface concept is cited to external literature and is not an unverified ansatz that the paper's result depends on. The valid concerns are non-circular: Section 3.2 specifies eight r×s arrays with initial values, so the claimed resolution-independence ignores Θ(rs) initialization unless lazy initialization is assumed, and the equivalence of the heuristic local rule to the graph-theoretic root definition is asserted without proof. These are correctness/complexity gaps, not reductions of the output to the input, so the circularity score stays low.
Assumptions & free parameters
free parameters (4)
- δ (max temporal distance) =
δ = 2 ms (demo; user-set)
- d (max spatial distance in pixels) =
d = 1 (demo)
- n (minimum events per cluster) =
n = 10 (demo)
- m (minimum contributing pixels) =
m = 5 (demo)
assumptions (5)
- domain assumption Event camera output is an asynchronous list sorted by timestamp v_i=(t_i,x_i,y_i,p_i).
- ad hoc to paper The clustering target is defined by the paper's graph construction (Sec 2): roots of connected components under same-pixel/neighbor and δ temporal rules, with size thresholds n,m.
- domain assumption The d-radius neighborhood is a square (Chebyshev distance).
- domain assumption Polarity can be ignored (Sec 3.3: 'the algorithm does not use the polarity of the event').
- ad hoc to paper The r×s arrays can be accessed/initialized without an O(rs) cost (or that cost is not counted).
Cite this review
Pith. "Pith review of Event Driven Clustering Algorithm." pith.science (2026). https://pith.science/paper/K3N5RTKD
@misc{pith2026260200115,
author = {Pith},
title = {Pith review of: Event Driven Clustering Algorithm},
year = {2026},
howpublished = {\url{https://pith.science/paper/K3N5RTKD}},
note = {Machine review of arXiv:2602.00115}
}
abstract
This paper introduces a novel asynchronous, event-driven algorithm for real-time detection of small event clusters in event camera data. Similar to hierarchical agglomerative clustering methods, the proposed algorithm detects clusters based on their spatio-temporal proximity. However, it explicitly leverages the asynchronous structure of event camera data and employs a simple yet efficient decision mechanism, achieving a linear time complexity of $\Theta(N)$, where $N$ is the number of events. Furthermore, the runtime is independent of the sensor resolution, i.e., the number of pixels.
Figures
Reviewed August 3, 2026 · model on record in the stance chip above.
Discussion (0). Continue with ORCID to comment.