UROSCommands Class Reference

#include <ROSCommands.h>

Inheritance diagram for UROSCommands:

Collaboration diagram for UROSCommands:

Public Member Functions
void	TryExecuteCommand (const FString &Command)

Private Member Functions
void	Init ()
void	Destroy ()
UWorld *	GetGameWorld ()
UAgrarsenseSettings *	GetSettings ()
void	AddCommands ()
void	SetupROSCommandTopic ()
void	DestroyROSTopic ()
void	ParseIncomingMessage (const FString Message)
void	ROSBridgeStateChanged (EROSState state)
bool	TryParseBoolean (const FString &String, bool &OutBool) const
void	HandlePrintAvailableCommands (const FString &Variable)
void	HandleQuit (const FString &Variable)
void	HandlePauseSimulator (const FString &Variable)
void	HandleUnPauseSimulator (const FString &Variable)
void	HandleAdvanceOneFrame (const FString &Variable)
void	HandleAdvanceFrames (const FString &Variable)
void	HandleAdvanceTime (const FString &Variable)
void	HandleChangeMap (const FString &Variable)
void	HandleUnrealCommand (const FString &Variable)
void	HandleSetSpectatorOverlapRadius (const FString &Variable)
void	HandleTeleportSpectatorHeight (const FString &Variable)
void	HandleTeleportSpectator (const FString &Variable)
void	HandleTeleportActorByID (const FString &Variable)
void	HandleTeleportActorByIDHeight (const FString &Variable)
void	HandleTeleportSpectatorByInstanceID (const FString &Variable)
void	HandleTryDestroyObjectByID (const FString &Variable)
void	HandleDestroyAllSensors (const FString &Variable)
void	HandleDestroyAllWalkers (const FString &Variable)
void	HandleDestroyAllVehicles (const FString &Variable)
void	HandleDestroyObjectByInstanceID (const FString &Variable)
void	HandlePrintMaps (const FString &Variable)
void	HandlePrintAllSensors (const FString &Variable)
void	HandlePrintAllVehicles (const FString &Variable)
void	HandlePrintAllWalkers (const FString &Variable)
void	PrintActorInformation (const FString &Variable, UClass *ActorClass, const FString &ActorTypeName)
void	HandlePrintIds (const FString &Variable)
void	HandleSetGlobalTargetFrameRate (const FString &Variable)
void	HandleSetGlobalTimeDilation (const FString &Variable)
void	HandleSetQualityLevel (const FString &Variable)
void	HandleSetWorldRendering (const FString &Variable)
void	HandleSetGrassVisibility (const FString &Variable)
void	HandleSetSaveCombinedPointcloudToDisk (const FString &Variable)
void	HandleSpawnObjects (const FString &Variable)
void	HandleExportAll (const FString &Variable)
void	HandleExportWeather (const FString &Variable)
void	HandleExportWalkers (const FString &Variable)
void	HandleExportVehicles (const FString &Variable)
void	HandleExportSensors (const FString &Variable)
void	HandleExportFoliage (const FString &Variable)
void	HandleExportObjects (const FString &Variable)
void	HandleExportProps (const FString &Variable)
void	HandleVisualizeOverlapSensorsBounds (const FString &Variable)
void	HandleChangeOverlapSensorBounds (const FString &Variable)
void	HandleChangeOverlapSensorPosition (const FString &Variable)
void	HandleMoveWalkerToAndDestroy (const FString &Variable)
void	HandleMoveWalkerToAndStop (const FString &Variable)
void	HandleMoveWalkerTo (const FString &Variable, EWalkerEndAction EndAction)
void	HandleStopWalker (const FString &Variable)
void	HandleResumeWalker (const FString &Variable)
void	HandleSetWalkerMovement (const FString &Variable, bool IsPaused)
void	HandleResetDrone (const FString &Variable)
void	HandleMoveDroneTo (const FString &Variable, EDroneEndAction EndAction)
void	HandleMoveDroneToAndStop (const FString &Variable)
void	HandleSetAllSensorsEnabled (const FString &Variable)
void	HandleEnableAllSensors (const FString &Variable)
void	HandleDisableAllSensors (const FString &Variable)
void	HandleSetSensorEnabled (const FString &Variable)
void	HandleSetWPO (const FString &Variable)
void	HandleSetNaniteMaxPixelsPerEdge (const FString &Variable)
void	HandleDestroyTreesArea (const FString &Variable)
void	HandleDestroyActorsArea (const FString &Variable)
void	HandleDestroyActors (const FString &Variable, bool OnlyTrees)
void	HandleVehicleMeshVisibility (const FString &Variable)

Private Attributes
UTopic *	CommandTopic = nullptr
UROSIntegrationGameInstance *	RosInstance = nullptr
bool	InMeters = false
bool	TeleportSpectatorHeight = false

Static Private Attributes
static TMap< FString, FCommand >	CommandHandlers

Friends
class	AAgrarsenseGameModeBase

Detailed Description

Definition at line 47 of file ROSCommands.h.

Member Function Documentation

AddCommands()

void UROSCommands::AddCommands ( )

private

Definition at line 84 of file ROSCommands.cpp.

