EvTexture++ for Event-Driven Texture Enhancement

• EvTexture++ is an event-driven framework that uses high-frequency spatiotemporal details from event signals to enhance texture recovery in video super-resolution.
• It employs a dual-branch design with an iterative texture enhancement module and motion alignment to improve both intra-frame detail and inter-frame consistency.
• Empirical results show state-of-the-art performance on texture-rich datasets like Vid4, with notable gains in PSNR and reduced texture flickering.

Searching arXiv for EvTexture++ and closely related VSR/event-based papers to ground the article with citations. arxiv_search query="EvTexture++ Event-Driven Texture Enhancement for Video Super-Resolution" max_results=5 sort_by="submittedDate" sort_order="descending" EvTexture++ is an event-driven framework for video super-resolution (VSR) that shifts the role of event signals from motion refinement to texture enhancement. Introduced in the paper "EvTexture++: Event-Driven Texture Enhancement for Video Super-Resolution" (Kai et al., 11 Jun 2026), it is described as the first event-driven framework dedicated to texture enhancement in VSR. The method leverages high-frequency spatiotemporal details from events to improve texture recovery, combines a customized texture enhancement branch with an iterative texture enhancement module, and further introduces temporal texture alignment to reduce texture flickering under large motion. It is also designed as a plug-and-play tool for existing VSR models, and experiments on five datasets report state-of-the-art performance, including gains of up to $1.55$ dB in PSNR on the texture-rich Vid4 dataset (Kai et al., 11 Jun 2026).

1. Conceptual positioning within event-based VSR

Event-based vision has drawn increasing attention because of ultra-high temporal resolution and extreme dynamic range. In prior VSR work, event signals were introduced to enhance flow estimation and temporal alignment. EvTexture++ departs from that emphasis and treats events primarily as a source of high-frequency spatiotemporal detail for texture recovery (Kai et al., 11 Jun 2026).

This reframing is central to the method’s identity. Rather than using events only to support motion compensation, EvTexture++ targets both intra-frame texture recovery and inter-frame temporal consistency in texture regions. The paper explicitly associates large motions with degradation in inter-frame temporal consistency, particularly in texture regions, and identifies texture flickering as a consequence. Its response is a two-branch design in which one branch focuses on texture enhancement and the other on motion alignment (Kai et al., 11 Jun 2026).

A common misconception in event-based VSR is that the principal utility of event streams lies in motion cues alone. EvTexture++ directly contests that assumption by assigning texture restoration a first-order role. This suggests a broader interpretation of event data in VSR pipelines: asynchronous measurements may be useful not only for correspondence estimation but also for recovering fine-grained visual structure.

2. Pipeline design and plug-and-play integration

EvTexture++ builds on a bidirectional recurrent backbone, with BasicVSR given as an example. At each timestep, the pipeline splits into two parallel branches: a texture-enhancement branch that uses events to inject high-frequency detail, and a motion branch that uses both events and RGB frames to improve inter-frame alignment. The outputs of the two branches are fused; one copy is propagated to the next timestep, while another is upsampled through pixel-shuffle together with a bicubic residual to form the final super-resolved frame (Kai et al., 11 Jun 2026).

In plug-and-play mode, the method is inserted between a frozen VSR backbone and its upsampler. For each frame, three quantities are extracted from the pretrained backbone: “before-propagation” features $\{f_t^{bp}\}$, “after-propagation” features $\{f_t^{ap}\}$, and RGB-based optical flows $\{O^r_{t\leftrightarrow t+1}\}$. EvTexture++ then applies its two-branch structure to refine $f_t^{ap}$. The texture branch uses Iterative Texture Enhancement (ITE),

$$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$

while the motion branch reuses alignment through

$$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$

These are fused to form $f_{t+1}^M$, and the fused texture and motion features are then fed into the backbone’s upsampler. In this scheme, the pretrained backbone remains $100\%$ frozen, and only EvTexture++ plus the upsampler are trained (Kai et al., 11 Jun 2026).

