Event-Based Normal Flow Analysis

• Event-Based Normal Flow is the observable motion component along image gradients from asynchronous event camera outputs, focusing on edge dynamics.
• Classical methods use plane-fitting and PCA while modern approaches leverage learned per-event predictors and VecKM encoding for precise normal flow estimation.
• Geometric solvers integrate normal flow into pipelines for camera motion, scene structure recovery, and real-time motion segmentation with high efficiency.

Searching arXiv for the cited event-based normal flow papers to ground the article in the current literature. Event-based normal flow is the component of image motion that is locally observable along the image-gradient direction when vision is mediated by asynchronous events rather than frames. In the standard formulation, optical flow is $u=(u_x,u_y)$, the unit gradient direction is $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$, and the normal-flow magnitude is $v_n=u\cdot n_{\mathrm{grad}}$. Under brightness constancy, $I_xu_x+I_yu_y+I_t=0$, so $v_n=-I_t/\|\nabla I\|$ wherever $\|\nabla I\|\neq 0$. Because event cameras emit events $E=\{(x,y,t,p)\}$ when log-intensity changes cross a threshold, their output is tightly coupled to edge dynamics and therefore to normal flow. Across recent work, event-based normal flow has developed from plane-fitting and PCA estimators into learned per-event predictors, real-time GPU implementations, and downstream geometric pipelines for motion, structure, egomotion, and motion segmentation (Khairallah et al., 2021, Ren et al., 2024, Yuan et al., 2024, Yuan et al., 28 Apr 2025, Zhong et al., 24 Feb 2026, Hua et al., 19 Jul 2025).

1. Definition, event-camera formulation, and observability

The central distinction between optical flow and normal flow is observability. Optical flow is a full $2$D image-plane velocity field, whereas normal flow is only the component along the image gradient direction. This is the local aperture problem: tangential motion along an isophote remains ambiguous, while motion perpendicular to an edge is constrained by brightness variation. In the event-camera setting this distinction is especially consequential, because events are generated precisely where spatiotemporal brightness changes occur, typically near moving edges and strong gradients.

The event-generation model used throughout the literature writes an event as $e=(x,y,t,p)$, with polarity $p\in\{+1,-1\}$, triggered when the change in log intensity $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$0 reaches a threshold $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$1. One common expression is

$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$2

This makes normal flow a particularly natural motion primitive for event cameras: it is locally measurable where events occur, but it does not claim to recover the full tangential component of motion.

Several papers formalize event-based normal flow through the time surface $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$3, which maps each pixel to its latest event time. In that formulation,

$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$4

so the spatial gradient of event timing provides both a direction and a scale for an observable motion proxy. Closely related geometric constraints recur across the literature. One form is

$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$5

while another is

$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$6

Both encode the same basic idea: a measured normal-flow vector constrains the true optical flow without requiring recovery of the tangential component (Ren et al., 2024, Yuan et al., 2024, Zhong et al., 24 Feb 2026).

2. Classical model-based estimation

Before learned estimators, event-based normal flow was typically obtained from local spatiotemporal structure. Two families dominate this stage of the literature. The first fits planes in $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$7–$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$8–$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$9 to local event clouds or time surfaces; the plane normal encodes local motion direction and speed along the gradient. The second estimates spatiotemporal gradients of timestamps or time surfaces, often called lifetime methods. Both rely on small neighborhoods and locally straight-edge assumptions, and both degrade with curved edges, corners, mixed motions, sparsity, latency, and sensor noise (Yuan et al., 2024).

A representative formulation is the PCA-based estimator for event optical flow used in visual odometry. In that approach, events in a local neighborhood are centralized in $v_n=u\cdot n_{\mathrm{grad}}$0, a covariance matrix is formed, and the eigenvector of smallest eigenvalue is treated as the plane normal. If that eigenvector is $v_n=u\cdot n_{\mathrm{grad}}$1, the estimated per-event flow is

$v_n=u\cdot n_{\mathrm{grad}}$2

which is exactly the minimum-norm solution aligned with the spatial part of the plane normal, i.e. the event-based normal flow. The same geometry yields an event lifetime estimate

$v_n=u\cdot n_{\mathrm{grad}}$3

