HOT3DHUGGFACE/Segmentation.py

#Written by Zhonghao Zhang (FKZZddd): 
# This script was copied and adapted from the original script provided by Meta for HOT3D dataset. 
# The original script can be found at HOT3D/hot3d/hot3d/render_3d.py in the HOT3D repository.

# Used for segmentation of hand meshes, 
# setup_hand_at_timestamp is the main function that segments hands and adds hand meshes to the scene
# This script was tested on BOTH Aria and Quest3. By modifying sequence_folder="./dataset/P0002_2f137f83". The script can detect the device type and load the corresponding data for rendering.
#
# Code Sample
#
# Installation:
# - pip install pyrender trimesh
#
# Details:
# Demonstrate how to use PyRender to render HOT3D meshes (objects, hands) for a given timestamp & stream_id
# - As OpenGL rendering is rectilinear, color, segmentation and depth buffer are also rectilinear rendering
# - We then show how to map the rectilinear image back to the original fisheye image (but do not we are loosing some field of view)

from typing import Dict, List, Optional, Tuple

import numpy as np

try:
    import trimesh
    from pyrender import (
        IntrinsicsCamera,
        Mesh,
        Node,
        OffscreenRenderer,
        RenderFlags,
        Scene,
    )
except ImportError:
    print("trimesh or pyrender modules are missing. Please install them.")

from data_loaders.HandDataProviderBase import HandDataProviderBase
from data_loaders.headsets import Headset
from data_loaders.loader_object_library import load_object_library, ObjectLibrary
from dataset_api import Hot3dDataProvider
from PIL import Image
from projectaria_tools.core.calibration import (
    CameraCalibration,
    distort_by_calibration,
    FISHEYE624,
    LINEAR,
)
from projectaria_tools.core.sensor_data import TimeDomain, TimeQueryOptions
from projectaria_tools.core.sophus import SE3
from projectaria_tools.core.stream_id import StreamId
from tqdm import tqdm

# Matrix transform to change Aria camera pose to PyRender coordinate system
# PyRender: +Z = back, +Y = up, +X = right
# Aria: +Z = forward, +Y = down, +X = right
T_ARIA_OPENGL = SE3.from_matrix(
    np.array(
        [
            [1.0, 0.0, 0.0, 0.0],
            [0.0, -1.0, 0.0, 0.0],
            [0.0, 0.0, -1.0, 0.0],
            [0.0, 0.0, 0.0, 1.0],
        ]
    )
)

ACCEPTABLE_TIME_DELTA = 0  # To retrieve exact GT


def load_meshes_scene(
    hot3d_data_provider: Hot3dDataProvider,
) -> Dict[str, Mesh]:
    """
    Load all meshes in the scene and hash them by object_uid
    """

    object_library = hot3d_data_provider.object_library
    object_library_folderpath = object_library.asset_folder_name

    object_pose_data_provider = hot3d_data_provider.object_pose_data_provider
    object_uids = object_pose_data_provider.object_uids_with_poses

    #
    # Load all meshes in the scene and store them in a dict
    #
    meshes: Dict[str, Mesh] = {}
    for object_uid in tqdm(object_uids):
        object_cad_asset_filepath = ObjectLibrary.get_cad_asset_path(
            object_library_folderpath=object_library_folderpath,
            object_id=object_uid,
        )
        # Load the mesh, merge its component
        scene = trimesh.load_mesh(
            object_cad_asset_filepath,
            process=True,
            merge_primitives=True,
            file_type="glb",
        )
        # Represent the scene by a single mesh
        glb_mesh = scene.to_mesh()
        # Store the resulting mesh in the dict
        meshes[object_uid] = Mesh.from_trimesh(glb_mesh)

    return meshes


def setup_objects_at_timestamp(
    scene: Scene,
    meshes: Dict[str, Mesh],
    hot3d_data_provider: Hot3dDataProvider,
    timestamp_ns: int,
) -> Dict[str, Node]:
    """
    Setup object meshes in the scene for the specified timestamp
    """

    object_pose_data_provider = hot3d_data_provider.object_pose_data_provider

    pyrender_node_meshes = {}
    object_poses_with_dt = None
    if object_pose_data_provider is not None:
        object_poses_with_dt = 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,
        )
        if object_poses_with_dt is not None:
            objects_pose3d_collection = object_poses_with_dt.pose3d_collection
            for (
                object_uid,
                object_pose3d,
            ) in objects_pose3d_collection.poses.items():
                transform = object_pose3d.T_world_object.to_matrix()
                pyrender_node_meshes[object_uid] = scene.add(
                    meshes[object_uid], pose=transform
                )

    return pyrender_node_meshes


