Update Foxglove visualization example

README.md

@@ -90,8 +90,8 @@ metadata/tof_sensor.yaml                       # TOFSense-M cascade metadata
 quality/reports/                               # generated quality reports
 calibration/robot_v1_template/                 # calibration files
 docs/foxglove_visualization.md                 # Foxglove visualization guide
-scripts/foxglove_visualization_bridge.py       # compact visualization bag builder
-examples/foxglove/run029_full_tof_odom_foxglove.bag  # ready-to-open Foxglove example
+scripts/foxglove_visual.py                    # Foxglove visualization bag builder
+examples/foxglove/visual_demo.bag  # ready-to-open Foxglove example
 ```
 
 ## Sensor Coverage
@@ -141,7 +141,7 @@ examples/foxglove/run029_full_tof_odom_foxglove.bag  # ready-to-open Foxglove ex
 
 ## Foxglove Visualization
 
-`scripts/foxglove_visualization_bridge.py` creates compact visualization-only bags. By default it keeps ToF/IMU/odometry/TF-static topics, writes a 15 Hz compressed TOFSense-M overview image with distance values, `dis_status`, and `signal_strength`, and injects dynamic TF from odometry. Use `--copy-mode custom --keep-topics ...` to choose exactly which original topics are retained. A ready-to-open example is available at `examples/foxglove/run029_full_tof_odom_foxglove.bag`. See `docs/foxglove_visualization.md`.
+`scripts/foxglove_visual.py` creates Foxglove-ready visualization bags with compressed TOFSense-M overview images, optional RGB topics, standard `sensor_msgs/PointCloud2` output at `/foxglove/livox/points`, accumulated `nav_msgs/Path` output at `/foxglove/odom/path`, MAVROS IMU topics, and odometry TF. In Foxglove, use `Fixed frame = odom` and `Display frame = odom` for the 3D panel. A ready-to-open example is available at `examples/foxglove/visual_demo.bag`. See `docs/foxglove_visualization.md`.
 
 ## Limitations
 

calibration/robot_v1_template/README.md

@@ -2,6 +2,17 @@
 
 This directory stores the calibration files published with the dataset.
 
+## Hardware
+
+| Modality | Hardware |
+| --- | --- |
+| Flight controller | MicoAir / 微空 NxtPX4V2, label model `NXTPX4V2` |
+| Flight-controller IMU | Bosch Sensortec BMI088 x2 |
+| LiDAR | Livox MID360s |
+| LiDAR IMU | Livox MID360s integrated IMU |
+| Camera | Intel RealSense D435i |
+| ToF | Nooploop TOFSense-M six-node cascade |
+
 ## Files
 
 - `tf_static.yaml`: consolidated static frame tree.

calibration/robot_v1_template/camera_color.yaml

@@ -1,4 +1,6 @@
 camera_name: camera_color
+manufacturer: Intel RealSense
+model: D435i
 topic: /camera/color/image_raw
 camera_info_topic: /camera/color/camera_info
 frame_id: camera_color_optical_frame

calibration/robot_v1_template/camera_depth.yaml

@@ -1,4 +1,6 @@
 camera_name: camera_depth
+manufacturer: Intel RealSense
+model: D435i
 topic: /camera/depth/image_rect_raw
 camera_info_topic: /camera/depth/camera_info
 frame_id: camera_depth_optical_frame

calibration/robot_v1_template/camera_infra1.yaml

@@ -1,4 +1,6 @@
 camera_name: camera_infra1
+manufacturer: Intel RealSense
+model: D435i
 topic: /camera/infra1/image_rect_raw
 camera_info_topic: /camera/infra1/camera_info
 frame_id: camera_infra1_optical_frame

calibration/robot_v1_template/camera_infra2.yaml

@@ -1,4 +1,6 @@
 camera_name: camera_infra2
+manufacturer: Intel RealSense
+model: D435i
 topic: /camera/infra2/image_rect_raw
 camera_info_topic: /camera/infra2/camera_info
 frame_id: camera_infra2_optical_frame

calibration/robot_v1_template/imu_to_base.yaml

@@ -1,4 +1,14 @@
 sensor: mavros_imu
+source_hardware:
+  flight_controller:
+    manufacturer: MicoAir
+    manufacturer_cn: 微空
+    model: NxtPX4V2
+    label_model: NXTPX4V2
+  imu:
+    manufacturer: Bosch Sensortec
+    model: BMI088
+    count: 2
 topic: /mavros/imu/data
 parent_frame: base_link
 child_frame: mavros_imu_frame

calibration/robot_v1_template/livox_to_base.yaml

@@ -1,5 +1,9 @@
 sensor: livox_mid360
+manufacturer: Livox
+model: MID360s
+sensor_type: lidar_with_integrated_imu
 topic: /livox/lidar
+imu_topic: /livox/imu
 parent_frame: base_link
 child_frame: livox_frame
 translation_xyz_m: [0.0, 0.0, 0.0]

dataset.yaml

@@ -32,6 +32,7 @@ default_topics:
 
 sensor_metadata:
   tof: metadata/tof_sensor.yaml
+  sensors: metadata/sensors.yaml
 
 quality_status:
   - unchecked

docs/foxglove_visualization.md

@@ -1,172 +1,230 @@
-# Foxglove Visualization Bag
+# Foxglove Visualization
 
-Use `scripts/foxglove_visualization_bridge.py` to create a small visualization-only rosbag from a raw dataset bag.
+Language: English | [简体中文](foxglove_visualization.zh-CN.md)
 
-The raw bag remains the source of truth. Do not replace raw bags with generated visualization bags.
+This guide shows how to inspect the dataset in Foxglove with ToF heatmaps, RGB images, LiDAR point clouds, MAVROS IMU curves, and 3D odometry.
 
-## Why the Old Script Made Huge Bags
+The raw rosbag remains the source data. The Foxglove bag is a visualization artifact generated with `scripts/foxglove_visual.py`.
 
-The previous script did three expensive things at the same time:
+## Ready-To-Open Example
 
-1. It copied every original topic by default, including large camera and lidar topics.
-2. It wrote one raw RGB `sensor_msgs/Image` overview plus six raw RGB node images for each ToF message.
-3. It wrote those images at the full ToF rate.
+The Hugging Face dataset includes a Foxglove example:
 
-That is the bad data structure. A visualization bag should not be a second full dataset plus uncompressed debug images.
+```text
+examples/foxglove/visual_demo.bag
+```
+
+It is generated from session:
+
+```text
+raw/sessions/2026-05-20_030414_odom_run029/bag.bag
+```
 
-## Compact Default
+Open the example bag in Foxglove, then create the panels below.
 
-The repository script changes the default:
+## Recommended Layout
 
-| Item | Default |
+| Panel | Topic / setting |
 | --- | --- |
-| Original topics | Compact ToF, IMU, odometry, and `/tf_static` only |
-| ToF image output | Overview image only |
-| ToF image format | `sensor_msgs/CompressedImage` JPEG |
-| ToF image rate | 15 Hz |
-| ToF image content | Distance values, `dis_status`, and `signal_strength` tables |
-| Dynamic TF | Injected from odometry at 10 Hz |
-| Output bag compression | `bz2` |
+| Image | `/foxglove/tof/overview/compressed` |
+| Image | `/camera/color/image_raw` |
+| 3D | `Fixed frame = odom`, `Display frame = odom` |
+| 3D point cloud | `/foxglove/livox/points` |
+| 3D path | `/foxglove/odom/path` |
+| 3D odometry | `/fusion_odometry/lazy_point_odom` or `/ekf_quat/ekf_odom` |
+| Plot | `/mavros/imu/data_raw.angular_velocity.{x,y,z}` |
+| Plot | `/mavros/imu/data_raw.linear_acceleration.{x,y,z}` |
 
-The original `/nlink_tofsensem_cascade` topic is still copied in compact mode, so the numeric ToF data remains complete. The generated heatmap is compressed JPEG and can be rate-limited independently.
+For this dataset, set both 3D frame fields to:
 
-## Hugging Face Example Bag
+```text
+Fixed frame:   odom
+Display frame: odom
+```
 
-The Hugging Face dataset includes a ready-to-open Foxglove example:
+The visualization bag provides this TF chain:
 
 ```text