That PCA work also examined two regularization strategies: multi-level neighborhood aggregation and time-weighted smoothing. On the reported translation sequence, PCA only achieved AEPE $v_n=u\cdot n_{\mathrm{grad}}$4 and AAE $v_n=u\cdot n_{\mathrm{grad}}$5; PCA + weights achieved AEPE $v_n=u\cdot n_{\mathrm{grad}}$6 and AAE $v_n=u\cdot n_{\mathrm{grad}}$7; PCA + levels achieved AEPE $v_n=u\cdot n_{\mathrm{grad}}$8 and AAE $v_n=u\cdot n_{\mathrm{grad}}$9. On the rotation sequence, PCA only achieved AEPE $I_xu_x+I_yu_y+I_t=0$0 and AAE $I_xu_x+I_yu_y+I_t=0$1, while PCA + levels achieved AEPE $I_xu_x+I_yu_y+I_t=0$2. The same paper reported computation times of $I_xu_x+I_yu_y+I_t=0$3/event for PCA only, $I_xu_x+I_yu_y+I_t=0$4/event for PCA + weights, and $I_xu_x+I_yu_y+I_t=0$5/event for PCA + levels, compared with $I_xu_x+I_yu_y+I_t=0$6/event for local plane fitting and $I_xu_x+I_yu_y+I_t=0$7/event for Lucas–Kanade (Khairallah et al., 2021).

These methods established that event streams naturally support local normal-flow estimation. They also clarified a persistent misconception: the reliable quantity in many local event neighborhoods is not full optical flow but its normal component.

3. Learned per-event normal flow from raw event neighborhoods

A major shift occurred with supervised point-based learning directly on local event neighborhoods. In "Learning Normal Flow Directly From Event Neighborhoods" (Yuan et al., 2024), the input for each event $I_xu_x+I_yu_y+I_t=0$8 is a centered local neighborhood treated as a point cloud in $I_xu_x+I_yu_y+I_t=0$9: $v_n=-I_t/\|\nabla I\|$0 The method omits polarity because it did not improve accuracy. Events are undistorted and mapped into normalized camera coordinates, and both training and inference are performed exclusively in these coordinates to improve cross-camera transferability.

The encoder is VecKM, described as a scalable local point-cloud geometry encoder that eliminates explicit grouping and sampling and uses all neighbors. With normalized points $v_n=-I_t/\|\nabla I\|$1, it computes a complex local encoding

$v_n=-I_t/\|\nabla I\|$2

with $v_n=-I_t/\|\nabla I\|$3, sparse adjacency $v_n=-I_t/\|\nabla I\|$4, and $v_n=-I_t/\|\nabla I\|$5. Each event encoding is then passed through a complex-feature MLP to output a $v_n=-I_t/\|\nabla I\|$6D normal-flow vector. Supervision uses per-event optical flow interpolated from frame-based forward and backward flow and converted into undistorted normalized camera coordinates. The training sets are MVSEC, EVIMO2, and DSEC, with models trained both per dataset and on the union $v_n=-I_t/\|\nabla I\|$7.

Because per-event ground-truth normal flow is unavailable, the paper introduces a motion-field loss that supervises with optical flow while inducing normal-flow predictions. For ground-truth optical flow $v_n=-I_t/\|\nabla I\|$8 and predicted normal flow $v_n=-I_t/\|\nabla I\|$9, the loss consists of a radial term and an angular term: $\|\nabla I\|\neq 0$0

$\|\nabla I\|\neq 0$1

with $\|\nabla I\|\neq 0$2. The paper states that the gradients of the two terms are orthogonal, so they do not interfere. Empirically, the network predicts full optical flow in textured corners and normal flow along strong edges.

The same formulation supports geometric augmentation that is difficult for many frame-based CNN pipelines: random rotation with $\|\nabla I\|\neq 0$3, random scaling with $\|\nabla I\|\neq 0$4, and random sampling retaining $\|\nabla I\|\neq 0$5–$\|\nabla I\|\neq 0$6 of events. Uncertainty is estimated by exploiting rotation equivariance: predictions from $\|\nabla I\|\neq 0$7 rotated inputs are de-rotated, combined by circular mean, and filtered by circular standard deviation. A typical uncertainty threshold is $\|\nabla I\|\neq 0$8, and $\|\nabla I\|\neq 0$9–$E=\{(x,y,t,p)\}$0 ensembles suffice for stable estimates.