The method can therefore operate in two regimes: as a standalone architecture built around a bidirectional recurrent backbone, or as a module that augments an existing VSR system without retraining the backbone itself. A plausible implication is that the method is intended not only as a new VSR model, but also as an interface layer for transferring event-based texture enhancement into established RGB VSR pipelines.

Component	Inputs	Role
Texture-enhancement branch	Propagated feature, events, LR frame	Inject high-frequency detail
Motion branch	Events and RGB frames	Improve inter-frame alignment
Fusion and upsampling	Texture feature, motion feature, backward feature, LR frame	Produce final SR frame

3. Event representation and the texture-enhancement branch

The event stream is represented as $E=\{(x_k,y_k,t_k,p_k)\}$ and discretized into an Event Voxel Grid with $\{f_t^{bp}\}$0 temporal bins: $\{f_t^{bp}\}$1 followed by clamping and normalization,

$\{f_t^{bp}\}$2

where $\{f_t^{bp}\}$3 is the $\{f_t^{bp}\}$4th percentile of non-zero $\{f_t^{bp}\}$5. The final voxel grid is denoted by $\{f_t^{bp}\}$6 (Kai et al., 11 Jun 2026).

At frame $\{f_t^{bp}\}$7, the texture branch is written as

$\{f_t^{bp}\}$8

where $\{f_t^{bp}\}$9 is the ITE module and $\{f_t^{ap}\}$0 is the propagated feature from $\{f_t^{ap}\}$1. The branch extracts a context feature and per-bin event features through

$\{f_t^{ap}\}$2

with $\{f_t^{ap}\}$3 defined as an 8-block ESRGAN-style ResNet producing $\{f_t^{ap}\}$4, and $\{f_t^{ap}\}$5 defined as a 5-layer U-Net producing $\{f_t^{ap}\}$6 (Kai et al., 11 Jun 2026).

This branch is designed to expose the model to temporally localized event evidence before final fusion. Because the voxel bins retain a time-ordered decomposition of the asynchronous stream, the branch is organized to exploit the event sequence progressively rather than as a single collapsed descriptor. That design choice becomes explicit in the ITE module.

4. Iterative Texture Enhancement as progressive refinement

The Iterative Texture Enhancement module processes the $\{f_t^{ap}\}$7 voxel bins sequentially in $\{f_t^{ap}\}$8 iterations, maintaining a hidden state $\{f_t^{ap}\}$9. Initialization is given by $\{O^r_{t\leftrightarrow t+1}\}$0 and $\{O^r_{t\leftrightarrow t+1}\}$1. At iteration $\{O^r_{t\leftrightarrow t+1}\}$2,

$\{O^r_{t\leftrightarrow t+1}\}$3

where $\{O^r_{t\leftrightarrow t+1}\}$4 is a ConvGRU shared across iterations and $\{O^r_{t\leftrightarrow t+1}\}$5 is five ESRGAN-style residual blocks. After $\{O^r_{t\leftrightarrow t+1}\}$6 iterations, the texture-enhanced feature is

$\{O^r_{t\leftrightarrow t+1}\}$7

The paper states that, by processing each temporal bin in turn, the module progressively injects high-frequency detail locked in the event stream into the feature map (Kai et al., 11 Jun 2026).

The significance of this formulation lies in its temporal granularity. Rather than treating event-derived texture cues as a static conditioning signal, the module uses a recurrent state to accumulate incremental residual corrections $\{O^r_{t\leftrightarrow t+1}\}$8. This suggests that texture recovery is modeled as an iterative reconstruction process synchronized with the temporal partition of the event voxel grid. In that sense, the ITE module is not merely feature fusion; it is a structured refinement mechanism designed to exploit the ultra-high temporal resolution of events.

5. Temporal texture alignment and feature fusion

