fix(autoware_carla_interface): address Codex review on traffic-light matching

- Use the resolved map origin (`_current_map_origin()`) instead of the raw
  `map_origin_x/y` parameters when placing CARLA light heads in the map frame,
  so georeferenced maps (origin derived from the OpenDRIVE geoReference in
  `on_world_ready`, parameters left at zero) match correctly instead of falling
  outside the distance threshold and publishing nothing. (P1)
- Treat a candidate head as a genuine alternative for the ambiguity test unless
  its group set is exactly equal to the winner's, replacing the `isdisjoint`
  check. Overlapping-but-unequal sets (e.g. {500, 501} vs {501}) would otherwise
  be accepted by arbitrary ranking and publish a missing or spurious group. Adds
  a regression test. (P2)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Signed-off-by: Masaya Kataoka <cld-masaya.kataoka@tier4.jp>

Author: Masaya Kataoka

simulator/autoware_carla_interface/src/autoware_carla_interface/carla_ros.py

@@ -1225,6 +1225,12 @@ def _carla_light_map_point(self, actor):
         ``get_light_boxes()`` reports them in world coordinates) rather than the
         actor origin, which sits at the pole base and is offset from the heads the
         lanelet2 map records. Falls back to the actor location if no boxes exist.
+
+        The CARLA→map offset is read via :meth:`_current_map_origin` (not the raw
+        ``map_origin_x/y`` parameters) so georeferenced maps, whose origin is
+        derived from the OpenDRIVE geoReference in ``on_world_ready`` while the
+        parameters stay at their zero default, transform the heads into the same
+        frame as the lanelet2 ``local_x/local_y`` coordinates and localization.
         """
         try:
             boxes = actor.get_light_boxes()
@@ -1239,11 +1245,8 @@ def _carla_light_map_point(self, actor):
             )
         else:
             carla_location = actor.get_location()
-        point = carla_location_to_ros_point(
-            carla_location,
-            origin_x=self.param_values["map_origin_x"],
-            origin_y=self.param_values["map_origin_y"],
-        )
+        origin_x, origin_y = self._current_map_origin()
+        point = carla_location_to_ros_point(carla_location, origin_x=origin_x, origin_y=origin_y)
         return (point.x, point.y)
 
     def _parse_traffic_light_id_override(self):

simulator/autoware_carla_interface/src/autoware_carla_interface/modules/traffic_light_matcher.py

@@ -193,17 +193,14 @@ def match_traffic_lights(
 
         nearest_dist, nearest_way = ranked[0]
         nearest_groups = map_lights.head_groups[nearest_way]
-        # Closest head that would resolve to a *different* set of group ids, i.e. a
-        # genuinely different signal (the light across the intersection), not just the
-        # neighbouring head of the same approach, which shares the same regulatory
-        # elements and would give the same answer. Only such a head makes a match
-        # ambiguous.
+        # Closest head that would resolve to a *different answer* than the winner.
+        # A head is a genuine alternative unless its group set is exactly equal to
+        # the winner's: only then does matching it publish the same group ids, so a
+        # neighbouring head of the same approach is ignored, while a head with an
+        # overlapping-but-unequal or disjoint set (e.g. {500, 501} vs {501}, or the
+        # light across the intersection) still makes the match ambiguous.
         second_dist = next(
-            (
-                d
-                for d, way_id in ranked[1:]
-                if map_lights.head_groups[way_id].isdisjoint(nearest_groups)
-            ),
+            (d for d, way_id in ranked[1:] if map_lights.head_groups[way_id] != nearest_groups),
             None,
         )
 

simulator/autoware_carla_interface/test/test_traffic_light_matcher.py

@@ -66,6 +66,16 @@ def test_close_neighbor_sharing_groups_is_not_ambiguous():
     assert result.assignments["a"] == [1, 2]
 
 
+def test_overlapping_but_unequal_group_sets_are_ambiguous():
+    # Two heads at equal distance whose group sets overlap but are not equal:
+    # matching the wrong one would publish a different set ({500, 501} vs {501}),
+    # so the light must be dropped, not resolved by arbitrary ranking.
+    m = _map({"w1": ((0.0, 0.0), {500, 501}), "w2": ((0.5, 0.0), {501})})
+    result = match_traffic_lights([("a", None, (0.25, 0.0))], m)
+    assert "a" not in result.assignments
+    assert _status(result, "a") == MatchResult.AMBIGUOUS
+
+
 def test_clear_winner_over_nearby_disjoint_head_still_matches():
     # Light sits essentially on its own head (0.1 m); a different signal 1.5 m away
     # should not defeat the match thanks to the ratio-based ambiguity test.