nsubiron · July 12, 2019 16:57 · replica6 · Jun 10, 2021 · thbake · Nov 4, 2021
diff --git a/SafeDistanceEvent.h b/SafeDistanceEvent.h
 // Copyright (c) 2019 Computer Vision Center (CVC) at the Universitat Autonoma
 // de Barcelona (UAB).
 //
 // This work is licensed under the terms of the MIT license.
 // For a copy, see <https://opensource.org/licenses/MIT>.

 #pragma once

 #include "carla/rpc/ActorId.h"
 #include "carla/sensor/data/Array.h"

 namespace carla {
 namespace sensor {
 namespace data {

  class SafeDistanceEvent : public Array<rpc::ActorId> {
  public:

    explicit SafeDistanceEvent(RawData &&data)
      : Array<rpc::ActorId>(std::move(data)) {}
  };

 } // namespace data
 } // namespace sensor
 } // namespace carla
diff --git a/SafeDistanceSensor.cpp b/SafeDistanceSensor.cpp
 // Copyright (c) 2019 Computer Vision Center (CVC) at the Universitat Autonoma
 // de Barcelona (UAB).
 //
 // This work is licensed under the terms of the MIT license.
 // For a copy, see <https://opensource.org/licenses/MIT>.

 #include "Carla.h"
 #include "Carla/Sensor/SafeDistanceSensor.h"

 #include "Carla/Actor/ActorBlueprintFunctionLibrary.h"
 #include "Carla/Game/CarlaEpisode.h"
 #include "Carla/Util/BoundingBoxCalculator.h"
 #include "Carla/Vehicle/CarlaWheeledVehicle.h"

 ASafeDistanceSensor::ASafeDistanceSensor(const FObjectInitializer &ObjectInitializer)
  : Super(ObjectInitializer)
 {
  Box = CreateDefaultSubobject<UBoxComponent>(TEXT("BoxOverlap"));
  Box->SetupAttachment(RootComponent);
  Box->SetHiddenInGame(true); // Disable for debugging.
  Box->SetCollisionProfileName(FName("OverlapAll"));

  PrimaryActorTick.bCanEverTick = true;
 }

 FActorDefinition ASafeDistanceSensor::GetSensorDefinition()
 {
  auto Definition = UActorBlueprintFunctionLibrary::MakeGenericSensorDefinition(
      TEXT("other"),
      TEXT("safe_distance"));

  FActorVariation Front;
  Front.Id = TEXT("safe_distance_front");
  Front.Type = EActorAttributeType::Float;
  Front.RecommendedValues = { TEXT("1.0") };
  Front.bRestrictToRecommended = false;

  FActorVariation Back;
  Back.Id = TEXT("safe_distance_back");
  Back.Type = EActorAttributeType::Float;
  Back.RecommendedValues = { TEXT("0.5") };
  Back.bRestrictToRecommended = false;

  FActorVariation Lateral;
  Lateral.Id = TEXT("safe_distance_lateral");
  Lateral.Type = EActorAttributeType::Float;
  Lateral.RecommendedValues = { TEXT("0.5") };
  Lateral.bRestrictToRecommended = false;

  Definition.Variations.Append({ Front, Back, Lateral });

  return Definition;
 }

 void ASafeDistanceSensor::Set(const FActorDescription &Description)
 {
  Super::Set(Description);

  float Front = UActorBlueprintFunctionLibrary::RetrieveActorAttributeToFloat(
      "safe_distance_front",
      Description.Variations,
      1.0f);
  float Back = UActorBlueprintFunctionLibrary::RetrieveActorAttributeToFloat(
      "safe_distance_back",
      Description.Variations,
      0.5f);
  float Lateral = UActorBlueprintFunctionLibrary::RetrieveActorAttributeToFloat(
      "safe_distance_lateral",
      Description.Variations,
      0.5f);

  constexpr float M_TO_CM = 100.0f; // Unit conversion.

  float LocationX = M_TO_CM * (Front - Back) / 2.0f;
  float ExtentX = M_TO_CM * (Front + Back) / 2.0f;
  float ExtentY = M_TO_CM * Lateral;

  Box->SetRelativeLocation(FVector{LocationX, 0.0f, 0.0f});
  Box->SetBoxExtent(FVector{ExtentX, ExtentY, 0.0f});
 }

 void ASafeDistanceSensor::SetOwner(AActor *Owner)
 {
  Super::SetOwner(Owner);

  auto BoundingBox = UBoundingBoxCalculator::GetActorBoundingBox(Owner);

  Box->SetBoxExtent(BoundingBox.Extent + Box->GetUnscaledBoxExtent());
 }

 void ASafeDistanceSensor::Tick(float DeltaSeconds)
 {
  Super::Tick(DeltaSeconds);

  TSet<AActor *> DetectedActors;
  Box->GetOverlappingActors(DetectedActors, ACarlaWheeledVehicle::StaticClass());
  DetectedActors.Remove(GetOwner());

  if (DetectedActors.Num() > 0)
  {
    auto Stream = GetDataStream(*this);
    Stream.Send(*this, GetEpisode(), DetectedActors);
  }
 }
