MSF: Multi-Level Spatiotemporal Filtering for Event Denoising via Motion Estimation

Abstract

Event cameras provide microsecond-level temporal resolution, low latency, and high dynamic range, enabling robust perception under fast motion and challenging lighting conditions. Nevertheless, event streams are susceptible to background activity, thermal noise, and hot pixels. Their sparse and irregular patterns can corrupt event structures and degrade downstream tasks. We propose MSF, a multi-level spatiotemporal filtering framework that couples motion-compensated aggregation with neighborhood-level verification. In each temporal window, MSF estimates a constant 2D optical flow by maximizing a robust, density-normalized contrast objective on the image of warped events (IWE). We further incorporate polarity–gradient decorrelation to suppress mixed-polarity noise and an explicit peak-suppression regularizer to avoid hot-pixel-induced degeneracy. The motion parameters are optimized via coarse grid initialization followed by gradient-ascent refinement. Based on the estimated motion, MSF performs hierarchical event selection: central events are extracted from high-confidence aggregated regions, local events are recovered through joint spatial–temporal–directional–polarity consistency, and weak border events are identified using a density-normalized probabilistic support model that rewards support from reliable structures while penalizing self-clustering. Experiments on four public benchmarks (DVSNOISE20, DVSMOTION20, DVSCLEAN, and E-MLB) show that MSF consistently improves the Event Structural Ratio (ESR) and outperforms representative baselines across diverse motion regimes and severe low-light noise.

1. Introduction

Event cameras have demonstrated strong potential in robotic navigation and SLAM [1,2,3], autonomous driving [4,5,6], and high-speed tracking [7,8,9]. Unlike frame-based cameras, event sensors asynchronously report per-pixel brightness changes as a stream of events, enabling microsecond-level temporal resolution, low latency, and high dynamic range. These properties make event cameras particularly attractive for fast motion and challenging lighting conditions, where conventional cameras often suffer from motion blur and under-/over-exposure. Event-based vision has rapidly evolved from early sensor prototypes to a mature research field with a broad algorithmic ecosystem; comprehensive overviews can be found in the surveys by Gallego et al. and Liu et al. [10,11].

Despite these advantages, the differential sensing mechanism of event cameras [12] makes event streams inherently susceptible to noise, including background activity, thermal noise, and hot pixels. This noise is not simply additive, it is sparse, temporally irregular, and can be spatially concentrated, which severely degrades downstream tasks such as motion estimation and reconstruction. As a result, reliably separating real events caused by scene dynamics from sensor noise has become a fundamental problem in event-based vision [13].

Existing denoising methods can be broadly divided into rule-based filtering and learning-based approaches. Rule-based filters typically rely on handcrafted priors, such as spatiotemporal density or clustering cues [14,15,16]. While efficient, they can be brittle in complex scenes where event rates and motion patterns change rapidly. Another line of work formulates denoising as iterative optimization by exploiting global spatiotemporal correlations, often guided by a single dominant cue, e.g., motion consistency [17,18] or contrast maximization (CM) [19]. However, relying on a single cue can lead to failure modes. CM-based models may be distracted by spurious high responses after warping, while pure motion-consistency models may discard weak yet valid boundary events in low-texture or low-contrast regions. Deep learning methods [20,21,22,23] can achieve strong performance on specific benchmarks, but they often require large labeled datasets, introduce substantial model complexity, and may generalize poorly across sensors and operating conditions.

To address these limitations, we propose a multi-level spatiotemporal noise filtering framework, termed MSF, that integrates motion-compensated aggregation with neighborhood-level statistical verification. MSF first estimates a constant 2D optical flow within a window by robust contrast maximization on the image of warped events. The objective combines (i) density-normalized robust contrast to reduce sensitivity to varying event rates, (ii) a polarity-based regularization term to suppress mixed-polarity noise patterns, and (iii) a peak-suppression term to mitigate hot-pixel-induced degeneracy. We optimize the motion parameters using a practical two-stage strategy: coarse grid initialization followed by gradient-ascent refinement. Based on the estimated motion, MSF then performs hierarchical event selection. It extracts highly reliable central events from high-confidence aggregated regions on the warped plane, expands them to local events through joint spatial–temporal–directional–polarity consistency, and finally recovers weak border events using a density-normalized probabilistic support model. This progressive selection preserves coherent motion-induced structures while effectively rejecting background-activity noise.

Experimental results on public datasets show that MSF consistently outperforms representative filtering baselines and improves the reliability of downstream event processing in complex real-world scenarios.

Contributions

The main contributions of this paper are summarized as follows:

• We propose MSF, a multi-level joint spatiotemporal denoising framework that progressively separates motion-induced real events from noisy event streams. The method remains robust under diverse motion patterns and illumination conditions.
• We introduce a robust CM-based motion estimation objective for event streams. It combines density-normalized robust contrast, polarity regularization, and peak suppression, and it is optimized efficiently via grid initialization followed by gradient ascent.
• We design a hierarchical event selection strategy (central–local–border) that integrates motion-compensated aggregation with neighborhood-based spatiotemporal probabilistic support. This enables the effective removal of sparse background noise while preserving weak but valid boundary events.

2. Related Work

From a sensing perspective, event cameras are a representative instance of event-driven sensing, where measurements are reported asynchronously upon sufficiently large signal changes. This paradigm is closely related to the send-on-delta (SoD) strategy, which formalizes threshold-triggered reporting and has been widely discussed beyond vision [24]. Broader perspectives on event-driven sensing and its perception algorithms in both vision and audition are summarized in [11], while ref. [10] provides an extensive survey focused on event-based vision.

Recent studies commonly categorize event camera denoising methods according to their algorithmic principles and the event characteristics they exploit. First, spatiotemporal correlation filtering leverages the continuity and local clustering of genuine events in space and time to suppress random and isolated noise events; representative strategies include local density thresholding and neighborhood-consistency tests, often achieving a favorable balance between detail preservation and real-time efficiency [25,26]. Second, graph spectral and graph-learning approaches model events as nodes in a graph with edges encoding spatial/temporal proximity, and then use spectral properties (e.g., the Fiedler vector) to separate sparsely connected noise from structured signal events; this line also includes models that combine graph encoding with temporal convolution and attention, as well as graph convolutional networks that learn event representations for denoising and classification [27]. Third, deep learning—especially transformer-based architectures—has been adapted to learn complex spatiotemporal dependencies from data, achieving state-of-the-art performance on real-world benchmarks; convolutional and recurrent networks have also been explored to process event streams (or their representations) in an end-to-end manner [28,29]. Fourth, cascaded noise-processing pipelines typically apply multi-stage spatial/temporal filtering together with adaptive thresholding to improve signal-to-noise ratio with reduced computational cost, making them attractive for real-time deployment [30]. Finally, hybrid and bio-inspired frameworks either integrate graph-based features with neural networks to improve robustness and feature fusion, or draw inspiration from biological neural systems (e.g., LIF neurons and their enhanced variants) to achieve energy-efficient, low-latency denoising suitable for neuromorphic hardware [31,32,33,34]. Overall, this diversity reflects the multifaceted noise characteristics of event data and application-driven trade-offs, with hybrid and bio-inspired directions increasingly viewed as promising [28].

