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 "Engine/World.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();
 
    return SensorMapDataAsset.Get();
}
 
ALidar* USensorFactory::SpawnLidarSensor(const FSensorSpawnParameters SpawnParameters, FLidarParameters SensorParameters)
{
    ALidar* Sensor = SpawnSensor<ALidar>(SpawnParameters, true);
    if (!Sensor) return nullptr;
 
    Sensor->Init(SensorParameters);
    return Sensor;
}
 
ACamera* USensorFactory::SpawnCamera(const FSensorSpawnParameters SpawnParameters, FCameraBaseParameters SensorParameters)
{
    ACamera* Sensor = SpawnSensor<ACamera>(SpawnParameters, true);
    if (!Sensor) return nullptr;
 
    Sensor->Init(SensorParameters);
    return Sensor;
}
 
AThermalCamera* USensorFactory::SpawnThermalCamera(const FSensorSpawnParameters SpawnParameters, FThermalCameraParameters SensorParameters)
{
    AThermalCamera* Sensor = SpawnSensor<AThermalCamera>(SpawnParameters, true);
    if (!Sensor) return nullptr;
 
    Sensor->ThermalInit(SensorParameters, SpawnParameters.SimulateSensor);
    return Sensor;
}
 
ADepthCamera* USensorFactory::SpawnDepthCamera(const FSensorSpawnParameters SpawnParameters, FDepthCameraParameters SensorParameters)
{
    ADepthCamera* Sensor = SpawnSensor<ADepthCamera>(SpawnParameters, true);
    if (!Sensor) return nullptr;
 
    Sensor->DepthInit(SensorParameters, SpawnParameters.SimulateSensor);
    return Sensor;
}
 
ASemanticSegmentationCamera* USensorFactory::SpawnSegmentationCamera(const FSensorSpawnParameters SpawnParameters, FCameraBaseParameters SensorParameters)
{
    ASemanticSegmentationCamera* Sensor = SpawnSensor<ASemanticSegmentationCamera>(SpawnParameters, true);
    if (!Sensor) return nullptr;
 
    Sensor->Init(SensorParameters, SpawnParameters.SimulateSensor);
    return Sensor;
}
 
AInstanceSegmentationCamera* USensorFactory::SpawnInstanceSegmentationCamera(const FSensorSpawnParameters SpawnParameters, FCameraBaseParameters SensorParameters)
{
    AInstanceSegmentationCamera* Sensor = SpawnSensor<AInstanceSegmentationCamera>(SpawnParameters, true);
    if (!Sensor) return nullptr;
 
    Sensor->Init(SensorParameters);
    return Sensor;
}
 
ADVSCamera* USensorFactory::SpawnDVSCamera(const FSensorSpawnParameters SpawnParameters, FDVSCameraParameters SensorParameters)
{
    ADVSCamera* Sensor = SpawnSensor<ADVSCamera>(SpawnParameters, true);
    if (!Sensor) return nullptr;
 
    Sensor->DVSInit(SensorParameters, SpawnParameters.SimulateSensor);
    return Sensor;
}
 
ARadar* USensorFactory::SpawnRadar(const FSensorSpawnParameters SpawnParameters, FRadarParameters SensorParameters)
{
    ARadar* Sensor = SpawnSensor<ARadar>(SpawnParameters, true);
    if (!Sensor) return nullptr;
 
    Sensor->Init(SensorParameters, SpawnParameters.SimulateSensor);
    return Sensor;
}
 
ACollisionSensor* USensorFactory::SpawnCollisionSensor(const FSensorSpawnParameters SpawnParameters)
{
    ACollisionSensor* Sensor = SpawnSensor<ACollisionSensor>(SpawnParameters, false);
    if (!Sensor) return nullptr;
 
    Sensor->Init(SpawnParameters.Parent, SpawnParameters.SimulateSensor);
    return Sensor;
}
 
ATransformSensor* USensorFactory::SpawnTransformSensor(const FSensorSpawnParameters SpawnParameters, FTransformSensorParameters SensorParameters)
{
    ATransformSensor* Sensor = SpawnSensor<ATransformSensor>(SpawnParameters, false);
    if (!Sensor) return nullptr;
 
    Sensor->Init(SensorParameters, SpawnParameters.SimulateSensor);
    Sensor->AttachToActor(SensorParameters.OwningActor, FAttachmentTransformRules::KeepWorldTransform);
    return Sensor;
}
 
AOverlapSensor* USensorFactory::SpawnOverlapSensor(const FSensorSpawnParameters SpawnParameters, FOverlapSensorParameters SensorParameters)
{
    AOverlapSensor* Sensor = SpawnSensor<AOverlapSensor>(SpawnParameters, false);
    if (!Sensor) return nullptr;
 
    Sensor->Init(SensorParameters);
    return Sensor;
}
 
template <typename T>
T* USensorFactory::SpawnSensor(const FSensorSpawnParameters& SpawnParameters, bool SpawnSensorModel)
{
    T* Sensor = nullptr;
 
    if (UWorld* World = GetGameWorld())
    {
        Sensor = World->SpawnActorDeferred<T>(T::StaticClass(), SpawnParameters.Transform);
        if (Sensor)
        {
            SetSensorIdentifierAndNameWithFallbacks(Sensor, SpawnParameters.SensorIdentifier, SpawnParameters.SensorName);
 
            if (SpawnParameters.Parent)
            {
                Sensor->SetParentActorPtr(SpawnParameters.Parent);
            }
 
            Sensor->FinishSpawning(SpawnParameters.Transform);
 
            if (SpawnSensorModel)
            {
                SpawnModelClassForSensor(Cast<ASensor>(Sensor));
            }
        }
    }
 
    return Sensor;
}
 
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());
    }
}
 
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;
    }
 
    if (UWorld* World = GetGameWorld())
    {
        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;
}
 
UWorld* USensorFactory::GetGameWorld()
{
    return (GEngine && GEngine->GameViewport) ? GEngine->GameViewport->GetWorld() : nullptr;
}