#include <Lidar.h>

Inheritance diagram for ALidar:

[legend]

Collaboration diagram for ALidar:

[legend]

Public Member Functions
	ALidar (const FObjectInitializer &ObjectInitializer)

void	Init (FLidarParameters parameters, bool SimulateSensor=true)

virtual ESensorTypes	GetSensorType () const override

void	ChangeLidarParameters (FLidarParameters newLidarParameters)

void	SetVisualizeLidarParticles (bool Visualize)

void	SetParticleLifeTime (float ParticleLifeTime)

FLidarParameters	GetLidarParameters () const

UNiagaraComponent *	GetNiagaraComponent () const

virtual FString	GetParametersAsString () const override

void	ForceClearContainers ()

void	SaveCurrentPointCloudToDisk ()

Public Member Functions inherited from ASensor
	ASensor (const FObjectInitializer &ObjectInitializer)

FString	ExportToJsonFile (const FString &FileName)

virtual ESensorTypes	GetSensorType () const

FString	GetSensorIdentifier () const

void	SetSensorIdentifier (const FString newIdentifier)

FString	GetSensorName () const

virtual FString	GetParametersAsString () const

AVehicle *	IsAttachedToVehicle () const

void	SetSensorName (const FString newName)

FString	GetTopicName ()

UTopic *	GetROSTopic () const

void	SetSimulateSensor (bool SimulateSensor)

bool	CanSimulateSensor () const

ASensorModel *	GetSensorModel () const

void	SetSensorModel (ASensorModel *NewSensorModel)

FORCEINLINE bool	IsROSConnected () const

UROSIntegrationGameInstance *	GetROSGameInstance () const

virtual FString	GetActorID_Implementation () const override

virtual FString	GetActorName_Implementation () const override

virtual FString	GetActorInformation_Implementation () const override

virtual void	SetActorName_Implementation (const FString &NewActorName) override

virtual void	SetActorIDAndName_Implementation (const FString &NewActorName, const FString &NewID) override

void	SetParentActorPtr (AActor *ParentActorPtr)

Public Member Functions inherited from IActorInformation
FString	GetActorID () const

FString	GetActorName () const

FString	GetActorInformation () const

void	SetActorName (const FString &NewActorName)

void	SetActorIDAndName (const FString &NewActorName, const FString &NewID)

Protected Member Functions
virtual void	BeginPlay () override

virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override

void	CreateLogFile () override

void	SaveLidarMetaDataToDisk (const FString &FileName)

Protected Member Functions inherited from ASensor
virtual void	BeginPlay () override

virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override

FString	CreateTimeStampString () const

virtual void	CreateROSTopic ()

virtual void	DestroyROSTopic ()

virtual void	CreateDataSavePath ()

bool	IsLogFileCreated ()

virtual void	CreateLogFile ()

void	WriteToLogFile (const FString &Message)

Private Member Functions
std::vector< FPointData >	SimulateRaycastLidar (const float DeltaTime)

void	SetNiagaraRendering (bool Enabled)

void	VisualizeLidarParticles (std::vector< FPointData > HitPoints)

void	ChangeParameters ()

FORCEINLINE bool	ShootLaser (const UWorld *World, FHitResult &HitResult, const FVector &EndTrace, const FCollisionQueryParams &TraceParams, const FVector &LidarBodyLocation, const int32 Channel, const bool Semantic, const uint32 RGBDefault, const bool UseLidarNoiseModel)

void	ResetRecordedHits (int32 MaxPointsPerChannel)

FORCEINLINE uint32	GetSemanticData (const FHitResult &HitResult) const

void	SendData (const float DeltaTime)

bool	CanSendData (const float DeltaTime)

void	SendDataToTopic (const std::vector< FPointData > &points)

void	SaveDataToDisk ()

void	AddProcessingToHitResult (FHitResult &HitResult, const FVector &LidarBodyLocation, const bool UseHorizontalNoise, const bool UseSnowTerrainAdjustment)

void	AddDistanceNoise (FHitResult &HitResult, const FVector &LidarBodyLocation)

void	AddLateralNoise (FHitResult &HitResult, const FVector &LidarBodyLocation, const bool UseHorizontalNoise)

void	AddSnowTerrainAdjustment (FHitResult &HitResult, const FVector &LidarBodyLocation)

void	UpdateLidarParticles (int32 NumberOfHits, const TArray< FVector > &HitPoints, const TArray< FLinearColor > &Colors)

void	OnWeatherChanged (FWeatherParameters WeatherParams)

Private Attributes
UNiagaraComponent *	NiagaraComponent = nullptr

AGeoReferencingSystem *	GeoReferencingSystem = nullptr

FLidarParameters	LidarParameters

FLidarParameters	TempLidarParameters

FWeatherParameters	CurrentWeatherParameters

TMap< FName, FColor >	SemanticColors

TSharedPtr< ROSMessages::sensor_msgs::PointCloud2 >	PointCloudMessage

std::vector< std::vector< FPointData > >	PreProcessedHitImpactPoints

std::vector< std::vector< FPointData > >	Points

std::vector< FPointData >	PointsFlattened

std::vector< float >	LaserAngles

std::random_device	RandomDevice

std::mt19937	Generator

bool	NeedToSavePointCloudWithoutNoise = false

bool	LidarParametersChanged = false

bool	SendDataEveryFrame = false

const FName	TerrainTag = "Terrain"

float	CurrentHorizontalAngle = 0.0f

float	SensorHzFrequency = 0.1f

float	SensorHzTimer = 0.0f

float	SnowHeightOffset = 0.0f

int32	LidarSaves = 0

uint32	CachedNoneColor

uint32	CachedSnowflakeColor

bool	SaveCurrentPointCloudToDiskRequested = false

bool	ClearContainers = true

Friends
class	ALidarManager

Additional Inherited Members
Static Public Member Functions inherited from ASensor
static void	HideComponentForAllCameras (UPrimitiveComponent *PrimitiveComponent)

static TMap< FString, FColor >	GetSemanticColors ()

static TArray< TWeakObjectPtr< UPrimitiveComponent > >	GetComponentsToHide ()

Static Public Member Functions inherited from IActorInformation
static void	SetAndValidateActorIDAndName (FString &ActorName, FString &ActorID, TWeakObjectPtr< AActor > Actor)

static bool	DestroyActorByID (const FString &ID)

static AActor *	GetActorByID (const FString &ID)

template<typename T >
static TArray< T * >	GetActorsWithInterface ()

static void	PrintAllIds ()

Public Attributes inherited from ASensor
FSensorDestroy	OnSensorDestroy

FString	AttachedToComponent

FName	AttachedToBone

Static Protected Member Functions inherited from ASensor
template<typename InStructType >
static FString	StructToString (const InStructType &InStruct)

Protected Attributes inherited from ASensor
UTopic *	ROSTopic = nullptr

bool	SendDataToROS = true

ULogFile *	LogFile = nullptr

AActor *	ParentActor = nullptr

FString	FileSavePath

UROSIntegrationGameInstance *	ROSInstance = nullptr

Static Protected Attributes inherited from ASensor
static FPrimitiveAdded	OnPrimitiveAdded

static const FName	NiagaraPointsInt = "User.PointCount"

static const FName	NiagaraHitPoints = "User.HitPoints"

static const FName	NiagaraHitColors = "User.HitColors"

static const FName	NiagaraPointsFloat = "User.Test"