Regarding methodology and data transparency, representative algorithms span from classical filters to learning-based models. Spatiotemporal filters remove noise by analyzing local density and neighborhood continuity and have been applied effectively in task-specific settings such as space target detection while maintaining efficiency [25]. Graph-based denoising performs structured separation through graph construction and spectral analysis, and can be strengthened by deep modules for temporal modeling and discrimination [35]. Transformer-based methods rely on large and diverse data to learn cross-scene spatiotemporal correlations and have demonstrated strong performance on real-world datasets [25]. Cascaded and adaptive-threshold approaches improve the trade-off between denoising and detail retention with computationally efficient multi-stage processing [30], whereas bio-inspired methods emphasize deployability and energy efficiency for edge devices and neuromorphic platforms [31,32,33,34]. In parallel, because dense ground truth is often unavailable for real event data, the community has introduced label-free evaluation metrics to quantify structural preservation after denoising, and has released large-scale real-world datasets. Visualization techniques—such as converting event streams into intensity-like images or contrast curves—further support both quantitative and qualitative assessment [36,37].

A critical synthesis of existing findings indicates clear strengths and limitations across categories. Spatiotemporal filtering is effective for preserving fine event details and enabling real-time operation, yet it can be sensitive to parameter choices and may struggle with complex or structured noise [38]. Graph spectral methods are robust to sparse noise and can be scaled using efficient eigenvector estimation algorithms, but they may incur significant cost for large event graphs and remain sensitive to graph construction and hyperparameters [35]. Deep models provide high accuracy and strong representational capacity, but their performance is highly dependent on data diversity and may generalize poorly under low-light or high-noise conditions not well covered during training [28,39,40]. Cascaded pipelines are computationally efficient and often suitable for real-time use, but can lead to over-smoothing or under-filtering and may be less adaptive to rapidly changing scenes [38]. Hybrid and bio-inspired approaches show potential in energy efficiency and robustness, yet they face integration complexity and are still limited by the lack of standardized benchmarks and comprehensive comparisons [31,32,33,34]. More broadly, event denoising inherently involves a trade-off between noise suppression and detail preservation; adaptive thresholding and multi-scale decomposition can improve this balance, but require systematic optimization under different application constraints [41,42,43,44]. Consequently, emerging research trends emphasize stronger adaptability and real-world generalization, including integrating physical noise modeling with data-driven learning, and employing domain adaptation, cross-sensor transfer, and temporal fusion to enhance robustness in complex environments [45,46].

3. Method

Prior work [47] modeled the measured characteristic of background activity (BA) noise and drew conclusions that BA noise behaves very differently under bright and dark conditions. Although the mechanisms underlying noise formation vary across different illumination conditions, the distribution characteristics of noise in event streams consistently exhibit separation from the motion trajectory of moving objects [48]. Consequently, the critical challenge in noise elimination resides in discriminating between events triggered by moving objects and inherent sensor noise. To address this fundamental distinction, we introduce a novel denoising framework as shown in Figure 1. This framework is anchored in the spatiotemporal mo tion trajectory of objects within the observed scene.

3.1. The Theory of Event Denoising

Event cameras work asynchronously by responding to logarithmic intensity changes [12,24], triggering timestamped events when the logarithmic-scale intensity variation surpasses the threshold parameter c > 0:

$$log\left(L\left(\mathbf{x},t\right)\right)-log\left(L\left(\mathbf{x},\tau \right)\right)=p·c,$$

(1)

where $L\left(\mathbf{x},t\right)$ indicates the logarithmic brightness at time t and $\tau$ and at pixel position $\mathbf{x}$, and the polarity $p=\left\{+1,-1\right\}$. Thus, the event is a 4-dimensional tuple $e_k\doteq \left({\mathbf{x}}_k,t_k,p_k\right)$, where ${\mathbf{x}}_k={\left(x_k,y_k\right)}^{\mathrm{T}}$ is the pixel position, $t_k$ is is the triggering time and $p_k$ is the polarity of k-th events.

Moving objects generate a large number of real events, which dynamically outline their instantaneous contours. These real events exhibit strong spatiotemporal consistency, which can be quantified by the proximity of their positional coordinates and timestamps. The temporal information of the events corresponds to the motion trends of the objects, while the spatial information relates to their geometric shapes [49]. The distinction between events and noise based on spatiotemporal correlation relies on the following two rules:

(a) Real events and their adjacent events exhibit high spatial compactness and continuity, and these adjacent events are likely to represent the geometric contours of moving objects. In other words, real events can be fitted on the same temporal plane with adjacent events through consistent motion patterns, whereas noise lacks such motion coherence.

(b) An event is considered real if it exhibits a strong spatio-temporal correlation with its neighbors. This principle is rooted in the continuity of object motion, which, when captured by the high temporal resolution of event-based sensors, manifests as a sequence of causally related events forming a coherent motion trajectory. In contrast, noise events are temporally isolated, with random timestamps lacking correlation with neighboring events.

3.2. Problem Formulation

Let an event stream within a time window be

$$\mathsf{\Omega }={\left\{e_k\right\}}_{k=1}^{N_e},e_k\doteq ({\mathbf{x}}_k,t_k,p_k),$$

(2)

where ${\mathbf{x}}_k={(x_k,y_k)}^{\top }\in {\mathbb{R}}^2$ is the pixel location, $t_k\in \mathbb{R}$ is the timestamp, and $p_k\in \{-1,+1\}$ denotes the polarity. We estimate the motion parameters in each window and simultaneously remove noise events, producing a denoised event stream.

3.3. Constant-Flow Warping Model

We adopt a constant 2D optical flow model within each window:

$$\theta \doteq \mathbf{v}={(v_x,v_y)}^{\top }.$$

(3)

Given a reference time $t_{\mathrm{ref}}$ (set to the window midpoint in our implementation), each event is temporally warped onto the reference plane by

$${\mathbf{x}}_k^{\prime }=W({\mathbf{x}}_k,t_k;\theta )\doteq {\mathbf{x}}_k+\mathbf{v}(t_{\mathrm{ref}}-t_k),$$

(4)

yielding the warped event $e_k^{\prime }\doteq ({\mathbf{x}}_k^{\prime },t_{\mathrm{ref}},p_k)$. When $\theta$ matches the true motion, events triggered by the same moving edge become maximally aligned on the reference plane.

3.4. Robust Contrast Maximization with Polarity Regularization

3.4.1. Image of Warped Events (IWEs)

Instead of the Dirac delta, we construct the image of warped events (IWEs) using Gaussian splatting to reduce discretization artifacts and improve robustness to isolated hot pixels:

