Adding Cosmos Control Visualization Sensor

LibCarla/source/carla/road/Map.h

@@ -91,6 +91,10 @@ namespace road {
     /// when a location is repeated an area is finished
     std::vector<geom::Location> GetAllCrosswalkZones() const;
 
+    const std::unordered_map<RoadId, Road>& GetRoads() const {
+      return _data.GetRoads();
+    }
+
     /// Data structure for the signal search
     struct SignalSearchData {
       const element::RoadInfoSignal *signal;

LibCarla/source/carla/sensor/SensorRegistry.h

@@ -47,6 +47,7 @@ class ARayCastLidar;
 class ASceneCaptureCamera;
 class ASemanticSegmentationCamera;
 class AInstanceSegmentationCamera;
+class ACosmosControlSensor;
 class ARssSensor;
 class FWorldObserver;
 struct FCameraGBufferUint8;
@@ -81,6 +82,7 @@ namespace sensor {
     std::pair<ASceneCaptureCamera *, s11n::ImageSerializer>,
     std::pair<ASemanticSegmentationCamera *, s11n::ImageSerializer>,
     std::pair<AInstanceSegmentationCamera *, s11n::ImageSerializer>,
+    std::pair<ACosmosControlSensor *, s11n::ImageSerializer>,
     std::pair<FWorldObserver *, s11n::EpisodeStateSerializer>,
     std::pair<FCameraGBufferUint8 *, s11n::GBufferUint8Serializer>,
     std::pair<FCameraGBufferFloat *, s11n::GBufferFloatSerializer>,
@@ -114,6 +116,7 @@ namespace sensor {
 #include "Carla/Sensor/SceneCaptureCamera.h"
 #include "Carla/Sensor/SemanticSegmentationCamera.h"
 #include "Carla/Sensor/InstanceSegmentationCamera.h"
+#include "Carla/Sensor/CosmosControlSensor.h"
 #include "Carla/Sensor/WorldObserver.h"
 #include "Carla/Sensor/V2XSensor.h"
 #include "Carla/Sensor/CustomV2XSensor.h"

PythonAPI/examples/manual_control.py

@@ -1118,6 +1118,7 @@ def __init__(self, parent_actor, hud, gamma_correction):
             ['sensor.camera.semantic_segmentation', cc.CityScapesPalette, 'Camera Semantic Segmentation (CityScapes Palette)', {}],
             ['sensor.camera.instance_segmentation', cc.CityScapesPalette, 'Camera Instance Segmentation (CityScapes Palette)', {}],
             ['sensor.camera.instance_segmentation', cc.Raw, 'Camera Instance Segmentation (Raw)', {}],
+            ['sensor.camera.cosmos_visualization', cc.Raw, 'Cosmos Control Visualization', {}],
             ['sensor.lidar.ray_cast', None, 'Lidar (Ray-Cast)', {'range': '50'}],
             ['sensor.camera.dvs', cc.Raw, 'Dynamic Vision Sensor', {}],
             ['sensor.camera.rgb', cc.Raw, 'Camera RGB Distorted',

PythonAPI/test/smoke/test_sensor_tick_time.py

@@ -40,7 +40,8 @@ def test_sensor_tick_time(self):
       "sensor.other.obstacle",
       "sensor.camera.instance_segmentation",
       "sensor.other.v2x",
-      "sensor.other.v2x_custom"
+      "sensor.other.v2x_custom",
+      "sensor.camera.cosmos_visualization"
     }
     spawned_sensors = []
     sensor_tick = 1.0

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaGameModeBase.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2017 Computer Vision Center (CVC) at the Universitat Autonoma
+// Copyright (c) 2025 Computer Vision Center (CVC) at the Universitat Autonoma
 // de Barcelona (UAB).
 //
 // This work is licensed under the terms of the MIT license.
@@ -9,6 +9,7 @@
 #include "Carla/Game/CarlaHUD.h"
 #include "Carla/Game/CarlaStatics.h"
 #include "Carla/Game/CarlaStaticDelegates.h"
+#include "Carla/Traffic/RoadSpline.h"
 #include "Carla/Lights/CarlaLight.h"
 #include "Engine/DecalActor.h"
 #include "Engine/LevelStreaming.h"
@@ -35,6 +36,7 @@
 #include "DrawDebugHelpers.h"
 #include "Kismet/KismetSystemLibrary.h"
 
+
 namespace cr = carla::road;
 namespace crp = carla::rpc;
 namespace cre = carla::road::element;
@@ -163,6 +165,7 @@ void ACarlaGameModeBase::InitGame(
   if(Map.has_value())
   {
     StoreSpawnPoints();
+    SpawnRoadSplines();
   }
 }
 
@@ -478,6 +481,137 @@ void ACarlaGameModeBase::ParseOpenDrive()
   }
 }
 
+void ACarlaGameModeBase::SpawnRoadSplines()
+{
+  if (!Map.has_value())
+  {
+    UE_LOG(LogCarla, Warning, TEXT("Map is not available yet."));
+    return;
+  }
+
+  UWorld* World = GetWorld();
+  if (!World)
+  {
+    UE_LOG(LogCarla, Error, TEXT("World context is invalid."));
+    return;
+  }
+
+  const auto& Roads = Map->GetRoads();
+  for (const auto& RoadTuple : Roads) {
+    const auto RoadId = RoadTuple.first;
+    const auto& Road = RoadTuple.second;
+
+    const auto& LaneSections = Road.GetLaneSections();
+
+    for (const auto& Section : LaneSections)
+    {
+      const auto& Lanes = Section.GetLanes();
+
+      for (const auto& LaneTuple : Lanes)
+      {
+        const auto& Lane = LaneTuple.second;
+        auto LaneType = Lane.GetType();
+        if (LaneType == carla::road::Lane::LaneType::None)
+          continue;
+
+        auto AssignBoundaryType = [&](ARoadSpline* SplineActor)
+        {
+          switch (LaneType)
+          {
+            case carla::road::Lane::LaneType::Driving:       SplineActor->BoundaryType = ERoadSplineBoundaryType::Driving; break;
+            case carla::road::Lane::LaneType::Stop:          SplineActor->BoundaryType = ERoadSplineBoundaryType::Stop; break;
+            case carla::road::Lane::LaneType::Shoulder:      SplineActor->BoundaryType = ERoadSplineBoundaryType::Shoulder; break;
+            case carla::road::Lane::LaneType::Biking:        SplineActor->BoundaryType = ERoadSplineBoundaryType::Biking; break;
+            case carla::road::Lane::LaneType::Sidewalk:      SplineActor->BoundaryType = ERoadSplineBoundaryType::Sidewalk; break;
+            case carla::road::Lane::LaneType::Border:        SplineActor->BoundaryType = ERoadSplineBoundaryType::Border; break;
+            case carla::road::Lane::LaneType::Restricted:    SplineActor->BoundaryType = ERoadSplineBoundaryType::Restricted; break;
+            case carla::road::Lane::LaneType::Parking:       SplineActor->BoundaryType = ERoadSplineBoundaryType::Parking; break;
+            case carla::road::Lane::LaneType::Bidirectional: SplineActor->BoundaryType = ERoadSplineBoundaryType::Bidirectional; break;
+            case carla::road::Lane::LaneType::Median:        SplineActor->BoundaryType = ERoadSplineBoundaryType::Median; break;
+            case carla::road::Lane::LaneType::Special1:      SplineActor->BoundaryType = ERoadSplineBoundaryType::Special1; break;
+            case carla::road::Lane::LaneType::Special2:      SplineActor->BoundaryType = ERoadSplineBoundaryType::Special2; break;
+            case carla::road::Lane::LaneType::Special3:      SplineActor->BoundaryType = ERoadSplineBoundaryType::Special3; break;
+            case carla::road::Lane::LaneType::RoadWorks:     SplineActor->BoundaryType = ERoadSplineBoundaryType::RoadWorks; break;
+            case carla::road::Lane::LaneType::Tram:          SplineActor->BoundaryType = ERoadSplineBoundaryType::Tram; break;
+            case carla::road::Lane::LaneType::Rail:          SplineActor->BoundaryType = ERoadSplineBoundaryType::Rail; break;
+            case carla::road::Lane::LaneType::Entry:         SplineActor->BoundaryType = ERoadSplineBoundaryType::Entry; break;
+            case carla::road::Lane::LaneType::Exit:          SplineActor->BoundaryType = ERoadSplineBoundaryType::Exit; break;
+            case carla::road::Lane::LaneType::OffRamp:       SplineActor->BoundaryType = ERoadSplineBoundaryType::OffRamp; break;
+            case carla::road::Lane::LaneType::OnRamp:        SplineActor->BoundaryType = ERoadSplineBoundaryType::OnRamp; break;
+            default:                                         SplineActor->BoundaryType = ERoadSplineBoundaryType::Unknown; break;
+          }
+        };
+
+
+        const double s_start = Lane.GetDistance();
+        const double s_end = s_start + Lane.GetLength();
+
+        TArray<FVector> LeftBoundaryPoints;
+        TArray<FVector> RightBoundaryPoints;
+
+        for (double s = s_start; s < s_end; s += SampleDistance)
+        {
+          auto Corners = Lane.GetCornerPositions(s);
+          const auto& LeftLoc = Corners.first;
+          const auto& RightLoc = Corners.second;
+
+          LeftBoundaryPoints.Add(FVector(LeftLoc.x * 100.0f, LeftLoc.y * 100.0f, RightLoc.z * 100.0f));
+          RightBoundaryPoints.Add(FVector(RightLoc.x * 100.0f, RightLoc.y * 100.0f, RightLoc.z * 100.0f));
+        }
+
+        {
+          auto Corners = Lane.GetCornerPositions(s_end);
+          const auto& LeftLoc = Corners.first;
+          const auto& RightLoc = Corners.second;
+
+          LeftBoundaryPoints.Add(FVector(LeftLoc.x * 100.0f, LeftLoc.y * 100.0f, RightLoc.z * 100.0f));
+          RightBoundaryPoints.Add(FVector(RightLoc.x * 100.0f, RightLoc.y * 100.0f, RightLoc.z * 100.0f));
+        }
+
+        if (LeftBoundaryPoints.Num() > 0)
+        {
+          ARoadSpline* SplineActor = World->SpawnActor<ARoadSpline>(FVector::ZeroVector, FRotator::ZeroRotator);
+          if (SplineActor)
+          {
+#if WITH_EDITOR
+            SplineActor->SetFolderPath(FName(TEXT("RoadSplines")));
+            SplineActor->SetActorLabel(FString::Printf(TEXT("RoadSpline_%d_%d_Left"), RoadId, Lane.GetId()));
+#endif
+            SplineActor->SetSplinePoints(LeftBoundaryPoints);
+            SplineActor->OrientationType = ERoadSplineOrientationType::Left;
+            SplineActor->LaneID = Lane.GetId();
+            SplineActor->RoadID = RoadId;
+            AssignBoundaryType(SplineActor);
+
+            if (Map->IsJunction(RoadId))
+              SplineActor->bIsJunction = true;
+          }
+        }
+
+        if (RightBoundaryPoints.Num() > 0)
+        {
+          ARoadSpline* SplineActor = World->SpawnActor<ARoadSpline>(FVector::ZeroVector, FRotator::ZeroRotator);
+          if (SplineActor)
+          {
+#if WITH_EDITOR
+            SplineActor->SetFolderPath(FName(TEXT("RoadSplines")));
+            SplineActor->SetActorLabel(FString::Printf(TEXT("RoadSpline_%d_%d_Right"), RoadId, Lane.GetId()));
+#endif
+            SplineActor->SetSplinePoints(RightBoundaryPoints);
+            SplineActor->OrientationType = ERoadSplineOrientationType::Right;
+            SplineActor->LaneID = Lane.GetId();
+            SplineActor->RoadID = RoadId;
+            AssignBoundaryType(SplineActor);
+
+            if (Map->IsJunction(RoadId))
+              SplineActor->bIsJunction = true;
+          }
+        }
+      }
+    }
+  }
+}
+
 ATrafficLightManager* ACarlaGameModeBase::GetTrafficLightManager()
 {
   if (!TrafficLightManager)

Unreal/CarlaUE4/Plugins/Carla/Source/Carla/Game/CarlaGameModeBase.h

@@ -116,6 +116,9 @@ class CARLA_API ACarlaGameModeBase : public AGameModeBase
   UPROPERTY(BlueprintReadOnly, EditAnywhere, Category="Sensor Gravity")
   float IMUISensorGravity = 9.81f;
 
+  UPROPERTY(BlueprintReadOnly, EditAnywhere, Category = "Road Spline")
+  float SampleDistance = 2.0f;
+
 protected:
 
   void InitGame(const FString &MapName, const FString &Options, FString &ErrorMessage) override;
@@ -138,6 +141,8 @@ class CARLA_API ACarlaGameModeBase : public AGameModeBase
 
   void ParseOpenDrive();
 
+  void SpawnRoadSplines();
+
   void RegisterEnvironmentObjects();
 
   void ConvertMapLayerMaskToMapNames(int32 MapLayer, TArray<FName>& OutLevelNames);