Detailed Description

Parameterized linetrace based Lidar sensor. Parameters defined in FLidarParameters struct. This Sensor Actor is ticked by LidarManager where all added Lidar sensors are ticked in parallel.

Definition at line 34 of file Lidar.h.

Constructor & Destructor Documentation

◆ ALidar()

ALidar::ALidar ( const FObjectInitializer & ObjectInitializer )

Definition at line 36 of file Lidar.cpp.

                                                          : Super(ObjectInitializer)
{
    // Lidar sensors are ticked by LidarManager.cpp
    PrimaryActorTick.bCanEverTick = false;
}

Member Function Documentation

◆ AddDistanceNoise()

void ALidar::AddDistanceNoise	(	FHitResult &	HitResult,
		const FVector &	LidarBodyLocation
	)

private

Definition at line 395 of file Lidar.cpp.

{
    std::normal_distribution<float> Distribution(0.0f, LidarParameters.DistanceNoiseStdDev);
    float NoiseValue = Distribution(Generator);
    const FVector DirectionToSensor = ((LidarBodyLocation * 1e-2) - HitResult.ImpactPoint).GetSafeNormal();
    const FVector Noise = DirectionToSensor * NoiseValue;
    HitResult.ImpactPoint += Noise;
}

References FLidarParameters::DistanceNoiseStdDev, Generator, and LidarParameters.

Referenced by AddProcessingToHitResult().

◆ AddLateralNoise()

void ALidar::AddLateralNoise	(	FHitResult &	HitResult,
		const FVector &	LidarBodyLocation,
		const bool	UseHorizontalNoise
	)

private

Definition at line 404 of file Lidar.cpp.

{
    const FVector ForwardVector = (HitResult.ImpactPoint - LidarBodyLocation).GetSafeNormal();
    const FVector RightVector = FVector::CrossProduct(ForwardVector, FVector::UpVector).GetSafeNormal();
 
    FVector ChosenDirection;
    if (UseHorizontalNoise)
    {
        ChosenDirection = RightVector;
    }
    else
    {
        FVector UpVector = FVector::CrossProduct(ForwardVector, RightVector).GetSafeNormal();
        ChosenDirection = UpVector;
    }
 
    std::normal_distribution<float> Distribution(0.0f, LidarParameters.LateralNoiseStdDev);
    const float NoiseValue = Distribution(Generator);
 
    HitResult.ImpactPoint += ChosenDirection * NoiseValue;
}

References Generator, FLidarParameters::LateralNoiseStdDev, and LidarParameters.

Referenced by AddProcessingToHitResult().

◆ AddProcessingToHitResult()

void ALidar::AddProcessingToHitResult	(	FHitResult &	HitResult,
		const FVector &	LidarBodyLocation,
		const bool	UseHorizontalNoise,
		const bool	UseSnowTerrainAdjustment
	)

private

Definition at line 377 of file Lidar.cpp.

{
    if (UseSnowTerrainAdjustment)
    {
        AddSnowTerrainAdjustment(HitResult, LidarBodyLocation);
    }
 
    if (LidarParameters.DistanceNoiseStdDev > 0.0f)
    {
        AddDistanceNoise(HitResult, LidarBodyLocation);
    }
 
    if (LidarParameters.LateralNoiseStdDev > 0.0f)
    {
        AddLateralNoise(HitResult, LidarBodyLocation, UseHorizontalNoise);
    }
}

References AddDistanceNoise(), AddLateralNoise(), AddSnowTerrainAdjustment(), FLidarParameters::DistanceNoiseStdDev, FLidarParameters::LateralNoiseStdDev, and LidarParameters.

Referenced by SimulateRaycastLidar().

◆ AddSnowTerrainAdjustment()

void ALidar::AddSnowTerrainAdjustment	(	FHitResult &	HitResult,
		const FVector &	LidarBodyLocation
	)

private

Definition at line 426 of file Lidar.cpp.

{
    AActor* HitActor = HitResult.GetActor();
 
    // Terrain should have tag "Terrain" in order to make this work.
    if (HitActor && HitActor->Tags.Contains(TerrainTag))
    {
        // Scale the Z value of ImpactPoint based on SnowHeightOffset.
        HitResult.ImpactPoint.Z += SnowHeightOffset;
    }
}

References SnowHeightOffset, and TerrainTag.

Referenced by AddProcessingToHitResult().

◆ BeginPlay()

void ALidar::BeginPlay ( )

overrideprotectedvirtual

Reimplemented from ASensor.

Definition at line 58 of file Lidar.cpp.

{
    Super::BeginPlay();
 
    UWorld* World = GetWorld();
 
    // Create the SemanticColors TMap
    TMap<FString, FColor> Colors = GetSemanticColors();
    for (const auto& ColorEntry : Colors)
    {
        FName SemanticName = FName(*ColorEntry.Key);
        SemanticColors.Add(SemanticName, ColorEntry.Value);
    }
 
    // Cache "None" and "Snowflake" colors for Semantic
    FColor NoneColor = SemanticColors.FindRef("None");
    FColor SnowflakeColor = SemanticColors.FindRef("Snowflake");
    CachedNoneColor = (NoneColor.R << 16) | (NoneColor.G << 8) | (NoneColor.B << 0);
    CachedSnowflakeColor = (SnowflakeColor.R << 16) | (SnowflakeColor.G << 8) | (SnowflakeColor.B << 0);
 
    // Add this lidar to LidarManager that handles ticking of this sensor in parallel.
    ALidarManager* LidarManager = UAgrarsenseStatics::GetLidarManager(World);
    if (LidarManager)
    {
        LidarManager->AddRaycastLidar(this);
    }
 
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(World);
    if (Weather)
    {
        CurrentWeatherParameters = Weather->GetCurrentWeather();
        Weather->OnWeatherChanged.AddUniqueDynamic(this, &ALidar::OnWeatherChanged);
    }
 
    // Load pointcloud Niagara particle system
    UNiagaraSystem* NS = LoadObject<UNiagaraSystem>(nullptr, TEXT("/Game/Agrarsense/Particles/PointCloud/NS_PointCloudSemanticFast"), nullptr, LOAD_None, nullptr);
    if (NS)
    {
        NiagaraComponent = UNiagaraFunctionLibrary::SpawnSystemAtLocation(World, NS, GetActorLocation());
        if (NiagaraComponent)
        {
            // Hide this NiagaraComponent for all Camera sensors.
            HideComponentForAllCameras(Cast<UPrimitiveComponent>(NiagaraComponent));
 
            NiagaraComponent->SetAffectDynamicIndirectLighting(false);
            NiagaraComponent->SetAffectDistanceFieldLighting(false);
            NiagaraComponent->SetCastContactShadow(false);
            NiagaraComponent->SetCastShadow(false);
 
            SetParticleLifeTime(2.0f);
        }
    }
#if WITH_EDITOR
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("Lidar.cpp: Couldn't find Niagara particle system."));
    }
#endif
}

References ALidarManager::AddRaycastLidar(), CachedNoneColor, CachedSnowflakeColor, CurrentWeatherParameters, AWeather::GetCurrentWeather(), UAgrarsenseStatics::GetLidarManager(), ASensor::GetSemanticColors(), UAgrarsenseStatics::GetWeatherActor(), ASensor::HideComponentForAllCameras(), NiagaraComponent, OnWeatherChanged(), AWeather::OnWeatherChanged, SemanticColors, and SetParticleLifeTime().

