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)
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	HandleTeleportSpectator (const FString &Variable)
void	HandleTeleportActorByID (const FString &Variable)
void	HandleTryDestroyObjectByID (const FString &Variable)
void	HandleDestroyAllSensors (const FString &Variable)
void	HandleDestroyAllWalkers (const FString &Variable)
void	HandleDestroyAllVehicles (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	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	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	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)

Private Attributes
UTopic *	CommandTopic = nullptr
UROSIntegrationGameInstance *	RosInstance = nullptr

Static Private Attributes
static TMap< FString, FCommand >	CommandHandlers

Friends
class	AAgrarsenseGameModeBase

Detailed Description

Definition at line 46 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.05f, TEXT("x,y,z or x,y,z,yaw,pitch,roll")));
    CommandHandlers.Add(TEXT("teleportbyid"), FCommand(&UROSCommands::HandleTeleportActorByID, 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")));
 
    // 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, 2.0f, TEXT("low / ultra")));
    CommandHandlers.Add(TEXT("setworldrendering"), FCommand(&UROSCommands::HandleSetWorldRendering, 1.0f, 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")));
    
    // 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("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 weather 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")));
    
    // Overlap sensor commands
    // changeoverlapbounds format: 'changeoverlapbounds sensor_id 500,500,500'
    // changeoverlapposition format: 'changeoverlapposition sensor_id 0,0,0'
    CommandHandlers.Add(TEXT("visoverlapbounds"), FCommand(&UROSCommands::HandleVisualizeOverlapSensorsBounds, 0.05f, TEXT("Visualize All Overlap sensors bounds")));
    CommandHandlers.Add(TEXT("changeoverlapbounds"), FCommand(&UROSCommands::HandleChangeOverlapSensorBounds, 0.05f, TEXT("Change Overlap sensor area bounds")));
    CommandHandlers.Add(TEXT("changeoverlapposition"), FCommand(&UROSCommands::HandleChangeOverlapSensorPosition, 0.05f, TEXT("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")));
 
    // Drone commands
    CommandHandlers.Add(TEXT("movedroneto"), FCommand(&UROSCommands::HandleMoveDroneToAndStop, 0.05f, TEXT("ID (position)")));
}

References CommandHandlers, HandleAdvanceFrames(), HandleAdvanceOneFrame(), HandleAdvanceTime(), HandleChangeMap(), HandleChangeOverlapSensorBounds(), HandleChangeOverlapSensorPosition(), HandleDestroyActorsArea(), HandleDestroyAllSensors(), HandleDestroyAllVehicles(), HandleDestroyAllWalkers(), HandleDestroyTreesArea(), HandleDisableAllSensors(), HandleEnableAllSensors(), HandleExportAll(), HandleExportFoliage(), HandleExportProps(), HandleExportSensors(), HandleExportVehicles(), HandleExportWalkers(), HandleExportWeather(), HandleMoveDroneToAndStop(), HandleMoveWalkerToAndDestroy(), HandleMoveWalkerToAndStop(), HandlePauseSimulator(), HandlePrintAllSensors(), HandlePrintAllVehicles(), HandlePrintAvailableCommands(), HandlePrintIds(), HandlePrintMaps(), HandleQuit(), HandleResumeWalker(), HandleSetAllSensorsEnabled(), HandleSetGlobalTargetFrameRate(), HandleSetGlobalTimeDilation(), HandleSetNaniteMaxPixelsPerEdge(), HandleSetQualityLevel(), HandleSetSaveCombinedPointcloudToDisk(), HandleSetSensorEnabled(), HandleSetWorldRendering(), HandleSetWPO(), HandleSpawnObjects(), HandleStopWalker(), HandleTeleportActorByID(), HandleTeleportSpectator(), HandleTryDestroyObjectByID(), HandleUnPauseSimulator(), HandleUnrealCommand(), 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 193 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(), HandleDisableAllSensors(), HandleEnableAllSensors(), HandleExportSensors(), HandleExportWeather(), HandleQuit(), HandleSetAllSensorsEnabled(), HandleSetSaveCombinedPointcloudToDisk(), HandleTeleportSpectator(), 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(), HandleSetNaniteMaxPixelsPerEdge(), HandleSetQualityLevel(), HandleSetWorldRendering(), HandleSetWPO(), and HandleUnPauseSimulator().

HandleAdvanceFrames()

void UROSCommands::HandleAdvanceFrames ( const FString &  Variable )

private

Definition at line 376 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 367 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 395 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 414 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 875 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 Bounds;
    TArray<FString> BoundsTokens;
    BoundsString.ParseIntoArray(BoundsTokens, TEXT(","), true);
 
    if (BoundsTokens.Num() >= 3)
    {
        Bounds.X = FCString::Atof(*BoundsTokens[0]);
        Bounds.Y = FCString::Atof(*BoundsTokens[1]);
        Bounds.Z = FCString::Atof(*BoundsTokens[2]);
 
        AActor* Actor = IActorInformation::GetActorByID(ID);
        AOverlapSensor* Sensor = Cast<AOverlapSensor>(Actor);
        if (Sensor)
        {
            Sensor->SetOverlapBounds(Bounds);
        }
    }
}

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

Referenced by AddCommands().

HandleChangeOverlapSensorPosition()

void UROSCommands::HandleChangeOverlapSensorPosition ( const FString &  Variable )

private

Definition at line 911 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 1248 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 1243 of file ROSCommands.cpp.

{
    HandleDestroyActors(Variable, false);
}

References HandleDestroyActors().

Referenced by AddCommands().

HandleDestroyAllSensors()

void UROSCommands::HandleDestroyAllSensors ( const FString &  Variable )

private

Definition at line 575 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 585 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 580 of file ROSCommands.cpp.

{
    UAssetLibrary::DestroyAllWalkers();
}

References UAssetLibrary::DestroyAllWalkers().

Referenced by AddCommands().

HandleDestroyTreesArea()

void UROSCommands::HandleDestroyTreesArea ( const FString &  Variable )

private

Definition at line 1238 of file ROSCommands.cpp.

{
    HandleDestroyActors(Variable, true);
}

References HandleDestroyActors().

Referenced by AddCommands().

HandleDisableAllSensors()

void UROSCommands::HandleDisableAllSensors ( const FString &  Variable )

private

Definition at line 1171 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 1166 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 754 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 837 of file ROSCommands.cpp.

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

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

Referenced by AddCommands(), and HandleExportAll().

HandleExportProps()

void UROSCommands::HandleExportProps ( const FString &  Variable )

private

Definition at line 843 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 804 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 791 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 779 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 770 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 1068 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 957 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 962 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 947 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 952 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 349 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 623 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 628 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 633 of file ROSCommands.cpp.

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

References PrintActorInformation().

HandlePrintAvailableCommands()

void UROSCommands::HandlePrintAvailableCommands ( const FString &  Variable )

private

Definition at line 314 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 677 of file ROSCommands.cpp.

{
    IActorInformation::PrintAllIds();
}

References IActorInformation::PrintAllIds().

Referenced by AddCommands().

HandlePrintMaps()

void UROSCommands::HandlePrintMaps ( const FString &  Variable )

private

Definition at line 605 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 340 of file ROSCommands.cpp.

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

References GetGameWorld().

Referenced by AddCommands().

HandleResumeWalker()

void UROSCommands::HandleResumeWalker ( const FString &  Variable )

private

Definition at line 1044 of file ROSCommands.cpp.

{
    HandleSetWalkerMovement(Variable, false);
}

References HandleSetWalkerMovement().

Referenced by AddCommands().

HandleSetAllSensorsEnabled()

void UROSCommands::HandleSetAllSensorsEnabled ( const FString &  Variable )

private

Definition at line 1147 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 682 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 695 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().

HandleSetNaniteMaxPixelsPerEdge()

void UROSCommands::HandleSetNaniteMaxPixelsPerEdge ( const FString &  Variable )

private

Definition at line 1225 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 708 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 733 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 1176 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().

HandleSetWalkerMovement()

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

private

Definition at line 1049 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 717 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 1212 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 749 of file ROSCommands.cpp.

{
    USimulatorJsonParser::ParseAndOperateJSONFile(Variable);
}

References USimulatorJsonParser::ParseAndOperateJSONFile().

Referenced by AddCommands().

HandleStopWalker()

void UROSCommands::HandleStopWalker ( const FString &  Variable )

private

Definition at line 1039 of file ROSCommands.cpp.

{
    HandleSetWalkerMovement(Variable, true);
}

References HandleSetWalkerMovement().

Referenced by AddCommands().

HandleTeleportActorByID()

void UROSCommands::HandleTeleportActorByID ( const FString &  Variable )

private

Definition at line 476 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
    {
        // Not valid, return
        return;
    }
 
    // Check if this ID matches any Actor
    AActor* Actor = IActorInformation::GetActorByID(ID);
    if (!Actor)
    {
        // Not valid, return
        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 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 IActorInformation::GetActorByID(), AVehicle::TogglePhysics(), and Transform.

Referenced by AddCommands().

HandleTeleportSpectator()

void UROSCommands::HandleTeleportSpectator ( const FString &  Variable )

private

Definition at line 432 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);
                Spectator->TeleportSpectator(Transform);
            }
        }
    }
}

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