-examples/foxglove/run029_full_tof_odom_foxglove.bag
+odom -> base_link -> livox_frame
+base_link -> base_link_frd
+odom -> odom_ned
 ```
 
-It is generated from `odom_dataset_20260520_030414.bag` / session `2026-05-20_030414_odom_run029`.
+Use `odom` for the main 3D view. `odom_ned` and `base_link_frd` are auxiliary frames for NED/FRD conventions.
 
-| Item | Value |
-| --- | --- |
-| Source duration | 409 s |
-| Example bag size | About 886 MB |
-| ToF raw messages | 6138 |
-| ToF overview images | 4047 |
-| Image topic | `/foxglove/tof/overview/compressed` |
-| Image size | 1794 x 878 |
+## Topic Guide
 
-## Generate A Bag
+| Topic | Type | What it shows |
+| --- | --- | --- |
+| `/foxglove/tof/overview/compressed` | `sensor_msgs/CompressedImage` | Six-node Nooploop TOFSense-M 8x8 cascade heatmap |
+| `/nlink_tofsensem_cascade` | `nlink_parser/TofsenseMCascade` | Original ToF numeric data |
+| `/camera/color/image_raw` | `sensor_msgs/Image` | Intel RealSense D435i RGB stream |
+| `/camera/color/camera_info` | `sensor_msgs/CameraInfo` | RGB camera intrinsics |
+| `/livox/lidar` | `livox_ros_driver2/CustomMsg` | Original Livox MID360s packet topic |
+| `/foxglove/livox/points` | `sensor_msgs/PointCloud2` | Foxglove-ready LiDAR point cloud |
+| `/foxglove/odom/path` | `nav_msgs/Path` | Accumulated odometry trajectory for 3D display |
+| `/mavros/imu/data` | `sensor_msgs/Imu` | Filtered flight-controller IMU |
+| `/mavros/imu/data_raw` | `sensor_msgs/Imu` | Raw flight-controller IMU |
+| `/fusion_odometry/lazy_point_odom` | `nav_msgs/Odometry` | Main odometry for 3D trajectory |
+| `/ekf_quat/ekf_odom` | `nav_msgs/Odometry` | EKF odometry, when present |
+| `/tf` | `tf2_msgs/TFMessage` | Dynamic odometry transform |
+| `/tf_static` | `tf2_msgs/TFMessage` | Static camera, LiDAR, and frame transforms |
 
-Run inside a ROS1 environment that can import this dataset's custom message types:
+Foxglove does not reliably render Livox custom messages directly. Use `/foxglove/livox/points` for the 3D point cloud.
 
-```bash
-python3 scripts/foxglove_visualization_bridge.py \
-  --input-bag raw/sessions/2026-05-20_030414_odom_run029/bag.bag \
-  --output-bag /tmp/run029_full_tof_odom_foxglove.bag \
-  --force
+## ToF Panel
+
+Add an Image panel and select:
+
+```text
+/foxglove/tof/overview/compressed
 ```
 
-Open the output bag in Foxglove.
+The overview image contains six TOFSense-M nodes. Each node shows:
+
+| Field | Meaning |
+| --- | --- |
+| `dis` | distance in millimeters |
+| `dis_status` | per-pixel distance status |
+| `signal_strength` | per-pixel return strength |
 
-Useful topics:
+Valid pixels are colorized by distance. Invalid or missing pixels are drawn in gray.
 
-| Topic | Purpose |
+## LiDAR Panel
+
+Add a 3D panel and select:
+
+```text
+/foxglove/livox/points
+```
+
+Recommended point-cloud settings:
+
+| Setting | Value |
 | --- | --- |
-| `/foxglove/tof/overview/compressed` | Six-node TOFSense-M cascade heatmap |
-| `/tf` | Injected `map -> base_link` transform from odometry |
-| `/fusion_odometry/current_point_odom` | Primary odometry |
-| `/ekf_quat/ekf_odom` | EKF odometry when present |
-| `/mavros/imu/data` | IMU |
-| `/nlink_tofsensem_cascade` | Original ToF cascade message |
+| Point size | `1.0` to `1.5` |
+| Point shape | Circle |
+| Color mode | Color map |
+| Color field | `intensity` |
+| Stixel view | Off |
 
-## Time Windows
+If Stixel view is enabled, Foxglove draws pillar-like vertical structures. That is useful for obstacle-style views, but it is not the best mode for checking the raw point cloud.
 
-Use a time window when the raw bag is large and you only need a representative segment:
+## Odometry And TF
 
-```bash
-python3 scripts/foxglove_visualization_bridge.py \
-  --input-bag raw/sessions/2026-05-20_030414_odom_run029/bag.bag \
-  --start-offset-sec 189.891 \
-  --duration-sec 30 \
-  --output-bag /tmp/run029_mid30s_tof_odom_foxglove.bag \
-  --force
+Add odometry display in the same 3D panel:
+
+```text
+/fusion_odometry/lazy_point_odom
+```
+
+For the already-traveled trajectory line, add:
+
+```text
+/foxglove/odom/path
 ```
 
-The script also copies `/tf_static` into the window so Foxglove can resolve static frames in the clipped bag.
+If that topic is not available in a selected session, use:
 
-## Smaller Or Larger Outputs
+```text
+/ekf_quat/ekf_odom
+```
 
-Only generated visualization topics:
+The generated bag injects dynamic TF from odometry, so the 3D view can resolve:
 
-```bash
-python3 scripts/foxglove_visualization_bridge.py \
-  --input-bag raw/sessions/2026-05-13_024746_odom_run001/bag.bag \
-  --copy-mode none \
-  --output-bag /tmp/tof_odom_view_only.bag \
-  --force
+```text
+odom -> base_link -> livox_frame
 ```
 
-Include per-node ToF images:
+This is the frame path required to show the LiDAR point cloud together with the odometry trajectory.
 
-```bash
-python3 scripts/foxglove_visualization_bridge.py \
-  --input-bag raw/sessions/2026-05-13_024746_odom_run001/bag.bag \
-  --tof-image-mode both \
-  --tof-rate-hz 15 \
-  --output-bag /tmp/tof_nodes_view.bag \
-  --force
+## IMU Plots
+
+Add a Plot panel and select angular velocity:
+
+```text
+/mavros/imu/data_raw.angular_velocity.x
+/mavros/imu/data_raw.angular_velocity.y
+/mavros/imu/data_raw.angular_velocity.z
 ```
 
-Write every ToF heatmap frame without throttling:
+For acceleration, add:
 
-```bash
-python3 scripts/foxglove_visualization_bridge.py \
-  --input-bag raw/sessions/2026-05-13_024746_odom_run001/bag.bag \
-  --tof-rate-hz 0 \
-  --output-bag /tmp/tof_full_rate_view.bag \
-  --force
+```text
+/mavros/imu/data_raw.linear_acceleration.x
+/mavros/imu/data_raw.linear_acceleration.y
+/mavros/imu/data_raw.linear_acceleration.z
 ```
 
-Keep exactly the original topics you choose:
+Use `/mavros/imu/data` when you want the filtered MAVROS IMU stream, and `/mavros/imu/data_raw` when you want the raw flight-controller IMU stream.
+
+## Generate A Visualization Bag
+
+Build the ROS1 helper image once:
 
 ```bash
-python3 scripts/foxglove_visualization_bridge.py \
-  --input-bag raw/sessions/2026-05-13_024746_odom_run001/bag.bag \
-  --copy-mode custom \
-  --keep-topics /tf_static,/mavros/imu/data,/nlink_tofsensem_cascade,/fusion_odometry/current_point_odom \
-  --output-bag /tmp/custom_topics_view.bag \
-  --force
+make docker-build
 ```
 
