Documents the ImageJ (1-based slice:timestamp), INTERFRAME.corr-xml
(timestamp_microseconds key), and COLMAP (0-based frame_NNNN) conventions
in the module docstring so any frame can be cross-referenced across tools.
Also clarifies the underscore→dot timestamp conversion in parse_interframe_xml.
Co-authored-by: Claude <claude@elphel.com>

Timestamps are unambiguous when using sub-sequences (e.g. 378 of 498
frames).  0-based sequential scene_idx was misleading.

- console top-N table: Scene column replaced with Timestamp
- CSV: scene_idx column removed, timestamp is the identity column
- parse_interframe_xml: drop scene_idx from returned dicts
Co-authored-by: Claude <claude@elphel.com>

*-egomotion.csv is a human-readable output file for Calc analysis, not
a machine input source.  *-INTERFRAME.corr-xml is the internal state
always present alongside processed data and is the correct programmatic
source for x/y/z/a/t/r poses.

- remove parse_egomotion_csv() and --ego argument
- --xml is now required
- remove IMS/PIMU col_specs (not in XML)
- rename CSV output columns: ego_* → xml_*, ers_*_rad → xml_*_rad
Co-authored-by: Claude <claude@elphel.com>

--ego (egomotion.csv) was required but is not always present (it is an
optional output file).  --xml (*-INTERFRAME.corr-xml) is always written
by the pipeline and contains the same x/y/z/a/t/r values.

Changes:
- add parse_interframe_xml(): sorts timestamps → same frame order as COLMAP
- --xml is the new preferred input; --ego is optional and overrides --xml
  (it additionally provides IMS/PIMU columns)
- at least one of --xml or --ego is required
- IMS/PIMU [SKIP] messages suppressed when using XML (NaN is expected)
- verified: XML and egomotion.csv produce identical results
Co-authored-by: Claude <claude@elphel.com>

CuasDnnInfer auto-detects reg from the ONNX output channels (6 = reg head
{det,Vx,Vy,logvar,dx,dy}, else grid) via getOutCh()/isReg(), and adds
inferROIReg() returning {S,Vx,Vy,sigma,dx,dy} per ROI pixel (S=sigmoid(det),
Vx/Vy model-bounded, sigma=exp(logvar/2)). CuasDetectRT branches: reg saves an
S-first {S,Vx,Vy,sigma} hyperstack (-VXYS) + -OFFSET (showArraysHyperstack,
channel x time x ROI), metadata-tagged; ghostbuster/grid renders/recurrent
skipped (no grid corners, |v|<=vmax baked in). Set curt_dnn_patch=32 for the
reg model; curt_dnn_vmax unused in reg mode.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

tagCuasImp() serializes every curt_* param (via IntersceneMatchParameters.setProperties,
so new params are auto-included) into the ImagePlus properties and calls
EyesisTiff.encodeProperiesToInfo -> XML in the "Info" field -> FileSaver writes it
to the TIFF ImageDescription. Applied to -DNN-RECT/-HYPER-RECT/-OFFSET. The python
reader (python3-imagej-tiff format) decodes it back, so outputs are self-describing;
ROI/model/patch/vmax/etc. restore without manual entry (supplements the filename tag).
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

The DNN save titles (-DNN-OFFSET / -HYPER-RECT / -RECT) now carry the ROI as
-ROI<x>_<y>_<w>_<h> (underscores to avoid scp/shell colon hazards) so the python
flight-log comparison can auto-restore the ROI per file instead of a hardcoded
constant - lets the real-UAS evaluation run hands-off across multiple ROIs.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

The CONV2D images are saved BEFORE synth injection (real-only), so the actual
DNN input (LoG-conditioned real bg + injected synth) was no longer visible once
the mixing order moved to post-conditioning. Add a per-selected-level save of
dpixels_pyramid right after injection: getBaseName()+"-SYNTHMIX"+("B" if over
real bg)+("-SUBAVG" if avg-subtracted)+"-LEVn", full-frame (640x512), same
timestamps - what the network actually sees. Gated by save_LoG_pixels.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

inferROI's receptive-field patch was hardcoded P=24. Add CuasDnnInfer.setPatch
and new param curt_dnn_patch (default 24) so a wider-attention model (patch 32)
can be deployed: CuasDetectRT sets it on the inferer. The 32-patch model widens
off-center suppression reach (off_max 9->13 px) and removes the trajectory-alias
ghosts seen in the clean synthetic grid (field ~0.16 -> ~0.003). Must match the
loaded model's training patch.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

