Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+HOT3DHUGGFACE/dataset/P0002_2f137f83/recording.vrs filter=lfs diff=lfs merge=lfs -text

HOT3DHUGGFACE/.gitattributes

@@ -0,0 +1,2 @@
+# GitHub syntax highlighting
+pixi.lock linguist-language=YAML

HOT3DHUGGFACE/.gitignore

@@ -0,0 +1,4 @@
+# pixi environments
+.pixi
+# dataset download instruction
+/dataset/**

HOT3DHUGGFACE/Data_Reader.ipynb

@@ -0,0 +1,675 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ee215408-e60b-4209-a09a-f84a8fd5ffa1",
+   "metadata": {},
+   "source": [
+    "# HOT3D Data Reader\n",
+    "\n",
+    "This notebook is adapted from the HOT3D official tutorial. It supports both **Aria** and **Quest3** devices and uses only the **MANO** hand model (no UmeTrack or object assets required).\n",
+    "\n",
+    "## Sections\n",
+    "- **Section 0**: Initialization (update the two paths, then run)\n",
+    "- **Section 1**: Image streams + camera calibration\n",
+    "- **Section 2.a**: Device / headset pose trajectory\n",
+    "- **Section 2.b**: Hand wrist trajectory\n",
+    "- **Section 2.b.a**: Hand landmarks (skeleton) + mesh\n",
+    "- **Section 2.c**: Object poses (requires assets folder, skipped automatically otherwise)\n",
+    "- **Section 3.b**: Hand 2D bounding boxes\n",
+    "- **Section 4**: Eye gaze (Aria only, skipped automatically on Quest3)\n",
+    "- **Section 5**: Hand keypoint reprojection onto image\n",
+    "\n",
+    "```\n",
+    "Hot3dDataProvider\n",
+    "|- device_data_provider        -> image data + camera calibration\n",
+    "|- device_pose_data_provider   -> device pose\n",
+    "|- mano_hand_data_provider     -> hand pose (MANO)\n",
+    "|- object_pose_data_provider   -> object pose\n",
+    "|- hand_box2d_data_provider    -> hand 2D bounding boxes\n",
+    "|- object_box2d_data_provider  -> object 2D bounding boxes\n",
+    "```\n",
+    "\n",
+    "> All pose data is in **world coordinates** (meters)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97bcb96c-4910-4a60-9a41-c3b34ee7ac7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 0: DataProvider initialization\n",
+    "#\n",
+    "# Only the two paths below need to be updated; everything else adapts automatically\n",
+    "# to Aria or Quest3.\n",
+    "\n",
+    "import os\n",
+    "import sys\n",
+    "\n",
+    "# Make sure the hot3d package is importable from this notebook\n",
+    "notebook_dir = os.path.abspath('')\n",
+    "if notebook_dir not in sys.path:\n",
+    "    sys.path.insert(0, notebook_dir)\n",
+    "\n",
+    "from dataset_api import Hot3dDataProvider\n",
+    "from data_loaders.mano_layer import MANOHandModel\n",
+    "from data_loaders.headsets import Headset\n",
+    "from projectaria_tools.core.stream_id import StreamId\n",
+    "\n",
+    "# ── Update these two paths ───────────────────────────────────────\n",
+    "sequence_path   = \"/home/zhang/3D_Reconstruct/HOT3D/hot3d/hot3d/dataset/P0002_2f137f83\"\n",
+    "mano_model_path = \"/home/zhang/Downloads/mano_v1_2/models\"\n",
+    "# ────────────────────────────────────────────────────────────────\n",
+    "\n",
+    "# Load MANO hand model (requires smplx: pip install smplx)\n",
+    "mano_hand_model = MANOHandModel(mano_model_path)\n",
+    "\n",
+    "# Initialize the data provider.\n",
+    "# object_library=None: no assets folder needed when only reading hand data.\n",
+    "hot3d_data_provider = Hot3dDataProvider(\n",
+    "    sequence_folder=sequence_path,\n",
+    "    object_library=None,\n",
+    "    mano_hand_model=mano_hand_model,\n",
+    ")\n",
+    "\n",
+    "# Auto-detect device type and pick the corresponding primary camera stream_id\n",
+    "device_type = hot3d_data_provider.get_device_type()\n",
+    "print(f\"Device type: {device_type}\")\n",
+    "\n",
+    "if device_type == Headset.Aria:\n",
+    "    main_stream_id = StreamId(\"214-1\")   # Aria: RGB camera\n",
+    "else:\n",
+    "    main_stream_id = StreamId(\"1201-1\")  # Quest3: SLAM Left camera\n",
+    "\n",
+    "print(f\"Primary stream_id: {main_stream_id}\")\n",
+    "print(f\"Data statistics: {hot3d_data_provider.get_data_statistics()}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24dae021-1cfe-440a-a5c8-6f44851219e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Utility functions for Rerun visualization\n",
+    "\n",
+    "import rerun as rr\n",
+    "import numpy as np\n",
+    "from projectaria_tools.core.sophus import SE3\n",
+    "from projectaria_tools.utils.rerun_helpers import ToTransform3D\n",
+    "\n",
+    "\n",
+    "def log_image(image: np.array, label: str, static=False) -> None:\n",
+    "    rr.log(label, rr.Image(image), static=static)\n",
+    "\n",
+    "\n",
+    "def log_pose(pose: SE3, label: str, static=False) -> None:\n",
+    "    rr.log(label, ToTransform3D(pose, False), static=static)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7447d83-bf07-4bfb-8e4f-9d548617cde7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 1: Image streams + camera calibration\n",
+    "\n",
+    "from tqdm import tqdm\n",
+    "from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions\n",
+    "\n",
+    "device_data_provider = hot3d_data_provider.device_data_provider\n",
+    "image_stream_ids = device_data_provider.get_image_stream_ids()\n",
+    "\n",
+    "# Timestamp retrieval differs between Aria and Quest3\n",
+    "if device_type == Headset.Aria:\n",
+    "    timestamps = device_data_provider.get_sequence_timestamps(\n",
+    "        stream_id=main_stream_id,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "else:\n",
+    "    timestamps = device_data_provider.get_sequence_timestamps()\n",
+    "\n",
+    "print(f\"Sequence : {os.path.basename(os.path.normpath(sequence_path))}\")\n",
+    "print(f\"Streams  : {image_stream_ids}\")\n",
+    "print(f\"Frames   : {len(timestamps)}\")\n",
+    "\n",
+    "rr.init(\"Device images\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "# Sample one frame every 200 timestamps to keep the visualization fast\n",
+    "for timestamp_ns in tqdm(timestamps[::200]):\n",
+    "    for stream_id in image_stream_ids:\n",
+    "        image_stream_label = device_data_provider.get_image_stream_label(stream_id)\n",
+    "        image_data = device_data_provider.get_image(timestamp_ns, stream_id)\n",
+    "        if image_data is not None:\n",
+    "            log_image(label=f\"img/{image_stream_label}\", image=image_data)\n",
+    "\n",
+    "# Print calibration parameters for each camera stream\n",
+    "for stream_id in image_stream_ids:\n",
+    "    [extrinsics, intrinsics] = device_data_provider.get_camera_calibration(stream_id)\n",
+    "    label = device_data_provider.get_image_stream_label(stream_id)\n",
+    "    print(f\"\\n[{label}] intrinsics: {intrinsics}\")\n",
+    "\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d199e9c-7359-43b2-8ecd-807db548def0",
+   "metadata": {},
+   "source": [
+    "# GT Data Provider API\n",
+    "\n",
+    "All GT data providers share the same query interface:\n",
+    "```python\n",
+    "result = provider.get_X_at_timestamp(\n",
+    "    timestamp_ns=timestamp_ns,\n",
+    "    time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "    time_domain=TimeDomain.TIME_CODE,\n",
+    ")\n",
+    "```\n",
+    "- If the exact timestamp is not found, the **closest** sample is returned.\n",
+    "- The delta time (`dt`) between the queried and returned timestamp is also available.\n",
+    "\n",
+    "Available providers:\n",
+    "```\n",
+    "|- device_pose_data_provider   -> device/headset pose\n",
+    "|- mano_hand_data_provider     -> hand pose (MANO)\n",
+    "|- object_pose_data_provider   -> object pose\n",
+    "|- hand_box2d_data_provider    -> hand 2D bbox + visibility\n",
+    "|- object_box2d_data_provider  -> object 2D bbox + visibility\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7c473c3-174f-4cff-9d58-0650b580da72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 2.a: Device / headset pose trajectory\n",
+    "\n",
+    "device_pose_provider = hot3d_data_provider.device_pose_data_provider\n",
+    "\n",
+    "rr.init(\"Device/Headset trajectory\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "pose_translations = []\n",
+    "for timestamp_ns in tqdm(timestamps):\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    if device_pose_provider is None:\n",
+    "        continue\n",
+    "    result = device_pose_provider.get_pose_at_timestamp(\n",
+    "        timestamp_ns=timestamp_ns,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "    if result is None:\n",
+    "        continue\n",
+    "\n",
+    "    T_world_device = result.pose3d.T_world_device\n",
+    "    log_pose(pose=T_world_device, label=\"world/device\")\n",
+    "    pose_translations.append(T_world_device.translation()[0])\n",
+    "\n",
+    "rr.log(\"world/device_trajectory\", rr.LineStrips3D([pose_translations]), static=True)\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5253618-2ca2-4d11-a605-aa5aa19c54eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 2.b: Hand wrist trajectory (MANO only)\n",
+    "\n",
+    "hand_data_provider = hot3d_data_provider.mano_hand_data_provider\n",
+    "if hand_data_provider is None:\n",
+    "    print(\"MANO hand data provider not initialized. Check mano_model_path and smplx installation.\")\n",
+    "\n",
+    "rr.init(\"Hand wrist trajectory\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "left_traj, right_traj = [], []\n",
+    "for timestamp_ns in tqdm(timestamps):\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    if hand_data_provider is None:\n",
+    "        continue\n",
+    "    result = hand_data_provider.get_pose_at_timestamp(\n",
+    "        timestamp_ns=timestamp_ns,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "    if result is None:\n",
+    "        continue\n",
+    "\n",
+    "    for hand_pose in result.pose3d_collection.poses.values():\n",
+    "        label = hand_pose.handedness_label()\n",
+    "        T_world_wrist = hand_pose.wrist_pose\n",
+    "        log_pose(pose=T_world_wrist, label=f\"world/hand/{label}\")\n",
+    "        if hand_pose.is_left_hand():\n",
+    "            left_traj.append(T_world_wrist.translation()[0])\n",
+    "        else:\n",
+    "            right_traj.append(T_world_wrist.translation()[0])\n",
+    "\n",
+    "if left_traj:\n",
+    "    rr.log(\"world/left_hand_traj\", rr.LineStrips3D([left_traj]), static=True)\n",
+    "if right_traj:\n",
+    "    rr.log(\"world/right_hand_traj\", rr.LineStrips3D([right_traj]), static=True)\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a013c63-65e6-4c38-b378-141c8c7ae3ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 2.b.a: Hand landmarks (skeleton) and mesh\n",
+    "#\n",
+    "# Left hand  -> landmark line strips (skeleton)\n",
+    "# Right hand -> triangular mesh\n",
+    "\n",
+    "from data_loaders.hand_common import LANDMARK_CONNECTIVITY\n",
+    "\n",
+    "hand_data_provider = hot3d_data_provider.mano_hand_data_provider\n",
+    "\n",
+    "rr.init(\"Hand Landmark / Mesh\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "for timestamp_ns in tqdm(timestamps[:300]):\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    if hand_data_provider is None:\n",
+    "        continue\n",
+    "    result = hand_data_provider.get_pose_at_timestamp(\n",
+    "        timestamp_ns=timestamp_ns,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "    if result is None:\n",
+    "        continue\n",
+    "\n",
+    "    for hand_pose in result.pose3d_collection.poses.values():\n",
+    "        label = hand_pose.handedness_label()\n",
+    "\n",
+    "        if hand_pose.is_left_hand():\n",
+    "            # Skeleton: connected landmark line strips\n",
+    "            landmarks = hand_data_provider.get_hand_landmarks(hand_pose)\n",
+    "            points = [\n",
+    "                [landmarks[i].numpy().tolist() for i in conn]\n",
+    "                for conn in LANDMARK_CONNECTIVITY\n",
+    "            ]\n",
+    "            rr.log(f\"world/{label}/joints\", rr.LineStrips3D(points, radii=0.002))\n",
+    "\n",
+    "        else:\n",
+    "            # Mesh: vertices, triangle indices, and vertex normals\n",
+    "            verts = hand_data_provider.get_hand_mesh_vertices(hand_pose)\n",
+    "            triangles, normals = hand_data_provider.get_hand_mesh_faces_and_normals(hand_pose)\n",
+    "            rr.log(\n",
+    "                f\"world/{label}/mesh\",\n",
+    "                rr.Mesh3D(\n",
+    "                    vertex_positions=verts,\n",
+    "                    vertex_normals=normals,\n",
+    "                    triangle_indices=triangles,\n",
+    "                ),\n",
+    "            )\n",
+    "\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a909427f-d8c5-40a7-8eba-8702de2a313b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 2.c: Object poses\n",
+    "# Requires object_library (assets folder). Skipped automatically if not available.\n",
+    "\n",
+    "if hot3d_data_provider._object_library is None:\n",
+    "    print(\"Skipping Section 2.c: object_library=None (no assets folder loaded)\")\n",
+    "else:\n",
+    "    from data_loaders.loader_object_library import ObjectLibrary\n",
+    "    object_library = hot3d_data_provider._object_library\n",
+    "    object_pose_data_provider = hot3d_data_provider.object_pose_data_provider\n",
+    "    object_cache_status = {}\n",
+    "\n",
+    "    rr.init(\"Object pose\")\n",
+    "    rec = rr.memory_recording()\n",
+    "\n",
+    "    for timestamp_ns in tqdm(timestamps[100:300]):\n",
+    "        rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "        rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "        result = object_pose_data_provider.get_pose_at_timestamp(\n",
+    "            timestamp_ns=timestamp_ns,\n",
+    "            time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "            time_domain=TimeDomain.TIME_CODE,\n",
+    "        )\n",
+    "        if result is None:\n",
+    "            continue\n",
+    "\n",
+    "        object_uids = object_pose_data_provider.object_uids_with_poses\n",
+    "        logging_status = {x: False for x in object_uids}\n",
+    "\n",
+    "        for object_uid, object_pose3d in result.pose3d_collection.poses.items():\n",
+    "            object_name = object_library.object_id_to_name_dict[object_uid] + \"_\" + str(object_uid)\n",
+    "            log_pose(pose=object_pose3d.T_world_object, label=f\"world/objects/{object_name}\")\n",
+    "            logging_status[object_uid] = True\n",
+    "            if object_uid not in object_cache_status:\n",
+    "                object_cache_status[object_uid] = True\n",
+    "                asset_path = ObjectLibrary.get_cad_asset_path(\n",
+    "                    object_library_folderpath=object_library.asset_folder_name,\n",
+    "                    object_id=object_uid,\n",
+    "                )\n",
+    "                rr.log(f\"world/objects/{object_name}\", rr.Asset3D(path=asset_path))\n",
+    "\n",
+    "        for object_uid, displayed in logging_status.items():\n",
+    "            if not displayed:\n",
+    "                object_name = object_library.object_id_to_name_dict[object_uid] + \"_\" + str(object_uid)\n",
+    "                rr.log(f\"world/objects/{object_name}\", rr.Clear.recursive())\n",
+    "                object_cache_status.pop(object_uid, None)\n",
+    "\n",
+    "    rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f31214ce-108e-403e-b66f-2c224ab450f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 3: 2D Bounding Boxes\n",
+    "# Bbox data is queried by TIMESTAMP + STREAM_ID and contains an amodal bbox and a visibility ratio."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b841145d-a114-4693-a0d4-492f9629bbbe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 3.a: Object 2D bounding boxes\n",
+    "# Requires object_library. Skipped automatically if not available.\n",
+    "\n",
+    "if hot3d_data_provider._object_library is None:\n",
+    "    print(\"Skipping Section 3.a: object_library=None\")\n",
+    "else:\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    object_library = hot3d_data_provider._object_library\n",
+    "    object_box2d_data_provider = hot3d_data_provider.object_box2d_data_provider\n",
+    "    object_uids = list(object_box2d_data_provider.object_uids)\n",
+    "    color_map = plt.get_cmap(\"viridis\")\n",
+    "    object_box2d_colors = color_map(np.linspace(0, 1, len(object_uids)))\n",
+    "\n",
+    "    rr.init(\"Object bounding boxes\")\n",
+    "    rec = rr.memory_recording()\n",
+    "\n",
+    "    stream_id = main_stream_id\n",
+    "    for timestamp_ns in tqdm(timestamps[100:200]):\n",
+    "        rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "        rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "        result = object_box2d_data_provider.get_bbox_at_timestamp(\n",
+    "            stream_id=stream_id,\n",
+    "            timestamp_ns=timestamp_ns,\n",
+    "            time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "            time_domain=TimeDomain.TIME_CODE,\n",
+    "        )\n",
+    "        if result is None or result.box2d_collection is None:\n",
+    "            continue\n",
+    "\n",
+    "        for object_uid in result.box2d_collection.object_uid_list:\n",
+    "            object_name = object_library.object_id_to_name_dict[object_uid]\n",
+    "            ab = result.box2d_collection.box2ds[object_uid]\n",
+    "            bbox = ab.box2d\n",
+    "            if bbox is None:\n",
+    "                continue\n",
+    "            rr.log(\n",
+    "                f\"{stream_id}_raw/bbox/{object_name}\",\n",
+    "                rr.Boxes2D(mins=[bbox.left, bbox.top], sizes=[bbox.width, bbox.height],\n",
+    "                           colors=object_box2d_colors[object_uids.index(object_uid)]),\n",
+    "            )\n",
+    "            rr.log(f\"visibility/{object_name}\", rr.Scalar(ab.visibility_ratio))\n",
+    "            image_data = device_data_provider.get_image(timestamp_ns, stream_id)\n",
+    "            if image_data is not None:\n",
+    "                log_image(label=f\"{stream_id}_raw\", image=image_data)\n",
+    "\n",
+    "    rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d1daf98-2df6-4d0a-ae38-331060353b99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 3.b: Hand 2D bounding boxes\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "from data_loaders.loader_hand_poses import LEFT_HAND_INDEX, RIGHT_HAND_INDEX\n",
+    "\n",
+    "hand_box2d_data_provider = hot3d_data_provider.hand_box2d_data_provider\n",
+    "hand_uids = [LEFT_HAND_INDEX, RIGHT_HAND_INDEX]\n",
+    "hand_names = {LEFT_HAND_INDEX: \"left\", RIGHT_HAND_INDEX: \"right\"}\n",
+    "color_map = plt.get_cmap(\"viridis\")\n",
+    "hand_box2d_colors = color_map(np.linspace(0, 1, 2))\n",
+    "\n",
+    "rr.init(\"Hand bounding boxes\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "stream_id = main_stream_id\n",
+    "if stream_id not in hand_box2d_data_provider.stream_ids:\n",
+    "    print(f\"stream_id {stream_id} has no hand bbox data. Available: {hand_box2d_data_provider.stream_ids}\")\n",
+    "\n",
+    "for timestamp_ns in tqdm(timestamps[100:200]):\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    result = hand_box2d_data_provider.get_bbox_at_timestamp(\n",
+    "        stream_id=stream_id,\n",
+    "        timestamp_ns=timestamp_ns,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "    if result is None or result.box2d_collection is None:\n",
+    "        continue\n",
+    "\n",
+    "    for i, hand_uid in enumerate(hand_uids):\n",
+    "        ab = result.box2d_collection.box2ds[hand_uid]\n",
+    "        bbox = ab.box2d\n",
+    "        if bbox is None:\n",
+    "            continue\n",
+    "        hand_name = hand_names[hand_uid]\n",
+    "        rr.log(\n",
+    "            f\"{stream_id}_raw/bbox/{hand_name}\",\n",
+    "            rr.Boxes2D(mins=[bbox.left, bbox.top], sizes=[bbox.width, bbox.height],\n",
+    "                       colors=hand_box2d_colors[i]),\n",
+    "        )\n",
+    "        rr.log(f\"visibility/{hand_name}\", rr.Scalar(ab.visibility_ratio))\n",
+    "        image_data = device_data_provider.get_image(timestamp_ns, stream_id)\n",
+    "        if image_data is not None:\n",
+    "            log_image(label=f\"{stream_id}_raw\", image=image_data)\n",
+    "\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8bad34e-a8ab-437d-84ff-1c046ca35d51",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 4: Eye gaze (Aria only, skipped automatically on Quest3)\n",
+    "\n",
+    "if device_type != Headset.Aria:\n",
+    "    print(f\"Skipping Section 4: eye gaze is Aria-only (current device: {device_type})\")\n",
+    "else:\n",
+    "    from projectaria_tools.core.calibration import FISHEYE624\n",
+    "\n",
+    "    rr.init(\"Eye Gaze reprojection\")\n",
+    "    rec = rr.memory_recording()\n",
+    "\n",
+    "    stream_id = StreamId(\"214-1\")\n",
+    "    for timestamp_ns in tqdm(timestamps[100:120]):\n",
+    "        rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "        rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "        eye_gaze = device_data_provider.get_eye_gaze(timestamp_ns)\n",
+    "        if eye_gaze is None:\n",
+    "            continue\n",
+    "\n",
+    "        proj = device_data_provider.get_eye_gaze_in_camera(\n",
+    "            stream_id, timestamp_ns, camera_model=FISHEYE624\n",
+    "        )\n",
+    "        if proj is None or not proj.any():\n",
+    "            continue\n",
+    "\n",
+    "        rr.log(f\"{stream_id}/eye-gaze\", rr.Points2D(proj, radii=20))\n",
+    "        image_data = device_data_provider.get_image(timestamp_ns, stream_id)\n",
+    "        if image_data is not None:\n",
+    "            log_image(label=str(stream_id), image=image_data)\n",
+    "\n",
+    "    rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4d6ac37-e3b3-401a-83b7-e09a42a183a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 5: Hand keypoint reprojection onto image\n",
+    "#\n",
+    "# Projects 3D world-space hand landmarks through the camera extrinsics + intrinsics\n",
+    "# to obtain 2D pixel coordinates, then overlays them on the image.\n",
+    "\n",
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "from typing import Any, Optional\n",
+    "from data_loaders.HeadsetPose3dProvider import HeadsetPose3dProvider\n",
+    "from data_loaders.loader_hand_poses import Handedness, HandPose3dCollection\n",
+    "from projectaria_tools.core.calibration import CameraCalibration\n",
+    "from projectaria_tools.core.sophus import SE3\n",
+    "\n",
+    "# Use a mid-sequence frame; clamp so the index is always valid\n",
+    "frame_idx = min(420, len(timestamps) - 1)\n",
+    "timestamp_ns = timestamps[frame_idx]\n",
+    "image_streamid = main_stream_id  # Aria -> 214-1, Quest3 -> 1201-1\n",
+    "\n",
+    "image_stream_label = device_data_provider.get_image_stream_label(image_streamid)\n",
+    "image_data = device_data_provider.get_image(timestamp_ns, image_streamid)\n",
+    "\n",
+    "\n",
+    "def get_hand_poses(ts):\n",
+    "    if hand_data_provider is None:\n",
+    "        return None\n",
+    "    result = hand_data_provider.get_pose_at_timestamp(\n",
+    "        timestamp_ns=ts,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "    return result.pose3d_collection if result else None\n",
+    "\n",
+    "\n",
+    "def get_camera_pose(ts, stream_id):\n",
+    "    \"\"\"Returns (T_world_camera, intrinsics) or None.\"\"\"\n",
+    "    if device_pose_provider is None:\n",
+    "        return None\n",
+    "    result = device_pose_provider.get_pose_at_timestamp(\n",
+    "        timestamp_ns=ts,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "    if result is None:\n",
+    "        return None\n",
+    "    [T_device_camera, intrinsics] = device_data_provider.get_camera_calibration(stream_id)\n",
+    "    T_world_camera = result.pose3d.T_world_device @ T_device_camera\n",
+    "    return T_world_camera, intrinsics\n",
+    "\n",
+    "\n",
+    "hand_data  = get_hand_poses(timestamp_ns)\n",
+    "camera_pose = get_camera_pose(timestamp_ns, image_streamid)\n",
+    "\n",
+    "if hand_data is None or camera_pose is None or image_data is None:\n",
+    "    print(\"Missing hand data, camera pose, or image — cannot project.\")\n",
+    "else:\n",
+    "    T_world_camera, intrinsics = camera_pose\n",
+    "    plt.figure(figsize=(10, 8))\n",
+    "    plt.imshow(image_data, interpolation=\"nearest\")\n",
+    "    plt.title(f\"{image_stream_label}  frame={frame_idx}\")\n",
+    "\n",
+    "    for hand_pose in hand_data.poses.values():\n",
+    "        label = hand_pose.handedness_label()\n",
+    "        landmarks = hand_data_provider.get_hand_landmarks(hand_pose)\n",
+    "\n",
+    "        # Gather all 3D points along the skeleton connectivity\n",
+    "        all_pts_3d = [\n",
+    "            landmarks[idx].numpy()\n",
+    "            for conn in LANDMARK_CONNECTIVITY\n",
+    "            for idx in conn\n",
+    "        ]\n",
+    "\n",
+    "        # Project each 3D world point into the camera image plane\n",
+    "        projected = []\n",
+    "        for pt_world in all_pts_3d:\n",
+    "            pt_cam = T_world_camera.inverse() @ pt_world\n",
+    "            pt_2d  = intrinsics.project(pt_cam)\n",
+    "            if pt_2d is not None:\n",
+    "                projected.append(pt_2d)\n",
+    "\n",
+    "        color = 'r' if hand_pose.handedness == Handedness.Right else 'b'\n",
+    "        print(f\"{label} hand: {len(projected)} keypoints visible in image\")\n",
+    "        if projected:\n",
+    "            plt.scatter([p[0] for p in projected], [p[1] for p in projected],\n",
+    "                        s=3, c=color, label=label)\n",
+    "\n",
+    "    plt.legend()\n",
+    "    plt.axis('off')\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

HOT3DHUGGFACE/HOT3D_Tutorial.ipynb

@@ -0,0 +1,1045 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ee215408-e60b-4209-a09a-f84a8fd5ffa1",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# Hot3D Data Provider Tutorial\n",
+    "\n",
+    "In order to use sequences from the HOT3D dataset, you will need ot use the Hot3dDataProvider object.\n",
+    "\n",
+    "This notebook is explaining how to use the various \"DataProvider\" in order to retrieve:\n",
+    "- Section 0: DataProvider initialization\n",
+    "- Section 1: Device calibration and Image data\n",
+    "- Section 2: Pose data\n",
+    "  - Section 2.a: Device/Headset pose data\n",
+    "  - Section 2.b: Hand pose data\n",
+    "  - Section 2.b.a: Hand pose data and MESH hands\n",
+    "  - Section 2.c: Object pose data\n",
+    "- Section 3:\n",
+    "  - Section 3.a: Object bounding boxes (amodal bounding boxes)\n",
+    "  - Section 3.b: Hand bounding boxes (amodal bounding boxes)\n",
+    "- Section 4: Eye Gaze data (only for Aria data)\n",
+    "- Section 5: Camera reprojection (reprojection hand vertices to raw fish images)\n",
+    "\n",
+    "Hot3dDataProvider API is organized as follow:\n",
+    "```\n",
+    "|- device_data_provider        -> provides device calibration and image data\n",
+    "|- device_pose_data_provider   -> provides device pose data\n",
+    "|- mano_hand_data_provider     -> provides hand pose data (MANO representation)\n",
+    "|- umetrack_hand_data_provider -> provides hand pose data (UmeTrack representation)\n",
+    "|- object_pose_data_provider   -> provides object pose data\n",
+    "|- object_library              -> provides information about the HOT3D 3D objects/assets\n",
+    "|- hand_box2d_data_provider    -> provides hands bbox information\n",
+    "|- object_box2d_data_provider  -> provides objects bbox information\n",
+    "```\n",
+    "\n",
+    "## Notes\n",
+    "- All Device/Headset, Hand, Object poses data are shared in world coordinates (meters)\n",
+    "\n",
+    "In this tutorial you will learn that:\n",
+    "- Device data, such as Image data stream is indexed with a stream_id\n",
+    "- Headset use camera rig coordinates relative to the DEVICE pose (world_camera_stream_id = world_device @ device_camera_stream_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97bcb96c-4910-4a60-9a41-c3b34ee7ac7b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 0: DataProvider initialization\n",
+    "#\n",
+    "# Take home message:\n",
+    "# - Device data, such as Image data stream is indexed with a stream_id\n",
+    "# - Intrinsics and Extrinsics calibration relative to the device coordinates is available for each CAMERA/stream_id\n",
+    "#\n",
+    "# Data Requirements:\n",
+    "# - a sequence\n",
+    "# - the object library\n",
+    "# Optional:\n",
+    "# - To use the Mano hand you need to have the LEFT/RIGHT *.pkl hand models (available)\n",
+    "\n",
+    "import os\n",
+    "from dataset_api import Hot3dDataProvider\n",
+    "from data_loaders.loader_object_library import load_object_library\n",
+    "from data_loaders.mano_layer import MANOHandModel\n",
+    "\n",
+    "home = os.path.expanduser(\"~\")\n",
+    "hot3d_dataset_path = home + \"/Downloads/hot3d_dataset\"\n",
+    "sequence_path = os.path.join(hot3d_dataset_path, \"P0003_c701bd11\")\n",
+    "object_library_path = os.path.join(hot3d_dataset_path, \"assets\")\n",
+    "mano_hand_model_path = os.path.join(home, \"Downloads\")\n",
+    "\n",
+    "if not os.path.exists(sequence_path) or not os.path.exists(object_library_path):\n",
+    "    print(\"Invalid input sequence or library path.\")\n",
+    "    print(\"Please do update the path to VALID values for your system.\")\n",
+    "    raise\n",
+    "#\n",
+    "# Init the object library\n",
+    "#\n",
+    "object_library = load_object_library(object_library_folderpath=object_library_path)\n",
+    "\n",
+    "#\n",
+    "# Init the HANDs model\n",
+    "# If None, the UmeTrack HANDs model will be used\n",
+    "#\n",
+    "mano_hand_model = None\n",
+    "if mano_hand_model_path is not None:\n",
+    "    mano_hand_model = MANOHandModel(mano_hand_model_path)\n",
+    "\n",
+    "#\n",
+    "# Initialize hot3d data provider\n",
+    "#\n",
+    "hot3d_data_provider = Hot3dDataProvider(\n",
+    "    sequence_folder=sequence_path,\n",
+    "    object_library=object_library,\n",
+    "    mano_hand_model=mano_hand_model,\n",
+    ")\n",
+    "print(f\"data_provider statistics: {hot3d_data_provider.get_data_statistics()}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24dae021-1cfe-440a-a5c8-6f44851219e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Utility functions\n",
+    "# Used for interactive display in the following sections\n",
+    "#\n",
+    "import rerun as rr\n",
+    "import numpy as np\n",
+    "\n",
+    "from projectaria_tools.core.sophus import SE3\n",
+    "from projectaria_tools.utils.rerun_helpers import ToTransform3D\n",
+    "\n",
+    "\n",
+    "def log_image(\n",
+    "    image: np.array,\n",
+    "    label: str,\n",
+    "    static=False\n",
+    ") -> None:\n",
+    "    rr.log(label, rr.Image(image), static=static)\n",
+    "\n",
+    "\n",
+    "def log_pose(\n",
+    "    pose: SE3,\n",
+    "    label: str,\n",
+    "    static=False\n",
+    ") -> None:\n",
+    "    rr.log(label, ToTransform3D(pose, False), static=static)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7447d83-bf07-4bfb-8e4f-9d548617cde7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Section 1: Device calibration and Image data\n",
+    "\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "#\n",
+    "# Retrieve some statistics about the \"IMAGE\" VRS recording\n",
+    "#\n",
+    "\n",
+    "# Getting the device data provider (alias)\n",
+    "device_data_provider = hot3d_data_provider.device_data_provider\n",
+    "\n",
+    "# Retrieve the list of image stream supported by this sequence\n",
+    "# It will return the RGB and SLAM Left/Right image streams\n",
+    "image_stream_ids = device_data_provider.get_image_stream_ids()\n",
+    "# Retrieve a list of timestamps for the sequence (in nanoseconds)\n",
+    "timestamps = device_data_provider.get_sequence_timestamps()\n",
+    "\n",
+    "print(f\"Sequence: {os.path.basename(os.path.normpath(sequence_path))}\")\n",
+    "print(f\"Device type is {hot3d_data_provider.get_device_type()}\")\n",
+    "print(f\"Image stream ids: {image_stream_ids}\")\n",
+    "print(f\"Number of timestamp for this sequence: {len(timestamps)}\")\n",
+    "print(\n",
+    "    f\"Duration of the sequence: {(timestamps[-1] - timestamps[0]) / 1e9} (seconds)\"\n",
+    ")  # Timestamps are in nanoseconds\n",
+    "\n",
+    "\n",
+    "# Init a rerun context to visualize the sequence file images\n",
+    "rr.init(\"Device images\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "# How to iterate over timestamps using a slice to show one timestamp every 200\n",
+    "timestamps_slice = slice(None, None, 200)\n",
+    "# Loop over the timestamps of the sequence and visualize corresponding data\n",
+    "for timestamp_ns in tqdm(timestamps[timestamps_slice]):\n",
+    "\n",
+    "    for stream_id in image_stream_ids:\n",
+    "        # Retrieve the image stream label as string\n",
+    "        image_stream_label = device_data_provider.get_image_stream_label(stream_id)\n",
+    "        # Retrieve the image data for a given timestamp\n",
+    "        image_data = device_data_provider.get_image(timestamp_ns, stream_id)\n",
+    "        # Visualize the image data (it's a numpy array)\n",
+    "        log_image(label=f\"img/{image_stream_label}\", image=image_data)\n",
+    "\n",
+    "\n",
+    "#\n",
+    "# Retrieve Camera calibration (intrinsics and extrinsics) for a given stream_id\n",
+    "#\n",
+    "for stream_id in image_stream_ids:\n",
+    "    # Retrieve the camera calibration (intrinsics and extrinsics) for a given stream_id\n",
+    "    [extrinsics, intrinsics] = device_data_provider.get_camera_calibration(stream_id)\n",
+    "    print(intrinsics)\n",
+    "    # We will show in next section how to visualize the position of the camera in the world frame\n",
+    "\n",
+    "# Showing the rerun window\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d199e9c-7359-43b2-8ecd-807db548def0",
+   "metadata": {},
+   "source": [
+    "# A gentle introduction to the \"GT Data\" Provider API\n",
+    "\n",
+    "Take home message:\n",
+    "- All \"GT data provider\" are using a similar API interface to query data at a given timestamp and/or StreamID.\n",
+    "- If the requested timestamp does not exists, the closest one can be retrieve along its delta time (dt).\n",
+    "\n",
+    "All the following \"GT data providers\" are accessible from Hot3dDataProvider and using a similar API interface.\n",
+    "```\n",
+    "|- device_pose_data_provider   -> device/headset pose data\n",
+    "|- mano_hand_data_provider     -> hand pose data (MANO hand model)\n",
+    "|- umetrack_hand_data_provider -> hand pose data (UmeTrack hand model)\n",
+    "|- object_pose_data_provider   -> object pose data\n",
+    "|- hand_box2d_data_provider    -> hand information such as amodal BBox and visibility ratio\n",
+    "|- object_box2d_data_provider  -> object information such as amodal BBox and visibility ratio\n",
+    "```\n",
+    "\n",
+    "We are here shortly introducing the retrieval concept used, and then will showcase how to use each data_provider.\n",
+    "GT data providers enable retrieving information at a given TIMESTAMP\n",
+    "- If the timestamp is not exact, the closest one can will be returned,\n",
+    "- Delta Time (dt) between the found sample and the query timestamp is returned\n",
+    "  Meaning that you known if you have a perfect match to the GT time sample or retrieved a close sample.\n",
+    "  \n",
+    "Note: Some GT data providers are STREAM_ID specific and enable retrieve information for a given image stream.\n",
+    "```\n",
+    "data_with_dt = device_pose_provider.get_pose_at_timestamp(\n",
+    "   timestamp_ns: int,                           -> Timestamp\n",
+    "   stream_id: StreamID,                         -> If used, specify for which VRS image stream you query the data\n",
+    "   time_query_options: TimeQueryOptions,        -> Retrieval configuration, i.e TimeQueryOptions.CLOSEST\n",
+    "   time_domain: TimeDomain,                     -> TimeDomain (always use TimeDomain.TIME_CODE)\n",
+    "   acceptable_time_delta: Optional[int] = None, -> Threshold to reject delta dt that would be too large (using 0 or None is recommended)\n",
+    "```\n",
+    "\n",
+    "Here is how most of the interface will be used in the following sections:\n",
+    "```\n",
+    "data_with_dt = X_provider.get_X_at_timestamp(\n",
+    "    timestamp_ns=timestamp_ns,\n",
+    "    time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "    time_domain=TimeDomain.TIME_CODE)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7c473c3-174f-4cff-9d58-0650b580da72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 2: Pose data\n",
+    "#\n",
+    "# Take home message:\n",
+    "# - the device_pose_provider enables you to retrieve the Headset pose as (T_world_device)\n",
+    "# - moving to the device to a given camera can be done by using calibration data and combining SE3 poses\n",
+    "#   - such as T_world_camera = T_world_device @ T_device_camera\n",
+    "#\n",
+    "\n",
+    "from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions\n",
+    "\n",
+    "# Alias over the HEADSET/Device pose data provider\n",
+    "device_pose_provider = hot3d_data_provider.device_pose_data_provider\n",
+    "\n",
+    "# Init a rerun context to visualize the device trajectory\n",
+    "rr.init(\"Device/Headset trajectory\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "pose_translations = []\n",
+    "# Retrieve the position of the device in the world frame at a given timestamp\n",
+    "for timestamp_ns in tqdm(timestamps):\n",
+    "\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    headset_pose3d_with_dt = None\n",
+    "    if device_pose_provider is None:\n",
+    "        continue\n",
+    "    headset_pose3d_with_dt = device_pose_provider.get_pose_at_timestamp(\n",
+    "        timestamp_ns=timestamp_ns,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "\n",
+    "    if headset_pose3d_with_dt is None:\n",
+    "        continue\n",
+    "\n",
+    "    headset_pose3d = headset_pose3d_with_dt.pose3d\n",
+    "    T_world_device = headset_pose3d.T_world_device\n",
+    "    \n",
+    "    log_pose(pose=T_world_device, label=\"world/device\")\n",
+    "    pose_translations.append(T_world_device.translation()[0])\n",
+    "    # This is the pose of the device, to move to a given camera, you need to apply the device_camera transformation\n",
+    "    #for stream_id in image_stream_ids:\n",
+    "       # # Retrieve the camera calibration (intrinsics and extrinsics) for a given stream_id\n",
+    "       # [T_device_camera, intrinsics] = device_data_provider.get_camera_calibration(stream_id)\n",
+    "       # # The pose of the given camera at this timestamp is (world_camera = world_device @ device_camera):\n",
+    "       # T_world_camera = headset_pose3d.T_world_device @ T_device_camera\n",
+    "       # camera_stream_label = device_data_provider.get_image_stream_label(stream_id)\n",
+    "       # print(f\"Image stream label: {camera_stream_label} -> world_camera translation: {T_world_camera.translation()[0]}\")\n",
+    "\n",
+    "rr.log(\"world/device_trajectory\", rr.LineStrips3D([pose_translations]), static=True)\n",
+    "\n",
+    "# Showing the rerun window\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5253618-2ca2-4d11-a605-aa5aa19c54eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 2.b: Hand pose data\n",
+    "#\n",
+    "# Take home message:\n",
+    "# - Hands are labelled as LEFT or RIGHT hands\n",
+    "# - \"Hands pose\" are representing the WRIST pose on which a MESH or LANDMARKS can be attached (see next section)\n",
+    "#\n",
+    "\n",
+    "# Alias over the HAND pose data provider\n",
+    "hand_data_provider = hot3d_data_provider.mano_hand_data_provider if hot3d_data_provider.mano_hand_data_provider is not None else hot3d_data_provider.umetrack_hand_data_provider\n",
+    "\n",
+    "# Init a rerun context to visualize the hand pose data trajectory\n",
+    "rr.init(\"Hand pose trajectory (wrist)\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "# Accumulate HAND poses translations as list, to show a LINE strip HAND trajectory\n",
+    "left_hand_pose_translations = []\n",
+    "right_hand_pose_translations = []\n",
+    "\n",
+    "# Retrieve the position of the device in the world frame at a given timestamp\n",
+    "for timestamp_ns in tqdm(timestamps):\n",
+    "\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    hand_poses_with_dt = None\n",
+    "    if hand_data_provider is None:\n",
+    "        continue\n",
+    "    \n",
+    "    hand_poses_with_dt = hand_data_provider.get_pose_at_timestamp(\n",
+    "        timestamp_ns=timestamp_ns,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "\n",
+    "    if hand_poses_with_dt is None:\n",
+    "        continue\n",
+    "        \n",
+    "    hand_pose_collection = hand_poses_with_dt.pose3d_collection\n",
+    "\n",
+    "    for hand_pose_data in hand_pose_collection.poses.values():\n",
+    "        # Retrieve the handedness of the hand (i.e Left or Right)\n",
+    "        handedness_label = hand_pose_data.handedness_label()\n",
+    "\n",
+    "        T_world_wrist = hand_pose_data.wrist_pose\n",
+    "        log_pose(pose=T_world_wrist, label=f\"world/hand/{handedness_label}\")\n",
+    "\n",
+    "        # Accumulate HAND poses translations as list, to show a LINE strip HAND trajectory\n",
+    "        if hand_pose_data.is_left_hand():\n",
+    "            left_hand_pose_translations.append(T_world_wrist.translation()[0])\n",
+    "        elif hand_pose_data.is_right_hand():\n",
+    "            right_hand_pose_translations.append(T_world_wrist.translation()[0])\n",
+    "\n",
+    "rr.log(\"world/left_hand\", rr.LineStrips3D([left_hand_pose_translations]), static=True)\n",
+    "rr.log(\"world/right_hand\", rr.LineStrips3D([right_hand_pose_translations]), static=True)\n",
+    "\n",
+    "# Showing the rerun window\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a013c63-65e6-4c38-b378-141c8c7ae3ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 2.b.a: Hand pose data\n",
+    "#\n",
+    "# Take home message:\n",
+    "# - Hands are labelled as LEFT or RIGHT hands\n",
+    "# - Hands can be retrieved as:\n",
+    "#   - Landmarks and displayed as line\n",
+    "#   - Vertices\n",
+    "#   - Mesh (using vertices, faces index and normals)\n",
+    "#\n",
+    "\n",
+    "from data_loaders.hand_common import LANDMARK_CONNECTIVITY\n",
+    "\n",
+    "\n",
+    "# Alias over the HAND pose data provider\n",
+    "hand_data_provider = hot3d_data_provider.mano_hand_data_provider if hot3d_data_provider.mano_hand_data_provider is not None else hot3d_data_provider.umetrack_hand_data_provider\n",
+    "\n",
+    "# Init a rerun context\n",
+    "rr.init(\"Hand pose LANDMARK/MESH\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "left_hand_pose_translations = []\n",
+    "right_hand_pose_translations = []\n",
+    "\n",
+    "# Limit to the first 300 timestamps\n",
+    "for timestamp_ns in tqdm(timestamps[:300]):\n",
+    "\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    hand_poses_with_dt = None\n",
+    "    if hand_data_provider is None:\n",
+    "        continue\n",
+    "        \n",
+    "    hand_poses_with_dt = hand_data_provider.get_pose_at_timestamp(\n",
+    "        timestamp_ns=timestamp_ns,\n",
+    "        time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "        time_domain=TimeDomain.TIME_CODE,\n",
+    "    )\n",
+    "\n",
+    "    if hand_poses_with_dt is None:\n",
+    "        continue\n",
+    "    \n",
+    "    hand_pose_collection = hand_poses_with_dt.pose3d_collection\n",
+    "\n",
+    "    for hand_pose_data in hand_pose_collection.poses.values():\n",
+    "        # Retrieve the handedness of the hand (i.e Left or Right)\n",
+    "        handedness_label = hand_pose_data.handedness_label()\n",
+    "\n",
+    "        # Skeleton/Joints landmark representation (for LEFT hand)\n",
+    "        if hand_pose_data.is_left_hand():\n",
+    "            hand_landmarks = hand_data_provider.get_hand_landmarks(\n",
+    "                hand_pose_data\n",
+    "            )\n",
+    "            # convert landmarks to connected lines for display\n",
+    "            # (i.e retrieve points along the HAND LANDMARK_CONNECTIVITY as a list)\n",
+    "            points = [connections\n",
+    "                      for connectivity in LANDMARK_CONNECTIVITY\n",
+    "                      for connections in [[hand_landmarks[it].numpy().tolist() for it in connectivity]]]\n",
+    "            rr.log(\n",
+    "                f\"world/{handedness_label}/joints\",\n",
+    "                rr.LineStrips3D(points, radii=0.002),\n",
+    "            )\n",
+    "\n",
+    "        #\n",
+    "        # Plot RIGHT hand as a Triangular Mesh representation\n",
+    "        #\n",
+    "        if hand_pose_data.is_right_hand():\n",
+    "            hand_mesh_vertices = hand_data_provider.get_hand_mesh_vertices(hand_pose_data)\n",
+    "            hand_triangles, hand_vertex_normals = hand_data_provider.get_hand_mesh_faces_and_normals(hand_pose_data)\n",
+    "            \n",
+    "            rr.log(\n",
+    "                f\"world/{handedness_label}/mesh_faces\",\n",
+    "                rr.Mesh3D(\n",
+    "                    vertex_positions=hand_mesh_vertices,\n",
+    "                    vertex_normals=hand_vertex_normals,\n",
+    "                    triangle_indices=hand_triangles,\n",
+    "                ),\n",
+    "            )\n",
+    "\n",
+    "# Showing the rerun window\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a909427f-d8c5-40a7-8eba-8702de2a313b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 2.c: Object pose data\n",
+    "#\n",
+    "# Take home message:\n",
+    "# - Each object is associated with a Unique Identified (uid)\n",
+    "# - The object library enables to retrieve the 3D asset linked to this UID (a glb file)\n",
+    "#\n",
+    "\n",
+    "from data_loaders.loader_object_library import ObjectLibrary\n",
+    "\n",
+    "# Alias over the Object pose data provider\n",
+    "object_pose_data_provider = hot3d_data_provider.object_pose_data_provider\n",
+    "\n",
+    "# Keep track of what 3D assets has been loaded/unloaded so we will load them only when needed\n",
+    "# So we will load them only when required for Rerun\n",
+    "object_cache_status = {}\n",
+    "\n",
+    "# Init a rerun context\n",
+    "rr.init(\"Object pose\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "# Limit to the some timestamps\n",
+    "for timestamp_ns in tqdm(timestamps[100:300]):\n",
+    "\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    object_poses_with_dt = (\n",
+    "        object_pose_data_provider.get_pose_at_timestamp(\n",
+    "            timestamp_ns=timestamp_ns,\n",
+    "            time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "            time_domain=TimeDomain.TIME_CODE,\n",
+    "        )\n",
+    "    )\n",
+    "    if object_poses_with_dt is None:\n",
+    "        continue\n",
+    "\n",
+    "    objects_pose3d_collection = object_poses_with_dt.pose3d_collection\n",
+    "\n",
+    "    # Keep a mapping to know what object has been seen, and which one has not\n",
+    "    object_uids = object_pose_data_provider.object_uids_with_poses\n",
+    "    logging_status = {x: False for x in object_uids}\n",
+    "\n",
+    "    for (\n",
+    "        object_uid,\n",
+    "        object_pose3d,\n",
+    "    ) in objects_pose3d_collection.poses.items():\n",
+    "\n",
+    "        object_name = object_library.object_id_to_name_dict[object_uid]\n",
+    "        object_name = object_name + \"_\" + str(object_uid)\n",
+    "        object_cad_asset_filepath = ObjectLibrary.get_cad_asset_path(\n",
+    "            object_library_folderpath=object_library.asset_folder_name,\n",
+    "            object_id=object_uid,\n",
+    "        )\n",
+    "\n",
+    "        log_pose(pose=object_pose3d.T_world_object, label=f\"world/objects/{object_name}\")\n",
+    "        \n",
+    "        # Mark object has been seen (enable to know which object has been logged or not)\n",
+    "        # I.E and object not logged, has not been seen and will have its entity cleared for rerun\n",
+    "        logging_status[object_uid] = True\n",
+    "\n",
+    "        # Link the corresponding 3D object to the pose\n",
+    "        if object_uid not in object_cache_status.keys():\n",
+    "            object_cache_status[object_uid] = True\n",
+    "            rr.log(\n",
+    "                f\"world/objects/{object_name}\",\n",
+    "                rr.Asset3D(\n",
+    "                    path=object_cad_asset_filepath,\n",
+    "                ),\n",
+    "            )\n",
+    "\n",
+    "    # Rerun specifics (if an entity is disapearing, the last status is shown)\n",
+    "    # To compensate that , if some objects are not visible, we clear the entity\n",
+    "    for object_uid, displayed in logging_status.items():\n",
+    "        if not displayed:\n",
+    "            object_name = object_library.object_id_to_name_dict[object_uid]\n",
+    "            object_name = object_name + \"_\" + str(object_uid)\n",
+    "            rr.log(\n",
+    "                f\"world/objects/{object_name}\",\n",
+    "                rr.Clear.recursive(),\n",
+    "            )\n",
+    "            if object_uid in object_cache_status.keys():\n",
+    "                del object_cache_status[object_uid]  # We will log the mesh again\n",
+    "\n",
+    "# Showing the rerun window\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f31214ce-108e-403e-b66f-2c224ab450f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 3: Object/Hand bounding boxes\n",
+    "#\n",
+    "# Take home message\n",
+    "# - Bounding box data is queried by TIMESTAMP and STREAM_ID and contains amodal bbox and visibility ratio\n",
+    "# - Unique Identifiers are used to label objects (uid) -> they can be mapped to literal name by using the object_library\n",
+    "#"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b841145d-a114-4693-a0d4-492f9629bbbe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 3.a: Object bounding boxes\n",
+    "#\n",
+    "#\n",
+    "from projectaria_tools.core.stream_id import StreamId\n",
+    "\n",
+    "import matplotlib.pyplot as plt # Used to display consistent colored Bounding Boxes contours\n",
+    "\n",
+    "# Alias over the Object box2d data provider and Device data provider (to get image data)\n",
+    "object_box2d_data_provider = hot3d_data_provider.object_box2d_data_provider\n",
+    "device_data_provider = hot3d_data_provider.device_data_provider\n",
+    "\n",
+    "# Retrieve a distinct color mapping for object bounding box\n",
+    "# by using a colormap (i.e associate a object_uid to a specific color)\n",
+    "object_uids = list(object_box2d_data_provider.object_uids) # list of available object_uid used to map them to [0, 1, 2, ...] indices\n",
+    "object_box2d_colors = None\n",
+    "if object_box2d_data_provider is not None:\n",
+    "    color_map = plt.get_cmap(\"viridis\")\n",
+    "    object_box2d_colors = color_map(\n",
+    "        np.linspace(0, 1, len(object_uids))\n",
+    "    )\n",
+    "else:\n",
+    "    print(\"This section expect to have valid bounding box data\")\n",
+    "\n",
+    "\n",
+    "# Init a rerun context\n",
+    "rr.init(\"Object bounding boxed and visibility ratio\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "# Use SLAM-LEFT image (exists for both Aria and Quest files)\n",
+    "stream_id = StreamId(\"1201-1\")\n",
+    "if stream_id not in object_box2d_data_provider.stream_ids:\n",
+    "    print(f\"The object_box2d_data_provider does not have data for this StreamId: {stream_id}\")\n",
+    "\n",
+    "\n",
+    "# Limit to the some timestamps\n",
+    "for timestamp_ns in tqdm(timestamps[100:200]):\n",
+    "\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    # Retrieve data for this timestamp and specific stream_id\n",
+    "    box2d_collection_with_dt = (\n",
+    "        object_box2d_data_provider.get_bbox_at_timestamp(\n",
+    "            stream_id=stream_id,\n",
+    "            timestamp_ns=timestamp_ns,\n",
+    "            time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "            time_domain=TimeDomain.TIME_CODE,\n",
+    "        )\n",
+    "    )\n",
+    "    if box2d_collection_with_dt is None:\n",
+    "        continue\n",
+    "    if (\n",
+    "        box2d_collection_with_dt is None\n",
+    "        and box2d_collection_with_dt.box2d_collection or None\n",
+    "    ):\n",
+    "        continue\n",
+    "    \n",
+    "    # We have valid data, returned as a collection\n",
+    "    # i.e for each object_uid, we retrieve its BBOX and visibility\n",
+    "    object_uids_at_query_timestamp = (\n",
+    "        box2d_collection_with_dt.box2d_collection.object_uid_list\n",
+    "    )\n",
+    "\n",
+    "    for object_uid in object_uids_at_query_timestamp:\n",
+    "        object_name = object_library.object_id_to_name_dict[object_uid]\n",
+    "        axis_aligned_box2d = box2d_collection_with_dt.box2d_collection.box2ds[object_uid]\n",
+    "        bbox = axis_aligned_box2d.box2d\n",
+    "        visibility_ratio = axis_aligned_box2d.visibility_ratio\n",
+    "        if bbox is None:\n",
+    "            continue\n",
+    "\n",
+    "        rr.log(\n",
+    "            f\"{stream_id}_raw/bbox/{object_name}\",\n",
+    "            rr.Boxes2D(\n",
+    "                mins=[bbox.left, bbox.top],\n",
+    "                sizes=[bbox.width, bbox.height],\n",
+    "                colors=object_box2d_colors[object_uids.index(object_uid)],\n",
+    "            ),\n",
+    "        )\n",
+    "        rr.log(f\"visibility_ratio/{object_name}\", rr.Scalar(visibility_ratio))\n",
+    "        \n",
+    "        # Log the corresponding image\n",
+    "        image_stream_label = device_data_provider.get_image_stream_label(stream_id)\n",
+    "        # Retrieve the image data for a given timestamp\n",
+    "        image_data = device_data_provider.get_image(timestamp_ns, stream_id)\n",
+    "        # Visualize the image data (it's a numpy array)\n",
+    "        log_image(label=f\"{stream_id}_raw\", image=image_data)\n",
+    "\n",
+    "# Showing the rerun window\n",
+    "rr.notebook_show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d1daf98-2df6-4d0a-ae38-331060353b99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 3.b: Hand bounding boxes\n",
+    "#\n",
+    "#\n",
+    "from projectaria_tools.core.stream_id import StreamId\n",
+    "\n",
+    "from data_loaders.loader_hand_poses import LEFT_HAND_INDEX, RIGHT_HAND_INDEX\n",
+    "import matplotlib.pyplot as plt # Used to display consistent colored Bounding Boxes contours\n",
+    "\n",
+    "# Alias over the Hand box2d data provider and Device data provider (to get image data)\n",
+    "hand_box2d_data_provider = hot3d_data_provider.hand_box2d_data_provider\n",
+    "device_data_provider = hot3d_data_provider.device_data_provider\n",
+    "\n",
+    "# Retrieve a distinct color mapping for hand bounding box\n",
+    "# by using a colormap (i.e associate a hand_uid to a specific color)\n",
+    "hand_uids = [LEFT_HAND_INDEX, RIGHT_HAND_INDEX]\n",
+    "hand_box2d_colors = None\n",
+    "if hand_box2d_data_provider is not None:\n",
+    "    color_map = plt.get_cmap(\"viridis\")\n",
+    "    hand_box2d_colors = color_map(\n",
+    "        np.linspace(0, 1, len(hand_uids))\n",
+    "    )\n",
+    "else:\n",
+    "    print(\"This section expect to have valid bounding box data\")\n",
+    "\n",
+    "\n",
+    "# Init a rerun context\n",
+    "rr.init(\"Hand bounding boxed and visibility ratio\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "# Use SLAM-LEFT image (exists for both Aria and Quest files)\n",
+    "stream_id = StreamId(\"1201-1\")\n",
+    "if stream_id not in hand_box2d_data_provider.stream_ids:\n",
+    "    print(f\"The hand_box2d_data_provider does not have data for this StreamId: {stream_id}\")\n",
+    "\n",
+    "\n",
+    "# Limit to the some timestamps\n",
+    "for timestamp_ns in tqdm(timestamps[100:200]):\n",
+    "\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "\n",
+    "    # Retrieve data for this timestamp and specific stream_id\n",
+    "    box2d_collection_with_dt = (\n",
+    "        hand_box2d_data_provider.get_bbox_at_timestamp(\n",
+    "            stream_id=stream_id,\n",
+    "            timestamp_ns=timestamp_ns,\n",
+    "            time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "            time_domain=TimeDomain.TIME_CODE,\n",
+    "        )\n",
+    "    )\n",
+    "    \n",
+    "    if box2d_collection_with_dt is None:\n",
+    "        continue\n",
+    "    if (\n",
+    "        box2d_collection_with_dt is None\n",
+    "        and box2d_collection_with_dt.box2d_collection or None\n",
+    "    ):\n",
+    "        continue\n",
+    "\n",
+    "    \n",
+    "    # We have valid data, returned as a collection\n",
+    "    # i.e for each hand_uid, we retrieve its BBOX and visibility\n",
+    "    for hand_uid in hand_uids:\n",
+    "        hand_name = \"left\" if hand_uid == LEFT_HAND_INDEX else \"right\"\n",
+    "        axis_aligned_box2d = box2d_collection_with_dt.box2d_collection.box2ds[hand_uid]\n",
+    "        bbox = axis_aligned_box2d.box2d\n",
+    "        visibility_ratio = axis_aligned_box2d.visibility_ratio\n",
+    "        if bbox is None:\n",
+    "            continue\n",
+    "\n",
+    "        rr.log(\n",
+    "            f\"{stream_id}_raw/bbox/{hand_name}\",\n",
+    "            rr.Boxes2D(\n",
+    "                mins=[bbox.left, bbox.top],\n",
+    "                sizes=[bbox.width, bbox.height],\n",
+    "                colors=object_box2d_colors[hand_uids.index(hand_uid)],\n",
+    "            ),\n",
+    "        )\n",
+    "        rr.log(f\"visibility_ratio/{hand_name}\", rr.Scalar(visibility_ratio))\n",
+    "        \n",
+    "        # Log the corresponding image\n",
+    "        image_stream_label = device_data_provider.get_image_stream_label(stream_id)\n",
+    "        # Retrieve the image data for a given timestamp\n",
+    "        image_data = device_data_provider.get_image(timestamp_ns, stream_id)\n",
+    "        # Visualize the image data (it's a numpy array)\n",
+    "        log_image(label=f\"{stream_id}_raw\", image=image_data)\n",
+    "\n",
+    "# Showing the rerun window\n",
+    "rr.notebook_show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8bad34e-a8ab-437d-84ff-1c046ca35d51",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# Section 4: Eye Gaze data (only for Aria data)\n",
+    "#\n",
+    "# Take home message\n",
+    "# - Eye Gaze data is only available for Aria sequences\n",
+    "# - Eye Gaze data is retrieved via the device_data_provider\n",
+    "# - Eye Gaze data is a 3D ray that can be reprojected at any desired depth in a given image\n",
+    "#\n",
+    "\n",
+    "from data_loaders.headsets import Headset\n",
+    "from projectaria_tools.core.calibration import FISHEYE624\n",
+    "\n",
+    "if hot3d_data_provider.get_device_type() is not Headset.Aria:\n",
+    "    pass\n",
+    "\n",
+    "device_data_provider = hot3d_data_provider.device_data_provider\n",
+    "\n",
+    "# Use RGB image\n",
+    "stream_id = StreamId(\"214-1\")\n",
+    "\n",
+    "# Init a rerun context\n",
+    "rr.init(\"Eye Gaze reprojection in RGB image\")\n",
+    "rec = rr.memory_recording()\n",
+    "\n",
+    "# Limit to the some timestamps\n",
+    "for timestamp_ns in tqdm(timestamps[100:120]):\n",
+    "\n",
+    "    rr.set_time_nanos(\"synchronization_time\", int(timestamp_ns))\n",
+    "    rr.set_time_sequence(\"timestamp\", timestamp_ns)\n",
+    "    \n",
+    "    aria_eye_gaze_data = (\n",
+    "        device_data_provider.get_eye_gaze(timestamp_ns)\n",
+    "        if hot3d_data_provider.get_device_type() is Headset.Aria\n",
+    "        else None\n",
+    "    )\n",
+    "    #\n",
+    "    ## Eye Gaze image reprojection\n",
+    "    #\n",
+    "    if aria_eye_gaze_data is not None:\n",
+    "\n",
+    "        # We are showing EyeGaze reprojection only on the RGB image stream\n",
+    "        if stream_id != StreamId(\"214-1\"):\n",
+    "            continue\n",
+    "\n",
+    "        # Reproject EyeGaze for raw images\n",
+    "        camera_model = FISHEYE624\n",
+    "        \n",
+    "        eye_gaze_reprojection_data = (\n",
+    "            device_data_provider.get_eye_gaze_in_camera(\n",
+    "                stream_id, timestamp_ns, camera_model=camera_model\n",
+    "            )\n",
+    "        )\n",
+    "        if (\n",
+    "            eye_gaze_reprojection_data is None\n",
+    "            or not eye_gaze_reprojection_data.any()\n",
+    "        ):\n",
+    "            continue\n",
+    "\n",
+    "        rr.log(\n",
+    "            f\"{stream_id}/eye-gaze_projection\",\n",
+    "            rr.Points2D(eye_gaze_reprojection_data, radii=20),\n",
+    "        )\n",
+    "\n",
+    "        # Log the corresponding image\n",
+    "        image_stream_label = device_data_provider.get_image_stream_label(stream_id)\n",
+    "        # Retrieve the image data for a given timestamp\n",
+    "        image_data = device_data_provider.get_image(timestamp_ns, stream_id)\n",
+    "        # Visualize the image data (it's a numpy array)\n",
+    "        log_image(label=f\"{stream_id}\", image=image_data)\n",
+    "\n",
+    "# Showing the rerun window\n",
+    "rr.notebook_show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4d6ac37-e3b3-401a-83b7-e09a42a183a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#\n",
+    "# - Section 5: Camera reprojection (reprojection hand vertices to raw fish images)\n",
+    "#\n",
+    "# Take home message\n",
+    "#\n",
+    "# - Each image/streamId is having its own calibration you can retrieve and use\n",
+    "# - Using project(X) enables you to project a 3D point to a 2D image\n",
+    "#\n",
+    "\n",
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "from typing import Any, Optional\n",
+    "\n",
+    "import numpy as np\n",
+    "from data_loaders.HeadsetPose3dProvider import HeadsetPose3dProvider\n",
+    "\n",
+    "from data_loaders.loader_hand_poses import Handedness, HandPose3dCollection\n",
+    "\n",
+    "# Todo move up later\n",
+    "%matplotlib inline\n",
+    "from matplotlib import pyplot as plt\n",
+    "from projectaria_tools.core.calibration import CameraCalibration\n",
+    "from projectaria_tools.core.sophus import SE3\n",
+    "from projectaria_tools.core.stream_id import StreamId\n",
+    "\n",
+    "\n",
+    "image_streamid = StreamId(\"214-1\")\n",
+    "# image_streamid = StreamId(\"1201-1\")\n",
+    "\n",
+    "# timestamp_ns = timestamps[len(timestamps) // 2]\n",
+    "timestamp_ns = timestamps[420]\n",
+    "\n",
+    "# Retrieve the image stream label as string\n",
+    "image_stream_label = device_data_provider.get_image_stream_label(image_streamid)\n",
+    "\n",
+    "# Retrieve the image data for a given timestamp\n",
+    "image_data = device_data_provider.get_image(timestamp_ns, image_streamid)\n",
+    "\n",
+    "# Retrieve the hand vertices and project them on the image at this timestamp\n",
+    "def retrieve_hand_data(timestamp_ns: int) -> Optional[HandPose3dCollection]:\n",
+    "    \"\"\"\n",
+    "    Retrieve the collection of Hand Pose at this timestamp (i.e. LEFT or RIGHT hand)\n",
+    "    Note: They are 3D pose in world, and does not say if they are visible for a given camera or not (stream_id)\n",
+    "    Visibility can either being determined by using camera visibility (are vertices visible), or using the 2d hands bounding box\n",
+    "    \"\"\"\n",
+    "    hand_poses_with_dt = None\n",
+    "    if hand_data_provider is not None:\n",
+    "        hand_poses_with_dt = hand_data_provider.get_pose_at_timestamp(\n",
+    "            timestamp_ns=timestamp_ns,\n",
+    "            time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "            time_domain=TimeDomain.TIME_CODE,\n",
+    "        )\n",
+    "\n",
+    "        if hand_poses_with_dt is not None:\n",
+    "            return hand_poses_with_dt.pose3d_collection\n",
+    "    return None\n",
+    "\n",
+    "\n",
+    "def retrieve_device_pose(\n",
+    "    timestamp_ns: int,\n",
+    "    stream_id: StreamId,\n",
+    "    device_pose_provider: Optional[HeadsetPose3dProvider] = None,\n",
+    "    device_data_provider: Optional[Any] = None,\n",
+    ") -> Optional[tuple[SE3, CameraCalibration]]:\n",
+    "    \"\"\"\n",
+    "    Retrieve the pose of the device and apply the device_camera transformation on top of it for the provided stream_id\n",
+    "    \"\"\"\n",
+    "    headset_pose3d_with_dt = None\n",
+    "    if device_pose_provider is not None:\n",
+    "        headset_pose3d_with_dt = device_pose_provider.get_pose_at_timestamp(\n",
+    "            timestamp_ns=timestamp_ns,\n",
+    "            time_query_options=TimeQueryOptions.CLOSEST,\n",
+    "            time_domain=TimeDomain.TIME_CODE,\n",
+    "        )\n",
+    "\n",
+    "        if headset_pose3d_with_dt is not None:\n",
+    "            headset_pose3d = headset_pose3d_with_dt.pose3d\n",
+    "\n",
+    "            # Retrieve the camera calibration (intrinsics and extrinsics) for a given stream_id\n",
+    "            [extrinsics, intrinsics] = device_data_provider.get_camera_calibration(\n",
+    "                stream_id\n",
+    "            )\n",
+    "            # The pose of the given camera at this timestamp is (world_camera = world_device @ device_camera):\n",
+    "            world_camera_pose = headset_pose3d.T_world_device @ extrinsics\n",
+    "            return [world_camera_pose, intrinsics]\n",
+    "    return None\n",
+    "\n",
+    "\n",
+    "# Retrieve the data for this timestamp\n",
+    "hand_data = retrieve_hand_data(timestamp_ns)\n",
+    "device_pose = retrieve_device_pose(\n",
+    "    timestamp_ns, image_streamid, device_pose_provider, device_data_provider\n",
+    ")\n",
+    "\n",
+    "if hand_data is not None and device_pose is not None:\n",
+    "\n",
+    "    device_pose_extrinsic = device_pose[0]\n",
+    "    device_pose_intrinsic = device_pose[1]\n",
+    "\n",
+    "    # Visualize the image\n",
+    "    plt.imshow(image_data, interpolation=\"nearest\")\n",
+    "\n",
+    "    # For each possible hand pose (Left or Right)\n",
+    "    # Project the vertices in the camera and plot the visible one\n",
+    "    for hand_pose_data in hand_data.poses.values():\n",
+    "        # Retrieve the hand vertices and project them on the image at this timestamp\n",
+    "        # hand_mesh_vertices = hand_data_provider.get_hand_mesh_vertices(\n",
+    "        #     hand_pose_data\n",
+    "        # ).tolist()\n",
+    "\n",
+    "        # Use Landmarks\n",
+    "        hand_landmarks = hand_data_provider.get_hand_landmarks(hand_pose_data)\n",
+    "        # convert landmarks to connected lines for display\n",
+    "        hand_mesh_vertices = np.array([])\n",
+    "        for connectivity in LANDMARK_CONNECTIVITY:\n",
+    "            connections = np.array([])\n",
+    "            for it in connectivity:\n",
+    "                if len(connections) == 0:\n",
+    "                    connections = [hand_landmarks[it].numpy()]\n",
+    "                else:\n",
+    "                    connections = np.vstack((connections, hand_landmarks[it].numpy()))\n",
+    "            if len(hand_mesh_vertices) == 0:\n",
+    "                hand_mesh_vertices = connections\n",
+    "            else:\n",
+    "                hand_mesh_vertices = np.vstack((hand_mesh_vertices, connections))\n",
+    "\n",
+    "        hand_vertices_in_camera = []\n",
+    "        for vertex_in_world in hand_mesh_vertices:\n",
+    "            vertice_3d_camera_coordinates = (\n",
+    "                device_pose_extrinsic.inverse() @ vertex_in_world\n",
+    "            )\n",
+    "            vertice_2d_camera_coordinates = device_pose_intrinsic.project(\n",
+    "                vertice_3d_camera_coordinates\n",
+    "            )\n",
+    "            if vertice_2d_camera_coordinates is not None:\n",
+    "                hand_vertices_in_camera.append(vertice_2d_camera_coordinates)\n",
+    "        handedness_label = hand_pose_data.handedness_label()\n",
+    "        print(\n",
+    "            f\"{handedness_label} hand -> visible vertices: {len(hand_vertices_in_camera)}\"\n",
+    "        )\n",
+    "\n",
+    "        # Plot the hand vertices\n",
+    "        plt.scatter(\n",
+    "            x=[x[0] for x in hand_vertices_in_camera],\n",
+    "            y=[x[1] for x in hand_vertices_in_camera],\n",
+    "            s=1,\n",
+    "            c=\"r\" if hand_pose_data.handedness == Handedness.Right else \"b\",\n",
+    "        )\n",
+    "\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

HOT3DHUGGFACE/Hot3DVisualizer.py

@@ -0,0 +1,593 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict, List, Optional
+
+import matplotlib.pyplot as plt
+import numpy as np
+import rerun as rr  # @manual
+from data_loaders.hand_common import LANDMARK_CONNECTIVITY
+from data_loaders.headsets import Headset
+from data_loaders.loader_hand_poses import HandType
+from data_loaders.loader_object_library import ObjectLibrary
+from projectaria_tools.core.stream_id import StreamId  # @manual
+
+try:
+    from dataset_api import Hot3dDataProvider  # @manual
+except ImportError:
+    from hot3d.dataset_api import Hot3dDataProvider
+
+from data_loaders.HandDataProviderBase import (  # @manual
+    HandDataProviderBase,
+    HandPose3dCollectionWithDt,
+)
+from data_loaders.ObjectBox2dDataProvider import (  # @manual
+    ObjectBox2dCollectionWithDt,
+    ObjectBox2dProvider,
+)
+from data_loaders.ObjectPose3dProvider import (  # @manual
+    ObjectPose3dCollectionWithDt,
+    ObjectPose3dProvider,
+)
+from projectaria_tools.core.calibration import (
+    CameraCalibration,
+    DeviceCalibration,
+    FISHEYE624,
+    LINEAR,
+)
+from projectaria_tools.core.mps import get_eyegaze_point_at_depth  # @manual
+from projectaria_tools.core.mps.utils import (  # @manual
+    filter_points_from_confidence,
+    filter_points_from_count,
+)
+from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions  # @manual
+from projectaria_tools.core.sophus import SE3  # @manual
+from projectaria_tools.utils.rerun_helpers import (  # @manual
+    AriaGlassesOutline,
+    ToTransform3D,
+)
+
+
+class Hot3DVisualizer:
+    def __init__(
+        self,
+        hot3d_data_provider: Hot3dDataProvider,
+        hand_type: HandType = HandType.Umetrack,
+    ) -> None:
+        self._hot3d_data_provider = hot3d_data_provider
+        # Device calibration and Image stream data
+        self._device_data_provider = hot3d_data_provider.device_data_provider
+        # Data provider at time T (for device & objects & hand poses)
+        self._device_pose_provider = hot3d_data_provider.device_pose_data_provider
+        self._hand_data_provider = (
+            hot3d_data_provider.umetrack_hand_data_provider
+            if hand_type == HandType.Umetrack
+            else hot3d_data_provider.mano_hand_data_provider
+        )
+        if hand_type is HandType.Umetrack:
+            print("Hot3DVisualizer is using UMETRACK hand model")
+        elif hand_type is HandType.Mano:
+            print("Hot3DVisualizer is using MANO hand model")
+        self._object_pose_data_provider = hot3d_data_provider.object_pose_data_provider
+        self._object_box2d_data_provider = (
+            hot3d_data_provider.object_box2d_data_provider
+        )
+        # Object library
+        self._object_library = hot3d_data_provider.object_library
+
+        # If required
+        # Retrieve a distinct color mapping for object bounding box to show consistent color across stream_ids
+        # - Use a Colormap for visualizing object bounding box
+        self._object_box2d_colors = None
+        if self._object_box2d_data_provider is not None:
+            color_map = plt.get_cmap("viridis")
+            self._object_box2d_colors = color_map(
+                np.linspace(0, 1, len(self._object_box2d_data_provider.object_uids))
+            )
+
+        # Keep track of what 3D assets has been loaded/unloaded so we will load them only when needed
+        self._object_cache_status = {}
+
+        # To be parametrized later
+        self._jpeg_quality = 75
+
+    def log_static_assets(
+        self,
+        image_stream_ids: List[StreamId],
+    ) -> None:
+        """
+        Log all static assets (aka Timeless assets)
+        - assets that are immutable (but can still move if attached to a 3D Pose)
+        """
+
+        # Configure the world coordinate system to ease navigation
+        if self._hot3d_data_provider.get_device_type() is Headset.Aria:
+            rr.log("world", rr.ViewCoordinates.RIGHT_HAND_Z_UP, static=True)
+        else:
+            rr.log("world", rr.ViewCoordinates.RIGHT_HAND_Y_UP, static=True)
+
+        if self._hot3d_data_provider.get_device_type() is Headset.Aria:
+            ## for Aria devices, we use online calibration which is a dynamic asset
+            pass
+        elif self._hot3d_data_provider.get_device_type() is Headset.Quest3:
+            # For each of the stream ids we want to use, export the camera calibration (intrinsics and extrinsics)
+            for stream_id in image_stream_ids:
+                #
+                # Plot the camera configuration
+                [extrinsics, intrinsics] = (
+                    self._device_data_provider.get_camera_calibration(stream_id)
+                )
+                Hot3DVisualizer.log_pose(
+                    f"world/device/{stream_id}", extrinsics, static=True
+                )
+                Hot3DVisualizer.log_calibration(f"world/device/{stream_id}", intrinsics)
+
+        # Deal with Aria specifics
+        # - Glasses outline
+        # - Point cloud
+        if self._hot3d_data_provider.get_device_type() is Headset.Aria:
+            Hot3DVisualizer.log_aria_glasses(
+                "world/device/glasses_outline",
+                self._device_data_provider.get_device_calibration(),
+            )
+
+            # Point cloud (downsampled for visualization)
+            point_cloud = self._device_data_provider.get_point_cloud()
+            if point_cloud:
+                # Filter out low confidence points
+                threshold_invdep = 5e-4
+                threshold_dep = 5e-4
+                point_cloud = filter_points_from_confidence(
+                    point_cloud, threshold_invdep, threshold_dep
+                )
+                # Down sample points
+                points_data_down_sampled = filter_points_from_count(
+                    point_cloud, 500_000
+                )
+                # Retrieve point position
+                point_positions = [it.position_world for it in points_data_down_sampled]
+                POINT_COLOR = [200, 200, 200]
+                rr.log(
+                    "world/points",
+                    rr.Points3D(point_positions, colors=POINT_COLOR, radii=0.002),
+                    static=True,
+                )
+
+    def log_dynamic_assets(
+        self,
+        stream_ids: List[StreamId],
+        timestamp_ns: int,
+    ) -> None:
+        """
+        Log dynamic assets:
+        I.e assets that are moving, such as:
+        - 3D assets
+        - Device pose
+        - Hands
+        - Object poses
+        - Image related specifics assets
+        - images (stream_ids)
+        - Object Bounding boxes
+        - Aria Eye Gaze
+        """
+
+        #
+        ## Retrieve and log data that is not stream_id dependent (pure 3D data)
+        #
+        acceptable_time_delta = 0
+
+        if self._hot3d_data_provider.get_device_type() is Headset.Aria:
+            # For each of the stream ids we want to use, export the camera calibration (intrinsics and extrinsics)
+            for stream_id in stream_ids:
+                #
+                # Plot the camera configuration
+                [extrinsics, intrinsics] = (
+                    self._device_data_provider.get_online_camera_calibration(
+                        stream_id=stream_id, timestamp_ns=timestamp_ns
+                    )
+                )
+                Hot3DVisualizer.log_pose(f"world/device/{stream_id}", extrinsics)
+                Hot3DVisualizer.log_calibration(f"world/device/{stream_id}", intrinsics)
+
+        elif self._hot3d_data_provider.get_device_type() is Headset.Quest3:
+            ## for Quest devices we will use factory calibration which is a static asset
+            pass
+
+        headset_pose3d_with_dt = None
+        if self._device_data_provider is not None:
+            headset_pose3d_with_dt = self._device_pose_provider.get_pose_at_timestamp(
+                timestamp_ns=timestamp_ns,
+                time_query_options=TimeQueryOptions.CLOSEST,
+                time_domain=TimeDomain.TIME_CODE,
+                acceptable_time_delta=acceptable_time_delta,
+            )
+
+        hand_poses_with_dt = None
+        if self._hand_data_provider is not None:
+            hand_poses_with_dt = self._hand_data_provider.get_pose_at_timestamp(
+                timestamp_ns=timestamp_ns,
+                time_query_options=TimeQueryOptions.CLOSEST,
+                time_domain=TimeDomain.TIME_CODE,
+                acceptable_time_delta=acceptable_time_delta,
+            )
+
+        object_poses_with_dt = None
+        if self._object_pose_data_provider is not None:
+            object_poses_with_dt = (
+                self._object_pose_data_provider.get_pose_at_timestamp(
+                    timestamp_ns=timestamp_ns,
+                    time_query_options=TimeQueryOptions.CLOSEST,
+                    time_domain=TimeDomain.TIME_CODE,
+                    acceptable_time_delta=acceptable_time_delta,
+                )
+            )
+
+        aria_eye_gaze_data = (
+            self._device_data_provider.get_eye_gaze(timestamp_ns)
+            if self._hot3d_data_provider.get_device_type() is Headset.Aria
+            else None
+        )
+
+        #
+        ## Log Device pose
+        #
+        if headset_pose3d_with_dt is not None:
+            headset_pose3d = headset_pose3d_with_dt.pose3d
+            Hot3DVisualizer.log_pose(
+                "world/device", headset_pose3d.T_world_device, static=False
+            )
+
+        #
+        ## Log Hand poses
+        #
+        Hot3DVisualizer.log_hands(
+            "world/hands",  # /{handedness_label}/... will be added as necessary
+            self._hand_data_provider,
+            hand_poses_with_dt,
+            show_hand_mesh=True,
+            show_hand_vertices=False,
+            show_hand_landmarks=False,
+        )
+
+        #
+        ## Log Object poses
+        #
+        Hot3DVisualizer.log_object_poses(
+            "world/objects",
+            object_poses_with_dt,
+            self._object_pose_data_provider,
+            self._object_library,
+            self._object_cache_status,
+        )
+
+        #
+        ## Log stream dependent data
+        #
+        for stream_id in stream_ids:
+            #
+            ## Log Image data
+            #
+
+            # Undistorted image (required if you want see reprojected 3D mesh on the images)
+            image_data = self._device_data_provider.get_undistorted_image(
+                timestamp_ns, stream_id
+            )
+            if image_data is not None:
+                rr.log(
+                    f"world/device/{stream_id}",
+                    rr.Image(image_data).compress(jpeg_quality=self._jpeg_quality),
+                )
+
+            # Raw device images (required for object bounding box visualization)
+            image_data = self._device_data_provider.get_image(timestamp_ns, stream_id)
+            if image_data is not None:
+                rr.log(
+                    f"world/device/{stream_id}_raw",
+                    rr.Image(image_data).compress(jpeg_quality=self._jpeg_quality),
+                )
+
+            if (
+                self._object_box2d_data_provider is not None
+                and stream_id in self._object_box2d_data_provider.stream_ids
+            ):
+                box2d_collection_with_dt = (
+                    self._object_box2d_data_provider.get_bbox_at_timestamp(
+                        stream_id=stream_id,
+                        timestamp_ns=timestamp_ns,
+                        time_query_options=TimeQueryOptions.CLOSEST,
+                        time_domain=TimeDomain.TIME_CODE,
+                    )
+                )
+                Hot3DVisualizer.log_object_bounding_boxes(
+                    stream_id,
+                    box2d_collection_with_dt,
+                    self._object_box2d_data_provider,
+                    self._object_library,
+                    self._object_box2d_colors,
+                )
+
+            #
+            ## Eye Gaze image reprojection
+            #
+            if self._hot3d_data_provider.get_device_type() is Headset.Aria:
+                # We are showing EyeGaze reprojection only on the RGB image stream
+                if stream_id != StreamId("214-1"):
+                    continue
+
+                # Reproject EyeGaze for raw and pinhole images
+                camera_configurations = [FISHEYE624, LINEAR]
+                for camera_model in camera_configurations:
+                    eye_gaze_reprojection_data = (
+                        self._device_data_provider.get_eye_gaze_in_camera(
+                            stream_id, timestamp_ns, camera_model=camera_model
+                        )
+                    )
+                    if (
+                        eye_gaze_reprojection_data is None
+                        or not eye_gaze_reprojection_data.any()
+                    ):
+                        continue
+
+                    label = (
+                        f"world/device/{stream_id}/eye-gaze_projection"
+                        if camera_model == LINEAR
+                        else f"world/device/{stream_id}_raw/eye-gaze_projection_raw"
+                    )
+                    rr.log(
+                        label,
+                        rr.Points2D(eye_gaze_reprojection_data, radii=20),
+                        # TODO consistent color and size depending of camera resolution
+                    )
+        #
+        ## Log device dependent remaining 3D data
+        #
+
+        # Log 3D eye gaze
+        if aria_eye_gaze_data is not None:
+            T_device_CPF = self._device_data_provider.get_device_calibration().get_transform_device_cpf()
+            # Compute eye_gaze vector at depth_m (30cm for a proxy 3D vector to display)
+            gaze_vector_in_cpf = get_eyegaze_point_at_depth(
+                aria_eye_gaze_data.yaw, aria_eye_gaze_data.pitch, depth_m=0.3
+            )
+            # Draw EyeGaze vector
+            rr.log(
+                "world/device/eye-gaze",
+                rr.Arrows3D(
+                    origins=[T_device_CPF @ [0, 0, 0]],
+                    vectors=[
+                        T_device_CPF @ gaze_vector_in_cpf - T_device_CPF @ [0, 0, 0]
+                    ],
+                ),
+            )
+
+    @staticmethod
+    def log_aria_glasses(
+        label: str,
+        device_calibration: DeviceCalibration,
+        use_cad_calibration: bool = True,
+    ) -> None:
+        ## Plot Project Aria Glasses outline (as lines)
+        aria_glasses_point_outline = AriaGlassesOutline(
+            device_calibration, use_cad_calibration
+        )
+        rr.log(label, rr.LineStrips3D([aria_glasses_point_outline]), static=True)
+
+    @staticmethod
+    def log_calibration(
+        label: str,
+        camera_calibration: CameraCalibration,
+    ) -> None:
+        rr.log(
+            label,
+            rr.Pinhole(
+                resolution=[
+                    camera_calibration.get_image_size()[0],
+                    camera_calibration.get_image_size()[1],
+                ],
+                focal_length=float(camera_calibration.get_focal_lengths()[0]),
+            ),
+            static=True,
+        )
+
+    @staticmethod
+    def log_pose(label: str, pose: SE3, static=False) -> None:
+        rr.log(label, ToTransform3D(pose, False), static=static)
+
+    @staticmethod
+    def log_hands(
+        label: str,
+        hand_data_provider: HandDataProviderBase,
+        hand_poses_with_dt: HandPose3dCollectionWithDt,
+        show_hand_mesh=True,
+        show_hand_vertices=True,
+        show_hand_landmarks=True,
+    ):
+        logged_right_hand_data = False
+        logged_left_hand_data = False
+        if hand_poses_with_dt is None:
+            return
+
+        hand_pose_collection = hand_poses_with_dt.pose3d_collection
+
+        for hand_pose_data in hand_pose_collection.poses.values():
+            if hand_pose_data.is_left_hand():
+                logged_left_hand_data = True
+            elif hand_pose_data.is_right_hand():
+                logged_right_hand_data = True
+
+            handedness_label = hand_pose_data.handedness_label()
+
+            # Skeleton/Joints landmark representation
+            if show_hand_landmarks:
+                hand_landmarks = hand_data_provider.get_hand_landmarks(hand_pose_data)
+                # convert landmarks to connected lines for display
+                # (i.e retrieve points along the HAND LANDMARK_CONNECTIVITY as a list)
+                points = [
+                    connections
+                    for connectivity in LANDMARK_CONNECTIVITY
+                    for connections in [
+                        [hand_landmarks[it].numpy().tolist() for it in connectivity]
+                    ]
+                ]
+                rr.log(
+                    f"{label}/{handedness_label}/joints",
+                    rr.LineStrips3D(points, radii=0.002),
+                )
+
+            # Update mesh vertices if required
+            hand_mesh_vertices = (
+                hand_data_provider.get_hand_mesh_vertices(hand_pose_data)
+                if show_hand_vertices or show_hand_mesh
+                else None
+            )
+
+            # Vertices representation
+            if show_hand_vertices:
+                rr.log(
+                    f"{label}/{handedness_label}/mesh",
+                    rr.Points3D(hand_mesh_vertices),
+                )
+
+            # Triangular Mesh representation
+            if show_hand_mesh:
+                [hand_triangles, hand_vertex_normals] = (
+                    hand_data_provider.get_hand_mesh_faces_and_normals(hand_pose_data)
+                )
+                rr.log(
+                    f"{label}/{handedness_label}/mesh_faces",
+                    rr.Mesh3D(
+                        vertex_positions=hand_mesh_vertices,
+                        vertex_normals=hand_vertex_normals,
+                        triangle_indices=hand_triangles,  # TODO: we could avoid sending this list if we want to save memory
+                    ),
+                )
+        # If some hand data has not been logged, do not show it in the visualizer
+        if logged_left_hand_data is False:
+            rr.log(f"{label}/left", rr.Clear.recursive())
+        if logged_right_hand_data is False:
+            rr.log(f"{label}/right", rr.Clear.recursive())
+
+    @staticmethod
+    def log_object_poses(
+        label: str,  # "world/objects",
+        object_poses_with_dt: ObjectPose3dCollectionWithDt,
+        object_pose_data_provider: ObjectPose3dProvider,
+        object_library: ObjectLibrary,
+        object_cache_status: Dict[int, bool],
+    ):
+        if object_poses_with_dt is None:
+            return
+
+        objects_pose3d_collection = object_poses_with_dt.pose3d_collection
+
+        # Keep a mapping to know what object has been seen, and which one has not
+        object_uids = object_pose_data_provider.object_uids_with_poses
+        logging_status = {x: False for x in object_uids}
+
+        for (
+            object_uid,
+            object_pose3d,
+        ) in objects_pose3d_collection.poses.items():
+            object_name = object_library.object_id_to_name_dict[object_uid]
+            object_name = object_name + "_" + str(object_uid)
+            object_cad_asset_filepath = ObjectLibrary.get_cad_asset_path(
+                object_library_folderpath=object_library.asset_folder_name,
+                object_id=object_uid,
+            )
+
+            Hot3DVisualizer.log_pose(
+                f"world/objects/{object_name}",
+                object_pose3d.T_world_object,
+                False,
+            )
+            # Mark object has been seen
+            logging_status[object_uid] = True
+
+            # Link the corresponding 3D object
+            if object_uid not in object_cache_status.keys():
+                object_cache_status[object_uid] = True
+                rr.log(
+                    f"world/objects/{object_name}",
+                    rr.Asset3D(
+                        path=object_cad_asset_filepath,
+                    ),
+                )
+
+        # If some object are not visible, we clear the entity (last known mesh and pose will not be displayed)
+        for object_uid, displayed in logging_status.items():
+            if not displayed:
+                object_name = object_library.object_id_to_name_dict[object_uid]
+                object_name = object_name + "_" + str(object_uid)
+                rr.log(
+                    f"world/objects/{object_name}",
+                    rr.Clear.recursive(),
+                )
+                if object_uid in object_cache_status.keys():
+                    del object_cache_status[object_uid]  # We will log the mesh again
+
+    @staticmethod
+    def log_object_bounding_boxes(
+        stream_id: StreamId,
+        box2d_collection_with_dt: Optional[ObjectBox2dCollectionWithDt],
+        object_box2d_data_provider: ObjectBox2dProvider,
+        object_library: ObjectLibrary,
+        bbox_colors: np.ndarray,
+    ):
+        """
+        Object bounding boxes (valid for native raw images).
+        - We assume that the image corresponding to the stream_id has been logged beforehand as 'world/device/{stream_id}_raw/'
+        """
+
+        # Keep a mapping to know what object has been seen, and which one has not
+        object_uids = list(object_box2d_data_provider.object_uids)
+        logging_status = {x: False for x in object_uids}
+
+        if (
+            box2d_collection_with_dt is None
+            or box2d_collection_with_dt.box2d_collection is None
+        ):
+            # No bounding box are retrieved, we clear all the bounding box visualization existing so far
+            rr.log(f"world/device/{stream_id}_raw/bbox", rr.Clear.recursive())
+            return
+
+        object_uids_at_query_timestamp = (
+            box2d_collection_with_dt.box2d_collection.object_uid_list
+        )
+
+        for object_uid in object_uids_at_query_timestamp:
+            object_name = object_library.object_id_to_name_dict[object_uid]
+            axis_aligned_box2d = box2d_collection_with_dt.box2d_collection.box2ds[
+                object_uid
+            ]
+            box = axis_aligned_box2d.box2d
+            if box is None:
+                continue
+
+            logging_status[object_uid] = True
+            rr.log(
+                f"world/device/{stream_id}_raw/bbox/{object_name}",
+                rr.Boxes2D(
+                    mins=[box.left, box.top],
+                    sizes=[box.width, box.height],
+                    colors=bbox_colors[object_uids.index(object_uid)],
+                ),
+            )
+        # If some object are not visible, we clear the bounding box visualization
+        for key, value in logging_status.items():
+            if not value:
+                object_name = object_library.object_id_to_name_dict[key]
+                rr.log(
+                    f"world/device/{stream_id}_raw/bbox/{object_name}",
+                    rr.Clear.flat(),
+                )

HOT3DHUGGFACE/data_loaders/AlignedBox2d.py

@@ -0,0 +1,156 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import numpy as np
+
+
+class AlignedBox2d:
+    """
+    An 2D axis aligned box in floating point.
+
+    Assumptions:
+    * The origin is at top-left corner
+    * `right` and `bottom` are not inclusive in the region, i.e. the width and
+        height can be simply calculated by `right - left` and `bottom - top`.
+    """
+
+    def __init__(self, left: float, top: float, right: float, bottom: float):
+        """Initializes the bounding box given (left, top, right, bottom)"""
+        self._left: float = left
+        self._top: float = top
+        self._right: float = right
+        self._bottom: float = bottom
+
+    def __repr__(self):
+        return f"AlignedBox2d(left: {self._left}, top: {self._top}, right: {self._right}, bottom: {self._bottom})"
+
+    @property
+    def left(self) -> float:
+        """Left of the aligned box on x-axis."""
+        return self._left
+
+    @property
+    def top(self) -> float:
+        """Top of the aligned box on y-axis."""
+        return self._top
+
+    @property
+    def right(self) -> float:
+        """Right of the aligned box on x-axis."""
+        return self._right
+
+    @property
+    def bottom(self) -> float:
+        """Bottom of the aligned box on y-axis."""
+        return self._bottom
+
+    @property
+    def width(self) -> float:
+        """Width of the aligned box.
+
+        Returns:
+            Width computed by right - left
+        """
+        return self.right - self.left
+
+    @property
+    def height(self) -> float:
+        """Height of the aligned box.
+
+        Returns:
+            Height computed by bottom - top
+        """
+        return self.bottom - self.top
+
+    def pad(self, width: float, height: float) -> AlignedBox2d:
+        """Pads the region by extending `width` and `height` on four sides.
+
+        Args:
+            width (float): length to pad on left and right sides
+            height (float): length to pad on top and bottom sides
+        Returns:
+            a new AlignedBox2d object with padded region
+        """
+        return AlignedBox2d(
+            self.left - width,
+            self.top - height,
+            self.right + width,
+            self.bottom + height,
+        )
+
+    def array_ltrb(self) -> np.ndarray:
+        """Converts the box into a float np.ndarray of shape (4,):  (left, top, right, bottom).
+
+        Returns:
+            a float np.ndarray of shape (4,) representing (left, top, right, bottom)
+        """
+        return np.array([self.left, self.top, self.right, self.bottom])
+
+    def array_ltwh(self) -> np.ndarray:
+        """Converts the box into a float np.ndarray of shape (4,): (left, top, width, height).
+
+        Returns:
+            a float np.ndarray of shape (4,) representing (left, top, width, height)
+        """
+        return np.array([self.left, self.top, self.width, self.height])
+
+    def int_array_ltrb(self) -> np.ndarray:
+        """Converts the box into an int np.ndarray of shape (4,): (left, top, width, height).
+
+        Returns:
+            an int np.ndarray of shape (4,) representing (left, top, right, bottom)
+        """
+        return self.array_ltrb().astype(int)
+
+    def int_array_ltwh(self) -> np.ndarray:
+        """Converts the box into an int np.ndarray of shape (4,): (left, top, width, height).
+
+        Returns:
+            an int np.ndarray of shape (4,) representing (left, top, width, height)
+        """
+        return self.array_ltwh().astype(int)
+
+    def round(self) -> AlignedBox2d:
+        """Rounds the float values to int.
+
+        Returns:
+            a new AlignedBox2d object with rounded values (still float)
+        """
+        return AlignedBox2d(
+            np.round(self.left),
+            np.round(self.top),
+            np.round(self.right),
+            np.round(self.bottom),
+        )
+
+    def clip(self, boundary: AlignedBox2d) -> AlignedBox2d:
+        """Clips the region by the boundary
+
+        Args:
+            boundary (AlignedBox2d): boundary of box to be clipped
+                (boundary.left: minimum left / right value,
+                 boundary.top: minimum top / bottom value,
+                 boundary.right: maximum left / right value,
+                 boundary.bottom: maximum top / bottom value)
+        Returns:
+            a new clipped AlignedBox2d object
+        """
+        return AlignedBox2d(
+            min(max(self.left, boundary.left), boundary.right),
+            min(max(self.top, boundary.top), boundary.bottom),
+            min(max(self.right, boundary.left), boundary.right),
+            min(max(self.bottom, boundary.top), boundary.bottom),
+        )

HOT3DHUGGFACE/data_loaders/AriaDataProvider.py

@@ -0,0 +1,377 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from typing import Dict, List, Optional
+
+import numpy as np
+from data_loaders.frameset import compute_frameset_for_timestamp
+from projectaria_tools.core import data_provider  # @manual
+from projectaria_tools.core.calibration import (  # @manual
+    CameraCalibration,
+    DeviceCalibration,
+    distort_by_calibration,
+    FISHEYE624,
+    get_linear_camera_calibration,
+    LINEAR,
+)
+from projectaria_tools.core.mps import (  # @manual
+    EyeGaze,
+    get_eyegaze_point_at_depth,
+    MpsDataPathsProvider,
+    MpsDataProvider,
+)
+from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions  # @manual
+from projectaria_tools.core.sophus import SE3  # @manual
+from projectaria_tools.core.stream_id import StreamId  # @manual
+
+
+class AriaDataProvider:
+    def __init__(
+        self, vrs_filepath: str, mps_folder_path: Optional[str] = None
+    ) -> None:
+        self._vrs_data_provider = data_provider.create_vrs_data_provider(vrs_filepath)
+
+        # MPS data provider
+        if mps_folder_path is not None and os.path.exists(mps_folder_path):
+            mps_data_paths_provider = MpsDataPathsProvider(mps_folder_path)
+            mps_data_paths = mps_data_paths_provider.get_data_paths()
+            self._mps_data_provider = MpsDataProvider(mps_data_paths)
+            print(mps_data_paths)
+        else:
+            self._mps_data_provider = None
+
+        # Pre-compute the sorted timestamps for each stream
+        self._stream_timestamps_sorted: Dict[str, List[int]] = {}
+        for stream_id in self.get_image_stream_ids():
+            self._stream_timestamps_sorted[str(stream_id)] = sorted(
+                self.get_sequence_timestamps(stream_id, TimeDomain.TIME_CODE)
+            )
+
+    def get_image_stream_ids(self) -> List[StreamId]:
+        # retrieve all streams ids and filter the one that are image based
+        stream_ids = self._vrs_data_provider.get_all_streams()
+        image_stream_ids = [
+            p
+            for p in stream_ids
+            if self._vrs_data_provider.get_label_from_stream_id(p).startswith("camera-")
+        ]
+        return image_stream_ids
+
+    def get_sequence_timestamps(
+        self,
+        stream_id: StreamId = StreamId("214-1"),
+        time_domain: TimeDomain = TimeDomain.TIME_CODE,
+    ) -> List[int]:
+        """
+        Returns the list of "time code" timestamp for the sequence
+        """
+        return self._vrs_data_provider.get_timestamps_ns(stream_id, time_domain)
+
+    def get_frameset_from_timestamp(
+        self,
+        timestamp_ns: int,
+        frameset_acceptable_time_diff_ns: int,
+        time_domain: TimeDomain = TimeDomain.TIME_CODE,
+    ) -> Dict[str, Optional[int]]:
+        """
+        Computes a frameset from a given timestamp within an acceptable time difference.
+        The frameset consists of the closest timestamps for each stream that are within the acceptable time difference.
+        For Aria, the recommended acceptable time difference is 1e6 ns (or 1ms).
+        Returns a dictionary mapping each str(StreamId) to its closest timestamp.
+        """
+        if time_domain is not TimeDomain.TIME_CODE:
+            raise ValueError(
+                f"{time_domain} is not supported. Only TIME_CODE is supported"
+            )
+        out_frameset = compute_frameset_for_timestamp(
+            stream_timestamps_sorted=self._stream_timestamps_sorted,
+            target_timestamp=timestamp_ns,
+            frameset_acceptable_time_diff=frameset_acceptable_time_diff_ns,
+        )
+        return out_frameset
+
+    def get_image_stream_label(self, stream_id: StreamId) -> str:
+        return self._vrs_data_provider.get_label_from_stream_id(stream_id)
+
+    def get_image(self, timestamp_ns: int, stream_id: StreamId) -> np.ndarray:
+        image = self._vrs_data_provider.get_image_data_by_time_ns(
+            stream_id,
+            timestamp_ns,
+            TimeDomain.TIME_CODE,
+            TimeQueryOptions.CLOSEST,
+        )
+        return image[0].to_numpy_array() if image is not None else None
+
+    def get_undistorted_image(
+        self, timestamp_ns: int, stream_id: StreamId
+    ) -> np.ndarray:
+        image = self.get_image(timestamp_ns, stream_id)
+
+        [T_device_camera, native_camera_online_calibration] = (
+            self.get_online_camera_calibration(
+                stream_id, timestamp_ns=timestamp_ns, camera_model=FISHEYE624
+            )
+        )
+        [T_device_camera, pinhole_camera_online_calibration] = (
+            self.get_online_camera_calibration(
+                stream_id, timestamp_ns=timestamp_ns, camera_model=LINEAR
+            )
+        )
+
+        # Compute the actual undistorted image
+        undistorted_image = distort_by_calibration(
+            image, pinhole_camera_online_calibration, native_camera_online_calibration
+        )
+
+        return undistorted_image
+
+    def get_device_calibration(self) -> DeviceCalibration:
+        """
+        Return the device calibration (factory calibration of all sensors)
+        """
+        return self._vrs_data_provider.get_device_calibration()
+
+    def get_camera_calibration(
+        self,
+        stream_id: StreamId,
+        camera_model=FISHEYE624,
+    ) -> tuple[SE3, CameraCalibration]:
+        """
+        Return the camera calibration of the device of the sequence as [Extrinsics, Intrinsics]
+        Note:
+         - A corresponding pinhole camera can be requested by using camera_model = LINEAR.
+         - This is the camera model used to generate the 'get_undistorted_image'.
+        """
+        if not (camera_model is FISHEYE624 or camera_model is LINEAR):
+            raise ValueError(
+                "Invalid camera_model type, only FISHEYE624 and LINEAR are supported"
+            )
+
+        device_calibration = self.get_device_calibration()
+        stream_label = self._vrs_data_provider.get_label_from_stream_id(stream_id)
+        camera_calibration = device_calibration.get_camera_calib(stream_label)
+
+        # Store the relative transform from device to camera
+        T_device_camera = camera_calibration.get_transform_device_camera()
+
+        # If a corresponding pinhole camera is requested, we build one on the fly
+        if camera_model == LINEAR:
+            focal_lengths = camera_calibration.get_focal_lengths()
+            image_size = camera_calibration.get_image_size()
+            camera_calibration = get_linear_camera_calibration(
+                image_size[0], image_size[1], focal_lengths[0]
+            )
+        # else return the native FISHEYE624 camera model
+
+        return [T_device_camera, camera_calibration]
+
+    def get_online_camera_calibration(
+        self,
+        stream_id: StreamId,
+        timestamp_ns: Optional[int],
+        time_domain: TimeDomain = TimeDomain.TIME_CODE,
+        camera_model=FISHEYE624,
+    ) -> tuple[SE3, CameraCalibration]:
+        """
+        Return the camera calibration of the device of the sequence as [Extrinsics, Intrinsics]
+        Note:
+         - A corresponding pinhole camera can be requested by using camera_model = LINEAR.
+         - This is the camera model used to generate the 'get_undistorted_image'.
+        """
+        if not (camera_model is FISHEYE624 or camera_model is LINEAR):
+            raise ValueError(
+                "Invalid camera_model type, only FISHEYE624 and LINEAR are supported"
+            )
+        if time_domain is not TimeDomain.TIME_CODE:
+            raise ValueError(
+                f"{time_domain} is not supported. Only TIME_CODE is supported"
+            )
+
+        device_timestamp_ns = (
+            self._vrs_data_provider.convert_from_timecode_to_device_time_ns(
+                timestamp_ns
+            )
+        )
+        online_calibration = self._mps_data_provider.get_online_calibration(
+            device_timestamp_ns=device_timestamp_ns,
+            time_query_options=TimeQueryOptions.CLOSEST,
+        )
+        camera_calibs = online_calibration.camera_calibs
+
+        stream_label = self._vrs_data_provider.get_label_from_stream_id(stream_id)
+        camera_calib = [c for c in camera_calibs if c.get_label() == stream_label]
+        if len(camera_calib) == 0:
+            raise ValueError(
+                f"camera_calib not found for stream_label: {stream_label} stream_id: {stream_id} at timestamp_ns: {timestamp_ns}"
+            )
+        camera_calibration = camera_calib[0]
+
+        ## Fix the image size to correspond to the image saved in the vrs.
+        ## The calibration returned by mps_data_provider has hardcoded image sizes which are incorrect.
+        [_, native_camera_calibration] = self.get_camera_calibration(
+            stream_id, camera_model=camera_model
+        )
+        camera_calibration = CameraCalibration(
+            camera_calibration.get_label(),
+            camera_model,
+            camera_calibration.projection_params(),
+            camera_calibration.get_transform_device_camera(),
+            native_camera_calibration.get_image_size()[0],  ## correct the image size
+            native_camera_calibration.get_image_size()[1],
+            camera_calibration.get_valid_radius(),
+            camera_calibration.get_max_solid_angle(),
+            camera_calibration.get_serial_number(),
+        )
+        # Store the relative transform from device to camera
+        T_device_camera = camera_calibration.get_transform_device_camera()
+
+        # If a corresponding pinhole camera is requested, we build one on the fly
+        if camera_model == LINEAR:
+            focal_lengths = camera_calibration.get_focal_lengths()
+            image_size = camera_calibration.get_image_size()
+            camera_calibration = get_linear_camera_calibration(
+                image_size[0], image_size[1], focal_lengths[0]
+            )
+            # Info: transform_device_camera is set to ID in this path in the camera_calibration
+        # else return the native FISHEYE624 camera model
+
+        return [T_device_camera, camera_calibration]
+
+    def _timestamp_convert(
+        self, timestamp: int, time_domain_in: TimeDomain, time_domain_out: TimeDomain
+    ) -> int:
+        """
+        Returns the converted timestamp between two domains (TimeCode <-> Aria DeviceTime)
+        """
+        if self._vrs_data_provider:
+            # Map to corresponding timestamp
+            if (
+                time_domain_in == TimeDomain.TIME_CODE
+                and time_domain_out == TimeDomain.DEVICE_TIME
+            ):
+                out_timestamp = (
+                    self._vrs_data_provider.convert_from_timecode_to_device_time_ns(
+                        timestamp
+                    )
+                )
+            if (
+                time_domain_in == TimeDomain.DEVICE_TIME
+                and time_domain_out == TimeDomain.TIME_CODE
+            ):
+                out_timestamp = (
+                    self._vrs_data_provider.convert_from_device_time_to_timecode_ns(
+                        timestamp
+                    )
+                )
+            return out_timestamp
+        return None
+
+    ###
+    # Add MPS data specifics
+    ###
+
+    def get_point_cloud(self) -> Optional[np.ndarray]:
+        """
+        Return the point cloud of the scene
+        """
+        if self._mps_data_provider is None:
+            return None
+        if self._mps_data_provider.has_semidense_point_cloud():
+            point_cloud_data = self._mps_data_provider.get_semidense_point_cloud()
+            # Point cloud filtering is left to the user
+            return point_cloud_data
+
+        return None
+
+    def _get_gaze_vector_reprojection(
+        self,
+        eye_gaze: EyeGaze,
+        stream_id_label: str,
+        device_calibration: DeviceCalibration,
+        camera_calibration: CameraCalibration,
+    ) -> np.ndarray:
+        """
+        Helper function to project a eye gaze output onto a given image and its calibration, assuming specified fixed depth
+        """
+        gaze_center_in_cpf = get_eyegaze_point_at_depth(
+            eye_gaze.yaw, eye_gaze.pitch, depth_m=eye_gaze.depth or 1.0
+        )
+        transform_device_cpf = device_calibration.get_transform_device_cpf()
+        transform_device_camera = device_calibration.get_transform_device_sensor(
+            stream_id_label, True
+        )
+        # We use CAD value (this is the coordinate system used by the Eye Gaze model prediction)
+        # Using factory calibration (i.e CAD = False) would lead to less accurate EyeGaze reprojection.
+        transform_camera_cpf = transform_device_camera.inverse() @ transform_device_cpf
+        gaze_center_in_camera = transform_camera_cpf @ gaze_center_in_cpf
+        gaze_center_in_pixels = camera_calibration.project(gaze_center_in_camera)
+        return gaze_center_in_pixels
+
+    def get_eye_gaze_in_camera(
+        self,
+        stream_id: StreamId,
+        timestamp_ns: int,
+        time_domain: TimeDomain = TimeDomain.TIME_CODE,
+        camera_model=FISHEYE624,
+    ):
+        """
+        Return the eye_gaze at the given timestamp projected in the given stream for the given time_domain
+        """
+        if not (camera_model is FISHEYE624 or camera_model is LINEAR):
+            raise ValueError(
+                "Invalid camera_model type, only FISHEYE624 and LINEAR are supported"
+            )
+
+        eye_gaze = self.get_eye_gaze(timestamp_ns, time_domain)
+        if eye_gaze:
+            [T_device_camera, camera_calibration] = self.get_camera_calibration(
+                stream_id, camera_model
+            )
+            # Compute eye_gaze vector at depth_m and project it in the image
+            gaze_projection = self._get_gaze_vector_reprojection(
+                eye_gaze,
+                self.get_image_stream_label(stream_id),
+                self.get_device_calibration(),
+                camera_calibration,
+            )
+            return gaze_projection
+        return None
+
+    def get_eye_gaze(
+        self,
+        timestamp_ns: int,
+        time_domain: TimeDomain = TimeDomain.TIME_CODE,
+    ) -> Optional[EyeGaze]:
+        """
+        Return the eye_gaze data at the given timestamp
+        """
+        # Map to corresponding timestamp
+        if time_domain == TimeDomain.TIME_CODE:
+            device_timestamp_ns = self._timestamp_convert(
+                timestamp_ns, TimeDomain.TIME_CODE, TimeDomain.DEVICE_TIME
+            )
+        elif time_domain == TimeDomain.DEVICE_TIME:
+            device_timestamp_ns = timestamp_ns
+        else:
+            raise ValueError("Unsupported time domain")
+
+        if device_timestamp_ns:
+            if self._mps_data_provider.has_personalized_eyegaze():
+                return self._mps_data_provider.get_personalized_eyegaze(
+                    device_timestamp_ns
+                )
+            elif self._mps_data_provider.has_general_eyegaze():
+                return self._mps_data_provider.get_general_eyegaze(device_timestamp_ns)
+        return None

HOT3DHUGGFACE/data_loaders/HandBox2dDataProvider.py

@@ -0,0 +1,188 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import csv
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions  # @manual
+from projectaria_tools.core.stream_id import StreamId  # @manual
+
+from .AlignedBox2d import AlignedBox2d
+from .constants import HAND_BOX2D_DATA_CSV_COLUMNS
+from .io_utils import float_or_none, is_float
+from .loader_poses_utils import check_csv_columns
+from .pose_utils import lookup_timestamp
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(filename)s - %(lineno)d - %(levelname)s - %(message)s",
+)
+
+
+@dataclass
+class HandBox2d:
+    box2d: AlignedBox2d
+    visibility_ratio: float
+
+
+@dataclass
+class HandBox2dCollection:
+    timestamp_ns: int
+    box2ds: Dict[int, HandBox2d]
+
+
+HandBox2dTrajectory = Dict[int, HandBox2dCollection]  # trajectory for a single stream
+HandBox2dTrajectoryCollection = Dict[
+    str, HandBox2dTrajectory
+]  # trajectories for multiple streams
+
+
+@dataclass
+class HandBox2dCollectionWithDt:
+    box2d_collection: HandBox2dCollection
+    time_delta_ns: int
+
+#box2ds: Dict[int, HandBox2d]
+class HandBox2dProvider:
+    def __init__(
+        self, box2d_trajectory_collection: HandBox2dTrajectoryCollection
+    ) -> None:
+        #真正存数据的，但没有进行排序
+        self._box2d_trajectory_collection = box2d_trajectory_collection
+
+        self._sorted_timestamp_ns_list: Dict[str, List[int]] = {}
+        for stream_id in self._box2d_trajectory_collection.keys():
+            self._sorted_timestamp_ns_list[stream_id] = sorted(
+                self._box2d_trajectory_collection[stream_id].keys()
+            )
+
+    def get_timestamp_ns_list(self, stream_id: StreamId) -> Optional[List[int]]:
+        return self._sorted_timestamp_ns_list.get(str(stream_id), None)
+
+    @property
+    def stream_ids(self) -> List[StreamId]:
+        return [StreamId(x) for x in self._box2d_trajectory_collection.keys()]
+
+    def get_data_statistics(self) -> Dict[str, Any]:
+        """
+        Returns the stats for Hand 2D bounding boxes
+        """
+        stats = {}
+        stats["num_frames"] = {
+            k: len(v) for k, v in self._sorted_timestamp_ns_list.items()
+        }
+        stats["stream_ids"] = [str(x) for x in self.stream_ids]
+        return stats
+
+    def get_bbox_at_timestamp(
+        self,
+        stream_id: StreamId,
+        timestamp_ns: int,
+        time_query_options: TimeQueryOptions,
+        time_domain: TimeDomain,
+    ) -> Optional[HandBox2dCollectionWithDt]:
+        """
+        Return the list of poses at the given timestamp
+        """
+        if time_domain is not TimeDomain.TIME_CODE:
+            raise ValueError("Value other than TimeDomain.TIME_CODE not yet supported.")
+
+        if stream_id not in self.stream_ids:
+            raise ValueError(f"Box2d trajectory not available for stream {stream_id}.")
+
+        box2d_collection, time_delta_ns = lookup_timestamp(
+            time_indexed_dict=self._box2d_trajectory_collection[str(stream_id)],
+            sorted_timestamp_list=self.get_timestamp_ns_list(stream_id=stream_id),
+            query_timestamp=timestamp_ns,
+            time_query_options=time_query_options,
+        )
+
+        if box2d_collection is None or time_delta_ns is None:
+            return None
+        else:
+            return HandBox2dCollectionWithDt(
+                box2d_collection=box2d_collection, time_delta_ns=time_delta_ns
+            )
+
+
+def parse_box2ds_from_csv_reader(csv_reader) -> HandBox2dTrajectoryCollection:
+    box2d_trajectory_collection: HandBox2dTrajectoryCollection = {}
+
+    # Read the header row
+    header = next(csv_reader)
+
+    # Ensure we have the desired columns
+    check_csv_columns(header, HAND_BOX2D_DATA_CSV_COLUMNS)
+
+    # Read the rest of the rows in the CSV file
+    for row in csv_reader:
+        stream_id = str(StreamId(row[header.index("stream_id")]))
+        timestamp_ns = int(row[header.index("timestamp[ns]")])
+        hand_index = int(row[header.index("hand_index")])
+        visibility_ratio = float_or_none(row[header.index("visibility_ratio[%]")])
+
+        if is_float(row[header.index("x_min[pixel]")]):
+            x_min_px = float(row[header.index("x_min[pixel]")])
+            x_max_px = float(row[header.index("x_max[pixel]")])
+            y_min_px = float(row[header.index("y_min[pixel]")])
+            y_max_px = float(row[header.index("y_max[pixel]")])
+
+            box2d = AlignedBox2d(
+                left=x_min_px, top=y_min_px, right=x_max_px, bottom=y_max_px
+            )
+        else:
+            box2d = None
+
+        object_box2d = HandBox2d(
+            box2d=box2d,
+            visibility_ratio=visibility_ratio,
+        )
+
+        if stream_id not in box2d_trajectory_collection:
+            box2d_trajectory_collection[stream_id] = {}
+
+        if timestamp_ns not in box2d_trajectory_collection[stream_id]:
+            box2d_trajectory_collection[stream_id][timestamp_ns] = HandBox2dCollection(
+                timestamp_ns=timestamp_ns, box2ds={}
+            )
+
+        box2d_trajectory_collection[stream_id][timestamp_ns].box2ds[hand_index] = (
+            object_box2d
+        )
+    return box2d_trajectory_collection
+
+
+def load_box2d_trajectory_from_csv(filename: str) -> Optional[HandBox2dProvider]:
+    """Load Hand 2D bounding box meta data from a CSV file.
+
+    Keyword arguments:
+    filename -- the csv file i.e. sequence_folder + "/box2d_hands.csv"
+    """
+    if not os.path.exists(filename):
+        logger.warn(f"filename: {filename} does not exist.")
+        return None
+
+    # Open the CSV file for reading
+    with open(filename, "r") as f:
+        csv_reader = csv.reader(f)
+        box2d_trajectory_collection = parse_box2ds_from_csv_reader(
+            csv_reader=csv_reader
+        )
+        return HandBox2dProvider(
+            box2d_trajectory_collection=box2d_trajectory_collection
+        )

HOT3DHUGGFACE/data_loaders/HandDataProviderBase.py

@@ -0,0 +1,184 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import torch
+from data_loaders.loader_hand_poses import (
+    Handedness,
+    HandPose,
+    HandPose3dCollection,
+    load_hand_poses,
+)
+from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions  # @manual
+
+from .pose_utils import lookup_timestamp
+
+
+@dataclass
+class HandPose3dCollectionWithDt:
+    pose3d_collection: HandPose3dCollection
+    time_delta_ns: int
+
+
+class HandDataProviderBase:
+    def __init__(
+        self,
+    ) -> None:
+        self._hand_poses = None
+        self._sorted_timestamp_ns_list: List[int]
+
+    def _init_hand_poses(self, hand_pose_trajectory_filepath: str) -> None:
+        #self._hand_poses是一个字典，key是timestamp_ns，value是HandPose3dCollection对象，里面包含timestamp_ns和poses字典
+        # 取某一帧
+        # frame = hand_poses[1234567890]
+
+        # # 取右手
+        # right_hand = frame.poses[Handedness.Right]
+
+        # # 取右手手腕位置
+        # wrist_se3 = right_hand.wrist_pose
+
+        # # 取右手关节角度
+        # angles = right_hand.joint_angles
+
+        self._hand_poses = load_hand_poses(hand_pose_trajectory_filepath)
+        self._sorted_timestamp_ns_list: List[int] = sorted(self._hand_poses.keys())
+
+    @property
+    def timestamp_ns_list(self) -> List[int]:
+        return self._sorted_timestamp_ns_list
+
+    def get_data_statistics(self) -> Dict[str, Any]:
+        """
+        Returns the stats of the Hand data
+        """
+        assert self._hand_poses is not None
+
+        stats = {}
+        stats["num_frames"] = len(self._sorted_timestamp_ns_list)
+        stats["num_right_hands"] = sum(
+            [
+                1
+                for it in self._hand_poses.values()
+                if Handedness.Right in it.poses.keys()
+            ]
+        )
+        stats["num_left_hands"] = sum(
+            [
+                1
+                for it in self._hand_poses.values()
+                if Handedness.Left in it.poses.keys()
+            ]
+        )
+        return stats
+
+    def get_pose_at_timestamp(
+        self,
+        timestamp_ns: int,
+        time_query_options: TimeQueryOptions,
+        time_domain: TimeDomain,
+        acceptable_time_delta: Optional[int] = None,
+    ) -> Optional[HandPose3dCollectionWithDt]:
+        """
+        Return the list of hands available at a given timestamp
+        """
+        if time_domain is not TimeDomain.TIME_CODE:
+            raise ValueError("Value other than TimeDomain.TIME_CODE not yet supported.")
+
+        hand_pose_collection, time_delta_ns = lookup_timestamp(
+            time_indexed_dict=self._hand_poses,
+            sorted_timestamp_list=self._sorted_timestamp_ns_list,
+            query_timestamp=timestamp_ns,
+            time_query_options=time_query_options,
+        )
+
+        if (
+            hand_pose_collection is None
+            or time_delta_ns is None
+            or (
+                acceptable_time_delta is not None
+                and abs(time_delta_ns) > acceptable_time_delta
+            )
+        ):
+            return None
+        else:
+            return HandPose3dCollectionWithDt(
+                pose3d_collection=hand_pose_collection, time_delta_ns=time_delta_ns
+            )
+
+    @abstractmethod
+    def get_hand_mesh_vertices(
+        self, hand_wrist_data: HandPose
+    ) -> Optional[torch.Tensor]:
+        """
+        Return the hand mesh corresponding to given HandPose
+        """
+
+    @abstractmethod
+    def get_hand_mesh_faces_and_normals(
+        self, hand_wrist_data: HandPose
+    ) -> Optional[List[np.ndarray]]:
+        """
+        Return the hand mesh faces and normals
+        """
+
+    @abstractmethod
+    def get_hand_landmarks(self, hand_wrist_data: HandPose) -> Optional[torch.Tensor]:
+        """
+        Return the hand joint landmarks corresponding to given HandPose
+        See how to map the vertices together to represent a Hand as linked lines using LANDMARK_CONNECTIVITY
+        """
+
+    @staticmethod
+    def normalized(
+        vecs: np.ndarray, axis: int = -1, add_const_to_denom: bool = True
+    ) -> np.ndarray:
+        """
+        Normalize a set of vectors.
+        Args:
+            vecs: np.ndarray of shape (..., V).
+            axis: axis along which to normalize.
+            add_const_to_denom: if True, add a small constant to the denominator to prevent numerical issues.
+        Returns:
+            np.ndarray of the same shape as vecs.
+        """
+        denom = np.linalg.norm(vecs, axis=axis, keepdims=True)
+        if add_const_to_denom:
+            denom += 1e-5
+        return vecs / denom
+
+    @staticmethod
+    def get_triangular_mesh_normals(
+        vertices: np.ndarray, triangles: np.ndarray
+    ) -> np.ndarray:
+        """
+        Compute the normals of a triangular mesh.
+        Args:
+            vertices: np.ndarray of shape (..., V, 3).
+            triangles: np.ndarray of shape (..., F, 3).
+        Returns:
+            normals: np.ndarray of shape (..., F, 3).
+        """
+        norm = np.zeros_like(vertices)
+        tris = vertices[triangles]
+        n = np.cross(tris[::, 1] - tris[::, 0], tris[::, 2] - tris[::, 0])
+        n = HandDataProviderBase.normalized(n)
+        norm[triangles[:, 0]] += n
+        norm[triangles[:, 1]] += n
+        norm[triangles[:, 2]] += n
+        return HandDataProviderBase.normalized(norm)

HOT3DHUGGFACE/data_loaders/HeadsetPose3dProvider.py

@@ -0,0 +1,171 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import csv
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions  # @manual
+from projectaria_tools.core.sophus import SE3  # @manual
+
+from .constants import POSE_DATA_CSV_COLUMNS
+from .loader_poses_utils import check_csv_columns
+from .pose_utils import lookup_timestamp
+
+
+@dataclass
+class HeadsetPose3d:
+    """
+    Class to store pose of a headset
+    """
+
+    T_world_device: Optional[SE3] = None
+
+
+HeadsetPose3dTrajectory = Dict[int, HeadsetPose3d]
+
+
+@dataclass
+class HeadsetPose3dWithDt:
+    pose3d: HeadsetPose3d
+    time_delta_ns: int
+
+#头显设备在每个时间戳下的位置和朝向信息
+class HeadsetPose3dProvider(object):
+    def __init__(
+        self, headset_pose3d_trajectory: HeadsetPose3dTrajectory, headset_uid: str
+    ):
+        self._pose3d_trajectory: HeadsetPose3dTrajectory = headset_pose3d_trajectory
+        self._sorted_timestamp_ns_list: List[int] = sorted(
+            self._pose3d_trajectory.keys()
+        )
+        self._headset_uid: str = str(headset_uid)
+
+    @property
+    def timestamp_ns_list(self) -> List[int]:
+        return self._sorted_timestamp_ns_list
+
+    @property
+    def headset_uid(self) -> str:
+        return self._headset_uid
+
+    def get_data_statistics(self) -> Dict[str, Any]:
+        """
+        Returns the stats of the trajectory
+        """
+        stats = {}
+        stats["num_frames"] = len(self._sorted_timestamp_ns_list)
+        stats["headset_uid"] = str(self._headset_uid)
+        return stats
+
+    def get_pose_at_timestamp(
+        self,
+        timestamp_ns: int,
+        time_query_options: TimeQueryOptions,
+        time_domain: TimeDomain,
+        acceptable_time_delta: Optional[int] = None,
+    ) -> Optional[HeadsetPose3dWithDt]:
+        """
+        Return the list of poses at the given timestamp
+        """
+        if time_domain is not TimeDomain.TIME_CODE:
+            raise ValueError("Value other than TimeDomain.TIME_CODE not yet supported.")
+
+        headset_pose3d, time_delta_ns = lookup_timestamp(
+            time_indexed_dict=self._pose3d_trajectory,
+            sorted_timestamp_list=self._sorted_timestamp_ns_list,
+            query_timestamp=timestamp_ns,
+            time_query_options=time_query_options,
+        )
+
+        if (
+            headset_pose3d is None
+            or time_delta_ns is None
+            or (
+                acceptable_time_delta is not None
+                and abs(time_delta_ns) > acceptable_time_delta
+            )
+        ):
+            return None
+        else:
+            return HeadsetPose3dWithDt(
+                pose3d=headset_pose3d, time_delta_ns=time_delta_ns
+            )
+
+
+def load_headset_pose_trajectory_from_csv(filename: str) -> Tuple[Dict[int, SE3], str]:
+    """Load Device Poses meta data from a CSV file.
+
+    Keyword arguments:
+    filename -- the csv file i.e. sequence_folder + "/headset_trajectory.csv"
+    """
+
+    pose3d_trajectory: HeadsetPose3dTrajectory = {}
+    headset_uids = set()
+
+    # Open the CSV file for reading
+    with open(filename, "r") as f:
+        reader = csv.reader(f)
+
+        # Read the header row
+        header = next(reader)
+
+        # Ensure we have the desired columns
+        check_csv_columns(header, POSE_DATA_CSV_COLUMNS)
+
+        # Read the rest of the rows in the CSV file
+        for row in reader:
+            translation = [
+                row[header.index("t_wo_x[m]")],
+                row[header.index("t_wo_y[m]")],
+                row[header.index("t_wo_z[m]")],
+            ]
+            quaternion_xyz = [
+                row[header.index("q_wo_x")],
+                row[header.index("q_wo_y")],
+                row[header.index("q_wo_z")],
+            ]
+            quaternion_w = row[header.index("q_wo_w")]
+            timestamp_ns = int(row[header.index("timestamp[ns]")])
+            headset_uids.add(str(row[header.index("object_uid")]))
+
+            object_pose = SE3.from_quat_and_translation(
+                float(quaternion_w),
+                np.array([float(o) for o in quaternion_xyz]),
+                np.array([float(o) for o in translation]),
+            )[0]
+
+            pose3d_trajectory[timestamp_ns] = HeadsetPose3d(T_world_device=object_pose)
+
+    if len(headset_uids) != 1:
+        raise ValueError(
+            f"Expected 1 headset pose per timestamp, got {len(headset_uids)}. headset_uids: {headset_uids}"
+        )
+
+    return pose3d_trajectory, headset_uids.pop()
+
+
+def load_headset_pose_provider_from_csv(filename: str) -> HeadsetPose3dProvider:
+    """
+    Load pose_provider from csv
+    """
+
+    headset_pose3d_trajectory, headset_uid = load_headset_pose_trajectory_from_csv(
+        filename
+    )
+    return HeadsetPose3dProvider(
+        headset_pose3d_trajectory=headset_pose3d_trajectory,
+        headset_uid=headset_uid,
+    )

HOT3DHUGGFACE/data_loaders/ManoHandDataProvider.py

@@ -0,0 +1,128 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List, Optional
+
+import numpy as np
+import torch
+from data_loaders.HandDataProviderBase import HandDataProviderBase
+from data_loaders.loader_hand_poses import Handedness, HandPose, load_mano_shape_params
+from data_loaders.pytorch3d_rotation.rotation_conversions import (  # @manual
+    matrix_to_axis_angle,
+)
+
+from .mano_layer import MANOHandModel
+
+
+class MANOHandDataProvider(HandDataProviderBase):
+    def __init__(
+        self,
+        hand_pose_trajectory_filepath: str,
+        mano_layer: MANOHandModel,
+    ) -> None:
+        super().__init__()
+        #mano_hand_pose_trajectory.jsonl：每一帧中每只手的“手腕位置 + 手腕朝向 + 手指姿态 + 手型”
+        super()._init_hand_poses(hand_pose_trajectory_filepath)
+
+        # Hand profile
+        self._mano_shape_params = load_mano_shape_params(hand_pose_trajectory_filepath)
+        if self._mano_shape_params is not None:
+            self._mano_shape_params = torch.from_numpy(
+                np.array(self._mano_shape_params)
+            )
+
+        self.mano_layer = mano_layer
+
+    def get_hand_mesh_vertices(
+        self, hand_wrist_data: HandPose
+    ) -> Optional[torch.Tensor]:
+        """
+        Return the hand mesh corresponding to given HandPose
+        """
+        if (
+            hand_wrist_data.wrist_pose is not None
+            and self._mano_shape_params is not None
+            and self.mano_layer is not None
+        ):
+            hand_wrist_pose_matrix = hand_wrist_data.wrist_pose.to_matrix()
+            hand_wrist_pose_tensor = torch.from_numpy(hand_wrist_pose_matrix)
+
+            hand_wrist_rotation_axis_angle = matrix_to_axis_angle(
+                hand_wrist_pose_tensor[:3, :3]
+            )
+            hand_wrist_pose_tensor = torch.cat(
+                [hand_wrist_rotation_axis_angle, hand_wrist_pose_tensor[:3, 3]]
+            )
+
+            mesh_vertices, landmarks = self.mano_layer.forward_kinematics(
+                self._mano_shape_params,
+                torch.from_numpy(np.array(hand_wrist_data.joint_angles)),
+                hand_wrist_pose_tensor,
+                torch.tensor([hand_wrist_data.handedness == Handedness.Right]),
+            )
+
+            return mesh_vertices
+        return None
+
+    def get_hand_mesh_faces_and_normals(
+        self, hand_wrist_data: HandPose
+    ) -> Optional[List[np.ndarray]]:
+        """
+        Return the hand mesh faces and normals
+        """
+        if self.mano_layer is not None:
+            if hand_wrist_data.handedness == Handedness.Right:
+                hand_triangles = self.mano_layer.mano_layer_right.faces
+            else:
+                hand_triangles = self.mano_layer.mano_layer_left.faces
+
+            vertices = self.get_hand_mesh_vertices(hand_wrist_data)
+            assert vertices is not None
+            normals = HandDataProviderBase.get_triangular_mesh_normals(
+                vertices.float().numpy(), hand_triangles
+            )
+            return [hand_triangles, normals]
+        else:
+            return None
+
+    def get_hand_landmarks(self, hand_wrist_data: HandPose) -> Optional[torch.Tensor]:
+        """
+        Return the hand joint landmarks corresponding to given HandPose
+        See how to map the vertices together to represent a Hand as linked lines using LANDMARK_CONNECTIVITY
+        """
+        if (
+            hand_wrist_data.wrist_pose is not None
+            and self._mano_shape_params is not None
+            and self.mano_layer is not None
+        ):
+            hand_wrist_pose_matrix = hand_wrist_data.wrist_pose.to_matrix()
+            hand_wrist_pose_tensor = torch.from_numpy(hand_wrist_pose_matrix)
+
+            hand_wrist_rotation_axis_angle = matrix_to_axis_angle(
+                hand_wrist_pose_tensor[:3, :3]
+            )
+            hand_wrist_pose_tensor = torch.cat(
+                [hand_wrist_rotation_axis_angle, hand_wrist_pose_tensor[:3, 3]]
+            )
+
+            mesh_vertices, hand_landmarks = self.mano_layer.forward_kinematics(
+                self._mano_shape_params,
+                torch.from_numpy(np.array(hand_wrist_data.joint_angles)),
+                hand_wrist_pose_tensor,
+                torch.tensor([hand_wrist_data.handedness == Handedness.Right]),
+            )
+
+            return hand_landmarks
+
+        return None

HOT3DHUGGFACE/data_loaders/ObjectBox2dDataProvider.py

@@ -0,0 +1,219 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import csv
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Set
+
+from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions  # @manual
+from projectaria_tools.core.stream_id import StreamId  # @manual
+
+from .AlignedBox2d import AlignedBox2d
+from .constants import BOX2D_DATA_CSV_COLUMNS
+from .io_utils import float_or_none, is_float
+from .loader_poses_utils import check_csv_columns
+from .pose_utils import lookup_timestamp
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(filename)s - %(lineno)d - %(levelname)s - %(message)s",
+)
+
+#物体在图像上的 2D 边界框
+@dataclass
+class ObjectBox2d:
+    box2d: Optional[AlignedBox2d]
+    visibility_ratio: float
+
+
+@dataclass
+class ObjectBox2dCollection:
+    timestamp_ns: int
+    box2ds: Dict[str, ObjectBox2d]
+
+    @property
+    def object_uid_list(self) -> Set[str]:
+        return set(self.box2ds.keys())
+
+
+ObjectBox2dTrajectory = Dict[
+    int, ObjectBox2dCollection
+]  # trajectory for a single stream
+ObjectBox2dTrajectoryCollection = Dict[
+    str, ObjectBox2dTrajectory
+]  # trajectories for multiple streams
+
+
+@dataclass
+class ObjectBox2dCollectionWithDt:
+    box2d_collection: ObjectBox2dCollection
+    time_delta_ns: int
+
+
+class ObjectBox2dProvider:
+    def __init__(
+        self, box2d_trajectory_collection: ObjectBox2dTrajectoryCollection
+    ) -> None:
+        #真正存数据的，但没有进行排序
+        self._box2d_trajectory_collection = box2d_trajectory_collection
+        #对时间戳进行排序，纯时间序列
+        self._sorted_timestamp_ns_list: Dict[str, List[int]] = {}
+        for stream_id in self._box2d_trajectory_collection.keys():
+            self._sorted_timestamp_ns_list[stream_id] = sorted(
+                self._box2d_trajectory_collection[stream_id].keys()
+            )
+        #生成一个set，里面是所有出现过的物体ID
+        self._object_uids_with_box2ds: Set = {
+            x
+            for box2d_trajectory in self._box2d_trajectory_collection.values()
+            for v in box2d_trajectory.values()
+            for x in v.object_uid_list
+        }
+
+    def get_timestamp_ns_list(self, stream_id: StreamId) -> Optional[List[int]]:
+        return self._sorted_timestamp_ns_list.get(str(stream_id), None)
+
+    @property
+    def stream_ids(self) -> List[StreamId]:
+        return [StreamId(x) for x in self._box2d_trajectory_collection.keys()]
+
+    @property
+    def object_uids(self) -> Set[str]:
+        return set(self._object_uids_with_box2ds)
+
+    def get_data_statistics(self) -> Dict[str, Any]:
+        """
+        Returns the stats for Object 2D bounding boxes
+        """
+        stats = {}
+        stats["num_frames"] = {
+            k: len(v) for k, v in self._sorted_timestamp_ns_list.items()
+        }
+        stats["stream_ids"] = [str(x) for x in self.stream_ids]
+        stats["num_objects"] = len(self.object_uids)
+        stats["object_uids"] = [str(x) for x in self.object_uids]
+        return stats
+
+    def get_bbox_at_timestamp(
+        self,
+        stream_id: StreamId,
+        timestamp_ns: int,
+        time_query_options: TimeQueryOptions,
+        time_domain: TimeDomain,
+        acceptable_time_delta: Optional[int] = None,
+    ) -> Optional[ObjectBox2dCollectionWithDt]:
+        """
+        Return the list of boxes at the given timestamp
+        """
+        if time_domain is not TimeDomain.TIME_CODE:
+            raise ValueError("Value other than TimeDomain.TIME_CODE not yet supported.")
+
+        if stream_id not in self.stream_ids:
+            raise ValueError(f"Box2d trajectory not available for stream {stream_id}.")
+
+        box2d_collection, time_delta_ns = lookup_timestamp(
+            time_indexed_dict=self._box2d_trajectory_collection[str(stream_id)],
+            sorted_timestamp_list=self.get_timestamp_ns_list(stream_id=stream_id),
+            query_timestamp=timestamp_ns,
+            time_query_options=time_query_options,
+        )
+
+        if (
+            box2d_collection is None
+            or time_delta_ns is None
+            or (
+                acceptable_time_delta is not None
+                and abs(time_delta_ns) > acceptable_time_delta
+            )
+        ):
+            return None
+        else:
+            return ObjectBox2dCollectionWithDt(
+                box2d_collection=box2d_collection, time_delta_ns=time_delta_ns
+            )
+
+# box2d_trajectory_collection[stream_id][timestamp_ns].box2ds[object_uid] = (
+#             object_box2d
+#         )
+def parse_box2ds_from_csv_reader(csv_reader) -> ObjectBox2dTrajectoryCollection:
+    box2d_trajectory_collection: ObjectBox2dTrajectoryCollection = {}
+
+    # Read the header row
+    header = next(csv_reader)
+
+    # Ensure we have the desired columns
+    check_csv_columns(header, BOX2D_DATA_CSV_COLUMNS)
+
+    # Read the rest of the rows in the CSV file
+    for row in csv_reader:
+        stream_id = str(StreamId(row[header.index("stream_id")]))
+        timestamp_ns = int(row[header.index("timestamp[ns]")])
+        object_uid = str(row[header.index("object_uid")])
+        visibility_ratio = float_or_none(row[header.index("visibility_ratio[%]")])
+        
+        #读取和存储已有的框
+        if is_float(row[header.index("x_min[pixel]")]):
+            x_min_px = float(row[header.index("x_min[pixel]")])
+            x_max_px = float(row[header.index("x_max[pixel]")])
+            y_min_px = float(row[header.index("y_min[pixel]")])
+            y_max_px = float(row[header.index("y_max[pixel]")])
+
+            box2d = AlignedBox2d(
+                left=x_min_px, top=y_min_px, right=x_max_px, bottom=y_max_px
+            )
+        else:
+            box2d = None
+
+        object_box2d = ObjectBox2d(
+            box2d=box2d,
+            visibility_ratio=visibility_ratio,
+        )
+
+        if stream_id not in box2d_trajectory_collection:
+            box2d_trajectory_collection[stream_id] = {}
+
+        if timestamp_ns not in box2d_trajectory_collection[stream_id]:
+            box2d_trajectory_collection[stream_id][timestamp_ns] = (
+                ObjectBox2dCollection(timestamp_ns=timestamp_ns, box2ds={})
+            )
+        #由于ObjectBox2dCollection用的所对象，所以使用"."
+        box2d_trajectory_collection[stream_id][timestamp_ns].box2ds[object_uid] = (
+            object_box2d
+        )
+    return box2d_trajectory_collection
+
+
+def load_box2d_trajectory_from_csv(filename: str) -> Optional[ObjectBox2dProvider]:
+    """Load Objects 2D bounding box meta data from a CSV file.
+
+    Keyword arguments:
+    filename -- the csv file i.e. sequence_folder + "/box2d_objects.csv"
+    """
+
+    if not os.path.exists(filename):
+        logger.warn(f"filename: {filename} does not exist.")
+        return None
+
+    # Open the CSV file for reading
+    with open(filename, "r") as f:
+        csv_reader = csv.reader(f)
+        box2d_trajectory_collection = parse_box2ds_from_csv_reader(
+            csv_reader=csv_reader
+        )
+        return ObjectBox2dProvider(
+            box2d_trajectory_collection=box2d_trajectory_collection
+        )

HOT3DHUGGFACE/data_loaders/ObjectPose3dProvider.py

@@ -0,0 +1,189 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import csv
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Set
+
+import numpy as np
+from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions  # @manual
+from projectaria_tools.core.sophus import SE3  # @manual
+
+from .constants import POSE_DATA_CSV_COLUMNS
+from .loader_poses_utils import check_csv_columns
+from .pose_utils import lookup_timestamp
+
+
+@dataclass
+class ObjectPose3d:
+    """
+    Class to store pose of a single entity (object/headset/hand)
+    """
+
+    T_world_object: Optional[SE3] = None
+
+
+@dataclass
+class ObjectPose3dCollection:
+    """
+    Class to store the poses for a given timestamp
+    """
+
+    timestamp_ns: int
+    poses: Dict[str, ObjectPose3d]
+
+    @property
+    def object_uid_list(self) -> Set[str]:
+        return set(self.poses.keys())
+
+
+ObjectPose3dTrajectory = Dict[int, ObjectPose3dCollection]
+
+
+@dataclass
+class ObjectPose3dCollectionWithDt:
+    pose3d_collection: ObjectPose3dCollection
+    time_delta_ns: int
+
+
+class ObjectPose3dProvider(object):
+    def __init__(self, pose3d_trajectory: ObjectPose3dTrajectory):
+        self._pose3d_trajectory: ObjectPose3dTrajectory = pose3d_trajectory
+        #排序时间戳
+        self._sorted_timestamp_ns_list: List[int] = sorted(
+            self._pose3d_trajectory.keys()
+        )
+        #所有出现过的物体ID
+        self._object_uids_with_poses: Set = {
+            x for v in self._pose3d_trajectory.values() for x in v.object_uid_list
+        }
+
+    #像属性一样访问，不用加括号
+    @property
+    def timestamp_ns_list(self) -> List[int]:
+        return self._sorted_timestamp_ns_list
+
+    @property
+    def object_uids_with_poses(self) -> Set[str]:
+        return set(self._object_uids_with_poses)
+
+    def get_data_statistics(self) -> Dict[str, Any]:
+        """
+        Returns the stats of the trajectory
+        """
+        stats = {}
+        stats["num_frames"] = len(self._sorted_timestamp_ns_list)
+        stats["num_objects"] = len(self._object_uids_with_poses)
+        stats["object_uids"] = [str(x) for x in self._object_uids_with_poses]
+        return stats
+
+    def get_pose_at_timestamp(
+        self,
+        timestamp_ns: int,
+        time_query_options: TimeQueryOptions,
+        time_domain: TimeDomain,
+        acceptable_time_delta: Optional[int] = None,
+    ) -> Optional[ObjectPose3dCollectionWithDt]:
+        """
+        Return the list of poses available at the given timestamp
+        """
+        if time_domain is not TimeDomain.TIME_CODE:
+            raise ValueError("Value other than TimeDomain.TIME_CODE not yet supported.")
+
+        pose3d_collection, time_delta_ns = lookup_timestamp(
+            time_indexed_dict=self._pose3d_trajectory,
+            sorted_timestamp_list=self._sorted_timestamp_ns_list,
+            query_timestamp=timestamp_ns,
+            time_query_options=time_query_options,
+        )
+
+        if (
+            pose3d_collection is None
+            or time_delta_ns is None
+            or (
+                acceptable_time_delta is not None
+                and abs(time_delta_ns) > acceptable_time_delta
+            )
+        ):
+            return None
+        else:
+            return ObjectPose3dCollectionWithDt(
+                pose3d_collection=pose3d_collection, time_delta_ns=time_delta_ns
+            )
+
+#生成了一个pose3d_trajectory里面有物品在每个时间下的位置
+def load_object_pose_trajectory_from_csv(filename: str) -> ObjectPose3dTrajectory:
+    """Load Dynamic Objects meta data from a CSV file.
+
+    Keyword arguments:
+    filename -- the csv file i.e. sequence_folder + "/dynamic_objects.csv"
+    """
+    #空字典，后面逐行读 CSV 往里填数据
+    pose3d_trajectory: ObjectPose3dTrajectory = {}
+    # Open the CSV file for reading
+    with open(filename, "r") as f:
+        reader = csv.reader(f)
+
+        # Read the header row
+        #读表头
+        header = next(reader)
+
+        # Ensure we have the desired columns
+        check_csv_columns(header, POSE_DATA_CSV_COLUMNS)
+
+        # Read the rest of the rows in the CSV file
+        for row in reader:
+            #位置
+            translation = [
+                #"t_wo_x[m]" 这个字符串在 header 列表的第几位？ 然后读取
+                row[header.index("t_wo_x[m]")],
+                row[header.index("t_wo_y[m]")],
+                row[header.index("t_wo_z[m]")],
+            ]
+            #朝向
+            quaternion_xyz = [
+                ##"q_wo_x 这个字符串在 header 列表的第几位？ 然后读取
+                row[header.index("q_wo_x")],
+                row[header.index("q_wo_y")],
+                row[header.index("q_wo_z")],
+            ]
+            quaternion_w = row[header.index("q_wo_w")]
+            timestamp_ns = int(row[header.index("timestamp[ns]")])
+            object_uid = str(row[header.index("object_uid")])
+            #把位置和朝向转换成 SE3 变换矩阵，se3 物品位置和朝向的信息    
+            T_world_object = SE3.from_quat_and_translation(
+                float(quaternion_w),
+                np.array([float(o) for o in quaternion_xyz]),
+                np.array([float(o) for o in translation]),
+            )[0]
+
+            pose3d = ObjectPose3d(T_world_object=T_world_object)
+            #确保timestamp_ns有位置
+            if timestamp_ns not in pose3d_trajectory:
+                pose3d_trajectory[timestamp_ns] = ObjectPose3dCollection(
+                    timestamp_ns=timestamp_ns, poses={}
+                )
+
+            pose3d_trajectory[timestamp_ns].poses[object_uid] = pose3d
+
+    return pose3d_trajectory
+
+
+def load_pose_provider_from_csv(filename: str) -> ObjectPose3dProvider:
+    """
+    Load the ObjectPose3dProvider from a csv file
+    """
+    return ObjectPose3dProvider(
+        pose3d_trajectory=load_object_pose_trajectory_from_csv(filename)
+    )

HOT3DHUGGFACE/data_loaders/PathProvider.py

@@ -0,0 +1,141 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from abc import abstractmethod
+
+from .headsets import Headset
+from .io_utils import load_json
+
+
+#提供所有文件的地址
+class SequenceDatasetPathsBase:
+    """
+    Class defining the expected filepaths for a given HOT3D sequence
+    This base class can be extended to support headset specific filepaths (Aria, Quest, etc.)
+    """
+
+    def __init__(self, recording_instance_folderpath):
+        self._recording_instance_folderpath = recording_instance_folderpath
+
+    @property
+    def recording_instance_folderpath(self):
+        return self._recording_instance_folderpath
+
+    @property
+    def dynamic_objects_filepath(self):
+        return f"{self._recording_instance_folderpath}/dynamic_objects.csv"
+
+    @property
+    def headset_trajectory_filepath(self):
+        return f"{self._recording_instance_folderpath}/headset_trajectory.csv"
+
+    @property
+    def mano_hand_pose_trajectory_filepath(self):
+        return f"{self._recording_instance_folderpath}/mano_hand_pose_trajectory.jsonl"
+
+    @property
+    def umetrack_hand_user_profile_filepath(self):
+        return f"{self._recording_instance_folderpath}/umetrack_hand_user_profile.json"
+
+    @property
+    def umetrack_hand_pose_trajectory_filepath(self):
+        return (
+            f"{self._recording_instance_folderpath}/umetrack_hand_pose_trajectory.jsonl"
+        )
+
+    @property
+    def vrs_filepath(self):
+        return f"{self._recording_instance_folderpath}/recording.vrs"
+
+    @property
+    def box2d_objects_filepath(self):
+        return f"{self._recording_instance_folderpath}/box2d_objects.csv"
+
+    @property
+    def box2d_hands_filepath(self):
+        return f"{self._recording_instance_folderpath}/box2d_hands.csv"
+
+    @property
+    def scene_metadata_filepath(self):
+        return f"{self._recording_instance_folderpath}/metadata.json"
+
+    @abstractmethod
+    def is_valid(self) -> bool:
+        """
+        Returns if the list of required file for the Headset sequence are available
+        """
+
+
+class Hot3dDataPathProvider(object):
+    @staticmethod
+    def fromRecordingFolder(recording_instance_folderpath) -> SequenceDatasetPathsBase:
+        metadata_filepath = os.path.join(recording_instance_folderpath, "metadata.json")
+        metadata_json = load_json(metadata_filepath)
+        headset = Headset[metadata_json["headset"]]
+
+        if headset is Headset.Aria:
+            return AriaDatasetPaths(
+                recording_instance_folderpath=recording_instance_folderpath
+            )
+        elif headset is Headset.Quest3:
+            return Quest3DatasetPaths(
+                recording_instance_folderpath=recording_instance_folderpath
+            )
+        else:
+            raise NotImplementedError(f"{headset} not supported at the moment.")
+
+
+#继承，子类自动拥有父类的所有属性和方法
+class Quest3DatasetPaths(SequenceDatasetPathsBase):
+    def __init__(self, recording_instance_folderpath):
+        super().__init__(recording_instance_folderpath)
+
+    @property
+    def camera_models_filepath(self):
+        return f"{self._recording_instance_folderpath}/camera_models.json"
+
+    @property
+    def required_filepaths(self):
+        return [
+            self.vrs_filepath,
+            self.dynamic_objects_filepath,
+            self.headset_trajectory_filepath,
+            self.camera_models_filepath,
+            self.mano_hand_pose_trajectory_filepath,
+        ]
+
+    def is_valid(self) -> bool:
+        return all(os.path.exists(filepath) for filepath in self.required_filepaths)
+
+
+class AriaDatasetPaths(SequenceDatasetPathsBase):
+    def __init__(self, recording_instance_folderpath):
+        super().__init__(recording_instance_folderpath)
+
+    @property
+    def mps_folderpath(self):
+        return f"{self._recording_instance_folderpath}/mps"
+
+    @property
+    def required_filepaths(self):
+        return [
+            self.vrs_filepath,
+            self.dynamic_objects_filepath,
+            self.headset_trajectory_filepath,
+            self.mano_hand_pose_trajectory_filepath,
+        ]
+
+    def is_valid(self) -> bool:
+        return all(os.path.exists(filepath) for filepath in self.required_filepaths)

HOT3DHUGGFACE/data_loaders/QuestDataProvider.py

@@ -0,0 +1,257 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict, List, Optional
+
+import numpy as np
+from data_loaders.frameset import compute_frameset_for_timestamp
+from data_loaders.io_utils import load_json
+from PIL import Image
+from projectaria_tools.core.calibration import (  # @manual
+    CameraCalibration,
+    DeviceCadExtrinsics,
+    DeviceCalibration,
+    distort_by_calibration,
+    FISHEYE624,
+    get_linear_camera_calibration,
+    LINEAR,
+)
+from projectaria_tools.core.sensor_data import TimeDomain  # @manual
+from projectaria_tools.core.sophus import SE3  # @manual
+from projectaria_tools.core.stream_id import StreamId  # @manual
+
+try:
+    from pyvrs import ImageConversion, SyncVRSReader  # @manual
+except ImportError:
+    from pyvrs2 import SyncVRSReader  # @manual
+    from vrsbindings import ImageConversion  # @manual
+
+
+class QuestDataProvider:
+    #recording.vrs-----vrs_filepath,
+    #camera_models.json---device_calibration_filepath,
+    def __init__(self, vrs_filepath: str, device_calibration_filepath: str) -> None:
+        #打开VRS 文件
+        self._vrs_reader = SyncVRSReader(vrs_filepath)
+        # Configure Image conversion
+        #把所有图像像素值归一化到 [0, 1]
+        self._vrs_reader.set_image_conversion(ImageConversion.NORMALIZE)
+        #转换成 8位灰度图
+        self._vrs_reader.set_stream_type_image_conversion(
+            8010, ImageConversion.NORMALIZE_GREY8
+        )
+
+        # extract the streamids corresponding to the image streams
+        #判断这个流是否包含图像，只保留图像流，过滤掉 IMU、音频等其他流。
+        image_stream_ids = []
+        for stream_id in self._vrs_reader.stream_ids:
+            if self._vrs_reader.might_contain_images(stream_id):
+                image_stream_ids.append(stream_id)
+        image_stream_ids = sorted(image_stream_ids)
+        image_stream_ids = []
+        for stream_id in self._vrs_reader.stream_ids:
+            if self._vrs_reader.might_contain_images(stream_id):
+                image_stream_ids.append(stream_id)
+        image_stream_ids = sorted(image_stream_ids)
+        # Filter the reader
+        filtered_reader = self._vrs_reader.filtered_by_fields(
+            stream_ids=image_stream_ids
+        )
+        self._vrs_reader = filtered_reader
+
+        # Loading camera calibration data
+        device_calibration_json = load_json(device_calibration_filepath)
+        camera_calibration = {}
+        for it in device_calibration_json:
+            quaternion = it["T_Device_Camera"]["quaternion_wxyz"]
+            translation = it["T_Device_Camera"]["translation_xyz"]
+            image_height = it["imageHeight"]
+            image_width = it["imageWidth"]
+            label = it["label"]
+            max_solid_angle = 1  # Limiting the fov to a constant value.
+            # projection_model_type = it["projectionModelType"]
+            projection_params = it["projectionParams"]
+            serial_number = it["serialNumber"]
+            #两个分开的数据合并成一个 SE3 
+            #有误导性的命名，T_world_device 实际上是从相机坐标系到设备坐标系的变换？？
+            T_world_device = SE3.from_quat_and_translation(
+                quaternion[0],
+                quaternion[1:4],
+                translation,
+            )
+            # Skip focal_y and rely on a single focal length for x,y
+            projection_params = projection_params[:1] + projection_params[2:]
+
+            # Build the corresponding camera calibration object
+            camera_calibration[label] = CameraCalibration(
+                label,
+                FISHEYE624,
+                projection_params,
+                T_world_device,
+                image_width,
+                image_height,
+                None,
+                max_solid_angle,
+                serial_number,
+            )
+
+        self._device_calibration = DeviceCalibration(
+            camera_calibration,
+            {},
+            {},
+            {},
+            {},
+            DeviceCadExtrinsics(),
+            "",
+            "",
+        )
+
+        # Pre-compute the sorted timestamps for each image stream
+        self._stream_timestamps_sorted: Dict[str, List[int]] = {}
+        for stream_id in self.get_image_stream_ids():
+            self._stream_timestamps_sorted[str(stream_id)] = sorted(
+                self.get_sequence_timestamps()
+            )
+
+    def get_device_calibration(self) -> DeviceCalibration:
+        """
+        Return the device calibration (factory calibration of all sensors)
+        """
+        return self._device_calibration
+    #返回设备的相机标定数据，以及每个摄像头的内参
+    def get_camera_calibration(
+        self,
+        stream_id: StreamId,
+        camera_model=FISHEYE624,
+    ) -> tuple[SE3, CameraCalibration]:
+        """
+        Return the camera calibration of the device of the sequence as [Extrinsics, Intrinsics]
+        Note:
+         - A corresponding pinhole camera can be requested by using camera_model = LINEAR.
+         - This is the camera model used to generate the 'get_undistorted_image'.
+        """
+        if not (camera_model is FISHEYE624 or camera_model is LINEAR):
+            raise ValueError(
+                "Invalid camera_model type, only FISHEYE624 and LINEAR are supported"
+            )
+
+        device_calibration = self.get_device_calibration()
+        # Map the string to the right label
+        stream_label = self.get_image_stream_label(stream_id)
+        stream_labels_str = [
+            self.get_image_stream_label(x) for x in self.get_image_stream_ids()
+        ]
+        idx_stream = stream_labels_str.index(stream_label)
+        corresponding_calibration_label = device_calibration.get_camera_labels()[
+            idx_stream
+        ]
+        camera_calibration = device_calibration.get_camera_calib(
+            corresponding_calibration_label
+        )
+
+        # Store the relative transform from device to camera
+        T_device_camera = camera_calibration.get_transform_device_camera()
+
+        # If a corresponding pinhole camera is requested, we build one on the fly
+        if camera_model == LINEAR:
+            focal_lengths = camera_calibration.get_focal_lengths()
+            image_size = camera_calibration.get_image_size()
+            camera_calibration = get_linear_camera_calibration(
+                image_size[0], image_size[1], focal_lengths[0]
+            )
+        # else return the native FISHEYE624 camera model
+
+        return [T_device_camera, camera_calibration]
+
+    def get_image_stream_ids(self) -> List[StreamId]:
+        # retrieve all streams ids and filter the one that are image based
+        image_stream_ids = []
+        for stream_id in self._vrs_reader.stream_ids:
+            if self._vrs_reader.might_contain_images(stream_id):
+                image_stream_ids.append(stream_id)
+        image_stream_ids = sorted(image_stream_ids)
+        return [StreamId(x) for x in image_stream_ids]
+
+    def get_sequence_timestamps(self) -> List[int]:
+        """
+        Returns the list of "time code" timestamp for the sequence
+        """
+        timestamps = self._vrs_reader.get_timestamp_list()
+        # convert timestamp from float to int in ns
+        return sorted({int(x * 1e9) for x in timestamps})
+
+    def get_frameset_from_timestamp(
+        self,
+        timestamp_ns: int,
+        frameset_acceptable_time_diff_ns: int,
+        time_domain: TimeDomain = TimeDomain.TIME_CODE,
+    ) -> Dict[str, Optional[int]]:
+        """
+        Computes a frameset from a given timestamp within an acceptable time difference.
+        The frameset consists of the closest timestamps for each stream that are within the acceptable time difference.
+        For Quest3, the recommended acceptable time difference is 1e6 ns (or 1ms).
+        Returns a dictionary mapping each str(StreamId) to its closest timestamp.
+        """
+        if time_domain is not TimeDomain.TIME_CODE:
+            raise ValueError(
+                f"{time_domain} is not supported. Only TIME_CODE is supported"
+            )
+        out_frameset = compute_frameset_for_timestamp(
+            stream_timestamps_sorted=self._stream_timestamps_sorted,
+            target_timestamp=timestamp_ns,
+            frameset_acceptable_time_diff=frameset_acceptable_time_diff_ns,
+        )
+        return out_frameset
+
+    def get_image_stream_label(self, stream_id: StreamId) -> str:
+        return str(stream_id)
+
+    def get_image(self, timestamp_ns: int, stream_id: StreamId) -> Optional[np.ndarray]:
+        try:
+            record = self._vrs_reader.read_record_by_time(
+                stream_id=self.get_image_stream_label(stream_id),
+                timestamp=timestamp_ns / 1e9,
+            )
+        except ValueError as e:
+            print(
+                f"No record found for timestamp {timestamp_ns} and stream {stream_id}. Caught exception: {e}"
+            )
+            record = None
+
+        if record is not None and record.record_type == "data":
+            grey8 = Image.fromarray(record.image_blocks[0])
+            return np.array(grey8)
+        else:
+            print(f"No image found for timestamp {timestamp_ns} and stream {stream_id}")
+        return None
+
+    def get_undistorted_image(
+        self, timestamp_ns: int, stream_id: StreamId
+    ) -> Optional[np.ndarray]:
+        image = self.get_image(timestamp_ns, stream_id)
+        if image is None:
+            return None
+
+        [T_device_camera, native_camera_calibration] = self.get_camera_calibration(
+            stream_id, camera_model=FISHEYE624
+        )
+        [T_device_camera, pinhole_camera_calibration] = self.get_camera_calibration(
+            stream_id, camera_model=LINEAR
+        )
+
+        # Compute the actual undistorted image
+        undistorted_image = distort_by_calibration(
+            image, pinhole_camera_calibration, native_camera_calibration
+        )
+        return undistorted_image

HOT3DHUGGFACE/data_loaders/UmeTrackHandDataProvider.py

@@ -0,0 +1,186 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import torch
+from data_loaders.HandDataProviderBase import HandDataProviderBase
+from data_loaders.loader_hand_poses import Handedness, HandPose
+from data_loaders.umetrack_layer import get_skinning_weights, skin_points
+
+
+@dataclass
+class UmeTrackHandModelData:
+    joint_rotation_axes: torch.Tensor
+    joint_rest_positions: torch.Tensor
+    joint_frame_index: torch.Tensor
+    joint_parent: torch.Tensor
+    joint_first_child: torch.Tensor
+    joint_next_sibling: torch.Tensor
+    landmark_rest_positions: torch.Tensor
+    landmark_rest_bone_weights: torch.Tensor
+    landmark_rest_bone_indices: torch.Tensor
+    hand_scale: Optional[torch.Tensor] = None
+    mesh_vertices: Optional[torch.Tensor] = None
+    mesh_triangles: Optional[torch.Tensor] = None
+    dense_bone_weights: Optional[torch.Tensor] = None
+    joint_limits: Optional[torch.Tensor] = None
+
+
+def from_dict(j: Dict[str, Any]) -> UmeTrackHandModelData:
+    model = UmeTrackHandModelData(**{k: torch.tensor(v) for k, v in j.items()})
+    MM_TO_M = 1e-3
+    model.joint_rest_positions *= MM_TO_M
+    model.landmark_rest_positions *= MM_TO_M
+    if model.mesh_vertices is not None:
+        model.mesh_vertices *= MM_TO_M
+    return model
+
+
+def load_hand_model_from_file(filename: str) -> Optional[UmeTrackHandModelData]:
+    with open(filename, "rb") as f:
+        hand_model_dict = json.load(f)
+        if "hand_model" in hand_model_dict.keys():
+            return from_dict(hand_model_dict["hand_model"])
+    return None
+
+
+class UmeTrackHandDataProvider(HandDataProviderBase):
+    def __init__(
+        self, hand_pose_trajectory_filepath: str, hand_profile_filepath: str
+    ) -> None:
+        super().__init__()
+        super()._init_hand_poses(hand_pose_trajectory_filepath)
+
+        # Hand profile
+        self._hand_model = (
+            None
+            if len(self._hand_poses) == 0
+            else load_hand_model_from_file(hand_profile_filepath)
+        )
+
+    def get_hand_mesh_vertices(
+        self, hand_wrist_data: HandPose
+    ) -> Optional[torch.Tensor]:
+        """
+        Return the hand mesh corresponding to given HandPose
+        """
+        if hand_wrist_data.wrist_pose is not None and self._hand_model is not None:
+            hand_wrist_pose_matrix = hand_wrist_data.wrist_pose.to_matrix()
+            hand_wrist_pose_tensor = torch.from_numpy(hand_wrist_pose_matrix)
+
+            # self._hand_model is defined for the Left hand,
+            #  flipping here the pose X axis is moving the Left Hand to a Right Hand
+            if hand_wrist_data.handedness == Handedness.Right:
+                hand_wrist_pose_tensor[:, 0] *= -1
+
+            mesh_vertices = skin_vertices(
+                self._hand_model,
+                torch.Tensor(hand_wrist_data.joint_angles),
+                hand_wrist_pose_tensor,
+            )
+            return mesh_vertices
+        return None
+
+    def get_hand_mesh_faces_and_normals(
+        self, hand_wrist_data: HandPose
+    ) -> Optional[List[np.ndarray]]:
+        """
+        Return the hand mesh faces and normals
+        """
+        if self._hand_model is not None and self._hand_model.mesh_triangles is not None:
+            hand_triangles = self._hand_model.mesh_triangles.int().numpy()
+            vertices = self.get_hand_mesh_vertices(hand_wrist_data)
+            assert vertices is not None
+            normals = HandDataProviderBase.get_triangular_mesh_normals(
+                vertices.float().numpy(), hand_triangles
+            )
+            return [hand_triangles, normals]
+        else:
+            return None
+
+    def get_hand_landmarks(self, hand_wrist_data: HandPose) -> Optional[torch.Tensor]:
+        """
+        Return the hand joint landmarks corresponding to given HandPose
+        See how to map the vertices together to represent a Hand as linked lines using LANDMARK_CONNECTIVITY
+        """
+        if self._hand_model is not None and self._hand_model.mesh_triangles is not None:
+            hand_wrist_pose_matrix = hand_wrist_data.wrist_pose.to_matrix()
+            hand_wrist_pose_tensor = torch.from_numpy(hand_wrist_pose_matrix)
+
+            # self._hand_model is defined for the Left hand,
+            #  flipping here the pose X axis is moving the Left Hand to a Right Hand
+            if hand_wrist_data.handedness == Handedness.Right:
+                hand_wrist_pose_tensor[:, 0] *= -1
+
+            hand_landmarks = skin_landmarks(
+                self._hand_model,
+                torch.Tensor(hand_wrist_data.joint_angles),
+                hand_wrist_pose_tensor,
+            )
+            return hand_landmarks
+
+        return None
+
+
+NUM_JOINT_FRAMES: int = 1 + 1 + 3 * 5  # root + wrist + finger frames * 5
+
+
+def skin_landmarks(
+    hand_model: UmeTrackHandModelData,
+    joint_angles: torch.Tensor,
+    wrist_transforms: torch.Tensor,
+) -> torch.Tensor:
+    leading_dims = joint_angles.shape[:-1]
+    numel = torch.flatten(joint_angles, end_dim=-2).shape[0] if len(leading_dims) else 1
+    max_weights = hand_model.landmark_rest_bone_indices.shape[-1]
+    skin_mat = get_skinning_weights(
+        hand_model.landmark_rest_bone_indices.reshape(numel, -1, max_weights),
+        hand_model.landmark_rest_bone_weights.reshape(numel, -1, max_weights),
+        NUM_JOINT_FRAMES,
+    )
+    return skin_points(
+        hand_model.joint_rest_positions.double(),
+        hand_model.joint_rotation_axes.double(),
+        skin_mat.double(),
+        joint_angles.double(),
+        hand_model.landmark_rest_positions.double(),
+        wrist_transforms.double(),
+    )
+
+
+def skin_vertices(
+    hand_model: UmeTrackHandModelData,
+    joint_angles: torch.Tensor,
+    wrist_transforms: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    assert hand_model.mesh_vertices is not None, "mesh vertices should not be none"
+    assert hand_model.dense_bone_weights is not None, (
+        "dense bone weights should not be none"
+    )
+    vertices = skin_points(
+        hand_model.joint_rest_positions.double(),
+        hand_model.joint_rotation_axes.double(),
+        hand_model.dense_bone_weights.double(),
+        joint_angles.double(),
+        hand_model.mesh_vertices.double(),
+        wrist_transforms.double(),
+    )
+
+    leading_dims = joint_angles.shape[:-1]
+    vertices = vertices.reshape(list(leading_dims) + list(vertices.shape[-2:]))
+    return vertices

HOT3DHUGGFACE/data_loaders/constants.py

@@ -0,0 +1,53 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+POSE_DATA_CSV_COLUMNS = [
+    "object_uid",
+    "timestamp[ns]",
+    "t_wo_x[m]",
+    "t_wo_y[m]",
+    "t_wo_z[m]",
+    "q_wo_w",
+    "q_wo_x",
+    "q_wo_y",
+    "q_wo_z",
+]
+
+BOX2D_DATA_CSV_COLUMNS = [
+    "stream_id",
+    "object_uid",
+    "timestamp[ns]",
+    "x_min[pixel]",
+    "x_max[pixel]",
+    "y_min[pixel]",
+    "y_max[pixel]",
+    "visibility_ratio[%]",
+]
+
+HAND_BOX2D_DATA_CSV_COLUMNS = [
+    "stream_id",
+    "hand_index",
+    "timestamp[ns]",
+    "x_min[pixel]",
+    "x_max[pixel]",
+    "y_min[pixel]",
+    "y_max[pixel]",
+    "visibility_ratio[%]",
+]
+
+MASK_DATA_CSV_COLUMNS = [
+    "timestamp[ns]",
+    "stream_id",
+    "mask",
+]

HOT3DHUGGFACE/data_loaders/frameset.py

@@ -0,0 +1,66 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import bisect
+from typing import Dict, List, Optional
+
+
+def find_closest(sorted_input_list: List[int], target: int) -> int:
+    """
+    Find the closest value in a sorted list to a target value
+    """
+    index = bisect.bisect_left(sorted_input_list, target)
+    if index == 0:
+        closest = sorted_input_list[0]
+    elif index == len(sorted_input_list):
+        closest = sorted_input_list[-1]
+    else:
+        before = sorted_input_list[index - 1]
+        after = sorted_input_list[index]
+        if abs(target - after) > abs(target - before):
+            closest = before
+        else:
+            closest = after
+    return closest
+
+
+def compute_frameset_for_timestamp(
+    stream_timestamps_sorted: Dict[str, List[int]],
+    target_timestamp: int,
+    frameset_acceptable_time_diff: int,
+) -> Dict[str, Optional[int]]:
+    """
+    Compute the frameset for a given timestamp.
+    The frameset consists of the closest timestamps for each stream that are within the acceptable time difference.
+    Args:
+        stream_timestamps_sorted: A dictionary containing lists of sorted timestamps indexed by str(StreamId).
+        target_timestamp: The target timestamp to compute the frameset for.
+        frameset_acceptable_time_diff: The maximum difference between the target timestamp and the closest timestamp in each stream.
+    Returns:
+        A dictionary of str(StreamId) to timestamps which defines a frameset at the target timestamp.
+    """
+
+    stream_id_strs = list(stream_timestamps_sorted.keys())
+    frameset = {}
+    for stream_id_str in stream_id_strs:
+        closest_timestamp = find_closest(
+            sorted_input_list=stream_timestamps_sorted[stream_id_str],
+            target=target_timestamp,
+        )
+        if abs(closest_timestamp - target_timestamp) < frameset_acceptable_time_diff:
+            frameset[stream_id_str] = closest_timestamp
+        else:
+            frameset[stream_id_str] = None
+
+    return frameset

HOT3DHUGGFACE/data_loaders/hand_common.py

@@ -0,0 +1,169 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from enum import Enum
+
+# Define a HAND with 21 landmarks
+
+
+class LANDMARK(Enum):
+    THUMB_FINGERTIP = "Thumb fingertip"
+    INDEX_FINGER_FINGERTIP = "Index finger fingertip"
+    MIDDLE_FINGER_FINGERTIP = "Middle finger fingertip"
+    RING_FINGER_FINGERTIP = "Ring finger fingertip"
+    PINKY_FINGER_FINGERTIP = "Pinky finger fingertip"
+    WRIST_JOINT = "Wrist joint"
+    THUMB_INTERMEDIATE_FRAME = "Thumb intermediate frame"
+    THUMB_DISTAL_FRAME = "Thumb distal frame"
+    INDEX_PROXIMAL_FRAME = "Index proximal frame"
+    INDEX_INTERMEDIATE_FRAME = "Index intermediate frame"
+    INDEX_DISTAL_FRAME = "Index distal frame"
+    MIDDLE_PROXIMAL_FRAME = "Middle proximal frame"
+    MIDDLE_INTERMEDIATE_FRAME = "Middle intermediate frame"
+    MIDDLE_DISTAL_FRAME = "Middle distal frame"
+    RING_PROXIMAL_FRAME = "Ring proximal frame"
+    RING_INTERMEDIATE_FRAME = "Ring intermediate frame"
+    RING_DISTAL_FRAME = "Ring distal frame"
+    PINKY_PROXIMAL_FRAME = "Pinky proximal frame"
+    PINKY_INTERMEDIATE_FRAME = "Pinky intermediate frame"
+    PINKY_DISTAL_FRAME = "Pinky distal frame"
+    PALM_CENTER = "Palm center"
+
+
+LANDMARK_INDEX_TO_NAMING = [
+    LANDMARK.THUMB_FINGERTIP,
+    LANDMARK.INDEX_FINGER_FINGERTIP,
+    LANDMARK.MIDDLE_FINGER_FINGERTIP,
+    LANDMARK.RING_FINGER_FINGERTIP,
+    LANDMARK.PINKY_FINGER_FINGERTIP,
+    LANDMARK.WRIST_JOINT,
+    LANDMARK.THUMB_INTERMEDIATE_FRAME,
+    LANDMARK.THUMB_DISTAL_FRAME,
+    LANDMARK.INDEX_PROXIMAL_FRAME,
+    LANDMARK.INDEX_INTERMEDIATE_FRAME,
+    LANDMARK.INDEX_DISTAL_FRAME,
+    LANDMARK.MIDDLE_PROXIMAL_FRAME,
+    LANDMARK.MIDDLE_INTERMEDIATE_FRAME,
+    LANDMARK.MIDDLE_DISTAL_FRAME,
+    LANDMARK.RING_PROXIMAL_FRAME,
+    LANDMARK.RING_INTERMEDIATE_FRAME,
+    LANDMARK.RING_DISTAL_FRAME,
+    LANDMARK.PINKY_PROXIMAL_FRAME,
+    LANDMARK.PINKY_INTERMEDIATE_FRAME,
+    LANDMARK.PINKY_DISTAL_FRAME,
+    LANDMARK.PALM_CENTER,
+]
+
+LANDMARK_NAMING_TO_INDEX = {k: i for i, k in enumerate(LANDMARK_INDEX_TO_NAMING)}
+
+LANDMARK_CONNECTIVITY = [
+    # pinky
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.WRIST_JOINT],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.PINKY_PROXIMAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.PINKY_PROXIMAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.PINKY_INTERMEDIATE_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.PINKY_INTERMEDIATE_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.PINKY_DISTAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.PINKY_DISTAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.PINKY_FINGER_FINGERTIP],
+    ],
+    # ring
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.WRIST_JOINT],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_PROXIMAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_PROXIMAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_INTERMEDIATE_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_INTERMEDIATE_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_DISTAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_DISTAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_FINGER_FINGERTIP],
+    ],
+    # middle
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.WRIST_JOINT],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_PROXIMAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_PROXIMAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_INTERMEDIATE_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_INTERMEDIATE_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_DISTAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_DISTAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_FINGER_FINGERTIP],
+    ],
+    # index
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.WRIST_JOINT],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_PROXIMAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_PROXIMAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_INTERMEDIATE_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_INTERMEDIATE_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_DISTAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_DISTAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_FINGER_FINGERTIP],
+    ],
+    # thumb
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.WRIST_JOINT],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.THUMB_INTERMEDIATE_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.THUMB_INTERMEDIATE_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.THUMB_DISTAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.THUMB_DISTAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.THUMB_FINGERTIP],
+    ],
+    # palm
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.THUMB_INTERMEDIATE_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_PROXIMAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.INDEX_PROXIMAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_PROXIMAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.MIDDLE_PROXIMAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_PROXIMAL_FRAME],
+    ],
+    [
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.RING_PROXIMAL_FRAME],
+        LANDMARK_NAMING_TO_INDEX[LANDMARK.PINKY_PROXIMAL_FRAME],
+    ],
+]

HOT3DHUGGFACE/data_loaders/headsets.py

@@ -0,0 +1,20 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from enum import auto, Enum
+
+
+class Headset(Enum):
+    Aria = auto()
+    Quest3 = auto()

HOT3DHUGGFACE/data_loaders/io_utils.py

@@ -0,0 +1,70 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from typing import Any, Optional
+
+
+def load_json(json_filepath):
+    with open(json_filepath, "r") as fp:
+        return json.loads(fp.read())
+
+
+def write_json(payload, json_filepath):
+    with open(json_filepath, "w") as fp:
+        json.dump(payload, fp, indent=4, sort_keys=True)
+
+
+def is_float(x: Any) -> bool:
+    """
+    Function checks if the input is convertible to float
+    """
+    if x is None:
+        return False
+    if len(x) == 0:
+        return False
+    try:
+        float(x)
+        return True
+    except ValueError:
+        return False
+
+
+def is_int(x: Any) -> bool:
+    """
+    Function checks if the input is convertible to int
+    """
+    if x is None:
+        return False
+    if len(x) == 0:
+        return False
+    try:
+        int(x)
+        return True
+    except ValueError:
+        return False
+
+
+def float_or_none(x: Any) -> Optional[float]:
+    """
+    Function returns a float if x is convertible to float, otherwise None
+    """
+    return float(x) if is_float(x) else None
+
+
+def int_or_none(x: Any) -> Optional[int]:
+    """
+    Function returns a int if x is convertible to int, otherwise None
+    """
+    return int(x) if is_int(x) else None

HOT3DHUGGFACE/data_loaders/loader_hand_poses.py

@@ -0,0 +1,175 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from dataclasses import dataclass
+from enum import auto, Enum
+from typing import Dict, List, Optional
+
+import numpy as np
+from projectaria_tools.core.sophus import SE3  # @manual
+
+LEFT_HAND_INDEX = 0
+RIGHT_HAND_INDEX = 1
+
+
+class Handedness(Enum):
+    Left = int(LEFT_HAND_INDEX)
+    Right = int(RIGHT_HAND_INDEX)
+
+
+class HandType(Enum):
+    Mano = auto()
+    Umetrack = auto()
+
+
+@dataclass
+class HandPose:
+    """Define a Hand pose as wrist_pose (SE3), and joint_angles."""
+
+    handedness: Handedness
+    wrist_pose: Optional[SE3]
+    joint_angles: List[float]
+
+    def is_left_hand(self) -> bool:
+        return self.handedness == Handedness.Left
+
+    def is_right_hand(self) -> bool:
+        return self.handedness == Handedness.Right
+
+    def handedness_label(self) -> str:
+        return "left" if self.is_left_hand() else "right"
+
+
+@dataclass
+class HandPose3dCollection:
+    """
+    Class to store the Hand poses for a given timestamp
+    """
+
+    timestamp_ns: int
+    poses: Dict[Handedness, HandPose]
+
+
+TimestampHandPoses3d = Dict[int, HandPose3dCollection]
+
+
+def _get_hand_pose(handedness: str, hand_poses_json: Dict) -> Optional[SE3]:
+    if handedness in hand_poses_json.keys():
+        wrist = hand_poses_json[handedness]["wrist_xform"]
+        #JSONL文件，可以直接用标签读取，不用像csv文件一样用header.index()读取
+        quaternion_w = wrist["q_wxyz"][0]
+        quaternion_xyz = wrist["q_wxyz"][1:4]
+        translation = wrist["t_xyz"]
+        hand_pose = SE3.from_quat_and_translation(
+            float(quaternion_w),
+            np.array([float(o) for o in quaternion_xyz]),
+            np.array([float(o) for o in translation]),
+        )[0]
+        return hand_pose
+    return None
+
+
+def _get_joint_angles(handedness: str, hand_poses_json: Dict) -> Optional[List[float]]:
+    if handedness in hand_poses_json.keys():
+        if "pose" in hand_poses_json[handedness].keys():
+            return hand_poses_json[handedness]["pose"]  # MANO pose_pca
+        elif "joint_angles" in hand_poses_json[handedness].keys():
+            return hand_poses_json[handedness]["joint_angles"]  # UMETRACK joint angles
+    return None
+
+
+def parse_hand_poses_from_fileobject(fileobject):
+    hand_poses_per_timestamp: TimestampHandPoses3d = {}
+    for line in fileobject:
+        # Parse the JSON file line
+        #把json转移成字典
+        hand_pose_instance = json.loads(line)
+        timestamp_ns = hand_pose_instance["timestamp_ns"]
+        hand_poses_json = hand_pose_instance["hand_poses"]
+
+        # Read hand pose data
+        #	在哪里
+        left_hand_pose = _get_hand_pose(str(LEFT_HAND_INDEX), hand_poses_json)
+        right_hand_pose = _get_hand_pose(str(RIGHT_HAND_INDEX), hand_poses_json)
+        
+        #	各关节角度（手势）
+        left_joint_angles = _get_joint_angles(str(LEFT_HAND_INDEX), hand_poses_json)
+        right_joint_angles = _get_joint_angles(str(RIGHT_HAND_INDEX), hand_poses_json)
+
+        # If hand pose data is available, add it to the dictionary
+        if (
+            left_hand_pose is not None or right_hand_pose is not None
+        ) and timestamp_ns not in hand_poses_per_timestamp:
+            #将hand_poses_per_timestamp[timestamp_ns]放入一个HandPose3dCollection对象，里面包含timestamp_ns=timestamp_ns, poses={}
+            hand_poses_per_timestamp[timestamp_ns] = HandPose3dCollection(
+                timestamp_ns=timestamp_ns, poses={}
+            )
+
+        if left_hand_pose is not None:
+            #调用上面创建的对象中的posees字典，poses是一个dict Dict[Handedness, HandPose]
+            #Handedness0=左手 Handedness1=右手
+            hand_poses_per_timestamp[timestamp_ns].poses[Handedness.Left] = HandPose(
+                Handedness.Left, left_hand_pose, left_joint_angles
+            )
+
+        if right_hand_pose is not None:
+            hand_poses_per_timestamp[timestamp_ns].poses[Handedness.Right] = HandPose(
+                Handedness.Right, right_hand_pose, right_joint_angles
+            )
+    return hand_poses_per_timestamp
+
+
+def load_hand_poses(filename: str) -> TimestampHandPoses3d:
+    """Load Hand Poses meta data from a JSONL file.
+
+    Keyword arguments:
+    filename -- the jsonl file i.e. sequence_folder + "/hand_pose_trajectory.jsonl"
+    """
+    with open(filename, "r") as fobj:
+        hand_poses_per_timestamp = parse_hand_poses_from_fileobject(fobj)
+
+    return hand_poses_per_timestamp
+
+
+def load_hand_pose_as_json_lines(filename: str) -> Dict[int, Dict]:
+    """
+    Load Hand Poses as JSON payload (Dict) per timestamp from a json line file
+    """
+    timestamp_jsons = {}
+    with open(filename, "r") as f:
+        for line in f:
+            # Parse the JSON file line
+            hand_pose_instance = json.loads(line)
+            timestamp_ns = hand_pose_instance["timestamp_ns"]
+            hand_poses_json = hand_pose_instance["hand_poses"]
+            timestamp_jsons[timestamp_ns] = hand_poses_json
+    return timestamp_jsons
+
+
+def load_mano_shape_params(filename: str) -> Optional[List[float]]:
+    betas = None
+    with open(filename, "rb") as f:
+        for line in f:
+            hand_pose_instance = json.loads(line)
+            for handedness in ["0", "1"]:
+                if (
+                    handedness in hand_pose_instance["hand_poses"].keys()
+                    and "betas" in hand_pose_instance["hand_poses"][handedness]
+                ):
+                    betas = hand_pose_instance["hand_poses"][handedness]["betas"]
+                    break
+            if betas is not None:
+                break
+    return betas

HOT3DHUGGFACE/data_loaders/loader_masks.py

@@ -0,0 +1,156 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import csv
+from collections import Counter
+from typing import Dict, List, Optional
+
+import numpy as np
+from projectaria_tools.core.stream_id import StreamId  # @manual
+
+from .constants import MASK_DATA_CSV_COLUMNS
+from .loader_poses_utils import check_csv_columns
+
+TimestampedMask = Dict[int, bool]
+StreamMask = Dict[str, TimestampedMask]
+
+
+class MaskData(object):
+    def __init__(self, mask_data: Optional[StreamMask] = None):
+        self._mask = mask_data if mask_data is not None else Dict[str, bool]
+
+    @property
+    def data(self):
+        return self._mask
+
+    @property
+    def stream_ids(self):
+        return [StreamId(x) for x in self._mask.keys()]
+
+    def stream_mask(self, stream_id: StreamId) -> Optional[TimestampedMask]:
+        return self._mask.get(str(stream_id), None)
+
+    def length(self, stream_id: StreamId) -> int:
+        if str(stream_id) not in self._mask:
+            return 0
+        return len(self._mask[str(stream_id)])
+
+    def num_true(self, stream_id: StreamId) -> int:
+        """Return the number of True values"""
+        if str(stream_id) not in self._mask:
+            return 0
+
+        return Counter(self._mask[str(stream_id)].values()).get(True, 0)
+
+    def num_false(self, stream_id: StreamId) -> int:
+        """Return the number of False values"""
+        if str(stream_id) not in self._mask:
+            return 0
+        return Counter(self._mask[str(stream_id)].values()).get(False, 0)
+
+    def stats(self):
+        return {
+            sid: {
+                "length": self.length(sid),
+                "num_true": self.num_true(sid),
+                "num_false": self.num_false(sid),
+            }
+            for sid in sorted(self._mask.keys())
+        }
+
+
+def load_mask_data(mask_filename: str) -> MaskData:
+    """Load mask data from a HOT3D mask CSV file.
+    Data saved as CSV with three columns:
+    # timestamp[ns],stream_id,mask
+    # 67842008213302,214-1,True
+    # ...
+    """
+    mask = {}
+    with open(mask_filename, "r") as f:
+        reader = csv.reader(f)
+
+        # Read the header row
+        header = next(reader)
+
+        # Ensure we have the desired columns
+        check_csv_columns(header, MASK_DATA_CSV_COLUMNS)
+
+        # Read the rest of the rows in the CSV file
+        for row in reader:
+            timestamp_int = int(row[header.index("timestamp[ns]")])
+            stream_id_str = row[header.index("stream_id")]
+            value = row[header.index("mask")]
+
+            if stream_id_str not in mask:
+                mask[stream_id_str] = {}
+
+            mask[stream_id_str][timestamp_int] = bool(value == "True")
+
+    return MaskData(mask)
+
+
+def combine_mask_data(
+    mask_list: List[MaskData],
+    operator: str = "and",  # i.e 'and' or 'or'
+) -> MaskData:
+    """
+    Combine mask data from two or three sources given a logical operator.
+    """
+
+    stream_id_strs = {str(y) for x in mask_list for y in x.stream_ids}
+    stream_ids = [StreamId(x) for x in stream_id_strs]
+
+    out_mask_dict = {}
+    for stream_id in stream_ids:
+        timestamped_mask_list = [x.stream_mask(stream_id=stream_id) for x in mask_list]
+        if any(x is None for x in timestamped_mask_list):
+            raise ValueError("mask data must be present for all streams")
+        out_mask_dict[str(stream_id)] = combine_timestamped_mask_data(
+            mask_list=timestamped_mask_list, operator=operator
+        )
+    return MaskData(out_mask_dict)
+
+
+def combine_timestamped_mask_data(
+    mask_list: List[TimestampedMask],
+    operator: str = "and",  # i.e 'and' or 'or'
+) -> TimestampedMask:
+    if len(mask_list) > 0:
+        if not all(len(d) == len(mask_list[0]) for d in mask_list):
+            raise ValueError("Mask data must have the same length")
+    else:
+        raise ValueError("mask_list must not be empty")
+
+    ## ensure the timestamps are identical across lists
+    reference_tsns_list = list(mask_list[0].keys())
+    for it in mask_list[1:]:
+        if list(it.keys()) != reference_tsns_list:
+            raise ValueError("Mask data must have the same timestamps")
+
+    resulting_array = np.array([mask_list[0][tsns] for tsns in reference_tsns_list])
+    # resulting_array = np.array(list(mask_list[0].values()))
+    for it in mask_list[1:]:
+        if operator == "and":
+            resulting_array = resulting_array & np.array(
+                [it[tsns] for tsns in reference_tsns_list]
+            )
+        elif operator == "or":
+            resulting_array = resulting_array | np.array(
+                [it[tsns] for tsns in reference_tsns_list]
+            )
+        else:
+            raise ValueError("Invalid operator")
+
+    return dict(zip(reference_tsns_list, resulting_array.tolist()))

HOT3DHUGGFACE/data_loaders/loader_object_library.py

@@ -0,0 +1,91 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import os
+from typing import Any, Dict, Set
+
+from .io_utils import load_json
+
+
+class ObjectLibrary(object):
+    def __init__(self, object_library_json: Dict[str, Any], asset_folder: str):
+        self._object_library_json = object_library_json
+        (
+            self._object_id_to_name_dict,
+            self._object_name_to_id_dict,
+        ) = self._get_object_id_name_mappings(object_library_json)
+        (
+            self._headset_id_to_name_dict,
+            self._headset_name_to_id_dict,
+        ) = self._get_headset_id_name_mappings(object_library_json)
+
+        self._asset_folder = asset_folder
+
+    @property
+    def object_id_to_name_dict(self):
+        return self._object_id_to_name_dict
+
+    @property
+    def object_name_to_id_dict(self):
+        return self._object_name_to_id_dict
+
+    @property
+    def headset_id_to_name_dict(self):
+        return self._headset_id_to_name_dict
+
+    @property
+    def headset_name_to_id_dict(self):
+        return self._headset_name_to_id_dict
+
+    @property
+    def object_uids(self) -> Set[str]:
+        return set(self._object_name_to_id_dict.values())
+
+    @property
+    def headset_uids(self) -> Set[str]:
+        return set(self._headset_name_to_id_dict.values())
+
+    @property
+    def asset_folder_name(self) -> str:
+        return self._asset_folder
+
+    def _get_object_id_name_mappings(self, object_info_json):
+        object_id_to_name_dict = {
+            k: v["instance_name"]
+            for k, v in object_info_json.items()
+            if v["instance_type"] == "object" and v["motion_type"] == "dynamic"
+        }
+        object_name_to_id_dict = {v: k for k, v in object_id_to_name_dict.items()}
+        return object_id_to_name_dict, object_name_to_id_dict
+
+    def _get_headset_id_name_mappings(self, object_info_json):
+        headset_id_to_name_dict = {
+            k: v["instance_name"]
+            for k, v in object_info_json.items()
+            if v["instance_type"] == "headset"
+        }
+        headset_name_to_id_dict = {v: k for k, v in headset_id_to_name_dict.items()}
+        return headset_id_to_name_dict, headset_name_to_id_dict
+
+    @staticmethod
+    def get_cad_asset_path(object_library_folderpath: str, object_id: str) -> str:
+        return os.path.join(object_library_folderpath, f"{object_id}.glb")
+
+
+def load_object_library(object_library_folderpath: str) -> ObjectLibrary:
+    instance_filepath = os.path.join(object_library_folderpath, "instance.json")
+    object_library_json = load_json(instance_filepath)
+    asset_folder = os.path.join(object_library_folderpath)
+    return ObjectLibrary(object_library_json, asset_folder)

HOT3DHUGGFACE/data_loaders/loader_poses_utils.py

@@ -0,0 +1,27 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from typing import List
+
+
+def check_csv_columns(csv_columns: List[str], expected_columns: List[str]) -> None:
+    """Ensure csv_columns is containing all value from expected_columns"""
+    for column in csv_columns:
+        if column not in expected_columns:
+            raise ValueError(
+                "Invalid Object CSV format. Expected columns are: {}".format(
+                    ", ".join(expected_columns)
+                )
+            )

HOT3DHUGGFACE/data_loaders/mano_layer.py

@@ -0,0 +1,314 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from typing import List, Optional
+
+SMPLX_IMPORT_SUCCEEDED = False  # default suppose we can't import SMPLX
+
+try:
+    import smplx
+
+    SMPLX_IMPORT_SUCCEEDED = True
+except ImportError:
+    print(
+        "INFO: HOT3D hands requires smplx (See our GitHub repository for more information on its installation)."
+    )
+
+import torch
+
+mano_joint_mapping = [
+    16,
+    17,
+    18,
+    19,
+    20,
+    0,
+    14,
+    15,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    10,
+    11,
+    12,
+    7,
+    8,
+    9,
+]
+
+
+class MANOHandModel:
+    #一只手有 778 个 3D 顶点
+    N_VERT = 778
+    N_LANDMARKS = 21
+    #每一个手指N_VERT中的index分区
+    MANO_FINGERTIP_VERT_INDICES = {
+        "thumb": 744,
+        "index": 320,
+        "middle": 443,
+        "ring": 554,
+        "pinky": 671,
+    }
+
+    def __init__(
+        self,
+        mano_model_files_dir: str,
+        ##手部关节索引列表：index list，也就是“索引列表”
+        joint_mapper: Optional[List] = mano_joint_mapping,
+    ):
+        mano_left_filename = os.path.join(mano_model_files_dir, "MANO_LEFT.pkl")
+        mano_right_filename = os.path.join(mano_model_files_dir, "MANO_RIGHT.pkl")
+
+        #PCA 全称是 Principal Component Analysis，中文通常叫 主成分分析
+        #降维方法，把很多手部参数，压缩成更少的几个重要参数。
+        #使用PCA，15个参数描述手部姿势变化，10 个参数描述手的形状
+        self.use_pose_pca = True
+        self.num_pose_coeffs = 15
+        self.num_shape_params = 10
+        self.device = "cpu"
+        self.dtype = torch.float32
+        self.joint_mapper = joint_mapper
+
+        #smplx.create创建 mano左手模型，一个 PyTorch 模型对象
+        self.mano_layer_left = smplx.create(
+            mano_left_filename,
+            "mano",
+            use_pca=self.use_pose_pca,
+            is_rhand=False,
+            num_pca_comps=self.num_pose_coeffs,
+        )
+        self.mano_layer_left.to(self.device)
+
+        self.mano_layer_right = smplx.create(
+            mano_right_filename,
+            "mano",
+            use_pca=self.use_pose_pca,
+            is_rhand=True,
+            num_pca_comps=self.num_pose_coeffs,
+        )
+        self.mano_layer_right.to(self.device)
+
+        #左右手同向bug
+        # fix MANO shapedirs of the left hand bug (https://github.com/vchoutas/smplx/issues/48)
+        if (
+            torch.sum(
+                torch.abs(
+                    self.mano_layer_left.shapedirs[:, 0, :]
+                    - self.mano_layer_right.shapedirs[:, 0, :]
+                )
+            )
+            < 1
+        ):
+            self.mano_layer_left.shapedirs[:, 0, :] *= -1
+
+    def forward_kinematics(
+        self,
+        shape_params: torch.Tensor,
+        #手指怎么弯、怎么张开
+        joint_angles: torch.Tensor,
+        #手的方向
+        global_xfrom: torch.Tensor,
+        is_right_hand: torch.Tensor,
+        #tuple元组，固定结构的返回值，x, y = get_result()
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        assert shape_params.shape[0] == self.num_shape_params
+        #在第 0 维前面加一个新维度，统一成 batch 格式。
+        is_batched = len(joint_angles.shape) == 2
+        if len(global_xfrom.shape) == 1:
+            global_xfrom = torch.unsqueeze(global_xfrom, 0)
+            
+        assert global_xfrom.shape[1] == 6
+        if len(joint_angles.shape) == 1:
+            joint_angles = torch.unsqueeze(joint_angles, 0)
+            
+        if self.use_pose_pca:
+            assert joint_angles.shape[1] == self.num_pose_coeffs
+        assert is_right_hand.shape[0] == joint_angles.shape[0]
+
+        num_frames = joint_angles.shape[0]
+
+        # Left hand FK
+        if torch.any(torch.logical_not(is_right_hand)):
+            #取出左手的 global_xfrom 和 joint_angles
+            left_global_xform = global_xfrom[torch.logical_not(is_right_hand)]
+            left_joint_angles = joint_angles[torch.logical_not(is_right_hand)]
+            #调用之前的left hand模型
+            left_mano_output = self.mano_layer_left(
+                #复制shape_params匹配batch大小
+                betas=shape_params[None]
+                .repeat(left_global_xform.shape[0], 1)
+                .to(self.dtype),
+                #手的朝向
+                global_orient=left_global_xform[:, :3].to(self.dtype),
+                hand_pose=left_joint_angles.to(self.dtype),
+                #整只手的平移
+                transl=left_global_xform[:, 3:].to(self.dtype),
+                #返回手部 mesh 顶点
+                return_verts=True,  # MANO doesn't return landmarks as well if this is false
+            )
+
+        # Right hand FK
+        if torch.any(is_right_hand):
+            right_global_xform = global_xfrom[is_right_hand]
+            right_joint_angles = joint_angles[is_right_hand]
+            right_mano_output = self.mano_layer_right(
+                betas=shape_params[None]
+                .repeat(right_global_xform.shape[0], 1)
+                .to(self.dtype),
+                global_orient=right_global_xform[:, :3].to(self.dtype),
+                hand_pose=right_joint_angles.to(self.dtype),
+                transl=right_global_xform[:, 3:].to(self.dtype),
+                return_verts=True,  # MANO doesn't return landmarks as well if this is false
+            )
+
+        # Merge the left and right hand outputs
+        #把左右手的顶点和关节合并到一起(mesh)
+        out_vertices = torch.zeros(
+            (
+                num_frames,
+                self.N_VERT,
+                3,
+            )
+        ).to(self.device)
+        if torch.any(torch.logical_not(is_right_hand)):
+            out_vertices[torch.logical_not(is_right_hand)] = left_mano_output.vertices
+        if torch.sum(is_right_hand) > 0:
+            out_vertices[is_right_hand] = right_mano_output.vertices
+
+        #把左右手的顶点和关节合并到一起(points)
+        out_landmarks = torch.zeros(
+            (
+                num_frames,
+                self.N_LANDMARKS,
+                3,
+            )
+        ).to(self.device)
+        if torch.any(torch.logical_not(is_right_hand)):
+            if left_mano_output.joints.shape[1] != self.N_LANDMARKS:
+                extra_joints = torch.index_select(
+                    left_mano_output.vertices,
+                    1,
+                    torch.tensor(
+                        list(self.MANO_FINGERTIP_VERT_INDICES.values()),
+                        dtype=torch.long,
+                    ),
+                )
+                joints = torch.cat([left_mano_output.joints, extra_joints], dim=1)
+            else:
+                joints = left_mano_output.joints
+            out_landmarks[torch.logical_not(is_right_hand)] = joints
+        if torch.sum(is_right_hand) > 0:
+            if right_mano_output.joints.shape[1] != self.N_LANDMARKS:
+                extra_joints = torch.index_select(
+                    right_mano_output.vertices,
+                    1,
+                    torch.tensor(
+                        list(self.MANO_FINGERTIP_VERT_INDICES.values()),
+                        dtype=torch.long,
+                    ),
+                )
+                joints = torch.cat([right_mano_output.joints, extra_joints], dim=1)
+            else:
+                joints = right_mano_output.joints
+            out_landmarks[is_right_hand] = joints
+
+        assert out_landmarks.shape[1] == self.N_LANDMARKS
+
+        if self.joint_mapper is not None:
+            out_landmarks = out_landmarks[:, self.joint_mapper]
+            
+        if not is_batched:
+            out_vertices = torch.squeeze(out_vertices, 0)
+            out_landmarks = torch.squeeze(out_landmarks, 0)
+
+        return out_vertices, out_landmarks
+
+    #简化版本，只有shape参数，pose参数和global xform都设为0
+    #pose_params = 0-->手指不弯曲，global_xform = 0 --> 手的朝向是默认的
+    #pose_xform = 0 --> 手的朝向是默认的，手的位置也是默认的
+    
+    def shape_only_forward_kinematics(
+        self,
+        shape_params: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Method to get the vertices and landmarks of the hand using only the shape
+        parameters and passing 0s for pose params and global xform.
+
+        Args:
+            shape_params: N x 6 (N is the number of frames) or 6,
+        """
+
+        is_batched = len(shape_params.shape) == 2
+        if is_batched:
+            assert shape_params.shape[1] == self.num_shape_params
+            num_frames = shape_params.shape[0]
+        else:
+            assert shape_params.shape[0] == self.num_shape_params
+            shape_params = shape_params.unsqueeze(0)
+            num_frames = 1
+
+        # create zero pose params
+        pose_params = torch.zeros((num_frames, 15))
+        pose_xform = torch.zeros((num_frames, 6))
+
+        # FK
+        left_mano_output = self.mano_layer_left(
+            betas=shape_params.to(self.dtype),
+            global_orient=pose_xform[:, :3].to(self.dtype),
+            hand_pose=pose_params.to(self.dtype),
+            transl=pose_xform[:, 3:].to(self.dtype),
+            return_verts=True,  # MANO doesn't return landmarks as well if this is false
+        )
+
+        # Merge the left and right hand outputs
+        out_vertices = left_mano_output.vertices
+
+        if left_mano_output.joints.shape[1] != self.N_LANDMARKS:
+            extra_joints = torch.index_select(
+                left_mano_output.vertices,
+                1,
+                torch.tensor(
+                    list(self.MANO_FINGERTIP_VERT_INDICES.values()),
+                    dtype=torch.long,
+                ),
+            )
+            joints = torch.cat([left_mano_output.joints, extra_joints], dim=1)
+        else:
+            joints = left_mano_output.joints
+        out_landmarks = joints
+
+        assert out_landmarks.shape[1] == self.N_LANDMARKS
+
+        if self.joint_mapper is not None:
+            out_landmarks = out_landmarks[:, self.joint_mapper]
+
+        if not is_batched:
+            out_vertices = torch.squeeze(out_vertices, 0)
+            out_landmarks = torch.squeeze(out_landmarks, 0)
+
+        return out_vertices, out_landmarks
+
+
+def loadManoHandModel(
+    mano_model_files_dir: Optional[str],
+) -> MANOHandModel:
+    if not SMPLX_IMPORT_SUCCEEDED or mano_model_files_dir is None:
+        return None
+
+    return MANOHandModel(mano_model_files_dir)

HOT3DHUGGFACE/data_loaders/pose_utils.py

@@ -0,0 +1,101 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import bisect
+from typing import Any, Dict, List, Optional, Tuple
+
+from projectaria_tools.core.sensor_data import TimeQueryOptions  # @manual
+
+
+def query_left_right(ordered_timestamps: List, query_timestamp: int):
+    """
+    Return the left and right timestamp of the query timestamp by using bisection.
+    Assumption: timestamps are monotonically sorted in the ordered_timestamps List
+    """
+    idx = bisect.bisect_left(ordered_timestamps, query_timestamp)
+    if idx == 0:
+        lower_timestamp = None
+    else:
+        lower_timestamp = ordered_timestamps[idx - 1]
+
+    if idx == len(ordered_timestamps):
+        upper_timestamp = None
+    else:
+        upper_timestamp = ordered_timestamps[idx]
+
+    if lower_timestamp is not None and upper_timestamp is not None:
+        alpha = (query_timestamp - lower_timestamp) / (
+            upper_timestamp - lower_timestamp
+        )
+    else:
+        alpha = None
+    return lower_timestamp, upper_timestamp, alpha
+
+
+def lookup_timestamp(
+    time_indexed_dict: Dict[int, Any],
+    sorted_timestamp_list: Optional[List[int]],
+    query_timestamp: int,
+    time_query_options: TimeQueryOptions,
+) -> Tuple[Any, int]:
+    """
+    Lookup the object corresponding to query_timestamp based on the time_query_options.
+    time_indexed_dict: a dictionary of timestamp to object
+    sorted_timestamp_list: a precomputed list of sorted timestamps in time_indexed_dict. If None, it will be computed from time_indexed_dict.
+    query_timestamp: the timestamp to query
+    time_query_options: the time query options to use (CLOSEST, BEFORE, AFTER)
+    """
+
+    if sorted_timestamp_list is None:
+        sorted_timestamp_list = sorted(time_indexed_dict.keys())
+
+    obj = None
+    time_delta_ns = None
+
+    if query_timestamp in time_indexed_dict:
+        obj = time_indexed_dict[query_timestamp]
+        time_delta_ns = 0
+    else:
+        left_frame_tsns, right_frame_tsns, alpha = query_left_right(
+            ordered_timestamps=sorted_timestamp_list,
+            query_timestamp=query_timestamp,
+        )
+        if time_query_options == TimeQueryOptions.BEFORE:
+            if left_frame_tsns is not None:
+                obj = time_indexed_dict[left_frame_tsns]
+                time_delta_ns = query_timestamp - left_frame_tsns
+
+        elif time_query_options == TimeQueryOptions.AFTER:
+            if right_frame_tsns is not None:
+                obj = time_indexed_dict[right_frame_tsns]
+                time_delta_ns = query_timestamp - right_frame_tsns
+
+        elif time_query_options == TimeQueryOptions.CLOSEST:
+            if left_frame_tsns is not None and right_frame_tsns is not None:
+                if abs(query_timestamp - left_frame_tsns) > abs(
+                    query_timestamp - right_frame_tsns
+                ):
+                    obj = time_indexed_dict[right_frame_tsns]
+                    time_delta_ns = query_timestamp - right_frame_tsns
+                else:
+                    obj = time_indexed_dict[left_frame_tsns]
+                    time_delta_ns = query_timestamp - left_frame_tsns
+            elif left_frame_tsns is not None:
+                obj = time_indexed_dict[left_frame_tsns]
+                time_delta_ns = query_timestamp - left_frame_tsns
+            elif right_frame_tsns is not None:
+                obj = time_indexed_dict[right_frame_tsns]
+                time_delta_ns = query_timestamp - right_frame_tsns
+
+    return obj, time_delta_ns

HOT3DHUGGFACE/data_loaders/pytorch3d_rotation/rotation_conversions.py

@@ -0,0 +1,171 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+#  * Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * Neither the name Meta nor the names of its contributors may be used to
+#    endorse or promote products derived from this software without specific
+#    prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# @lint-ignore-every LICENSELINT
+
+# Content of this file
+# Rotation functions extracted from PyTorch3d
+# https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/transforms/rotation_conversions.py
+
+
+import torch
+import torch.nn.functional as F
+
+
+def standardize_quaternion(quaternions: torch.Tensor) -> torch.Tensor:
+    """
+    Convert a unit quaternion to a standard form: one in which the real
+    part is non negative.
+
+    Args:
+        quaternions: Quaternions with real part first,
+            as tensor of shape (..., 4).
+
+    Returns:
+        Standardized quaternions as tensor of shape (..., 4).
+    """
+    return torch.where(quaternions[..., 0:1] < 0, -quaternions, quaternions)
+
+
+def _sqrt_positive_part(x: torch.Tensor) -> torch.Tensor:
+    """
+    Returns torch.sqrt(torch.max(0, x))
+    but with a zero subgradient where x is 0.
+    """
+    ret = torch.zeros_like(x)
+    positive_mask = x > 0
+    ret[positive_mask] = torch.sqrt(x[positive_mask])
+    return ret
+
+
+def matrix_to_quaternion(matrix: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as rotation matrices to quaternions.
+
+    Args:
+        matrix: Rotation matrices as tensor of shape (..., 3, 3).
+
+    Returns:
+        quaternions with real part first, as tensor of shape (..., 4).
+    """
+    if matrix.size(-1) != 3 or matrix.size(-2) != 3:
+        raise ValueError(f"Invalid rotation matrix shape {matrix.shape}.")
+
+    batch_dim = matrix.shape[:-2]
+    m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.unbind(
+        matrix.reshape(batch_dim + (9,)), dim=-1
+    )
+
+    q_abs = _sqrt_positive_part(
+        torch.stack(
+            [
+                1.0 + m00 + m11 + m22,
+                1.0 + m00 - m11 - m22,
+                1.0 - m00 + m11 - m22,
+                1.0 - m00 - m11 + m22,
+            ],
+            dim=-1,
+        )
+    )
+
+    # we produce the desired quaternion multiplied by each of r, i, j, k
+    quat_by_rijk = torch.stack(
+        [
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([q_abs[..., 0] ** 2, m21 - m12, m02 - m20, m10 - m01], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m21 - m12, q_abs[..., 1] ** 2, m10 + m01, m02 + m20], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m02 - m20, m10 + m01, q_abs[..., 2] ** 2, m12 + m21], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m10 - m01, m20 + m02, m21 + m12, q_abs[..., 3] ** 2], dim=-1),
+        ],
+        dim=-2,
+    )
+
+    # We floor here at 0.1 but the exact level is not important; if q_abs is small,
+    # the candidate won't be picked.
+    flr = torch.tensor(0.1).to(dtype=q_abs.dtype, device=q_abs.device)
+    quat_candidates = quat_by_rijk / (2.0 * q_abs[..., None].max(flr))
+
+    # if not for numerical problems, quat_candidates[i] should be same (up to a sign),
+    # forall i; we pick the best-conditioned one (with the largest denominator)
+    out = quat_candidates[
+        F.one_hot(q_abs.argmax(dim=-1), num_classes=4) > 0.5, :
+    ].reshape(batch_dim + (4,))
+    return standardize_quaternion(out)
+
+
+def quaternion_to_axis_angle(quaternions: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as quaternions to axis/angle.
+
+    Args:
+        quaternions: quaternions with real part first,
+            as tensor of shape (..., 4).
+
+    Returns:
+        Rotations given as a vector in axis angle form, as a tensor
+            of shape (..., 3), where the magnitude is the angle
+            turned anticlockwise in radians around the vector's
+            direction.
+    """
+    norms = torch.norm(quaternions[..., 1:], p=2, dim=-1, keepdim=True)
+    half_angles = torch.atan2(norms, quaternions[..., :1])
+    angles = 2 * half_angles
+    eps = 1e-6
+    small_angles = angles.abs() < eps
+    sin_half_angles_over_angles = torch.empty_like(angles)
+    sin_half_angles_over_angles[~small_angles] = (
+        torch.sin(half_angles[~small_angles]) / angles[~small_angles]
+    )
+    # for x small, sin(x/2) is about x/2 - (x/2)^3/6
+    # so sin(x/2)/x is about 1/2 - (x*x)/48
+    sin_half_angles_over_angles[small_angles] = (
+        0.5 - (angles[small_angles] * angles[small_angles]) / 48
+    )
+    return quaternions[..., 1:] / sin_half_angles_over_angles
+
+
+def matrix_to_axis_angle(matrix: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as rotation matrices to axis/angle.
+
+    Args:
+        matrix: Rotation matrices as tensor of shape (..., 3, 3).
+
+    Returns:
+        Rotations given as a vector in axis angle form, as a tensor
+            of shape (..., 3), where the magnitude is the angle
+            turned anticlockwise in radians around the vector's
+            direction.
+    """
+    return quaternion_to_axis_angle(matrix_to_quaternion(matrix))

HOT3DHUGGFACE/data_loaders/umetrack_layer.py

@@ -0,0 +1,229 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List
+
+import torch
+
+
+NUM_DIGITS: int = 5
+DOF_PER_FINGER: int = 4
+
+
+def _axis_angle_to_matrix(axis_angle: torch.Tensor) -> torch.Tensor:
+    theta = torch.norm(axis_angle, p=2, dim=-1)
+    axis = axis_angle / theta[..., None]
+
+    c = torch.cos(theta)
+    s = torch.sin(theta)
+    kx = axis[..., 0]
+    ky = axis[..., 1]
+    kz = axis[..., 2]
+    kxky = kx * ky
+    kxkz = kx * kz
+    kykz = ky * kz
+    kx2 = kx * kx
+    ky2 = ky * ky
+    kz2 = kz * kz
+
+    o = torch.stack(
+        (
+            c + kx2 * (1 - c),
+            kxky * (1 - c) - kz * s,
+            kxkz * (1 - c) + ky * s,
+            kxky * (1 - c) + kz * s,
+            c + ky2 * (1 - c),
+            kykz * (1 - c) - kx * s,
+            kxkz * (1 - c) - ky * s,
+            kykz * (1 - c) + kx * s,
+            c + kz2 * (1 - c),
+        ),
+        -1,
+    )
+
+    return o.reshape(*axis_angle.shape[:-1], 3, 3)
+
+
+def _finger_fk(
+    joint_local_xfs: torch.Tensor, parent_transform: torch.Tensor
+) -> List[torch.Tensor]:
+    """
+    each finger consists 4 DoF / Joints,
+    and returns 3 transformation frames
+    Input:
+        joint_local_xfs: (B, 4, 4)
+        parent_transform: (B, 4, 4)
+    Return:
+        transform_mats: (B, 3, 4, 4)
+    """
+    transform_mats = [parent_transform]
+    for i in range(4):
+        transform_mats.append(torch.matmul(transform_mats[-1], joint_local_xfs[:, i]))
+    return transform_mats[2:]
+
+
+def _joint_local_transform(
+    rotation_axis: torch.Tensor, rest_pose: torch.Tensor, joint_angles: torch.Tensor
+) -> torch.Tensor:
+    rotation_axis_flat = rotation_axis.reshape(-1, 3)
+    rest_pose_flat = rest_pose.reshape(-1, 3)
+    joint_angles_flat = joint_angles.reshape(-1)
+
+    angle_axis = rotation_axis_flat * joint_angles_flat.unsqueeze(-1)
+    local_transform = torch.eye(4, dtype=angle_axis.dtype, device=angle_axis.device)
+    local_transform = local_transform.unsqueeze(dim=0).repeat(angle_axis.shape[0], 1, 1)
+
+    rot_mat = _axis_angle_to_matrix(angle_axis)
+    translation = rest_pose_flat - torch.matmul(
+        rot_mat, rest_pose_flat.unsqueeze(dim=-1)
+    ).squeeze(dim=-1)
+    local_transform[:, :3, :3] = rot_mat
+    local_transform[:, 0:3, 3] = torch.squeeze(translation, dim=-1)
+
+    return local_transform.reshape(*rotation_axis.shape[0:-1], 4, 4)
+
+
+def _lbs(trans_mats: torch.Tensor, skinned_points: torch.Tensor) -> torch.Tensor:
+    """
+    Input:
+        trans_mats: (B, 17, 4, 4)
+        skinned_points: (B, V, 17, 4)
+    Return:
+        fk_points: (B, V, 4)
+    """
+    trans_mats = trans_mats.unsqueeze(dim=1)
+    skinned_points = skinned_points.unsqueeze(dim=-1)
+    fk_points = torch.matmul(trans_mats, skinned_points).sum(dim=2).squeeze(dim=-1)
+    return fk_points
+
+
+def get_skinning_weights(
+    bone_indices: torch.Tensor, bone_weights: torch.Tensor, n_frames: int
+) -> torch.Tensor:
+    """
+    Input:
+        bone_indices: (B, V, K)
+        bone_weights: (B, V, K)
+        n_frames: (or n_bones) Number of frames/bones (17 for hands)
+          Note: K is number of bones.
+    Return:
+        skin_mat: (B, V, n_frames)
+    """
+
+    bs = bone_indices.shape[0]
+    n_lms = bone_indices.shape[1]
+    # Offset all the bones linearly from 0 to (bs*n_lms*n_frames) so that we can directly
+    # index into the flattened weight matrix and set the corresponding skinning weights
+    flat_idx_offset = torch.arange(0, bs * n_lms, device=bone_indices.device) * n_frames
+    bone_flat_idx = bone_indices.long() + flat_idx_offset.reshape(bs, n_lms, 1)
+    skin_mat = torch.zeros(
+        bs * n_lms * n_frames, device=bone_weights.device, dtype=bone_weights.dtype
+    )
+    non0_w_mask = bone_weights != 0
+    non0_indices = bone_flat_idx[non0_w_mask]
+    skin_mat[non0_indices] = bone_weights[non0_w_mask]
+    skin_mat = skin_mat.reshape(bs, n_lms, n_frames)
+
+    return skin_mat
+
+
+def _hand_skinning_transform(
+    rotation_axis: torch.Tensor,
+    rest_poses: torch.Tensor,
+    joint_angles: torch.Tensor,
+    wrist_transforms: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Input:
+        rotation_axis: (B, 20, 3)
+        rest_poses: (B, 20, 3)
+        joint_angles: (B, 20)
+        wrist_transforms: (B, 4, 4)
+    Return:
+        skinning_matrices: (B, 17, 4, 4)
+    """
+    transform_mats = [wrist_transforms] * 2  # [root_transform, wrist_transforms]
+    d = DOF_PER_FINGER
+
+    joint_local_xfs = _joint_local_transform(
+        rotation_axis[:, 0:20], rest_poses[:, 0:20], joint_angles[:, 0:20]
+    )
+
+    for finger_idx in range(NUM_DIGITS):
+        transform_mats += _finger_fk(
+            joint_local_xfs[:, d * finger_idx : d * finger_idx + d], wrist_transforms
+        )
+    transform_mats = torch.cat([m.unsqueeze(1) for m in transform_mats], dim=1)
+    return transform_mats
+
+
+def _get_skinned_vertices(
+    vertices: torch.Tensor, weights: torch.Tensor
+) -> torch.Tensor:
+    """
+    Input:
+        vertices: (B, V, 3) or (B, V, 4)
+        weights: (B, V, 17)
+    Return:
+        skinned_vertices: (B, V, 17, 4)
+    """
+    if vertices.shape[2] == 3:
+        n_vertices = vertices.shape[1]
+        homo = torch.ones(
+            vertices.shape[0],
+            n_vertices,
+            1,
+            dtype=vertices.dtype,
+            device=vertices.device,
+        )
+        vertices = torch.cat([vertices, homo], dim=-1)
+
+    vertices = vertices.unsqueeze(dim=2)
+    weights = weights.unsqueeze(dim=-1)
+    return vertices * weights
+
+
+def skin_points(
+    joint_rest_positions: torch.Tensor,
+    joint_rotation_axes: torch.Tensor,
+    skin_mat: torch.Tensor,
+    joint_angles: torch.Tensor,
+    points: torch.Tensor,
+    wrist_transforms: torch.Tensor,
+) -> torch.Tensor:
+    leading_dims = joint_angles.shape[:-1]
+    assert joint_rest_positions.shape[:-2] == leading_dims, (
+        "Leading dimensions do not match, "
+        + f"got {leading_dims} and {joint_rest_positions.shape[:-2]}"
+    )
+
+    # This allows querying the product of leading dimensions without making the
+    # model specialized to a particular shape
+    numel = torch.flatten(joint_angles, end_dim=-2).shape[0] if len(leading_dims) else 1
+
+    batched_joint_rest_positions = joint_rest_positions.reshape(numel, -1, 3)
+
+    skin_xfs = _hand_skinning_transform(
+        rotation_axis=joint_rotation_axes.reshape(numel, -1, 3),
+        rest_poses=batched_joint_rest_positions,
+        joint_angles=joint_angles.reshape(numel, -1),
+        wrist_transforms=wrist_transforms.reshape(numel, 4, 4),
+    )
+
+    verts = _get_skinned_vertices(points.reshape(numel, -1, 3), skin_mat)
+    skinned_vecs = _lbs(skin_xfs, verts)[..., :3]
+    skinned_vecs = skinned_vecs.reshape(
+        list(leading_dims) + list(skinned_vecs.shape[-2:])
+    )
+    return skinned_vecs

HOT3DHUGGFACE/dataset/P0002_2f137f83/.download_status.json

@@ -0,0 +1,5 @@
+{
+    "main_vrs": true,
+    "ground_truth": true,
+    "hand_data": true
+}

HOT3DHUGGFACE/dataset/P0002_2f137f83/camera_models.json

@@ -0,0 +1,82 @@
+[
+    {
+        "T_Device_Camera": {
+            "quaternion_wxyz": [
+                -0.44995020258640295,
+                0.4002398518639525,
+                -0.5571697905977196,
+                0.5717645499833561
+            ],
+            "translation_xyz": [
+                0.02676488494873047,
+                -0.1293854675292969,
+                -0.03089171028137207
+            ]
+        },
+        "imageHeight": 1024,
+        "imageWidth": 1280,
+        "label": "camera-slam-left",
+        "maxSolidAngle": 1.8385352143167695,
+        "projectionModelType": "CameraModelType.FISHEYE624",
+        "projectionParams": [
+            504.5934753417969,
+            504.5934753417969,
+            638.3945922851562,
+            509.4228515625,
+            0.043982941657304764,
+            -0.0448598638176918,
+            0.01613209955394268,
+            -0.010928832925856113,
+            0.003512823488563299,
+            -0.0005242147017270327,
+            0.00047754947445355356,
+            -4.744782927446067e-05,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        "serialNumber": "21367848_11:mono10bit",
+        "stream_id": "1201-1"
+    },
+    {
+        "T_Device_Camera": {
+            "quaternion_wxyz": [
+                -0.43742901420997415,
+                0.40850468341688273,
+                -0.5546791775025043,
+                0.578023175312987
+            ],
+            "translation_xyz": [
+                0.023434097290039063,
+                -0.13131076049804688,
+                0.03267765808105469
+            ]
+        },
+        "imageHeight": 1024,
+        "imageWidth": 1280,
+        "label": "camera-slam-right",
+        "maxSolidAngle": 2.7418528142178835,
+        "projectionModelType": "CameraModelType.FISHEYE624",
+        "projectionParams": [
+            503.17462158203125,
+            503.17462158203125,
+            636.9581909179688,
+            511.8325500488281,
+            0.043429020792245865,
+            -0.046074334532022476,
+            0.02290933020412922,
+            -0.01852448284626007,
+            0.007009806111454964,
+            -0.001104349852539599,
+            -2.9515178539440967e-05,
+            0.000159201052156277,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+        ],
+        "serialNumber": "21366312_12:mono10bit",
+        "stream_id": "1201-2"
+    }
+]

HOT3DHUGGFACE/dataset/P0002_2f137f83/license.txt

@@ -0,0 +1,15 @@
+HOT3D Dataset License Agreement
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+Last updated May 29, 2024
+
+Before you access or use the HOT3D Dataset (the "Dataset") made available by Meta Platforms Technologies, LLC ("Meta") please read the following Dataset License Agreement (“Agreement”). By accessing or using the Dataset, you agree to be bound by this Agreement. If you don’t agree to be bound by this Agreement, do not use the Dataset.
+
+The dataset includes 3 data types, each governed by different license terms. You are responsible for complying with all license terms for the specific sequences, annotations, and models utilized by You.
+
+1. Sequence captured by Project Aria and Quest devices, and annotations (excluding hand annotations) ("Sequence data") is licensed under CC BY-SA (https://creativecommons.org/licenses/by-sa/4.0/).
+2. Hand annotations ("Hand data"”") is licensed under CC BY-NC-SA (https://creativecommons.org/licenses/by-nc-sa/4.0/). For example, the files under this license considered “Hand Data” includes but is not limited to: mano_hand_pose_trajectory.jsonl, umetrack_hand_pose_trajectory.jsonl, umetrack_hand_user_profile.json, box2d_hands.csv, mask_hand_pose_available.csv and mask_hand_visible.csv
+3. 3D object models ("Model data") are licensed under a CC BY-SA (https://creativecommons.org/licenses/by-sa/4.0/), with the modification that notwithstanding anything to the contrary, You shall not sell the Licensed Material, or incorporate the Licensed Material into a product to be sold, including for the avoidance of doubt objects or models contained in the Licensed Materials.
+
+The license terms are also visible in the readme of each corresponding download.

HOT3DHUGGFACE/dataset/P0002_2f137f83/metadata.json

@@ -0,0 +1,31 @@
+{
+    "have_hand_object_pose_gt": true,
+    "headset": "Quest3",
+    "object_bop_uids": [
+        "2",
+        "20",
+        "4",
+        "13",
+        "7",
+        "21"
+    ],
+    "object_names": [
+        "bowl",
+        "food_waffles",
+        "spoon_wooden",
+        "bottle_mustard",
+        "coffee_pot",
+        "food_vegetables"
+    ],
+    "object_uids": [
+        "194930206998778",
+        "253405647833885",
+        "225397651484143",
+        "261746112525368",
+        "228358276546933",
+        "96945373046044"
+    ],
+    "participant_id": "P0002",
+    "recording_name": "P0002_2f137f83",
+    "version": 4
+}

HOT3DHUGGFACE/dataset/P0002_2f137f83/recording.vrs

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2b7f1a1c7474b8287bda181279e9185c5bc3d701e27c11713be045e2c6f8d13
+size 1541144815

HOT3DHUGGFACE/dataset_api.py

@@ -0,0 +1,244 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from typing import Any, Dict, Optional
+
+import data_loaders.HandBox2dDataProvider as HandBox2dDataProvider
+import data_loaders.ObjectBox2dDataProvider as ObjectBox2dDataProvider
+from data_loaders.AriaDataProvider import AriaDataProvider
+from data_loaders.HeadsetPose3dProvider import (
+    HeadsetPose3dProvider,
+    load_headset_pose_provider_from_csv,
+)
+from data_loaders.headsets import Headset
+from data_loaders.io_utils import load_json
+from data_loaders.loader_object_library import ObjectLibrary
+from data_loaders.mano_layer import MANOHandModel
+from data_loaders.ManoHandDataProvider import MANOHandDataProvider
+from data_loaders.ObjectPose3dProvider import (
+    load_pose_provider_from_csv,
+    ObjectPose3dProvider,
+)
+from data_loaders.PathProvider import Hot3dDataPathProvider
+from data_loaders.QuestDataProvider import QuestDataProvider
+from data_loaders.UmeTrackHandDataProvider import UmeTrackHandDataProvider
+
+# 3D assets
+# - object_uid
+
+# 3D transform
+# Aria Device to Optitrack
+
+# Generic idea around the DataProvider is that is allow to initialize the data reading
+# and offer a generic interface to retrieve timestamp data by TYPE (Image, Object, Hand, etc.)
+
+
+class Hot3dDataProvider:
+    """
+    High Level interface to retrieve and use data from the hot3d dataset
+    """
+
+    def __init__(
+        self,
+        sequence_folder: str,
+        object_library: ObjectLibrary,
+        mano_hand_model: Optional[MANOHandModel] = None,
+        fail_on_missing_data: bool = True,
+    ) -> None:
+        """
+        INIT_DOC_STRING
+        """
+        # Will read all required metadata
+        # Hands
+        # Objects
+        # Device type, ...
+        self.path_provider = Hot3dDataPathProvider.fromRecordingFolder(
+            recording_instance_folderpath=sequence_folder
+        )
+        #根据path_provider检查是否所有文件存在
+        if not self.path_provider.is_valid():
+            missing_filepaths = [
+                filepath
+                for filepath in self.path_provider.required_filepaths
+                if not os.path.exists(filepath)
+            ]
+
+            if fail_on_missing_data:
+                raise RuntimeError(
+                    f"Invalid hot3d path. Not all expected data are present. missing_filepaths: {missing_filepaths}"
+                )
+            else:
+                print(
+                    f"Not all expected data are present. missing_filepaths: {missing_filepaths}"
+                )
+
+        self._dynamic_objects_provider = load_pose_provider_from_csv(
+            self.path_provider.dynamic_objects_filepath
+        )
+        #头显设备
+        self._device_pose_provider = load_headset_pose_provider_from_csv(
+            self.path_provider.headset_trajectory_filepath
+        )
+        #物体在图像上的 2D 边界框
+        self._object_box2d_provider = (
+            ObjectBox2dDataProvider.load_box2d_trajectory_from_csv(
+                self.path_provider.box2d_objects_filepath
+            )
+        )
+        #手在图像上的 2D 边界框，注意手是两个手，所以是一个list[0]是左手数据，list[1]是右手
+        self._hand_box2d_provider = (
+            HandBox2dDataProvider.load_box2d_trajectory_from_csv(
+                self.path_provider.box2d_hands_filepath
+            )
+        )
+
+        self._object_library: ObjectLibrary = object_library
+
+        self._mano_hand_data_provider = None
+        if os.path.isfile(self.path_provider.mano_hand_pose_trajectory_filepath):
+            if mano_hand_model is not None:
+                self._mano_hand_data_provider = MANOHandDataProvider(
+                    #mano_hand_pose_trajectory.jsonl：每一帧中每只手的“手腕位置 + 手腕朝向 + 手指姿态 + 手型”
+                    self.path_provider.mano_hand_pose_trajectory_filepath,
+                    mano_hand_model,
+                )
+            else:
+                print("No MANO hand model provided, skipping MANO hand data provider")
+        else:
+            print(
+                f"WARN: Cannot find {self.path_provider.mano_hand_pose_trajectory_filepath}"
+            )
+        
+        #umetrack_手部追踪系统，提供手部数据，但用的手模型不同
+        self._umetrack_hand_data_provider = None
+        if os.path.exists(
+            self.path_provider.umetrack_hand_pose_trajectory_filepath
+        ) and os.path.exists(self.path_provider.umetrack_hand_user_profile_filepath):
+            self._umetrack_hand_data_provider = UmeTrackHandDataProvider(
+                self.path_provider.umetrack_hand_pose_trajectory_filepath,
+                self.path_provider.umetrack_hand_user_profile_filepath,
+            )
+
+        if self.get_device_type() == Headset.Aria:
+            self._device_data_provider = AriaDataProvider(
+                self.path_provider.vrs_filepath,
+                self.path_provider.mps_folderpath,
+            )
+        elif self.get_device_type() == Headset.Quest3:
+            self._device_data_provider = QuestDataProvider(
+                #recording.vrs
+                self.path_provider.vrs_filepath,
+                #camera_models.json
+                self.path_provider.camera_models_filepath,
+            )
+        else:
+            raise RuntimeError(f"Unsupported device type {self.get_device_type()}")
+
+    def get_data_statistics(self) -> Dict[str, Any]:
+        statistics_dict = {}
+        statistics_dict["dynamic_objects"] = (
+            self._dynamic_objects_provider.get_data_statistics()
+        )
+
+        if self._mano_hand_data_provider is not None:
+            statistics_dict["mano_hand_poses"] = (
+                self._mano_hand_data_provider.get_data_statistics()
+            )
+
+        if self._umetrack_hand_data_provider is not None:
+            statistics_dict["umetrack_hand_poses"] = (
+                self._umetrack_hand_data_provider.get_data_statistics()
+            )
+
+        if self._object_box2d_provider is not None:
+            statistics_dict["object_box2ds"] = (
+                self.object_box2d_data_provider.get_data_statistics()
+            )
+
+        if self._hand_box2d_provider is not None:
+            statistics_dict["hand_box2ds"] = (
+                self.hand_box2d_data_provider.get_data_statistics()
+            )
+        return statistics_dict
+
+    @property
+    def object_library(self) -> ObjectLibrary:
+        """
+        Return the object library used for initializing the Hot3dDataProvider
+        """
+        return self._object_library
+
+    @property
+    def device_data_provider(self):
+        """
+        Return the device data provider (calibration and image stream data)
+        """
+        return self._device_data_provider
+
+    @property
+    def mano_hand_data_provider(self) -> Optional[MANOHandDataProvider]:
+        """
+        Return the Mano hand data provider
+        """
+        return self._mano_hand_data_provider
+
+    @property
+    def umetrack_hand_data_provider(self) -> Optional[UmeTrackHandDataProvider]:
+        """
+        Return the UmeTrack hand data provider
+        """
+        return self._umetrack_hand_data_provider
+
+    @property
+    def object_box2d_data_provider(self):
+        """
+        Return the object box2d data provider
+        """
+        return self._object_box2d_provider
+
+    @property
+    def hand_box2d_data_provider(self):
+        """
+        Return the hand box2d data provider
+        """
+        return self._hand_box2d_provider
+
+    @property
+    def object_pose_data_provider(self) -> Optional[ObjectPose3dProvider]:
+        """
+        Return the object pose provider
+        """
+        return self._dynamic_objects_provider
+
+    @property
+    def device_pose_data_provider(self) -> Optional[HeadsetPose3dProvider]:
+        """
+        Return the device pose provider
+        """
+        return self._device_pose_provider
+
+    def get_device_type(self) -> Headset:
+        """
+        Return the type of device used for recording (e.g. Quest3, Aria, etc.)
+        """
+        return Headset[self.get_sequence_metadata()["headset"]]
+
+    def get_sequence_metadata(self) -> Dict:
+        """
+        Return the metadata associated with the sequence
+        """
+        metadata_json = load_json(self.path_provider.scene_metadata_filepath)
+
+        return metadata_json