Referenced by AddCommands().

HandleTryDestroyObjectByID()

void UROSCommands::HandleTryDestroyObjectByID ( const FString &  Variable )

private

Definition at line 558 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 358 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 423 of file ROSCommands.cpp.

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

References GetGameWorld().

Referenced by AddCommands().

HandleVisualizeOverlapSensorsBounds()

void UROSCommands::HandleVisualizeOverlapSensorsBounds ( const FString &  Variable )

private

Definition at line 849 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 241 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("ROSCommands.cpp: 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 638 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 179 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 205 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  )

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 295 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(), HandleSetSaveCombinedPointcloudToDisk(), HandleSetSensorEnabled(), HandleSetWorldRendering(), and HandleVisualizeOverlapSensorsBounds().

Friends And Related Function Documentation

AAgrarsenseGameModeBase

friend class AAgrarsenseGameModeBase

friend

Definition at line 62 of file ROSCommands.h.

Member Data Documentation

CommandHandlers

TMap< FString, FCommand > UROSCommands::CommandHandlers

staticprivate

Definition at line 73 of file ROSCommands.h.

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

CommandTopic

UTopic* UROSCommands::CommandTopic = nullptr

private

Definition at line 102 of file ROSCommands.h.

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

RosInstance

UROSIntegrationGameInstance* UROSCommands::RosInstance = nullptr

private

Definition at line 105 of file ROSCommands.h.

Referenced by SetupROSCommandTopic().

---

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