diff --git a/SafeDistanceSensor.h b/SafeDistanceSensor.h
 // Copyright (c) 2019 Computer Vision Center (CVC) at the Universitat Autonoma
 // de Barcelona (UAB).
 //
 // This work is licensed under the terms of the MIT license.
 // For a copy, see <https://opensource.org/licenses/MIT>.

 #pragma once

 #include "Carla/Sensor/Sensor.h"

 #include "Carla/Actor/ActorDefinition.h"
 #include "Carla/Actor/ActorDescription.h"

 #include "Components/BoxComponent.h"

 #include "SafeDistanceSensor.generated.h"

 UCLASS()
 class CARLA_API ASafeDistanceSensor : public ASensor
 {
  GENERATED_BODY()

 public:

  ASafeDistanceSensor(const FObjectInitializer &ObjectInitializer);

  static FActorDefinition GetSensorDefinition();

  void Set(const FActorDescription &ActorDescription) override;

  void SetOwner(AActor *Owner) override;

  void Tick(float DeltaSeconds) override;

 private:

  UPROPERTY()
  UBoxComponent *Box = nullptr;
 };
diff --git a/SafeDistanceSerializer.cpp b/SafeDistanceSerializer.cpp
 // Copyright (c) 2019 Computer Vision Center (CVC) at the Universitat Autonoma
 // de Barcelona (UAB).
 //
 // This work is licensed under the terms of the MIT license.
 // For a copy, see <https://opensource.org/licenses/MIT>.

 #include "carla/sensor/s11n/SafeDistanceSerializer.h"

 #include "carla/sensor/data/SafeDistanceEvent.h"

 namespace carla {
 namespace sensor {
 namespace s11n {

  SharedPtr<SensorData> SafeDistanceSerializer::Deserialize(RawData &&data) {
    return SharedPtr<SensorData>(new data::SafeDistanceEvent(std::move(data)));
  }

 } // namespace s11n
 } // namespace sensor
 } // namespace carla
diff --git a/SafeDistanceSerializer.h b/SafeDistanceSerializer.h
 // Copyright (c) 2019 Computer Vision Center (CVC) at the Universitat Autonoma
 // de Barcelona (UAB).
 //
 // This work is licensed under the terms of the MIT license.
 // For a copy, see <https://opensource.org/licenses/MIT>.

 #pragma once

 #include "carla/Memory.h"
 #include "carla/rpc/ActorId.h"
 #include "carla/sensor/RawData.h"

 #include <cstdint>
 #include <cstring>

 namespace carla {
 namespace sensor {

  class SensorData;

 namespace s11n {

  class SafeDistanceSerializer {
  public:

    template <typename SensorT, typename EpisodeT, typename ActorListT>
    static Buffer Serialize(
        const SensorT &,
        const EpisodeT &episode,
        const ActorListT &detected_actors) {
      const uint32_t size_in_bytes = sizeof(ActorId) * detected_actors.Num();
      Buffer buffer{size_in_bytes};
      unsigned char *it = buffer.data();
      for (auto *actor : detected_actors) {
        ActorId id = episode.FindActor(actor).GetActorId();
        std::memcpy(it, &id, sizeof(ActorId));
        it += sizeof(ActorId);
      }
      return buffer;
    }

    static SharedPtr<SensorData> Deserialize(RawData &&data);
  };

 } // namespace s11n
 } // namespace sensor
 } // namespace carla
	// Copyright (c) 2019 Computer Vision Center (CVC) at the Universitat Autonoma
	// de Barcelona (UAB).
	//
	// This work is licensed under the terms of the MIT license.
	// For a copy, see <https://opensource.org/licenses/MIT>.

	#pragma once

	#include "carla/rpc/ActorId.h"
	#include "carla/sensor/data/Array.h"

	namespace carla {
	namespace sensor {
	namespace data {

	class SafeDistanceEvent : public Array<rpc::ActorId> {
	public:

	explicit SafeDistanceEvent(RawData &&data)
	: Array<rpc::ActorId>(std::move(data)) {}
	};

	} // namespace data
	} // namespace sensor
	} // namespace carla