#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

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

void	SetSensorName (const FString newName)

virtual 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

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

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

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

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

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

bool	ClearContainers = true

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

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

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 33 of file Lidar.h.

Constructor & Destructor Documentation

◆ ALidar()

ALidar::ALidar ( const FObjectInitializer & ObjectInitializer )

Definition at line 32 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 386 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 395 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 368 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 417 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 53 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 518 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 540 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 162 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().

◆ EndPlay()

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

overrideprotectedvirtual

Reimplemented from ASensor.

Definition at line 113 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().

◆ GetLidarParameters()

FLidarParameters ALidar::GetLidarParameters ( ) const

inline

Get current Lidar parameters

Returns: FLidarParameters struct

Definition at line 82 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 92 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 100 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 556 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 51 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 38 of file Lidar.cpp.

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

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

Referenced by USensorFactory::SpawnLidarSensor().

◆ OnWeatherChanged()

void ALidar::OnWeatherChanged ( FWeatherParameters WeatherParams )

private

Definition at line 150 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 641 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().

◆ SaveDataToDisk()

void ALidar::SaveDataToDisk ( )

private

Definition at line 704 of file Lidar.cpp.

{
    if (!LidarParameters.SaveDataToDisk)
    {
        return;
    }
 
    // Save point cloud to disk
    FString Filename = FString::Printf(TEXT("%sLidar_%d.ply"), *FileSavePath, LidarSaves);
    UPointcloudUtilities::SaveVectorArrayAsPlyAsync(Filename, PointsFlattened);
 
    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
        FString PreprocessedFilename = FString::Printf(TEXT("%sLidar_%d_without_noise_model.ply"), *FileSavePath, LidarSaves);
        UPointcloudUtilities::SaveVectorArrayAsPlyAsync(PreprocessedFilename, PointsWithOutNoiseModel);
    }
 
    ++LidarSaves;
}

References ASensor::FileSavePath, LidarParameters, LidarSaves, NeedToSavePointCloudWithoutNoise, PointsFlattened, PreProcessedHitImpactPoints, FLidarParameters::SaveDataToDisk, and UPointcloudUtilities::SaveVectorArrayAsPlyAsync().

Referenced by SendData().

◆ 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 486 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)
    {
        SaveDataToDisk();
    }
 
    if (SendDataToROS) 
    {
        SendDataToTopic(PointsFlattened);
    }
}

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

Referenced by SimulateRaycastLidar().

◆ SendDataToTopic()

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

private

