LidarManager.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 "GameFramework/Actor.h"
#include "CoreMinimal.h"
#include <vector>
 
#include "Agrarsense/Sensor/Lidar/PointData.h"
#include "Agrarsense/Managers/TickManager.h"
 
#include "ROSIntegration/Public/sensor_msgs/PointCloud2.h"
 
#include "LidarManager.generated.h"
 
class SimpleTimer;
class ALidar;
class UROSHandler;
class UNiagaraComponent;
class UTopic;
class UROSIntegrationGameInstance;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLidarDelegate_LidarSpawned, ALidar*, lidar);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLidarDelegate_LidarDestroyed, int, lidarCount);
 
UCLASS()
class AGRARSENSE_API ALidarManager : public AActor
{
    GENERATED_BODY()
 
public:
 
    ALidarManager(const FObjectInitializer& ObjectInitializer);
 
    UFUNCTION(BlueprintCallable)
    void SetSimulateLidars(bool bSimulateLidars);
 
    UFUNCTION(BlueprintCallable)
    void SetMeasurePerformance(bool bMeasurePerformance);
 
    UFUNCTION(BlueprintCallable)
    void SetSaveCombinedCloudToDisk(bool bSaveCombinedCloud);
 
    UFUNCTION(BlueprintCallable)
    void SetSendCombinedCloud(bool bSaveCombinedCloud);
 
    void AddRaycastLidar(ALidar* lidarPtr);
 
    void RemoveRaycastLidar(ALidar* lidarPtr);
 
    UFUNCTION(BlueprintCallable)
    int GetLidarCount() const
    {
        return RaycastLidars.size();
    }
 
    UFUNCTION(BlueprintCallable)
    TArray<ALidar*> GetAllLidars() const
    {
        // Create TArray<ALidar*> since LidarManager uses std::vector 
        // to keep track of Lidar sensors and Blueprints only support TArrays
        TArray<ALidar*> Lidars;
 
        for (int32 i = 0; i < RaycastLidars.size(); i++)
        {
            ALidar* LidarPtr = RaycastLidars[i];
            if (LidarPtr)
            {
                Lidars.Add(LidarPtr);
            }
        }
 
        return Lidars;
    }
 
    std::vector<ALidar*> GetAllLidarsVector() const
    {
        return RaycastLidars;
    }
 
    UPROPERTY(BlueprintAssignable)
    FLidarDelegate_LidarSpawned OnLidarSpawned;
 
    UPROPERTY(BlueprintAssignable)
    FLidarDelegate_LidarDestroyed OnLidarDestroyed;
 
    UPROPERTY(BlueprintReadOnly)
    bool SendCombinedCloudToROS = true;
 
    UPROPERTY(BlueprintReadOnly)
    bool SaveCombinedCloudToDisk = false;
 
    UPROPERTY(BlueprintReadOnly);
    bool MeasurePerformance = false;
 
    UPROPERTY(BlueprintReadOnly)
    float TimeInMilliseconds;
 
private:
 
    virtual void BeginPlay() override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    void TickParallel(float DeltaTime);
 
    FTickEntry TickEntry;
 
    bool TickAdded = false;
 
    void SimulateRaycastLidars(const float DeltaTime);
 
    void SendCombinedPointcloud(const std::vector<FPointData>& points);
 
 
    void SaveCombinedPointcloud(const std::vector<FPointData>& points);
 
    UFUNCTION()
    void ROSBridgeStateChanged(EROSState RosState);
 
    void InitTopic();
 
    void DestroyTopic();
 
    std::vector<ALidar*> RaycastLidars;
 
    UPROPERTY()
    UROSIntegrationGameInstance* RosInstance = nullptr;
 
    UPROPERTY()
    TWeakObjectPtr<UTopic> CombinedLidarTopic;
 
    SimpleTimer* TotalAverageTimer = nullptr;
 
    bool SimulateLidars = true;
 
    FString FileSavePath;
 
    int LidarSaves = 0;
 
    TSharedPtr<ROSMessages::sensor_msgs::PointCloud2> PointCloudMessage;
};