Sensor.h

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>.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Engine/EngineTypes.h"
#include "Engine/World.h"
#include "Templates/SharedPointer.h"
#include "UObject/ObjectPtr.h"
#include "Containers/UnrealString.h"
#include "Components/PrimitiveComponent.h"
#include "JsonObjectConverter.h"
 
#include <vector>
 
#include "ROSIntegration/Classes/ROSIntegrationGameInstance.h"
#include "ROSIntegration/Classes/RI/Topic.h"
 
#include "Agrarsense/ActorInterfaces/ActorInformation.h"
#include "Agrarsense/Game/AgrarsensePaths.h"
#include "Agrarsense/Utils/EnumUtilities.h"
#include "Agrarsense/Sensor/SensorTypes.h"
#include "Agrarsense/Logging/LogFile.h"
#include "Agrarsense/ROS/ROSState.h"
 
 
#include "Sensor.generated.h"
 
class ASensorModel;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FSensorDestroy, ASensor*, sensor);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPrimitiveAdded, UPrimitiveComponent*, PrimitiveComponent);
 
UCLASS()
class AGRARSENSE_API ASensor : public AActor, public IActorInformation
{
    GENERATED_BODY()
 
public:
 
    ASensor(const FObjectInitializer& ObjectInitializer);
 
    UFUNCTION(BlueprintCallable)
    FString ExportToJsonFile(const FString& FileName);
 
    UFUNCTION(BlueprintCallable)
    virtual ESensorTypes GetSensorType() const
    {
        return ESensorTypes::NONE;
    }
 
    UFUNCTION(BlueprintPure)
    FString GetSensorIdentifier() const
    {
        return SensorIdentifier;
    }
 
    UFUNCTION(BlueprintCallable)
    void SetSensorIdentifier(const FString newIdentifier)
    {
        SensorIdentifier = newIdentifier;
        SetAndValidateActorIDAndName(SensorName, SensorIdentifier, TWeakObjectPtr<AActor>(this));
    }
 
    UFUNCTION(BlueprintPure)
    FString GetSensorName() const
    {
        return SensorName;
    }
 
    UFUNCTION(BlueprintPure)
    virtual FString GetParametersAsString() const
    {
        return FString();
    }
 
    UFUNCTION(BlueprintCallable)
    void SetSensorName(const FString newName)
    {
        SensorName = newName;
    }
 
    UFUNCTION(BlueprintPure)
    virtual FString GetTopicName()
    {
        FString Name = "Undefined";
 
        if (ROSTopic)
        {
            Name = ROSTopic->GetName();
        }
 
        return Name;
    }
 
    UFUNCTION(BlueprintCallable)
    UTopic* GetROSTopic() const
    {
        return ROSTopic;
    }
 
    UFUNCTION(BlueprintCallable)
    void SetSimulateSensor(bool SimulateSensor)
    {
        SimulateThisSensor = SimulateSensor;
    }
 
