@@ -4,6 +4,7 @@ project(autoware_euclidean_cluster)
 find_package(autoware_cmake REQUIRED)
 autoware_package()
 
+find_package(autoware_shape_estimation REQUIRED)
 find_package(PCL REQUIRED)
 find_package(autoware_agnocast_wrapper REQUIRED)
 
@@ -62,6 +63,26 @@ autoware_agnocast_wrapper_register_node(${PROJECT_NAME}_voxel_grid_node_core
   ROS2_EXECUTOR SingleThreadedExecutor
 )
 
+ament_auto_add_library(${PROJECT_NAME}_label_based_node_core SHARED
+  src/label_based_euclidean_cluster_node.cpp
+)
+target_link_libraries(${PROJECT_NAME}_label_based_node_core
+  ${PCL_LIBRARIES}
+  ${PROJECT_NAME}_lib
+)
+ament_target_dependencies(${PROJECT_NAME}_label_based_node_core
+  autoware_agnocast_wrapper
+  autoware_shape_estimation
+)
+autoware_agnocast_wrapper_setup(${PROJECT_NAME}_label_based_node_core)
+
+autoware_agnocast_wrapper_register_node(${PROJECT_NAME}_label_based_node_core
+  PLUGIN "autoware::euclidean_cluster::LabelBasedEuclideanClusterNode"
+  EXECUTABLE label_based_euclidean_cluster_node
+  AGNOCAST_EXECUTOR CallbackIsolatedAgnocastExecutor
+  ROS2_EXECUTOR SingleThreadedExecutor
+)
+
 if(BUILD_TESTING)
   find_package(ament_cmake_gtest REQUIRED)
   ament_auto_add_gtest(test_voxel_grid_based_euclidean_cluster_fusion
 
@@ -45,6 +45,20 @@ This package has two clustering methods: `euclidean_cluster` and `voxel_grid_bas
 
 {{ json_to_markdown("perception/autoware_euclidean_cluster/schema/voxel_grid_based_euclidean_cluster.schema.json") }}
 
+#### label_based_euclidean_cluster
+
+| Name                                | Type   | Description                                                                                   |
+| ----------------------------------- | ------ | --------------------------------------------------------------------------------------------- |
+| `use_height`                        | bool   | use point.z for clustering                                                                    |
+| `min_cluster_size`                  | int    | minimum number of points required to keep a cluster                                           |
+| `max_cluster_size`                  | int    | maximum number of points allowed in a cluster                                                 |
+| `tolerance`                         | float  | Euclidean clustering tolerance                                                                |
+| `min_probability`                   | float  | minimum point probability to keep a point when the input has a `probability` field            |
+| `class_names.<original_class_name>` | string | mapped label keyed by original class name; YAML declaration order is used as input `class_id` |
+| `use_shape_estimation_corrector`    | bool   | pass clusters through the standard shape estimation corrector                                 |
+| `use_shape_estimation_filter`       | bool   | pass estimated boxes through the standard shape estimation filter                             |
+| `use_boost_bbox_optimizer`          | bool   | use the boost optimizer in the shape estimation backend                                       |
+
 ## Assumptions / Known limits
 
 <!-- Write assumptions and limitations of your implementation.
@@ -88,3 +102,9 @@ Example:
 ## (Optional) Future extensions / Unimplemented parts
 
 The `use_height` option of `voxel_grid_based_euclidean_cluster` isn't implemented yet.
+
+`label_based_euclidean_cluster` reads `class_names.<original_class_name>` in YAML declaration order and uses that order as `class_id`. Classes mapped to `car`, `bus`, `truck`, `motorcycle`, `bicycle`, or `pedestrian` are kept, and classes mapped to `ignore` are skipped.
+
+If the input pointcloud has no `probability` field, the node skips probability filtering and treats each point as probability `1.0`.
+
+If the input pointcloud has no `class_id` field, the node clusters all points together as `UNKNOWN` and runs shape estimation with the `UNKNOWN` label.
@@ -0,0 +1,52 @@
+/**:
+  ros__parameters:
+    # Euclidean clustering
+    use_height: false
+    tolerance: 0.7
+    min_cluster_size: 10
+    max_cluster_size: 3000
+    voxel_leaf_size: 0.2
+    min_points_number_per_voxel: 1
+    min_voxel_cluster_size_for_filtering: 10
+    max_points_per_voxel_in_large_cluster: 100
+    max_voxel_cluster_for_output: 1000
+
+    # Point filtering by semantic confidence
+    min_probability: 0.3
+
+    # Semantic label selection and mapping
+    # YAML declaration order is treated as the input class_id order.
+    class_names:
+      drivable_surface: ignore
+      other_flat_surface: ignore
+      sidewalk: ignore
+      manmade: ignore
+      vegetation: ignore
+      car: car
+      bus: bus
+      emergency_vehicle: car
+      train: unknown
+      truck: truck
+      tractor_unit: trailer
+      semi_trailer: trailer
+      construction_vehicle: truck
+      forklift: car
+      kart: car
+      motorcycle: motorcycle
+      bicycle: bicycle
+      pedestrian: pedestrian
+      personal_mobility: pedestrian
+      animal: animal
+      pushable_pullable: unknown
+      traffic_cone: unknown
+      debris: unknown
+      stroller: pedestrian
+      other_stuff: ignore
+      noise+ghost_point: ignore
+
+    # Shape estimation behavior
+    use_shape_estimation_corrector: false
+    use_shape_estimation_filter: false
+    use_boost_bbox_optimizer: false
+    # 0: ALL_POLYGON, 1: LABEL_DEPEND
+    # shape_policy: 0
@@ -0,0 +1,93 @@
+# Copyright 2026 TIER IV, Inc.
+#
+# 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 launch
+from launch.actions import DeclareLaunchArgument
+from launch.actions import OpaqueFunction
+from launch.conditions import IfCondition
+from launch.conditions import UnlessCondition
+from launch.substitutions import LaunchConfiguration
+from launch_ros.actions import ComposableNodeContainer
+from launch_ros.actions import LoadComposableNodes
+from launch_ros.descriptions import ComposableNode
+from launch_ros.substitutions import FindPackageShare
+import yaml
+
+
+def launch_setup(context, *args, **kwargs):
+    def load_composable_node_param(param_path):
+        with open(LaunchConfiguration(param_path).perform(context), "r") as f:
+            return yaml.safe_load(f)["/**"]["ros__parameters"]
+
+    ns = ""
+    component = ComposableNode(
+        package="autoware_euclidean_cluster",
+        namespace=ns,
+        plugin="autoware::euclidean_cluster::LabelBasedEuclideanClusterNode",
+        name="label_based_euclidean_cluster",
+        remappings=[
+            ("input", LaunchConfiguration("input_pointcloud")),
+            ("output", LaunchConfiguration("output_objects")),
+        ],
+        parameters=[
+            load_composable_node_param("param_path"),
+            {"shape_policy": LaunchConfiguration("shape_policy")},
+        ],
+    )
+
+    container = ComposableNodeContainer(
+        name="label_based_euclidean_cluster_container",
+        namespace=ns,
+        package="rclcpp_components",
+        executable="component_container",
+        composable_node_descriptions=[],
+        output="screen",
+        condition=UnlessCondition(LaunchConfiguration("use_pointcloud_container")),
+    )
+
+    target_container = (
+        LaunchConfiguration("pointcloud_container_name")
+        if IfCondition(LaunchConfiguration("use_pointcloud_container")).evaluate(context)
+        else container
+    )
+
+    loader = LoadComposableNodes(
+        composable_node_descriptions=[component],
+        target_container=target_container,
+    )
+
+    return [container, loader]
+
+
+def generate_launch_description():
+    def add_launch_arg(name: str, default_value=None):
+        return DeclareLaunchArgument(name, default_value=default_value)
+
+    return launch.LaunchDescription(
+        [
+            add_launch_arg("input_pointcloud", "/perception/ptv3/segmented/pointcloud"),
+            add_launch_arg("output_objects", "objects"),
+            add_launch_arg("use_pointcloud_container", "false"),
+            add_launch_arg("pointcloud_container_name", "pointcloud_container"),
+            add_launch_arg("shape_policy"),
+            add_launch_arg(
+                "param_path",
+                [
+                    FindPackageShare("autoware_euclidean_cluster"),
+                    "/config/label_based_euclidean_cluster.param.yaml",
+                ],
+            ),
+            OpaqueFunction(function=launch_setup),
+        ]
+    )
@@ -0,0 +1,16 @@
+<launch>
+  <arg name="input_pointcloud" default="/perception/ptv3/segmented/pointcloud"/>
+  <arg name="output_objects" default="objects"/>
+  <arg name="use_pointcloud_container" default="false"/>
+  <arg name="pointcloud_container_name" default="pointcloud_container"/>
+  <arg name="param_path" default="$(find-pkg-share autoware_euclidean_cluster)/config/label_based_euclidean_cluster.param.yaml"/>
+  <arg name="shape_policy" default="0" description="Shape policy for clustering 0: ALL_POLYGON, 1: LABEL_DEPEND"/>
+  <include file="$(find-pkg-share autoware_euclidean_cluster)/launch/label_based_euclidean_cluster.launch.py">
+    <arg name="input_pointcloud" value="$(var input_pointcloud)"/>
+    <arg name="output_objects" value="$(var output_objects)"/>
+    <arg name="use_pointcloud_container" value="$(var use_pointcloud_container)"/>
+    <arg name="pointcloud_container_name" value="$(var pointcloud_container_name)"/>
+    <arg name="param_path" value="$(var param_path)"/>
+    <arg name="shape_policy" value="$(var shape_policy)"/>
+  </include>
+</launch>
@@ -56,9 +56,99 @@ bool VoxelGridBasedEuclideanCluster::cluster(
   const pcl::PointCloud<pcl::PointXYZ>::ConstPtr & pointcloud,
   std::vector<pcl::PointCloud<pcl::PointXYZ>> & clusters)
 {
-  (void)pointcloud;
-  (void)clusters;
-  return false;
+  // 1) Voxel grid filtering
+  pcl::PointCloud<pcl::PointXYZ>::Ptr voxel_map_ptr(new pcl::PointCloud<pcl::PointXYZ>);
+  constexpr float Z_AXIS_VOXEL_SIZE = 100000.0f;
+  voxel_grid_.setLeafSize(voxel_leaf_size_, voxel_leaf_size_, Z_AXIS_VOXEL_SIZE);
+  voxel_grid_.setMinimumPointsNumberPerVoxel(min_points_number_per_voxel_);
+  voxel_grid_.setInputCloud(pointcloud);
+  voxel_grid_.setSaveLeafLayout(true);
+  voxel_grid_.filter(*voxel_map_ptr);
+
+  // 2) Build 2D centroid cloud
+  pcl::PointCloud<pcl::PointXYZ>::Ptr pointcloud_2d_ptr(new pcl::PointCloud<pcl::PointXYZ>);
+  for (const auto & point : voxel_map_ptr->points) {
+    pcl::PointXYZ point2d;
+    point2d.x = point.x;
+    point2d.y = point.y;
+    point2d.z = 0.0;  // Set z to 0.0 for 2D clustering
+    pointcloud_2d_ptr->push_back(point2d);
+  }
+
+  // 3) KD-tree + clustering
+  pcl::search::KdTree<pcl::PointXYZ>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZ>);
+  tree->setInputCloud(pointcloud_2d_ptr);
+  std::vector<pcl::PointIndices> cluster_indices;
+  pcl::EuclideanClusterExtraction<pcl::PointXYZ> pcl_euclidean_cluster;
+  pcl_euclidean_cluster.setClusterTolerance(tolerance_);
+  pcl_euclidean_cluster.setMinClusterSize(1);
+  pcl_euclidean_cluster.setMaxClusterSize(max_cluster_size_);
+  pcl_euclidean_cluster.setSearchMethod(tree);
+  pcl_euclidean_cluster.setInputCloud(pointcloud_2d_ptr);
+  pcl_euclidean_cluster.extract(cluster_indices);
+
+  // 4) Map voxel index to cluster index
+  std::unordered_map<int, int> voxel_to_cluster_map;
+  for (size_t cluster_idx = 0; cluster_idx < cluster_indices.size(); ++cluster_idx) {
+    const auto & cluster = cluster_indices.at(cluster_idx);
+    for (const auto & point_idx : cluster.indices) {
+      voxel_to_cluster_map[point_idx] = cluster_idx;
+    }
+  }
+
+  // Precompute which clusters are large enough based on the voxel threshold.
+  std::vector<bool> is_large_cluster(cluster_indices.size(), false);
+  std::vector<bool> is_extreme_large_cluster(cluster_indices.size(), false);
+  for (size_t cluster_idx = 0; cluster_idx < cluster_indices.size(); ++cluster_idx) {
+    const int cluster_size = static_cast<int>(cluster_indices[cluster_idx].indices.size());
+    is_large_cluster[cluster_idx] = cluster_size > min_voxel_cluster_size_for_filtering_;
+    is_extreme_large_cluster[cluster_idx] = cluster_size > max_voxel_cluster_for_output_;
+  }
+
+  // 5) Prepare output clusters
+  clusters.clear();
+  clusters.resize(cluster_indices.size());
+  // Track how many points each voxel has per cluster
+  std::unordered_map<int, std::unordered_map<int, int>> point_counts_per_voxel_per_cluster;
+  std::vector<size_t> random_indices(pointcloud->points.size());
+  static std::default_random_engine rng(42);
+  std::iota(random_indices.begin(), random_indices.end(), 0);
+  std::shuffle(random_indices.begin(), random_indices.end(), rng);
+  for (size_t i = 0; i < random_indices.size(); ++i) {
+    const size_t random_index = random_indices[i];
+    const auto & point = pointcloud->points.at(random_index);
+    const Eigen::Vector3i grid_coord = voxel_grid_.getGridCoordinates(point.x, point.y, point.z);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+    const int voxel_index = voxel_grid_.getCentroidIndexAt(grid_coord);
+#pragma GCC diagnostic pop
+    auto voxel_to_cluster_map_it = voxel_to_cluster_map.find(voxel_index);
+    if (voxel_to_cluster_map_it != voxel_to_cluster_map.end()) {
+      int cluster_idx = voxel_to_cluster_map_it->second;
+      if (is_extreme_large_cluster[cluster_idx]) {
+        continue;
+      }
+      if (is_large_cluster[cluster_idx]) {
+        int & voxel_point_count = point_counts_per_voxel_per_cluster[cluster_idx][voxel_index];
+        if (voxel_point_count >= max_points_per_voxel_in_large_cluster_) {
+          continue;
+        }
+        voxel_point_count++;
+      }
+      clusters.at(cluster_idx).push_back(point);
+    }
+  }
+
+  // Remove clusters that are too small
+  clusters.erase(
+    std::remove_if(
+      clusters.begin(), clusters.end(),
+      [this](const pcl::PointCloud<pcl::PointXYZ> & cluster) {
+        return static_cast<int>(cluster.size()) < min_cluster_size_;
+      }),
+    clusters.end());
+
+  return true;
 }
 
 bool VoxelGridBasedEuclideanCluster::cluster(
 
@@ -16,6 +16,7 @@
   <depend>autoware_agnocast_wrapper</depend>
   <depend>autoware_perception_msgs</depend>
   <depend>autoware_point_types</depend>
+  <depend>autoware_shape_estimation</depend>
   <depend>autoware_utils</depend>
   <depend>geometry_msgs</depend>
   <depend>libpcl-all-dev</depend>