feat: separate lidarseg method

Signed-off-by: ktro2828 <kotaro.uetake@tier4.jp>

Author: ktro2828

docs/cli/t4viz.md

@@ -64,6 +64,16 @@ For options, run `t4viz pointcloud -h`.
 t4viz pointcloud <DATA_ROOT> [OPTIONS]
 ```
 
+### LiDAR Segmentation
+
+This command performs the same behavior with [`Tier4.render_lidarseg(...)`](../tutorials/render.md#rendering-lidar-segmentation).
+
+For options, run `t4viz lidarseg -h`.
+
+```shell
+t4viz lidarseg <DATA_ROOT> [OPTIONS]
+```
+
 ### Future Trajectories
 
 `scene` and `instance` commands support visualizing future trajectories for each object.

docs/tutorials/render.md

@@ -48,6 +48,22 @@ If you want to visualize annotation results, `Tier4` supports some rendering met
     ```
 <!-- prettier-ignore-end -->
 
+### LiDAR Segmentation
+
+```python
+>>> t4.render_lidarseg()
+```
+
+<!--![Render LiDAR Segmentation GIF](../assets/render_lidarseg.gif)-->
+
+<!-- prettier-ignore-start -->
+!!! NOTE
+    `render_lidarseg()` method requires `lidarseg` data as follows:
+
+    ```shell
+    ```
+<!-- prettier-ignore-end -->
+
 ### Save Recording
 
 You can save the rendering result as follows:
@@ -134,15 +150,31 @@ It allows you to render boxes by specifying elements of boxes directly:
 
 ```python
 from t4_devkit.dataclass import LidarPointCloud
+from t4_devkit.viewer import PointCloudColorMode
 # Point cloud channel name
 >>> lidar_channel = "LIDAR_TOP"
 # Load point cloud from file
 >>> pointcloud = LidarPointCloud.from_file(<PATH_TO_POINTCLOUD.pcd.bin>)
->>> viewer.render_pointcloud(seconds, lidar_channel, pointcloud)
+>>> color_mode = PointCloudColorMode.DISTANCE
+>>> viewer.render_pointcloud(seconds, lidar_channel, pointcloud, color_mode)
 ```
 
 ![Render Point Cloud](../assets/render_pointcloud.png)
 