Definition at line 682 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()));
    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 210 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 236 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 205 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 580 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 244 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 FMatrix LidarRotationMatrix = FRotationMatrix(FQuat(LidarBodyRotation).Rotator());
 
    // 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;
 
    // 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)
    {
        const float VerticalAngle = LaserAngles[Channel];
        int32 RGB = RgbDefault;
        FHitResult HitResult;
 
        // Generate random bool which we use later in AddLateralNoise
        const bool UseHorizontalNoise = FMath::RandBool();
 
        // Cache the reference to Points[idxChannel]
        std::vector<FPointData>& ChannelPoints = Points[Channel];
 
        // Loop through this channel linetraces
        for (int32 i = 0; i < PointsToScanWithOneChannel; i++)
        {
            //HitResult.Reset();
 
            // Calculate the EndTrace point for this linetrace
            const float LaserHorizontalAngle = std::fmod(HorizontalAngle + AngleDistanceOfLaserMeasure * i, HorizontalFOV) - HorizontalFOVHalf;
            const float VerticalRad = FMath::DegreesToRadians(VerticalAngle);
            const float HorizontalRad = FMath::DegreesToRadians(LaserHorizontalAngle);
 
            const FVector LocalDirection(FMath::Cos(VerticalRad) * FMath::Cos(HorizontalRad),
                FMath::Cos(VerticalRad) * FMath::Sin(HorizontalRad),
                FMath::Sin(VerticalRad));
 
            const FVector EndTrace = LidarBodyLocation + Range * LidarRotationMatrix.TransformVector(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);
            }
        }
    }, 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 225 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 429 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;
    }
 
    // Convert std::vector<FPointData> to 
    // TArray<FVector> and TArray<FLinearColor> for Niagara visualization.
    int32 NumberOfHits = HitPoints.size();
 
    // Create and allocate HitLocations TArray
    TArray<FVector> HitLocations;
    HitLocations.SetNumUninitialized(NumberOfHits);
 
    // Create and set initial colors to green
    TArray<FLinearColor> Colors;
    Colors.Init(FLinearColor::Green, NumberOfHits);
 
    // Pointer access for reduced overhead
    FVector* HitLocationPtr = HitLocations.GetData();
    FLinearColor* ColorsPtr = Colors.GetData();
 
    const bool Semantic = LidarParameters.Semantic;
 
    for (int32 i = 0; i < NumberOfHits; ++i)
    {
        const FPointData& point = HitPoints[i];
 
        HitLocationPtr[i].X = point.X;
        HitLocationPtr[i].Y = (point.Y * -1);
        HitLocationPtr[i].Z = point.Z;
 
        if (Semantic)
        {
            // Convert point.RGB (uint32) to FLinearColor
            uint8 R = (point.RGB >> 16) & 0xFF;
            uint8 G = (point.RGB >> 8) & 0xFF;
            uint8 B = point.RGB & 0xFF;
 
            ColorsPtr[i].R = R / 255.0f;
            ColorsPtr[i].G = G / 255.0f;
            ColorsPtr[i].B = B / 255.0f;
            //ColorsPtr[i].A = 1.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 113 of file Lidar.h.

Member Data Documentation

◆ CachedNoneColor

uint32 ALidar::CachedNoneColor

private

Definition at line 268 of file Lidar.h.

Referenced by BeginPlay(), and GetSemanticData().

◆ CachedSnowflakeColor

uint32 ALidar::CachedSnowflakeColor

private

Definition at line 270 of file Lidar.h.

Referenced by BeginPlay(), and GetSemanticData().

◆ ClearContainers

bool ALidar::ClearContainers = true

private

Definition at line 256 of file Lidar.h.

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

◆ CurrentHorizontalAngle

float ALidar::CurrentHorizontalAngle = 0.0f

private

Definition at line 260 of file Lidar.h.

Referenced by SimulateRaycastLidar().

◆ CurrentWeatherParameters

FWeatherParameters ALidar::CurrentWeatherParameters

private

Definition at line 236 of file Lidar.h.

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

◆ Generator

std::mt19937 ALidar::Generator

private

Definition at line 251 of file Lidar.h.

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

◆ LaserAngles

std::vector<float> ALidar::LaserAngles

private

Definition at line 248 of file Lidar.h.

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

◆ LidarParameters

FLidarParameters ALidar::LidarParameters

private

Definition at line 232 of file Lidar.h.

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

◆ LidarParametersChanged

bool ALidar::LidarParametersChanged = false

private

Definition at line 254 of file Lidar.h.

Referenced by ChangeLidarParameters(), and SimulateRaycastLidar().

◆ LidarSaves

int32 ALidar::LidarSaves = 0

private

Definition at line 266 of file Lidar.h.

Referenced by SaveDataToDisk().

◆ NeedToSavePointCloudWithoutNoise

bool ALidar::NeedToSavePointCloudWithoutNoise = false

private

Definition at line 253 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 126 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 241 of file Lidar.h.

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

◆ Points

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

private

Definition at line 245 of file Lidar.h.

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

◆ PointsFlattened

std::vector<FPointData> ALidar::PointsFlattened

private

Definition at line 246 of file Lidar.h.

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

◆ PreProcessedHitImpactPoints

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

private

Definition at line 243 of file Lidar.h.

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

◆ RandomDevice

std::random_device ALidar::RandomDevice

private

Definition at line 250 of file Lidar.h.

Referenced by Init().

◆ SemanticColors

TMap<FName, FColor> ALidar::SemanticColors

private

Definition at line 239 of file Lidar.h.

Referenced by BeginPlay(), and GetSemanticData().

◆ SendDataEveryFrame

bool ALidar::SendDataEveryFrame = false

private

Definition at line 255 of file Lidar.h.

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

◆ SensorHzFrequency

float ALidar::SensorHzFrequency = 0.1f

private

Definition at line 261 of file Lidar.h.

Referenced by CanSendData(), and ChangeParameters().

◆ SensorHzTimer

float ALidar::SensorHzTimer = 0.0f

private

Definition at line 262 of file Lidar.h.

Referenced by CanSendData().

◆ SnowHeightOffset

float ALidar::SnowHeightOffset = 0.0f

private

Definition at line 264 of file Lidar.h.

Referenced by AddSnowTerrainAdjustment(), and OnWeatherChanged().

◆ TempLidarParameters

FLidarParameters ALidar::TempLidarParameters

private

Definition at line 234 of file Lidar.h.

Referenced by ChangeLidarParameters(), and SimulateRaycastLidar().

◆ TerrainTag

const FName ALidar::TerrainTag = "Terrain"

private

Definition at line 258 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()

◆ EndPlay()

◆ GetLidarParameters()

◆ GetNiagaraComponent()

◆ GetParametersAsString()

◆ GetSemanticData()

◆ GetSensorType()

◆ Init()

◆ OnWeatherChanged()

◆ ResetRecordedHits()

◆ SaveDataToDisk()

◆ SendData()

◆ SendDataToTopic()

◆ SetNiagaraRendering()

◆ SetParticleLifeTime()

◆ SetVisualizeLidarParticles()

◆ ShootLaser()

◆ SimulateRaycastLidar()

◆ UpdateLidarParticles()

◆ VisualizeLidarParticles()

Friends And Related Function Documentation

◆ ALidarManager

Member Data Documentation

◆ CachedNoneColor

◆ CachedSnowflakeColor

◆ ClearContainers

◆ CurrentHorizontalAngle

◆ CurrentWeatherParameters

◆ Generator

◆ LaserAngles

◆ LidarParameters

◆ LidarParametersChanged

◆ LidarSaves

◆ NeedToSavePointCloudWithoutNoise

◆ NiagaraComponent

◆ PointCloudMessage

◆ Points

◆ PointsFlattened

◆ PreProcessedHitImpactPoints

◆ RandomDevice

◆ SemanticColors

◆ SendDataEveryFrame

◆ SensorHzFrequency

◆ SensorHzTimer

◆ SnowHeightOffset

◆ TempLidarParameters

◆ TerrainTag