    UFUNCTION(BlueprintCallable)
    inline bool CanSimulateSensor() const
    {
        return SimulateThisSensor;
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    ASensorModel* GetSensorModel() const
    {
        return SensorModel.Get();
    }
 
    UFUNCTION(BlueprintCallable)
    void SetSensorModel(ASensorModel* NewSensorModel)
    {
        SensorModel = NewSensorModel;
    }
 
    UFUNCTION(BlueprintCallable)
    bool IsROSConnected() const
    {
        return ROSConnected;
    }
 
    UFUNCTION(BlueprintPure)
    UROSIntegrationGameInstance* GetROSGameInstance() const
    {
        return ROSInstance;
    }
 
    virtual FString GetActorID_Implementation() const override
    {
        return GetSensorIdentifier();
    }
 
    virtual FString GetActorName_Implementation() const override
    {
        return GetSensorName();
    }
 
    virtual FString GetActorInformation_Implementation() const override
    {
        const FString Sensor = UEnumUtilities::ConvertSensorTypeToString(GetSensorType());
        const FString ID = GetActorID_Implementation();
        const FTransform VehicleTransform = GetActorTransform();
        const FVector Location = VehicleTransform.GetLocation();
        const FRotator Rotation = VehicleTransform.Rotator();
        const FString Parameters = GetParametersAsString();
 
        FString Information = FString::Printf(TEXT("Sensor: %s \nID: %s \nLocation: %s \nRotation: %s \nParameters: %s"),
            *Sensor, *ID, *Location.ToString(), *Rotation.ToString(), *Parameters);
 
        return Information;
    }
 
    virtual void SetActorName_Implementation(const FString& NewActorName) override
    {
        SetSensorName(NewActorName);
    }
 
    virtual void SetActorIDAndName_Implementation(const FString& NewActorName, const FString& NewID) override
    {
        SetSensorName(NewActorName);
        SetSensorIdentifier(NewID);
    }
 
    static void HideComponentForAllCameras(UPrimitiveComponent* PrimitiveComponent);
 
    UFUNCTION(BlueprintCallable)
    static TMap<FString, FColor> GetSemanticColors();
 
    static TArray<TWeakObjectPtr<UPrimitiveComponent>> GetComponentsToHide()
    {
        // Since we don't know whether some UPrimitiveComponent has been destroyed,
        // we need to check these are still valid.
        ComponentsToHide.RemoveAll([](const TWeakObjectPtr<UPrimitiveComponent>& WeakComponent)
            {
                return !WeakComponent.IsValid();
            });
 
        return ComponentsToHide;
    }
 
    UPROPERTY(BlueprintAssignable)
    FSensorDestroy OnSensorDestroy;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sensor")
    FString AttachedToComponent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sensor")
    FName AttachedToBone;
 
protected:
 
    virtual void BeginPlay() override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    virtual void CreateROSTopic();
 
    virtual void DestroyROSTopic();
 
    virtual void CreateDataSavePath();
 
    template<typename InStructType>
    static FString StructToString(const InStructType& InStruct)
    {
        FString AsString;
        FJsonObjectConverter::UStructToJsonObjectString(InStruct, AsString);
        return AsString;
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    bool IsLogFileCreated()
    {
        if (LogFile)
        {
            return true;
        }
 
        return false;
    }
 
    UFUNCTION(BlueprintCallable)
    virtual void CreateLogFile();
 
    UFUNCTION(BlueprintCallable)
    void WriteToLogFile(const FString& Message);
 
    UPROPERTY()
    UTopic* ROSTopic = nullptr;
 
    UPROPERTY(VisibleAnywhere, Category = "Sensor")
    bool SendDataToROS = true;
 
    UPROPERTY()
    ULogFile* LogFile = nullptr;
 
    FString FileSavePath;
 
    UPROPERTY()
    UROSIntegrationGameInstance* ROSInstance = nullptr;
 
    static FPrimitiveAdded OnPrimitiveAdded;
 
    // Lidar Niagara particle system visualization FName constants
    inline static const FName NiagaraPointsInt = "User.PointCount";
    inline static const FName NiagaraHitPoints = "User.HitPoints";
    inline static const FName NiagaraHitColors = "User.HitColors";
    inline static const FName NiagaraPointsFloat = "User.Test";
 
private:
 
    UFUNCTION()
    void ROSBridgeStateChanged(EROSState ROSState);
 
    UPROPERTY()
    TObjectPtr<ASensorModel> SensorModel;
 
    UPROPERTY(EditAnywhere, Category = "Sensor")
    FString SensorIdentifier;
 
    UPROPERTY(EditAnywhere, Category = "Sensor")
    FString SensorName;
 
    UPROPERTY(EditAnywhere, Category = "Sensor")
    bool SimulateThisSensor = true;
 
    UPROPERTY(VisibleAnywhere, Category = "Sensor")
    bool ROSConnected = false;
 
    static TArray<TWeakObjectPtr<UPrimitiveComponent>> ComponentsToHide;
 
};