◆ CanSendData()

bool ALidar::CanSendData ( const float DeltaTime )

private

Checks can sensor send data in this tick

Definition at line 526 of file Lidar.cpp.

{
    if (SendDataEveryFrame)
    {
        ClearContainers = true;
        return true;
    }
 
    SensorHzTimer += DeltaTime;
    if (SensorHzTimer >= SensorHzFrequency)
    {
        SensorHzTimer = 0.0f;
        ClearContainers = true;
        return true;
    }
    else
    {
        ClearContainers = false;
        return false;
    }
}

References ClearContainers, SendDataEveryFrame, SensorHzFrequency, and SensorHzTimer.

Referenced by SendData().

◆ ChangeLidarParameters()

void ALidar::ChangeLidarParameters ( FLidarParameters newLidarParameters )

Change Lidar parameter for this sensor.

Parameters

newLidarParameters FLidarParameters struct

Definition at line 548 of file Lidar.cpp.

{
    if (!CanSimulateSensor())
    {
        // We are not currently simulating sensor, we can safely change parameters here
        LidarParameters = newLidarParameters;
        ChangeParameters();
    }
    else
    {
        // Change parameters at the end of the frame
        TempLidarParameters = newLidarParameters;
        LidarParametersChanged = true;
    }
}

References ASensor::CanSimulateSensor(), ChangeParameters(), LidarParameters, LidarParametersChanged, and TempLidarParameters.

◆ ChangeParameters()

void ALidar::ChangeParameters ( )

private

Change this Lidar sensor parameters

Definition at line 167 of file Lidar.cpp.

{
    // Ensure certain parameters are valid ranges
    LidarParameters.HorizontalFov = FMath::Clamp(LidarParameters.HorizontalFov, 0.1f, 360.0f);
    LidarParameters.Channels = FMath::Max(LidarParameters.Channels, 1);
    LidarParameters.DistanceNoiseStdDev = FMath::Clamp(LidarParameters.DistanceNoiseStdDev, 0.0f, 1.0f);
    LidarParameters.LateralNoiseStdDev = FMath::Clamp(LidarParameters.LateralNoiseStdDev, 0.0f, 1.0f);
 
    const int32 NumberOfLasers = LidarParameters.Channels;
 
    // Resize arrays
    PreProcessedHitImpactPoints.resize(NumberOfLasers);
    Points.resize(NumberOfLasers);
 
    // Create Lidar linetrace angles
    LaserAngles.clear();
    const float DeltaAngle = NumberOfLasers == 1u ? 0.f : (LidarParameters.UpperFovLimit - LidarParameters.LowerFovLimit) / static_cast<float>(NumberOfLasers - 1);
 
    for (int32 i = 0; i < NumberOfLasers; ++i)
    {
        const float VerticalAngle = LidarParameters.UpperFovLimit - static_cast<float>(i) * DeltaAngle;
        LaserAngles.emplace_back(VerticalAngle);
    }
 
    SendDataToROS = LidarParameters.SendDataToROS;
    SensorHzFrequency = 1.0f / LidarParameters.RotationFrequency;
    SendDataEveryFrame = !LidarParameters.SendDataAtRotationFrequency;
    
    if (LidarParameters.PointsPerSecond > 1000000)
    {
        SimulatorLog::Log("Lidar sensor: It's highly advisable to turn off VisualizePointcloud when PointsPerSecond exceed 1 million.");
 
        /*if (LidarParameters.PointsPerSecond > 2000000)
        {
            LidarParameters.VisualizePointcloud = false;
            SimulatorLog::Log("Lidar sensor: VisualizePointcloud has been set to false due PointsPerSecond exceeding 2 million.");
        }*/
    }
 
    SetVisualizeLidarParticles(LidarParameters.VisualizePointcloud);
    CreateROSTopic();
}

Referenced by ChangeLidarParameters(), Init(), and SimulateRaycastLidar().

◆ CreateLogFile()

void ALidar::CreateLogFile ( )

overrideprotectedvirtual

Create Text file for this sensor if it has not been created already. Text file will be created to ROOT/Data/Run/Logs directory. Filename will be SensorName_ID_UnixTimestamp.txt Can be overriden by individual sensor if needed.

Reimplemented from ASensor.

Definition at line 751 of file Lidar.cpp.

{
    if (IsValid(LogFile))
    {
        // File has already been created, return
        return;
    }
 
    FLogFileSettings Settings;
    Settings.FileCreationOptions = FFileCreationOptions::Overwrite;
    Settings.FileWriteOptions = FFileWriteOptions::Queue;
    Settings.QueueLength = MAX_int32; // Only write the log after destroying the sensor
    Settings.KeepFileOpen = false;
    Settings.Timestamp = false;
    Settings.OverrideFilePath = true;
    Settings.FilePath = FileSavePath;
 
    LogFile = NewObject<ULogFile>(ULogFile::StaticClass());
    if (IsValid(LogFile))
    {
        const FString FileName = "lidar_metadata";
        LogFile->Create(FileName, Settings);
 
        // Write camera metadata first line to explain the values.
        GeoReferencingSystem = AGeoReferencingSystem::GetGeoReferencingSystem(GetWorld());
        if (GeoReferencingSystem)
        {
            WriteToLogFile("timestamp, pointcloud_name, X location, Y location, Z location, yaw rotation, pitch rotation, roll rotation, GPS latitude, GPS longitude, GPS altitude");
        }
        else
        {
            WriteToLogFile("timestamp, pointcloud_name, X location, Y location, Z location, yaw rotation, pitch rotation, roll rotation");
        }
    }
}

References ULogFile::Create(), FLogFileSettings::FileCreationOptions, FLogFileSettings::FilePath, ASensor::FileSavePath, FLogFileSettings::FileWriteOptions, GeoReferencingSystem, FLogFileSettings::KeepFileOpen, ASensor::LogFile, FLogFileSettings::OverrideFilePath, Overwrite, Queue, FLogFileSettings::QueueLength, FLogFileSettings::Timestamp, and ASensor::WriteToLogFile().

Referenced by Init().

◆ EndPlay()

void ALidar::EndPlay ( const EEndPlayReason::Type EndPlayReason )

overrideprotectedvirtual

Reimplemented from ASensor.

Definition at line 118 of file Lidar.cpp.

{
    Super::EndPlay(EndPlayReason);
 
    UWorld* World = GetWorld();
 
    // Remove this lidar from LidarManager
    ALidarManager* LidarManager = UAgrarsenseStatics::GetLidarManager(World);
    if (LidarManager)
    {
        LidarManager->RemoveRaycastLidar(this);
    }
 
    // Unbind from Weather changed event
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(World);
    if (Weather)
    {
        Weather->OnWeatherChanged.RemoveDynamic(this, &ALidar::OnWeatherChanged);
    }
 
    if (NiagaraComponent)
    {
        SetNiagaraRendering(false);
 
        // Destroy component
        NiagaraComponent->UnregisterComponent();
        NiagaraComponent->DestroyComponent();
        NiagaraComponent = nullptr;
    }
 
    PointCloudMessage.Reset();
    PreProcessedHitImpactPoints.clear();
    PointsFlattened.clear();
    LaserAngles.clear();
    Points.clear();
}

