OMPilot: Imaging & Code Translation Suite

• OMPilot is a dual-purpose open-source system combining real-time deskewing and visualization in oblique plane microscopy with a transformer-based model for automated C++ to OpenMP translation.
• The microscopy module delivers GPU-accelerated, on-the-fly geometric correction and rapid projection techniques that enhance live imaging performance and region-of-interest navigation.
• The code translation component employs a domain-specific transformer with specialized training objectives and the OMPBLEU metric to ensure accurate, performance-optimized parallel code generation.

OMPilot is the designation of two distinct but technically significant open-source systems in contemporary research: (1) a real-time volumetric microscopy software suite for deskewing and visualization in oblique plane microscopy (OPM) (Lamb et al., 2022), and (2) a domain-specific transformer-based code translation model for automatic C++ to OpenMP parallelization, paired with a specialized evaluation metric (OMPBLEU) (Bhattacharjee et al., 5 Nov 2025). These systems address different computational fields—biomedical imaging and high-performance code translation/parallelization—sharing the OMPilot nomenclature due to their focus on optimization within their domains.

1. Real-Time Deskewing and Live Viewing in Oblique Plane Microscopy

OMPilot, in the context of light-sheet microscopy, is an open-source Python package designed for on-the-fly deskewing and interactive visualization of volumetric data acquired from OPM and its variants (Lamb et al., 2022). OPM employs an angled light-sheet excitation geometry, resulting in image stacks sheared relative to sample space. This introduces challenges for biological imaging, particularly for real-time region-of-interest localization and navigation.

The software inserts a transformation pipeline between the camera and user display:

• Deskewing: Each acquired slice is geometrically remapped to correct the lateral shear, governed by the excitation angle $\alpha$ and axial position $z$, via

$$x_d = x_r + z_r \cos\alpha,\, y_d = y_r,\, z_d = z_r$$

with index-space equivalents utilizing slice index $k$, pixel size $p_x$, and step $\Delta z$.

• Projection and Display: Following deskewing, volumetric data are summarized for fast visual feedback (e.g., maximum-intensity projection, MIP), mimicking standard widefield microscopy experiences.
• Update Modes: Two paradigms are supported—global-update (projection after stack completion, for high-speed scans), and rolling-update (projection after every slice, for slow or long-exposure imaging).

The underlying pipeline is GPU-accelerated (CUDA via CuPy/PyTorch/TensorFlow) and multiprocessing-enabled. Acquisition (via PycroManager), deskewing/projection (one process per channel), and GUI rendering (PyQtGraph/VisPy) execute as intercommunicating processes, sharing data over fast queues and GPU buffers.

2. Mathematical and Computational Foundation of Live Deskewing

Deskewing corrects the spatial distortion produced by oblique slice acquisition. For a slice indexed by $k$ at position $z_r = k \Delta z$, every raw voxel is remapped:

• Shearing transform: $x_d = x_r + z_r \cos\alpha$
• Pixel mapping: $i_d = i_r + k\,\frac{\Delta z}{p_x}\cos\alpha$, $j_d = j_r$, $k_d = k$

Composite visualization leverages the shear–warp principle: a variable shear factor $s$ and subsequent 2D warp simulates arbitrary projection angles efficiently, without explicit 3D rotation. This enables interactive navigation across the dataset.

Modes include basic and multichannel support, interpolation orders up to tricubic, and several projection types (MIP, average, sum). The pipeline architecture ensures frame-limited latency; CPU–GPU data transfer overlaps with acquisition, and GUI update rates match or nearly match camera rates even under high data throughput.

3. Software Architecture, Performance Benchmarks, and User Interface

The OMPilot suite is modular:

• Core modules: omp_acquire.py, omp_process.py, omp_gui.py, and omp_utils.py
• Principal classes: OMPilotController (acquisition/processing management), DeskewerWorker (GPU operations), LiveViewer (real-time display)

Configuration is available for all acquisition and processing parameters, including region-of-interest (ROI), exposure/stack settings, deskew angle $\alpha$ (adjustable in real time), and projection characteristics.

Performance on hardware (AMD Ryzen 9 5900X, NVIDIA RTX 3060) achieves up to 12.5 volumes/second for modest ROIs, sustaining several Hz for full camera fields (e.g., 3652×1304 px, 50 slices). System latency remains below camera cycle time unless display size exceeds 6 MP, where rendering bottlenecks become significant.

GUI features include live display, control sliders, mode selectors, multichannel toggles, live histograms, contrast tools, and on-the-fly snapshot/record functions. Calibration/validation protocols use fiducial stacks and ground-truth affine standards to confirm geometric accuracy (<1 pixel error full-FOV).