$$H(\mathbf{x};\theta )=\sum _{k=1}^{N_e}{\kappa }_g(\mathbf{x}-{\mathbf{x}}_k^{\prime }),\mathbf{x}\in \mathcal{X},$$

(5)

where $\mathcal{X}$ is the pixel grid and ${\kappa }_g(·)$ is an isotropic Gaussian kernel with standard deviation ${\sigma }_g$. To exploit polarity information, we accumulate two polarity-separated IWEs:

$$H^{\pm }(\mathbf{x};\theta )=\sum _{k:p_k=\pm 1}{\kappa }_g(\mathbf{x}-{\mathbf{x}}_k^{\prime }).$$

(6)

3.4.2. Density-Normalized Robust Contrast

A key difficulty in contrast maximization is that the absolute scale of $H(\mathbf{x};\theta )$ depends on the event rate, which can vary significantly across windows. Moreover, a few hot pixels can create spurious high peaks after warping. To stabilize the objective, we define a robust, density-normalized contrast based on a robust center and scale.

We first define a robust center (median) on the pixel plane:

$$m_H\left(\theta \right)={\mathrm{median}}_{\mathbf{x}\in \mathcal{X}}H(\mathbf{x};\theta ),$$

(7)

and a robust scale using the median absolute deviation (MAD):

$$s_H\left(\theta \right)=1.4826·{\mathrm{median}}_{\mathbf{x}\in \mathcal{X}}\left|H(\mathbf{x};\theta )-m_H\left(\theta \right)\right|+ϵ,$$

(8)

where $ϵ>0$ is a small constant for numerical stability. We then define the normalized residual

$$r(\mathbf{x};\theta )={\displaystyle \frac{H(\mathbf{x};\theta )-m_H\left(\theta \right)}{s_H\left(\theta \right)}}.$$

(9)

The robust contrast term is obtained through a Huber M-estimator:

$$f_{\mathrm{rc}}\left(\theta \right)={\displaystyle \frac{1}{\left|\mathcal{X}\right|}}\sum _{\mathbf{x}\in \mathcal{X}}\rho \left(r(\mathbf{x};\theta )\right),$$

(10)

with