{
    // To call from Terminal (note all in lower case)
    // rostopic pub /agrarsense/in/commands std_msgs/String "{COMMAND} {VARIABLE}" --once
    // rostopic pub /agrarsense/in/commands std_msgs/String "help" --once
 
    if (!CommandHandlers.IsEmpty())
    {
        return;
    }
 
    
    // General commands
    CommandHandlers.Add(TEXT("help"), FCommand(&UROSCommands::HandlePrintAvailableCommands, 0.1f, "Print all commands"));
    CommandHandlers.Add(TEXT("quit"), FCommand(&UROSCommands::HandleQuit, 1.0f, "Quits the Simulator"));
    CommandHandlers.Add(TEXT("loadmap"), FCommand(&UROSCommands::HandleChangeMap, 5.0f, TEXT("load map by name")));
    CommandHandlers.Add(TEXT("unrealcommand"), FCommand(&UROSCommands::HandleUnrealCommand, 0.05f, TEXT("Execute Unreal engine console command")));
 
    // Pause commands
    CommandHandlers.Add(TEXT("pause"), FCommand(&UROSCommands::HandlePauseSimulator, 0.01f, "Pauses the Simulator after current frame has finished"));
    CommandHandlers.Add(TEXT("unpause"), FCommand(&UROSCommands::HandleUnPauseSimulator, 0.01f, "Un pauses the Simulator immediately upon receiving the message"));
    CommandHandlers.Add(TEXT("nextframe"), FCommand(&UROSCommands::HandleAdvanceOneFrame, 0.01f, "Advance one frame"));
    CommandHandlers.Add(TEXT("advanceframes"), FCommand(&UROSCommands::HandleAdvanceFrames, 0.01f, "Advance given amount of frames"));
    CommandHandlers.Add(TEXT("advancetime"), FCommand(&UROSCommands::HandleAdvanceTime, 0.01f, "Advance given amount of time in seconds"));
 
    // Teleport commands
    CommandHandlers.Add(TEXT("teleportspectator"), FCommand(&UROSCommands::HandleTeleportSpectator, 0.03f, TEXT("x,y,z or x,y,z,yaw,pitch,roll")));
    CommandHandlers.Add(TEXT("teleportspectatorheight"), FCommand(&UROSCommands::HandleTeleportSpectatorHeight, 0.03f, TEXT("x,y,z or x,y,z,yaw,pitch,roll")));
    CommandHandlers.Add(TEXT("teleportbyid"), FCommand(&UROSCommands::HandleTeleportActorByID, 0.03f, TEXT("ID of Actor, x,y,z or x,y,z,yaw,pitch,roll")));
    CommandHandlers.Add(TEXT("teleportSpectatorToInstanceID"), FCommand(&UROSCommands::HandleTeleportSpectatorByInstanceID, 0.03f, TEXT("Instance ID")));
    CommandHandlers.Add(TEXT("teleportbyidheight"), FCommand(&UROSCommands::HandleTeleportActorByIDHeight, 0.05f, TEXT("ID of Actor, x,y,z or x,y,z,yaw,pitch,roll")));
 
    // Destroy commands
    CommandHandlers.Add(TEXT("destroyobjectbyid"), FCommand(&UROSCommands::HandleTryDestroyObjectByID, 0.05f, TEXT("Try to destroy object by id")));
    CommandHandlers.Add(TEXT("destroyallsensors"), FCommand(&UROSCommands::HandleDestroyAllSensors, 1.0f, TEXT("Destroy all sensors")));
    CommandHandlers.Add(TEXT("destroyallwalkers"), FCommand(&UROSCommands::HandleDestroyAllWalkers, 1.0f, TEXT("Destroy all sensors")));
    CommandHandlers.Add(TEXT("destroyallvehicles"), FCommand(&UROSCommands::HandleDestroyAllVehicles, 1.0f, TEXT("Destroy all sensors")));
 
    CommandHandlers.Add(TEXT("destroyobjectbyinstanceid"), FCommand(&UROSCommands::HandleDestroyObjectByInstanceID, 1.0f, TEXT("id")));
 
    // Volume commands
    // ex. "destroytrees 0,0,0 300,300,300" - destroys all tree actors within certain box area.
    // ex. "destroyassets 0,0,0 300,300,300" - destroys all Instanced actors within certain box area.
    CommandHandlers.Add(TEXT("destroytreesarea"), FCommand(&UROSCommands::HandleDestroyTreesArea, 0.05f, TEXT("x,y,z sizeX,sizeY,sizeZ")));
    CommandHandlers.Add(TEXT("destroyassetsarea"), FCommand(&UROSCommands::HandleDestroyActorsArea, 0.05f, TEXT("x,y,z sizeX,sizeY,sizeZ")));
 
    // Print commands
    CommandHandlers.Add(TEXT("getmaps"), FCommand(&UROSCommands::HandlePrintMaps, 0.5f, TEXT("Print all available maps")));
    CommandHandlers.Add(TEXT("getsensors"), FCommand(&UROSCommands::HandlePrintAllSensors, 0.1f, TEXT("Print all sensors information")));
    CommandHandlers.Add(TEXT("getvehicles"), FCommand(&UROSCommands::HandlePrintAllVehicles, 0.1f, TEXT("Print all vehicles information")));
    CommandHandlers.Add(TEXT("getwalkers"), FCommand(&UROSCommands::HandlePrintMaps, 0.1f, TEXT("print all walkers information")));
    CommandHandlers.Add(TEXT("getids"), FCommand(&UROSCommands::HandlePrintIds, 0.1f, TEXT("print all ids")));
 
    // Set commands
    CommandHandlers.Add(TEXT("setglobaltargetframeRate"), FCommand(&UROSCommands::HandleSetGlobalTargetFrameRate, 1.0f, TEXT("0 - 300")));
    CommandHandlers.Add(TEXT("setglobaltimedilation"), FCommand(&UROSCommands::HandleSetGlobalTimeDilation, 1.0f, TEXT("0.0f - 10.0f")));
    CommandHandlers.Add(TEXT("setqualityLevel"), FCommand(&UROSCommands::HandleSetQualityLevel, 1.0f, TEXT("low / ultra")));
    CommandHandlers.Add(TEXT("setworldrendering"), FCommand(&UROSCommands::HandleSetWorldRendering, 0.05f, TEXT("true / false")));
    CommandHandlers.Add(TEXT("setgrassvisibility"), FCommand(&UROSCommands::HandleSetGrassVisibility, 0.05f, TEXT("true / false")));
    CommandHandlers.Add(TEXT("setsavecombinedpointcloud"), FCommand(&UROSCommands::HandleSetSaveCombinedPointcloudToDisk, 0.05f, TEXT("true / false")));
    CommandHandlers.Add(TEXT("setwpodistance"), FCommand(&UROSCommands::HandleSetWPO, 0.5f, TEXT("Set WPO render distance in cm")));
    CommandHandlers.Add(TEXT("setnanitemaxpixelsperedge"), FCommand(&UROSCommands::HandleSetNaniteMaxPixelsPerEdge, 0.5f, TEXT("Set Nanite max pixels per edge")));
    CommandHandlers.Add(TEXT("setspectatoroverlapradius"), FCommand(&UROSCommands::HandleSetSpectatorOverlapRadius, 0.05f, TEXT("radius in meters")));
    
    // Sensor commands
    CommandHandlers.Add(TEXT("setallsensorsenabled"), FCommand(&UROSCommands::HandleSetAllSensorsEnabled, 1.0f, TEXT("true / false")));
    CommandHandlers.Add(TEXT("enableallsensors"), FCommand(&UROSCommands::HandleEnableAllSensors, 1.0f, TEXT("true / false")));
    CommandHandlers.Add(TEXT("disableallsensors"), FCommand(&UROSCommands::HandleDisableAllSensors, 1.0f, TEXT("true / false")));
    CommandHandlers.Add(TEXT("setsensorenabled"), FCommand(&UROSCommands::HandleSetSensorEnabled, 1.0f, TEXT("ID true/false")));
 
    // Spawn/change objects commands. They all call the same function. They are defined separately for clarity.
    CommandHandlers.Add(TEXT("spawn"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("Spawn objects from JSON file")));
    CommandHandlers.Add(TEXT("load"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("Spawn objects from JSON file")));
    CommandHandlers.Add(TEXT("loadjson"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("Spawn objects from JSON file")));
    CommandHandlers.Add(TEXT("spawnobjects"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("Spawn objects from JSON file")));
    CommandHandlers.Add(TEXT("changeweather"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("change weather from JSON file")));
    CommandHandlers.Add(TEXT("changecolors"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("change semantic colors from JSON file")));
 
    // Exports
    CommandHandlers.Add(TEXT("exportall"), FCommand(&UROSCommands::HandleExportAll, 1.0f, TEXT("Export all spanwed things to JSON file")));
    CommandHandlers.Add(TEXT("exportweather"), FCommand(&UROSCommands::HandleExportWeather, 1.0f, TEXT("Export current weather to JSON file")));
    CommandHandlers.Add(TEXT("exportwalkers"), FCommand(&UROSCommands::HandleExportWalkers, 1.0f, TEXT("Export all Walkers to JSON file")));
    CommandHandlers.Add(TEXT("exportvehicles"), FCommand(&UROSCommands::HandleExportVehicles, 1.0f, TEXT("Export all Vehicles to JSON file")));
    CommandHandlers.Add(TEXT("exportsensors"), FCommand(&UROSCommands::HandleExportSensors, 1.0f, TEXT("Export all Sensors to JSON file")));
    CommandHandlers.Add(TEXT("exportprops"), FCommand(&UROSCommands::HandleExportProps, 1.0f, TEXT("Export all props to JSON file")));
    CommandHandlers.Add(TEXT("exportfoliage"), FCommand(&UROSCommands::HandleExportFoliage, 1.0f, TEXT("Export all Foliage to JSON file")));
    CommandHandlers.Add(TEXT("exportobjects"), FCommand(&UROSCommands::HandleExportObjects, 1.0f, TEXT("Export all object locations to CSV file")));
    
    // Overlap sensor commands
    // changeoverlapbounds format: 'setoverlapradiusbyid sensor_id 25'
    // changeoverlapposition format: 'setoverlappositionbyid sensor_id 0,0,0'
    CommandHandlers.Add(TEXT("visualizeoverlaps"), FCommand(&UROSCommands::HandleVisualizeOverlapSensorsBounds, 0.05f, TEXT("true/false: Visualize all Overlap sensors")));
    CommandHandlers.Add(TEXT("setoverlapradiusbyid"), FCommand(&UROSCommands::HandleChangeOverlapSensorBounds, 0.05f, TEXT("ID float: change overlap sensor radius by actor id")));
    CommandHandlers.Add(TEXT("setoverlappositionbyid"), FCommand(&UROSCommands::HandleChangeOverlapSensorPosition, 0.05f, TEXT("ID float, float, float: Change Overlap sensor relative position")));
 
    // Walker commands
    CommandHandlers.Add(TEXT("movewalkerto"), FCommand(&UROSCommands::HandleMoveWalkerToAndStop, 0.05f, TEXT("ID (position or position,rotation)")));
    CommandHandlers.Add(TEXT("movewalkertoanddestroy"), FCommand(&UROSCommands::HandleMoveWalkerToAndDestroy, 0.05f, TEXT("ID (position or position,rotation)")));
    CommandHandlers.Add(TEXT("stopwalker"), FCommand(&UROSCommands::HandleStopWalker, 0.05f, TEXT("ID of the Walker")));
    CommandHandlers.Add(TEXT("resumewalker"), FCommand(&UROSCommands::HandleResumeWalker, 0.05f, TEXT("ID of the Walker")));
 
    // Vehicle commands
    CommandHandlers.Add(TEXT("setvehiclemeshvisibility"), FCommand(&UROSCommands::HandleVehicleMeshVisibility, 0.05f, TEXT("ID true/false")));
 
    // Drone commands
    CommandHandlers.Add(TEXT("movedroneto"), FCommand(&UROSCommands::HandleMoveDroneToAndStop, 0.05f, TEXT("ID (position)")));
    CommandHandlers.Add(TEXT("resetdrone"), FCommand(&UROSCommands::HandleResetDrone, 0.15f, TEXT("Drone ID")));
}

References CommandHandlers, HandleAdvanceFrames(), HandleAdvanceOneFrame(), HandleAdvanceTime(), HandleChangeMap(), HandleChangeOverlapSensorBounds(), HandleChangeOverlapSensorPosition(), HandleDestroyActorsArea(), HandleDestroyAllSensors(), HandleDestroyAllVehicles(), HandleDestroyAllWalkers(), HandleDestroyObjectByInstanceID(), HandleDestroyTreesArea(), HandleDisableAllSensors(), HandleEnableAllSensors(), HandleExportAll(), HandleExportFoliage(), HandleExportObjects(), HandleExportProps(), HandleExportSensors(), HandleExportVehicles(), HandleExportWalkers(), HandleExportWeather(), HandleMoveDroneToAndStop(), HandleMoveWalkerToAndDestroy(), HandleMoveWalkerToAndStop(), HandlePauseSimulator(), HandlePrintAllSensors(), HandlePrintAllVehicles(), HandlePrintAvailableCommands(), HandlePrintIds(), HandlePrintMaps(), HandleQuit(), HandleResetDrone(), HandleResumeWalker(), HandleSetAllSensorsEnabled(), HandleSetGlobalTargetFrameRate(), HandleSetGlobalTimeDilation(), HandleSetGrassVisibility(), HandleSetNaniteMaxPixelsPerEdge(), HandleSetQualityLevel(), HandleSetSaveCombinedPointcloudToDisk(), HandleSetSensorEnabled(), HandleSetSpectatorOverlapRadius(), HandleSetWorldRendering(), HandleSetWPO(), HandleSpawnObjects(), HandleStopWalker(), HandleTeleportActorByID(), HandleTeleportActorByIDHeight(), HandleTeleportSpectator(), HandleTeleportSpectatorByInstanceID(), HandleTeleportSpectatorHeight(), HandleTryDestroyObjectByID(), HandleUnPauseSimulator(), HandleUnrealCommand(), HandleVehicleMeshVisibility(), and HandleVisualizeOverlapSensorsBounds().

