#!/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("= 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()