tier4 · KSeangTan · Jun 22, 2026 · Jan 14, 2026 · Jan 14, 2026 · Jan 20, 2026
diff --git a/Dockerfile b/Dockerfile
@@ -61,7 +61,7 @@ RUN python3 -m pip --no-cache-dir install \
 RUN python3 -m pip install git+https://github.com/tier4/t4-devkit@v0.5.1
 
 # Install autoware-perception-evaluation
-RUN python3 -m pip install git+https://github.com/tier4/autoware_perception_evaluation@f67600293e3e74861f913da3efafd6bf436d2ab6
+RUN python3 -m pip install git+https://github.com/tier4/autoware_perception_evaluation@85b78e52bca312911ea6730163dfeaa63c66c628
 
 # Need to dowgrade setuptools to 60.2.0 to fix setup
 RUN python3 -m pip --no-cache-dir install \

@@ -29,6 +29,9 @@
     "db_j6gen2_v7",
     "db_j6gen2_v8",
     "db_j6gen2_v9",
+    "db_j6gen2_v10",
+    "db_j6gen2_v11",
+    "db_j6gen2_v12",
     "db_largebus_v1",
     "db_largebus_v2",
     "db_largebus_v3",
@@ -146,6 +149,8 @@
     "traffic_cone": "traffic_cone",
     "trafficcone": "traffic_cone",
     "barrier": "barrier",
+    "other_vehicle": "car",
+    "other_pedestrian": "pedestrian",
 }
 
 class_names = ["car", "truck", "bus", "bicycle", "pedestrian", "traffic_cone", "barrier"]

@@ -27,6 +27,9 @@
     "db_j6gen2_v7",
     "db_j6gen2_v8",
     "db_j6gen2_v9",
+    "db_j6gen2_v10",
+    "db_j6gen2_v11",
+    "db_j6gen2_v12",
 ]
 
 dataset_test_groups = {
@@ -127,6 +130,8 @@
     "traffic_cone": "traffic_cone",
     "trafficcone": "traffic_cone",
     "barrier": "barrier",
+    "other_vehicle": "car",
+    "other_pedestrian": "pedestrian",
 }
 
 class_names = [

@@ -27,6 +27,9 @@
     "db_j6gen2_v7",
     "db_j6gen2_v8",
     "db_j6gen2_v9",
+    "db_j6gen2_v10",
+    "db_j6gen2_v11",
+    "db_j6gen2_v12",
     "db_largebus_v1",
     "db_largebus_v2",
     "db_largebus_v3",
@@ -133,6 +136,8 @@
     "traffic_cone": "traffic_cone",
     "trafficcone": "traffic_cone",
     "barrier": "barrier",
+    "other_vehicle": "car",
+    "other_pedestrian": "pedestrian",
 }
 
 

@@ -123,6 +123,8 @@
     "traffic_cone": "traffic_cone",
     "trafficcone": "traffic_cone",
     "barrier": "barrier",