Referenced by Init().

Destroy()

void UROSCommands::Destroy ( )

private

Definition at line 59 of file ROSCommands.cpp.

{
    DestroyROSTopic();
}

References DestroyROSTopic().

Referenced by AAgrarsenseGameModeBase::EndPlay().

DestroyROSTopic()

void UROSCommands::DestroyROSTopic ( )

private

Definition at line 208 of file ROSCommands.cpp.

{
    if (CommandTopic)
    {
        CommandTopic->Unadvertise();
        CommandTopic->Unsubscribe();
        CommandTopic->MarkAsDisconnected();
        CommandTopic->ConditionalBeginDestroy();
        CommandTopic = nullptr;
    }
}

References CommandTopic.

Referenced by Destroy(), and ROSBridgeStateChanged().

GetGameWorld()

UWorld * UROSCommands::GetGameWorld ( )

private

Definition at line 69 of file ROSCommands.cpp.

{
    UWorld* World = nullptr;
    if (GEngine && GEngine->GameViewport)
    {
        World = GEngine->GameViewport->GetWorld();
    }
    return World;
}

Referenced by HandleDestroyActors(), HandleDestroyAllSensors(), HandleDestroyAllVehicles(), HandleDestroyObjectByInstanceID(), HandleDisableAllSensors(), HandleEnableAllSensors(), HandleExportObjects(), HandleExportSensors(), HandleExportWeather(), HandleQuit(), HandleSetAllSensorsEnabled(), HandleSetSaveCombinedPointcloudToDisk(), HandleSetSpectatorOverlapRadius(), HandleTeleportSpectator(), HandleTeleportSpectatorByInstanceID(), HandleUnrealCommand(), HandleVisualizeOverlapSensorsBounds(), Init(), PrintActorInformation(), and SetupROSCommandTopic().

GetSettings()

UAgrarsenseSettings * UROSCommands::GetSettings ( )

private

Definition at line 79 of file ROSCommands.cpp.

{
    return UAgrarsenseStatics::GetAgrarsenseSettings();
}

References UAgrarsenseStatics::GetAgrarsenseSettings().

Referenced by HandleAdvanceFrames(), HandleAdvanceOneFrame(), HandleAdvanceTime(), HandleChangeMap(), HandlePauseSimulator(), HandlePrintMaps(), HandleSetGlobalTargetFrameRate(), HandleSetGlobalTimeDilation(), HandleSetGrassVisibility(), HandleSetNaniteMaxPixelsPerEdge(), HandleSetQualityLevel(), HandleSetWorldRendering(), HandleSetWPO(), and HandleUnPauseSimulator().

HandleAdvanceFrames()

void UROSCommands::HandleAdvanceFrames ( const FString &  Variable )

private

Definition at line 391 of file ROSCommands.cpp.

{
    int32 FrameCount = 0;
    if (!Variable.IsNumeric())
    {
        return;
    }
 
    FrameCount = FCString::Atoi(*Variable);
    if (FrameCount != 0) 
    {
        UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
        if (AgrarsenseSettings)
        {
            AgrarsenseSettings->AdvanceFrameCount(FrameCount);
        }
    }
}

References UAgrarsenseSettings::AdvanceFrameCount(), and GetSettings().

Referenced by AddCommands().

HandleAdvanceOneFrame()

void UROSCommands::HandleAdvanceOneFrame ( const FString &  Variable )

private

Definition at line 382 of file ROSCommands.cpp.

{
    UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
    if (AgrarsenseSettings)
    {
        AgrarsenseSettings->AdvanceFrameCount(1);
    }
}

References UAgrarsenseSettings::AdvanceFrameCount(), and GetSettings().

Referenced by AddCommands().

HandleAdvanceTime()

void UROSCommands::HandleAdvanceTime ( const FString &  Variable )

private

Definition at line 410 of file ROSCommands.cpp.

{
    float Time = 0.0f;
    if (!Variable.IsNumeric())
    {
        return;
    }
 
    Time = FCString::Atof(*Variable);
    if (Time != 0.0f)
    {
        UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
        if (AgrarsenseSettings)
        {
            AgrarsenseSettings->AdvanceTime(Time);
        }
    }
}

References UAgrarsenseSettings::AdvanceTime(), and GetSettings().

Referenced by AddCommands().

HandleChangeMap()

void UROSCommands::HandleChangeMap ( const FString &  Variable )

private

Definition at line 429 of file ROSCommands.cpp.

{
    UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
    if (AgrarsenseSettings)
    {
        AgrarsenseSettings->ChangeMapByName(Variable);
    }
}

References UAgrarsenseSettings::ChangeMapByName(), and GetSettings().

Referenced by AddCommands().

HandleChangeOverlapSensorBounds()

void UROSCommands::HandleChangeOverlapSensorBounds ( const FString &  Variable )

private

Definition at line 1038 of file ROSCommands.cpp.

{
    FString ID;
    FString BoundsString;
 
    TArray<FString> Tokens;
    Variable.ParseIntoArray(Tokens, TEXT(" "), true);
 
    if (Tokens.Num() < 2)
    {
        // Incoming parameters were invalid, return
        return;
    }
 
    ID = Tokens[0];
    BoundsString = Tokens[1];
 
    if (BoundsString.IsNumeric())
    {
        float Radius = FCString::Atof(*BoundsString);
 
        AActor* Actor = IActorInformation::GetActorByID(ID);
        AOverlapSensor* Sensor = Cast<AOverlapSensor>(Actor);
        if (Sensor)
        {
            Sensor->SetOverlapBounds(FVector(Radius, Radius, Radius));
        }
    }
}

References IActorInformation::GetActorByID(), and AOverlapSensor::SetOverlapBounds().

Referenced by AddCommands().

HandleChangeOverlapSensorPosition()

void UROSCommands::HandleChangeOverlapSensorPosition ( const FString &  Variable )

private

Definition at line 1068 of file ROSCommands.cpp.

{
    FString ID;
    FString BoundsString;
 
    TArray<FString> Tokens;
    Variable.ParseIntoArray(Tokens, TEXT(" "), true);
 
    if (Tokens.Num() < 2)
    {
        // Incoming parameters were invalid, return
        return;
    }
 
    ID = Tokens[0];
    BoundsString = Tokens[1];
 
    FVector RelativePosition;
    TArray<FString> BoundsTokens;
    BoundsString.ParseIntoArray(BoundsTokens, TEXT(","), true);
 
    if (BoundsTokens.Num() >= 3)
    {
        RelativePosition.X = FCString::Atof(*BoundsTokens[0]);
        RelativePosition.Y = FCString::Atof(*BoundsTokens[1]);
        RelativePosition.Z = FCString::Atof(*BoundsTokens[2]);
 
        AActor* Actor = IActorInformation::GetActorByID(ID);
        AOverlapSensor* Sensor = Cast<AOverlapSensor>(Actor);
        if (Sensor)
        {
            Sensor->SetOverlapRelativePosition(RelativePosition);
        }
    }
}

References IActorInformation::GetActorByID(), and AOverlapSensor::SetOverlapRelativePosition().

Referenced by AddCommands().

HandleDestroyActors()

void UROSCommands::HandleDestroyActors ( const FString &  Variable, bool  OnlyTrees  )

private

Definition at line 1418 of file ROSCommands.cpp.

{
    TArray<FString> ParsedStrings;
    Variable.ParseIntoArray(ParsedStrings, TEXT(" "), true);
 
    if (ParsedStrings.Num() != 2)
    {
        return;
    }
 
    // Parse position
    TArray<FString> PositionComponents;
    ParsedStrings[0].ParseIntoArray(PositionComponents, TEXT(","), true);
 
    if (PositionComponents.Num() != 3)
    {
        return;
    }
 
    FVector Position(FCString::Atof(*PositionComponents[0]), FCString::Atof(*PositionComponents[1]), FCString::Atof(*PositionComponents[2]));
 
    // Parse bounds
    TArray<FString> BoundsComponents;
    ParsedStrings[1].ParseIntoArray(BoundsComponents, TEXT(","), true);
 
    if (BoundsComponents.Num() != 3)
    {
        return;
    }
 
    FVector Bounds(FCString::Atof(*BoundsComponents[0]), FCString::Atof(*BoundsComponents[1]), FCString::Atof(*BoundsComponents[2]));
 
    FTransform VolumeTransform;
    VolumeTransform.SetLocation(Position);
 
    UWorld* World = GetGameWorld();
    if (World)
    {
        ADeletionVolume* Volume = World->SpawnActor<ADeletionVolume>(ADeletionVolume::StaticClass(), VolumeTransform);
        if (Volume)
        {
            // Change volume bounds
            Volume->ChangeOverlapBounds(Bounds);
 
            // Destroy overlapping actors, 
            // this Actor gets deleted automatically after calling this.
            Volume->DestroyOverlappingActors(OnlyTrees);
        }
    }
}

References ADeletionVolume::ChangeOverlapBounds(), ADeletionVolume::DestroyOverlappingActors(), and GetGameWorld().

Referenced by HandleDestroyActorsArea(), and HandleDestroyTreesArea().

HandleDestroyActorsArea()

void UROSCommands::HandleDestroyActorsArea ( const FString &  Variable )

private

Definition at line 1413 of file ROSCommands.cpp.

{
    HandleDestroyActors(Variable, false);
}

References HandleDestroyActors().

Referenced by AddCommands().

HandleDestroyAllSensors()