def get_camera_calibration(
    hot3d_data_provider: Hot3dDataProvider,
    timestamp_ns: int,
    stream_id: StreamId,
    camera_model=LINEAR,
) -> Optional[Tuple[SE3, CameraCalibration]]:
    """
    Return the camera calibration
    """
    device_data_provider = hot3d_data_provider.device_data_provider
    if hot3d_data_provider.get_device_type() is Headset.Aria:
        return device_data_provider.get_online_camera_calibration(
            stream_id=stream_id,
            timestamp_ns=timestamp_ns,
            camera_model=camera_model,
        )
    elif hot3d_data_provider.get_device_type() is Headset.Quest3:
        return device_data_provider.get_camera_calibration(
            stream_id=stream_id,
            camera_model=camera_model,
        )
    else:
        return None


def setup_camera_at_timestamp(
    scene: Scene,
    hot3d_data_provider: Hot3dDataProvider,
    timestamp_ns: int,
    stream_id: StreamId,
) -> Tuple[Node, List[int]]:
    """
    Setup a rectilinear camera for the specified stream_id and timestamp
    """

    device_data_provider = hot3d_data_provider.device_data_provider
    device_pose_provider = hot3d_data_provider.device_pose_data_provider

    [T_device_camera, intrinsics] = get_camera_calibration(
        hot3d_data_provider=hot3d_data_provider,
        stream_id=stream_id,
        timestamp_ns=timestamp_ns,
        camera_model=LINEAR,
    )

    headset_pose3d_with_dt = None
    if device_data_provider is not None:
        headset_pose3d_with_dt = 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,
        )
        if headset_pose3d_with_dt is not None:
            headset_pose3d = headset_pose3d_with_dt.pose3d
            focal_lengths = intrinsics.get_focal_lengths()
            principal_point = intrinsics.get_principal_point()
            camera = IntrinsicsCamera(
                focal_lengths[0],
                focal_lengths[0],
                principal_point[0],
                principal_point[1],
                znear=0.05,
                zfar=100.0,
                name=None,
            )

            camera_pose = (
                (headset_pose3d.T_world_device @ T_device_camera) @ T_ARIA_OPENGL
            ).to_matrix()

            camera_node = scene.add(camera, pose=camera_pose)
    return [camera_node, intrinsics.get_image_size().tolist()]


def setup_hand_at_timestamp(
    scene: Scene,
    hot3d_data_provider: Hot3dDataProvider,
    timestamp_ns: int,
    hand_data_provider: HandDataProviderBase,
) -> Dict[str, Mesh]:
    """
    Add hand meshes to the scene for the specified timestamp
    """

    pyrender_node_meshes = {}

    if hand_data_provider is None:
        return []

    hand_poses_with_dt = 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,
    )
    if hand_poses_with_dt is not None:
        hand_pose_collection = hand_poses_with_dt.pose3d_collection

        for hand_pose_data in hand_pose_collection.poses.values():
            handedness_label = hand_pose_data.handedness_label()

            hand_mesh_vertices = hand_data_provider.get_hand_mesh_vertices(
                hand_pose_data
            )

            [hand_triangles, hand_vertex_normals] = (
                hand_data_provider.get_hand_mesh_faces_and_normals(hand_pose_data)
            )

            pyrender_node_meshes[handedness_label] = scene.add(
                Mesh.from_trimesh(
                    trimesh.Trimesh(
                        vertices=hand_mesh_vertices,
                        normals=hand_vertex_normals,
                        faces=hand_triangles,
                    )
                )
            )
    return pyrender_node_meshes


def offscreen_render(
    scene: Scene,
    resolution: List[int],  # [width, height]
) -> Tuple[np.ndarray, np.ndarray]:
    """
    Return COLOR and DEPTH images
    """
    renderer = OffscreenRenderer(resolution[0], resolution[1])
    color, depth = renderer.render(scene)  # , flags=RenderFlags.RGBA)

    nm = {
        node: 20 * (i + 1) for i, node in enumerate(scene.mesh_nodes)
    }  # Node->Seg Id map
    seg = renderer.render(scene, RenderFlags.SEG, nm)[0]

    renderer.delete()
    return [color, depth, seg]