-Hide the ToF numeric overlays when you need a smaller visualization bag:
+Generate a 30 second all-modality example:
 
 ```bash
-python3 scripts/foxglove_visualization_bridge.py \
+docker/ros1_noetic/run.sh 'python3 scripts/foxglove_visual.py \
   --input-bag raw/sessions/2026-05-20_030414_odom_run029/bag.bag \
-  --tof-hide-distance-text \
-  --tof-hide-tables \
-  --output-bag /tmp/tof_heatmap_only.bag \
-  --force
+  --output-bag outputs_tmp/foxglove_samples/run029_mid30s_all_modalities_foxglove.bag \
+  --start-offset-sec 189.891 \
+  --duration-sec 30 \
+  --copy-mode custom \
+  --keep-topics /tf_static,/camera/color/image_raw,/camera/color/camera_info,/livox/lidar,/mavros/imu/data,/mavros/imu/data_raw,/nlink_tofsensem_cascade,/fusion_odometry/lazy_point_odom,/ekf_quat/ekf_odom \
+  --tof-rate-hz 15 \
+  --tf-rate-hz 30 \
+  --tf-parent-frame odom \
+  --force'
 ```
 
-Copy every original topic only when you really need it:
+Generate a ToF + odometry focused bag:
 
 ```bash
-python3 scripts/foxglove_visualization_bridge.py \
-  --input-bag raw/sessions/2026-05-13_024746_odom_run001/bag.bag \
-  --copy-mode all \
-  --tof-rate-hz 1 \
-  --output-bag /tmp/full_plus_foxglove.bag \
-  --force
+docker/ros1_noetic/run.sh 'python3 scripts/foxglove_visual.py \
+  --input-bag raw/sessions/2026-05-20_030414_odom_run029/bag.bag \
+  --output-bag outputs_tmp/foxglove_samples/run029_tof_odom_foxglove.bag \
+  --copy-mode custom \
+  --keep-topics /tf_static,/mavros/imu/data,/mavros/imu/data_raw,/nlink_tofsensem_cascade,/fusion_odometry/lazy_point_odom,/ekf_quat/ekf_odom \
+  --tof-rate-hz 15 \
+  --tf-rate-hz 30 \
+  --tf-parent-frame odom \
+  --force'
 ```
 
-`--copy-mode all` can still produce a large bag. That is expected.
-
-## Foxglove Panel Setup
+## Useful Options
 
-Use an Image panel for `/foxglove/tof/overview/compressed`. The image contains six TOFSense-M nodes. Each node shows distance in millimeters, `dis_status`, and `signal_strength`.
-
-Use a 3D panel with:
-
-| Setting | Value |
+| Option | Purpose |
+| --- | --- |
+| `--start-offset-sec` | Start from an offset relative to the raw bag start |
+| `--duration-sec` | Convert only a time window |
+| `--copy-mode custom` | Keep exactly the original topics listed in `--keep-topics` |
+| `--keep-topics` | Original raw topics to copy into the visualization bag |
+| `--tof-rate-hz` | ToF overview image rate; `15` matches the nominal TOFSense-M 8x8 rate |
+| `--tof-image-mode overview` | Write only the six-node overview image |
+| `--tof-image-mode both` | Write overview plus per-node ToF images |
+| `--convert-livox-pointcloud2` | Convert `/livox/lidar` to `/foxglove/livox/points` |
+| `--livox-calibration` | LiDAR-to-body calibration YAML used for `/tf_static` |
+| `--tf-parent-frame odom` | Use `odom -> base_link` for injected dynamic TF |
+| `--bag-compression bz2` | Compress the generated bag |
+
+## Troubleshooting
+
+| Symptom | Check |
 | --- | --- |
-| Fixed frame | `map` |
-| Dynamic frame | `base_link` |
-| Odometry | `/fusion_odometry/current_point_odom` or `/ekf_quat/ekf_odom` |
-| TF | `/tf` and `/tf_static` |
+| ToF image panel says waiting for messages | Make sure `/foxglove/tof/overview/compressed` exists in the bag |
+| LiDAR topic has a warning icon | Use `/foxglove/livox/points`, not raw `/livox/lidar` |
+| Point cloud does not appear in 3D | Confirm `Fixed frame = odom` and `Display frame = odom` |
+| Point cloud looks like vertical pillars | Turn Stixel view off |
+| Odometry and point cloud are not aligned | Confirm `/tf` and `/tf_static` are enabled |
+| RGB panel is blank | Use an Image panel for `/camera/color/image_raw` |
 
-If the trajectory looks wrong, first check the odometry topic and frame names. Do not patch the visualization bag until the source frame convention is clear.
+To inspect the generated bag before opening it:
+
+```bash
+docker/ros1_noetic/run.sh 'rosbag info outputs_tmp/foxglove_samples/run029_mid30s_all_modalities_foxglove.bag'
+```

examples/foxglove/{run029_full_tof_odom_foxglove.bag → visual_demo.bag}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:42b7e5ab3149230778076564cb9bb746366671bc893249b04ad0323064486fd2
-size 929220010
+oid sha256:174da96d4abf8eb9eabd97f15c1120666ad32178607dd0c168ef06a85088e42b
+size 817543913

metadata/sensors.yaml

@@ -25,6 +25,31 @@ topic_categories:
     - /tf_static
 
 sensor_specs:
+  flight_controller:
+    manufacturer: MicoAir
+    manufacturer_cn: 微空
+    model: NxtPX4V2
+    label_model: NXTPX4V2
+    imu_model: Bosch Sensortec BMI088
+    imu_count: 2
+    topics:
+      - /mavros/imu/data
+      - /mavros/imu/data_raw
+    notes: "Flight-controller IMU stream from the MicoAir NxtPX4V2 autopilot."
+  lidar:
+    manufacturer: Livox
+    model: MID360s
+    sensor_type: lidar_with_integrated_imu
+    lidar_topic: /livox/lidar
+    imu_topic: /livox/imu
+  camera:
+    manufacturer: Intel RealSense
+    model: D435i
+    topics:
+      color: /camera/color/image_raw
+      depth: /camera/depth/image_rect_raw
+      infra1: /camera/infra1/image_rect_raw
+      infra2: /camera/infra2/image_rect_raw
   tof:
     metadata_file: metadata/tof_sensor.yaml
     description_file: metadata/tof_sensor.md

metadata/tof_sensor.md

@@ -1,5 +1,7 @@
 # TOFSense-M ToF Sensor Metadata
 
+Language: English | [简体中文](tof_sensor.zh-CN.md)
+
 The dataset ToF topic is `/nlink_tofsensem_cascade`. It records a six-node Nooploop TOFSense-M cascade using UART query output in 8x8 mode.
 
 ## Collection Configuration

metadata/tof_sensor.zh-CN.md

