SensorFactory.cpp

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "Agrarsense/Sensor/SensorFactory.h"
#include "Agrarsense/Sensor/SensorModel.h"
#include "Agrarsense/Sensor/Lidar/Lidar.h"
#include "Agrarsense/Sensor/Camera/Camera.h"
#include "Agrarsense/Sensor/Camera/DVSCamera.h"
#include "Agrarsense/Sensor/Camera/ThermalCamera.h"
#include "Agrarsense/Sensor/Camera/DepthCamera.h"
#include "Agrarsense/Sensor/Camera/SemanticSegmentationCamera.h"
#include "Agrarsense/Sensor/Camera/InstanceSegmentationCamera.h"
#include "Agrarsense/Sensor/Camera/ThermalCameraParameters.h"
#include "Agrarsense/Sensor/Radar/Radar.h"
#include "Agrarsense/Sensor/Collision/CollisionSensor.h"
#include "Agrarsense/Sensor/Transform/TransformSensor.h"
#include "Agrarsense/Sensor/Transform/TransformSensorParameters.h"
#include "Agrarsense/Sensor/Overlap/OverlapSensor.h"
#include "Agrarsense/Utils/EnumUtilities.h"
 
#include "Engine/GameViewportClient.h"
#include "Misc/Guid.h"
 
TWeakObjectPtr<USensorMapDataAsset> USensorFactory::SensorMapDataAsset;
 
void USensorFactory::Initialize()
{
    if (SensorMapDataAsset.IsValid())
    {
        return;
    }
 
    SensorMapDataAsset.Reset();
    FSoftObjectPath SensorMapDataAssetPath(TEXT("/Game/Agrarsense/Data/Sensors/SensorMap"));
    SensorMapDataAsset = Cast<USensorMapDataAsset>(SensorMapDataAssetPath.TryLoad());
 
#if WITH_EDITOR
    if (SensorMapDataAsset.IsValid())
    {
        UE_LOG(LogTemp, Warning, TEXT("USensorFactory.cpp: Loaded SensorMapDataAsset successfully."));
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("USensorFactory.cpp: Loading SensorMapDataAsset failed."));
    }
#endif
}
 
USensorMapDataAsset* USensorFactory::GetSensorMapDataAsset()
{
    Initialize();
 
    if (SensorMapDataAsset.IsValid())
    {
        return SensorMapDataAsset.Get();
    }
    else
    {
        return nullptr;
    }
}
 
void USensorFactory::SetSensorIdentifierAndNameWithFallbacks(ASensor* sensor, const FString& sensorIdentifier, const FString& sensorName)
{
    bool generateIdentifier = sensorIdentifier.IsEmpty();
    bool generateName = sensorName.IsEmpty();
 
    FString generatedSensorIdentifier;
 
    // If ID not given, use ESensorTypes as the ID
    // and let the ActorInformation-interface handle the numbering after that
    if (generateIdentifier)
    {
        generatedSensorIdentifier = UEnumUtilities::ConvertSensorTypeToString(sensor->GetSensorType());
    }
 
    // If not using generated name -> set the given sensor name
    if (!generateName)
    {
        sensor->SetSensorName(sensorName);
    }
 
    sensor->SetSensorIdentifier(generateIdentifier ? generatedSensorIdentifier : sensorIdentifier);
 
    // If using generated name -> use the identifier as the name too
    if (generateName)
    {
        sensor->SetSensorName(sensor->GetSensorIdentifier());
    }
}
 
ALidar* USensorFactory::SpawnLidarSensor(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FLidarParameters lidarParameters, bool SimulateSensor, AActor* Parent)
{
    ALidar* LidarSensor = nullptr;
    LidarSensor = SpawnSensor<ALidar>(transform, sensorIdentifier, sensorName, true, Parent);
    if (LidarSensor)
    {
        LidarSensor->Init(lidarParameters, SimulateSensor);
    }
 
    return LidarSensor;
}
 