References UAgrarsenseStatics::GetLidarManager(), UAgrarsenseStatics::GetWeatherActor(), LaserAngles, NiagaraComponent, OnWeatherChanged(), AWeather::OnWeatherChanged, PointCloudMessage, Points, PointsFlattened, PreProcessedHitImpactPoints, ALidarManager::RemoveRaycastLidar(), and SetNiagaraRendering().

◆ ForceClearContainers()

void ALidar::ForceClearContainers ( )

inline

Definition at line 110 of file Lidar.h.

    {
        ClearContainers = true;
    }

Referenced by ADataCapture::UpdatePositions().

◆ GetLidarParameters()

FLidarParameters ALidar::GetLidarParameters ( ) const

inline

Get current Lidar parameters

Returns: FLidarParameters struct

Definition at line 83 of file Lidar.h.

    {
        return LidarParameters;
    }

Referenced by USimulatorJsonExporter::ExportSensorToJSON().

◆ GetNiagaraComponent()

UNiagaraComponent * ALidar::GetNiagaraComponent ( ) const

inline

Retrieves the Niagara component associated with this sensor.

Returns: A pointer to the UNiagaraComponent instance associated with this sensor.

Definition at line 93 of file Lidar.h.

    {
        return NiagaraComponent;
    }

◆ GetParametersAsString()

virtual FString ALidar::GetParametersAsString ( ) const

inlineoverridevirtual

Get current LidarParameters struct fields as one string.

Reimplemented from ASensor.

Definition at line 101 of file Lidar.h.

    {
        return StructToString(LidarParameters);
    }

◆ GetSemanticData()

uint32 ALidar::GetSemanticData ( const FHitResult & HitResult ) const

private

Retrieve semantic data based on the object hit by the line trace.

Parameters

HitResult The result of the line trace indicating the object hit.

Returns: The semantic data associated with the hit object.

Definition at line 564 of file Lidar.cpp.

{
    auto* HitComponent = HitResult.Component.Get();
 
    if (HitComponent)
    {
        TArray<FName>& CompTags = HitComponent->ComponentTags;
        if (!CompTags.IsEmpty())
        {
            FName Tag = CompTags[0]; // First component tag should be the tag we want.
            FColor Color = SemanticColors.FindRef(Tag);
            return (Color.R << 16) | (Color.G << 8) | (Color.B << 0);
        }
        else
        {
            return CachedNoneColor;
        }
    }
    else
    {
        return CachedSnowflakeColor;
    }
}

References CachedNoneColor, CachedSnowflakeColor, and SemanticColors.

Referenced by ShootLaser(), and SimulateRaycastLidar().

◆ GetSensorType()

virtual ESensorTypes ALidar::GetSensorType ( ) const

inlineoverridevirtual

Get type of the sensor

Returns: Sensor's type

Reimplemented from ASensor.

Definition at line 52 of file Lidar.h.

    {
        return ESensorTypes::Lidar;
    }

References Lidar.

◆ Init()

void ALidar::Init	(	FLidarParameters	parameters,
		bool	SimulateSensor = `true`
	)

Initialize new Lidar sensor

Parameters

parameters FLidarParameters struct

Definition at line 42 of file Lidar.cpp.

{
    LidarParameters = parameters;
    SetSimulateSensor(SimulateSensor);
    ChangeParameters();
    CreateDataSavePath();
    CreateLogFile();
 
    // Initialize PointCloudMessage
    PointCloudMessage.Reset();
    PointCloudMessage = MakeShared<ROSMessages::sensor_msgs::PointCloud2>();
    PointCloudMessage->CreateDefaultPointCloud2Message();
 
    Generator.seed(RandomDevice());
}

References ChangeParameters(), ASensor::CreateDataSavePath(), CreateLogFile(), Generator, LidarParameters, PointCloudMessage, RandomDevice, and ASensor::SetSimulateSensor().

Referenced by USensorFactory::SpawnLidarSensor().

◆ OnWeatherChanged()

void ALidar::OnWeatherChanged ( FWeatherParameters WeatherParams )

private

Definition at line 155 of file Lidar.cpp.

{
    CurrentWeatherParameters = WeatherParams;
 
    // Here we recalculate SnowHeightOffset when Weather changes.
    // This is fine-tuned by hand. If the Snow implementation would change meaningfully,
    // we would need to change this implementation as well.
    // See AddSnowTerrainAdjustment() function how SnowHeightOffset is used.
    SnowHeightOffset = CurrentWeatherParameters.SnowAmount * 0.74f;
    SnowHeightOffset *= 1e-2;
}

References CurrentWeatherParameters, FWeatherParameters::SnowAmount, and SnowHeightOffset.

Referenced by BeginPlay(), and EndPlay().

◆ ResetRecordedHits()

void ALidar::ResetRecordedHits ( int32 MaxPointsPerChannel )

private

Reset and possibly re-allocate needed arrays.

Definition at line 649 of file Lidar.cpp.

{
    if (!ClearContainers)
    {
        return;
    }
 
    // Visualize Lidar particles on main thread because, 
    // in some instances NiagaraComponent crashes when updating points from background thread.
    std::vector<FPointData> CopiedPoints = PointsFlattened;
    AsyncTask(ENamedThreads::GameThread, [this, CopiedPoints]()
    {
        VisualizeLidarParticles(CopiedPoints);
    });
 
    if (!SendDataEveryFrame)
    {
        // If we only send data at Lidar sensor rotation frequency
        // reserve enough points to fill all points
        MaxPointsPerChannel = LidarParameters.PointsPerSecond / LidarParameters.Channels;
    }
 
    // Clear all containers
    if (LidarParameters.SavePointcloudWithoutNoiseModel)
    {
        for (std::vector<FPointData>& ImpactPoints : PreProcessedHitImpactPoints)
        {
            ImpactPoints.clear();
            ImpactPoints.reserve(MaxPointsPerChannel);
        }
    }
 
    for (std::vector<FPointData>& ImpactPoints : Points)
    {
        ImpactPoints.clear();
        ImpactPoints.reserve(MaxPointsPerChannel);
    }
 
    PointsFlattened.clear();
}

References FLidarParameters::Channels, ClearContainers, LidarParameters, Points, PointsFlattened, FLidarParameters::PointsPerSecond, PreProcessedHitImpactPoints, FLidarParameters::SavePointcloudWithoutNoiseModel, SendDataEveryFrame, and VisualizeLidarParticles().

Referenced by SimulateRaycastLidar().

◆ SaveCurrentPointCloudToDisk()

void ALidar::SaveCurrentPointCloudToDisk ( )

inline

Definition at line 118 of file Lidar.h.

    {
        SaveCurrentPointCloudToDiskRequested = true;
    }

Referenced by ADataCapture::CaptureDataNow().

◆ SaveDataToDisk()

void ALidar::SaveDataToDisk ( )

private

Definition at line 713 of file Lidar.cpp.

