USensorFactory Class Reference

#include <SensorFactory.h>

Inheritance diagram for USensorFactory:

Collaboration diagram for USensorFactory:

Static Public Member Functions
static USensorMapDataAsset *	GetSensorMapDataAsset ()
static ALidar *	SpawnLidarSensor (const FTransform &transform, const FString sensorIdentifier, const FString sensorName, FLidarParameters lidarParameters, bool SimulateSensor=true, AActor *Parent=nullptr)
static ACamera *	SpawnCamera (const FTransform &transform, const FString sensorIdentifier, const FString sensorName, FCameraBaseParameters cameraParameters, bool SimulateSensor=true, AActor *Parent=nullptr)
static AThermalCamera *	SpawnThermalCamera (const FTransform &transform, const FString sensorIdentifier, const FString sensorName, FThermalCameraParameters thermalCameraParameters, bool SimulateSensor=true, AActor *Parent=nullptr)
static ADepthCamera *	SpawnDepthCamera (const FTransform &transform, const FString sensorIdentifier, const FString sensorName, FDepthCameraParameters depthCameraParameters, bool SimulateSensor=true, AActor *Parent=nullptr)
static ASemanticSegmentationCamera *	SpawnSegmentationCamera (const FTransform &transform, const FString sensorIdentifier, const FString sensorName, FCameraBaseParameters cameraParameters, bool SimulateSensor=true, AActor *Parent=nullptr)
static AInstanceSegmentationCamera *	SpawnInstanceSegmentationCamera (const FTransform &transform, const FString sensorIdentifier, const FString sensorName, FCameraBaseParameters cameraParameters, bool SimulateSensor=true, AActor *Parent=nullptr)
static ADVSCamera *	SpawnDVSCamera (const FTransform &transform, const FString sensorIdentifier, const FString sensorName, FDVSCameraParameters DVSCameraParameters, bool SimulateSensor, AActor *Parent=nullptr)
static ARadar *	SpawnRadar (const FTransform &transform, const FString sensorIdentifier, const FString sensorName, FRadarParameters radarParameters, bool SimulateSensor=true, AActor *Parent=nullptr)
static ACollisionSensor *	SpawnCollisionSensor (const FTransform &transform, AActor *Owner, const FString sensorIdentifier, const FString sensorName, bool SimulateSensor=true, AActor *Parent=nullptr)
static ATransformSensor *	SpawnTransformSensor (const FTransform &transform, FTransformSensorParameters Parameters, const FString sensorIdentifier, const FString sensorName, bool SimulateSensor=true, AActor *Parent=nullptr)
static AOverlapSensor *	SpawnOverlapSensor (const FTransform &transform, FOverlapSensorParameters Parameters, const FString sensorIdentifier, const FString sensorName, AActor *Parent=nullptr)

Static Private Member Functions
template<typename T >
static T *	SpawnSensor (const FTransform &transform, const FString &sensorIdentifier, const FString &sensorName, bool SpawnSensorModel=true, AActor *Parent=nullptr)
static void	SetSensorIdentifierAndNameWithFallbacks (ASensor *sensor, const FString &sensorIdentifier, const FString &sensorName)
static ASensorModel *	SpawnModelClassForSensor (ASensor *attachTo)
static ASensorModel *	SpawnModelClass (TSubclassOf< ASensorModel > modelClass, ASensor *attachTo)
static void	Initialize ()

Static Private Attributes
static TWeakObjectPtr< USensorMapDataAsset >	SensorMapDataAsset

Detailed Description

SensorFactory is a UBlueprintFunctionLibrary based class in charge of spawning sensors. Sensors should not be spawned in any other way. Note. This Factory only works during runtime, don't call these functions in Editor without play mode on.

Definition at line 44 of file SensorFactory.h.

Member Function Documentation

GetSensorMapDataAsset()

USensorMapDataAsset * USensorFactory::GetSensorMapDataAsset ( )

static

Definition at line 51 of file SensorFactory.cpp.

{
    Initialize();
 
    if (SensorMapDataAsset.IsValid())
    {
        return SensorMapDataAsset.Get();
    }
    else
    {
        return nullptr;
    }
}

References Initialize(), and SensorMapDataAsset.

Referenced by SpawnModelClassForSensor().

Initialize()

void USensorFactory::Initialize ( )