To preserve temporal consistency and reduce flickering, EvTexture++ introduces a Temporal Texture Alignment (TTA) module with dual-stream event-guided alignment. Starting from $\{O^r_{t\leftrightarrow t+1}\}$9, the event-based motion-estimation and motion-compensation stream reverses the inter-frame events to form $f_t^{ap}$0, then computes

$f_t^{ap}$1

where $f_t^{ap}$2 is a U-Net predicting a “texture-aware” flow $f_t^{ap}$3. In parallel, the RGB-based stream uses SpyNet $f_t^{ap}$4: $f_t^{ap}$5 The two aligned features are concatenated and fused by a $f_t^{ap}$6 convolution: $f_t^{ap}$7 This yields the motion-branch output $f_t^{ap}$8 (Kai et al., 11 Jun 2026).

The full branch fusion stage also incorporates the backward-propagated feature $f_t^{ap}$9 and the low-resolution frame $$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$0. The fused representation is computed by

$$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$1

The paper specifies that this fusion is implemented with 15 residual blocks. The resulting feature $$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$2 is then upsampled by pixel-shuffle and added to a bicubic upsampling of $$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$3 to obtain $$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$4 (Kai et al., 11 Jun 2026).

The two alignment streams serve different roles. The event-based stream contributes continuous-time motion cues and a texture-aware flow, while the RGB-based stream provides a conventional optical-flow estimate. Their concatenation and $$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$5 fusion indicate that EvTexture++ does not replace RGB motion information with event motion information; it combines the two for precise inter-frame texture alignment. This is consistent with the paper’s claim that large motions can specifically destabilize texture regions.

6. Training protocol, reported results, and interpretation

In both standalone and plug-in settings, EvTexture++ is trained end-to-end with a single Charbonnier reconstruction loss over all frames: $$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$6 No separate texture-consistency or temporal-alignment losses are used; instead, the high-frequency event cues and the two-branch architecture are described as implicitly enforcing texture fidelity and stability (Kai et al., 11 Jun 2026).

The reported empirical results include several Vid4 measurements. In the standalone setting on Vid4 at $$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$7, EvTexture++ is reported to achieve $$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$8 dB/$$f_{t+1}^T \;=\;\mathrm{ITE}\bigl(f_t^{ap},\,f_t^{bp},\,E_{t\to t+1}\bigr),$$9 SSIM, versus IART’s $$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$0/$$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$1 SSIM. In the plug-in setting, adding EvTexture++ to IART boosts performance from $$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$2 dB to $$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$3 dB, approximately $$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$4 dB on Vid4. More broadly, on Vid4 at $$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$5, EvTexture++ obtains $$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$6 dB/$$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$7 SSIM, surpassing the previous state of the art, EvTexture, at $$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$8 dB/$$f_{t+1}^{M_1}=\mathcal W(f_t^{ap},\,O^e_{t+1\to t}),\quad f_{t+1}^{M_2}=\mathcal W(f_t^{ap},\,O^r_{t+1\to t}).$$9, by $f_{t+1}^M$0 dB. Temporal-consistency metrics on Vid4 at $f_{t+1}^M$1, specifically tOF $f_{t+1}^M$2 and TCC $f_{t+1}^M$3, are reported to confirm reduced flicker (Kai et al., 11 Jun 2026).

The qualitative observations recorded in the paper focus on rich high-frequency patterns, including building stripes, foliage, and text on license plates. These are described as being faithfully restored only by EvTexture++. Temporal profiles are also reported to be smoother and more flicker-free than those of both pure RGB and prior event-based methods (Kai et al., 11 Jun 2026).

Two clarifications follow from these results. First, EvTexture++ is not presented solely as a new standalone VSR architecture; it is also a pure plug-in that can lift a frozen VSR backbone with minimal extra cost. Second, its training objective remains unusually compact relative to the phenomena it targets: there is a single reconstruction loss, with no explicit temporal-consistency penalty. This suggests that the method’s contributions are concentrated in representation design and feature interaction rather than loss engineering.