@@ -0,0 +1,86 @@
+# TOFSense-M ToF 传感器元数据
+
+语言：[English](tof_sensor.md) | 简体中文
+
+本数据集的 ToF topic 是 `/nlink_tofsensem_cascade`。该 topic 记录的是六个 Nooploop TOFSense-M 传感器级联后的数据，采集时使用 UART 查询输出模式，像素模式为 8x8。
+
+## 采集配置
+
+| 字段 | 数值 |
+| --- | --- |
+| 传感器型号 | Nooploop TOFSense-M |
+| 传感器类型 | 飞行时间矩阵式激光测距传感器 |
+| ROS topic | `/nlink_tofsensem_cascade` |
+| ROS message | `nlink_parser/TofsenseMCascade` |
+| 接口 | UART |
+| 输出模式 | 查询模式 |
+| 级联节点数 | 6 |
+| 像素模式 | 8x8 |
+| 每个节点像素数 | 64 |
+| 每条级联消息的期望像素数 | 384 |
+| 标称刷新率 | 8x8 模式下每个节点 15 Hz |
+| UART 波特率 | 921600 bps |
+
+## 消息结构
+
+`nlink_parser/TofsenseMCascade` 包含 `nodes` 字段，它是一个 `nlink_parser/TofsenseMFrame0` 数组。
+
+每个节点包含：
+
+| 字段 | 类型 | 含义 |
+| --- | --- | --- |
+| `id` | `uint8` | 级联中的模块 ID |
+| `system_time` | `uint32` | 传感器侧系统时间 |
+| `pixel_count` | `uint8` | 在本数据集中期望为 64 |
+| `pixels` | `TofsenseMFrame0Pixel[]` | 像素数据，按 index 0 到 63 排列 |
+
+每个像素包含：
+
+| 字段 | 类型 | 单位 | 含义 |
+| --- | --- | --- | --- |
+| `dis` | `float32` | mm | 当前 `nlink_parser` 输出解码后的距离 |
+| `dis_status` | `uint8` | code | 单个像素的距离状态码 |
+| `signal_strength` | `uint16` | 原始计数 | 返回信号强度，数值越大表示回波越强 |
+
+做有效性检查时，只把 `dis_status == 0` 且 `dis > 0` 的像素视为可用。
+
+## 距离状态码
+
+| Code | 含义 |
+| --- | --- |
+| 0 | 测量数据可用 |
+| 1 | 信号强度过低 |
+| 2 | 阶段目标 |
+| 3 | 目标噪声估值过高 |
+| 4 | 目标一致性检测失败 |
+| 5 | 测量数据未更新 |
+| 6 | 未执行环绕操作，通常出现在第一次测量 |
+| 7 | 速率不一致 |
+| 8 | 当前目标信号强度低 |
+| 9 | 大脉冲有效范围，可能由合并目标导致 |
+| 10 | 测量数据可用，但在之前的检测中未检测到目标 |
+| 11 | 测量结果不一致 |
+| 12 | 目标被模糊 |
+| 13 | 检测到目标但数据不一致，通常发生在存在次要目标时 |
+| 255 | 未检测到目标 |
+
+## 传感器规格
+
+| 参数 | 数值 |
+| --- | --- |
+| 600 lux 下量程 | 1.5 cm 到 4 m |
+| 60K lux 下量程 | 1.5 cm 到 2 m |
+| 100K lux 下量程 | 1.5 cm 到 1.2 m |
+| 距离分辨率 | 1 mm |
+| 典型测距精度 | +/- 1.5 cm |
+| 典型标准差 | 室内 / 600 lux / 4 m 条件下 < 1 cm |
+| 视场角 | 水平 45 deg，垂直 45 deg，对角 65 deg |
+| 支持像素模式 | 8x8 和 4x4 |
+| 刷新率 | 8x8 为 15 Hz，4x4 为 60 Hz |
+| 激光波长 | 940 nm |
+| 激光等级 | Class 1 |
+| 典型功耗 | 670 mW |
+| UART 供电电压 | 3.7 V 到 5.2 V |
+| CAN 供电电压 | 4.2 V 到 5.2 V |
+
+当前数据集版本没有固定的 ToF-to-base 外参。明确的标定状态见 `calibration/robot_v1_template/tof_to_base.yaml`。

scripts/foxglove_visual.py

@@ -0,0 +1,851 @@
+#!/usr/bin/env python3
+"""Build a compact Foxglove-friendly rosbag from the raw dataset bags.
+
+The raw bags are the source of truth. This script is only for visualization.
+It keeps a small set of original topics, adds throttled compressed ToF heatmaps,
+and can inject dynamic TF from odometry for Foxglove 3D view.
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import math
+import os
+import struct
+from pathlib import Path
+
+cv2 = None
+np = None
+
+
+TOF_CASCADE_TOPIC = "/nlink_tofsensem_cascade"
+TOF_FRAME0_TOPIC = "/nlink_tofsensem_frame0"
+LIVOX_LIDAR_TOPIC = "/livox/lidar"
+LIVOX_POINTCLOUD_TOPIC = "/foxglove/livox/points"
+
+ODOM_CANDIDATE_TOPICS = (
+    "/fusion_odometry/current_point_odom",
+    "/fusion_odometry/lazy_point_odom",
+    "/ekf_quat/ekf_odom",
+    "/ekf/ekf_odom",
+    "/Odometry",
+    "/vrpn_client_node/crazy/pose",
+)
+
+COMPACT_COPY_TOPICS = (
+    "/tf_static",
+    "/fusion_odometry/current_point_odom",
+    "/fusion_odometry/lazy_point_odom",
+    "/ekf_quat/ekf_odom",
+    "/mavros/imu/data",
+    "/mavros/imu/data_raw",
+    "/livox/imu",
+    TOF_CASCADE_TOPIC,
+    TOF_FRAME0_TOPIC,
+)
+
+
+def import_ros_deps():
+    try:
+        import genpy
+        import rosbag
+        from geometry_msgs.msg import PoseStamped, TransformStamped
+        from nav_msgs.msg import Path as RosPath
+        from sensor_msgs.msg import CompressedImage, Image, PointCloud2, PointField
+        from tf2_msgs.msg import TFMessage
+    except ImportError as exc:
+        raise RuntimeError(
+            "ROS1 Python dependencies are not available. Run this script inside a ROS1 environment "
+            "that can import rosbag, geometry_msgs, sensor_msgs, and tf2_msgs."
+        ) from exc
+    return genpy, rosbag, PoseStamped, TransformStamped, RosPath, CompressedImage, Image, PointCloud2, PointField, TFMessage
+
+
+def import_visual_deps():
+    global cv2, np
+    try:
+        import cv2 as cv2_module
+        import numpy as np_module
+    except ImportError as exc:
+        raise RuntimeError(
+            "Visualization dependencies are not available. Install python3-opencv and numpy "
+            "inside the ROS1 environment used to run this script."
+        ) from exc
+    cv2 = cv2_module
+    np = np_module
+
+
+def is_valid_stamp(stamp) -> bool:
+    return stamp is not None and hasattr(stamp, "to_sec") and stamp.to_sec() > 0.0
+
+
+def select_time(stamp, fallback_time):
+    return stamp if is_valid_stamp(stamp) else fallback_time
+
+
+def parse_topic_csv(text: str) -> list[str]:
+    if not text:
+        return []
+    return [item.strip() for item in text.split(",") if item.strip()]
+
+
+def bag_stem(path: str) -> str:
+    name = Path(path).name
+    return name[:-4] if name.endswith(".bag") else name
+
+
+class RateLimiter:
+    def __init__(self, hz: float):
+        self.period = 0.0 if hz <= 0.0 else 1.0 / float(hz)
+        self.next_time = None
+
+    def allow(self, stamp) -> bool:
+        if self.period <= 0.0:
+            return True
+        if not is_valid_stamp(stamp):
+            return True
+        now = stamp.to_sec()
+        if self.next_time is None or now >= self.next_time:
+            self.next_time = now + self.period
+            return True
+        return False
+
+
+class TofHeatmapRenderer:
+    def __init__(
+        self,
+        compressed_image_cls,
+        raw_image_cls,
+        max_nodes: int,
+        grid_size: int,
+        cell_px: int,
+        min_distance_mm: float,
+        max_distance_mm: float,
+        valid_status: int,
+        colormap_name: str,
+        output_format: str,
+        jpeg_quality: int,
+        draw_distance_text: bool,
+        show_tables: bool,
+        include_overview_image: bool,
+        include_node_images: bool,
+        overview_topic: str,
+        node_topic_prefix: str,
+    ):
+        self.CompressedImage = compressed_image_cls
+        self.Image = raw_image_cls
+        self.max_nodes = max(1, int(max_nodes))
+        self.grid_size = int(grid_size)
+        self.cell_px = int(cell_px)
+        self.min_distance_mm = float(min_distance_mm)
+        self.max_distance_mm = float(max_distance_mm)
+        self.valid_status = int(valid_status)
+        self.colormap = getattr(cv2, colormap_name, cv2.COLORMAP_TURBO)
+        self.output_format = output_format
+        self.jpeg_quality = int(jpeg_quality)
+        self.draw_distance_text = bool(draw_distance_text)
+        self.show_tables = bool(show_tables)
+        self.include_overview_image = bool(include_overview_image)
+        self.include_node_images = bool(include_node_images)
+        self.overview_topic = overview_topic
+        self.node_topic_prefix = node_topic_prefix
+        self.latest_frame0_panels = {}
+
+    @staticmethod
+    def get_nodes(msg) -> list:
+        if hasattr(msg, "nodes"):
+            return list(msg.nodes)
+        if hasattr(msg, "node"):
+            return list(msg.node)
+        return []
+
+    def reshape_or_pad(self, values, fill_value: float = 0.0) -> np.ndarray:
+        target = self.grid_size * self.grid_size
+        data = list(values[:target])
+        if len(data) < target:
+            data.extend([fill_value] * (target - len(data)))
+        return np.array(data, dtype=np.float32).reshape(self.grid_size, self.grid_size)
+
+    def render_numeric_table(self, grid, title: str, cell_w: int = 44, cell_h: int = 20) -> np.ndarray:
+        rows, cols = grid.shape
+        header_h = 24
+        width = cols * cell_w
+        height = header_h + rows * cell_h
+        image = np.full((height, width, 3), 248, dtype=np.uint8)
+
+        cv2.putText(image, title, (5, 17), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (20, 20, 20), 1, cv2.LINE_AA)
+        for row in range(rows + 1):
+            y = header_h + row * cell_h
+            cv2.line(image, (0, y), (width, y), (180, 180, 180), 1)
+        for col in range(cols + 1):
+            x = col * cell_w
+            cv2.line(image, (x, header_h), (x, height), (180, 180, 180), 1)
+
+        for row in range(rows):
+            for col in range(cols):
+                text = str(int(grid[row, col]))
+                x = col * cell_w + 3
+                y = header_h + row * cell_h + 14
+                cv2.putText(image, text, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.34, (30, 30, 30), 1, cv2.LINE_AA)
+        return image
+
+    def render_node(self, node_id: int, pixels, stamp) -> np.ndarray:
+        distances = [float(getattr(pixel, "dis", 0.0)) for pixel in pixels]
+        statuses = [int(getattr(pixel, "dis_status", 255)) for pixel in pixels]
+        strengths = [int(getattr(pixel, "signal_strength", 0)) for pixel in pixels]
+
+        dis = self.reshape_or_pad(distances, fill_value=0.0)
+        status = self.reshape_or_pad(statuses, fill_value=255).astype(np.int32)
+        strength = self.reshape_or_pad(strengths, fill_value=0).astype(np.int32)
+        valid = np.logical_and(status == self.valid_status, dis > 0.0)
+
+        clipped = np.clip(dis, self.min_distance_mm, self.max_distance_mm)
+        scale = max(1e-6, self.max_distance_mm - self.min_distance_mm)
+        normalized = ((clipped - self.min_distance_mm) / scale * 255.0).astype(np.uint8)
+        heat = cv2.applyColorMap(normalized, self.colormap)
+        heat = cv2.cvtColor(heat, cv2.COLOR_BGR2RGB)
+        heat[~valid] = np.array([88, 88, 88], dtype=np.uint8)
+
+        tile_size = self.grid_size * self.cell_px
+        tile = cv2.resize(heat, (tile_size, tile_size), interpolation=cv2.INTER_NEAREST)
+        for idx in range(self.grid_size + 1):
+            offset = idx * self.cell_px
+            cv2.line(tile, (offset, 0), (offset, tile.shape[0]), (255, 255, 255), 1)
+            cv2.line(tile, (0, offset), (tile.shape[1], offset), (255, 255, 255), 1)
+
+        if self.draw_distance_text:
+            for row in range(self.grid_size):
+                for col in range(self.grid_size):
+                    text = str(int(dis[row, col]))
+                    x = col * self.cell_px + 3
+                    y = row * self.cell_px + int(self.cell_px * 0.65)
+                    color = (255, 255, 255) if valid[row, col] else (220, 220, 220)
+                    cv2.putText(tile, text, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.32, color, 1, cv2.LINE_AA)
+
+        body = tile
+        if self.show_tables:
+            status_table = self.render_numeric_table(status, "dis_status")
+            strength_table = self.render_numeric_table(strength, "signal_strength")
+            table_w = max(status_table.shape[1], strength_table.shape[1])
+
+            def pad_width(image, width):
+                if image.shape[1] == width:
+                    return image
+                pad = np.full((image.shape[0], width - image.shape[1], 3), 248, dtype=np.uint8)
+                return np.concatenate([image, pad], axis=1)
+
+            status_table = pad_width(status_table, table_w)
+            strength_table = pad_width(strength_table, table_w)
+            table_gap = np.full((8, table_w, 3), 245, dtype=np.uint8)
+            tables = np.concatenate([status_table, table_gap, strength_table], axis=0)
+
+            content_h = max(tile.shape[0], tables.shape[0])
+            tile_pad = np.full((content_h, tile.shape[1], 3), 245, dtype=np.uint8)
+            table_pad = np.full((content_h, tables.shape[1], 3), 245, dtype=np.uint8)
+            tile_pad[:tile.shape[0], :tile.shape[1], :] = tile
+            table_pad[:tables.shape[0], :tables.shape[1], :] = tables
+            gap = np.full((content_h, 10, 3), 245, dtype=np.uint8)
+            body = np.concatenate([tile_pad, gap, table_pad], axis=1)
+
+        header_h = 32
+        panel = np.full((header_h + body.shape[0], body.shape[1], 3), 245, dtype=np.uint8)
+        valid_ratio = float(np.count_nonzero(valid)) / float(valid.size) if valid.size else 0.0
+        title = "node {}  dis(mm) heatmap  valid {:.0f}%".format(node_id, valid_ratio * 100.0)
+        if is_valid_stamp(stamp):
+            title += "  t={:.2f}".format(stamp.to_sec())
+        cv2.putText(panel, title, (6, 22), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (20, 20, 20), 1, cv2.LINE_AA)
+        panel[header_h:, :, :] = body
+        return panel
+
+    @staticmethod
+    def render_overview(node_panels):
+        if not node_panels:
+            return np.full((260, 420, 3), 245, dtype=np.uint8)
+
+        cols = min(3, len(node_panels))
+        rows = int(math.ceil(len(node_panels) / float(cols)))
+        gap = 12
+        top = 38
+        tile_h = max(panel.shape[0] for panel in node_panels)
+        tile_w = max(panel.shape[1] for panel in node_panels)
+        canvas_h = top + rows * tile_h + max(0, rows - 1) * gap + 12
+        canvas_w = cols * tile_w + max(0, cols - 1) * gap + 12
+        canvas = np.full((canvas_h, canvas_w, 3), 245, dtype=np.uint8)
+        cv2.putText(
+            canvas,
+            "TOFSense-M cascade heatmap",
+            (6, 25),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.72,
+            (20, 20, 20),
+            2,
+            cv2.LINE_AA,
+        )
+        for idx, panel in enumerate(node_panels):
+            row = idx // cols
+            col = idx % cols
+            y = top + row * (tile_h + gap)
+            x = 6 + col * (tile_w + gap)
+            canvas[y:y + panel.shape[0], x:x + panel.shape[1], :] = panel
+        return canvas
+
+    def to_ros_image(self, image_rgb: np.ndarray, stamp):
+        if self.output_format == "raw":
+            msg = self.Image()
+            if is_valid_stamp(stamp):
+                msg.header.stamp = stamp
+            msg.height = image_rgb.shape[0]
+            msg.width = image_rgb.shape[1]
+            msg.encoding = "rgb8"
+            msg.is_bigendian = 0
+            msg.step = msg.width * 3
+            msg.data = np.ascontiguousarray(image_rgb).tobytes()
+            return msg
+
+        msg = self.CompressedImage()
+        if is_valid_stamp(stamp):
+            msg.header.stamp = stamp
+        image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
+        if self.output_format == "png":
+            ok, encoded = cv2.imencode(".png", image_bgr, [cv2.IMWRITE_PNG_COMPRESSION, 3])
+            msg.format = "png"
+        else:
+            ok, encoded = cv2.imencode(".jpg", image_bgr, [cv2.IMWRITE_JPEG_QUALITY, self.jpeg_quality])
+            msg.format = "jpeg"
+        if not ok:
+            raise RuntimeError("failed to encode ToF heatmap")
+        msg.data = encoded.tobytes()
+        return msg
+
+    def consume_cascade(self, msg, fallback_time) -> list[tuple[str, object, object]]:
+        stamp = fallback_time
+        if hasattr(msg, "header") and hasattr(msg.header, "stamp"):
+            stamp = select_time(msg.header.stamp, fallback_time)
+
+        node_panels = []
+        node_outputs = []
+        for idx, node in enumerate(self.get_nodes(msg)[:self.max_nodes]):
+            node_id = int(getattr(node, "id", idx))
+            panel = self.render_node(node_id, list(getattr(node, "pixels", [])), stamp)
+            node_panels.append(panel)
+            if self.include_node_images:
+                node_outputs.append((
+                    self.node_topic_prefix + str(node_id),
+                    self.to_ros_image(panel, stamp),
+                    select_time(stamp, fallback_time),
+                ))
+
+        outputs = []
+        if self.include_overview_image:
+            overview = self.render_overview(node_panels)
+            outputs.append((self.overview_topic, self.to_ros_image(overview, stamp), select_time(stamp, fallback_time)))
+        outputs.extend(node_outputs)
+        return outputs
+
+    def consume_frame0(self, msg, fallback_time) -> list[tuple[str, object, object]]:
+        stamp = fallback_time
+        if hasattr(msg, "header") and hasattr(msg.header, "stamp"):
+            stamp = select_time(msg.header.stamp, fallback_time)
+
+        node_id = int(getattr(msg, "id", 0))
+        panel = self.render_node(node_id, list(getattr(msg, "pixels", [])), stamp)
+        self.latest_frame0_panels[node_id] = panel
+
+        ordered_ids = sorted(self.latest_frame0_panels.keys())[:self.max_nodes]
+        outputs = []
+        if self.include_overview_image:
+            overview = self.render_overview([self.latest_frame0_panels[item] for item in ordered_ids])
+            outputs.append((self.overview_topic, self.to_ros_image(overview, stamp), select_time(stamp, fallback_time)))
+        if self.include_node_images:
+            outputs.append((self.node_topic_prefix + str(node_id), self.to_ros_image(panel, stamp), select_time(stamp, fallback_time)))
+        return outputs
+
+
+class Converter:
+    def __init__(self, args):
+        self.args = args
+        import_visual_deps()
+        (
+            self.genpy,
+            self.rosbag,
+            self.PoseStamped,
+            self.TransformStamped,
+            self.RosPath,
+            self.CompressedImage,
+            self.Image,
+            self.PointCloud2,
+            self.PointField,
+            self.TFMessage,
+        ) = import_ros_deps()
+        self.input_bag = Path(args.input_bag).resolve()
+        self.output_bag = self.resolve_output_bag()
+        self.tof_limiter = RateLimiter(args.tof_rate_hz)
+        self.tf_limiter = RateLimiter(args.tf_rate_hz)
+        self.path_limiter = RateLimiter(args.path_rate_hz)
+        self.odom_path = None
+        self.copy_topics = self.resolve_copy_topics()
+        self.renderer = TofHeatmapRenderer(
+            compressed_image_cls=self.CompressedImage,
+            raw_image_cls=self.Image,
+            max_nodes=args.tof_max_nodes,
+            grid_size=args.tof_grid_size,
+            cell_px=args.tof_cell_px,
+            min_distance_mm=args.tof_min_dis,
+            max_distance_mm=args.tof_max_dis,
+            valid_status=args.tof_valid_status,
+            colormap_name=args.tof_colormap,
+            output_format=args.tof_output_format,
+            jpeg_quality=args.tof_jpeg_quality,
+            draw_distance_text=args.tof_draw_distance_text,
+            show_tables=args.tof_show_tables,
+            include_overview_image=args.tof_image_mode in ("overview", "both"),
+            include_node_images=args.tof_image_mode in ("nodes", "both"),
+            overview_topic=args.tof_overview_topic,
+            node_topic_prefix=args.tof_node_topic_prefix,
+        )
+
+    def resolve_output_bag(self) -> Path:
+        if self.args.output_bag:
+            output = Path(self.args.output_bag).resolve()
+        else:
+            output_dir = Path(self.args.output_dir).resolve() if self.args.output_dir else self.input_bag.parent / "foxglove"
+            output = output_dir / (bag_stem(str(self.input_bag)) + "_foxglove_compact.bag")
+        if output == self.input_bag:
+            raise RuntimeError("output bag path must be different from input bag path")
+        output.parent.mkdir(parents=True, exist_ok=True)
+        if output.exists():
+            if self.args.force:
+                output.unlink()
+            else:
+                raise RuntimeError("output bag already exists: {} (use --force)".format(output))
+        return output
+
+    def resolve_copy_topics(self) -> set[str]:
+        mode = self.args.copy_mode
+        if mode == "none":
+            topics = set()
+        elif mode == "compact":
+            topics = set(COMPACT_COPY_TOPICS)
+        elif mode == "custom":
+            topics = set()
+        else:
+            topics = None
+
+        if topics is not None:
+            topics.update(parse_topic_csv(self.args.copy_topics))
+            topics.update(parse_topic_csv(self.args.keep_topics))
+        return topics
+
+    def choose_topic(self, topic_info, requested, candidates, label):
+        if requested and requested != "auto":
+            if requested not in topic_info:
+                raise RuntimeError("{} topic not found in bag: {}".format(label, requested))
+            return requested
+        for topic in candidates:
+            if topic in topic_info:
+                return topic
+        return None
+
+    def build_tf_from_pose(self, msg, bag_time):
+        if hasattr(msg, "pose") and hasattr(msg.pose, "pose"):
+            pose = msg.pose.pose
+            stamp = select_time(msg.header.stamp, bag_time)
+            parent = self.args.tf_parent_frame or getattr(msg.header, "frame_id", "") or "map"
+        elif hasattr(msg, "pose"):
+            pose = msg.pose
+            stamp = select_time(msg.header.stamp, bag_time)
+            parent = self.args.tf_parent_frame or getattr(msg.header, "frame_id", "") or "map"
+        else:
+            return None, None
+
+        transform = self.TransformStamped()
+        transform.header.stamp = stamp
+        transform.header.frame_id = parent
+        transform.child_frame_id = self.args.tf_child_frame
+        transform.transform.translation.x = pose.position.x
+        transform.transform.translation.y = pose.position.y
+        transform.transform.translation.z = pose.position.z
+        transform.transform.rotation.x = pose.orientation.x
+        transform.transform.rotation.y = pose.orientation.y
+        transform.transform.rotation.z = pose.orientation.z
+        transform.transform.rotation.w = pose.orientation.w
+        return self.TFMessage(transforms=[transform]), stamp
+
+    def build_path_from_odometry(self, msg, bag_time):
+        if hasattr(msg, "pose") and hasattr(msg.pose, "pose"):
+            pose = msg.pose.pose
+            stamp = select_time(msg.header.stamp, bag_time)
+        elif hasattr(msg, "pose"):
+            pose = msg.pose
+            stamp = select_time(msg.header.stamp, bag_time)
+        else:
+            return None, None
+
+        frame_id = self.args.path_frame
+        if frame_id == "auto":
+            frame_id = self.args.tf_parent_frame or getattr(msg.header, "frame_id", "") or "odom"
+
+        if self.odom_path is None:
+            self.odom_path = self.RosPath()
+            self.odom_path.header.frame_id = frame_id
+
+        pose_msg = self.PoseStamped()
+        pose_msg.header.stamp = stamp
+        pose_msg.header.frame_id = frame_id
+        pose_msg.pose = pose
+        self.odom_path.poses.append(pose_msg)
+
+        if self.args.path_max_poses > 0 and len(self.odom_path.poses) > self.args.path_max_poses:
+            self.odom_path.poses = self.odom_path.poses[-self.args.path_max_poses:]
+
+        self.odom_path.header.stamp = stamp
+        self.odom_path.header.frame_id = frame_id
+        return self.odom_path, stamp
+
+    def build_pointcloud2_from_livox(self, msg, bag_time):
+        stamp = bag_time
+        frame_id = "livox_frame"
+        if hasattr(msg, "header"):
+            stamp = select_time(getattr(msg.header, "stamp", None), bag_time)
+            frame_id = getattr(msg.header, "frame_id", "") or frame_id
+
+        points = []
+        for point in getattr(msg, "points", []):
+            x = float(getattr(point, "x", 0.0))
+            y = float(getattr(point, "y", 0.0))
+            z = float(getattr(point, "z", 0.0))
+            if not self.args.livox_keep_zero_points and x == 0.0 and y == 0.0 and z == 0.0:
+                continue
+            points.append((
+                x,
+                y,
+                z,
+                float(getattr(point, "reflectivity", 0)),
+                int(getattr(point, "line", 0)) & 0xFF,
+                int(getattr(point, "tag", 0)) & 0xFF,
+                int(getattr(point, "offset_time", 0)) & 0xFFFFFFFF,
+            ))
+
+        cloud = self.PointCloud2()
+        cloud.header.stamp = stamp
+        cloud.header.frame_id = frame_id
+        cloud.height = 1
+        cloud.width = len(points)
+        cloud.fields = [
+            self.PointField(name="x", offset=0, datatype=self.PointField.FLOAT32, count=1),
+            self.PointField(name="y", offset=4, datatype=self.PointField.FLOAT32, count=1),
+            self.PointField(name="z", offset=8, datatype=self.PointField.FLOAT32, count=1),
+            self.PointField(name="intensity", offset=12, datatype=self.PointField.FLOAT32, count=1),
+            self.PointField(name="line", offset=16, datatype=self.PointField.UINT8, count=1),
+            self.PointField(name="tag", offset=17, datatype=self.PointField.UINT8, count=1),
+            self.PointField(name="offset_time", offset=20, datatype=self.PointField.UINT32, count=1),
+        ]
+        cloud.is_bigendian = False
+        cloud.point_step = 24
+        cloud.row_step = cloud.point_step * cloud.width
+        cloud.is_dense = False
+
+        packer = struct.Struct("<ffffBBxxI")
+        data = bytearray(cloud.row_step)
+        for idx, point in enumerate(points):
+            packer.pack_into(data, idx * cloud.point_step, *point)
+        cloud.data = bytes(data)
+        return cloud, stamp
+
+    def output_compression(self):
+        if self.args.bag_compression == "none":
+            return "none"
+        return self.args.bag_compression
+
+    def resolve_time_window(self, in_bag):
+        if self.args.start_offset_sec is None and self.args.duration_sec is None:
+            return None, None
+
+        bag_start = float(in_bag.get_start_time())
+        bag_end = float(in_bag.get_end_time())
+        start_offset = float(self.args.start_offset_sec or 0.0)
+        start_sec = bag_start + max(0.0, start_offset)
+        if self.args.duration_sec is None:
+            end_sec = bag_end
+        else:
+            end_sec = min(bag_end, start_sec + max(0.0, float(self.args.duration_sec)))
+        if start_sec >= end_sec:
+            raise RuntimeError("empty time window: start={} end={}".format(start_sec, end_sec))
+        return self.genpy.Time.from_sec(start_sec), self.genpy.Time.from_sec(end_sec)
+
+    def write_static_tf_for_window(self, in_bag, out_bag, window_start):
+        if window_start is None:
+            return 0
+        if self.copy_topics is not None and "/tf_static" not in self.copy_topics:
+            return 0
+        written = 0
+        for _, msg, _ in in_bag.read_messages(topics=["/tf_static"]):
+            out_bag.write("/tf_static", msg, t=window_start)
+            written += 1
+        return written
+
+    def resolve_livox_calibration_path(self):
+        if not self.args.inject_livox_static_tf:
+            return None
+        calib_path = Path(self.args.livox_calibration)
+        if not calib_path.is_absolute():
+            calib_path = Path(__file__).resolve().parents[1] / calib_path
+        if not calib_path.is_file():
+            raise RuntimeError("Livox calibration file not found: {}".format(calib_path))
+        return calib_path
+
+    def load_livox_static_transform(self, stamp):
+        calib_path = self.resolve_livox_calibration_path()
+        if calib_path is None:
+            return None
+        try:
+            import yaml
+        except ImportError as exc:
+            raise RuntimeError("PyYAML is required to read Livox calibration: {}".format(calib_path)) from exc
+
+        with calib_path.open("r", encoding="utf-8") as stream:
+            calib = yaml.safe_load(stream) or {}
+
+        parent = calib.get("parent_frame")
+        child = calib.get("child_frame")
+        translation = calib.get("translation_xyz_m")
+        rotation = calib.get("rotation_xyzw")
+        if not parent or not child or translation is None or rotation is None:
+            raise RuntimeError(
+                "Livox calibration must define parent_frame, child_frame, translation_xyz_m, and rotation_xyzw: {}".format(
+                    calib_path
+                )
+            )
+        if len(translation) != 3 or len(rotation) != 4:
+            raise RuntimeError("invalid Livox calibration vector length: {}".format(calib_path))
+
+        transform = self.TransformStamped()
+        transform.header.stamp = stamp or self.genpy.Time(0)
+        transform.header.frame_id = str(parent)
+        transform.child_frame_id = str(child)
+        transform.transform.translation.x = float(translation[0])
+        transform.transform.translation.y = float(translation[1])
+        transform.transform.translation.z = float(translation[2])
+        transform.transform.rotation.x = float(rotation[0])
+        transform.transform.rotation.y = float(rotation[1])
+        transform.transform.rotation.z = float(rotation[2])
+        transform.transform.rotation.w = float(rotation[3])
+        return self.TFMessage(transforms=[transform])
+
+    def write_livox_static_tf(self, out_bag, window_start):
+        if self.copy_topics is not None and "/tf_static" not in self.copy_topics:
+            return 0
+        tf_msg = self.load_livox_static_transform(window_start)
+        if tf_msg is None:
+            return 0
+        out_bag.write("/tf_static", tf_msg, t=window_start or self.genpy.Time(0))
+        return 1
+
+    def convert(self):
+        if not self.input_bag.is_file():
+            raise RuntimeError("input bag does not exist: {}".format(self.input_bag))
+
+        processed = 0
+        copied = 0
+        tof_images = 0
+        tf_inserted = 0
+        livox_converted = 0
+        path_inserted = 0
+
+        with self.rosbag.Bag(str(self.input_bag), "r") as in_bag:
+            window_start, window_end = self.resolve_time_window(in_bag)
+            topic_info = in_bag.get_type_and_topic_info().topics
+            tof_topic = self.choose_topic(
+                topic_info,
+                self.args.tof_input_topic,
+                (TOF_CASCADE_TOPIC, TOF_FRAME0_TOPIC),
+                "ToF",
+            )
+            odom_topic = self.choose_topic(topic_info, self.args.odom_input_topic, ODOM_CANDIDATE_TOPICS, "odometry")
+            livox_topic = self.choose_topic(
+                topic_info,
+                self.args.livox_input_topic,
+                (LIVOX_LIDAR_TOPIC,),
+                "Livox lidar",
+            ) if self.args.convert_livox_pointcloud2 else None
+
+            read_topics = None
+            if self.copy_topics is not None:
+                read_topics = set(topic for topic in self.copy_topics if topic in topic_info)
+                if tof_topic:
+                    read_topics.add(tof_topic)
+                if self.args.inject_dynamic_tf and odom_topic:
+                    read_topics.add(odom_topic)
+                if livox_topic:
+                    read_topics.add(livox_topic)
+                read_topics = sorted(read_topics)
+
+            print("[INFO] input bag: {}".format(self.input_bag))
+            print("[INFO] output bag: {}".format(self.output_bag))
+            print("[INFO] copy mode: {}".format(self.args.copy_mode))
+            print("[INFO] ToF topic: {}".format(tof_topic or "not found"))
+            print("[INFO] ToF image mode: {} format={} rate={}Hz".format(
+                self.args.tof_image_mode, self.args.tof_output_format, self.args.tof_rate_hz
+            ))
+            print("[INFO] odometry topic for TF: {}".format(odom_topic or "not found"))
+            print("[INFO] odometry Path: {}".format(
+                "{} -> {}".format(odom_topic, self.args.odom_path_topic) if odom_topic and self.args.write_odom_path else "disabled/not found"
+            ))
+            print("[INFO] Livox PointCloud2: {}".format(
+                "{} -> {}".format(livox_topic, self.args.livox_pointcloud_topic) if livox_topic else "disabled/not found"
+            ))
+            print("[INFO] Livox static TF calibration: {}".format(
+                self.resolve_livox_calibration_path() if self.args.inject_livox_static_tf else "disabled"
+            ))
+            if window_start is not None:
+                print("[INFO] time window: {:.3f} -> {:.3f} ({:.3f}s)".format(
+                    window_start.to_sec(), window_end.to_sec(), window_end.to_sec() - window_start.to_sec()
+                ))
+
+            with self.rosbag.Bag(str(self.output_bag), "w", compression=self.output_compression()) as out_bag:
+                copied += self.write_static_tf_for_window(in_bag, out_bag, window_start)
+                copied += self.write_livox_static_tf(out_bag, window_start)
+
+                for topic, msg, bag_time in in_bag.read_messages(
+                    topics=read_topics,
+                    start_time=window_start,
+                    end_time=window_end,
+                ):
+                    processed += 1
+
+                    if self.copy_topics is None or topic in self.copy_topics:
+                        out_bag.write(topic, msg, t=bag_time)
+                        copied += 1
+
+                    if self.args.inject_dynamic_tf and odom_topic and topic == odom_topic and self.tf_limiter.allow(bag_time):
+                        tf_msg, tf_time = self.build_tf_from_pose(msg, bag_time)
+                        if tf_msg is not None:
+                            out_bag.write(self.args.tf_topic, tf_msg, t=tf_time)
+                            tf_inserted += 1
+
+                    if self.args.write_odom_path and odom_topic and topic == odom_topic:
+                        path_msg, path_time = self.build_path_from_odometry(msg, bag_time)
+                        if path_msg is not None and self.path_limiter.allow(path_time):
+                            out_bag.write(self.args.odom_path_topic, path_msg, t=path_time)
+                            path_inserted += 1
+
+                    if livox_topic and topic == livox_topic:
+                        cloud, cloud_time = self.build_pointcloud2_from_livox(msg, bag_time)
+                        out_bag.write(self.args.livox_pointcloud_topic, cloud, t=cloud_time)
+                        livox_converted += 1
+
+                    if tof_topic and topic == tof_topic and self.args.tof_image_mode != "none" and self.tof_limiter.allow(bag_time):
+                        if topic == TOF_CASCADE_TOPIC or hasattr(msg, "nodes") or hasattr(msg, "node"):
+                            outputs = self.renderer.consume_cascade(msg, bag_time)
+                        else:
+                            outputs = self.renderer.consume_frame0(msg, bag_time)
+                        for out_topic, out_msg, out_time in outputs:
+                            out_bag.write(out_topic, out_msg, t=out_time)
+                            tof_images += 1
+
+                    if processed % 10000 == 0:
+                        print("[RUNNING] processed={} copied={} tof_images={} tf={} path={} livox_pc2={}".format(
+                            processed, copied, tof_images, tf_inserted, path_inserted, livox_converted
+                        ))
+
+        input_size = self.input_bag.stat().st_size
+        output_size = self.output_bag.stat().st_size
+        ratio = float(output_size) / float(input_size) if input_size else 0.0
+        print("[DONE] processed={} copied={} tof_images={} tf={} path={} livox_pc2={}".format(
+            processed, copied, tof_images, tf_inserted, path_inserted, livox_converted
+        ))
+        print("[DONE] input_size={:.2f} GB output_size={:.2f} GB ratio={:.3f}".format(
+            input_size / 1e9, output_size / 1e9, ratio
+        ))
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Create a compact Foxglove visualization rosbag.")
+    parser.add_argument("--input-bag", required=True, help="Input ROS1 bag")
+    parser.add_argument("--output-bag", default=None, help="Output ROS1 bag")
+    parser.add_argument("--output-dir", default=None, help="Output directory when --output-bag is omitted")
+    parser.add_argument("--force", action="store_true", help="Overwrite output bag")
+    parser.add_argument("--start-offset-sec", type=float, default=None, help="Start offset from input bag start")
+    parser.add_argument("--duration-sec", type=float, default=None, help="Maximum duration to convert")
+
+    parser.add_argument(
+        "--copy-mode",
+        choices=("compact", "all", "none", "custom"),
+        default="compact",
+        help="Original topic copy policy. compact avoids camera/lidar by default.",
+    )
+    parser.add_argument("--copy-topics", default="", help="Comma-separated extra original topics to copy")
+    parser.add_argument(
+        "--keep-topics",
+        default="",
+        help="Alias for --copy-topics. Use with --copy-mode custom to keep exactly the listed original topics.",
+    )
+    parser.add_argument("--bag-compression", choices=("none", "bz2", "lz4"), default="bz2")
+
+    parser.add_argument("--tof-input-topic", default="auto")
+    parser.add_argument("--tof-image-mode", choices=("overview", "nodes", "both", "none"), default="overview")
+    parser.add_argument("--tof-output-format", choices=("jpeg", "png", "raw"), default="jpeg")
+    parser.add_argument(
+        "--tof-rate-hz",
+        type=float,
+        default=15.0,
+        help="Visualization image rate. 15 matches TOFSense-M 8x8 nominal rate; 0 disables throttling.",
+    )
+    parser.add_argument("--tof-overview-topic", default="/foxglove/tof/overview/compressed")
+    parser.add_argument("--tof-node-topic-prefix", default="/foxglove/tof/node_")
+    parser.add_argument("--tof-max-nodes", type=int, default=6)
+    parser.add_argument("--tof-grid-size", type=int, default=8)
+    parser.add_argument("--tof-cell-px", type=int, default=28)
+    parser.add_argument("--tof-min-dis", type=float, default=0.0)
+    parser.add_argument("--tof-max-dis", type=float, default=5000.0)
+    parser.add_argument("--tof-valid-status", type=int, default=0)
+    parser.add_argument("--tof-colormap", default="COLORMAP_TURBO")
+    parser.add_argument("--tof-jpeg-quality", type=int, default=82)
+    parser.add_argument("--tof-draw-distance-text", dest="tof_draw_distance_text", action="store_true")
+    parser.add_argument("--tof-hide-distance-text", dest="tof_draw_distance_text", action="store_false")
+    parser.set_defaults(tof_draw_distance_text=True)
+    parser.add_argument("--tof-show-tables", dest="tof_show_tables", action="store_true")
+    parser.add_argument("--tof-hide-tables", dest="tof_show_tables", action="store_false")
+    parser.set_defaults(tof_show_tables=True)
+
+    parser.add_argument("--convert-livox-pointcloud2", dest="convert_livox_pointcloud2", action="store_true")
+    parser.add_argument("--no-convert-livox-pointcloud2", dest="convert_livox_pointcloud2", action="store_false")
+    parser.set_defaults(convert_livox_pointcloud2=True)
+    parser.add_argument("--livox-input-topic", default="auto")
+    parser.add_argument("--livox-pointcloud-topic", default=LIVOX_POINTCLOUD_TOPIC)
+    parser.add_argument("--livox-keep-zero-points", action="store_true")
+    parser.add_argument("--inject-livox-static-tf", dest="inject_livox_static_tf", action="store_true")
+    parser.add_argument("--no-inject-livox-static-tf", dest="inject_livox_static_tf", action="store_false")
+    parser.set_defaults(inject_livox_static_tf=True)
+    parser.add_argument(
+        "--livox-calibration",
+        default="calibration/robot_v1_template/livox_to_base.yaml",
+        help="YAML file with parent_frame, child_frame, translation_xyz_m, and rotation_xyzw.",
+    )
+
+    parser.add_argument("--inject-dynamic-tf", dest="inject_dynamic_tf", action="store_true")
+    parser.add_argument("--no-inject-dynamic-tf", dest="inject_dynamic_tf", action="store_false")
+    parser.set_defaults(inject_dynamic_tf=True)
+    parser.add_argument("--odom-input-topic", default="auto")
+    parser.add_argument("--tf-rate-hz", type=float, default=10.0, help="0 disables TF throttling")
+    parser.add_argument("--tf-topic", default="/tf")
+    parser.add_argument("--tf-parent-frame", default="map")
+    parser.add_argument("--tf-child-frame", default="base_link")
+    parser.add_argument("--write-odom-path", dest="write_odom_path", action="store_true")
+    parser.add_argument("--no-write-odom-path", dest="write_odom_path", action="store_false")
+    parser.set_defaults(write_odom_path=True)
+    parser.add_argument("--odom-path-topic", default="/foxglove/odom/path")
+    parser.add_argument("--path-rate-hz", type=float, default=10.0, help="0 writes path at every odometry message")
+    parser.add_argument("--path-frame", default="auto", help="Path frame. auto uses --tf-parent-frame, then odometry frame.")
+    parser.add_argument("--path-max-poses", type=int, default=0, help="0 keeps the full path")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    Converter(args).convert()
+
+
+if __name__ == "__main__":
+    main()