{
    if (PointsFlattened.size() == 0)
    {
        return;
    }
 
    // Save point cloud to disk
    const FString Filename = FString::Printf(TEXT("%sLidar_%d.ply"), *FileSavePath, LidarSaves);
    UPointcloudUtilities::SaveVectorArrayAsPlyAsync(Filename, PointsFlattened);
    SaveLidarMetaDataToDisk(Filename);
 
    if (NeedToSavePointCloudWithoutNoise)
    {
        // Flatten 2D std::vector to 1D std::vector
        std::vector<FPointData> PointsWithOutNoiseModel;
    
        size_t totalSize = 0;
        for (const std::vector<FPointData>& Vec : PreProcessedHitImpactPoints)
        {
            totalSize += Vec.size();
        }
        PointsWithOutNoiseModel.reserve(totalSize);
 
        for (const std::vector<FPointData>& Vec : PreProcessedHitImpactPoints)
        {
            PointsWithOutNoiseModel.insert(PointsWithOutNoiseModel.end(), Vec.begin(), Vec.end());
        }
 
        // Save pointcloud to disk without any noise
        const FString PreprocessedFilename = FString::Printf(TEXT("%sLidar_%d_without_noise_model.ply"), *FileSavePath, LidarSaves);
        UPointcloudUtilities::SaveVectorArrayAsPlyAsync(PreprocessedFilename, PointsWithOutNoiseModel);
        SaveLidarMetaDataToDisk(PreprocessedFilename);
    }
 
    ++LidarSaves;
}

References ASensor::FileSavePath, LidarSaves, NeedToSavePointCloudWithoutNoise, PointsFlattened, PreProcessedHitImpactPoints, SaveLidarMetaDataToDisk(), and UPointcloudUtilities::SaveVectorArrayAsPlyAsync().

Referenced by SendData().

◆ SaveLidarMetaDataToDisk()

void ALidar::SaveLidarMetaDataToDisk ( const FString & FileName )

protected

Definition at line 787 of file Lidar.cpp.

{
    if (!IsValid(LogFile))
    {
        // If the log file located in base class is not valid, return here.
        return;
    }
 
    const FVector ActorPosition = GetActorLocation();
    const FRotator ActorRotation = GetActorRotation();
 
    const FString TimeStamp = CreateTimeStampString();
    FString MetaData;
 
    if (GeoReferencingSystem)
    {
        FGeographicCoordinates GeoCoordinates = UCoordinateConversionUtilities::UnrealToGeographicCoordinates(GeoReferencingSystem, ActorPosition);
        MetaData = FString::Printf(TEXT("%s, %s, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.8f, %.8f, %.8f"),
            *TimeStamp, *FileName,
            ActorPosition.X, ActorPosition.Y, ActorPosition.Z,
            ActorRotation.Pitch, ActorRotation.Yaw, ActorRotation.Roll,
            GeoCoordinates.Latitude, GeoCoordinates.Longitude, GeoCoordinates.Altitude);
    }
    else
    {
        MetaData = FString::Printf(TEXT("%s, %s, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f"),
            *TimeStamp, *FileName,
            ActorPosition.X, ActorPosition.Y, ActorPosition.Z,
            ActorRotation.Pitch, ActorRotation.Yaw, ActorRotation.Roll);
    }
 
    // Write to the log file (this is written after sensor is destroyed)
    WriteToLogFile(MetaData);
}

References ASensor::CreateTimeStampString(), GeoReferencingSystem, ASensor::LogFile, UCoordinateConversionUtilities::UnrealToGeographicCoordinates(), and ASensor::WriteToLogFile().

Referenced by SaveDataToDisk().

◆ SendData()

void ALidar::SendData ( const float DeltaTime )

private

Send data to topics and save point cloud to disk if that's enabled. Before sending and saving, CanSendData is checked.

Definition at line 490 of file Lidar.cpp.

{
    if (!CanSendData(DeltaTime))
    {
        return;
    }
 
    // Preallocate PointsFlattened size
    // and fill PointsFlattened
    size_t TotalSize = 0;
    for (const std::vector<FPointData>& Vec : Points)
    {
        TotalSize += Vec.size();
    }
    PointsFlattened.reserve(TotalSize);
 
    for (std::vector<FPointData>& HitPoints : Points)
    {
        PointsFlattened.insert(PointsFlattened.end(), std::make_move_iterator(HitPoints.begin()), std::make_move_iterator(HitPoints.end()));
    }
 
    if (LidarParameters.SaveDataToDisk || SaveCurrentPointCloudToDiskRequested)
    {
        SaveDataToDisk();
 
        if (SaveCurrentPointCloudToDiskRequested) {
            SaveCurrentPointCloudToDiskRequested = false;
        }
    }
 
    if (SendDataToROS) 
    {
        SendDataToTopic(PointsFlattened);
    }
}

References CanSendData(), LidarParameters, Points, PointsFlattened, SaveCurrentPointCloudToDiskRequested, SaveDataToDisk(), FLidarParameters::SaveDataToDisk, ASensor::SendDataToROS, and SendDataToTopic().

Referenced by SimulateRaycastLidar().

◆ SendDataToTopic()

void ALidar::SendDataToTopic ( const std::vector< FPointData > & points )

private

Definition at line 690 of file Lidar.cpp.

{
    UTopic* Topic = GetROSTopic();
 
    if (!IsROSConnected()
        || !Topic
        || !SendDataToROS
        || !PointCloudMessage.IsValid()
        || points.empty())
    {
        return;
    }
 
    const size_t PointsSize = points.size();
    const size_t DataSize = PointsSize * sizeof(FPointData);
 
    PointCloudMessage->width = static_cast<uint32>(PointsSize);
    PointCloudMessage->row_step = static_cast<uint32>(DataSize);
    PointCloudMessage->data_ptr = reinterpret_cast<uint8*>(const_cast<FPointData*>(points.data()));
    PointCloudMessage->header.time = FROSTime::Now();
    Topic->Publish(PointCloudMessage);
}

References ASensor::GetROSTopic(), ASensor::IsROSConnected(), PointCloudMessage, and ASensor::SendDataToROS.

Referenced by SendData().

◆ SetNiagaraRendering()

void ALidar::SetNiagaraRendering ( bool Enabled )

private

Set Niagara component rendering on/off

Parameters

bEnabled boolean to set Niagara rendering on/off

Definition at line 215 of file Lidar.cpp.

{
    if (NiagaraComponent)
    {
        if (!Enabled)
        {
            TArray<FVector> EmptyHitpoints;
            TArray<FLinearColor> EmptyColors;
            UpdateLidarParticles(0, EmptyHitpoints, EmptyColors);
        }
 
        NiagaraComponent->SetRenderingEnabled(Enabled);
    }
}

References NiagaraComponent, and UpdateLidarParticles().

Referenced by EndPlay(), and SetVisualizeLidarParticles().

◆ SetParticleLifeTime()

void ALidar::SetParticleLifeTime ( float ParticleLifeTime )

Set Niagara particle lifetime (default 2 seconds)

Parameters

particleLifeTime new lifetime as float

Definition at line 241 of file Lidar.cpp.

{
    if (NiagaraComponent)
    {
        NiagaraComponent->SetVariableFloat(FName("User.LifeTime"), ParticleLifeTime);
    }
}

References NiagaraComponent.

Referenced by BeginPlay().

◆ SetVisualizeLidarParticles()

void ALidar::SetVisualizeLidarParticles ( bool Visualize )

Set boolean whether Lidar sensors be visualized

Parameters

bVisualize boolean to set visualization on/off

Definition at line 210 of file Lidar.cpp.

{
    SetNiagaraRendering(Visualize);
}

References SetNiagaraRendering().

Referenced by ChangeParameters().

◆ ShootLaser()