4. Transformer-Based C++–OpenMP Translation: OMPilot Model Design

OMPilot as a code translation tool denotes a domain-specific encoder–decoder transformer (12x12 layers/heads, 0.8B parameters) for automatic C++ to OpenMP source-to-source rewriting (Bhattacharjee et al., 5 Nov 2025). It leverages a BPE tokenizer (from UniXcoder), GeLU activations, and is trained/fine-tuned specifically on C++ and OpenMP corpora.

Custom pre-training objectives infuse explicit awareness of parallel programming semantics:

• Masked Language Modeling (MLM): Focuses on both OpenMP and C++ tokens.
• Syntax Structure Annotation (SSA): AST-based tag prediction, using Tree-sitter to provide up to 70 fine-grained structural labels (e.g., “loop_index”, “clause_identifier”).
• Denoising Autoencoding (DAE): Trains robustness via corruption and reconstruction under noise/perturbation regimes.
• Weighted Token Cross-Entropy Loss: Weights OpenMP constructs 5× more heavily in loss computation, ensuring accurate generation of pragmas and clauses.
• Back Translation: Employs C++↔OpenMP direction alternation to generate pseudo-paired samples, improving rare construct coverage.
• Progressive Fine-Tuning: Stages training from simple to complex directive usage, further optimizing for correct clause emission.

Training utilizes GPU clusters (4×A100 80GB, ~114 wall hours) and is conducted on high-quality, code-classified datasets encompassing 149,696 OpenMP and the same number of C++ functions.

The translator ingests entire C++ functions (≤512 tokens), processes them with AST tags, and emits C++ with embedded OpenMP parallelization, supporting both loop-level and block-level constructs.

5. OMPBLEU Metric for Parallel Code Evaluation

OMPBLEU is a multi-factor metric designed to address inadequacies in conventional code translation metrics (BLEU, CodeBLEU), which inadequately encapsulate pragma placement, variable list accuracy, and compilability.

OMPBLEU computes a weighted sum of eight sub-scores:

• Weighted Clause Importance (WC) measures recall of pragmas/clauses, prioritizing critical ones (reduction, collapse).
• Variable Usage Consistency (VU) quantifies correct mapping of private/shared/reduction variables per clause type.
• Integrated Semantic Similarity (IS) blends Levenshtein and embedding-based similarity.
• Ordering/Nesting (OR) assesses the placement and context of directives.
• Redundancy/Coverage (RC) rewards clause completeness and lack of over-specification.
• Cyclomatic Complexity (CC) penalizes semantic alterations to parallel regions.
• Pragma Location (PL) assesses AST attachment correctness.
• Compilation (C) ensures that output is syntactically valid and compilable under Clang.

OMPBLEU's explicit inclusion of clause-level accuracy, semantic variables, pragma registry, and compilation status enables more faithful measurement of functional and performance-preserving translation compared to n-gram/syntax metrics.

6. Empirical Performance in Automatic Parallelization

OMPilot demonstrates state-of-the-art or near-state-of-the-art metrics in function-level C++ to OpenMP rewriting:

• Model-level (Score@5): BLEU 94.38, CodeBLEU 87.93, OMPBLEU 79.17, top speedup 12.3× on the XSBench benchmark (32 threads), outperforming baseline code LLMs such as o3-mini, Qwen2.5, and specialized OpenMP tools in accuracy and parallel speedup.
• Clause classification: F1 score 0.65, compared to 0.417 for o3-mini.
• Ablation analysis: Weighted loss reduces OMPBLEU by 14.28 when omitted, MLM omission leads to a significant drop (from 79.17 to 11.49).

Inference is lightweight (0.8B params, 3.24GB binary, 28× speedup versus large LLMs), requires no natural-language prompts, and supports a broad range of OpenMP directives (70+ clauses).

7. Limitations and Prospective Extensions

OMPilot’s microscopy suite is constrained by available GPU/CPU bandwidth (performance scaling bottlenecked by display at very high resolutions) and assumes accurate calibration/fiducial data for transform validation (Lamb et al., 2022).

The transformer-based code translation model is constrained by the need for high-quality, expert-annotated ground truth, and its focus on shared-memory OpenMP. It lacks comprehensive static or dynamic dependency checking, does not extend to distributed systems (MPI), or direct support for heterogeneous or GPU-targeted acceleration. Future work proposes adaptation towards MPI, CUDA, more advanced dataflow analysis, and extending to broader interprocedural/cross-function contexts (Bhattacharjee et al., 5 Nov 2025).