Evaluation uses Projection Endpoint Error (PEE) and percentage of sign correctness (\%Pos). On EVIMO2-imo, averaged over eight scenes, the learned method trained on EVIMO2 achieved $E=\{(x,y,t,p)\}$1 and $E=\{(x,y,t,p)\}$2, compared with $E=\{(x,y,t,p)\}$3 and $E=\{(x,y,t,p)\}$4 for E-RAFT trained on DSEC, and $E=\{(x,y,t,p)\}$5 and $E=\{(x,y,t,p)\}$6 for TCM trained on DSEC. On MVSEC, averaged over four sequences, the union-trained model achieved $E=\{(x,y,t,p)\}$7 and $E=\{(x,y,t,p)\}$8, while TCM achieved $E=\{(x,y,t,p)\}$9 and $2$0, and E-RAFT achieved $2$1 and $2$2. The MVSEC result is explicitly interpreted in the paper: MVSEC contains mostly slow, static scenes, so frame-based methods with large receptive fields can produce smoother flow magnitudes and hence lower PEE, but their $2$3 is lower and they degrade with independently moving objects. An ablation on EVIMO2-imo reported that the motion-field loss reduced average PEE from $2$4 to $2$5 and improved $2$6 from $2$7 to $2$8 (Yuan et al., 2024).

4. Geometric solvers for motion, structure, and egomotion

Event-based normal flow has also been used directly as a geometric measurement for camera motion and scene structure. For a calibrated pinhole camera in normalized coordinates, the rigid-motion optical flow is written

$2$9

with

$e=(x,y,t,p)$0

"Motion and Structure from Event-based Normal Flow" (Ren et al., 2024) substitutes normal-flow constraints directly into this motion field and defines a geometric error

$e=(x,y,t,p)$1

This supports a family of problems: pure rotation, $e=(x,y,t,p)$2-DoF motion with known depth, structure-only estimation given motion, optical-flow recovery given motion, and planar-scene differential homography estimation. The paper develops both a fast linear solver and a continuous-time nonlinear solver using cubic B-splines, with the latter explicitly designed to avoid the constant-motion assumption. On mountain_normal, the reported runtime was $e=(x,y,t,p)$3 ms for $e=(x,y,t,p)$4 normal-flow vectors, $e=(x,y,t,p)$5 ms for the linear solver, and $e=(x,y,t,p)$6 ms for the continuous-time solver. In pure rotation benchmarks, the linear solver outperformed contrast-maximization baselines on several sequences, for example reducing RMSE on ground_rotation from $e=(x,y,t,p)$7 to $e=(x,y,t,p)$8 deg/s and on patterns_rotation from $e=(x,y,t,p)$9 to $p\in\{+1,-1\}$0 deg/s.

The learned-normal-flow work also proposed an IMU-assisted egomotion solver based on a maximum-margin formulation. With IMU angular velocity $p\in\{+1,-1\}$1, the rotational optical flow at normalized coordinate $p\in\{+1,-1\}$2 is $p\in\{+1,-1\}$3. If $p\in\{+1,-1\}$4 is the unit predicted normal-flow direction and $p\in\{+1,-1\}$5 its magnitude, the derotated normal-flow magnitude is

$p\in\{+1,-1\}$6

The translational contribution obeys

$p\in\{+1,-1\}$7

Depth positivity then implies

$p\in\{+1,-1\}$8

so the signs of $p\in\{+1,-1\}$9 must match the signs of $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$00. The paper casts this as a linear SVM classification problem without intercept, using features $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$01 and labels $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$02, and then normalizes the resulting $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$03. On EVIMO2-sfm, the paper reports lower RMS translation error than a baseline that maximizes negative depth; on sfm 03_04_0, RMS $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$04 was reduced from $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$05 to $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$06 m/s (Yuan et al., 2024).

A related 2025 framework combined learned normal flow, planar background modeling, residual analysis, IMU derotation, and hierarchical clustering for motion segmentation and translational egomotion. That system models background normal flow by least squares, refines translation with derotated normal flow, and uses per-cluster Tikhonov-regularized solves for motion similarity. On EVIMO2v2 it reported IoU values of $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$07 on 13-00, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$08 on 13-05, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$09 on 14-03, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$10 on 14-04, and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$11 on 14-05. Translational RMSEs were $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$12, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$13, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$14 m/s on 13-05; $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$15, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$16, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$17 m/s on 14-03; and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$18, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$19, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$20 m/s on 14-04 (Hua et al., 19 Jul 2025).

5. Motion segmentation with normal flow as an intermediate representation

The most explicit downstream use of event-based normal flow to date is real-time motion segmentation. "Real-time Motion Segmentation with Event-based Normal Flow" (Zhong et al., 24 Feb 2026) treats dense normal flow, produced by VecKM_Flow, as an intermediate motion representation that compresses raw event data into a more tractable geometric signal. The segmentation problem is formulated as a multi-label MRF energy with data, Potts smoothness, and label-cost terms: $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$21 The data term uses the normal-flow constraint

$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$22

squared over all samples assigned to model $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$23. Motion models are $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$24-parameter $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$25D affine transformations with $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$26. Spatial adjacency is built by Delaunay triangulation, and labeling is solved by $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$27-expansion graph cuts because the Potts term is metric and submodular.

