Group non-Unix epoch ROS 2 messages on a shared timeline (#11218)

oxkitsune · web-flow · commit f47dab6b2c33 · 2025-09-15T18:03:39.000+02:00
diff --git a/crates/store/re_data_loader/tests/snapshots/test.snap b/crates/store/re_data_loader/tests/snapshots/test.snap
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8ea1193dfe8e86ddd32a7c5926dcb7af876b31f7a1905f205c9e6549b14c394
+size 12
diff --git a/crates/store/re_data_loader/tests/snapshots/test.snap.new b/crates/store/re_data_loader/tests/snapshots/test.snap.new
diff --git a/crates/store/re_data_loader/tests/snapshots/test_mcap_loader__tests__assert_chunk_snapshot@supported_ros2_messages.mcap.snap b/crates/store/re_data_loader/tests/snapshots/test_mcap_loader__tests__assert_chunk_snapshot@supported_ros2_messages.mcap.snap
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a5007101f4ae92b50171c12aed1b51ceb482503aade827248c8d8c8fabb146f4
-size 442998
+oid sha256:9edae2d9c157373606a3909fccc9ad3dca5c4f829c0b9e8a3a3f74594c9fdc8e
+size 443218
diff --git a/crates/utils/re_mcap/src/layers/mod.rs b/crates/utils/re_mcap/src/layers/mod.rs
@@ -118,9 +118,8 @@ impl McapChunkDecoder {
 
         let channel = msg.channel.as_ref();
         let channel_id = ChannelId(channel.id);
-        let log_time_cell = crate::util::TimestampCell::guess_from_nanos(msg.log_time, "log_time");
-        let publish_time_cell =
-            crate::util::TimestampCell::guess_from_nanos(msg.publish_time, "publish_time");
+        let log_time_cell = crate::util::TimestampCell::guess_from_nanos(msg.log_time);
+        let publish_time_cell = crate::util::TimestampCell::guess_from_nanos(msg.publish_time);
         let timepoint = re_chunk::TimePoint::from([
             ("log_time", log_time_cell.into_time_cell()),
             ("publish_time", publish_time_cell.into_time_cell()),
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/rcl_interfaces/log.rs b/crates/utils/re_mcap/src/parsers/ros2msg/rcl_interfaces/log.rs
@@ -83,9 +83,8 @@ impl MessageParser for LogMessageParser {
             .context("Failed to decode `rcl_interfaces::Log` message from CDR data")?;
 
         // add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         self.text_entries.push(format!("[{name}] {log_msg}"));
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/scalar_parser.rs b/crates/utils/re_mcap/src/parsers/ros2msg/scalar_parser.rs
@@ -86,9 +86,8 @@ impl<T: ScalarExtractor> MessageParser for ScalarMessageParser<T> {
         })?;
 
         // Add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             message.header().stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         let scalar_values = message.extract_scalars();
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/camera_info.rs b/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/camera_info.rs
@@ -99,9 +99,8 @@ impl MessageParser for CameraInfoMessageParser {
         } = cdr::try_decode_message::<sensor_msgs::CameraInfo>(&msg.data)?;
 
         // add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             header.stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         self.distortion_models
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/compressed_image.rs b/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/compressed_image.rs
@@ -51,9 +51,8 @@ impl MessageParser for CompressedImageMessageParser {
         } = cdr::try_decode_message::<sensor_msgs::CompressedImage<'_>>(&msg.data)?;
 
         // add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(TimestampCell::guess_from_nanos_ros2(
             header.stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         self.blobs.push(data.into_owned());
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/image.rs b/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/image.rs
@@ -75,9 +75,8 @@ impl MessageParser for ImageMessageParser {
             .context("Failed to decode sensor_msgs::Image message from CDR data")?;
 
         // add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             header.stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         let dimensions = [width, height];
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/imu.rs b/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/imu.rs
@@ -74,9 +74,8 @@ impl MessageParser for ImuMessageParser {
             .map_err(|err| Error::Other(anyhow::anyhow!(err)))?;
 
         // add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             imu.header.stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         self.orientation.values().append_slice(&[
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/joint_state.rs b/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/joint_state.rs
@@ -45,9 +45,8 @@ impl MessageParser for JointStateMessageParser {
             .map_err(|err| Error::Other(anyhow::anyhow!(err)))?;
 
         // add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             header.stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         for name in &name {
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/magnetic_field.rs b/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/magnetic_field.rs
@@ -43,9 +43,8 @@ impl MessageParser for MagneticFieldMessageParser {
                 .map_err(|err| Error::Other(anyhow::anyhow!(err)))?;
 
         // add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             magnetic_field.header.stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         // Convert magnetic field vector to Vector3D and store
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/nav_sat_fix.rs b/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/nav_sat_fix.rs
@@ -69,9 +69,8 @@ impl MessageParser for NavSatFixMessageParser {
             .context("Failed to decode sensor_msgs::NavSatFix message from CDR data")?;
 
         // add the sensor timestamp to the context, `log_time` and `publish_time` are added automatically
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             header.stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         // Store latitude/longitude as geographic points
diff --git a/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/point_cloud_2.rs b/crates/utils/re_mcap/src/parsers/ros2msg/sensor_msgs/point_cloud_2.rs
@@ -331,9 +331,8 @@ impl MessageParser for PointCloud2MessageParser {
         let point_cloud = cdr::try_decode_message::<sensor_msgs::PointCloud2>(msg.data.as_ref())
             .map_err(|err| Error::Other(anyhow::anyhow!(err)))?;
 
-        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos(
+        ctx.add_timestamp_cell(crate::util::TimestampCell::guess_from_nanos_ros2(
             point_cloud.header.stamp.as_nanos() as u64,
-            msg.channel.topic.clone(),
         ));
 
         let Self {
diff --git a/crates/utils/re_mcap/src/util.rs b/crates/utils/re_mcap/src/util.rs
@@ -28,7 +28,7 @@ pub fn read_summary<R: Read + Seek>(mut reader: R) -> anyhow::Result<Option<Summ
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum TimestampCell {
     /// Unix epoch (nanoseconds since 1970-01-01).
-    Unix { time: TimeCell },
+    Unix { timeline: String, time: TimeCell },
 
     /// User-understood epoch with a named timeline (nanoseconds since custom zero).
     Custom { timeline: String, time: TimeCell },
@@ -40,33 +40,49 @@ impl TimestampCell {
     const YEAR_2100_NS: i64 = 4_102_444_800_000_000_000; // 2100-01-01
 
     /// Make a best-effort guess on the epoch type based on the provided raw timestamp.
-    pub fn guess_from_nanos(timestamp_ns: u64, timeline: impl Into<String>) -> Self {
+    pub fn guess_from_nanos_with_names(
+        timestamp_ns: u64,
+        timestamp_timeline: impl Into<String>,
+        duration_timeline: impl Into<String>,
+    ) -> Self {
         let ns = timestamp_ns as i64; // safe for our bounds
 
         if ns >= Self::YEAR_1990_NS && ns <= Self::YEAR_2100_NS {
             Self::Unix {
+                timeline: timestamp_timeline.into(),
                 time: TimeCell::from_timestamp_nanos_since_epoch(ns),
             }
         } else {
             Self::Custom {
-                timeline: timeline.into(),
+                timeline: duration_timeline.into(),
                 time: TimeCell::from_duration_nanos(ns),
             }
         }
     }
 
+    /// Make a best-effort guess on the epoch type based on the provided raw timestamp, using
+    /// the default timeline names `timestamp` and `duration`.
+    pub fn guess_from_nanos(timestamp_ns: u64) -> Self {
+        Self::guess_from_nanos_with_names(timestamp_ns, "timestamp", "duration")
+    }
+
+    /// Make a best-effort guess on the epoch type based on the provided raw timestamp, using
+    /// the default timeline names `ros2_timestamp` and `ros2_duration`.
+    pub fn guess_from_nanos_ros2(timestamp_ns: u64) -> Self {
+        Self::guess_from_nanos_with_names(timestamp_ns, "ros2_timestamp", "ros2_duration")
+    }
+
     /// The timeline name for this timestamp.
     pub fn timeline_name(&self) -> &str {
         match self {
-            Self::Unix { .. } => "timestamp",
-            Self::Custom { timeline, .. } => timeline,
+            Self::Custom { timeline, .. } | Self::Unix { timeline, .. } => timeline,
         }
     }
 
     /// Extract the contained [`TimeCell`].
     pub fn into_time_cell(self) -> TimeCell {
         match self {
-            Self::Unix { time } | Self::Custom { time, .. } => time,
+            Self::Unix { time, .. } | Self::Custom { time, .. } => time,
         }
     }
 }
@@ -81,8 +97,8 @@ mod tests {
     fn test_guess_from_nanos() {
         // within reasonable unix range for `TimestampCell::Unix`
         let unix_ts_2023: u64 = 1_672_531_200_000_000_000; // 2023-01-01
-        let cell = TimestampCell::guess_from_nanos(unix_ts_2023, "test_timeline");
-        let TimestampCell::Unix { time } = cell else {
+        let cell = TimestampCell::guess_from_nanos(unix_ts_2023);
+        let TimestampCell::Unix { timeline: _, time } = cell else {
             panic!("expected `TimestampCell::Unix` variant")
         };
 
@@ -91,32 +107,32 @@ mod tests {
             time,
             TimeCell::from_timestamp_nanos_since_epoch(unix_ts_2023 as i64)
         );
-        assert_eq!(TimestampCell::Unix { time }.timeline_name(), "timestamp");
+        assert_eq!(cell.timeline_name(), "timestamp");
 
         // early date for `TimestampCell::Custom`
         let early: u64 = 100_000_000;
-        let cell = TimestampCell::guess_from_nanos(early, "test_timeline");
+        let cell = TimestampCell::guess_from_nanos(early);
         let TimestampCell::Custom { timeline, time } = cell else {
             panic!("expected `TimestampCell::Custom` variant")
         };
-        assert_eq!(timeline, "test_timeline");
+        assert_eq!(timeline, "duration");
         assert!(matches!(time.typ, TimeType::DurationNs));
         assert_eq!(time, TimeCell::from_duration_nanos(early as i64));
 
         // after 2100 for `TimestampCell::Custom`
         let far_future: u64 = 5_000_000_000_000_000_000;
-        let cell = TimestampCell::guess_from_nanos(far_future, "test_timeline");
+        let cell = TimestampCell::guess_from_nanos(far_future);
         let TimestampCell::Custom { timeline, time } = cell else {
             panic!("expected `TimestampCell::Custom` variant")
         };
-        assert_eq!(timeline, "test_timeline");
+        assert_eq!(timeline, "duration");
         assert!(matches!(time.typ, TimeType::DurationNs));
         assert_eq!(time, TimeCell::from_duration_nanos(far_future as i64));
 
         // exactly 1990-01-01 for `TimestampCell::Unix`
         let year_1990 = TimestampCell::YEAR_1990_NS as u64;
-        let cell = TimestampCell::guess_from_nanos(year_1990, "test_timeline");
-        let TimestampCell::Unix { time } = cell else {
+        let cell = TimestampCell::guess_from_nanos(year_1990);
+        let TimestampCell::Unix { timeline: _, time } = cell else {
             panic!("expected `TimestampCell::Unix` at lower boundary")
         };
         assert!(matches!(time.typ, TimeType::TimestampNs));
@@ -127,8 +143,8 @@ mod tests {
 
         // exactly 2100-01-01 for `TimestampCell::Unix`
         let year_2100 = TimestampCell::YEAR_2100_NS as u64;
-        let cell = TimestampCell::guess_from_nanos(year_2100, "test_timeline");
-        let TimestampCell::Unix { time } = cell else {
+        let cell = TimestampCell::guess_from_nanos(year_2100);
+        let TimestampCell::Unix { timeline: _, time } = cell else {
             panic!("expected `TimestampCell::Unix` at upper boundary")
         };
         assert!(matches!(time.typ, TimeType::TimestampNs));
@@ -139,28 +155,29 @@ mod tests {
 
         // just outside lower boundary for `TimestampCell::Custom`
         let before_1990 = (TimestampCell::YEAR_1990_NS - 1) as u64;
-        let cell = TimestampCell::guess_from_nanos(before_1990, "test_timeline");
+        let cell = TimestampCell::guess_from_nanos(before_1990);
         let TimestampCell::Custom { timeline, time } = cell else {
             panic!("expected `TimestampCell::Custom` just before lower boundary")
         };
-        assert_eq!(timeline, "test_timeline");
+        assert_eq!(timeline, "duration");
         assert!(matches!(time.typ, TimeType::DurationNs));
         assert_eq!(time, TimeCell::from_duration_nanos(before_1990 as i64));
 
         // just outside upper boundary for `TimestampCell::Custom`
         let after_2100 = (TimestampCell::YEAR_2100_NS + 1) as u64;
-        let cell = TimestampCell::guess_from_nanos(after_2100, "test_timeline");
+        let cell = TimestampCell::guess_from_nanos(after_2100);
         let TimestampCell::Custom { timeline, time } = cell else {
             panic!("expected `TimestampCell::Custom` just after upper boundary")
         };
-        assert_eq!(timeline, "test_timeline");
+        assert_eq!(timeline, "duration");
         assert!(matches!(time.typ, TimeType::DurationNs));
         assert_eq!(time, TimeCell::from_duration_nanos(after_2100 as i64));
     }
 
     #[test]
     fn test_timeline_name() {
         let unix = TimestampCell::Unix {
+            timeline: "timestamp".to_owned(),
             time: TimeCell::from_timestamp_nanos_since_epoch(1_234_567_890),
         };
         assert_eq!(unix.timeline_name(), "timestamp");
@@ -175,7 +192,10 @@ mod tests {
     #[test]
     fn test_into_time_cell() {
         let timestamp1 = TimeCell::from_timestamp_nanos_since_epoch(42);
-        let unix = TimestampCell::Unix { time: timestamp1 };
+        let unix = TimestampCell::Unix {
+            timeline: "timestamp".to_owned(),
+            time: timestamp1,
+        };
         assert_eq!(unix.into_time_cell(), timestamp1);
 
         let timestamp2 = TimeCell::from_duration_nanos(1337);
diff --git a/docs/content/reference/mcap/message-formats.md b/docs/content/reference/mcap/message-formats.md
@@ -16,6 +16,12 @@ The `ros2msg` layer provides automatic visualization for common ROS2 message typ
 
 We are continually adding support for more standard ROS2 message types. For the complete list of currently supported messages, see the [ROS2 message parsers in our codebase](../../../../crates/utils/re_mcap/src/layers/ros2.rs).
 
+### Timelines
+
+In addition to the `log_time` and `publish_time` timestamps that are part of an MCAP message, some ROS message payloads can have an additional [`Header`]( https://docs.ros.org/en/noetic/api/std_msgs/html/msg/Header.html) that may also contain timestamp information. These timestamps are put onto specific `ros2_*` timelines.
+
+Timestamps within Unix time range (1990-2100) create a `ros2_timestamp` timeline. Values outside this range create a `ros2_duration` timeline representing relative time from custom epochs.
+
 ### Limitations
 
 The following are known limitations and link to the corresponding GitHub issues.

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+version https://git-lfs.github.com/spec/v1`
	`2`	`+oid sha256:b8ea1193dfe8e86ddd32a7c5926dcb7af876b31f7a1905f205c9e6549b14c394`
	`3`	`+size 12`