def distort_rendering(
    image: np.ndarray,
    hot3d_data_provider: Hot3dDataProvider,
    timestamp_ns: int,
    stream_id: StreamId,
) -> np.ndarray:
    """
    Map a rectilinear image to the native Fisheye camera model.
    - Do notice that we are loosing some field of view.
    """

    # Retrieve the camera model we want to distort to
    [T_device_camera, intrinsics_raw] = get_camera_calibration(
        hot3d_data_provider=hot3d_data_provider,
        stream_id=stream_id,
        timestamp_ns=timestamp_ns,
        camera_model=FISHEYE624,
    )

    # Retrieve the camera model we used for rendering
    [T_device_camera, intrinsics_linear] = get_camera_calibration(
        hot3d_data_provider=hot3d_data_provider,
        stream_id=stream_id,
        timestamp_ns=timestamp_ns,
        camera_model=LINEAR,
    )

    re_distorted_image = distort_by_calibration(
        image,
        intrinsics_raw,
        intrinsics_linear,
    )

    return re_distorted_image



#The main function 
#Set object_library=None because object meshes are unnecessary for project.
hot3d_data_provider = Hot3dDataProvider(
    # sequence_folder="./data_loaders/tests/data_sample/Aria/P0003_c701bd11",
    sequence_folder="./dataset/P0002_2f137f83",
    object_library=None,
)
print(f"data_provider statistics: {hot3d_data_provider.get_data_statistics()}")

scene_meshes = {}

# Define timestamps and stream ids that need rendering
# Default attempts all stream ids and a timestamp in the middle of the sequence

#total timestamps/2
timestamps = hot3d_data_provider.device_data_provider.get_sequence_timestamps()
timestamp_list = [timestamps[len(timestamps) // 2]]
stream_id_list = (
    [StreamId("1201-1"), StreamId("1201-2"), StreamId("214-1")]
    if hot3d_data_provider.get_device_type() is Headset.Aria
    else [StreamId("1201-1"), StreamId("1201-2")]
)

# Main rendering loop
print(f"Rendering for: {stream_id_list}")
for stream_id in stream_id_list:
    for timestamp_ns in timestamp_list:
        # Initialize the scene
        scene = Scene(ambient_light=np.array([1.0, 1.0, 1.0, 1.0]))

        # Add hands into scene, the main function that do segmentation
        setup_hand_at_timestamp(
            scene=scene,
            hot3d_data_provider=hot3d_data_provider,
            timestamp_ns=timestamp_ns,
            hand_data_provider=hot3d_data_provider.umetrack_hand_data_provider,
        )

        # Setup camera rendering (for the specific stream_id and timestamp)
        camera_node_and_resolution = setup_camera_at_timestamp(
            scene=scene,
            hot3d_data_provider=hot3d_data_provider,
            timestamp_ns=timestamp_ns,
            stream_id=stream_id,
        )

        print(camera_node_and_resolution)
        # Setup off screen rendering (to save rendering buffer to disk as image)
        [color, depth, seg] = offscreen_render(scene, camera_node_and_resolution[1])

        camera_node_and_resolution = setup_camera_at_timestamp(
            scene=scene,
            hot3d_data_provider=hot3d_data_provider,
            timestamp_ns=timestamp_ns,
            stream_id=stream_id,
        )
        
        im = Image.fromarray(color)
        im.save(f"render_native_{stream_id}_{timestamp_ns}.png")

        # im = Image.fromarray(distorted_seg)
        im = Image.fromarray(seg)
        im.save(f"seg_ref_{stream_id}_{timestamp_ns}.png")

        # Save "depth" buffer
        # im = Image.fromarray(depth)
        # im.save(f"depth_ref_{stream_id}_{timestamp_ns}.tiff")

        image_data_raw = hot3d_data_provider.device_data_provider.get_image(
            timestamp_ns, stream_id
        )
        if image_data_raw is not None:
            im = Image.fromarray(image_data_raw)
            im.save(f"image_ref_{stream_id}_{timestamp_ns}.png")