bool ALidar::ShootLaser	(	const UWorld *	World,
		FHitResult &	HitResult,
		const FVector &	EndTrace,
		const FCollisionQueryParams &	TraceParams,
		const FVector &	LidarBodyLocation,
		const int32	Channel,
		const bool	Semantic,
		const uint32	RGBDefault,
		const bool	UseLidarNoiseModel
	)

private

This function calculates the impact point of the laser shot based on provided parameters, considering the specified vertical and horizontal angles, collision parameters, Lidar body location, Lidar body rotation, and the specified range.

Returns: true if the laser shot hits a valid target, false otherwise.

Definition at line 588 of file Lidar.cpp.

{
#ifdef ParallelLineTraceSingleByChannel_EXISTS
    // Defined and implemented in our AGRARSENSE Unreal Engine fork
    // This LineTrace method doesn't block the physics scene which improves linetrace performance.
    World->ParallelLineTraceSingleByChannel(
        HitResult,
        LidarBodyLocation,
        EndTrace,
        ECC_GameTraceChannel3,
        TraceParams,
        FCollisionResponseParams::DefaultResponseParam);
#else
    // If not using our fork of the engine, use default LineTrace method.
    World->LineTraceSingleByChannel(
        HitResult,
        LidarBodyLocation,
        EndTrace,
        ECC_GameTraceChannel3,
        TraceParams,
        FCollisionResponseParams::DefaultResponseParam);
#endif
 
    bool BlockingHit = HitResult.IsValidBlockingHit();
    if (!BlockingHit && !UseLidarNoiseModel)
    {
        return false;
    }
 
    // Scale the pointcloud
    HitResult.ImpactPoint *= 1e-2;
 
    // Flip Y axis
    HitResult.ImpactPoint.Y *= -1;
 
    if (NeedToSavePointCloudWithoutNoise)
    {
        // Save Original FHitResult to separate array
        FHitResult OriginalHitResultCopy = HitResult;
        uint32 RGB = RGBDefault;
        if (Semantic)
        {
            // If Lidar is set to Semantic, set point color
            RGB = GetSemanticData(OriginalHitResultCopy);
        }
        const FVector& HitPoint = OriginalHitResultCopy.ImpactPoint;
        FPointData point = { HitPoint.X, HitPoint.Y, HitPoint.Z, RGB };
        PreProcessedHitImpactPoints[Channel].emplace_back(point);
    }
 
    if (UseLidarNoiseModel)
    {
        // Check whether we "hit" snowflake by using LUAS formula
        bool HitSnowFlake = LidarNoiseModel::CheckSnowflakeHit(HitResult, EndTrace, LidarBodyLocation, CurrentWeatherParameters);
        BlockingHit = HitResult.bBlockingHit || HitSnowFlake;
    }
 
    return BlockingHit;
}

References LidarNoiseModel::CheckSnowflakeHit(), CurrentWeatherParameters, GetSemanticData(), NeedToSavePointCloudWithoutNoise, PreProcessedHitImpactPoints, and FPointData::X.

Referenced by SimulateRaycastLidar().

◆ SimulateRaycastLidar()

std::vector< FPointData > ALidar::SimulateRaycastLidar ( const float DeltaTime )

private

Simulate this Lidar sensor. Should only be called by LidarManager.

Parameters

DeltaTime current DeltaTime

Definition at line 249 of file Lidar.cpp.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ALidar::SimulateRaycastLidar);
 
    std::vector<FPointData> HitPoints;
 
    if (!CanSimulateSensor())
    {
        return HitPoints;
    }
 
    // Get sensor position and rotation
    const FTransform& ActorTransform = GetTransform();
    const FVector LidarBodyLocation = ActorTransform.GetLocation();
    const FRotator LidarBodyRotation = ActorTransform.Rotator();
    const FQuat LidarQuat = FQuat(LidarBodyRotation);
 
    // Prepare needed variables for processing
    const int32 ChannelCount = LidarParameters.Channels;
    const int32 PointsToScanWithOneChannel = FMath::RoundHalfFromZero(LidarParameters.PointsPerSecond * DeltaTime / float(ChannelCount));
    const float HorizontalAngle = CurrentHorizontalAngle;
    const float AngleDistanceOfTick = LidarParameters.RotationFrequency * LidarParameters.HorizontalFov * DeltaTime;
    const float AngleDistanceOfLaserMeasure = AngleDistanceOfTick / PointsToScanWithOneChannel;
    const float Range = LidarParameters.Range * 100; // to meters
 
    const FColor Color = FColor(255, 255, 255);
    const int32 RgbDefault = (Color.R << 16) | (Color.G << 8) | (Color.B << 0);
 
    FCollisionQueryParams TraceParams = FCollisionQueryParams(FName(TEXT("Laser_Trace")), true, this);
    TraceParams.bReturnPhysicalMaterial = false;
    TraceParams.bReturnFaceIndex = false;
 
    // Note. can become very expensive with high vertice meshes.
    // Any very high vertice mesh should have simpler collision mesh (Tree for example)
    TraceParams.bTraceComplex = LidarParameters.UseComplexCollisionTrace;
 
    // Check if we are going to add any noise
    const bool ShouldAddNoise = (LidarParameters.UseLidarNoiseModel && CurrentWeatherParameters.IsLidarNoiseModelCondition())
        || LidarParameters.DistanceNoiseStdDev != 0.0f
        || LidarParameters.LateralNoiseStdDev != 0.0f;
 
    // Check if separate point cloud should be saved without the noise
    NeedToSavePointCloudWithoutNoise = ShouldAddNoise
        && LidarParameters.SaveDataToDisk 
        && LidarParameters.SavePointcloudWithoutNoiseModel;
 
    const bool Semantic = LidarParameters.Semantic;
    const bool UseSnowTerrainAdjustment = LidarParameters.UseTerrainSnowHitAdjustment && CurrentWeatherParameters.IsWinterSnowCondition();
    const bool NeedsExtraProcessing = UseSnowTerrainAdjustment || LidarParameters.DistanceNoiseStdDev > 0.0f || LidarParameters.LateralNoiseStdDev > 0.0f;
    const bool UseLidarNoiseModel = LidarParameters.UseLidarNoiseModel;
 
    const float HorizontalFOV = LidarParameters.HorizontalFov;
    const float HorizontalFOVHalf = HorizontalFOV / 2;
 
    const UWorld* World = GetWorld();
 
    ResetRecordedHits(PointsToScanWithOneChannel);
 
    // Loop Lidar channels in Parallel
    ParallelFor(ChannelCount, [&](int32 Channel)
    {
        std::vector<FPointData>& ChannelPoints = Points[Channel];
 
        int32 RGB = RgbDefault;
        const bool UseHorizontalNoise = FMath::RandBool();
 
        FHitResult HitResult;
 
        const float VerticalAngle = LaserAngles[Channel];
        const float VerticalRad = FMath::DegreesToRadians(VerticalAngle);
        const float VCos = FMath::Cos(VerticalRad);
        const float VSin = FMath::Sin(VerticalRad);
 
        float CurrentHorizontalAngle = HorizontalAngle;
 
        // Loop through this channel linetraces
        for (int32 i = 0; i < PointsToScanWithOneChannel; i++)
        {
            // Calculate the EndTrace point for this linetrace
            const float LaserHorizontalAngle = CurrentHorizontalAngle - HorizontalFOVHalf;
            const float HorizontalRad = FMath::DegreesToRadians(LaserHorizontalAngle);
            const FVector LocalDirection(VCos * FMath::Cos(HorizontalRad), VCos * FMath::Sin(HorizontalRad), VSin);
            const FVector EndTrace = LidarBodyLocation + Range * LidarQuat.RotateVector(LocalDirection);
 
            if (ShootLaser(World, HitResult, EndTrace, TraceParams, LidarBodyLocation, Channel, Semantic, RgbDefault, UseLidarNoiseModel))
            {
                if (Semantic)
                {
                    RGB = GetSemanticData(HitResult);
                }
 
                if (NeedsExtraProcessing)
                {
                    AddProcessingToHitResult(HitResult, LidarBodyLocation, UseHorizontalNoise, UseSnowTerrainAdjustment);
                }
 
                // Add HitResult impact point to the current channel's point list
                const FVector& HitPoint = HitResult.ImpactPoint;
                ChannelPoints.emplace_back(HitPoint.X, HitPoint.Y, HitPoint.Z, RGB);
            }
 
            CurrentHorizontalAngle += AngleDistanceOfLaserMeasure;
            if (CurrentHorizontalAngle >= HorizontalFOV) 
            {
                CurrentHorizontalAngle -= HorizontalFOV;
            }   
        }
    }, EParallelForFlags::Unbalanced);
 
    CurrentHorizontalAngle = FMath::Fmod(HorizontalAngle + AngleDistanceOfTick, LidarParameters.HorizontalFov);
 
    SendData(DeltaTime);
 
    if (LidarParametersChanged)
    {
        LidarParameters = TempLidarParameters;
        LidarParametersChanged = false;
        ChangeParameters();
    }
 
    if (ClearContainers && LidarParameters.SendDataToCombinedROSTopic)
    {
        return PointsFlattened;
    }
 
    return HitPoints;
}