ACamera* USensorFactory::SpawnCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FCameraBaseParameters cameraParameters, bool SimulateSensor, AActor* Parent)
{
    ACamera* RGBCamera = nullptr;
    RGBCamera = SpawnSensor<ACamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (RGBCamera)
    {
        RGBCamera->Init(cameraParameters, SimulateSensor);
    }
 
    return RGBCamera;
}
 
AThermalCamera* USensorFactory::SpawnThermalCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FThermalCameraParameters thermalCameraParameters, bool SimulateSensor, AActor* Parent)
{
    AThermalCamera* ThermalCamera = nullptr;
    ThermalCamera = SpawnSensor<AThermalCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (ThermalCamera)
    {
        ThermalCamera->ThermalInit(thermalCameraParameters, SimulateSensor);
    }
 
    return ThermalCamera;
}
 
ADepthCamera* USensorFactory::SpawnDepthCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FDepthCameraParameters depthCameraParameters, bool SimulateSensor, AActor* Parent)
{
    ADepthCamera* DepthCamera = nullptr;
    DepthCamera = SpawnSensor<ADepthCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (DepthCamera)
    {
        DepthCamera->DepthInit(depthCameraParameters, SimulateSensor);
    }
 
    return DepthCamera;
}
 
ASemanticSegmentationCamera* USensorFactory::SpawnSegmentationCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FCameraBaseParameters cameraParameters, bool SimulateSensor, AActor* Parent)
{
    ASemanticSegmentationCamera* SemanticSegmentationCamera = nullptr;
    SemanticSegmentationCamera = SpawnSensor<ASemanticSegmentationCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (SemanticSegmentationCamera)
    {
        SemanticSegmentationCamera->Init(cameraParameters, SimulateSensor);
    }
 
    return SemanticSegmentationCamera;
}
 
AInstanceSegmentationCamera* USensorFactory::SpawnInstanceSegmentationCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FCameraBaseParameters cameraParameters, bool SimulateSensor, AActor* Parent)
{
    AInstanceSegmentationCamera* InstanceSegmentationCamera = nullptr;
    InstanceSegmentationCamera = SpawnSensor<AInstanceSegmentationCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (InstanceSegmentationCamera)
    {
        InstanceSegmentationCamera->Init(cameraParameters, SimulateSensor);
    }
 
    return InstanceSegmentationCamera;
}
 
ADVSCamera* USensorFactory::SpawnDVSCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FDVSCameraParameters DVSCameraParameters, bool SimulateSensor, AActor* Parent)
{
    ADVSCamera* DVSCamera = nullptr;
    DVSCamera = SpawnSensor<ADVSCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (DVSCamera)
    {
        DVSCamera->DVSInit(DVSCameraParameters, SimulateSensor);
    }
 
    return DVSCamera;
}
 
ARadar* USensorFactory::SpawnRadar(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FRadarParameters radarParameters, bool SimulateSensor, AActor* Parent)
{
    ARadar* RadarSensor = nullptr;
    RadarSensor = SpawnSensor<ARadar>(transform, sensorIdentifier, sensorName, true, Parent);
    if (RadarSensor)
    {
        RadarSensor->Init(radarParameters, SimulateSensor);
    }
 
    return RadarSensor;
}
 
ACollisionSensor* USensorFactory::SpawnCollisionSensor(const FTransform& transform, AActor* Owner, const FString sensorIdentifier, const FString sensorName, bool SimulateSensor, AActor* Parent)
{
    ACollisionSensor* CollisionSensor = nullptr;
    if (Owner)
    {
        CollisionSensor = SpawnSensor<ACollisionSensor>(transform, sensorIdentifier, sensorName, false, Parent);
        if (CollisionSensor)
        {
            CollisionSensor->Init(Owner, SimulateSensor);
            CollisionSensor->AttachToActor(Owner, FAttachmentTransformRules::KeepWorldTransform);
        }
    }
 
    return CollisionSensor;
}
 