+    "other_vehicle": "car",
+    "other_pedestrian": "pedestrian",
 }
 
 class_names = [

@@ -120,6 +120,8 @@
     "traffic_cone": "traffic_cone",
     "trafficcone": "traffic_cone",
     "barrier": "barrier",
+    "other_vehicle": "car",
+    "other_pedestrian": "pedestrian",
 }
 
 class_names = [

@@ -122,6 +122,8 @@
     "traffic_cone": "traffic_cone",
     "trafficcone": "traffic_cone",
     "barrier": "barrier",
+    "other_vehicle": "car",
+    "other_pedestrian": "pedestrian",
 }
 
 class_names = [

@@ -1,3 +1,4 @@
+from .local_3d_bbox import Local3DBBoxExpand
 from .object_min_points_filter import ObjectMinPointsFilter
 
-__all__ = ["ObjectMinPointsFilter"]
+__all__ = ["ObjectMinPointsFilter", "Local3DBBoxExpand"]
@@ -0,0 +1,58 @@
+from typing import List
+
+import numpy as np
+from mmcv.transforms import BaseTransform
+from mmdet3d.structures.ops import box_np_ops
+from mmengine.registry import TRANSFORMS
+
+
+@TRANSFORMS.register_module()
+class Local3DBBoxExpand(BaseTransform):
+    """Locally expand the 3D bounding boxes by scaling the width, which it doesn't scale the points.
+
+    Args:
+        expand_widths: (List[float]): Uniformly sampled expand width.
+        width_dim: (int): The dimension of the width. Default is 4, which is the width dimension of the 3D
+                  bounding box. Since 3D Bbox is in the format of [x, y, z, dx, dy, dz, heading], the width dimension is the
+                    4th dimension.
+            label_ids: (List[int]): The label IDs to expand. If None, all label IDs will be expanded.
+    """
+
+    def __init__(self, expand_widths: List[float], width_dim: int = 4, label_ids: List[int] = None) -> None:
+        assert isinstance(expand_widths, list)
+        assert len(expand_widths) == 2
+        assert expand_widths[0] < expand_widths[1]
+        self.expand_widths = expand_widths
+        self.width_dim = width_dim
+        self.label_ids = label_ids
+
+    def transform(self, input_dict: dict) -> dict:
+        """Call function to locally augment the 3D bounding boxes by scaling the width.
+
+        Args:
+            input_dict (dict): Result dict from loading pipeline.
+
+        Returns:
+            dict: Results after locally augmenting the 3D bounding boxes by scaling the width, 'gt_bboxes_3d' \
+                key is updated in the result dict.
+        """
+        # Label mask
+        if self.label_ids is not None:
+            label_masks = [True if label in self.label_ids else False for label in input_dict["gt_labels_3d"]]
+        else:
+            label_masks = np.ones(len(input_dict["gt_labels_3d"]), dtype=bool)
+
+        for i in range(len(input_dict["gt_bboxes_3d"])):
+            if not label_masks[i]:
+                continue
+
+            expand_width = np.random.uniform(self.expand_widths[0], self.expand_widths[1])
+            input_dict["gt_bboxes_3d"].tensor[i, self.width_dim] += expand_width
+
+        return input_dict
+
+    def __repr__(self) -> str:
+        """str: Return a string that describes the module."""
+        repr_str = self.__class__.__name__
+        repr_str += f"(expand_widths={self.expand_widths}, width_dim={self.width_dim}, label_ids={self.label_ids})"
+        return repr_str
@@ -34,6 +34,7 @@ def transform(self, input_dict: dict) -> dict:
         indices = box_np_ops.points_in_rbbox(
             points.tensor.numpy()[:, :3],
             gt_bboxes_3d.tensor.numpy()[:, :7],
+            origin=(0.5, 0.5, 0.0),  # Always assume it's center_x, center_y and bottom_z
         )
         num_points_in_gt = indices.sum(0)
         gt_bboxes_mask = num_points_in_gt >= self.min_num_points
@@ -107,6 +108,7 @@ def transform(self, input_dict: dict) -> dict:
         indices = box_np_ops.points_in_rbbox(
             points.tensor.numpy()[:, :3],
             gt_bboxes_3d.tensor.numpy()[:, :7],
+            origin=(0.5, 0.5, 0.0),  # Always assume it's center_x, center_y and bottom_z
         )
 
         num_points_in_gt = indices.sum(0)

@@ -11,6 +11,7 @@
 import torch
 from mmdet3d.registry import METRICS
 from mmdet3d.structures import LiDARInstance3DBoxes
+from mmdet3d.structures.ops import box_np_ops
 from mmengine.dist import get_world_size
 from mmengine.evaluator import BaseMetric
 from mmengine.logging import MessageHub, MMLogger
@@ -243,6 +244,7 @@ def __init__(
         experiment_name: str,
         experiment_group_name: str,
         write_metric_summary: bool,
+        min_num_points: int = 0,
         evaluate_frame_prefix: bool = True,
         checkpoint_path: Optional[Union[Path, str]] = None,
         scene_batch_size: int = 128,
@@ -268,6 +270,7 @@ def __init__(
         self.experiment_name = experiment_name
         self.experiment_group_name = experiment_group_name
         self.name_mapping = name_mapping
+        self.min_num_points = min_num_points
         if name_mapping is not None:
             self.class_names = [self.name_mapping.get(name, name) for name in self.class_names]
 
@@ -435,10 +438,11 @@ def process(self, data_batch: dict, data_samples: Sequence[dict]) -> None:
             # Skip processing if result pickle already exists
             return
 
-        for data_sample in data_samples:
+        batch_points = data_batch["inputs"]["points"]
+        for data_sample, points in zip(data_samples, batch_points):
             current_time = data_sample["timestamp"]
             scene_id = self._parse_scene_id(data_sample["lidar_path"])
-            frame_ground_truth = self._parse_ground_truth_from_sample(current_time, data_sample)
+            frame_ground_truth = self._parse_ground_truth_from_sample(current_time, data_sample, points)
             perception_frame = self._parse_predictions_from_sample(current_time, data_sample, frame_ground_truth)
             self._save_perception_frame(scene_id, data_sample["sample_idx"], perception_frame)
 
@@ -985,11 +989,27 @@ def _aggregate_metrics_data(
 
                     # Create precision_interpolate and recall_interpolate keys
                     iterable_metrics[
-                        f"T4MetricV2_label_detection/{label_name}_precisions_{matching_mode}_{threshold}"
+                        f"T4MetricV2_label_detection/{label_name}_interp-precisions_{matching_mode}_{threshold}"
                     ] = ap.precision_interp.tolist()
                     iterable_metrics[
-                        f"T4MetricV2_label_detection/{label_name}_recalls_{matching_mode}_{threshold}"
+                        f"T4MetricV2_label_detection/{label_name}_interp-recalls_{matching_mode}_{threshold}"
                     ] = ap.recall_interp.tolist()
+                    iterable_metrics[
+                        f"T4MetricV2_label_detection/{label_name}_interp-confs_{matching_mode}_{threshold}"
+                    ] = ap.conf_interp.tolist()
+
+                    # TP error metrics (e.g. ATE, AOE, ASE, AVE, AAE)
+                    if ap.tp_error_metrics is not None:
+                        for tp_error_metric in ap.tp_error_metrics:
+                            mode = tp_error_metric.mode
+                            average_mode = tp_error_metric.average_mode
+
+                            iterable_metrics[
+                                f"T4MetricV2_label_detection/{label_name}_{mode}_values_{matching_mode}_{threshold}"
+                            ] = tp_error_metric.values.tolist()
+                            iterable_metrics[
+                                f"T4MetricV2_label_detection/{label_name}_{mode}_interp-values_{matching_mode}_{threshold}"
+                            ] = tp_error_metric.interpolated_values.tolist()
 
         return iterable_metrics
 
@@ -1044,6 +1064,40 @@ def _process_metrics_for_aggregation(self, metrics_score: MetricsScore, evaluato
                         ap.optimal_precision
                     )
 
+                    # Number of prediction matches (TPs) and matches at the optimal confidence threshold
+                    metric_dict[f"T4MetricV2_label/{label_name}_num-match_{matching_mode}_{threshold}"] = ap.num_tp
+                    metric_dict[f"T4MetricV2_label/{label_name}_min-recall-num-match_{matching_mode}_{threshold}"] = (
+                        ap.num_tp_at_min_recall_conf
+                    )
+                    metric_dict[
+                        f"T4MetricV2_label/{label_name}_medium-recall-num-match_{matching_mode}_{threshold}"
+                    ] = ap.num_tp_at_medium_recall_conf
+                    metric_dict[f"T4MetricV2_label/{label_name}_optimal-num-match_{matching_mode}_{threshold}"] = (
+                        ap.num_tp_at_optimal_conf
+                    )
+
+                    # TP error metrics (e.g. ATE, AOE, ASE, AVE, AAE)
+                    if ap.tp_error_metrics is not None:
+                        for tp_error_metric in ap.tp_error_metrics:
+                            mode = tp_error_metric.mode
+                            average_mode = tp_error_metric.average_mode
+
+                            metric_dict[
+                                f"T4MetricV2_label/{label_name}_tp-error_{average_mode}_{matching_mode}_{threshold}"
+                            ] = tp_error_metric.avg_metric
+                            metric_dict[
+                                f"T4MetricV2_label/{label_name}_tp-error-min-recall-conf_{average_mode}_{matching_mode}_{threshold}"
+                            ] = tp_error_metric.min_recall_conf
+                            metric_dict[
+                                f"T4MetricV2_label/{label_name}_tp-error-optimal-{average_mode}_{matching_mode}_{threshold}"
+                            ] = tp_error_metric.optimal_avg_metric
+                            metric_dict[
+                                f"T4MetricV2_label/{label_name}_tp-error-medium-{average_mode}_{matching_mode}_{threshold}"
+                            ] = tp_error_metric.medium_avg_metric
+                            metric_dict[
+                                f"T4MetricV2_label/{label_name}_tp-error-medium-recall-conf-{average_mode}_{matching_mode}_{threshold}"
+                            ] = tp_error_metric.medium_recall_conf
+
                 # Label metadata key
                 metric_dict[f"metadata_label/test_{label_name}_num_predictions"] = label_num_preds
                 metric_dict[f"metadata_label/test_{label_name}_num_ground_truths"] = label_num_gts
@@ -1054,6 +1108,41 @@ def _process_metrics_for_aggregation(self, metrics_score: MetricsScore, evaluato
             metric_dict[map_key] = map_instance.map
             metric_dict[maph_key] = map_instance.maph
 
+            # Add mean TP errors (e.g. mATE, mAOE, mASE, mAVE, mAAE)
+            if map_instance.mean_tp_errors is not None:
+                for mean_tp_error_name, mean_tp_error_value in map_instance.mean_tp_errors.items():
+                    metric_dict[f"T4MetricV2/mean-tp-error_{mean_tp_error_name}_{matching_mode}"] = mean_tp_error_value
+
+                    optimal_mean_tp_errors = map_instance.optimal_mean_tp_errors.get(mean_tp_error_name, None)
+                    if optimal_mean_tp_errors is not None:
+                        metric_dict[f"T4MetricV2/mean-tp-error-optimal-{mean_tp_error_name}_{matching_mode}"] = (
+                            optimal_mean_tp_errors
+                        )
+
+                    medium_mean_tp_errors = map_instance.medium_mean_tp_errors.get(mean_tp_error_name, None)
+                    if medium_mean_tp_errors is not None:
+                        metric_dict[f"T4MetricV2/mean-tp-error-medium-{mean_tp_error_name}_{matching_mode}"] = (
+                            medium_mean_tp_errors
+                        )
+
+            # Add NuScenes Detection Score (NDS) based on mAP and mAPH
+            if map_instance.map_based_nds is not None:
+                metric_dict[f"T4MetricV2/{map_instance.map_based_nds.metric_prefix_name}_nds_{matching_mode}"] = (
+                    map_instance.map_based_nds.nds
+                )
+            if map_instance.medium_map_based_nds is not None:
+                metric_dict[
+                    f"T4MetricV2/{map_instance.medium_map_based_nds.metric_prefix_name}_nds_{matching_mode}"
+                ] = map_instance.medium_map_based_nds.nds
+            if map_instance.mapH_based_nds is not None:
+                metric_dict[f"T4MetricV2/{map_instance.mapH_based_nds.metric_prefix_name}_nds_{matching_mode}"] = (
+                    map_instance.mapH_based_nds.nds
+                )
+            if map_instance.medium_mapH_based_nds is not None:
+                metric_dict[
+                    f"T4MetricV2/{map_instance.medium_mapH_based_nds.metric_prefix_name}_nds_{matching_mode}"
+                ] = map_instance.medium_mapH_based_nds.nds
+
             total_num_preds = num_preds
 
         # Selected evaluator
@@ -1295,7 +1384,7 @@ def _parse_scene_id(self, lidar_path: str) -> str:
         except ValueError:
             return _UNKNOWN
 
-    def _parse_ground_truth_from_sample(self, time: float, data_sample: Dict[str, Any]) -> FrameGroundTruth:
+    def _parse_ground_truth_from_sample(self, time: float, data_sample: Dict[str, Any], points) -> FrameGroundTruth:
         """Parses ground truth objects from the given data sample.
 
         Args:
@@ -1325,6 +1414,15 @@ def _parse_ground_truth_from_sample(self, time: float, data_sample: Dict[str, An
         # num_lidar_pts: (N,) array of int, number of LiDAR points inside each GT box
         num_lidar_pts: np.ndarray = eval_info.get("num_lidar_pts", np.array([]))
 
+        if self.min_num_points > 0 and len(bboxes):
+            points_cpu = points.cpu().numpy()
+            indices = box_np_ops.points_in_rbbox(points_cpu[:, :3], bboxes[:, :7])
+            num_points_in_gt = indices.sum(0)
+            bboxes_mask = num_points_in_gt >= self.min_num_points
+            bboxes = bboxes[bboxes_mask]
+            gt_labels_3d = gt_labels_3d[bboxes_mask]
+            num_lidar_pts = num_lidar_pts[bboxes_mask]
+
         dynamic_objects = [
             DynamicObject(
                 unix_time=time,

@@ -1,6 +1,7 @@
 from .bevfusion import BEVFusion
 from .bevfusion_head import BEVFusionHead, ConvFuser
 from .bevfusion_necks import GeneralizedLSSFPN
+from .bevfusion_voxel_encoder import HardSimpleVoxelSinCosEncoder
 from .depth_lss import DepthLSSTransform, LSSTransform
 from .loading import BEVLoadMultiViewImageFromFiles
 from .sparse_encoder import BEVFusionSparseEncoder
@@ -27,4 +28,5 @@
     "BEVFusionRandomFlip3D",
     "BEVFusionGlobalRotScaleTrans",
     "TransFusionBBoxCoder",
+    "HardSimpleVoxelSinCosEncoder",
 ]