staticprivate

Initialize the factory. Should be called before using data or calling functions

Definition at line 28 of file SensorFactory.cpp.

{
    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
}

References SensorMapDataAsset.

Referenced by GetSensorMapDataAsset().

SetSensorIdentifierAndNameWithFallbacks()

void USensorFactory::SetSensorIdentifierAndNameWithFallbacks ( ASensor *  sensor, const FString &  sensorIdentifier, const FString &  sensorName  )

staticprivate

Set sensor name and identifier but fallback to default values if sensor name and/or sensor identifier are empty.

Parameters

sensor	Sensor which name and identifier to change
sensorIdentifier	Sensor new identifier (empty identifier not accepted)
sensorName	Sensor new name (empty name not accepted)

Definition at line 65 of file SensorFactory.cpp.

{
    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());
    }
}

References UEnumUtilities::ConvertSensorTypeToString(), ASensor::GetSensorIdentifier(), ASensor::GetSensorType(), ASensor::SetSensorIdentifier(), and ASensor::SetSensorName().

Referenced by SpawnSensor().

SpawnCamera()

ACamera * USensorFactory::SpawnCamera ( const FTransform &  transform, const FString  sensorIdentifier, const FString  sensorName, FCameraBaseParameters  cameraParameters, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Camera sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
FString	Sensor's unique identifier
FString	Sensor's name
FCameraBaseParameters	FCameraBaseParameters parameters struct
bool	Should the sensor start simulating after spawn

Returns

ACamera pointer or nullptr

Definition at line 106 of file SensorFactory.cpp.

{
    ACamera* RGBCamera = nullptr;
    RGBCamera = SpawnSensor<ACamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (RGBCamera)
    {
        RGBCamera->Init(cameraParameters, SimulateSensor);
    }
 
    return RGBCamera;
}

References RGBCamera.

SpawnCollisionSensor()

ACollisionSensor * USensorFactory::SpawnCollisionSensor ( const FTransform &  transform, AActor *  Owner, const FString  sensorIdentifier, const FString  sensorName, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Collision sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
AActor*	Owning actor
bool	Should the sensor start simulating after spawn

Returns

ACollisionSensor pointer or nullptr

Definition at line 190 of file SensorFactory.cpp.

{
    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;
}

References ACollisionSensor::Init().

Referenced by AVehicle::BeginPlay().

SpawnDepthCamera()

ADepthCamera * USensorFactory::SpawnDepthCamera ( const FTransform &  transform, const FString  sensorIdentifier, const FString  sensorName, FDepthCameraParameters  depthCameraParameters, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Camera sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
FString	Sensor's unique identifier
FString	Sensor's name
FCameraBaseParameters	FCameraBaseParameters parameters struct
bool	Should the sensor start simulating after spawn

Returns

ADepthCamera pointer or nullptr

Definition at line 130 of file SensorFactory.cpp.

{
    ADepthCamera* DepthCamera = nullptr;
    DepthCamera = SpawnSensor<ADepthCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (DepthCamera)
    {
        DepthCamera->DepthInit(depthCameraParameters, SimulateSensor);
    }
 
    return DepthCamera;
}

References DepthCamera.

SpawnDVSCamera()

ADVSCamera * USensorFactory::SpawnDVSCamera ( const FTransform &  transform, const FString  sensorIdentifier, const FString  sensorName, FDVSCameraParameters  DVSCameraParameters, bool  SimulateSensor, AActor *  Parent = nullptr  )

static

Spawn new Camera sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
FString	Sensor's unique identifier
FString	Sensor's name
FCameraBaseParameters	FCameraBaseParameters parameters struct
bool	Should the sensor start simulating after spawn

Returns

ADVSCamera pointer or nullptr

Definition at line 166 of file SensorFactory.cpp.

{
    ADVSCamera* DVSCamera = nullptr;
    DVSCamera = SpawnSensor<ADVSCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (DVSCamera)
    {
        DVSCamera->DVSInit(DVSCameraParameters, SimulateSensor);
    }
 
    return DVSCamera;
}

References DVSCamera.

SpawnInstanceSegmentationCamera()

AInstanceSegmentationCamera * USensorFactory::SpawnInstanceSegmentationCamera ( const FTransform &  transform, const FString  sensorIdentifier, const FString  sensorName, FCameraBaseParameters  cameraParameters, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Instance Segmentation Camera sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
FString	Sensor's unique identifier
FString	Sensor's name
FCameraBaseParameters	FCameraBaseParameters parameters struct
bool	Should the sensor start simulating after spawn

Returns

ASemanticSegmentationCamera pointer

Definition at line 154 of file SensorFactory.cpp.

{
    AInstanceSegmentationCamera* InstanceSegmentationCamera = nullptr;
    InstanceSegmentationCamera = SpawnSensor<AInstanceSegmentationCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (InstanceSegmentationCamera)
    {
        InstanceSegmentationCamera->Init(cameraParameters, SimulateSensor);
    }
 
    return InstanceSegmentationCamera;
}

References InstanceSegmentationCamera.

SpawnLidarSensor()

ALidar * USensorFactory::SpawnLidarSensor ( const FTransform &  transform, const FString  sensorIdentifier, const FString  sensorName, FLidarParameters  lidarParameters, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Lidar sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
FString	Sensor's unique identifier
FString	Sensor's name
FLidarParameters	FLidarParameters parameters struct
bool	Should the sensor start simulating after spawn

Returns

ALidar pointer or nullptr

Definition at line 94 of file SensorFactory.cpp.

{
    ALidar* LidarSensor = nullptr;
    LidarSensor = SpawnSensor<ALidar>(transform, sensorIdentifier, sensorName, true, Parent);
    if (LidarSensor)
    {
        LidarSensor->Init(lidarParameters, SimulateSensor);
    }
 
    return LidarSensor;
}

References ALidar::Init().

SpawnModelClass()

ASensorModel * USensorFactory::SpawnModelClass ( TSubclassOf< ASensorModel >  modelClass, ASensor *  attachTo  )

staticprivate

Spawn sensor model (3D model) class attaching it to the given actor

Parameters

ModelClass	ASensorModel class for the sensor's model's class
attachTo	Attach to this sensor

Returns

Spawned model actor or nullptr

Definition at line 269 of file SensorFactory.cpp.

{
    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;
}

References ASensorModel::InitAfterSpawn(), ASensorModel::SetAttachedToSensor(), and ASensor::SetSensorModel().

Referenced by SpawnModelClassForSensor().

SpawnModelClassForSensor()

ASensorModel * USensorFactory::SpawnModelClassForSensor ( ASensor *  attachTo )

staticprivate

Spawn sensor model (3D model) class attaching it to the given actor

Parameters

attachTo

Sensor to attach to

Returns

Spawned model actor or nullptr

Definition at line 234 of file SensorFactory.cpp.

{
    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;
}

References USensorMapDataAsset::GetAssetDataBySensorType(), GetSensorMapDataAsset(), ASensor::GetSensorType(), USensorDataAsset::ModelClass, and SpawnModelClass().

Referenced by SpawnSensor().

SpawnOverlapSensor()

AOverlapSensor * USensorFactory::SpawnOverlapSensor ( const FTransform &  transform, FOverlapSensorParameters  Parameters, const FString  sensorIdentifier, const FString  sensorName, AActor *  Parent = nullptr  )

static

Spawn new Overlap sensor. BlueprintCallable. This is spawned by default on every vehicle

Parameters

FTransform	location to spawn sensor
FOverlapSensorParameters*	Overlap sensor parameters

Returns

AOverlapSensor pointer or nullptr

Definition at line 222 of file SensorFactory.cpp.

{
    AOverlapSensor* OverlapSensor = nullptr;
    OverlapSensor = SpawnSensor<AOverlapSensor>(transform, sensorIdentifier, sensorName, false, Parent);
    if (OverlapSensor)
    {
        OverlapSensor->Init(Parameters);
    }
 
    return OverlapSensor;
}

References AOverlapSensor::Init().

Referenced by ASpectator::BeginPlay(), APIDDrone::BeginPlay(), AVehicle::BeginPlay(), and APIDDrone::ChangeDroneParameters().

SpawnRadar()

ARadar * USensorFactory::SpawnRadar ( const FTransform &  transform, const FString  sensorIdentifier, const FString  sensorName, FRadarParameters  radarParameters, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Radar sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
FString	Sensor's unique identifier
FString	Sensor's name
FRadarParameters	FRadarParameters parameters struct
bool	Should the sensor start simulating after spawn

Returns

ARadar pointer or nullptr

Definition at line 178 of file SensorFactory.cpp.

{
    ARadar* RadarSensor = nullptr;
    RadarSensor = SpawnSensor<ARadar>(transform, sensorIdentifier, sensorName, true, Parent);
    if (RadarSensor)
    {
        RadarSensor->Init(radarParameters, SimulateSensor);
    }
 
    return RadarSensor;
}

References ARadar::Init().

SpawnSegmentationCamera()

ASemanticSegmentationCamera * USensorFactory::SpawnSegmentationCamera ( const FTransform &  transform, const FString  sensorIdentifier, const FString  sensorName, FCameraBaseParameters  cameraParameters, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Camera sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
FString	Sensor's unique identifier
FString	Sensor's name
FCameraBaseParameters	FCameraBaseParameters parameters struct
bool	Should the sensor start simulating after spawn

Returns

ASemanticSegmentationCamera pointer

Definition at line 142 of file SensorFactory.cpp.

{
    ASemanticSegmentationCamera* SemanticSegmentationCamera = nullptr;
    SemanticSegmentationCamera = SpawnSensor<ASemanticSegmentationCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (SemanticSegmentationCamera)
    {
        SemanticSegmentationCamera->Init(cameraParameters, SimulateSensor);
    }
 
    return SemanticSegmentationCamera;
}

References SemanticSegmentationCamera.

SpawnSensor()

template<typename T >

T * USensorFactory::SpawnSensor ( const FTransform &  transform, const FString &  sensorIdentifier, const FString &  sensorName, bool  SpawnSensorModel = true, AActor *  Parent = nullptr  )

staticprivate

Definition at line 303 of file SensorFactory.cpp.

{
    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;
}

References SetSensorIdentifierAndNameWithFallbacks(), and SpawnModelClassForSensor().

SpawnThermalCamera()

AThermalCamera * USensorFactory::SpawnThermalCamera ( const FTransform &  transform, const FString  sensorIdentifier, const FString  sensorName, FThermalCameraParameters  thermalCameraParameters, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Camera sensor. BlueprintCallable.

Parameters

FTransform	location to spawn sensor
FString	Sensor's unique identifier
FString	Sensor's name
FCameraBaseParameters	FCameraBaseParameters parameters struct
bool	Should the sensor start simulating after spawn

Returns

AThermalCamera pointer or nullptr

Definition at line 118 of file SensorFactory.cpp.

{
    AThermalCamera* ThermalCamera = nullptr;
    ThermalCamera = SpawnSensor<AThermalCamera>(transform, sensorIdentifier, sensorName, true, Parent);
    if (ThermalCamera)
    {
        ThermalCamera->ThermalInit(thermalCameraParameters, SimulateSensor);
    }
 
    return ThermalCamera;
}

References ThermalCamera.

SpawnTransformSensor()

ATransformSensor * USensorFactory::SpawnTransformSensor ( const FTransform &  transform, FTransformSensorParameters  Parameters, const FString  sensorIdentifier, const FString  sensorName, bool  SimulateSensor = true, AActor *  Parent = nullptr  )

static

Spawn new Tranform sensor. BlueprintCallable. This is spawned by default on every vehicle

Parameters

FTransform	location to spawn sensor
AActor*	Owning actor
bool	Should the sensor start simulating after spawn

Returns

ATransformSensor pointer or nullptr

Definition at line 206 of file SensorFactory.cpp.

{
    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;
}

References ATransformSensor::Init(), and FTransformSensorParameters::OwningActor.

Referenced by ASensor::BeginPlay(), APIDDrone::BeginPlay(), AVehicle::BeginPlay(), and AWalker::BeginPlay().

Member Data Documentation

SensorMapDataAsset

TWeakObjectPtr< USensorMapDataAsset > USensorFactory::SensorMapDataAsset

staticprivate

Sensor map data asset to hold sensor specific base data

Definition at line 228 of file SensorFactory.h.

Referenced by GetSensorMapDataAsset(), and Initialize().

---

The documentation for this class was generated from the following files:

• Unreal/Agrarsense/Source/Agrarsense/Sensor/SensorFactory.h
• Unreal/Agrarsense/Source/Agrarsense/Sensor/SensorFactory.cpp