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.
- Engine: Modified CFAR and Processor to extract raw Range-Doppler and Range-Azimuth energy heatmaps.
- Visuals: Integrated high-fidelity Matplotlib colormapping (Viridis/Magma) for Foxglove image streaming.
- Data: Implemented 32-bit raw .npy persistence and JSONL telemetry for frame-level SNR analysis.
- Tools: Added a dedicated verification utility for end-to-end signal flow validation.
- Docs: Comprehensive documentation for the new 'Radar Lab' architecture in /intel/.
Implemented a major architectural refactor of the C-SHENRON radar engine to achieve physically stable, context-independent detections.
1. Physics Engine Refactor (Iteration 16):
- Sceneset.py: Replaced global 1/N normalization with a fixed Area-Density Integration model. This prevents Energy Starvation where buildings previously suppressed car detections.
- Gaussian Damping: Integrated a 20 deg vertical beamwidth profile to physically suppress tree-top clutter while preserving boresight targets.
- ConfigureRadar.py: Standardized hardware profiles with calibrated 110dB gain and removed Iteration 15 bandages.
2. Repository Reorganization:
- Moved analysis and verification scripts to a new scripts/analysis/ directory.
- Updated path resolution in moved scripts to ensure project-wide stability.
3. Documentation & Metrology:
- Created 3D vertical energy suppression.md detailing the Resolution Independence breakthrough.
- Updated Shenron_debug.md with Iterations 14-16, recording a +234% Target Magnitude recovery.
- Updated Shenron_Debug_Plan.md and possible_issue_resolution.md to reflect resolved technical blockers.
Implemented Gaussian vertical-gain damping (-2.77 constant) to address the 'Super-Reflector' tree density problem.
- [ConfigureRadar] Defined total vertical_beamwidth for AWRL1432 (30.0) and Radarbook (60.0).
- [Sceneset] Added G_vertical damping math in get_loss_3 to suppress high-elevation energy.
- [Sceneset] Retained debug logs (G_vertical average/min/max) for Iteration 14b calibration.
Hiccups:
- Resolved environment activation (carla312) in verification shell.
- Corrected test_shenron.py command syntax.
This commit marks the completion of the Iteration 13 'Golden Mix' calibration.
- intel/: Structured documentation into /radar, /scenarios, and /internal subfolders.
- Shenron_debug.md: Comprehensive history of all 13 calibration iterations.
- radar_processor.py: Implemented Blackman-Harris windowing for sidelobe suppression.
- lidar.py: Applied -2.0m parallax shift and ground suppression filtering.
- Sceneset.py: Calibrated specular thresholds and material roughness for stability.
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.
- Updated context.md with new CLI, framework contracts, and Z-axis safety rules
- Added .cursorrules to codify PowerShell and environment requirements
- Added braking.md deep-dive post-mortem on spawning challenges
- Formally marked scenario parameterization as a core feature
- Updated braking, cutin, and obstacle scenarios with class-held constants
- Added deterministic ego_spawn_point (Showcase P2) for all scenarios
- Added 0.5m Z-lift to NPC spawns to prevent ground clipping in Town10
- Refactored showcase.py to use the new standardized ego_spawn_point property
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.
Expanded object state to include physical (acceleration), geometric (bounding boxes),
and relative ADAS metrics (range, azimuth, closing velocity) for vehicles and pedestrians.
## 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
