This release marks a major architectural shift and achieves full feature
parity with the high-fidelity Shenron radar testbench.
Architecture:
- Implemented PipelineManager and Stage-based execution (Sim, Shenron, MCAP, Video).
- Decoupled recorder from physics/augmentation logic into src/processing/physics.py.
- Migrated all path resolution to Pathlib for cross-platform robustness.
Radar & Metrology:
- Integrated FastHeatmapEngine for stateful, high-performance RD/RA/CFAR rendering.
- Implemented dual-plot Range-Azimuth (Static Absolute vs Dynamic Peak).
- Flattened telemetry schema for direct Foxglove Plot panel compatibility.
- Added hardware-accurate 3D FOV frustum projections (LINE_LIST).
Dashboard & UX:
- Bumped version to v1.1.
- Fixed stop.flag detection bug in simulation shutdown.
- Optimized GPU headroom by maintaining idle/sync mode during synthesis.
Signed-off-by: Antigravity AI <cortex@deepmind.google>
Standardizes the metrology diagnostic suite for high-fidelity focus and
consistent dB scaling.
Core Improvements:
- Signal Processing: Switched Range and Doppler FFTs to Hann windowing,
reducing peak width by ~50% for sharper target focus (Iteration 27).
- Visualization Style: Implemented a fixed-scale MATLAB-style Jet colormap
(-5 to 45 dB). Disabled per-frame auto-scaling to preserve temporal
intensity consistency and physical R^-4 decay.
- Calibration: Applied a -68.0 dB System Gain Offset in post-processing
(calculated via statistical analysis of raw power levels in Iter 28)
to align noise floors (~7 dB) and target peaks (~41 dB).
- Pipeline: Standardized these focus and calibration settings across both
the testbench (test_shenron.py) and packaging pipeline (data_to_mcap.py).
- Docs: Verified and restored gemini.md at the repository root as the
master project context.
This milestone (Iteration 29) finalizes the visual interpretability of the
physics-based Shenron radar engine.
Restores high-fidelity physical realism to the C-Shenron radar engine by
aligning the synthesis pipeline with the pure Radar Range Equation.
Core Improvements:
- Physics: Restored 1/R^4 power-delay law (1/R^2 voltage) in Sceneset.py
and heatmap_gen_fast.py. Stripped legacy 1/1000 normalizations and
R^2 area-growth workarounds.
- Geometry: Fixed FFT index asymmetry in radar_processor.py, achieving a
perfectly symmetric 120° FOV sector.
- Metrology: Implemented "Radar Blue" (Viridis) 120° fan-projection for
diagnostic Range-Azimuth heatmaps.
- Automation: Integrated RD/RA/CFAR heatmap persistence into the
automated simulation-to-MCAP pipeline (data_to_mcap.py).
- Docs: Comprehensive update of intel/ directory, including Iterations 17-26
and the Physics/Symmetry Milestone deep-dive.
This milestone ensures that target brightness and spatial positioning
correctly mimic real-world TI AWRL1432 radar hardware.
Comprehensive integration of the Shenron radar model, enabling high-fidelity
physics-driven radar synthesis from semantic LiDAR data.
Core Changes:
- Sensor Migration: Updated EGO vehicle to use 'sensor.lidar.ray_cast_semantic'.
- Recorder Enhancement: Modified src/recorder.py to dynamically capture
6/7nd-column semantic LiDAR buffers [x, y, z, cos, obj, tag].
- Orchestration: Created scripts/ISOLATE/model_wrapper.py with the
ShenronRadarModel class for a unified physics-to-detection API.
- Processor Logic: Fixed broadcasting bugs and hardcoded antenna counts
in RadarProcessor to support dynamic radar models (radarbook/ti_cascade).
- Rich Data Output: Updated extraction logic to include [velocity, magnitude]
parameters for ADAS performance analysis.
- Batch Pipeline: Added scripts/generate_shenron.py to synthesize radar
data as a post-processing step, maintaining simulation performance.
- Visualization: Updated scripts/data_to_mcap.py to support the
new /radar/shenron topic with a 5-field rich PointCloud schema.
Stability & Fixes:
- Implemented CUDA-enabled PyTorch checks with a robust CPU fallback.
- Corrected CARLA 0.9.16 semantic column mapping in ISOLATE/lidar.py.
- Handled indexing and range-slicing errors in the CFAR detection routine.
This commit introduces a Flask-based web dashboard for the BATL CARLA orchestrator
and hardens the underlying data processing pipeline to support real-time UI tracking.
Dashboard & GUI:
- Added `dashboard/` directory containing the Flask backend (`app.py`), HTML UI,
and static assets (CSS/JS) for a seamless browser-based simulation controller.
- Created `dashboard.bat` to launch the web dashboard environment.
Pipeline Stability (Unbuffered Streaming):
- `run.bat`: Forced `PYTHONUNBUFFERED=1` to ensure subprocess stdout/stderr
is immediately available.
- `dashboard/app.py`: Injected the unbuffered environment flag into `subprocess.Popen`
to prevent the UI console from freezing during heavy post-processing tasks.
- `src/recorder.py` & `data_to_mcap.py`: Appended `flush=True` to stdout prints
to guarantee immediate log propagation to the web dashboard text stream.
Foxglove Data Integrity:
- `data_to_mcap.py`: Hardened internal JSON schemas (`foxglove.Pose`,
`foxglove.CompressedImage`, `foxglove.PointCloud`) by adding `$schema`, `$id`,
and `title` metadata tags over draft-2020-12. This prevents Foxglove Studio from
attempting internet CDN lookups, fully resolving the "Unable to parse ok response
body as json" crashes when importing local MCAP sets.
This commit represents a major architectural upgrade to the CARLA ADAS simulation project, transitioning from stochastic Traffic Manager behavior to a fully deterministic, high-impact demo environment.
1. Deterministic Scenario Architecture
New Showcase Scenario: Implemented
scenarios/showcase.py
for a manual "Left-Turn Across Path" (LTAP) maneuver.
Physics Velocity Injection: Overrode engine/friction variance by directly setting set_target_velocity for NPC actors at 35 km/h.
Multi-Stage Waypoint Guidance: Integrated EGO_MID and P1_MID transition points to ensure realistic, cinematic turning radii and reliable collision-avoidance timing.
Manual Steering Controller: Developed a proportional steering-to-target helper for all actors.
2. Sensor & Data Pipeline
Dual-Camera Support: Integrated a second Third-Person Perspective (TPP) camera.
Radar Serialization Fix: Implemented trigonometric conversion of raw spherical coordinates (Depth, Azimuth, Altitude) into Cartesian XYZ + Velocity 16-byte PointClouds for Foxglove Studio.
Synchronization: Aligned all sensor data (Dash Cam, TPP Cam, Radar, Lidar) at the orchestrator level.
3. Performance & Asynchronous I/O
Asynchronous Recorder: Refactored
src/recorder.py
to use ThreadPoolExecutor, offloading cv2.imwrite operations to background threads to eliminate simulation stutter.
Rapid Iteration: Added --no-record global flag to
main.py
for sub-second iteration during coordinate tuning.
4. Automation & Seamless UX
Auto-MCAP conversion: Integrated
data_to_mcap.py
as a post-simulation callback in
main.py
.
Auto-Video Stitching: Implement automatic .mp4 generation for both camera views using OpenCV's VideoWriter.
Weather/Time CLI: Added --weather flag with presets (Clear, Rain, Sunset, Night).
Console Sync: Integrated tqdm for professional progress tracking and refactored scenario logging to use pbar.write() to prevent terminal flickering/staircasing.
5. Dependency Updates
Added tqdm as a core dependency for enhanced console visualization.
## Summary
First commit of the Fox CARLA simulation pipeline. Establishes a fully working,
end-to-end ADAS data collection and visualization system built on CARLA 0.9.16.
---
## What is included
### Core Pipeline
- Multi-sensor synchronous simulation (Camera, Radar, LiDAR) at configurable FPS
- Frame-aligned sensor data captured using CARLA synchronous mode with fixed delta time
- Structured dataset output: PNG images, NPY arrays, JSONL metadata per frame
- MCAP conversion script producing Foxglove-compatible topics (/camera, /lidar, /radar, /ego_pose)
- Ground truth vehicle tracking embedded in every frame record
### Modular Scenario Architecture
- Abstract ScenarioBase plugin interface (setup / step / cleanup lifecycle)
- Dynamic scenario loader via importlib main.py never imports scenarios by name
- Three implemented ADAS test scenarios:
- braking : Lead vehicle hard braking (emergency stop at configurable frame)
- cutin : Adjacent lane NPC forced lane change into ego lane
- obstacle : Static traffic cone placed on ego lane
- All NPC placement via CARLA waypoints zero hardcoded world coordinates
- Scenario metadata embedded into every JSONL frame record for MCAP traceability
### Orchestrator (src/main.py)
- Fully scenario-agnostic scenarios selected via --scenario CLI flag
- Supports --frames override for quick test runs without editing config
- Supports --list-scenarios for dry-run discovery (no CARLA server required)
- Deferred CARLA import so the process works without a live server for non-simulation commands
### Configuration (config.py)
- Single source of truth for all simulation, sensor, and scenario constants
- Scenario trigger frames and distances fully configurable without code changes
### Recorder (src/recorder.py)
- Session folders named <scenario>_YYYYMMDD_HHMMSS for easy identification
- extra_meta parameter merges scenario state into every frame record automatically
### Developer Tooling
- run.bat: one-click launcher that activates the carla312 conda environment
- intel/context.md: comprehensive AI-agent and developer reference document
- .gitignore: excludes data/, *.mcap, __pycache__, logs/, *.pyc
---
## Architecture
src/main.py (orchestrator)
|-- scenario_loader.py (importlib-based dynamic loader)
|-- sensors.py (SensorManager: camera + radar + lidar)
|-- recorder.py (per-frame data writer)
scenarios/
|-- base.py (ScenarioBase ABC)
|-- braking.py (BrakingScenario)
|-- cutin.py (CutInScenario)
|-- obstacle.py (ObstacleScenario)
config.py (all constants)
data_to_mcap.py (dataset -> MCAP converter)
run.bat (conda env launcher)
intel/context.md (codebase reference)
---
## Usage
run.bat braking
run.bat cutin --frames 120
run.bat obstacle
python data_to_mcap.py
---
## Environment
- CARLA 0.9.16
- Python conda env: carla312 (miniconda)
- Key deps: carla, numpy, opencv-python, mcap
---
## Known Limitations (future work)
- MCAP uses JSON encoding (functional; Protobuf migration planned)
- Intersection scenario not yet implemented (requires junction-aware waypoint logic)
- Single ego vehicle assumed throughout
- Foxglove layout presets not yet defined
RUSHIL AMBARISH KADU