void UROSCommands::HandleDestroyAllSensors ( const FString &  Variable )

private

Definition at line 673 of file ROSCommands.cpp.

{
    USensorUtilities::DestroyAllSensors(GetGameWorld());
}

References USensorUtilities::DestroyAllSensors(), and GetGameWorld().

Referenced by AddCommands().

HandleDestroyAllVehicles()

void UROSCommands::HandleDestroyAllVehicles ( const FString &  Variable )

private

Definition at line 683 of file ROSCommands.cpp.

{
    UWorld* World = GetGameWorld();
    if (!World)
    {
        return;
    }
 
    TArray<AActor*> Vehicles;
    UGameplayStatics::GetAllActorsOfClass(World, AVehicle::StaticClass(), Vehicles);
    for (AActor* Actor : Vehicles)
    {
        AVehicle* Vehicle = Cast<AVehicle>(Actor);
        if (Vehicle)
        {
            Vehicle->Destroy();
        }
    }
}

References GetGameWorld(), and Vehicle.

Referenced by AddCommands().

HandleDestroyAllWalkers()

void UROSCommands::HandleDestroyAllWalkers ( const FString &  Variable )

private

Definition at line 678 of file ROSCommands.cpp.

{
    UAssetLibrary::DestroyAllWalkers();
}

References UAssetLibrary::DestroyAllWalkers().

Referenced by AddCommands().

HandleDestroyObjectByInstanceID()

void UROSCommands::HandleDestroyObjectByInstanceID ( const FString &  Variable )

private

Definition at line 703 of file ROSCommands.cpp.

{
    TArray<FString> Parts;
    Variable.TrimStartAndEnd().ParseIntoArrayWS(Parts);
 
    if (Parts.Num() < 2)
    {
        return;
    }
 
    int32 LabelIndex = 0;
    int32 InstanceID = 0;
 
    if (!LexTryParseString(LabelIndex, *Parts[0]) || !LexTryParseString(InstanceID, *Parts[1]))
    {
        return;
    }
 
    TArray<AActor*> Taggers;
    UGameplayStatics::GetAllActorsOfClass(GetGameWorld(), ATagger::StaticClass(), Taggers);
    ATagger* Tagger = Cast<ATagger>(Taggers[0]);
 
    if (Tagger)
    {
        AActor* Actor = Tagger->TryGetActorByInstanceID(LabelIndex, InstanceID);
        if (Actor)
        {
            Actor->Destroy();
        }
    }
}

References GetGameWorld(), and ATagger::TryGetActorByInstanceID().

Referenced by AddCommands().

HandleDestroyTreesArea()

void UROSCommands::HandleDestroyTreesArea ( const FString &  Variable )

private

Definition at line 1408 of file ROSCommands.cpp.

{
    HandleDestroyActors(Variable, true);
}

References HandleDestroyActors().

Referenced by AddCommands().

HandleDisableAllSensors()

void UROSCommands::HandleDisableAllSensors ( const FString &  Variable )

private

Definition at line 1341 of file ROSCommands.cpp.

{
    USensorUtilities::DisableAllSensors(GetGameWorld());
}

References USensorUtilities::DisableAllSensors(), and GetGameWorld().

Referenced by AddCommands().

HandleEnableAllSensors()

void UROSCommands::HandleEnableAllSensors ( const FString &  Variable )

private

Definition at line 1336 of file ROSCommands.cpp.

{
    USensorUtilities::EnableAllSensors(GetGameWorld());
}

References USensorUtilities::EnableAllSensors(), and GetGameWorld().

Referenced by AddCommands().

HandleExportAll()

void UROSCommands::HandleExportAll ( const FString &  Variable )

private

Definition at line 900 of file ROSCommands.cpp.

{
    // Below export functions do not need any incoming variable but require FString
    FString EmptyString;
 
    HandleExportWeather(EmptyString);
    HandleExportWalkers(EmptyString);
 
    // HandleExportSensors exports vehicles as well
    //HandleExportVehicles(EmptyString); 
    HandleExportSensors(EmptyString);
 
    HandleExportFoliage(EmptyString);
    HandleExportProps(EmptyString);
}

References HandleExportFoliage(), HandleExportProps(), HandleExportSensors(), HandleExportWalkers(), and HandleExportWeather().

Referenced by AddCommands().

HandleExportFoliage()

void UROSCommands::HandleExportFoliage ( const FString &  Variable )

private

Definition at line 983 of file ROSCommands.cpp.

{
    TArray<AInstancedActor*> FoliageActors = UAssetLibrary::GetAllAddedFoliageActors();
    USimulatorJsonExporter::ExportInstancedActorsToJSON("ExportedFoliage", FoliageActors);
}

References USimulatorJsonExporter::ExportInstancedActorsToJSON(), and UAssetLibrary::GetAllAddedFoliageActors().

Referenced by AddCommands(), and HandleExportAll().

HandleExportObjects()

void UROSCommands::HandleExportObjects ( const FString &  Variable )

private

Definition at line 989 of file ROSCommands.cpp.

{
    UWorld* World = GetGameWorld();
    if (!World)
    {
        return;
    }
 
    TArray<AActor*> Taggers;
    UGameplayStatics::GetAllActorsOfClass(World, ATagger::StaticClass(), Taggers);
    
    if (ATagger* Tagger = Cast<ATagger>(Taggers[0])) 
    {
        Tagger->ExportObjectLocationsToCSV();
    }
}

References GetGameWorld().

Referenced by AddCommands().

HandleExportProps()

void UROSCommands::HandleExportProps ( const FString &  Variable )

private

Definition at line 1006 of file ROSCommands.cpp.

{
    TArray<AInstancedActor*> PropActors = UAssetLibrary::GetAllAddedPropActors();
    USimulatorJsonExporter::ExportInstancedActorsToJSON("ExportedProps", PropActors);
}

References USimulatorJsonExporter::ExportInstancedActorsToJSON(), and UAssetLibrary::GetAllAddedPropActors().

Referenced by AddCommands(), and HandleExportAll().

HandleExportSensors()

void UROSCommands::HandleExportSensors ( const FString &  Variable )

private

Definition at line 950 of file ROSCommands.cpp.

{
    UWorld* World = GetGameWorld();
    if (!World)
    {
        return;
    }
 
    // Export all Vehicles and attached sensors
    TArray<AActor*> Vehicles;
    UGameplayStatics::GetAllActorsOfClass(World, AVehicle::StaticClass(), Vehicles);
    for (AActor* Actor : Vehicles)
    {
        AVehicle* VehiclePtr = Cast<AVehicle>(Actor);
        if (VehiclePtr)
        {
            VehiclePtr->ExportToJsonFile("ExportedVehicle");
        }
    }
 
    // Export all Sensors separately as well
    TArray<AActor*> Sensors;
    UGameplayStatics::GetAllActorsOfClass(World, ASensor::StaticClass(), Sensors);
    for (AActor* Actor : Sensors)
    {
        ASensor* SensorPtr = Cast<ASensor>(Actor);
        if (SensorPtr)
        {
            SensorPtr->ExportToJsonFile("ExportedSensor");
        }
    }
}

References ASensor::ExportToJsonFile(), AVehicle::ExportToJsonFile(), GetGameWorld(), and Sensors.

Referenced by AddCommands(), and HandleExportAll().

HandleExportVehicles()

void UROSCommands::HandleExportVehicles ( const FString &  Variable )

private

Definition at line 937 of file ROSCommands.cpp.

{
    TArray<FVehicleData> Vehicles = UAssetLibrary::GetSpawnedVehicles();
    for (const FVehicleData& VehicleData : Vehicles)
    {
        AVehicle* VehiclePtr = VehicleData.Vehicle.Get();
        if (VehiclePtr)
        {
            VehiclePtr->ExportToJsonFile("ExportedVehicle");
        }
    }
}

References AVehicle::ExportToJsonFile(), and UAssetLibrary::GetSpawnedVehicles().

Referenced by AddCommands().

HandleExportWalkers()

void UROSCommands::HandleExportWalkers ( const FString &  Variable )

private

Definition at line 925 of file ROSCommands.cpp.

{
    TArray<AWalker*> Walkers = UAssetLibrary::GetAllWalkers();
    for (AWalker* Walker : Walkers)
    {
        if (Walker)
        {
            Walker->ExportToJsonFile("ExportedWalker");
        }
    }
}

References UAssetLibrary::GetAllWalkers(), and Walker.

Referenced by AddCommands(), and HandleExportAll().

HandleExportWeather()

void UROSCommands::HandleExportWeather ( const FString &  Variable )

private

Definition at line 916 of file ROSCommands.cpp.

{
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(GetGameWorld());
    if (Weather)
    {
        Weather->ExportToJSON("ExportedWeather");
    }
}

References AWeather::ExportToJSON(), GetGameWorld(), and UAgrarsenseStatics::GetWeatherActor().

Referenced by AddCommands(), and HandleExportAll().

HandleMoveDroneTo()

void UROSCommands::HandleMoveDroneTo ( const FString &  Variable, EDroneEndAction  EndAction  )

private

Definition at line 1238 of file ROSCommands.cpp.

