x4d-devkit 0.9.0__tar.gz → 0.11.1__tar.gz

{x4d_devkit-0.9.0/x4d_devkit.egg-info → x4d_devkit-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.9.0
+Version: 0.11.1
 Summary: X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets
 Author: windzu
 License-Expression: Apache-2.0

{x4d_devkit-0.9.0 → x4d_devkit-0.11.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "x4d-devkit"
-version = "0.9.0"
+version = "0.11.1"
 description = "X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets"
 readme = "README.md"
 license = "Apache-2.0"

{x4d_devkit-0.9.0 → x4d_devkit-0.11.1}/x4d_devkit/converters/nuscenes.py

@@ -116,6 +116,11 @@ def compose_se3(
 
 
 # --- Target sensor channels (skip radar) ---
+#
+# nuScenes stores channels uppercase (LIDAR_TOP, CAM_FRONT_*); X-4D clip
+# schema v0.7 enforces ^[a-z][a-z0-9_]{0,63}$ on channel + every frame_id
+# field. We filter against the nuScenes uppercase keys, then `_normalize`
+# everything we emit to X-4D.
 
 TARGET_CHANNELS = {
     "CAM_FRONT",
@@ -127,6 +132,12 @@ TARGET_CHANNELS = {
     "LIDAR_TOP",
 }
 
+
+def _normalize_channel(name: str) -> str:
+    """Lowercase nuScenes channel into X-4D v0.7-compliant form
+    (e.g. ``LIDAR_TOP`` → ``lidar_top``)."""
+    return name.lower()
+
 LIDAR_POINT_FORMAT = {
     "fields": ["x", "y", "z", "intensity", "ring_index"],
     "types": ["float32", "float32", "float32", "float32", "float32"],
@@ -173,18 +184,20 @@ class NuScenesConverter:
         for channel, sd_token in first_sample["data"].items():
             if channel not in TARGET_CHANNELS:
                 continue
+            x4d_ch = _normalize_channel(channel)
             sd = self.nusc.get("sample_data", sd_token)
             cs = self._cs_by_token[sd["calibrated_sensor_token"]]
             sensor = self._sensor_by_token[cs["sensor_token"]]
             if sensor["modality"] == "lidar":
-                sensors_dict[channel] = {
+                sensors_dict[x4d_ch] = {
                     "modality": "lidar",
+                    "frame_id": x4d_ch,
                     "point_format": LIDAR_POINT_FORMAT,
                 }
             elif sensor["modality"] == "camera":
-                sensors_dict[channel] = {
+                sensors_dict[x4d_ch] = {
                     "modality": "camera",
-                    "resolution": [sd["width"], sd["height"]],
+                    "frame_id": x4d_ch,
                 }
 
         # Count keyframes
@@ -213,6 +226,10 @@ class NuScenesConverter:
         last_sample = self.nusc.get("sample", scene["last_sample_token"])
         duration_s = (last_sample["timestamp"] - first_sample["timestamp"]) / 1e6
 
+        # nuScenes annotates in the LIDAR_TOP frame; SLAM also runs there, so
+        # ego_pose is also expressed for that frame in clip-local world. After
+        # normalization, both are "lidar_top".
+        ann_frame_id = _normalize_channel("LIDAR_TOP")
         meta = {
             "clip_id": clip_id,
             "session_id": log["logfile"],
@@ -222,20 +239,38 @@ class NuScenesConverter:
             "keyframe_count": keyframe_count,
             "sweep_count": sweep_count,
             "sensors": sensors_dict,
+            "annotation_frame_id": ann_frame_id,
+            "ego_pose_frame_id": ann_frame_id,
             "route_tag": None,
             "weather": None,
             "time_of_day": None,
             "scene_tags": [log.get("location", "unknown")],
-            "schema_version": "0.1",
+            "schema_version": "0.8",
         }
         return clip_id, meta
 
     def _extract_calibrated_sensors(
         self, scene: dict, clip_id: str
     ) -> list[dict]:
-        """Extract calibrated sensor records for target channels."""
+        """Extract calibrated sensor records for target channels.
+
+        v0.8: emits a self-reference root record for ``base_link`` (the
+        calibration tree root for nuScenes — cameras and lidar are all
+        calibrated relative to ego vehicle).
+        """
+        # v0.8 self-reference root record (I1 invariant).
+        records = [
+            {
+                "calibrated_sensor_token": generate_token(clip_id, "cs:base_link"),
+                "channel": "base_link",
+                "parent_frame": "base_link",  # self-reference == root marker
+                "translation": {"x": 0.0, "y": 0.0, "z": 0.0},
+                "rotation": {"qx": 0.0, "qy": 0.0, "qz": 0.0, "qw": 1.0},
+                "intrinsics": None,
+                "distortion": None,
+            }
+        ]
         first_sample = self.nusc.get("sample", scene["first_sample_token"])
-        records = []
         for channel, sd_token in first_sample["data"].items():
             if channel not in TARGET_CHANNELS:
                 continue
@@ -251,10 +286,11 @@ class NuScenesConverter:
                 else None
             )
 
+            x4d_ch = _normalize_channel(channel)
             records.append(
                 {
-                    "calibrated_sensor_token": generate_token(clip_id, f"cs:{channel}"),
-                    "channel": channel,
+                    "calibrated_sensor_token": generate_token(clip_id, f"cs:{x4d_ch}"),
+                    "channel": x4d_ch,
                     "parent_frame": parent_frame,
                     "translation": translation_to_named(cs["translation"]),
                     "rotation": quat_wxyz_to_named(cs["rotation"]),
@@ -409,7 +445,15 @@ class NuScenesConverter:
     def _extract_annotations(
         self, scene: dict, clip_id: str
     ) -> tuple[list[dict], list[dict]]:
-        """Extract annotations and instances for the scene, in **per-sample ego frame** (v0.5)."""
+        """Extract annotations and instances for the scene, in **lidar_top frame** (v0.8).
+
+        v0.8 invariant: annotation_frame_id must equal some sensor's frame_id
+        (label-source colocation). For nuScenes that's lidar_top (the original
+        labeling source). We compose:
+            T_lidar_top←world = T_lidar_top←base_link · T_base_link←world
+                              = inv(cs_lidar_extrinsic) · inv(ego_pose)
+        and apply to each annotation's world-frame box.
+        """
         annotations: list[dict] = []
         instance_anns: dict[str, list[dict]] = {}
 
@@ -421,14 +465,30 @@ class NuScenesConverter:
             sample_token_map[sample_token] = new_token
             sample_token = sample["next"]
 
+        # nuScenes lidar extrinsic in base_link (ego vehicle) frame — read once;
+        # static across the scene.
+        first_sample = self.nusc.get("sample", scene["first_sample_token"])
+        first_lidar_sd = self.nusc.get("sample_data", first_sample["data"]["LIDAR_TOP"])
+        cs_lidar = self._cs_by_token[first_lidar_sd["calibrated_sensor_token"]]
+        R_base_from_lidar = quat_to_rotation_matrix(cs_lidar["rotation"])
+        t_base_from_lidar = np.asarray(cs_lidar["translation"])
+        # Inverse: lidar_top ← base_link
+        R_lidar_from_base, t_lidar_from_base = invert_se3(R_base_from_lidar, t_base_from_lidar)
+
         sample_token = scene["first_sample_token"]
         while sample_token:
             sample = self.nusc.get("sample", sample_token)
             new_sample_token = sample_token_map[sample_token]
 
-            # Per-sample ego_pose (LIDAR_TOP keyframe) — annotation frame.
-            R_ego_global, t_ego_global = self._get_lidar_ego_pose_for_sample(sample)
-            R_inv, t_inv = invert_se3(R_ego_global, t_ego_global)
+            # base_link in world for this sample (nuScenes ego_pose).
+            R_world_from_base, t_world_from_base = self._get_lidar_ego_pose_for_sample(sample)
+            # Inverse: base_link ← world
+            R_base_from_world, t_base_from_world = invert_se3(R_world_from_base, t_world_from_base)
+            # Compose: lidar_top ← world = (lidar_top ← base_link) · (base_link ← world)
+            R_lidar_from_world, t_lidar_from_world = compose_se3(
+                R_lidar_from_base, t_lidar_from_base,
+                R_base_from_world, t_base_from_world,
+            )
 
             for ann_token in sample["anns"]:
                 ann = self.nusc.get("sample_annotation", ann_token)
@@ -437,13 +497,13 @@ class NuScenesConverter:
                     self.nusc.get("instance", nusc_instance_token)["category_token"]
                 ]["name"]
 
-                # Global → ego (this sample's ego)
+                # Global → lidar_top
                 t_global = np.asarray(ann["translation"])
-                t_ego = apply_se3(R_inv, t_inv, t_global)
+                t_lidar = apply_se3(R_lidar_from_world, t_lidar_from_world, t_global)
 
                 R_ann_global = quat_to_rotation_matrix(ann["rotation"])
-                R_ann_ego = R_inv @ R_ann_global
-                q_ann_ego = rotation_matrix_to_quat(R_ann_ego)
+                R_ann_lidar = R_lidar_from_world @ R_ann_global
+                q_ann_lidar = rotation_matrix_to_quat(R_ann_lidar)
 
                 attributes = [
                     self._attribute_by_token[at]["name"]
@@ -454,15 +514,15 @@ class NuScenesConverter:
                     int(ann["visibility_token"]) if ann["visibility_token"] else None
                 )
 
-                # Velocity: nuScenes computes globally; rotate into this sample's ego.
+                # Velocity: nuScenes computes globally; rotate into lidar_top.
                 vel_global = self._compute_velocity(ann_token)
                 if vel_global is not None:
                     vel_vec = np.array([vel_global["vx"], vel_global["vy"], vel_global["vz"]])
-                    vel_ego = R_inv @ vel_vec
+                    vel_lidar = R_lidar_from_world @ vel_vec
                     velocity = {
-                        "vx": float(vel_ego[0]),
-                        "vy": float(vel_ego[1]),
-                        "vz": float(vel_ego[2]),
+                        "vx": float(vel_lidar[0]),
+                        "vy": float(vel_lidar[1]),
+                        "vz": float(vel_lidar[2]),
                     }
                 else:
                     velocity = None
@@ -471,9 +531,9 @@ class NuScenesConverter:
                     "sample_token": new_sample_token,
                     "category": category,
                     "bbox_3d": {
-                        "translation": translation_to_named(t_ego.tolist()),
+                        "translation": translation_to_named(t_lidar.tolist()),
                         "size": size_wlh_to_named(ann["size"]),
-                        "rotation": quat_wxyz_to_named(q_ann_ego),
+                        "rotation": quat_wxyz_to_named(q_ann_lidar),
                     },
                     "num_lidar_pts": ann["num_lidar_pts"],
                     "visibility": visibility,
@@ -577,7 +637,7 @@ class NuScenesConverter:
             )
             sample_token = sample["next"]
 
-        # Build cs token mapping
+        # Build cs token mapping (same lowercase tokens as _extract_calibrated_sensors)
         cs_token_map: dict[str, str] = {}
         first_sample = self.nusc.get("sample", scene["first_sample_token"])
         for channel, sd_token in first_sample["data"].items():
@@ -585,7 +645,7 @@ class NuScenesConverter:
                 continue
             sd = self.nusc.get("sample_data", sd_token)
             cs_token_map[sd["calibrated_sensor_token"]] = generate_token(
-                clip_id, f"cs:{channel}"
+                clip_id, f"cs:{_normalize_channel(channel)}"
             )
 
         # Collect all sample_data per channel, then build prev/next
@@ -613,20 +673,21 @@ class NuScenesConverter:
                     is_kf = sd["is_key_frame"]
                     ts = sd["timestamp"]
                     prefix = "samples" if is_kf else "sweeps"
+                    x4d_ch = _normalize_channel(ch)
                     ext = ".bin" if ch == "LIDAR_TOP" else ".jpg"
-                    file_path = f"{prefix}/{ch}/{ts}{ext}"
+                    file_path = f"{prefix}/{x4d_ch}/{ts}{ext}"
 
                     per_channel[channel].append(
                         {
                             "sample_data_token": generate_token(
-                                clip_id, f"{ch}:{ts}"
+                                clip_id, f"{x4d_ch}:{ts}"
                             ),
                             "sample_token": new_sample_token,
                             "ego_pose_token": ep_old_to_new[sd["ego_pose_token"]],
                             "calibrated_sensor_token": cs_token_map[
                                 sd["calibrated_sensor_token"]
                             ],
-                            "channel": ch,
+                            "channel": x4d_ch,
                             "file_path": file_path,
                             "timestamp_us": ts,
                             "is_keyframe": is_kf,

{x4d_devkit-0.9.0 → x4d_devkit-0.11.1}/x4d_devkit/core/loader.py

@@ -154,6 +154,7 @@ class ClipLoader:
             num_sweeps=d["sweep_count"],
             sensors=sensors,
             annotation_frame_id=d.get("annotation_frame_id"),
+            ego_pose_frame_id=d.get("ego_pose_frame_id"),
         )
 
     def _load_calibrated_sensors(self) -> list[CalibratedSensor]:
@@ -166,6 +167,7 @@ class ClipLoader:
             result.append(CalibratedSensor(
                 token=r["calibrated_sensor_token"],
                 channel=r["channel"],
+                parent_frame=r.get("parent_frame"),
                 modality="camera" if intr is not None else "lidar",
                 translation=[t["x"], t["y"], t["z"]],
                 rotation=[q["qx"], q["qy"], q["qz"], q["qw"]],
@@ -293,6 +295,18 @@ class ClipLoader:
             return self._meta.annotation_frame_id
         return "base_link"
 
+    @property
+    def ego_pose_frame_id(self) -> str:
+        """The frame_id whose pose ``ego_pose.json`` expresses in clip-local world.
+
+        Returns ``meta.ego_pose_frame_id`` if explicitly set (v0.7+). Pre-v0.7
+        clips fall back to ``annotation_frame_id`` — every X-4D and nuScenes
+        clip pose is anchored to the same frame as its annotations.
+        """
+        if self._meta.ego_pose_frame_id is not None:
+            return self._meta.ego_pose_frame_id
+        return self.annotation_frame_id
+
     def frame_id_for_channel(self, channel: str) -> str:
         """Resolve the ROS frame_id of a sensor channel.
 

{x4d_devkit-0.9.0 → x4d_devkit-0.11.1}/x4d_devkit/core/models.py

@@ -137,6 +137,9 @@ class ClipMeta:
             Required by v0.6 schema. ``None`` on older clips (callers can
             consult ``ClipLoader.annotation_frame_id`` for a back-compat
             fallback that infers ``"base_link"`` for v0.5 clips).
+        ego_pose_frame_id: The ROS frame_id whose pose ``ego_pose.json``
+            expresses in clip-local world. Required by v0.7 schema. ``None``
+            on older clips (loader falls back to ``annotation_frame_id``).
     """
 
     clip_id: str
@@ -149,18 +152,22 @@ class ClipMeta:
     num_sweeps: int
     sensors: dict[str, SensorInfo]
     annotation_frame_id: str | None = None
+    ego_pose_frame_id: str | None = None
 
 
 @dataclass(frozen=True)
 class CalibratedSensor:
-    """Static sensor extrinsic calibration (sensor → ego transform).
+    """Static sensor extrinsic calibration.
 
     Attributes:
         token: Unique token for this calibrated sensor record.
         channel: Sensor channel name — equals the ROS frame_id of the sensor
             (e.g. "lidar_top", "cam_front_left").
+        parent_frame: ROS frame_id of the parent in the calibration tree.
+            v0.8 self-reference root: ``parent_frame == channel`` marks the root.
+            Pre-v0.8 clips: parent is typically "base_link" (implicit root).
         modality: "lidar" or "camera".
-        translation: (3,) float64 array — sensor position in ego frame [x, y, z] meters.
+        translation: (3,) float64 array — sensor position in parent frame [x, y, z] meters.
         rotation: (4,) float64 array — sensor orientation as quaternion [qx, qy, qz, qw].
         intrinsics: Full camera intrinsics dict (camera_model, fx, fy, cx, cy,
             image_width, image_height) or None for LiDAR.
@@ -174,6 +181,7 @@ class CalibratedSensor:
     rotation: np.ndarray
     intrinsics: dict | None
     distortion: dict | None
+    parent_frame: str | None = None
 
     def __post_init__(self) -> None:
         object.__setattr__(self, "translation", np.asarray(self.translation, dtype=np.float64))

{x4d_devkit-0.9.0 → x4d_devkit-0.11.1}/x4d_devkit/core/transform.py

@@ -200,6 +200,39 @@ class TransformChain:
         for ch in self._cs_by_channel:
             self._channel_by_frame_id.setdefault(ch, ch)
 
+        # v0.8: cached calibration tree root, derived from the self-reference
+        # record (parent_frame == channel). Older clips fall back to topology
+        # inference (root = parent_frame value not present as any channel).
+        self._root_frame_id: str | None = self._infer_root_frame_id()
+
+    def _infer_root_frame_id(self) -> str | None:
+        """Return the calibration tree root frame_id.
+
+        v0.8+ clips have an explicit self-reference record; pre-v0.8 clips
+        fall back to topology inference (the unique parent_frame that doesn't
+        appear as any record's channel).
+        """
+        # Self-reference (v0.8+).
+        for cs in self._loader.calibrated_sensors:
+            parent = getattr(cs, "parent_frame", None)
+            if parent == cs.channel:
+                return cs.channel
+        # Topology fallback (v0.7 and earlier).
+        channel_set = set(self._cs_by_channel.keys())
+        parent_set = {
+            getattr(cs, "parent_frame", None)
+            for cs in self._loader.calibrated_sensors
+        } - {None}
+        roots = parent_set - channel_set
+        if len(roots) == 1:
+            return next(iter(roots))
+        return None  # Caller may still default to "base_link" via legacy path.
+
+    @property
+    def root_frame_id(self) -> str | None:
+        """ROS frame_id of the calibration tree root (or None if undetermined)."""
+        return self._root_frame_id
+
     def get_ego_from_sensor(self, channel: str) -> Transform:
         """Get the static sensor-to-ego transform for a channel.
 
@@ -214,32 +247,76 @@ class TransformChain:
         cs = self._cs_by_channel[channel]
         return Transform.from_quat(cs.translation, cs.rotation)
 
-    def get_ego_from_frame_id(self, frame_id: str) -> Transform:
-        """Get the static frame_id-to-ego transform.
+    def get_root_from_frame_id(self, frame_id: str) -> Transform:
+        """Get the static transform from ``frame_id`` to the calibration tree root.
+
+        v0.8 unified walk: traverses parent links until a self-reference record
+        terminates (root). Pre-v0.8 clips with no self-reference record fall
+        back to "stop when parent == root_frame_id" using the inferred root.
 
-        Resolves ``frame_id`` to the calibrated channel that declares it
-        (via ``meta.sensors[ch].frame_id``, falling back to channel-name
-        equality for older clips). For ``frame_id == "base_link"`` this is
-        the identity transform.
+        For pure single-node trees (frame_id IS the root), returns identity.
 
         Args:
-            frame_id: ROS frame_id (e.g. ``"LIDAR_TOP"``, ``"camera-front"``).
+            frame_id: ROS frame_id (e.g. ``"lidar_top"``, ``"cam_front"``).
 
         Returns:
-            Transform from the named frame to the ego (base_link) frame.
+            Transform from the named frame to the calibration tree root.
 
         Raises:
-            KeyError: if no sensor declares ``frame_id``.
+            KeyError: if ``frame_id`` is not in the calibration tree.
         """
-        if frame_id == "base_link":
-            return Transform.identity()
+        # Resolve frame_id to its calibration record (or root marker).
         ch = self._channel_by_frame_id.get(frame_id)
         if ch is None:
+            # Pre-v0.8 fallback: root has no record; identity if frame_id is
+            # the inferred root.
+            if frame_id == self._root_frame_id:
+                return Transform.identity()
+            # Legacy hardcoded fallback for very old clips with no calibration tree.
+            if frame_id == "base_link":
+                return Transform.identity()
             raise KeyError(
                 f"frame_id {frame_id!r} not found in calibration tree "
                 f"(known: {sorted(self._channel_by_frame_id)})"
             )
-        return self.get_ego_from_sensor(ch)
+
+        T = Transform.identity()
+        cur = ch
+        seen: set[str] = set()
+        while True:
+            if cur in seen:
+                raise ValueError(
+                    f"calibration tree has a cycle at {cur!r}: {seen}"
+                )
+            seen.add(cur)
+            cs = self._cs_by_channel.get(cur)
+            if cs is None:
+                # Pre-v0.8: this frame is the root (no record).
+                return T
+            parent = getattr(cs, "parent_frame", None)
+            if parent == cur:
+                # v0.8 self-reference: reached root, identity transform on this hop.
+                return T
+            # Compose: T_root_from_cur = T_root_from_parent ∘ T_parent_from_cur
+            step = Transform.from_quat(cs.translation, cs.rotation)
+            T = step @ T
+            if parent is None:
+                # Pre-v0.8 with explicit None parent — also a root marker.
+                return T
+            cur = self._channel_by_frame_id.get(parent, parent)
+
+    # Backward-compat alias (v0.7 callers): "ego" is the v0.7 name for what
+    # v0.8 calls "root". For X-4D platform clips they're identical (both are
+    # "base_link"); for nuScenes-rooted clips they diverge.
+    def get_ego_from_frame_id(self, frame_id: str) -> Transform:
+        """Deprecated alias for ``get_root_from_frame_id``.
+
+        v0.7 called the calibration tree root "ego" because for X-4D platform
+        clips root == base_link == ego. v0.8 generalizes: root is whatever
+        each clip's calibration tree declares (via self-reference record),
+        not necessarily base_link / ego_vehicle.
+        """
+        return self.get_root_from_frame_id(frame_id)
 
     def get_world_from_ego(self, ego_pose_token: str) -> Transform:
         """Get the ego-to-world transform for a specific ego pose.

{x4d_devkit-0.9.0 → x4d_devkit-0.11.1}/x4d_devkit/validation/validator.py

@@ -2,12 +2,15 @@
 from __future__ import annotations
 
 import json
+import re
 from pathlib import Path
 
 import numpy as np
 
 from x4d_devkit.validation.report import ValidationReport, ValidationIssue
 
+CHANNEL_FRAME_ID_REGEX = re.compile(r"^[a-z][a-z0-9_]{0,63}$")
+
 REQUIRED_JSON_FILES = [
     "meta.json",
     "calibrated_sensor.json",
@@ -101,56 +104,192 @@ def validate_clip(clip_dir: str | Path) -> ValidationReport:
     if "meta.json" in jsons:
         clip_id = jsons["meta.json"].get("clip_id", clip_id)
 
-    # Schema v0.6: explicit annotation_frame_id + per-sensor frame_id, both
+    # Schema v0.6+: explicit annotation_frame_id + per-sensor frame_id, both
     # resolving against calibrated_sensor.json.
+    # v0.7 additions: explicit ego_pose_frame_id, lowercase regex on every
+    # channel/frame_id, and `fusion.frame` removed.
+    # v0.8 additions: self-reference root in calibrated_sensor.json,
+    # annotation_frame_id must equal some sensor's frame_id (label-source colocation).
     if "meta.json" in jsons:
         meta = jsons["meta.json"]
         sv = str(meta.get("schema_version", ""))
-        if sv == "0.6":
+        is_v06_plus = sv in {"0.6", "0.7", "0.8"}
+        is_v07_plus = sv in {"0.7", "0.8"}
+        is_v07 = sv == "0.7"
+        is_v08 = sv == "0.8"
+        if is_v06_plus:
             cs_records = jsons.get("calibrated_sensor.json", []) or []
             cs_channels = {r.get("channel") for r in cs_records if r.get("channel")}
             calib_frame_ids = set(cs_channels) | {"base_link"}
             sensors = (meta.get("sensors") or {})
             sensor_frame_ids: set[str] = set()
             for ch, info in sensors.items():
+                if is_v07_plus and not CHANNEL_FRAME_ID_REGEX.match(str(ch)):
+                    issues.append(
+                        ValidationIssue(
+                            "channel_regex",
+                            "error",
+                            f"channel {ch!r} violates v0.7+ ^[a-z][a-z0-9_]{{0,63}}$",
+                        )
+                    )
                 fid = (info or {}).get("frame_id") if isinstance(info, dict) else None
                 if not fid:
                     issues.append(
                         ValidationIssue(
                             "sensor_frame_id",
                             "error",
-                            f"sensors[{ch!r}].frame_id is required in schema 0.6",
+                            f"sensors[{ch!r}].frame_id is required in schema {sv}",
                         )
                     )
                     continue
-                sensor_frame_ids.add(fid)
-                if ch not in cs_channels:
+                if is_v07_plus and not CHANNEL_FRAME_ID_REGEX.match(str(fid)):
                     issues.append(
                         ValidationIssue(
-                            "sensor_frame_id",
+                            "frame_id_regex",
                             "error",
-                            f"sensors[{ch!r}] has no matching calibrated_sensor record",
+                            f"sensors[{ch!r}].frame_id={fid!r} violates v0.7+ regex",
                         )
                     )
+                if is_v07_plus and isinstance(info.get("fusion"), dict) and "frame" in info["fusion"]:
+                    issues.append(
+                        ValidationIssue(
+                            "fusion_frame_removed",
+                            "error",
+                            f"sensors[{ch!r}].fusion.frame is removed in v0.7+ — "
+                            "use sensors[ch].frame_id only",
+                        )
+                    )
+                sensor_frame_ids.add(fid)
+                # v0.8: lookup by frame_id (channel and frame_id are decoupled —
+                # producer-private channel name != ROS frame_id). Pre-v0.8: lookup
+                # by channel (legacy "channel ≡ frame_id" assumption).
+                if is_v08:
+                    if fid not in cs_channels:
+                        issues.append(
+                            ValidationIssue(
+                                "sensor_frame_id",
+                                "error",
+                                f"sensors[{ch!r}].frame_id={fid!r} not in calibration "
+                                f"tree (known channels: {sorted(cs_channels)})",
+                            )
+                        )
+                else:
+                    if ch not in cs_channels:
+                        issues.append(
+                            ValidationIssue(
+                                "sensor_frame_id",
+                                "error",
+                                f"sensors[{ch!r}] has no matching calibrated_sensor record",
+                            )
+                        )
             calib_frame_ids |= sensor_frame_ids
+
+            def _check_frame_id(field: str, value):
+                if not value:
+                    issues.append(
+                        ValidationIssue(
+                            field, "error",
+                            f"meta.{field} is required in schema {sv}",
+                        )
+                    )
+                    return
+                if is_v07_plus and not CHANNEL_FRAME_ID_REGEX.match(str(value)):
+                    issues.append(
+                        ValidationIssue(
+                            f"{field}_regex", "error",
+                            f"meta.{field}={value!r} violates v0.7 regex",
+                        )
+                    )
+                if value not in calib_frame_ids:
+                    issues.append(
+                        ValidationIssue(
+                            field, "error",
+                            f"{field}={value!r} does not resolve in calibration tree "
+                            f"(known: {sorted(calib_frame_ids)})",
+                        )
+                    )
+
             ann_fid = meta.get("annotation_frame_id")
-            if not ann_fid:
-                issues.append(
-                    ValidationIssue(
-                        "annotation_frame_id",
-                        "error",
-                        "meta.annotation_frame_id is required in schema 0.6",
+            _check_frame_id("annotation_frame_id", ann_fid)
+            if is_v07:
+                _check_frame_id("ego_pose_frame_id", meta.get("ego_pose_frame_id"))
+
+            for r in cs_records:
+                ch = r.get("channel")
+                if is_v07_plus and ch and not CHANNEL_FRAME_ID_REGEX.match(str(ch)):
+                    issues.append(
+                        ValidationIssue(
+                            "calibrated_sensor_channel_regex",
+                            "error",
+                            f"calibrated_sensor channel {ch!r} violates v0.7+ regex",
+                        )
                     )
-                )
-            elif ann_fid not in calib_frame_ids:
-                issues.append(
-                    ValidationIssue(
-                        "annotation_frame_id",
-                        "error",
-                        f"annotation_frame_id={ann_fid!r} does not resolve in calibration tree "
-                        f"(known: {sorted(calib_frame_ids)})",
+
+            # v0.8 I1: exactly one self-reference root record
+            if is_v08:
+                self_refs = [
+                    r for r in cs_records
+                    if r.get("channel") and r.get("parent_frame") == r.get("channel")
+                ]
+                if len(self_refs) == 0:
+                    issues.append(
+                        ValidationIssue(
+                            "self_reference_root_missing",
+                            "error",
+                            "v0.8 requires exactly 1 calibrated_sensor record with "
+                            "parent_frame == channel (self-reference root); found 0",
+                        )
+                    )
+                elif len(self_refs) > 1:
+                    issues.append(
+                        ValidationIssue(
+                            "self_reference_root_multiple",
+                            "error",
+                            f"v0.8 requires exactly 1 self-reference root; found "
+                            f"{len(self_refs)}: {[r['channel'] for r in self_refs]}",
+                        )
+                    )
+                else:
+                    # I1 cont: root record must be identity transform.
+                    root = self_refs[0]
+                    t = root.get("translation") or {}
+                    r = root.get("rotation") or {}
+                    is_identity_t = all(abs(float(t.get(k, 0))) < 1e-9 for k in "xyz")
+                    is_identity_r = (
+                        abs(float(r.get("qx", 0))) < 1e-9
+                        and abs(float(r.get("qy", 0))) < 1e-9
+                        and abs(float(r.get("qz", 0))) < 1e-9
+                        and abs(float(r.get("qw", 1)) - 1.0) < 1e-9
                     )
+                    if not (is_identity_t and is_identity_r):
+                        issues.append(
+                            ValidationIssue(
+                                "self_reference_root_not_identity",
+                                "error",
+                                f"v0.8 self-reference root {root['channel']!r} must be "
+                                "identity transform (translation=0, rotation=identity)",
+                            )
+                        )
+
+            # v0.8 I2: annotation_frame_id must equal some sensor's frame_id
+            # (label-source colocation)
+            if is_v08 and ann_fid:
+                colocated = any(
+                    info.get("frame_id") == ann_fid
+                    and info.get("modality") in {"lidar"}
+                    for info in sensors.values()
+                    if isinstance(info, dict)
                 )
+                if not colocated:
+                    issues.append(
+                        ValidationIssue(
+                            "label_source_colocation",
+                            "error",
+                            f"v0.8 requires annotation_frame_id={ann_fid!r} to equal "
+                            "some sensor's frame_id (with modality lidar) — annotations "
+                            "must be colocated with their source data",
+                        )
+                    )
 
     # If we can't parse essential files, return early
     if "sample.json" not in jsons or "sample_data.json" not in jsons:

{x4d_devkit-0.9.0 → x4d_devkit-0.11.1/x4d_devkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.9.0
+Version: 0.11.1
 Summary: X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets
 Author: windzu
 License-Expression: Apache-2.0