References AddProcessingToHitResult(), ASensor::CanSimulateSensor(), ChangeParameters(), FLidarParameters::Channels, ClearContainers, CurrentHorizontalAngle, CurrentWeatherParameters, FLidarParameters::DistanceNoiseStdDev, GetSemanticData(), FLidarParameters::HorizontalFov, FWeatherParameters::IsLidarNoiseModelCondition(), FWeatherParameters::IsWinterSnowCondition(), LaserAngles, FLidarParameters::LateralNoiseStdDev, LidarParameters, LidarParametersChanged, NeedToSavePointCloudWithoutNoise, Points, PointsFlattened, FLidarParameters::PointsPerSecond, FLidarParameters::Range, ResetRecordedHits(), FLidarParameters::RotationFrequency, FLidarParameters::SaveDataToDisk, FLidarParameters::SavePointcloudWithoutNoiseModel, FLidarParameters::Semantic, SendData(), FLidarParameters::SendDataToCombinedROSTopic, ShootLaser(), SimulateRaycastLidar(), TempLidarParameters, FLidarParameters::UseComplexCollisionTrace, FLidarParameters::UseLidarNoiseModel, and FLidarParameters::UseTerrainSnowHitAdjustment.

Referenced by ALidarManager::SimulateLidars(), and SimulateRaycastLidar().

◆ UpdateLidarParticles()

void ALidar::UpdateLidarParticles	(	int32	NumberOfHits,
		const TArray< FVector > &	HitPoints,
		const TArray< FLinearColor > &	Colors
	)

private

Definition at line 230 of file Lidar.cpp.

{
    if (NiagaraComponent)
    {
        NiagaraComponent->SetVariableFloat(NiagaraPointsFloat, float(NumberOfHits));
        NiagaraComponent->SetVariableInt(NiagaraPointsInt, NumberOfHits);
        UNiagaraDataInterfaceArrayFunctionLibrary::SetNiagaraArrayVector(NiagaraComponent, NiagaraHitPoints, HitPoints);
        UNiagaraDataInterfaceArrayFunctionLibrary::SetNiagaraArrayColor(NiagaraComponent, NiagaraHitColors, Colors);
    }
}

References NiagaraComponent, ASensor::NiagaraHitColors, ASensor::NiagaraHitPoints, ASensor::NiagaraPointsFloat, and ASensor::NiagaraPointsInt.

Referenced by SetNiagaraRendering(), and VisualizeLidarParticles().

◆ VisualizeLidarParticles()

void ALidar::VisualizeLidarParticles ( std::vector< FPointData > HitPoints )

private

Visualize Lidar particles with Niagara particle system

Definition at line 438 of file Lidar.cpp.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ALidar::VisualizeLidarParticles);
 
    if (!LidarParameters.VisualizePointcloud || !NiagaraComponent || HitPoints.empty())
    {
        return;
    }
 
    if (GEngine && GEngine->GameViewport && GEngine->GameViewport->bDisableWorldRendering)
    {
        // If world rendering (Spectator camera) is disabled, no need to update the particle system.
        return;
    }
 
    const bool Semantic = LidarParameters.Semantic;
    const int32 NumberOfHits = HitPoints.size();
 
    TArray<FVector> HitLocations;
    HitLocations.SetNumUninitialized(NumberOfHits);
 
    TArray<FLinearColor> Colors;
    Colors.Init(FLinearColor::Green, NumberOfHits);
 
    FVector* RESTRICT HitLocationPtr = HitLocations.GetData();
    FLinearColor* RESTRICT ColorsPtr = Colors.GetData();
    const FPointData* RESTRICT HitPointPtr = HitPoints.data();
 
    for (int32 i = 0; i < NumberOfHits; ++i)
    {
        const FPointData& Point = HitPointPtr[i];
 
        HitLocationPtr[i].X = Point.X;
        HitLocationPtr[i].Y = -Point.Y;
        HitLocationPtr[i].Z = Point.Z;
 
        if (Semantic)
        {
            const uint32 RGB = Point.RGB;
            const uint8 R = (RGB >> 16) & 0xFF;
            const uint8 G = (RGB >> 8) & 0xFF;
            const uint8 B = RGB & 0xFF;
 
            ColorsPtr[i].R = R / 255.0f;
            ColorsPtr[i].G = G / 255.0f;
            ColorsPtr[i].B = B / 255.0f;
        }
    }
 
    UpdateLidarParticles(NumberOfHits, HitLocations, Colors);
}

References LidarParameters, NiagaraComponent, FPointData::RGB, FLidarParameters::Semantic, UpdateLidarParticles(), VisualizeLidarParticles(), FLidarParameters::VisualizePointcloud, FPointData::X, FPointData::Y, and FPointData::Z.

Referenced by ResetRecordedHits(), and VisualizeLidarParticles().

Friends And Related Function Documentation

◆ ALidarManager

friend class ALidarManager

friend

Definition at line 135 of file Lidar.h.

Member Data Documentation

◆ CachedNoneColor

uint32 ALidar::CachedNoneColor

private

Definition at line 292 of file Lidar.h.

Referenced by BeginPlay(), and GetSemanticData().

◆ CachedSnowflakeColor

uint32 ALidar::CachedSnowflakeColor

private

Definition at line 294 of file Lidar.h.

Referenced by BeginPlay(), and GetSemanticData().

◆ ClearContainers

bool ALidar::ClearContainers = true

private

Definition at line 298 of file Lidar.h.

Referenced by CanSendData(), ResetRecordedHits(), and SimulateRaycastLidar().

◆ CurrentHorizontalAngle

float ALidar::CurrentHorizontalAngle = 0.0f

private

Definition at line 284 of file Lidar.h.