The DNN velocity grid (radius vel_radius) extends past the trained velocity
disk, so untrained corner cells emit spurious sidelobes (ghosts) of non-trivial
strength (s up to ~0.09) that would confuse the recurrent layer. New
dnnGhostbust() zeros velocity cells with cell-radius > curt_dnn_vmax*vel_decimate,
and if a pixel's peak lands in the untrained corner it discards the whole
detection (field=0, s=0). Applied to the DNN field + offset before save and the
recurrent feed. New param curt_dnn_vmax (px/frame, default 1.4 = PM models'
training vmax_px; set to match the loaded model; <=0 disables).
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

curt_synth_bg was fully parsed/persisted in IntersceneMatchParameters
but never read by the detector: the synthetic grid was always ADDED on
top of the LoG-conditioned real pyramid, so "Synthetic over real
background = false" had no effect (real background noise, and any NaN
border pixels, always present). Now when curt_synth_bg=false the level
is zeroed before the synthetic targets are injected -> truly clean,
noise-free targets. Logs which path was taken.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Synthetic mode previously force-overrode the ROI with the full-grid
SYNTH_ROI (320x320). showConvKernel5d expands each ROI pixel by
(vout_dim+1)*sub_dim per axis, so 320x320 blows the heap. Now synthetic
mode uses curt_save_select directly and falls back to SYNTH_ROI only
when no ROI is set, so the user can shrink it to a slice of the grid.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

CuasDnnInfer reads N (temporal frame count) from the model's input
shape [B,N,H,W] and exposes getNFrames(); the constructor arg is now
only a fallback hint. CuasDetectRT uses dnn.getNFrames() instead of the
hardcoded 8, so an 8- vs 9-frame ONNX swaps purely by changing
curt_dnn_model (N follows automatically).
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

- curt_subtract_avg (+ -SUBAVG filename tag): subtract the input per-pixel temporal
  mean before LoG. Removes the static treeline edge (and so its 8px tile-grid
  horizontal streak and the first-LReLU amplification of it); the moving target is
  not in the average, so it survives. Uses the whole sequence (not realtime; realtime
  would use a prior-run average).
- DNN compute-window: the timing ROI (curt_time_from/to) now gates the DNN inference
  loop (only in-window scenes are inferred), not just the saved output - fast iteration
  on a target's few seconds.
- DNN -> recurrent layer: feed the DNN field to runRecurrentLevel (per selected level,
  curt_recur_*). curt_dnn_recur_splat toggles feed-as-is vs bilinear splat of each
  pixel's velocity vector to its fractional (px+dx,py+dy) so neighbours reinforce in one
  sub-pixel bin (-SPLAT mark). curt_dnn_recur_scale (default 10) lifts the [0,1] field
  (peaks ~0.1) to the recurrent's tuned rs_min~1.0 scale. splatField() helper added.
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

CLAUDE: CUAS-RT overhaul - real-base synthetic-grid injection, level/time ROIs, 3d3 bypass, DNN offset/stride/window

Reworks the synthetic B-measurement and detector flow on the real pyramid base:

- Load: the real -CUAS-MERGED-CUAS stack is always the pyramid base (full-length
  levels); when curt_synth_src, the synthetic grid is loaded separately (scaled,
  NOT LoG'd) and injected TILED into each selected pyramid level AFTER the pure
  pyramid is built - same grid at every level, real noise averaged (sqrt(2)/level,
  printed). Both file picks use newestFile(). The old load-time mixing and the
  curt_synth_bg_avg (N=) decimation are retired.
- Level selection unified on curt_c5_levels for ALL heavy paths (3d3/conv5d,
  C5P-direct, DNN); cheap temporalAverage pyramid still builds up to the max
  selected level. Pyramid-depth guard stops building when a level would have <1
  frame (was NegativeArraySizeException on short sequences).
- Timing ROI curt_time_from/to (timestamp seconds; last-4-of-seconds shortcut,
  rollover-aware, 3-decimal fixed display) clips saved RECT/HYPER/DNN/C5P stacks
  and gates the DNN inference (compute-window, not just save).
- curt_3d3_en (default false) bypasses the 3d3 coarse-velocity path and its
  ~W*H*9 arrays. Full-velocities hyperstack render is guarded by a free-heap
  estimate (it is also an unfilled stub) and skipped if it would not fit.
- DNN: curt_dnn_stride (1 testing / 4 production 50%-overlap), and -DNN-OFFSET
  visualization (dx, dy, s over the ROI) from the offset channels.
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

CuasRTUtils.getNumVout()/getSubDim() expose the 5D render dimensions for the
full-velocity-hyperstack memory estimate. CuasDnnInfer adds an inferROI(...,
double[][] offOut) overload that also returns the two offset channels
{dx, dy, s} per pixel (the DNN's per-pixel sub-pixel position estimate); the
existing 6-arg call delegates with offOut=null, so the field output is
unchanged. Both are prerequisites used by the CUAS-RT overhaul that follows.
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Prepend velocity index 0 = max over all velocities (per scene, per pixel) to
showConvKernel5dHyperRect, and scale the display range to that slice instead
of the fixed IMP_MINMAX, so the small (~0.1) maxima are visible on open. It is
the first slice ImageJ shows - a quick map of non-empty pixels before scanning
scenes (Z) and velocities (T). Applies to both -HYPER-RECT and -DNN-HYPER-RECT.
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

The bg_avg>1 path kept all n_synth frames and only added an averaged
background, so AVG4 and AVG8 produced the same frame count and 1/fps
timestamps. Now output frame i is the mean of bg_avg consecutive frames of
BOTH the scaled synthetic target AND the real background (non-overlapping
groups): the sequence is decimated by N (n_synth/N frames), the moving target
is motion-averaged like a real pyramid level, and each timestamp is the last
real frame of its group (N/fps increments).
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

When curt_dnn_model is set, run the ONNX DNN per-pixel inference over
curt_save_select across all available scenes (not just the first few),
saving -DNN-RECT / -DNN-HYPER-RECT. Slice labels carry timestamp + absolute
frame index for matching to real targets. New curt_dnn_thresh (6 sites in
IntersceneMatchParameters) zeroes the (Vx,Vy,s) field below confidence s -
display/FP-suppression only. inferROI tiles the ROI batch (CHUNK) to bound
ONNX Runtime activation memory.
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

PyTorch-trained, ONNX-exported all-conv FCN (per-pixel Vx,Vy,s) run in Java via
ONNX Runtime 1.20.0 (CPU EP). CuasDnnInfer loads the model with a location resolver
(local path / scp user@host:path / http(s) -> ~/.cache/c5p_dnn/, fetching the
model.onnx + external-data .data pair) and runs a float[N][H][W] patch to raw
det/vel/off output. Verified bit-exact vs PyTorch (max abs diff 2.9e-6) via a fixed
test vector. New config param curt_dnn_model (empty default) selects the model,
mirroring the tile_processor_gpu kernel-source default/override scheme. CPU first
(.224 has no cuDNN; 82k net is microseconds/patch); GPU (CUDA/TensorRT EP) and the
CuasDetectRT integration are the next phase.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Per Andrey's continuity requirement: a sub-pixel target shift switching
between 1 and 2 surviving cells must not change the total injected energy
(filterConv5dROI does not conserve energy - it zeroes weaker components).

condition() now labels 4D-connected survivor clusters (3^4-1 connectivity,
BFS) and applies three regimes:
1. Single survivor: full 3x3x3x3 spread with fading peripherals (as before).
2. Compact cluster (2..curt_recur_max_clust near-equal survivors): spread
   limited along resolved dimensions; cluster total output = cluster max M,
   shared proportionally (survivor i contributes M*m_i/sum(m_j)) - exactly
   continuous across the 1<->2 survivor transition.
3. Cluster larger than curt_recur_max_clust (default 5): weak signal that
   passed the filter linearly - identity, no spreading/renormalization.

New parameter curt_recur_max_clust plumbed through dialog/properties/copy;
-RC<n> added to the -RECUR image titles.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Implements the recurrent 4D (px, py, vx, vy) accumulation buffer per the
2026-06-09 design (cuas_rt_gpu-internal CONTINUE.md, Step 4):

- Update rule: buf = leak*(1-w_eff)*shift(buf, v) + w_eff*conditioned(meas),
  applied every curt_recur_period (default 4) time units so the per-update
  pixel shift is integer-clean (1 px per minimum velocity step).
- shift(): each 4D point moves by its own velocity; predictions leaving the
  ROI are dropped.
- conditioned(): adaptive 4D spreading of filterConv5dROI survivors -
  dimensions spanned by adjacent survivors are "resolved" and not expanded;
  total spread weight per survivor is 1.
- w_eff: fixed curt_recur_w, or per-pixel adaptive w*tanh(strength/wthresh)
  when curt_recur_wthresh > 0 (dark frames then decay by curt_recur_leak
  alone - blind prediction).
- convolve3d() still runs at every time step with unchanged output files;
  the buffer consumes every curt_recur_period-th ROI output (level 0 only).
- New params (curt_recur_en/period/w/leak/wthresh/spread) plumbed through
  IntersceneMatchParameters (dialog, get/set, properties, copy).
- Buffer state snapshots saved as -RECUR-RECT and -RECUR-HYPER-RECT images.

Single-threaded over the ROI for now; optimization deferred by design.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Replace fixed ±1 pixel/velocity loops and indx_center_3d3/indx_margins_3d3
with configurable vel_suppr_rad loops and indx_center_vsupp/indx_margins_vsupp.
Co-authored-by: Claude <claude@elphel.com>

Suppress a point only when both conditions hold simultaneously:
  thresh = Math.max(athresh, M * rthresh)
  (M - val) >= thresh   →   zero the point

athresh enforces a minimum absolute gap; M*rthresh enforces a minimum
relative gap. Math.max means BOTH must be satisfied (either alone is
insufficient). Replaces the previous M>=athresh && val<rthresh*M logic.
Co-authored-by: Claude <claude@elphel.com>

CuasRTUtils: new filterConv5dROI(data, roi, athresh, rthresh)
  For each (pixel, velocity) point, finds max M over the ±1 neighbourhood
  in both pixel space (3×3) and velocity space (3×3 in vx/vy).
  Zeroes the point if M >= athresh AND val < rthresh*M (sidelobe suppression).
  Passes through unchanged when M < athresh (weak-signal linear regime).
  Uses indx_center_3d3 / indx_margins_3d3 for bit-reversed multithreaded
  pixel iteration; returns a new filtered array.

CuasDetectRT: apply filterConv5dROI() to dpixels_5d_roi_pyramid[level][n5d]
  after convolve3d(), controlled by curt_vel_thresh_en / curt_vel_athresh /
  curt_vel_rthresh, at level-0 and all pyramid levels.
Co-authored-by: Claude <claude@elphel.com>

CuasRTUtils: new showConvKernel5dHyperRect(data, roi, scene_titles, title)
  - ImageJ hyperstack [num_vout][num_scenes][roi_w*sub_dim × roi_h*sub_dim]
  - Bottom slider (T): 121 velocities labelled "+vy:+vx"
  - Second slider (Z): scenes
  - Sub-pixels spatially embedded (no NaN separator grid)

CuasDetectRT: add HYPER-RECT save immediately after each RECT save block
  (level-0 and pyramid loop), suffix "-HYPER-RECT" / "-LEV{n}-HYPER-RECT"
Co-authored-by: Claude <claude@elphel.com>

- CuasRTUtils: add convolve3d(data, Rectangle roi, result_in) that allocates
  only [roi.width*roi.height][nsub][nvel] instead of full [width*height][nsub][nvel],
  skips non-ROI pixels in center/margin loops, uses roi-relative indexing.
  Also fix showConvKernel5d(data, roi, ...) pixel_idx to use ROI-relative
  (py_roi*roi.width+px_roi) instead of full-image indexing.

- CuasDetectRT: add dpixels_5d_roi_pyramid alongside dpixels_5d_pyramid.
  Level-0 and pyramid loop 5D blocks now call convolve3d(window, null) only
  when curt_save_c5full, and convolve3d(window, curt_save_select, null) only
  when curt_save_c5rect. RECT save blocks now read from dpixels_5d_roi_pyramid.
  Eliminates the OutOfMemoryError when curt_save_c5full=false.
Co-authored-by: Claude <claude@elphel.com>

New CuasRTUtils.showConvKernel5d(data, roi, titles, title): renders the
vout_dim×vout_dim velocity map for each ROI pixel as a tiled flat image,
with a 1-px NaN separator grid between pixel blocks (visible in ImageJ).
Sub-pixels (pixel_decimate>1) tile within each block.

CuasDetectRT: add curt_save_c5rect save calls at level-0 and each pyramid
level (title suffix "-RECT", "-LEVn-RECT"). curt_save_c5full path unchanged.
Co-authored-by: Claude <claude@elphel.com>

Add convolve3d() (kernel5d) at level-0 before the temporal pyramid loop
and at each pyramid level nlev+1 inside the loop, mirroring the existing
3D3 coarse-velocity pattern. Output saved as CONV5D hyperstack when
debugLevel > -4. Add getNumHist() getter to CuasRTUtils.
Co-authored-by: Claude <claude@elphel.com>

distributing for the power of coarse velocities