+### Rendering LiDAR segmentation
+
+```python
+from t4_devkit.dataclass import SegmentationPointCloud
+from t4_devkit.viewer import PointCloudColorMode
+# Point cloud channel name
+>>> lidar_channel = "LIDAR_TOP"
+# Load point cloud and label from file
+>>> pointcloud = SegmentationPointCloud.from_file("<PATH_TO_POINTCLOUD.pcd.bin>", "<PATH_TO_LABEL.pcd.bin>")
+>>> viewer.render_lidarseg(seconds, lidar_channel, pointcloud)
+```
+
+<!--![Render LiDAR Segmentation](../assets/render_lidarseg.png)-->
+
 ### Rendering lanelet map
 
 ```python

t4_devkit/cli/visualize.py

@@ -120,6 +120,43 @@ def pointcloud(
     t4.render_pointcloud(ignore_distortion=ignore_distortion, save_dir=output)
 
 
+@cli.command("lidarseg", help="Visualize LiDAR segmentation pointcloud.")
+def lidarseg(
+    data_root: Annotated[str, typer.Argument(help="Root directory path to the dataset.")],
+    revision: Annotated[
+        str | None,
+        typer.Option(
+            ...,
+            "-rv",
+            "--revision",
+            help="Specify if you want to load the specific version.",
+        ),
+    ] = None,
+    ignore_distortion: Annotated[
+        bool,
+        typer.Option(
+            ...,
+            "-ig",
+            "--ignore-distortion",
+            help="Indicates whether to ignore camera distortion",
+        ),
+    ] = True,
+    output: Annotated[
+        str | None,
+        typer.Option(
+            ...,
+            "-o",
+            "--output",
+            help="Output directory to save recorded .rrd file.",
+        ),
+    ] = None,
+) -> None:
+    _create_dir(output)
+
+    t4 = Tier4(data_root, revision=revision, verbose=False)
+    t4.render_lidarseg(ignore_distortion=ignore_distortion, save_dir=output)
+
+
 def _create_dir(dir_path: str | None) -> None:
     """Create a directory with the specified path.
 

t4_devkit/helper/rendering.py

@@ -318,6 +318,53 @@ def render_pointcloud(
             ),
         )
 
+    def render_lidarseg(
+        self,
+        *,
+        max_time_seconds: float = np.inf,
+        ignore_distortion: bool = True,
+        save_dir: str | None = None,
+    ) -> None:
+        """Render lidar segmentation.
+
+        Args:
+            max_time_seconds (float, optional): Max time length to be rendered [s].
+            ignore_distortion (bool, optional): Whether to ignore distortion parameters.
+            save_dir (str | None, optional): Directory path to save the recording.
+                Viewer will be spawned if it is None, otherwise not.
+        """
+        if self._sample_data_to_lidarseg_filename is None:
+            return
+
+        app_id = f"lidarseg@{self._t4.dataset_id}"
+        viewer = self._init_viewer(app_id, render_ann=True, save_dir=save_dir)
+
+        self._render_map(viewer)
+
+        # search first lidar sample data token
+        first_lidar_token: str | None = None
+        for sensor in self._t4.sensor:
+            if sensor.modality != SensorModality.LIDAR:
+                continue
+            first_lidar_token = sensor.first_sd_token
+
+        if first_lidar_token is None:
+            raise ValueError("There is no 3D pointcloud data.")
+
+        first_lidar_sample_data: Sample = self._t4.get("sample_data", first_lidar_token)
+        max_timestamp_us = first_lidar_sample_data.timestamp + seconds2microseconds(
+            max_time_seconds
+        )
+
+        concurrent.futures.wait(
+            self._render_lidar_and_ego(
+                viewer=viewer,
+                first_lidar_tokens=[first_lidar_token],
+                max_timestamp_us=max_timestamp_us,
+                color_mode=PointCloudColorMode.SEGMENTATION,
+            )
+        )
+
     def _render_map(self, viewer: RerunViewer) -> None:
         lanelet_path = osp.join(self._t4.map_dir, "lanelet2_map.osm")
         viewer.render_map(lanelet_path)
@@ -342,6 +389,7 @@ def _render_lidar_and_ego(
         viewer: RerunViewer,
         first_lidar_tokens: list[str],
         max_timestamp_us: float,
+        *,
         color_mode: PointCloudColorMode = PointCloudColorMode.DISTANCE,
     ) -> list[Future]:
         def _render_single_lidar(first_lidar_token: str) -> None:
@@ -358,26 +406,34 @@ def _render_single_lidar(first_lidar_token: str) -> None:
                 viewer.render_ego(ego_pose=ego_pose)
 
                 # render segmentation pointcloud if available, otherwise render raw pointcloud
-                if (
-                    self._sample_data_to_lidarseg_filename
-                    and sample_data.token in self._sample_data_to_lidarseg_filename
-                ):
+                if color_mode == PointCloudColorMode.SEGMENTATION:
+                    if not (
+                        self._sample_data_to_lidarseg_filename
+                        and sample_data.token in self._sample_data_to_lidarseg_filename
+                    ):
+                        continue
+
                     label_filename = self._sample_data_to_lidarseg_filename[sample_data.token]
                     pointcloud = SegmentationPointCloud.from_file(
                         point_filepath=osp.join(self._t4.data_root, sample_data.filename),
                         label_filepath=osp.join(self._t4.data_root, label_filename),
                     )
+                    viewer.render_lidarseg(
+                        seconds=microseconds2seconds(sample_data.timestamp),
+                        channel=sample_data.channel,
+                        pointcloud=pointcloud,
+                    )
                 else:
                     pointcloud = LidarPointCloud.from_file(
                         osp.join(self._t4.data_root, sample_data.filename)
                     )
 
-                viewer.render_pointcloud(
-                    seconds=microseconds2seconds(sample_data.timestamp),
-                    channel=sample_data.channel,
-                    pointcloud=pointcloud,
-                    color_mode=color_mode,
-                )
+                    viewer.render_pointcloud(
+                        seconds=microseconds2seconds(sample_data.timestamp),
+                        channel=sample_data.channel,
+                        pointcloud=pointcloud,
+                        color_mode=color_mode,
+                    )
 
                 current_lidar_token = sample_data.next
 

t4_devkit/tier4.py

@@ -799,3 +799,23 @@ def render_pointcloud(
             ignore_distortion=ignore_distortion,
             save_dir=save_dir,
         )
+
+    def render_lidarseg(
+        self,
+        *,
+        max_time_seconds: float = np.inf,
+        ignore_distortion: bool = True,
+        save_dir: str | None = None,
+    ) -> None:
+        """Render lidarseg on 3D view.
+
+        Args:
+            max_time_seconds (float, optional): Max time length to be rendered [s].
+            ignore_distortion (bool, optional): Whether to ignore distortion parameters.
+            save_dir (str | None, optional): Directory path to save the recording.
+        """
+        self._rendering_helper.render_lidarseg(
+            max_time_seconds=max_time_seconds,
+            ignore_distortion=ignore_distortion,
+            save_dir=save_dir,
+        )

t4_devkit/viewer/color.py

@@ -20,6 +20,7 @@ class PointCloudColorMode(str, Enum):
 
     DISTANCE = "distance"
     INTENSITY = "intensity"
+    SEGMENTATION = "segmentation"
 
 
 def pointcloud_color(

t4_devkit/viewer/viewer.py

@@ -9,7 +9,6 @@
 
 from t4_devkit.common.converter import to_quaternion
 from t4_devkit.common.timestamp import microseconds2seconds
-from t4_devkit.dataclass import SegmentationPointCloud
 from t4_devkit.lanelet import LaneletParser
 from t4_devkit.schema import SensorModality
 
@@ -25,7 +24,7 @@
 from .record import BatchBox2D, BatchBox3D, BatchSegmentation2D
 
 if TYPE_CHECKING:
-    from t4_devkit.dataclass import Box2D, Box3D, Future, PointCloudLike
+    from t4_devkit.dataclass import Box2D, Box3D, Future, PointCloudLike, SegmentationPointCloud
     from t4_devkit.schema import CalibratedSensor, EgoPose, Sensor
     from t4_devkit.typing import (
         CameraIntrinsicLike,
@@ -427,17 +426,31 @@ def render_pointcloud(
         # TODO(ktro2828): add support of rendering pointcloud on images
         rr.set_time_seconds(self.config.timeline, seconds)
 
-        if isinstance(pointcloud, SegmentationPointCloud):
-            rr.log(
-                format_entity(self.config.ego_entity, channel),
-                rr.Points3D(pointcloud.points[:3].T, class_ids=pointcloud.labels),
-            )
-        else:
-            colors = pointcloud_color(pointcloud, color_mode=color_mode)
-            rr.log(
-                format_entity(self.config.ego_entity, channel),
-                rr.Points3D(pointcloud.points[:3].T, colors=colors),
-            )
+        colors = pointcloud_color(pointcloud, color_mode=color_mode)
+        rr.log(
+            format_entity(self.config.ego_entity, channel),
+            rr.Points3D(pointcloud.points[:3].T, colors=colors),
+        )
+
+    @_check_spatial3d
+    def render_lidarseg(
+        self,
+        seconds: float,
+        channel: str,
+        pointcloud: SegmentationPointCloud,
+    ) -> None:
+        """Render a LiDAR segmentation point cloud.
+
+        Args:
+            seconds (float): Timestamp in [sec].
+            channel (str): Name of the pointcloud sensor channel.
+            pointcloud (SegmentationPointCloud): Segmentation pointcloud.
+        """
+        rr.set_time_seconds(self.config.timeline, seconds)
+        rr.log(
+            format_entity(self.config.ego_entity, channel),
+            rr.Points3D(pointcloud.points[:3].T, class_ids=pointcloud.labels),
+        )
 
     @_check_spatial2d
     def render_image(self, seconds: float, camera: str, image: str | NDArrayU8) -> None: