Add downstream learning demo to dataset card

.gitattributes

@@ -15,3 +15,4 @@
 *.zst filter=lfs diff=lfs merge=lfs -text
 *.tar filter=lfs diff=lfs merge=lfs -text
 *.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text

README.md

@@ -143,6 +143,28 @@ examples/foxglove/visual_demo.bag  # ready-to-open Foxglove example
 
 `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`.
 
+## Downstream Learning Example
+
+The dataset can also be used for compact non-visual motion estimation research. One example uses synchronized TOFSense-M range measurements and flight-controller IMU streams as temporal inputs, with recorded odometry as the trajectory reference. This demonstrates how the ROS timestamps, topic-level synchronization, sensor metadata, and calibration files can be used to align sparse ToF structure, inertial dynamics, and trajectory supervision.
+
+<p align="center">
+  <img src="docs/assets/readme/tof_imu_realtime_inference.gif" alt="Real-time ToF and IMU inference visualization" width="86%">
+</p>
+
+| Example | Modalities | Reference signal | Purpose |
+| --- | --- | --- | --- |
+| ToF + IMU trajectory modeling | Six-node Nooploop TOFSense-M cascade and MAVROS IMU | Recorded odometry trajectory | Temporal motion prediction and qualitative trajectory fitting |
+
+<p align="center">
+  <img src="docs/assets/readme/model_trajectory_fit_summary.png" alt="Trajectory fitting summary" width="86%">
+</p>
+
+The axis-wise error visualization below reports the fitted trajectory residuals along x, y, and z, which is useful for checking drift direction, vertical consistency, and segment-level error concentration.
+
+<p align="center">
+  <img src="docs/assets/readme/model_axis_error_xyz.png" alt="Axis-wise trajectory error" width="86%">
+</p>
+
 ## Limitations
 
 - No train/validation/test split is defined in this first version.

scripts/foxglove_visualization_bridge.py

@@ -1,641 +0,0 @@
-#!/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
-from pathlib import Path
-
-cv2 = None
-np = None
-
-
-TOF_CASCADE_TOPIC = "/nlink_tofsensem_cascade"
-TOF_FRAME0_TOPIC = "/nlink_tofsensem_frame0"
-
-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 TransformStamped
-        from sensor_msgs.msg import CompressedImage, Image
-        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, TransformStamped, CompressedImage, Image, 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.TransformStamped, self.CompressedImage, self.Image, 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.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 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 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
-
-        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")
-
-            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)
-                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"))
-            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)
-
-                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 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={}".format(
-                            processed, copied, tof_images, tf_inserted
-                        ))
-
-        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={}".format(processed, copied, tof_images, tf_inserted))
-        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("--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")
-    return parser.parse_args()
-
-
-def main():
-    args = parse_args()
-    Converter(args).convert()
-
-
-if __name__ == "__main__":
-    main()