Referenced by SimulateRaycastLidar().

◆ CurrentWeatherParameters

FWeatherParameters ALidar::CurrentWeatherParameters

private

Definition at line 261 of file Lidar.h.

Referenced by BeginPlay(), OnWeatherChanged(), ShootLaser(), and SimulateRaycastLidar().

◆ Generator

std::mt19937 ALidar::Generator

private

Definition at line 276 of file Lidar.h.

Referenced by AddDistanceNoise(), AddLateralNoise(), and Init().

◆ GeoReferencingSystem

AGeoReferencingSystem* ALidar::GeoReferencingSystem = nullptr

private

Definition at line 254 of file Lidar.h.

Referenced by CreateLogFile(), and SaveLidarMetaDataToDisk().

◆ LaserAngles

std::vector<float> ALidar::LaserAngles

private

Definition at line 273 of file Lidar.h.

Referenced by ChangeParameters(), EndPlay(), and SimulateRaycastLidar().

◆ LidarParameters

FLidarParameters ALidar::LidarParameters

private

Definition at line 257 of file Lidar.h.

Referenced by AddDistanceNoise(), AddLateralNoise(), AddProcessingToHitResult(), ChangeLidarParameters(), ChangeParameters(), Init(), ResetRecordedHits(), SendData(), SimulateRaycastLidar(), and VisualizeLidarParticles().

◆ LidarParametersChanged

bool ALidar::LidarParametersChanged = false

private

Definition at line 279 of file Lidar.h.

Referenced by ChangeLidarParameters(), and SimulateRaycastLidar().

◆ LidarSaves

int32 ALidar::LidarSaves = 0

private

Definition at line 290 of file Lidar.h.

Referenced by SaveDataToDisk().

◆ NeedToSavePointCloudWithoutNoise

bool ALidar::NeedToSavePointCloudWithoutNoise = false

private

Definition at line 278 of file Lidar.h.

Referenced by SaveDataToDisk(), ShootLaser(), and SimulateRaycastLidar().

◆ NiagaraComponent

UNiagaraComponent* ALidar::NiagaraComponent = nullptr

private

NiagaraComponent for visualizing Lidar particles. Particles are only visible on Spectator camera.

Definition at line 148 of file Lidar.h.

Referenced by BeginPlay(), EndPlay(), SetNiagaraRendering(), SetParticleLifeTime(), UpdateLidarParticles(), and VisualizeLidarParticles().

◆ PointCloudMessage

TSharedPtr<ROSMessages::sensor_msgs::PointCloud2> ALidar::PointCloudMessage

private

Definition at line 266 of file Lidar.h.

Referenced by EndPlay(), Init(), and SendDataToTopic().

◆ Points

std::vector<std::vector<FPointData> > ALidar::Points

private

Definition at line 270 of file Lidar.h.

Referenced by ChangeParameters(), EndPlay(), ResetRecordedHits(), SendData(), and SimulateRaycastLidar().

◆ PointsFlattened

std::vector<FPointData> ALidar::PointsFlattened

private

Definition at line 271 of file Lidar.h.

Referenced by EndPlay(), ResetRecordedHits(), SaveDataToDisk(), SendData(), and SimulateRaycastLidar().

◆ PreProcessedHitImpactPoints

std::vector<std::vector<FPointData> > ALidar::PreProcessedHitImpactPoints

private

Definition at line 268 of file Lidar.h.

Referenced by ChangeParameters(), EndPlay(), ResetRecordedHits(), SaveDataToDisk(), and ShootLaser().

◆ RandomDevice

std::random_device ALidar::RandomDevice

private

Definition at line 275 of file Lidar.h.

Referenced by Init().

◆ SaveCurrentPointCloudToDiskRequested

bool ALidar::SaveCurrentPointCloudToDiskRequested = false

private

Definition at line 296 of file Lidar.h.

Referenced by SendData().

◆ SemanticColors

TMap<FName, FColor> ALidar::SemanticColors

private

Definition at line 264 of file Lidar.h.

Referenced by BeginPlay(), and GetSemanticData().

◆ SendDataEveryFrame

bool ALidar::SendDataEveryFrame = false

private

Definition at line 280 of file Lidar.h.

Referenced by CanSendData(), ChangeParameters(), and ResetRecordedHits().

◆ SensorHzFrequency

float ALidar::SensorHzFrequency = 0.1f

private

Definition at line 285 of file Lidar.h.

Referenced by CanSendData(), and ChangeParameters().

◆ SensorHzTimer

float ALidar::SensorHzTimer = 0.0f

private

Definition at line 286 of file Lidar.h.

Referenced by CanSendData().

◆ SnowHeightOffset

float ALidar::SnowHeightOffset = 0.0f

private

Definition at line 288 of file Lidar.h.

Referenced by AddSnowTerrainAdjustment(), and OnWeatherChanged().

◆ TempLidarParameters

FLidarParameters ALidar::TempLidarParameters

private

Definition at line 259 of file Lidar.h.

Referenced by ChangeLidarParameters(), and SimulateRaycastLidar().

◆ TerrainTag

const FName ALidar::TerrainTag = "Terrain"

private

Definition at line 282 of file Lidar.h.

Referenced by AddSnowTerrainAdjustment().

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

Unreal/Agrarsense/Source/Agrarsense/Sensor/Lidar/Lidar.h
Unreal/Agrarsense/Source/Agrarsense/Sensor/Lidar/Lidar.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ALidar()

Member Function Documentation

◆ AddDistanceNoise()

◆ AddLateralNoise()

◆ AddProcessingToHitResult()

◆ AddSnowTerrainAdjustment()

◆ BeginPlay()

◆ CanSendData()

◆ ChangeLidarParameters()

◆ ChangeParameters()

◆ CreateLogFile()

◆ EndPlay()

◆ ForceClearContainers()

◆ GetLidarParameters()

◆ GetNiagaraComponent()

◆ GetParametersAsString()

◆ GetSemanticData()

◆ GetSensorType()

◆ Init()

◆ OnWeatherChanged()

◆ ResetRecordedHits()

◆ SaveCurrentPointCloudToDisk()

◆ SaveDataToDisk()

◆ SaveLidarMetaDataToDisk()

◆ SendData()

◆ SendDataToTopic()

◆ SetNiagaraRendering()

◆ SetParticleLifeTime()

◆ SetVisualizeLidarParticles()

◆ ShootLaser()

◆ SimulateRaycastLidar()

◆ UpdateLidarParticles()

◆ VisualizeLidarParticles()

Friends And Related Function Documentation

◆ ALidarManager

Member Data Documentation

◆ CachedNoneColor

◆ CachedSnowflakeColor

◆ ClearContainers

◆ CurrentHorizontalAngle

◆ CurrentWeatherParameters

◆ Generator

◆ GeoReferencingSystem

◆ LaserAngles

◆ LidarParameters

◆ LidarParametersChanged

◆ LidarSaves

◆ NeedToSavePointCloudWithoutNoise

◆ NiagaraComponent

◆ PointCloudMessage

◆ Points

◆ PointsFlattened

◆ PreProcessedHitImpactPoints

◆ RandomDevice

◆ SaveCurrentPointCloudToDiskRequested

◆ SemanticColors

◆ SendDataEveryFrame

◆ SensorHzFrequency

◆ SensorHzTimer

◆ SnowHeightOffset

◆ TempLidarParameters

◆ TerrainTag