A key contribution is candidate-model reduction. Instead of the $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$28-candidate initialization used by EMSGC, the method uses normal-flow-driven initialization and motion prediction, with $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$29 sampled candidates when prediction is available and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$30 otherwise. Model fitting combines linear least squares for fast initialization with nonlinear least squares via Levenberg–Marquardt for accuracy. The reported runtime on an Intel Core i7-14700k was $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$31 ms for preprocessing, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$32 ms for initialization, and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$33 ms for labeling and fitting, for a segmentation subtotal of $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$34 ms versus $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$35 ms for EMSGC under identical setup. The paper therefore reports real-time operation at approximately $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$36–$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$37 Hz and nearly $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$38 speedup over EMSGC.

Accuracy results indicate that this efficiency does not come from discarding the normal-flow geometry. On EED, the reported detection rates were $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$39 for Fast drone, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$40 for Lighting variation, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$41 for Occlusions, and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$42 for What is background, with an average of $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$43, compared with $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$44 average for EMSGC. On EVIMO, IoU was $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$45 for box and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$46 for table, with $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$47 average, versus $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$48, $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$49, and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$50 for EMSGC. The paper attributes the lower absolute IoU values partly to timestamp misalignment and sparser outputs due to downsampling and shorter windows (Zhong et al., 24 Feb 2026).

The alternative segmentation-and-egomotion framework in (Hua et al., 19 Jul 2025) adopts a different strategy: K-means over features $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$51 with $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$52 and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$53, followed by residual-based foreground–background segregation, temporal background warping, IMU-based derotation, and hierarchical cluster merging with residual coherence. Taken together, these two systems suggest that normal flow can support both graph-cut segmentation with affine motion models and residual-driven segmentation with explicit background motion reasoning.

6. Real-time implementations, limitations, and open directions

The main computational bottleneck in the original learned estimator was neighborhood encoding through adjacency multiplication, which has quadratic time complexity in the number of events. "A Real-Time Event-Based Normal Flow Estimator" (Yuan et al., 28 Apr 2025) preserves the same overall algorithmic structure as the earlier learning method but exploits the fact that event coordinates are integers. It reformulates neighborhood encoding as a pooling operation over per-pixel accumulations of temporal random Fourier features, replacing $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$54 with an adjacency-free discrete pooling operator. The resulting complexity is near-linear: $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$55 rather than quadratic in the slice size. The implementation reports a CUDA memory footprint of about $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$56 GB, end-to-end rates of $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$57 million normal flows/s on an RTX 3070 and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$58 million/s on an RTX A5000, accumulation rates of $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$59 M events/s and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$60 M events/s respectively, and pooling rates of $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$61 M flows/s and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$62 M flows/s for $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$63. On EVIMO2-imo, despite using $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$64 rather than $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$65 and omitting the uncertainty module, it still reported PEE values approximately $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$66–$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$67 and $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$68 approximately $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$69–$n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$70 for most scenes.

The limitations reported across the literature are consistent. Normal flow is intrinsically incomplete: it does not recover the tangential component of optical flow, so downstream tasks that require full motion must introduce additional constraints, multiple orientations, depth, motion models, or inertial sensing. Very low edge activity, textureless regions, extreme sparsity, heavy noise, and strong illumination changes degrade normal-flow reliability. Model-based methods are sensitive to window size, plane assumptions, and outliers. Learned methods depend on ground-truth optical flow for supervision, and their computational cost grows with event rate and resolution. Motion-segmentation pipelines inherit additional assumptions such as affine $n_{\mathrm{grad}}=\nabla I/\|\nabla I\|$71D motion, planar background structure, piecewise rigidity, or reliable temporal prediction (Yuan et al., 2024, Yuan et al., 28 Apr 2025, Zhong et al., 24 Feb 2026, Hua et al., 19 Jul 2025).

The future directions stated in these works are correspondingly concrete. They include self-supervised normal-flow training; optimization of VecKM and complex-MLP implementations; sparse batching; joint estimation of normal flow and uncertainty; multi-scale flow features or learned priors for segmentation; full optical-flow recovery by fusing normal flow across orientations or combining pooling encoders with cost-volume networks; spiking or neuromorphic implementations; adaptive pooling kernels; multi-plane background models; robust global motion fitting; and learning-based boundary refinement. A plausible implication is that event-based normal flow is becoming a stable intermediate representation rather than a narrow substitute for dense optical flow: it is local, asynchronous, and edge-aligned, yet now accurate enough to support transfer across cameras, real-time inference, geometric solvers, and dynamic-scene segmentation.