[Paper] SynthPix: A lightspeed PIV images generator

Source: arXiv - 2512.09664v1

Overview

SynthPix is a high‑performance synthetic image generator for Particle Image Velocimetry (PIV) that runs on modern accelerators (GPU/TPU) via the JAX framework. By turning the traditionally slow, CPU‑bound simulation pipeline into a massively parallel, just‑in‑time compiled workflow, the authors achieve orders‑of‑magnitude speed‑ups in generating realistic PIV image pairs—making it feasible to feed data‑hungry machine‑learning pipelines and rapid‑iteration control loops.

Key Contributions

• Accelerator‑native implementation: Re‑writes the entire PIV rendering pipeline in JAX, leveraging XLA compilation for GPUs/TPUs.
• Throughput boost: Generates millions of image pairs per second, far surpassing existing tools (e.g., OpenPIV, PIVlab) that are limited to a few hundred per minute.
• Drop‑in compatibility: Supports the same configuration schema (particle density, illumination, camera optics, noise models, etc.) as legacy generators, easing adoption.
• Open‑source release: Provides a well‑documented Python package with examples, enabling immediate experimentation.
• Enabler for RL‑based flow estimation: Supplies the massive synthetic datasets required to train reinforcement‑learning agents that estimate fluid velocity fields in real time.

Methodology

1. Physics‑based rendering: The authors model particle seeding, advection, illumination, and imaging optics using deterministic equations (e.g., Gaussian point‑spread functions, motion blur).
2. JAX vectorization: All per‑particle operations are expressed as pure NumPy‑like functions, which JAX automatically batches across the device’s SIMD lanes.
3. Just‑in‑time compilation: When a new configuration is requested, JAX compiles a specialized XLA kernel, eliminating Python overhead and enabling fused memory accesses.
4. Parallel data pipeline: Image pairs are generated in a streaming fashion—each step (seed placement → advection → rendering) runs concurrently on the accelerator, while the host CPU handles I/O and dataset sharding.
5. Noise injection & camera models: Random number generators (also JAX‑compatible) add realistic sensor noise, quantization, and lens distortion, preserving fidelity to real‑world PIV setups.

The result is a single function call like:

synthpix.generate(params, batch_size)

that returns a NumPy array of synthetic image pairs ready for training or testing.

Results & Findings

The authors demonstrate that a reinforcement‑learning flow estimator trained on SynthPix data reaches within 5 % of the accuracy of a model trained on real experimental data, while cutting training time dramatically. They also show that a closed‑loop active‑flow control demo (real‑time PIV feedback) can iterate its estimator in sub‑second intervals thanks to the rapid synthetic data generation.

Practical Implications

• Accelerated ML pipelines: Teams building deep‑learning or RL models for flow estimation can now generate unlimited, on‑the‑fly training data without waiting for costly experiments.
• Real‑time control loops: Controllers that need to re‑train or fine‑tune their estimators during operation (e.g., UAVs navigating turbulent air) can do so with near‑instantaneous synthetic data refreshes.
• Cost reduction: Labs can cut down on expensive PIV hardware usage for algorithm development, relying on high‑fidelity synthetic data for early prototyping.
• Scalable cloud deployment: Because SynthPix runs on any JAX‑compatible accelerator, it can be packaged as a microservice in cloud environments, enabling on‑demand dataset generation for distributed teams.
• Cross‑disciplinary reuse: The same pipeline can be adapted for other imaging modalities (e.g., smoke visualization, particle tracking) by swapping the physics kernels, opening doors for broader computer‑vision research.

Limitations & Future Work

• Domain gap: Although visual similarity scores are high, subtle discrepancies (e.g., rare particle‑clustering phenomena) can still affect models trained exclusively on synthetic data.
• Hardware dependence: The massive speed‑up hinges on access to modern GPUs/TPUs; performance on older hardware degrades sharply.
• Extensibility to 3‑D PIV: Current implementation focuses on 2‑D image pairs; extending to volumetric PIV (stereoscopic setups) will require additional rendering kernels.
• User‑level customization: While the API mirrors existing tools, highly specialized optics or custom noise models may need deeper code changes.

Future releases aim to close the synthetic‑real gap via adversarial domain‑adaptation techniques, add native support for stereoscopic and tomographic PIV, and provide a plug‑in system for user‑defined particle physics.

Authors

• Antonio Terpin
• Alan Bonomi
• Francesco Banelli
• Raffaello D’Andrea

Paper Information

• arXiv ID: 2512.09664v1
• Categories: cs.DC, cs.CV, cs.LG, eess.IV
• Published: December 10, 2025
• PDF: Download PDF