ATransformSensor* USensorFactory::SpawnTransformSensor(const FTransform& transform, FTransformSensorParameters Parameters, const FString sensorIdentifier, const FString sensorName, bool SimulateSensor, AActor* Parent)
{
    ATransformSensor* TransformSensor = nullptr;
    if (Parameters.OwningActor)
    {
        TransformSensor = SpawnSensor<ATransformSensor>(transform, sensorIdentifier, sensorName, false, Parent);
        if (TransformSensor)
        {
            TransformSensor->Init(Parameters, SimulateSensor);
            TransformSensor->AttachToActor(Parameters.OwningActor, FAttachmentTransformRules::KeepWorldTransform);
        }
    }
 
    return TransformSensor;
}
 
AOverlapSensor* USensorFactory::SpawnOverlapSensor(const FTransform& transform, FOverlapSensorParameters Parameters, const FString sensorIdentifier, const FString sensorName, AActor* Parent)
{
    AOverlapSensor* OverlapSensor = nullptr;
    OverlapSensor = SpawnSensor<AOverlapSensor>(transform, sensorIdentifier, sensorName, false, Parent);
    if (OverlapSensor)
    {
        OverlapSensor->Init(Parameters);
    }
 
    return OverlapSensor;
}
 
ASensorModel* USensorFactory::SpawnModelClassForSensor(ASensor* attachTo)
{
    ASensorModel* spawnedModel = nullptr;
 
    if (!attachTo)
    {
        return spawnedModel;
    }
 
    USensorMapDataAsset* SensorMap = GetSensorMapDataAsset();
 
    if (SensorMap)
    {
        ESensorTypes sensorType = attachTo->GetSensorType();
 
        TSubclassOf<ASensorModel> modelClass = nullptr;
 
        bool matchFound;
 
        USensorDataAsset* sensorData = SensorMap->GetAssetDataBySensorType(sensorType, matchFound);
 
        if (matchFound && sensorData)
        {
            modelClass = sensorData->ModelClass;
        }
 
        if (modelClass)
        {
            spawnedModel = SpawnModelClass(modelClass, attachTo);
        }
    }
 
    return spawnedModel;
}
 
ASensorModel* USensorFactory::SpawnModelClass(TSubclassOf<ASensorModel> modelClass, ASensor* attachTo)
{
    ASensorModel* createdModelActor = nullptr;
 
    if (!attachTo)
    {
        return createdModelActor;
    }
 
    UWorld* World = nullptr;
    if (GEngine && GEngine->GameViewport)
    {
        World = GEngine->GameViewport->GetWorld();
    }
 
    if (World)
    {
        FVector sensorLocation = attachTo->GetActorLocation();
        createdModelActor = World->SpawnActor<ASensorModel>(modelClass);
 
        if (createdModelActor)
        {
            createdModelActor->AttachToActor(attachTo, FAttachmentTransformRules::SnapToTargetIncludingScale);
 
            attachTo->SetSensorModel(createdModelActor);
            createdModelActor->SetAttachedToSensor(attachTo);
            createdModelActor->InitAfterSpawn();
        }
    }
 
    return createdModelActor;
}
 
template <typename T>
T* USensorFactory::SpawnSensor(const FTransform& transform, const FString& sensorIdentifier, const FString& sensorName, bool SpawnSensorModel, AActor* Parent)
{
    UWorld* World = nullptr;
 
    if (GEngine && GEngine->GameViewport)
    {
        // This might only fail if called in Editor without play mode.
        World = GEngine->GameViewport->GetWorld();
    }
 
    T* Sensor = nullptr;
 
    if (World)
    {
        Sensor = World->SpawnActorDeferred<T>(T::StaticClass(), transform);
        if (Sensor)
        {
            SetSensorIdentifierAndNameWithFallbacks(Sensor, sensorIdentifier, sensorName);
 
            if (Parent)
            {
                Sensor->SetParentActorPtr(Parent);
            }
 
            Sensor->FinishSpawning(transform);
 
            if (SpawnSensorModel)
            {
                SpawnModelClassForSensor(Cast<ASensor>(Sensor));
            }
        }
    }
 
    return Sensor;
}