{
    // This function overrides the current parameters of the Drone identified by the given ID,
    // moving the Drone to the specified x,y,z position and stopping upon reaching the target.
    // Usage: "movedroneto drone 0,0,0" where 'drone' is the Drone ID.
 
    FString ID;
    FString TransformString;
 
    // Split the ID and rest of the message
    TArray<FString> Tokens;
    Variable.ParseIntoArray(Tokens, TEXT(" "), true);
    if (Tokens.Num() >= 2)
    {
        ID = Tokens[0];
        TransformString = Variable.RightChop(ID.Len() + 1);
    }
    else
    {
        return;
    }
 
    // Check if this ID matches any Actor
    AActor* Actor = IActorInformation::GetActorByID(ID);
    if (!Actor)
    {
        return;
    }
 
    APIDDrone* Drone = Cast<APIDDrone>(Actor);
    if (!Drone)
    {
        return;
    }
 
    // Parse rest of the string to Transform
    TArray<FString> Components;
    TransformString.ParseIntoArray(Components, TEXT(","), true);
 
    if (Components.Num() >= 3)
    {
        FVector Location;
        FQuat Rotation;
 
        // Convert the first three components to float values for location
        float X = FCString::Atof(*Components[0]);
        float Y = FCString::Atof(*Components[1]);
        float Z = FCString::Atof(*Components[2]);
 
        Location = FVector(X, Y, Z);
 
        if (Components.Num() >= 6)
        {
            // If there are six or more components, try to parse them as rotation values
            float Pitch = FCString::Atof(*Components[3]);
            float Yaw = FCString::Atof(*Components[4]);
            float Roll = FCString::Atof(*Components[5]);
 
            // Convert the Euler angles to a quaternion
            Rotation = FQuat(FRotator(Pitch, Yaw, Roll));
        }
 
        FTransform Transform;
        Transform.SetLocation(Location);
        Transform.SetRotation(Rotation);
 
        // Create new drone parameters
        FDroneParameters NewParams;
        NewParams.DroneAction = EDroneAction::Roaming;
        NewParams.DroneEndAction = EndAction;
        //NewParams.Points.Add(Transform);
 
        Drone->ChangeDroneParameters(NewParams);
 
        // Change drone parameters
        Drone->MoveDroneToPosition(Transform);
    }
}

References Drone, FDroneParameters::DroneAction, FDroneParameters::DroneEndAction, IActorInformation::GetActorByID(), Roaming, and Transform.

Referenced by HandleMoveDroneToAndStop().

HandleMoveDroneToAndStop()

void UROSCommands::HandleMoveDroneToAndStop ( const FString &  Variable )

private

Definition at line 1114 of file ROSCommands.cpp.

{
    HandleMoveDroneTo(Variable, EDroneEndAction::Stop);
}

References HandleMoveDroneTo(), and Stop.

Referenced by AddCommands().

HandleMoveWalkerTo()

void UROSCommands::HandleMoveWalkerTo ( const FString &  Variable, EWalkerEndAction  EndAction  )

private

Definition at line 1119 of file ROSCommands.cpp.

{
    // This function overrides the current parameters of the Walker identified by the given ID,
    // moving the Walker to the specified x,y,z position and stopping upon reaching the target.
    // Usage: "movewalkerto reindeer 0,0,0" where 'reindeer' is the Walker ID.
 
    FString ID;
    FString TransformString;
 
    // Split the ID and rest of the message
    TArray<FString> Tokens;
    Variable.ParseIntoArray(Tokens, TEXT(" "), true);
    if (Tokens.Num() >= 2)
    {
        ID = Tokens[0];
        TransformString = Variable.RightChop(ID.Len() + 1);
    }
    else
    {
        return;
    }
 
    // Check if this ID matches any Actor
    AActor* Actor = IActorInformation::GetActorByID(ID);
    if (!Actor)
    {
        return;
    }
 
    AWalker* Walker = Cast<AWalker>(Actor);
    if (!Walker)
    {
        return;
    }
 
    // Parse rest of the string to Transform
    TArray<FString> Components;
    TransformString.ParseIntoArray(Components, TEXT(","), true);
 
    if (Components.Num() >= 3)
    {
        FVector Location;
        FQuat Rotation;
 
        // Convert the first three components to float values for location
        float X = FCString::Atof(*Components[0]);
        float Y = FCString::Atof(*Components[1]);
        float Z = FCString::Atof(*Components[2]);
 
        Location = FVector(X, Y, Z);
 
        if (Components.Num() >= 6)
        {
            // If there are six or more components, try to parse them as rotation values
            float Pitch = FCString::Atof(*Components[3]);
            float Yaw = FCString::Atof(*Components[4]);
            float Roll = FCString::Atof(*Components[5]);
 
            // Convert the Euler angles to a quaternion
            Rotation = FQuat(FRotator(Pitch, Yaw, Roll));
        }
 
        FTransform Transform;
        Transform.SetLocation(Location);
        Transform.SetRotation(Rotation);
 
        // Create new walker parameters
        FWalkerParameters NewParams;
        NewParams.WalkerAction = EWalkerAction::FollowPath;
        NewParams.WalkerEndAction = EndAction;
        NewParams.Points.Add(Transform);
 
        // Change Walker parameters
        Walker->ChangeWalkerParameters(NewParams);
    }
}

References FollowPath, IActorInformation::GetActorByID(), FWalkerParameters::Points, Transform, Walker, FWalkerParameters::WalkerAction, and FWalkerParameters::WalkerEndAction.

Referenced by HandleMoveWalkerToAndDestroy(), and HandleMoveWalkerToAndStop().

HandleMoveWalkerToAndDestroy()

void UROSCommands::HandleMoveWalkerToAndDestroy ( const FString &  Variable )

private

Definition at line 1104 of file ROSCommands.cpp.

{
    HandleMoveWalkerTo(Variable, EWalkerEndAction::Destroy);
}

References Destroy, and HandleMoveWalkerTo().

Referenced by AddCommands().

HandleMoveWalkerToAndStop()

void UROSCommands::HandleMoveWalkerToAndStop ( const FString &  Variable )

private

Definition at line 1109 of file ROSCommands.cpp.

{
    HandleMoveWalkerTo(Variable, EWalkerEndAction::Stop);
}

References HandleMoveWalkerTo(), and Stop.

Referenced by AddCommands().

HandlePauseSimulator()

void UROSCommands::HandlePauseSimulator ( const FString &  Variable )

private

Definition at line 364 of file ROSCommands.cpp.

{
    UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
    if (AgrarsenseSettings)
    {
        AgrarsenseSettings->PauseSimulationEndOfThisFrame();
    }
}

References GetSettings(), and UAgrarsenseSettings::PauseSimulationEndOfThisFrame().

Referenced by AddCommands().

HandlePrintAllSensors()

void UROSCommands::HandlePrintAllSensors ( const FString &  Variable )

private

Definition at line 753 of file ROSCommands.cpp.

{
    PrintActorInformation(Variable, ASensor::StaticClass(), "sensor");
}

References PrintActorInformation().

Referenced by AddCommands().

HandlePrintAllVehicles()

void UROSCommands::HandlePrintAllVehicles ( const FString &  Variable )

private

Definition at line 758 of file ROSCommands.cpp.

{
    PrintActorInformation(Variable, AVehicle::StaticClass(), "vehicle");
}

References PrintActorInformation().

Referenced by AddCommands().

HandlePrintAllWalkers()

void UROSCommands::HandlePrintAllWalkers ( const FString &  Variable )

private

Definition at line 763 of file ROSCommands.cpp.

{
    PrintActorInformation(Variable, AWalker::StaticClass(), "walker");
}

References PrintActorInformation().

HandlePrintAvailableCommands()

void UROSCommands::HandlePrintAvailableCommands ( const FString &  Variable )

private

Definition at line 329 of file ROSCommands.cpp.

{
    if (!CommandTopic)
    {
        return;
    }
 
    FString message = "Available Simulator ROS commands {COMMAND} {VALUE} || ";
 
    for (const TPair<FString, FCommand>& CommandPair : CommandHandlers)
    {
        const FString& CommandString = CommandPair.Key;
        const FCommand& CommandInfo = CommandPair.Value;
        if (CommandInfo.DefaultValue.IsEmpty())
        {
            message += FString::Printf(TEXT("%s || "), *CommandString);
        }
        else
        {
            message += FString::Printf(TEXT("%s %s || "), *CommandString, *CommandInfo.DefaultValue);
        }
    }
 
    SimulatorLog::Log(message);
}

References CommandHandlers, CommandTopic, FCommand::DefaultValue, and SimulatorLog::Log().

Referenced by AddCommands().

HandlePrintIds()

void UROSCommands::HandlePrintIds ( const FString &  Variable )

private

Definition at line 807 of file ROSCommands.cpp.

{
    IActorInformation::PrintAllIds();
}

References IActorInformation::PrintAllIds().

Referenced by AddCommands().

HandlePrintMaps()

void UROSCommands::HandlePrintMaps ( const FString &  Variable )

private

Definition at line 735 of file ROSCommands.cpp.

{
    UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
    if (AgrarsenseSettings)
    {
        TArray<FString> Maps = AgrarsenseSettings->GetMapNames();
 
        FString message;
 
        for (const FString& map : Maps)
        {
            message += FString::Printf(TEXT("%s, "), *map);
        }
 
        SimulatorLog::Log(message);
    }
}

References UAgrarsenseSettings::GetMapNames(), GetSettings(), and SimulatorLog::Log().

Referenced by AddCommands().

HandleQuit()

void UROSCommands::HandleQuit ( const FString &  Variable )

private

Definition at line 355 of file ROSCommands.cpp.

{
    UWorld* World = GetGameWorld();
    if (GEngine && World)
    {
        GEngine->Exec(World, TEXT("quit force"));
    }
}

References GetGameWorld().

Referenced by AddCommands().

HandleResetDrone()

void UROSCommands::HandleResetDrone ( const FString &  Variable )

private

Definition at line 1225 of file ROSCommands.cpp.

{
    AActor* Actor = IActorInformation::GetActorByID(Variable);
    if (Actor)
    {
        APIDDrone* Drone = Cast<APIDDrone>(Actor);
        if (Drone)
        {
            Drone->ResetDroneEvent();
        }
    }
}

References Drone, and IActorInformation::GetActorByID().

Referenced by AddCommands().

HandleResumeWalker()

void UROSCommands::HandleResumeWalker ( const FString &  Variable )

private

Definition at line 1201 of file ROSCommands.cpp.

{
    HandleSetWalkerMovement(Variable, false);
}

References HandleSetWalkerMovement().

Referenced by AddCommands().

HandleSetAllSensorsEnabled()

void UROSCommands::HandleSetAllSensorsEnabled ( const FString &  Variable )

private

Definition at line 1317 of file ROSCommands.cpp.

{
    bool EnableSensors;
    if (!TryParseBoolean(Variable, EnableSensors))
    {
        // Failed to parse, return
        return;
    }
 
    if (EnableSensors)
    {
        USensorUtilities::EnableAllSensors(GetGameWorld());
    }
    else 
    {
        USensorUtilities::DisableAllSensors(GetGameWorld());
    }
}

References USensorUtilities::DisableAllSensors(), USensorUtilities::EnableAllSensors(), GetGameWorld(), and TryParseBoolean().

Referenced by AddCommands().

HandleSetGlobalTargetFrameRate()

void UROSCommands::HandleSetGlobalTargetFrameRate ( const FString &  Variable )

private

Definition at line 812 of file ROSCommands.cpp.

{
    if (Variable.IsNumeric())
    {
        UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
        if (AgrarsenseSettings)
        {
            int32 IntValue = FCString::Atoi(*Variable);
            AgrarsenseSettings->SetGlobalTargetFrameRate(IntValue);
        }
    }
}

References GetSettings(), and UAgrarsenseSettings::SetGlobalTargetFrameRate().

Referenced by AddCommands().

HandleSetGlobalTimeDilation()

void UROSCommands::HandleSetGlobalTimeDilation ( const FString &  Variable )

private

Definition at line 825 of file ROSCommands.cpp.

{
    if (Variable.IsNumeric())
    {
        UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
        if (AgrarsenseSettings)
        {
            float FloatValue = FCString::Atof(*Variable);
            AgrarsenseSettings->SetGlobalTimeDilation(FloatValue);
        }
    }
}

References GetSettings(), and UAgrarsenseSettings::SetGlobalTimeDilation().

Referenced by AddCommands().

HandleSetGrassVisibility()

void UROSCommands::HandleSetGrassVisibility ( const FString &  Variable )

private

Definition at line 863 of file ROSCommands.cpp.

{
    bool RenderGrass;
    if (!TryParseBoolean(Variable, RenderGrass))
    {
        // Failed to parse, return
        return;
    }
 
    UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
    if (AgrarsenseSettings)
    {
        AgrarsenseSettings->SetGrassVisibility(RenderGrass);
    }
}

References GetSettings(), UAgrarsenseSettings::SetGrassVisibility(), and TryParseBoolean().

Referenced by AddCommands().

HandleSetNaniteMaxPixelsPerEdge()

void UROSCommands::HandleSetNaniteMaxPixelsPerEdge ( const FString &  Variable )

private

Definition at line 1395 of file ROSCommands.cpp.

{
    if (Variable.IsNumeric())
    {
        UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
        if (AgrarsenseSettings)
        {
            float Value = FCString::Atof(*Variable);
            AgrarsenseSettings->SetNaniteMaxPixelsPerEdge(Value);
        }
    }
}

References GetSettings(), and UAgrarsenseSettings::SetNaniteMaxPixelsPerEdge().

Referenced by AddCommands().

HandleSetQualityLevel()

void UROSCommands::HandleSetQualityLevel ( const FString &  Variable )

private

Definition at line 838 of file ROSCommands.cpp.

{
    UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
    if (AgrarsenseSettings)
    {
        AgrarsenseSettings->SetQualityLevelFromString(Variable);
    }
}

References GetSettings(), and UAgrarsenseSettings::SetQualityLevelFromString().

Referenced by AddCommands().

HandleSetSaveCombinedPointcloudToDisk()

void UROSCommands::HandleSetSaveCombinedPointcloudToDisk ( const FString &  Variable )

private

Definition at line 879 of file ROSCommands.cpp.

{
    bool Save;
    if (!TryParseBoolean(Variable, Save))
    {
        // Failed to parse, return
        return;
    }
 
    ALidarManager* LidarManager = UAgrarsenseStatics::GetLidarManager(GetGameWorld());
    if (LidarManager)
    {
        LidarManager->SetSaveCombinedCloudToDisk(Save);
    }
}

References GetGameWorld(), UAgrarsenseStatics::GetLidarManager(), ALidarManager::SetSaveCombinedCloudToDisk(), and TryParseBoolean().

Referenced by AddCommands().

HandleSetSensorEnabled()

void UROSCommands::HandleSetSensorEnabled ( const FString &  Variable )

private

Definition at line 1346 of file ROSCommands.cpp.

{
    TArray<FString> Tokens;
    Variable.ParseIntoArray(Tokens, TEXT(" "), true);
    if (Tokens.Num() < 2)
    {
        // Not enough arguments, return
        return;
    }
 
    const FString& ID = Tokens[0];
 
    AActor* Actor = IActorInformation::GetActorByID(ID);
    if (!Actor)
    {
        return;
    }
 
    ASensor* Sensor = Cast<ASensor>(Actor);
    if (!Sensor)
    {
        return;
    }
 
    FString BooleanString = Tokens[1].ToLower();
 
    bool SimulateSensor;
    if (!TryParseBoolean(BooleanString, SimulateSensor))
    {
        // Failed to parse, return
        return;
    }
 
    Sensor->SetSimulateSensor(SimulateSensor);
}

References IActorInformation::GetActorByID(), ASensor::SetSimulateSensor(), and TryParseBoolean().

Referenced by AddCommands().

HandleSetSpectatorOverlapRadius()

void UROSCommands::HandleSetSpectatorOverlapRadius ( const FString &  Variable )

private

Definition at line 447 of file ROSCommands.cpp.

{
    if (!Variable.IsNumeric()) 
    {
        return;
    }
 
    float Radius = FCString::Atof(*Variable);
 
    if (UWorld* World = GetGameWorld())
    {
        if (ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World))
        {
            if (AOverlapSensor* OverlapSensor = Spectator->GetOverlapSensor()) 
            {
                OverlapSensor->SetOverlapBounds(FVector(Radius, Radius, Radius));
            }
        }
    }
}

References GetGameWorld(), and UAgrarsenseStatics::GetSpectator().

Referenced by AddCommands().

HandleSetWalkerMovement()

void UROSCommands::HandleSetWalkerMovement ( const FString &  Variable, bool  IsPaused  )

private

Definition at line 1206 of file ROSCommands.cpp.

{
    AActor* Actor = IActorInformation::GetActorByID(Variable);
    AWalker* Walker = Cast<AWalker>(Actor);
    if (!Walker)
    {
        return;
    }
 
    if (IsPaused) 
    {
        Walker->PauseWalker();
    }
    else 
    {
        Walker->ResumeWalker();
    }
}

References IActorInformation::GetActorByID(), and Walker.

Referenced by HandleResumeWalker(), and HandleStopWalker().

HandleSetWorldRendering()

void UROSCommands::HandleSetWorldRendering ( const FString &  Variable )

private

Definition at line 847 of file ROSCommands.cpp.

{
    bool RenderWorld;
    if (!TryParseBoolean(Variable, RenderWorld))
    {
        // Failed to parse, return
        return;
    }
 
    UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
    if (AgrarsenseSettings)
    {
        AgrarsenseSettings->SetWorldRendering(RenderWorld);
    }
}

References GetSettings(), UAgrarsenseSettings::SetWorldRendering(), and TryParseBoolean().

Referenced by AddCommands().

HandleSetWPO()

void UROSCommands::HandleSetWPO ( const FString &  Variable )

private

Definition at line 1382 of file ROSCommands.cpp.

{
    if (Variable.IsNumeric())
    {
        UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
        if (AgrarsenseSettings)
        {
            int32 IntValue = FCString::Atoi(*Variable);
            AgrarsenseSettings->SetWorldPositionOffsetRenderDistance(IntValue);
        }
    }
}

References GetSettings(), and UAgrarsenseSettings::SetWorldPositionOffsetRenderDistance().

Referenced by AddCommands().

HandleSpawnObjects()

void UROSCommands::HandleSpawnObjects ( const FString &  Variable )

private

Definition at line 895 of file ROSCommands.cpp.

{
    USimulatorJsonParser::ParseAndOperateJSONFile(Variable);
}

References USimulatorJsonParser::ParseAndOperateJSONFile().

Referenced by AddCommands().

HandleStopWalker()

void UROSCommands::HandleStopWalker ( const FString &  Variable )

private

Definition at line 1196 of file ROSCommands.cpp.

{
    HandleSetWalkerMovement(Variable, true);
}

References HandleSetWalkerMovement().

Referenced by AddCommands().

HandleTeleportActorByID()

void UROSCommands::HandleTeleportActorByID ( const FString &  Variable )

private

Definition at line 568 of file ROSCommands.cpp.

{
    FString ID;
    FString TransformString;
 
    // Split the ID and rest of the message
    TArray<FString> Tokens;
    Variable.ParseIntoArray(Tokens, TEXT(" "), true);
    if (Tokens.Num() >= 2)
    {
        ID = Tokens[0];
        TransformString = Variable.RightChop(ID.Len() + 1);
    }
    else
    {
        SimulatorLog::Log("Invalid input. Input should be in format: ID,X,Y,Z or ID,X,Y,Z,YAW,PITCH,ROLL");
        return;
    }
 
    // Check if this ID matches any Actor
    AActor* Actor = IActorInformation::GetActorByID(ID);
    if (!Actor)
    {
        FString log = FString::Printf(TEXT("Could not find Actor with ID: %s"), *ID);
        SimulatorLog::Log(log);
        return;
    }
 
    // Parse rest of the string to Transform
    TArray<FString> Components;
    TransformString.ParseIntoArray(Components, TEXT(","), true);
 
    if (Components.Num() >= 3)
    {
        FVector Location;
        FQuat Rotation;
 
        // Convert the first three components to float values for location
        float X = FCString::Atof(*Components[0]);
        float Y = FCString::Atof(*Components[1]);
        float Z = FCString::Atof(*Components[2]);
 
        Location = FVector(X, Y, Z);
 
        if (Components.Num() >= 6)
        {
            // If there are six or more components, try to parse them as rotation values
            float Pitch = FCString::Atof(*Components[3]);
            float Yaw = FCString::Atof(*Components[4]);
            float Roll = FCString::Atof(*Components[5]);
 
            // Convert the Euler angles to a quaternion
            Rotation = FQuat(FRotator(Pitch, Yaw, Roll));
        }
 
        FTransform Transform;
        Transform.SetLocation(Location);
        Transform.SetRotation(Rotation);
 
        if (InMeters)
        {
            UPhysicsUtilities::AlignTransformFromGroundInMeters(Actor, Transform);
        }
 
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("Teleporting Actor with ID: %s to: %s"), *ID, *TransformString);
#endif
 
        // Check if this Actor is Vehicle
        AVehicle* VehiclePtr = Cast<AVehicle>(Actor);
        if (VehiclePtr)
        {
            // Disable vehicle physics so it can be teleported
            VehiclePtr->TogglePhysics(false);
 
            Actor->SetActorTransform(Transform);
 
            // Enable vehicle physics back on after teleporting vehicle
            VehiclePtr->TogglePhysics(true);
        }
        else
        {
            // Else set the Actor transform
            Actor->SetActorTransform(Transform);
        }
    }
}

References UPhysicsUtilities::AlignTransformFromGroundInMeters(), IActorInformation::GetActorByID(), InMeters, SimulatorLog::Log(), AVehicle::TogglePhysics(), and Transform.

Referenced by AddCommands(), and HandleTeleportActorByIDHeight().

HandleTeleportActorByIDHeight()

void UROSCommands::HandleTeleportActorByIDHeight ( const FString &  Variable )

private

Definition at line 526 of file ROSCommands.cpp.

{
    InMeters = true;
    HandleTeleportActorByID(Variable);
    InMeters = false;
}

References HandleTeleportActorByID(), and InMeters.

Referenced by AddCommands().

HandleTeleportSpectator()

void UROSCommands::HandleTeleportSpectator ( const FString &  Variable )

private

Definition at line 475 of file ROSCommands.cpp.

{
    // Split the comma-separated string into components
    TArray<FString> Components;
    Variable.ParseIntoArray(Components, TEXT(","), true);
 
    if (Components.Num() >= 3)
    {
        FVector Location;
        FQuat Rotation;
 
        // Convert the first three components to float values for location
        float X = FCString::Atof(*Components[0]);
        float Y = FCString::Atof(*Components[1]);
        float Z = FCString::Atof(*Components[2]);
 
        Location = FVector(X, Y, Z);
 
        if (Components.Num() >= 6)
        {
            // If there are six or more components, try to parse them as rotation values
            float Pitch = FCString::Atof(*Components[3]);
            float Yaw = FCString::Atof(*Components[4]);
            float Roll = FCString::Atof(*Components[5]);
 
            // Convert the Euler angles to a quaternion
            Rotation = FQuat(FRotator(Pitch, Yaw, Roll));
        }
 
        UWorld* World = GetGameWorld();
        if (World)
        {
            ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World);
            if (Spectator)
            {
                FTransform Transform;
                Transform.SetLocation(Location);
                Transform.SetRotation(Rotation);
 
 
                if (TeleportSpectatorHeight)
                {
                    UPhysicsUtilities::AlignTransformFromGroundInMeters(Cast<AActor>(Spectator), Transform);
                }
 
                Spectator->TeleportSpectator(Transform);
            }
        }
    }
}

References UPhysicsUtilities::AlignTransformFromGroundInMeters(), GetGameWorld(), UAgrarsenseStatics::GetSpectator(), ASpectator::TeleportSpectator(), TeleportSpectatorHeight, and Transform.

Referenced by AddCommands(), and HandleTeleportSpectatorHeight().

HandleTeleportSpectatorByInstanceID()

void UROSCommands::HandleTeleportSpectatorByInstanceID ( const FString &  Variable )

private

Definition at line 533 of file ROSCommands.cpp.

{
    TArray<FString> Parts;
    Variable.TrimStartAndEnd().ParseIntoArrayWS(Parts);
 
    if (Parts.Num() < 2)
    {
        return;
    }
 
    int32 LabelIndex = 0;
    int32 InstanceID = 0;
 
    if (!LexTryParseString(LabelIndex, *Parts[0]) || !LexTryParseString(InstanceID, *Parts[1]))
    {
        return;
    }
 
    TArray<AActor*> Taggers;
    UGameplayStatics::GetAllActorsOfClass(GetGameWorld(), ATagger::StaticClass(), Taggers);
    ATagger* Tagger = Cast<ATagger>(Taggers[0]);
 
    if (Tagger) 
    {
        AActor* Actor = Tagger->TryGetActorByInstanceID(LabelIndex, InstanceID);
        if (Actor) 
        {
            if (ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(GetGameWorld()))
            {
                Spectator->TeleportSpectator(Actor->GetActorTransform());
            }
        }
    }
}

References GetGameWorld(), UAgrarsenseStatics::GetSpectator(), and ATagger::TryGetActorByInstanceID().

Referenced by AddCommands().

HandleTeleportSpectatorHeight()

void UROSCommands::HandleTeleportSpectatorHeight ( const FString &  Variable )

private

Definition at line 468 of file ROSCommands.cpp.

{
    TeleportSpectatorHeight = true;
    HandleTeleportSpectator(Variable);
    TeleportSpectatorHeight = false;
}

References HandleTeleportSpectator(), and TeleportSpectatorHeight.

Referenced by AddCommands().

HandleTryDestroyObjectByID()

void UROSCommands::HandleTryDestroyObjectByID ( const FString &  Variable )

private

Definition at line 656 of file ROSCommands.cpp.

{
    bool success = IActorInformation::DestroyActorByID(Variable);
 
    FString Message;
    if (success)
    {
        Message = FString::Printf(TEXT("Object with ID %s successfully destroyed."), *Variable);
    }
    else
    {
        Message = FString::Printf(TEXT("Failed to destroy object with ID %s."), *Variable);
    }
 
    SimulatorLog::Log(Message);
}

References IActorInformation::DestroyActorByID(), and SimulatorLog::Log().

Referenced by AddCommands().

HandleUnPauseSimulator()

void UROSCommands::HandleUnPauseSimulator ( const FString &  Variable )

private

Definition at line 373 of file ROSCommands.cpp.

{
    UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
    if (AgrarsenseSettings)
    {
        AgrarsenseSettings->UnPauseSimulation();
    }
}

References GetSettings(), and UAgrarsenseSettings::UnPauseSimulation().

Referenced by AddCommands().

HandleUnrealCommand()

void UROSCommands::HandleUnrealCommand ( const FString &  Variable )

private

Definition at line 438 of file ROSCommands.cpp.

{
    UWorld* World = GetGameWorld();
    if (GEngine && World)
    {
        GEngine->Exec(World, *Variable);
    }
}

References GetGameWorld().

Referenced by AddCommands().

HandleVehicleMeshVisibility()

void UROSCommands::HandleVehicleMeshVisibility ( const FString &  Variable )

private

Definition at line 1469 of file ROSCommands.cpp.

{
    TArray<FString> Tokens;
    Variable.ParseIntoArray(Tokens, TEXT(" "), true);
 
    if (Tokens.Num() < 2)
    {
        return;
    }
 
    const FString& ID = Tokens[0];
    const FString Param = Variable.RightChop(ID.Len() + 1);
 
    bool bVisible = true;
    if (!TryParseBoolean(Param, bVisible))
    {
        return; // Invalid parameter
    }
 
    if (AActor* Actor = IActorInformation::GetActorByID(ID))
    {
        if (AVehicle* Vehicle = Cast<AVehicle>(Actor))
        {
            Vehicle->SetVehicleMeshVisibility(bVisible);
        }
    }
}

References IActorInformation::GetActorByID(), TryParseBoolean(), and Vehicle.

Referenced by AddCommands().

HandleVisualizeOverlapSensorsBounds()

void UROSCommands::HandleVisualizeOverlapSensorsBounds ( const FString &  Variable )

private

Definition at line 1012 of file ROSCommands.cpp.

{
    bool Visualize;
    if (!TryParseBoolean(Variable, Visualize))
    {
        // Failed to parse, return
        return;
    }
 
    UWorld* World = GetGameWorld();
    if (World)
    {
        TArray<AActor*> OverlapSensors;
        UGameplayStatics::GetAllActorsOfClass(World, AOverlapSensor::StaticClass(), OverlapSensors);
 
        for (AActor* SensorActor : OverlapSensors)
        {
            AOverlapSensor* Sensor = Cast<AOverlapSensor>(SensorActor);
            if (Sensor)
            {
                Sensor->SetVisualizeOverlapArea(Visualize);
            }
        }
    }
}

