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/ThermalCameraParameters.h"
#include "Agrarsense/Sensor/Radar/Radar.h"
#include "Agrarsense/Sensor/Collision/CollisionSensor.h"
#include "Agrarsense/Sensor/Transform/TransformSensor.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)
{
    ALidar* lidar = nullptr;
    lidar = SpawnSensor<ALidar>(transform, sensorIdentifier, sensorName, true);
    if (lidar)
    {
        lidar->Init(lidarParameters, SimulateSensor);
    }
 
    return lidar;
}
 
ACamera* USensorFactory::SpawnCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FCameraBaseParameters cameraParameters, bool SimulateSensor)
{
    ACamera* camera = nullptr;
    camera = SpawnSensor<ACamera>(transform, sensorIdentifier, sensorName, true);
    if (camera)
    {
        camera->Init(cameraParameters, SimulateSensor);
    }
 
    return camera;
}
 
AThermalCamera* USensorFactory::SpawnThermalCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FThermalCameraParameters thermalCameraParameters, bool SimulateSensor)
{
    AThermalCamera* thermalCamera = nullptr;
    thermalCamera = SpawnSensor<AThermalCamera>(transform, sensorIdentifier, sensorName, true);
    if (thermalCamera)
    {
        thermalCamera->ThermalInit(thermalCameraParameters, SimulateSensor);
    }
 
    return thermalCamera;
}
 
ADepthCamera* USensorFactory::SpawnDepthCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FDepthCameraParameters depthCameraParameters, bool SimulateSensor)
{
    ADepthCamera* depthCamera = nullptr;
    depthCamera = SpawnSensor<ADepthCamera>(transform, sensorIdentifier, sensorName, true);
    if (depthCamera)
    {
        depthCamera->DepthInit(depthCameraParameters, SimulateSensor);
    }
 
    return depthCamera;
}
 
ASemanticSegmentationCamera* USensorFactory::SpawnSegmentationCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FCameraBaseParameters cameraParameters, bool SimulateSensor)
{
    ASemanticSegmentationCamera* segmentationCamera = nullptr;
    segmentationCamera = SpawnSensor<ASemanticSegmentationCamera>(transform, sensorIdentifier, sensorName, true);
    if (segmentationCamera)
    {
        segmentationCamera->Init(cameraParameters, SimulateSensor);
    }
 
    return segmentationCamera;
}
 
ADVSCamera* USensorFactory::SpawnDVSCamera(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FDVSCameraParameters DVSCameraParameters, bool SimulateSensor)
{
    ADVSCamera* dvscamera = nullptr;
    dvscamera = SpawnSensor<ADVSCamera>(transform, sensorIdentifier, sensorName, true);
    if (dvscamera)
    {
        dvscamera->DVSInit(DVSCameraParameters, SimulateSensor);
    }
 
    return dvscamera;
}
 
ARadar* USensorFactory::SpawnRadar(const FTransform& transform, const FString sensorIdentifier, const FString sensorName, FRadarParameters radarParameters, bool SimulateSensor)
{
    ARadar* radar = nullptr;
    radar = SpawnSensor<ARadar>(transform, sensorIdentifier, sensorName, true);
    if (radar)
    {
        radar->Init(radarParameters, SimulateSensor);
    }
 
    return radar;
}
 
ACollisionSensor* USensorFactory::SpawnCollisionSensor(const FTransform& transform, AActor* Owner, const FString sensorIdentifier, const FString sensorName, bool SimulateSensor)
{
    ACollisionSensor* collisionSensor = nullptr;
    collisionSensor = SpawnSensor<ACollisionSensor>(transform, sensorIdentifier, sensorName, false);
    if (collisionSensor)
    {
        collisionSensor->Init(Owner, SimulateSensor);
    }
 
    return collisionSensor;
}
 
ATransformSensor* USensorFactory::SpawnTransformSensor(const FTransform& transform, AActor* Owner, const FString sensorIdentifier, const FString sensorName, bool SimulateSensor)
{
    ATransformSensor* transformSensor = nullptr;
    transformSensor = SpawnSensor<ATransformSensor>(transform, sensorIdentifier, sensorName, false);
    if (transformSensor)
    {
        transformSensor->Init(Owner, SimulateSensor);
    }
 
    return transformSensor;
}
 
AOverlapSensor* USensorFactory::SpawnOverlapSensor(const FTransform& transform, FOverlapSensorParameters Parameters, const FString sensorIdentifier, const FString sensorName)
{
    AOverlapSensor* OverlapSensor = nullptr;
    OverlapSensor = SpawnSensor<AOverlapSensor>(transform, sensorIdentifier, sensorName, false);
    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)
{
    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);
            Sensor->FinishSpawning(transform);
 
            if (SpawnSensorModel) 
            {
                SpawnModelClassForSensor(Cast<ASensor>(Sensor));
            }   
        }
    }
 
    return Sensor;
}