$$\rho \left(u\right)=\left\{\begin{array}{cc}{\displaystyle \frac{1}{2}}{u}^2,\hfill & \left|u\right|\le c,\hfill \\ c\left|u\right|-{\displaystyle \frac{1}{2}}{c}^2,\hfill & \left|u\right|>c,\hfill \end{array}\right.$$

(11)

where c is a constant (e.g., $c\in [1.5,2.5]$). Compared to applying Huberization on raw deviations around the mean, the MAD-normalized formulation provides (i) insensitivity to outliers and (ii) comparable objective scales across windows with different event densities.

3.4.3. Polarity Regularization via Gradient Decorrelation

Event polarities encode the sign of brightness changes. Random sensor noise and hot pixels often yield mixed-polarity activations that are not spatially coherent, while true motion-induced events form consistent edge structures. We therefore regularize motion estimation using a polarity term defined on the spatial gradients of $H^{+}$ and $H^{-}$.

Let

$${\mathbf{g}}^{\pm }(\mathbf{x};\theta )\doteq \nabla H^{\pm }(\mathbf{x};\theta ),$$

(12)

where ∇ denotes the spatial gradient operator on the IWE plane. We define a normalized gradient correlation and minimize it (equivalently, maximize its negative):

$$f_{\mathrm{pol}}\left(\theta \right)=-{\displaystyle \frac{{\sum }_{\mathbf{x}\in \mathcal{X}}{\mathbf{g}}^{+}{(\mathbf{x};\theta )}^{\top }{\mathbf{g}}^{-}(\mathbf{x};\theta )}{\sqrt{{\sum }_{\mathbf{x}\in \mathcal{X}}{\parallel {\mathbf{g}}^{+}(\mathbf{x};\theta )\parallel }^2}\sqrt{{\sum }_{\mathbf{x}\in \mathcal{X}}{\parallel {\mathbf{g}}^{-}(\mathbf{x};\theta )\parallel }^2}+ϵ}}.$$

(13)

This term is scale-invariant with respect to event counts, which reduces sensitivity to window selection and makes the regularization weight more stable across sequences.

3.4.4. Peak-Suppression Regularizer (Anti-Hot-Pixel)

Even under robust contrast, degenerate solutions may occur when a small number of pixels absorb a disproportionate amount of warped mass (typical of hot-pixel noise). To explicitly suppress such a collapse, we introduce a peak-occupancy penalty. Define the normalized IWE as

$$\tilde{H}(\mathbf{x};\theta )={\displaystyle \frac{H(\mathbf{x};\theta )}{{\sum }_{\mathbf{y}\in \mathcal{X}}H(\mathbf{y};\theta )+ϵ}},$$

(14)

and the peak regularizer as

$${\mathcal{R}}_{\mathrm{peak}}\left(\theta \right)={\parallel \tilde{H}(·;\theta )\parallel }_{\infty }=\underset{\mathbf{x}\in \mathcal{X}}{max}\tilde{H}(\mathbf{x};\theta ).$$

(15)

This regularizer is small for properly sharpened edge structures but becomes large if the warped mass collapses onto a single pixel.

3.4.5. Final Objective and Motion Estimation

Combining the above components, we estimate the motion parameters in each window by

$${\theta }^{*}=arg\underset{\theta }{max}f\left(\theta \right),f\left(\theta \right)=f_{\mathrm{rc}}\left(\theta \right)+{\lambda }_{\mathrm{pol}}{f}_{\mathrm{pol}}\left(\theta \right)-{\lambda }_{\mathrm{peak}}{\mathcal{R}}_{\mathrm{peak}}\left(\theta \right),$$

(16)

where ${\lambda }_{\mathrm{pol}}\ge 0$ and ${\lambda }_{\mathrm{peak}}\ge 0$ balance polarity regularization and peak suppression.

Grid Initialization + Gradient Ascent

We optimize $f\left(\theta \right)$ using a two-stage strategy. First, we evaluate $f\left(\theta \right)$ on a coarse grid of flow vectors $\theta \in [v_x^{min},v_x^{max}]\times [v_y^{min},v_y^{max}]$ and select the best candidate as initialization:

$${\theta }_0=arg\underset{\theta \in \mathcal{G}}{max}f\left(\theta \right),$$

(17)

where $\mathcal{G}$ denotes the grid. Second, starting from ${\theta }_0$, we refine the solution by gradient ascent:

$${\theta }^{(m+1)}={\theta }^{\left(m\right)}+{\eta }_m{\nabla }_{\theta }f\left({\theta }^{\left(m\right)}\right),$$

(18)

where ${\eta }_m$ is the step size at iteration m. In practice, ${\nabla }_{\theta }f\left(\theta \right)$ is computed via the chain rule through the warping function and the IWE construction, and ${\eta }_m$ is chosen using a simple backtracking line search to ensure monotonic increase of $f\left(\theta \right)$. The derivation process can be found in Appendix A.

3.5. Central Event Selection and Back-Projection

After obtaining ${\theta }^{*}$, we construct the final IWE $H\left(\mathbf{x}\right)\doteq H(\mathbf{x};{\theta }^{*})$. Since event density varies across windows, we retain a fixed proportion of highly aggregated pixels using an adaptive quantile threshold:

$$\tau =Q_q\left({\left\{H\left(\mathbf{x}\right)\right\}}_{\mathbf{x}\in \mathcal{X}}\right),$$

(19)

where $Q_q(·)$ denotes the sample quantile at level $q\in (0,1)$.

Pure quantile masking may still include isolated hot-pixel peaks. We therefore require that high-valued pixels also have local neighborhood support. Let $\mathcal{N}\left(\mathbf{x}\right)$ denote a small neighborhood (e.g., $3\times 3$). Define

$$S\left(\mathbf{x}\right)=\sum _{\mathbf{y}\in \mathcal{N}\left(\mathbf{x}\right)}H\left(\mathbf{y}\right),{\tau }_s=Q_{q_s}\left({\left\{S\left(\mathbf{x}\right)\right\}}_{\mathbf{x}\in \mathcal{X}}\right),$$

(20)

and form the central pixel mask

$$M_c\left(\mathbf{x}\right)=\mathbf{1}\left[H\left(\mathbf{x}\right)\ge \tau \right]·\mathbf{1}\left[S\left(\mathbf{x}\right)\ge {\tau }_s\right].$$

(21)

3.5.1. Back-Projection to the Event Domain

Given the binary central mask $M_c\left(\mathbf{x}\right)\in \{0,1\}$ on the reference plane, we compute a soft membership for each event by bilinear sampling at its warped sub-pixel coordinate ${\mathbf{x}}_k^{\prime }={(x_k^{\prime },y_k^{\prime })}^{\top }$.

Let

$$x_0=\lfloor x_k^{\prime }\rfloor ,y_0=\lfloor y_k^{\prime }\rfloor ,{\delta }_x=x_k^{\prime }-x_0,{\delta }_y=y_k^{\prime }-y_0,$$

(22)

and define the 4-neighborhood pixels

$$(x_0,y_0),(x_0+1,y_0),(x_0,y_0+1),(x_0+1,y_0+1).$$

(23)

The bilinear weights are

$$\begin{array}{cccc}\hfill w_{00}& =(1-{\delta }_x)(1-{\delta }_y),\hfill & \hfill w_{10}& ={\delta }_x(1-{\delta }_y),\hfill \end{array}$$

(24)

$$\begin{array}{cccc}\hfill w_{01}& =(1-{\delta }_x){\delta }_y,\hfill & \hfill w_{11}& ={\delta }_x{\delta }_y.\hfill \end{array}$$

(25)

We then compute

$$g_k^c\left({\theta }^{*}\right)=w_{00}{M}_c(x_0,y_0)+w_{10}{M}_c(x_0+1,y_0)+w_{01}{M}_c(x_0,y_0+1)+w_{11}{M}_c(x_0+1,y_0+1).$$

(26)

If any neighbor lies outside the image bounds, its mask value is treated as zero (zero padding). The final hard decision is

$${\chi }_k^c\left({\theta }^{*}\right)=\mathbf{1}\left[g_k^c\left({\theta }^{*}\right)\ge {\eta }_c\right],$$

(27)

where ${\eta }_c\in (0,1]$ controls strictness. In all experiments we use ${\eta }_c=0.5$, which corresponds to requiring that at least half of the bilinear support lies inside the central mask.

3.5.2. Directional Consistency

We further enforce consistency with the estimated motion direction. The predicted direction for $e_j$ is

$${\widehat{\mathbf{d}}}_j^{\mathrm{pred}}\doteq {\displaystyle \frac{\Delta {\mathbf{x}}_j^{\mathrm{pred}}}{\parallel \Delta {\mathbf{x}}_j^{\mathrm{pred}}\parallel +ϵ}}.$$

(28)

We also compute the observed direction between warped locations of $e_i$ and $e_j$:

$${\widehat{\mathbf{d}}}_{i\to j}^{\mathrm{obs}}\doteq {\displaystyle \frac{{\mathbf{x}}_j^{\prime }-{\mathbf{x}}_i^{\prime }}{\parallel {\mathbf{x}}_j^{\prime }-{\mathbf{x}}_i^{\prime }\parallel +ϵ}}.$$

(29)

The direction gate is

$$g_{\theta }(i,j)=\mathbf{1}\left(\angle ({\widehat{\mathbf{d}}}_{i\to j}^{\mathrm{obs}},{\widehat{\mathbf{d}}}_j^{\mathrm{pred}})\le {\tau }_{\theta }\right),$$

(30)

where ${\tau }_{\theta }$ is an angular threshold.

3.5.3. Polarity Consistency and Joint Gating

We require polarity consistency:

$$g_p(i,j)=\mathbf{1}[p_i=p_j].$$

(31)

The joint gating function is then

$$g(i,j)=g_d(i,j)g_t(i,j)g_{\theta }(i,j)g_p(i,j).$$

(32)

Finally, we define the set of local events as those satisfying the joint gate with at least one central event:

$${\mathsf{\Omega }}_l=\left\{e_j\in \mathsf{\Omega }\setminus {\mathsf{\Omega }}_c|\exists e_i\in {\mathsf{\Omega }}_c:g(i,j)=1\right\}.$$

(33)

This selection suppresses random noise events that accidentally align after warping but are inconsistent in temporal support or motion direction, while retaining events that extend the central structure into locally continuous contours.

3.6. Border Event Identification via Density-Normalized Probabilistic Support

After extracting ${\mathsf{\Omega }}_c$ and ${\mathsf{\Omega }}_l$, the remaining candidates are

$${\mathsf{\Omega }}^{\prime }=\mathsf{\Omega }\setminus ({\mathsf{\Omega }}_c\cup {\mathsf{\Omega }}_l).$$

(34)

These events often include weak responses near the boundary of true structures and isolated noise. We identify border events by measuring their spatiotemporal support from ${\mathsf{\Omega }}_c$ and ${\mathsf{\Omega }}_l$ while penalizing self-clustered candidates.

3.6.1. Local Neighborhood and Three Support Counts

For any candidate event $e=(\mathbf{x},t,p)\in {\mathsf{\Omega }}^{\prime }$, define a local spatiotemporal neighborhood

$$\mathcal{U}\left(e\right)=\left\{e^{\prime }=({\mathbf{x}}^{\prime },t^{\prime },p^{\prime })\in \mathsf{\Omega }|\parallel {\mathbf{x}}^{\prime }-\mathbf{x}\parallel \le r_s,|t^{\prime }-t|\le r_t\right\},$$

(35)

where $r_s$ and $r_t$ are the spatial and temporal radii.

We compute three support features:

$$\begin{array}{cc}\hfill n_A\left(e\right)& =\sum _{e_i\in {\mathsf{\Omega }}_c}\mathbf{1}\left[e_i\in \mathcal{U}\left(e\right)\right],\hfill \end{array}$$

(36)

$$\begin{array}{cc}\hfill n_B\left(e\right)& =\sum _{e_j\in {\mathsf{\Omega }}_l}\mathbf{1}\left[e_j\in \mathcal{U}\left(e\right)\right],\hfill \end{array}$$

(37)

$$\begin{array}{cc}\hfill n_C\left(e\right)& =\sum _{\begin{array}{c}{e}_k\in {\mathsf{\Omega }}^{\prime }\\ e_k\ne e\end{array}}\mathbf{1}\left[e_k\in \mathcal{U}\left(e\right)\right].\hfill \end{array}$$

(38)

Here, $n_A$ measures direct support from reliable central structures, $n_B$ measures continuity support from local contours, and $n_C$ captures clustering behavior within candidates themselves.

3.6.2. Density Normalization and Probabilistic Decision

Because $n_A,n_B,n_C$ scale with event density, we normalize them to obtain density-invariant ratios:

$$\begin{array}{c}\hfill u_A\left(e\right)={\displaystyle \frac{n_A\left(e\right)}{n_A\left(e\right)+n_B\left(e\right)+n_C\left(e\right)+ϵ}},\end{array}$$

(39)

$$\begin{array}{c}\hfill u_B\left(e\right)={\displaystyle \frac{n_B\left(e\right)}{n_A\left(e\right)+n_B\left(e\right)+n_C\left(e\right)+ϵ}},\end{array}$$

(40)

$$\begin{array}{c}\hfill u_C\left(e\right)={\displaystyle \frac{n_C\left(e\right)}{n_A\left(e\right)+n_B\left(e\right)+n_C\left(e\right)+ϵ}}.\end{array}$$

(41)

We then define the probability of being a real (non-noise) event by a logistic model:

$$P(\mathrm{real}\mid e)=\sigma \left(\alpha u_A\left(e\right)+\beta u_B\left(e\right)-\gamma u_C\left(e\right)-b\right),\sigma \left(z\right)={\displaystyle \frac{1}{1+e^{-z}}},$$

(42)

where $\alpha ,\beta ,\gamma \ge 0$ are weights and b is a bias term. The weights $(\alpha ,\beta ,\gamma ,b)$ control the relative importance of the three density-normalized supports: direct support from central events ($u_A$), continuity support from local events ($u_B$), and self-clustering among remaining candidates ($u_C$). We enforce the intuitive ordering $\alpha >\beta \ge 0$ and $\gamma >0$, reflecting that support from ${\mathsf{\Omega }}_c$ is the most reliable, ${\mathsf{\Omega }}_l$ provides secondary evidence, and excessive clustering in ${\mathsf{\Omega }}^{\prime }$ should be penalized.

In practice, we determine $(\alpha ,\beta ,\gamma ,b)$ using a lightweight validation procedure on DVSNOISE20 windows (Section 4.1): we perform a small grid search under the above constraints to maximize validation ESR, and then fix the selected weights for all datasets. This protocol avoids per-dataset tuning while providing a principled way to set the decision boundary of $P(\mathrm{real}\mid e)$.

Finally, the border event set is obtained by thresholding:

$${\mathsf{\Omega }}_b=\left\{e\in {\mathsf{\Omega }}^{\prime }|P(\mathrm{real}\mid e)\ge \pi \right\}.$$

(43)

3.7. Denoised Event Stream

The final denoised event stream is the union of central, local, and border events:

$${\mathsf{\Omega }}_{\mathrm{real}}={\mathsf{\Omega }}_c\cup {\mathsf{\Omega }}_l\cup {\mathsf{\Omega }}_b.$$

(44)

This hard-selection output preserves (i) strongly motion-compensated core structures, (ii) spatiotemporally and directionally consistent supporting events, and (iii) boundary events that are weak individually but supported by nearby real structures, thereby improving robustness to hot pixels, random background activations, and window-dependent event density variations.

3.8. Algorithm Overview

Algorithm 1 summarizes the proposed denoising pipeline within a single time window.

Algorithm 1 Denoising with Robust CM and Hierarchical Event Selection

Require:  Event window $\mathsf{\Omega }={\left\{({\mathbf{x}}_k,t_k,p_k)\right\}}_{k=1}^{N_e}$, reference time $t_{\mathrm{ref}}$, grid $\mathcal{G}$, parameters ${\sigma }_g,c,{\lambda }_{\mathrm{pol}},{\lambda }_{\mathrm{peak}}$, quantiles $q,q_s$, thresholds ${\eta }_c,\pi$, neighborhood radii $r_s,r_t$, local gates $(a_d,b_d,a_t,b_t,{\tau }_{\theta })$  Ensure:  Denoised events ${\mathsf{\Omega }}_{\mathrm{real}}$ 1: Construct $H(·;\theta ),H^{\pm }(·;\theta )$ for each $\theta \in \mathcal{G}$ and evaluate $f\left(\theta \right)$ 2: ${\theta }_0\leftarrow arg{max}_{\theta \in \mathcal{G}}f\left(\theta \right)$ {Grid initialization} 3: ${\theta }^{*}\leftarrow$ gradient ascent initialized at ${\theta }_0$ maximizing $f\left(\theta \right)$ 4: Construct $H(·)\leftarrow H(·;{\theta }^{*})$ and compute central mask $M_c$ via quantiles on H and neighborhood support S 5: Back-project $M_c$ to events to obtain ${\mathsf{\Omega }}_c$ using $g_k^c\ge {\eta }_c$ 6: Compute adaptive ${\tau }_d,{\tau }_t$ from ${\theta }^{*}$ and select ${\mathsf{\Omega }}_l$ by joint gating $g_d{g}_t{g}_{\theta }{g}_p$ 7: ${\mathsf{\Omega }}^{\prime }\leftarrow \mathsf{\Omega }\setminus ({\mathsf{\Omega }}_c\cup {\mathsf{\Omega }}_l)$; for each $e\in {\mathsf{\Omega }}^{\prime }$ compute $n_A,n_B,n_C$ in $\mathcal{U}\left(e\right)$ and $P(\mathrm{real}\mid e)$ 8: ${\mathsf{\Omega }}_b\leftarrow \{e\in {\mathsf{\Omega }}^{\prime }\mid P(\mathrm{real}\mid e)\ge \pi \}$ 9: ${\mathsf{\Omega }}_{\mathrm{real}}\leftarrow {\mathsf{\Omega }}_c\cup {\mathsf{\Omega }}_l\cup {\mathsf{\Omega }}_b$ 10: return  ${\mathsf{\Omega }}_{\mathrm{real}}$

4. Experimental Evaluation

4.1. Experimental Setup

4.1.1. Datasets

We evaluate the proposed MSF on four public benchmarks: DVSNOISE20 [23], DVSMOTION20 [50], DVSCLEAN [20], and E-MLB [36]. These datasets jointly cover (i) different background activity and hot-pixel characteristics (DVSNOISE20), (ii) a wide range of motion magnitudes including slow-motion sequences with large inter-event intervals (DVSMOTION20), (iii) controlled synthetic noise injection (DVSCLEAN), and (iv) progressively degraded illumination where noise becomes dominant (E-MLB). This combination enables an informative assessment of robustness and generalization.

4.1.2. Windowing Protocol

Following common practice in event denoising, all methods process the stream in fixed-length temporal windows of $\Delta t=20\mathrm{ms}$. For each window, we set the reference time $t_{\mathrm{ref}}$ to the midpoint of the window, consistent with Section 3.3. All reported quantitative results are obtained by averaging per-window scores over all sequences in each dataset.

4.1.3. Implementation Details and Hyperparameters

MSF contains three stages: (1) motion estimation via robust contrast maximization, (2) central and local event selection, and (3) border event identification by density-normalized probabilistic support.

Motion estimation. We construct the IWE using Gaussian splatting (Section 3.4.1) with kernel standard deviation ${\sigma }_g$. The robust contrast term uses the Huber constant c (Section 3.4.2). The final objective is $f\left(\theta \right)=f_{\mathrm{rc}}\left(\theta \right)+{\lambda }_{\mathrm{pol}}{f}_{\mathrm{pol}}\left(\theta \right)-{\lambda }_{\mathrm{peak}}{\mathcal{R}}_{\mathrm{peak}}\left(\theta \right)$ (Section 3.4.5), where ${\lambda }_{\mathrm{pol}}$ and ${\lambda }_{\mathrm{peak}}$ weight polarity regularization and peak suppression, respectively. Optimization follows the two-stage strategy in Section 3.4.5: a coarse grid search over $\mathcal{G}$ to obtain ${\theta }_0$, followed by gradient ascent with backtracking line search to yield ${\theta }^{*}$.

Central event extraction. Given ${\theta }^{*}$, we form the central mask $M_c$ by quantile thresholding on $H\left(\mathbf{x}\right)$ and on the neighborhood-supported accumulation $S\left(\mathbf{x}\right)={\sum }_{\mathbf{y}\in \mathcal{N}\left(\mathbf{x}\right)}H\left(\mathbf{y}\right)$ (Section 3.5). The quantile levels are q and $q_s$, respectively. Central events are obtained by back-projecting $M_c$ to the event domain using bilinear weights and thresholding the soft membership $g_k^c$ with ${\eta }_c$ (Section 3.5.1).

Local event selection. Local events ${\mathsf{\Omega }}_l$ are selected by joint gating (Section 3.5.3), enforcing spatial proximity (${\tau }_d$), temporal proximity (${\tau }_t$), directional consistency (${\tau }_{\theta }$), and polarity consistency. Importantly, ${\tau }_d$ and ${\tau }_t$ are adaptive and computed from the robust speed scale $\overline{v}$ derived from ${\theta }^{*}$:

$${\tau }_d=a_d+b_d\overline{v},{\tau }_t=a_t+{\displaystyle \frac{b_t}{\overline{v}+ϵ}}.$$

(45)

This design prevents over-expansion in low-speed segments and preserves sufficient support in high-speed segments.

Border event identification. For the remaining candidates ${\mathsf{\Omega }}^{\prime }$, we compute neighborhood support counts $n_A,n_B,n_C$ in the spatiotemporal neighborhood $\mathcal{U}\left(e\right)$ with radii $(r_s,r_t)$ (Section 3.6.1). We then form density-normalized ratios $(u_A,u_B,u_C)$ and apply the logistic model $P(\mathrm{real}\mid e)=\sigma (\alpha u_A+\beta u_B-\gamma u_C-b)$ with threshold $\pi$ (Section 3.6.2), yielding border events ${\mathsf{\Omega }}_b$.

4.1.4. Baselines

We compare MSF against density-based filters DWF [47], Knoise [51], and Ynoise [52]; a motion-based method EvFlow [17]; surface/smoothness methods TS [53] and RED [54]; and the learning-based EDnCNN [23]. All methods are evaluated under the same windowing protocol.

4.1.5. Metric

The mainstream evaluation metrics for event denoising include relative plausibility measure of denoising (RPMD) [23], plots receiver operating characteristic (ROC) [47], and Event Structural Ratio (ESR) [36]. RPMD evaluates the event denoising performance by measuring the APS intensity and based on IMU motion prediction, and requires high-quality and correctly aligned APS and IMU data, which is suitable for the DVSNOISE20 dataset; ROC assesses the denoising accuracy by using noise annotation data to calculate the false positive rate (FPR) and true positive rate (TPR), and is suitable for synthetic datasets such as DVSCLEAN. ESR assesses the denoising performance by projecting the events onto a distorted event image and calculating the image contrast metric, and can be tested directly on the event sequence. ESR neither relies on synthetic data nor requires access to additional information sources to obtain true value data, and can represent the noise level in all cases. ESR is computed from the image of warped events (IWE), obtained by accumulating the denoised events onto a 2D pixel grid after warping (e.g., using the estimated motion/flow). Let K denote the number of pixels in the IWE, N the total number of events, and $n_i$ the number (or accumulated count) of events falling on pixel i ($i=1,\dots ,K$), such that ${\sum }_{i=1}^K{n}_i=N$. A basic contrast measure for the IWE is the normalized total sum of squares (NTSS), defined as

$$\mathrm{NTSS}=\sum _{i=1}^K{\displaystyle \frac{n_i(n_i-1)}{N(N-1)}}.$$

(46)

NTSS reflects the tendency of events to concentrate on a subset of pixels (high contrast) and is normalized by N, making it largely comparable across different event counts. However, NTSS alone can be biased toward over-denoising: if too many events are removed, the remaining events may become artificially concentrated, and in the extreme case $N=1$ NTSS reaches its upper bound, failing to faithfully represent the noise level.

To mitigate this issue, ESR incorporates a penalty term that accounts for the spatial support (i.e., the effective area occupied by events) in the IWE:

$$L_N:=K-\sum _{i=1}^K{\left(1-{\displaystyle \frac{M}{N}}\right)}^{n_i},$$

(47)

where M is a fixed reference number of events used for interpolation (kept constant throughout evaluation). Intuitively, ${\left(1-{\displaystyle \frac{M}{N}}\right)}^{n_i}$ down-weights pixels with larger $n_i$, so $L_N$ increases when events are spread over more pixels and decreases when events collapse to a small spatial region. This term, therefore, discourages degenerate solutions that remove most events and yield spuriously high contrast.

Finally, ESR is defined as the geometric combination of the normalized contrast and the support penalty:

$$\mathrm{ESR}:=\sqrt{\mathrm{NTSS}·L_N}.$$

(48)

A higher ESR indicates that the denoised events form sharp, spatially coherent structures (high $\mathrm{NTSS}$) while still maintaining a reasonable spatial support (appropriate $L_N$), i.e., preserving meaningful event geometry rather than achieving high contrast by excessive event removal.

4.1.6. Hyper-Parameter Tuning and Protocol

MSF involves several hyper-parameters. To avoid per-dataset overfitting and to ensure fair cross-benchmark evaluation, we adopt a two-stage tuning protocol and then keep a single configuration fixed for all reported results. We also tune the logistic weights $(\alpha ,\beta ,\gamma ,b)$ of the border-event model (Section 3.6.2) using the same DVSNOISE20 validation protocol, and keep them fixed for all benchmarks.

Stage 1 (coarse search on a validation split). We tune the core hyper-parameters on DVSNOISE20 only. Following a sampling-based split, we randomly sample 20% of non-overlapping temporal windows from each sequence as a validation set, and use the remaining windows for evaluation, ensuring that windows are not shared across splits. We run a coarse grid/random search over a limited set of sensitive parameters and select the configuration that maximizes the average validation ESR (Section 4.1.5), with ties broken by runtime stability.

Stage 2 (fixed-parameter evaluation on all benchmarks). After selecting a single configuration on DVSNOISE20 validation windows, we fix the same hyper-parameters and evaluate on all four datasets (DVSMOTION20, DVSNOISE20, DVSCLEAN, and E-MLB) without any dataset-specific re-tuning.

Core parameters disclosed. In the interest of reproducibility, we disclose the main tuned parameters as follows (fixed across all datasets): Gaussian splatting standard deviation ${\sigma }_g=1.0$ pixel; Huber constant $c=2.0$; regularization weights ${\lambda }_{\mathrm{pol}}=0.2$ and ${\lambda }_{\mathrm{peak}}=0.1$; central-mask quantiles $q=0.95$ and $q_s=0.90$; back-projection threshold ${\eta }_c=0.5$. border-event probability threshold $\pi =0.5$; logistic weights $(\alpha ,\beta ,\gamma ,b)=(4,2,3,0)$. Other parameters (e.g., window length $\Delta t$, neighborhood size, and flow-grid bounds) follow common practice and are kept constant across all experiments.

4.2. Qualitative Evaluation

Figure 2 shows representative results in scenes with different motion magnitudes. The raw streams exhibit severe background activity, including isolated events and small spurious clusters that do not correspond to physical edges. Density-based methods (DWF, Knoise, and Ynoise) rely primarily on local event-count statistics and therefore face an intrinsic ambiguity in complex scenes: when genuine edges are temporally sparse (e.g., slow motion or low texture), density can be insufficient to distinguish weak-but-real events from noise, leading to either residual noise or over-suppression of valid structures. TS, which enforces local spatiotemporal surface regularity, often suppresses noise aggressively but may also remove thin structures and attenuate texture-like details, reducing the perceptual completeness of object contours.

EvFlow and RED, which impose temporal continuity constraints, can fail in slow-motion regimes where the temporal spacing of true events becomes large. In such cases, real events on edges are more easily rejected as temporally inconsistent, resulting in fragmented contours. EDnCNN generally produces visually clean outputs, but its behavior depends on the training distribution; in particular, under distribution shifts (e.g., extreme low-light noise patterns), it may either leave structured residual artifacts or oversmooth informative event patterns.

MSF yields visually sharper and more coherent structures across motion conditions. The improvement stems from two coupled mechanisms. First, the robust CM objective (Section 3.4.5) aligns motion-induced events while being less sensitive to event-rate variations and hot-pixel peaks, due to MAD normalization, polarity–gradient decorrelation, and explicit peak suppression. Second, the hierarchical selection strategy preserves structure progressively: central events provide a high-precision core; local events restore spatial continuity under adaptive spatiotemporal thresholds and directional agreement; and border events recover weak responses only when supported by nearby reliable events, while penalizing candidate self-clustering.

Figure 3 further highlights robustness under decreasing illumination. As illumination diminishes, background activity increases and the event manifolds become less regular, which degrades surface-fitting and temporal continuity baselines. MSF remains stable because motion-compensated aggregation strengthens true structures, and the density-normalized probabilistic support (Section 3.6.2) reduces sensitivity to the increased overall event rate, enabling the retention of meaningful contours even in the most challenging setting.

4.3. Quantitative Evaluation

Table 1. Average ESR on public datasets. The best and second-best results are highlighted.

	DVSMOTION20	DVSNOISE20	DVSCLEAN	E-MLB
Raw	0.684	0.524	0.732	0.814
Knoise	0.695	0.550	0.765	0.865
DWF	0.751	0.458	0.752	0.911
EvFlow	0.690	0.667	0.783	0.878
Ynoise	0.782	0.654	0.823	0.878
TS	0.732	0.745	0.815	0.891
RED	0.746	0.724	0.805	0.906
EDnCNN	0.762	0.762	0.816	0.913
Ours	0.795	0.747	0.818	0.920

reports average ESR over four benchmarks. All methods improve ESR relative to the raw streams to varying degrees, confirming that suppressing background activity generally increases structural consistency. EDnCNN achieves the highest ESR on DVSNOISE20, which is expected because the dataset provides noise probability labels and is commonly used to train or calibrate learning-based denoisers [23]. On DVSCLEAN, Ynoise attains the best ESR, likely because synthetic high-density noise amplifies the effectiveness of density-driven rules.

MSF achieves the best ESR on DVSMOTION20 and E-MLB, and remains highly competitive on DVSNOISE20 and DVSCLEAN. Notably, the gains on DVSMOTION20 indicate robustness to slow motion, where temporal continuity cues are weak and density statistics are ambiguous. The top performance on E-MLB validates MSF under low-light noise, where event-rate changes and hot-pixel activations are more pronounced. These results support the central claim of MSF: combining robust motion-compensated alignment with hierarchical, density-invariant spatiotemporal support yields stable denoising across heterogeneous conditions.

4.4. Ablation Study

To quantify the individual contribution of each proposed component, we conduct an ablation study on DVSNOISE20 under the same windowing protocol ($\Delta t=20$ ms) and the fixed hyper-parameter setting reported in Section 4.1. We report the average ESR over all windows. Each ablation variant removes one component from MSF while keeping all other steps unchanged.

4.4.1. Ablated Components

We evaluate the following: (i) removing the polarity–gradient decorrelation term by setting ${\lambda }_{\mathrm{pol}}=0$ (“w/o Pol”); (ii) removing peak suppression by setting ${\lambda }_{\mathrm{peak}}=0$ (“w/o Peak”); and (iii) removing each level of hierarchical selection by using only a subset of event sets: central-only (“C only”), central+local (“C+L”), and central+local+border (full MSF).

4.4.2. Results and Discussion

Table 2. Ablation study on DVSNOISE20. We report average ESR under the same protocol as Section 4.1. Higher is better.

Variant	ESR ↑
Full MSF (C+L+B, w/ Pol, w/ Peak)	0.795
w/o Polarity term (${\lambda }_{\mathrm{pol}}=0$) w/o Peak suppression (${\lambda }_{\mathrm{peak}}=0$)	0.732 0.748
C only (central events only) C+L (central + local, no border)	0.697 0.752

shows that each proposed component consistently improves ESR. In particular, the polarity regularization and peak suppression stabilize motion estimation under mixed-polarity noise and hot-pixel-induced degeneracy, respectively, which translates to improved event alignment and higher ESR. Moreover, progressively adding local and border events improves structural completeness: central events provide high precision, local expansion restores contour continuity, and the border stage recovers weak boundary events that are otherwise missed, leading to the best overall ESR.

4.5. Scalability with Respect to the Number of Events

We analyze how MSF scales with the number of events $N_e$ in a temporal window. Let the sensor resolution be $K=\left|\mathcal{X}\right|$ pixels (e.g., $K=WH$), the flow grid size be $\left|\mathcal{G}\right|=G$, the number of gradient-ascent iterations be I, the Gaussian splatting support size be S pixels per event (a small constant determined by ${\sigma }_g$ and truncation), and the average number of central events be $N_c$.

4.5.1. Motion Estimation (Grid + Refinement)

For each candidate flow $\theta$, constructing the IWE by Gaussian splatting costs $\mathcal{O}\left(N_{e}S\right)$. Computing robust statistics (median and MAD) over the pixel plane costs $\mathcal{O}\left(K\right)$ (or $\mathcal{O}(KlogK)$ if implemented via sorting; in practice K is fixed by the sensor resolution). The polarity–gradient correlation and peak penalty are also $\mathcal{O}\left(K\right)$ after the IWEs are built. Therefore, evaluating the objective once is

$$\mathcal{O}(N_{e}S+K).$$

(49)

The coarse grid search is $\mathcal{O}\left(G(N_{e}S+K)\right)$, and the refinement stage is $\mathcal{O}\left(I(N_{e}S+K)\right)$, yielding total motion-estimation complexity

$$\mathcal{O}\left((G+I)(N_{e}S+K)\right).$$

(50)

For a fixed sensor resolution and fixed splatting kernel, S and K are constants; hence. motion estimation scales linearly with $N_e$.

4.5.2. Central Event Extraction

Given ${\theta }^{*}$, building the final IWE is $\mathcal{O}\left(N_{e}S\right)$ and computing quantiles/neighborhood sums on the pixel plane is $\mathcal{O}\left(K\right)$. Back-projecting the central mask to the event domain via bilinear sampling is $\mathcal{O}\left(N_e\right)$. Thus, this stage is $\mathcal{O}(N_{e}S+K)$, i.e., linear in $N_e$.

4.5.3. Local Event Selection (Central-to-Local Expansion)

A naive implementation that checks each non-central event against all central events would be $\mathcal{O}\left(N_c(N_e-N_c)\right)$. To keep the method scalable, we use local spatiotemporal neighbor queries: events are indexed in a spatial grid (or voxel hash) and processed in timestamp order so that candidate neighbors of an event can be retrieved in expected constant time with a bounded neighborhood. With such indexing, each event only compares against a bounded number of nearby events within $({\tau }_d,{\tau }_t)$, and the expected cost becomes

$$\mathcal{O}\left(N_e\overline{m}\right),$$

(51)

where $\overline{m}$ is the average number of retrieved neighbors inside the query window (typically small and bounded by the chosen radii). Hence local selection is near-linear in $N_e$.

4.5.4. Border Event Identification

Border identification computes $(n_A,n_B,n_C)$ by counting neighbors in $\mathcal{U}\left(e\right)$. With the same grid/voxel indexing, each candidate event queries a bounded neighborhood; thus, the expected complexity is also $\mathcal{O}\left(N_e\overline{m}\right)$.

4.5.5. Overall Scaling

Combining all components, for fixed resolution K and fixed hyperparameters $(G,I,S,{\tau }_d,{\tau }_t,r_s,r_t)$, MSF scales approximately linearly with the number of events per window:

$$T\left(N_e\right)=\mathcal{O}\left((G+I)N_e+N_e\overline{m}\right),$$

(52)

where $(G+I)$ and $\overline{m}$ depend on the chosen accuracy–speed setting rather than on $N_e$ itself. In the worst case, if the neighborhood query window becomes so large that $\overline{m}$ grows with $N_e$, the counting stages may degrade toward quadratic behavior; however, MSF uses fixed spatiotemporal radii and a constant window length, which keeps the neighborhood size bounded and avoids such degeneration in typical operating conditions.

4.6. Computational Efficiency

4.6.1. Protocol

We measure average wall-clock runtime per $\Delta t=20$ ms window on a desktop CPU (Intel i5-13600KF) using Python 3.8 implementations for all methods. This setting reflects a practical non-optimized deployment and enables a fair comparison under the same windowing protocol used throughout the paper.

4.6.2. Runtime Comparison and Real-Time Requirement

With $\Delta t=20$ ms, real-time processing requires the average per-window latency to be below 20 ms.

Table 3. Average runtime per 20 ms window on Intel i5-13600KF (Python). Real-time requires <20 ms/window.

Method	Avg. Runtime (ms/window)
Knoise	3.18
DWF	7.25
Ynoise	6.07
TS	17.46
RED	12.05
MSF (ours)	11.64
EvFlow	256
EDnCNN	313

reports the measured runtimes. MSF achieves 11.64 ms per window on average, satisfying the real-time constraint on CPU in Python. Among the compared methods, density-based filters (Knoise/DWF/Ynoise) are faster due to their simpler local counting rules, while TS/RED and MSF remain within the 20 ms budget. In contrast, EvFlow (256 ms) and EDnCNN (313 ms) are not real-time under our CPU Python setup.

4.6.3. Discussion

MSF’s runtime is dominated by motion estimation (coarse grid evaluation and refinement) and the hierarchical neighborhood verification. In practice, the speed can be further improved by reducing the flow-grid resolution, decreasing the number of refinement iterations. These knobs provide an explicit accuracy–speed trade-off for embedded or low-power deployment.

5. Conclusions

We proposed MSF, a motion-guided multi-level filtering framework for event-stream denoising. Within each temporal window, MSF estimates a constant optical flow by maximizing a robust, density-normalized contrast objective on the image of warped events. We further incorporate a polarity–gradient decorrelation term to suppress mixed-polarity noise and a peak-suppression regularizer to avoid degeneracy caused by hot pixels. Based on the estimated motion, MSF performs hierarchical event selection: central events are extracted via quantile-based masking with neighborhood support and back-projection; local events are recovered using adaptive spatiotemporal proximity and directional consistency; and border events are identified by a density-normalized probabilistic support model that rewards support from reliable structures while penalizing self-clustering among remaining candidates. Experiments on four public datasets demonstrate that MSF consistently improves ESR and generalizes well across diverse motion and illumination conditions.

Future work will extend MSF beyond the single-motion assumption by integrating motion segmentation and multi-model flow estimation, enabling principled denoising in scenes containing multiple independently moving objects and complex motion boundaries.