References GetGameWorld(), AOverlapSensor::SetVisualizeOverlapArea(), and TryParseBoolean().

Referenced by AddCommands().

Init()

void UROSCommands::Init ( )

private

Definition at line 46 of file ROSCommands.cpp.

{
    AddCommands();
 
    UROSHandler* ROSHandler = UAgrarsenseStatics::GetROSHandle(GetGameWorld());
    if (ROSHandler)
    {
        ROSHandler->OnROSStateChanged.AddUniqueDynamic(this, &UROSCommands::ROSBridgeStateChanged);
    }
 
    SetupROSCommandTopic();
}

References AddCommands(), GetGameWorld(), UAgrarsenseStatics::GetROSHandle(), UROSHandler::OnROSStateChanged, ROSBridgeStateChanged(), and SetupROSCommandTopic().

Referenced by AAgrarsenseGameModeBase::SpawnNeededActorsBeginPlay().

ParseIncomingMessage()

void UROSCommands::ParseIncomingMessage ( const FString  Message )

private

Definition at line 256 of file ROSCommands.cpp.

{
    // Parse incoming string message into {COMMAND} {VARIABLE} format
    int32 SpaceIndex;
    FString Command;
    FString Variable;
 
    if (Message.FindChar(' ', SpaceIndex))
    {
        // Extract the command as the substring before the first space
        Command = Message.Left(SpaceIndex).ToLower();
 
        // Extract the rest of the message as the variable
        Variable = Message.Mid(SpaceIndex + 1);
    }
    else
    {
        // If no space is found, consider the entire message as the command
        Command = Message.ToLower();
    }
 
    // Log incoming message into text file for debugging purposes
    FString CommandMsg = FString::Printf(TEXT("Incoming [command variable]: %s %s"), *Command, *Variable);
    SimulatorLog::Log(CommandMsg);
 
    FCommand* CommandInfo = CommandHandlers.Find(Command);
    if (CommandInfo)
    {
        // Check if enough time has passed since the last execution.
        double CurrentTime = FPlatformTime::Seconds();
        double TimeSinceLastExecution = CurrentTime - CommandInfo->LastExecutionTime;
 
        if (TimeSinceLastExecution >= CommandInfo->CooldownTime)
        {
            // Call the handler function with the variable.
            (this->*(CommandInfo->Handler))(Variable);
 
            // Update the last execution time.
            CommandInfo->LastExecutionTime = CurrentTime;
        }
        else
        {
            float CoolDownTimeLeft = CommandInfo->CooldownTime - TimeSinceLastExecution;
            FString Msg = FString::Printf(TEXT("Command '%s' on cooldown. Retry in %.2f sec."), *Command, CoolDownTimeLeft);
            SimulatorLog::Log(Msg);
        }
    }
    else
    {
        FString Msg = FString::Printf(TEXT("Couldn't find command: '%s'"), *Command);
        SimulatorLog::Log(Msg);
    }
}

References CommandHandlers, FCommand::CooldownTime, FCommand::Handler, FCommand::LastExecutionTime, and SimulatorLog::Log().

Referenced by SetupROSCommandTopic(), and TryExecuteCommand().

PrintActorInformation()

void UROSCommands::PrintActorInformation ( const FString &  Variable, UClass *  ActorClass, const FString &  ActorTypeName  )

private

Definition at line 768 of file ROSCommands.cpp.

{
    TArray<AActor*> Actors;
    UGameplayStatics::GetAllActorsWithInterface(GetGameWorld(), UActorInformation::StaticClass(), Actors);
 
    TArray<AActor*> TypedActors;
    for (AActor* Actor : Actors)
    {
        if (Actor->IsA(ActorClass))
        {
            TypedActors.Add(Actor);
        }
    }
 
    FString Msg;
    if (!TypedActors.IsEmpty())
    {
        Msg = FString::Printf(TEXT("Simulation has %d %ss \n "), TypedActors.Num(), *ActorTypeName);
        for (AActor* Actor : TypedActors)
        {
            if (Actor)
            {
                if (Actor->Implements<UActorInformation>())
                {
                    FString ActorInfo = IActorInformation::Execute_GetActorInformation(Actor);
                    Msg += FString::Printf(TEXT("%s \n \n "), *ActorInfo);
                }
 
            }
        }
    }
    else
    {
        Msg = FString::Printf(TEXT("Simulation has 0 %ss."), *ActorTypeName);
    }
 
    SimulatorLog::Log(Msg);
}

References GetGameWorld(), and SimulatorLog::Log().

Referenced by HandlePrintAllSensors(), HandlePrintAllVehicles(), and HandlePrintAllWalkers().

ROSBridgeStateChanged()

void UROSCommands::ROSBridgeStateChanged ( EROSState  state )

private

Definition at line 194 of file ROSCommands.cpp.

{
    switch (state)
    {
    case EROSState::Connected:
        SetupROSCommandTopic();
        break;
 
    case EROSState::Disconnected:
        DestroyROSTopic();
        break;
    }
}

References Connected, DestroyROSTopic(), Disconnected, and SetupROSCommandTopic().

Referenced by Init().

SetupROSCommandTopic()

void UROSCommands::SetupROSCommandTopic ( )

private

Definition at line 220 of file ROSCommands.cpp.

{
    UWorld* World = GetGameWorld();
    if (!World)
    {
        return;
    }
 
    RosInstance = UAgrarsenseStatics::GetROSGameInstance(World);
    if (!CommandTopic && RosInstance && RosInstance->IsROSConnected())
    {
        CommandTopic = NewObject<UTopic>(UTopic::StaticClass());
        CommandTopic->Init(RosInstance->ROSIntegrationCore, TEXT("/agrarsense/in/commands"), TEXT("std_msgs/String"));
        CommandTopic->Advertise();
 
        // Create a std::function callback object
        std::function<void(TSharedPtr<FROSBaseMsg>)> SubscribeCallback = [this](TSharedPtr<FROSBaseMsg> msg) -> void
            {
                auto Concrete = StaticCastSharedPtr<ROSMessages::std_msgs::String>(msg);
                if (Concrete.IsValid())
                {
                    FString message = *(Concrete->_Data);
                    AsyncTask(ENamedThreads::GameThread, [this, message]()
                        {
                            // Parse message on GameThread since many commands are NOT thread-safe
                            ParseIncomingMessage(message);
                        });
                }
                return;
            };
 
        // Subscribe to the topic
        CommandTopic->Subscribe(SubscribeCallback);
    }
}

References CommandTopic, GetGameWorld(), UAgrarsenseStatics::GetROSGameInstance(), ParseIncomingMessage(), and RosInstance.

Referenced by Init(), and ROSBridgeStateChanged().

TryExecuteCommand()

void UROSCommands::TryExecuteCommand

(

const FString &

Command

)

Definition at line 64 of file ROSCommands.cpp.

{
    ParseIncomingMessage(Command);
}

References ParseIncomingMessage().

TryParseBoolean()

bool UROSCommands::TryParseBoolean ( const FString &  String, bool &  OutBool  ) const

private

Attempts to parse a string into a boolean value.

Parameters

String	The string to parse into a boolean value.
OutBool	A reference to a boolean where the result will be stored if the parsing is successful.

Returns

true if the string was successfully parsed into a boolean value, false otherwise.

Definition at line 310 of file ROSCommands.cpp.

{
    FString LoweredString = String.ToLower();
 
    if (LoweredString.Equals("true") || LoweredString.Equals("1"))
    {
        OutBool = true;
        return true;
    }
    else if (LoweredString.Equals("false") || LoweredString.Equals("0"))
    {
        OutBool = false;
        return true;
    }
 
    // Invalid boolean value
    return false;
}

Referenced by HandleSetAllSensorsEnabled(), HandleSetGrassVisibility(), HandleSetSaveCombinedPointcloudToDisk(), HandleSetSensorEnabled(), HandleSetWorldRendering(), HandleVehicleMeshVisibility(), and HandleVisualizeOverlapSensorsBounds().

Friends And Related Function Documentation

AAgrarsenseGameModeBase

friend class AAgrarsenseGameModeBase

friend

Definition at line 63 of file ROSCommands.h.

Member Data Documentation

CommandHandlers

TMap< FString, FCommand > UROSCommands::CommandHandlers

staticprivate

Definition at line 74 of file ROSCommands.h.

Referenced by AddCommands(), HandlePrintAvailableCommands(), and ParseIncomingMessage().

CommandTopic

UTopic* UROSCommands::CommandTopic = nullptr

private

Definition at line 103 of file ROSCommands.h.

Referenced by DestroyROSTopic(), HandlePrintAvailableCommands(), and SetupROSCommandTopic().

InMeters

bool UROSCommands::InMeters = false

private

Definition at line 108 of file ROSCommands.h.

Referenced by HandleTeleportActorByID(), and HandleTeleportActorByIDHeight().

RosInstance

UROSIntegrationGameInstance* UROSCommands::RosInstance = nullptr

private

Definition at line 106 of file ROSCommands.h.

Referenced by SetupROSCommandTopic().

TeleportSpectatorHeight

bool UROSCommands::TeleportSpectatorHeight = false

private

Definition at line 110 of file ROSCommands.h.

Referenced by HandleTeleportSpectator(), and HandleTeleportSpectatorHeight().

---

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

• Unreal/Agrarsense/Source/Agrarsense/ROS/ROSCommands.h
• Unreal/Agrarsense/Source/Agrarsense/ROS/ROSCommands.cpp