Agrarsense
Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes | Friends | List of all members
UROSCommands Class Reference

#include <ROSCommands.h>

Inheritance diagram for UROSCommands:
Inheritance graph
[legend]
Collaboration diagram for UROSCommands:
Collaboration graph
[legend]

Public Member Functions

void TryExecuteCommand (const FString &Command)
 

Private Member Functions

void Init ()
 
void Destroy ()
 
UWorld * GetGameWorld ()
 
UAgrarsenseSettingsGetSettings ()
 
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, FCommandCommandHandlers
 

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.

85{
86 // To call from Terminal (note all in lower case)
87 // rostopic pub /agrarsense/in/commands std_msgs/String "{COMMAND} {VARIABLE}" --once
88 // rostopic pub /agrarsense/in/commands std_msgs/String "help" --once
89
90 if (!CommandHandlers.IsEmpty())
91 {
92 return;
93 }
94
96
97 // General commands
98 CommandHandlers.Add(TEXT("help"), FCommand(&UROSCommands::HandlePrintAvailableCommands, 0.1f, "Print all commands"));
99 CommandHandlers.Add(TEXT("quit"), FCommand(&UROSCommands::HandleQuit, 1.0f, "Quits the Simulator"));
100 CommandHandlers.Add(TEXT("loadmap"), FCommand(&UROSCommands::HandleChangeMap, 5.0f, TEXT("load map by name")));
101 CommandHandlers.Add(TEXT("unrealcommand"), FCommand(&UROSCommands::HandleUnrealCommand, 0.05f, TEXT("Execute Unreal engine console command")));
102
103 // Pause commands
104 CommandHandlers.Add(TEXT("pause"), FCommand(&UROSCommands::HandlePauseSimulator, 0.01f, "Pauses the Simulator after current frame has finished"));
105 CommandHandlers.Add(TEXT("unpause"), FCommand(&UROSCommands::HandleUnPauseSimulator, 0.01f, "Un pauses the Simulator immediately upon receiving the message"));
106 CommandHandlers.Add(TEXT("nextframe"), FCommand(&UROSCommands::HandleAdvanceOneFrame, 0.01f, "Advance one frame"));
107 CommandHandlers.Add(TEXT("advanceframes"), FCommand(&UROSCommands::HandleAdvanceFrames, 0.01f, "Advance given amount of frames"));
108 CommandHandlers.Add(TEXT("advancetime"), FCommand(&UROSCommands::HandleAdvanceTime, 0.01f, "Advance given amount of time in seconds"));
109
110 // Teleport commands
111 CommandHandlers.Add(TEXT("teleportspectator"), FCommand(&UROSCommands::HandleTeleportSpectator, 0.03f, TEXT("x,y,z or x,y,z,yaw,pitch,roll")));
112 CommandHandlers.Add(TEXT("teleportspectatorheight"), FCommand(&UROSCommands::HandleTeleportSpectatorHeight, 0.03f, TEXT("x,y,z or x,y,z,yaw,pitch,roll")));
113 CommandHandlers.Add(TEXT("teleportbyid"), FCommand(&UROSCommands::HandleTeleportActorByID, 0.03f, TEXT("ID of Actor, x,y,z or x,y,z,yaw,pitch,roll")));
114 CommandHandlers.Add(TEXT("teleportSpectatorToInstanceID"), FCommand(&UROSCommands::HandleTeleportSpectatorByInstanceID, 0.03f, TEXT("Instance ID")));
115 CommandHandlers.Add(TEXT("teleportbyidheight"), FCommand(&UROSCommands::HandleTeleportActorByIDHeight, 0.05f, TEXT("ID of Actor, x,y,z or x,y,z,yaw,pitch,roll")));
116
117 // Destroy commands
118 CommandHandlers.Add(TEXT("destroyobjectbyid"), FCommand(&UROSCommands::HandleTryDestroyObjectByID, 0.05f, TEXT("Try to destroy object by id")));
119 CommandHandlers.Add(TEXT("destroyallsensors"), FCommand(&UROSCommands::HandleDestroyAllSensors, 1.0f, TEXT("Destroy all sensors")));
120 CommandHandlers.Add(TEXT("destroyallwalkers"), FCommand(&UROSCommands::HandleDestroyAllWalkers, 1.0f, TEXT("Destroy all sensors")));
121 CommandHandlers.Add(TEXT("destroyallvehicles"), FCommand(&UROSCommands::HandleDestroyAllVehicles, 1.0f, TEXT("Destroy all sensors")));
122
123 CommandHandlers.Add(TEXT("destroyobjectbyinstanceid"), FCommand(&UROSCommands::HandleDestroyObjectByInstanceID, 1.0f, TEXT("id")));
124
125 // Volume commands
126 // ex. "destroytrees 0,0,0 300,300,300" - destroys all tree actors within certain box area.
127 // ex. "destroyassets 0,0,0 300,300,300" - destroys all Instanced actors within certain box area.
128 CommandHandlers.Add(TEXT("destroytreesarea"), FCommand(&UROSCommands::HandleDestroyTreesArea, 0.05f, TEXT("x,y,z sizeX,sizeY,sizeZ")));
129 CommandHandlers.Add(TEXT("destroyassetsarea"), FCommand(&UROSCommands::HandleDestroyActorsArea, 0.05f, TEXT("x,y,z sizeX,sizeY,sizeZ")));
130
131 // Print commands
132 CommandHandlers.Add(TEXT("getmaps"), FCommand(&UROSCommands::HandlePrintMaps, 0.5f, TEXT("Print all available maps")));
133 CommandHandlers.Add(TEXT("getsensors"), FCommand(&UROSCommands::HandlePrintAllSensors, 0.1f, TEXT("Print all sensors information")));
134 CommandHandlers.Add(TEXT("getvehicles"), FCommand(&UROSCommands::HandlePrintAllVehicles, 0.1f, TEXT("Print all vehicles information")));
135 CommandHandlers.Add(TEXT("getwalkers"), FCommand(&UROSCommands::HandlePrintMaps, 0.1f, TEXT("print all walkers information")));
136 CommandHandlers.Add(TEXT("getids"), FCommand(&UROSCommands::HandlePrintIds, 0.1f, TEXT("print all ids")));
137
138 // Set commands
139 CommandHandlers.Add(TEXT("setglobaltargetframeRate"), FCommand(&UROSCommands::HandleSetGlobalTargetFrameRate, 1.0f, TEXT("0 - 300")));
140 CommandHandlers.Add(TEXT("setglobaltimedilation"), FCommand(&UROSCommands::HandleSetGlobalTimeDilation, 1.0f, TEXT("0.0f - 10.0f")));
141 CommandHandlers.Add(TEXT("setqualityLevel"), FCommand(&UROSCommands::HandleSetQualityLevel, 1.0f, TEXT("low / ultra")));
142 CommandHandlers.Add(TEXT("setworldrendering"), FCommand(&UROSCommands::HandleSetWorldRendering, 0.05f, TEXT("true / false")));
143 CommandHandlers.Add(TEXT("setgrassvisibility"), FCommand(&UROSCommands::HandleSetGrassVisibility, 0.05f, TEXT("true / false")));
144 CommandHandlers.Add(TEXT("setsavecombinedpointcloud"), FCommand(&UROSCommands::HandleSetSaveCombinedPointcloudToDisk, 0.05f, TEXT("true / false")));
145 CommandHandlers.Add(TEXT("setwpodistance"), FCommand(&UROSCommands::HandleSetWPO, 0.5f, TEXT("Set WPO render distance in cm")));
146 CommandHandlers.Add(TEXT("setnanitemaxpixelsperedge"), FCommand(&UROSCommands::HandleSetNaniteMaxPixelsPerEdge, 0.5f, TEXT("Set Nanite max pixels per edge")));
147 CommandHandlers.Add(TEXT("setspectatoroverlapradius"), FCommand(&UROSCommands::HandleSetSpectatorOverlapRadius, 0.05f, TEXT("radius in meters")));
148
149 // Sensor commands
150 CommandHandlers.Add(TEXT("setallsensorsenabled"), FCommand(&UROSCommands::HandleSetAllSensorsEnabled, 1.0f, TEXT("true / false")));
151 CommandHandlers.Add(TEXT("enableallsensors"), FCommand(&UROSCommands::HandleEnableAllSensors, 1.0f, TEXT("true / false")));
152 CommandHandlers.Add(TEXT("disableallsensors"), FCommand(&UROSCommands::HandleDisableAllSensors, 1.0f, TEXT("true / false")));
153 CommandHandlers.Add(TEXT("setsensorenabled"), FCommand(&UROSCommands::HandleSetSensorEnabled, 1.0f, TEXT("ID true/false")));
154
155 // Spawn/change objects commands. They all call the same function. They are defined separately for clarity.
156 CommandHandlers.Add(TEXT("spawn"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("Spawn objects from JSON file")));
157 CommandHandlers.Add(TEXT("load"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("Spawn objects from JSON file")));
158 CommandHandlers.Add(TEXT("loadjson"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("Spawn objects from JSON file")));
159 CommandHandlers.Add(TEXT("spawnobjects"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("Spawn objects from JSON file")));
160 CommandHandlers.Add(TEXT("changeweather"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("change weather from JSON file")));
161 CommandHandlers.Add(TEXT("changecolors"), FCommand(&UROSCommands::HandleSpawnObjects, 0.05f, TEXT("change semantic colors from JSON file")));
162
163 // Exports
164 CommandHandlers.Add(TEXT("exportall"), FCommand(&UROSCommands::HandleExportAll, 1.0f, TEXT("Export all spanwed things to JSON file")));
165 CommandHandlers.Add(TEXT("exportweather"), FCommand(&UROSCommands::HandleExportWeather, 1.0f, TEXT("Export current weather to JSON file")));
166 CommandHandlers.Add(TEXT("exportwalkers"), FCommand(&UROSCommands::HandleExportWalkers, 1.0f, TEXT("Export all Walkers to JSON file")));
167 CommandHandlers.Add(TEXT("exportvehicles"), FCommand(&UROSCommands::HandleExportVehicles, 1.0f, TEXT("Export all Vehicles to JSON file")));
168 CommandHandlers.Add(TEXT("exportsensors"), FCommand(&UROSCommands::HandleExportSensors, 1.0f, TEXT("Export all Sensors to JSON file")));
169 CommandHandlers.Add(TEXT("exportprops"), FCommand(&UROSCommands::HandleExportProps, 1.0f, TEXT("Export all props to JSON file")));
170 CommandHandlers.Add(TEXT("exportfoliage"), FCommand(&UROSCommands::HandleExportFoliage, 1.0f, TEXT("Export all Foliage to JSON file")));
171 CommandHandlers.Add(TEXT("exportobjects"), FCommand(&UROSCommands::HandleExportObjects, 1.0f, TEXT("Export all object locations to CSV file")));
172
173 // Overlap sensor commands
174 // changeoverlapbounds format: 'setoverlapradiusbyid sensor_id 25'
175 // changeoverlapposition format: 'setoverlappositionbyid sensor_id 0,0,0'
176 CommandHandlers.Add(TEXT("visualizeoverlaps"), FCommand(&UROSCommands::HandleVisualizeOverlapSensorsBounds, 0.05f, TEXT("true/false: Visualize all Overlap sensors")));
177 CommandHandlers.Add(TEXT("setoverlapradiusbyid"), FCommand(&UROSCommands::HandleChangeOverlapSensorBounds, 0.05f, TEXT("ID float: change overlap sensor radius by actor id")));
178 CommandHandlers.Add(TEXT("setoverlappositionbyid"), FCommand(&UROSCommands::HandleChangeOverlapSensorPosition, 0.05f, TEXT("ID float, float, float: Change Overlap sensor relative position")));
179
180 // Walker commands
181 CommandHandlers.Add(TEXT("movewalkerto"), FCommand(&UROSCommands::HandleMoveWalkerToAndStop, 0.05f, TEXT("ID (position or position,rotation)")));
182 CommandHandlers.Add(TEXT("movewalkertoanddestroy"), FCommand(&UROSCommands::HandleMoveWalkerToAndDestroy, 0.05f, TEXT("ID (position or position,rotation)")));
183 CommandHandlers.Add(TEXT("stopwalker"), FCommand(&UROSCommands::HandleStopWalker, 0.05f, TEXT("ID of the Walker")));
184 CommandHandlers.Add(TEXT("resumewalker"), FCommand(&UROSCommands::HandleResumeWalker, 0.05f, TEXT("ID of the Walker")));
185
186 // Vehicle commands
187 CommandHandlers.Add(TEXT("setvehiclemeshvisibility"), FCommand(&UROSCommands::HandleVehicleMeshVisibility, 0.05f, TEXT("ID true/false")));
188
189 // Drone commands
190 CommandHandlers.Add(TEXT("movedroneto"), FCommand(&UROSCommands::HandleMoveDroneToAndStop, 0.05f, TEXT("ID (position)")));
191 CommandHandlers.Add(TEXT("resetdrone"), FCommand(&UROSCommands::HandleResetDrone, 0.15f, TEXT("Drone ID")));
192}
void HandleTeleportActorByID(const FString &Variable)
void HandleUnrealCommand(const FString &Variable)
void HandleSetGrassVisibility(const FString &Variable)
void HandleChangeOverlapSensorBounds(const FString &Variable)
void HandleTeleportSpectator(const FString &Variable)
void HandlePrintAllVehicles(const FString &Variable)
void HandlePrintAllSensors(const FString &Variable)
void HandleDestroyActorsArea(const FString &Variable)
void HandleSetSpectatorOverlapRadius(const FString &Variable)
static TMap< FString, FCommand > CommandHandlers
Definition: ROSCommands.h:74
void HandleAdvanceOneFrame(const FString &Variable)
void HandleUnPauseSimulator(const FString &Variable)
void HandlePrintAvailableCommands(const FString &Variable)
void HandleAdvanceTime(const FString &Variable)
void HandleExportAll(const FString &Variable)
void HandleExportSensors(const FString &Variable)
void HandleExportVehicles(const FString &Variable)
void HandleSetSaveCombinedPointcloudToDisk(const FString &Variable)
void HandleTeleportActorByIDHeight(const FString &Variable)
void HandleDisableAllSensors(const FString &Variable)
void HandleSetWPO(const FString &Variable)
void HandleTeleportSpectatorByInstanceID(const FString &Variable)
void HandleChangeMap(const FString &Variable)
void HandleExportWalkers(const FString &Variable)
void HandleResumeWalker(const FString &Variable)
void HandleTeleportSpectatorHeight(const FString &Variable)
void HandleSetWorldRendering(const FString &Variable)
void HandleSetGlobalTimeDilation(const FString &Variable)
void HandleDestroyAllSensors(const FString &Variable)
void HandleMoveWalkerToAndStop(const FString &Variable)
void HandleExportWeather(const FString &Variable)
void HandleExportFoliage(const FString &Variable)
void HandleQuit(const FString &Variable)
void HandleSetAllSensorsEnabled(const FString &Variable)
void HandleVehicleMeshVisibility(const FString &Variable)
void HandleChangeOverlapSensorPosition(const FString &Variable)
void HandleSetSensorEnabled(const FString &Variable)
void HandleTryDestroyObjectByID(const FString &Variable)
void HandleVisualizeOverlapSensorsBounds(const FString &Variable)
void HandleEnableAllSensors(const FString &Variable)
void HandleDestroyAllVehicles(const FString &Variable)
void HandleStopWalker(const FString &Variable)
void HandleDestroyObjectByInstanceID(const FString &Variable)
void HandleMoveDroneToAndStop(const FString &Variable)
void HandleDestroyAllWalkers(const FString &Variable)
void HandleMoveWalkerToAndDestroy(const FString &Variable)
void HandleSetNaniteMaxPixelsPerEdge(const FString &Variable)
void HandlePrintMaps(const FString &Variable)
void HandleSpawnObjects(const FString &Variable)
void HandleDestroyTreesArea(const FString &Variable)
void HandleSetGlobalTargetFrameRate(const FString &Variable)
void HandlePrintIds(const FString &Variable)
void HandleAdvanceFrames(const FString &Variable)
void HandleSetQualityLevel(const FString &Variable)
void HandlePauseSimulator(const FString &Variable)
void HandleResetDrone(const FString &Variable)
void HandleExportObjects(const FString &Variable)
void HandleExportProps(const FString &Variable)

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.

60{
62}
void DestroyROSTopic()

References DestroyROSTopic().

Referenced by AAgrarsenseGameModeBase::EndPlay().

◆ DestroyROSTopic()

void UROSCommands::DestroyROSTopic ( )
private

Definition at line 208 of file ROSCommands.cpp.

209{
210 if (CommandTopic)
211 {
212 CommandTopic->Unadvertise();
213 CommandTopic->Unsubscribe();
214 CommandTopic->MarkAsDisconnected();
215 CommandTopic->ConditionalBeginDestroy();
216 CommandTopic = nullptr;
217 }
218}
UTopic * CommandTopic
Definition: ROSCommands.h:103

References CommandTopic.

Referenced by Destroy(), and ROSBridgeStateChanged().

◆ GetGameWorld()

UWorld * UROSCommands::GetGameWorld ( )
private

◆ GetSettings()

UAgrarsenseSettings * UROSCommands::GetSettings ( )
private

◆ HandleAdvanceFrames()

void UROSCommands::HandleAdvanceFrames ( const FString &  Variable)
private

Definition at line 391 of file ROSCommands.cpp.

392{
393 int32 FrameCount = 0;
394 if (!Variable.IsNumeric())
395 {
396 return;
397 }
398
399 FrameCount = FCString::Atoi(*Variable);
400 if (FrameCount != 0)
401 {
402 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
403 if (AgrarsenseSettings)
404 {
405 AgrarsenseSettings->AdvanceFrameCount(FrameCount);
406 }
407 }
408}
void AdvanceFrameCount(int32 FramesToAdvance)
UAgrarsenseSettings * GetSettings()
Definition: ROSCommands.cpp:79

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

Referenced by AddCommands().

◆ HandleAdvanceOneFrame()

void UROSCommands::HandleAdvanceOneFrame ( const FString &  Variable)
private

Definition at line 382 of file ROSCommands.cpp.

383{
384 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
385 if (AgrarsenseSettings)
386 {
387 AgrarsenseSettings->AdvanceFrameCount(1);
388 }
389}

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

Referenced by AddCommands().

◆ HandleAdvanceTime()

void UROSCommands::HandleAdvanceTime ( const FString &  Variable)
private

Definition at line 410 of file ROSCommands.cpp.

411{
412 float Time = 0.0f;
413 if (!Variable.IsNumeric())
414 {
415 return;
416 }
417
418 Time = FCString::Atof(*Variable);
419 if (Time != 0.0f)
420 {
421 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
422 if (AgrarsenseSettings)
423 {
424 AgrarsenseSettings->AdvanceTime(Time);
425 }
426 }
427}
void AdvanceTime(float TimeToAdvance)

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

Referenced by AddCommands().

◆ HandleChangeMap()

void UROSCommands::HandleChangeMap ( const FString &  Variable)
private

Definition at line 429 of file ROSCommands.cpp.

430{
431 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
432 if (AgrarsenseSettings)
433 {
434 AgrarsenseSettings->ChangeMapByName(Variable);
435 }
436}
void ChangeMapByName(FString MapName)

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

Referenced by AddCommands().

◆ HandleChangeOverlapSensorBounds()

void UROSCommands::HandleChangeOverlapSensorBounds ( const FString &  Variable)
private

Definition at line 1016 of file ROSCommands.cpp.

1017{
1018 FString ID;
1019 FString BoundsString;
1020
1021 TArray<FString> Tokens;
1022 Variable.ParseIntoArray(Tokens, TEXT(" "), true);
1023
1024 if (Tokens.Num() < 2)
1025 {
1026 // Incoming parameters were invalid, return
1027 return;
1028 }
1029
1030 ID = Tokens[0];
1031 BoundsString = Tokens[1];
1032
1033 if (BoundsString.IsNumeric())
1034 {
1035 float Radius = FCString::Atof(*BoundsString);
1036
1037 AActor* Actor = IActorInformation::GetActorByID(ID);
1038 AOverlapSensor* Sensor = Cast<AOverlapSensor>(Actor);
1039 if (Sensor)
1040 {
1041 Sensor->SetOverlapBounds(FVector(Radius, Radius, Radius));
1042 }
1043 }
1044}
void SetOverlapBounds(const FVector &NewSize)
static AActor * GetActorByID(const FString &ID)

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

Referenced by AddCommands().

◆ HandleChangeOverlapSensorPosition()

void UROSCommands::HandleChangeOverlapSensorPosition ( const FString &  Variable)
private

Definition at line 1046 of file ROSCommands.cpp.

1047{
1048 FString ID;
1049 FString BoundsString;
1050
1051 TArray<FString> Tokens;
1052 Variable.ParseIntoArray(Tokens, TEXT(" "), true);
1053
1054 if (Tokens.Num() < 2)
1055 {
1056 // Incoming parameters were invalid, return
1057 return;
1058 }
1059
1060 ID = Tokens[0];
1061 BoundsString = Tokens[1];
1062
1063 FVector RelativePosition;
1064 TArray<FString> BoundsTokens;
1065 BoundsString.ParseIntoArray(BoundsTokens, TEXT(","), true);
1066
1067 if (BoundsTokens.Num() >= 3)
1068 {
1069 RelativePosition.X = FCString::Atof(*BoundsTokens[0]);
1070 RelativePosition.Y = FCString::Atof(*BoundsTokens[1]);
1071 RelativePosition.Z = FCString::Atof(*BoundsTokens[2]);
1072
1073 AActor* Actor = IActorInformation::GetActorByID(ID);
1074 AOverlapSensor* Sensor = Cast<AOverlapSensor>(Actor);
1075 if (Sensor)
1076 {
1077 Sensor->SetOverlapRelativePosition(RelativePosition);
1078 }
1079 }
1080}
void SetOverlapRelativePosition(const FVector &Vector)

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

Referenced by AddCommands().

◆ HandleDestroyActors()

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

Definition at line 1396 of file ROSCommands.cpp.

1397{
1398 TArray<FString> ParsedStrings;
1399 Variable.ParseIntoArray(ParsedStrings, TEXT(" "), true);
1400
1401 if (ParsedStrings.Num() != 2)
1402 {
1403 return;
1404 }
1405
1406 // Parse position
1407 TArray<FString> PositionComponents;
1408 ParsedStrings[0].ParseIntoArray(PositionComponents, TEXT(","), true);
1409
1410 if (PositionComponents.Num() != 3)
1411 {
1412 return;
1413 }
1414
1415 FVector Position(FCString::Atof(*PositionComponents[0]), FCString::Atof(*PositionComponents[1]), FCString::Atof(*PositionComponents[2]));
1416
1417 // Parse bounds
1418 TArray<FString> BoundsComponents;
1419 ParsedStrings[1].ParseIntoArray(BoundsComponents, TEXT(","), true);
1420
1421 if (BoundsComponents.Num() != 3)
1422 {
1423 return;
1424 }
1425
1426 FVector Bounds(FCString::Atof(*BoundsComponents[0]), FCString::Atof(*BoundsComponents[1]), FCString::Atof(*BoundsComponents[2]));
1427
1428 FTransform VolumeTransform;
1429 VolumeTransform.SetLocation(Position);
1430
1431 UWorld* World = GetGameWorld();
1432 if (World)
1433 {
1434 ADeletionVolume* Volume = World->SpawnActor<ADeletionVolume>(ADeletionVolume::StaticClass(), VolumeTransform);
1435 if (Volume)
1436 {
1437 // Change volume bounds
1438 Volume->ChangeOverlapBounds(Bounds);
1439
1440 // Destroy overlapping actors,
1441 // this Actor gets deleted automatically after calling this.
1442 Volume->DestroyOverlappingActors(OnlyTrees);
1443 }
1444 }
1445}
void DestroyOverlappingActors(bool OnlyTrees)
void ChangeOverlapBounds(FVector Bounds)
UWorld * GetGameWorld()
Definition: ROSCommands.cpp:69

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

Referenced by HandleDestroyActorsArea(), and HandleDestroyTreesArea().

◆ HandleDestroyActorsArea()

void UROSCommands::HandleDestroyActorsArea ( const FString &  Variable)
private

Definition at line 1391 of file ROSCommands.cpp.

1392{
1393 HandleDestroyActors(Variable, false);
1394}
void HandleDestroyActors(const FString &Variable, bool OnlyTrees)

References HandleDestroyActors().

Referenced by AddCommands().

◆ HandleDestroyAllSensors()

void UROSCommands::HandleDestroyAllSensors ( const FString &  Variable)
private

Definition at line 662 of file ROSCommands.cpp.

663{
665}
static void DestroyAllSensors(const UObject *WorldContextObject, bool DestroyDefaultVehicleSensors=false)

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

Referenced by AddCommands().

◆ HandleDestroyAllVehicles()

void UROSCommands::HandleDestroyAllVehicles ( const FString &  Variable)
private

Definition at line 672 of file ROSCommands.cpp.

673{
674 UWorld* World = GetGameWorld();
675 if (!World)
676 {
677 return;
678 }
679
680 TArray<AActor*> Vehicles;
681 UGameplayStatics::GetAllActorsOfClass(World, AVehicle::StaticClass(), Vehicles);
682 for (AActor* Actor : Vehicles)
683 {
684 AVehicle* Vehicle = Cast<AVehicle>(Actor);
685 if (Vehicle)
686 {
687 Vehicle->Destroy();
688 }
689 }
690}

References GetGameWorld(), and Vehicle.

Referenced by AddCommands().

◆ HandleDestroyAllWalkers()

void UROSCommands::HandleDestroyAllWalkers ( const FString &  Variable)
private

Definition at line 667 of file ROSCommands.cpp.

668{
670}
static void DestroyAllWalkers()

References UAssetLibrary::DestroyAllWalkers().

Referenced by AddCommands().

◆ HandleDestroyObjectByInstanceID()

void UROSCommands::HandleDestroyObjectByInstanceID ( const FString &  Variable)
private

Definition at line 692 of file ROSCommands.cpp.

693{
694 if (!Variable.IsNumeric())
695 {
696 return;
697 }
698
699 TArray<AActor*> Taggers;
700 UGameplayStatics::GetAllActorsOfClass(GetGameWorld(), ATagger::StaticClass(), Taggers);
701 ATagger* Tagger = Cast<ATagger>(Taggers[0]);
702
703 if (Tagger)
704 {
705 AActor* Actor = Tagger->GetActorByInstanceID(FCString::Atof(*Variable));
706 if (Actor)
707 {
708 Actor->Destroy();
709 }
710 }
711}
Definition: Tagger.h:51
AActor * GetActorByInstanceID(float InstanceID)
Definition: Tagger.cpp:226

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

Referenced by AddCommands().

◆ HandleDestroyTreesArea()

void UROSCommands::HandleDestroyTreesArea ( const FString &  Variable)
private

Definition at line 1386 of file ROSCommands.cpp.

1387{
1388 HandleDestroyActors(Variable, true);
1389}

References HandleDestroyActors().

Referenced by AddCommands().

◆ HandleDisableAllSensors()

void UROSCommands::HandleDisableAllSensors ( const FString &  Variable)
private

Definition at line 1319 of file ROSCommands.cpp.

1320{
1322}
static void DisableAllSensors(const UObject *WorldContextObject)

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

Referenced by AddCommands().

◆ HandleEnableAllSensors()

void UROSCommands::HandleEnableAllSensors ( const FString &  Variable)
private

Definition at line 1314 of file ROSCommands.cpp.

1315{
1317}
static void EnableAllSensors(const UObject *WorldContextObject)

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

Referenced by AddCommands().

◆ HandleExportAll()

void UROSCommands::HandleExportAll ( const FString &  Variable)
private

Definition at line 878 of file ROSCommands.cpp.

879{
880 // Below export functions do not need any incoming variable but require FString
881 FString EmptyString;
882
883 HandleExportWeather(EmptyString);
884 HandleExportWalkers(EmptyString);
885
886 // HandleExportSensors exports vehicles as well
887 //HandleExportVehicles(EmptyString);
888 HandleExportSensors(EmptyString);
889
890 HandleExportFoliage(EmptyString);
891 HandleExportProps(EmptyString);
892}

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

Referenced by AddCommands().

◆ HandleExportFoliage()

void UROSCommands::HandleExportFoliage ( const FString &  Variable)
private

Definition at line 961 of file ROSCommands.cpp.

962{
963 TArray<AInstancedActor*> FoliageActors = UAssetLibrary::GetAllAddedFoliageActors();
964 USimulatorJsonExporter::ExportInstancedActorsToJSON("ExportedFoliage", FoliageActors);
965}
static TArray< AInstancedActor * > GetAllAddedFoliageActors()
static FString ExportInstancedActorsToJSON(FString FileName, const TArray< AInstancedActor * > &Actors)

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

Referenced by AddCommands(), and HandleExportAll().

◆ HandleExportObjects()

void UROSCommands::HandleExportObjects ( const FString &  Variable)
private

Definition at line 967 of file ROSCommands.cpp.

968{
969 UWorld* World = GetGameWorld();
970 if (!World)
971 {
972 return;
973 }
974
975 TArray<AActor*> Taggers;
976 UGameplayStatics::GetAllActorsOfClass(World, ATagger::StaticClass(), Taggers);
977
978 if (ATagger* Tagger = Cast<ATagger>(Taggers[0]))
979 {
980 Tagger->ExportObjectLocationsToCSV();
981 }
982}

References GetGameWorld().

Referenced by AddCommands().

◆ HandleExportProps()

void UROSCommands::HandleExportProps ( const FString &  Variable)
private

Definition at line 984 of file ROSCommands.cpp.

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

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

Referenced by AddCommands(), and HandleExportAll().

◆ HandleExportSensors()

void UROSCommands::HandleExportSensors ( const FString &  Variable)
private

Definition at line 928 of file ROSCommands.cpp.

929{
930 UWorld* World = GetGameWorld();
931 if (!World)
932 {
933 return;
934 }
935
936 // Export all Vehicles and attached sensors
937 TArray<AActor*> Vehicles;
938 UGameplayStatics::GetAllActorsOfClass(World, AVehicle::StaticClass(), Vehicles);
939 for (AActor* Actor : Vehicles)
940 {
941 AVehicle* VehiclePtr = Cast<AVehicle>(Actor);
942 if (VehiclePtr)
943 {
944 VehiclePtr->ExportToJsonFile("ExportedVehicle");
945 }
946 }
947
948 // Export all Sensors separately as well
949 TArray<AActor*> Sensors;
950 UGameplayStatics::GetAllActorsOfClass(World, ASensor::StaticClass(), Sensors);
951 for (AActor* Actor : Sensors)
952 {
953 ASensor* SensorPtr = Cast<ASensor>(Actor);
954 if (SensorPtr)
955 {
956 SensorPtr->ExportToJsonFile("ExportedSensor");
957 }
958 }
959}
Definition: Sensor.h:45
FString ExportToJsonFile(const FString &FileName)
Definition: Sensor.cpp:154
FString ExportToJsonFile(const FString &FileName)
Definition: Vehicle.cpp:269

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

Referenced by AddCommands(), and HandleExportAll().

◆ HandleExportVehicles()

void UROSCommands::HandleExportVehicles ( const FString &  Variable)
private

Definition at line 915 of file ROSCommands.cpp.

916{
917 TArray<FVehicleData> Vehicles = UAssetLibrary::GetSpawnedVehicles();
918 for (const FVehicleData& VehicleData : Vehicles)
919 {
920 AVehicle* VehiclePtr = VehicleData.Vehicle.Get();
921 if (VehiclePtr)
922 {
923 VehiclePtr->ExportToJsonFile("ExportedVehicle");
924 }
925 }
926}
static TArray< FVehicleData > GetSpawnedVehicles()

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

Referenced by AddCommands().

◆ HandleExportWalkers()

void UROSCommands::HandleExportWalkers ( const FString &  Variable)
private

Definition at line 903 of file ROSCommands.cpp.

904{
905 TArray<AWalker*> Walkers = UAssetLibrary::GetAllWalkers();
906 for (AWalker* Walker : Walkers)
907 {
908 if (Walker)
909 {
910 Walker->ExportToJsonFile("ExportedWalker");
911 }
912 }
913}
Definition: Walker.h:30
static TArray< AWalker * > GetAllWalkers()

References UAssetLibrary::GetAllWalkers(), and Walker.

Referenced by AddCommands(), and HandleExportAll().

◆ HandleExportWeather()

void UROSCommands::HandleExportWeather ( const FString &  Variable)
private

Definition at line 894 of file ROSCommands.cpp.

895{
897 if (Weather)
898 {
899 Weather->ExportToJSON("ExportedWeather");
900 }
901}
FString ExportToJSON(const FString &FileName)
Definition: Weather.cpp:121
static AWeather * GetWeatherActor(const UObject *WorldContextObject)

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 1216 of file ROSCommands.cpp.

1217{
1218 // This function overrides the current parameters of the Drone identified by the given ID,
1219 // moving the Drone to the specified x,y,z position and stopping upon reaching the target.
1220 // Usage: "movedroneto drone 0,0,0" where 'drone' is the Drone ID.
1221
1222 FString ID;
1223 FString TransformString;
1224
1225 // Split the ID and rest of the message
1226 TArray<FString> Tokens;
1227 Variable.ParseIntoArray(Tokens, TEXT(" "), true);
1228 if (Tokens.Num() >= 2)
1229 {
1230 ID = Tokens[0];
1231 TransformString = Variable.RightChop(ID.Len() + 1);
1232 }
1233 else
1234 {
1235 return;
1236 }
1237
1238 // Check if this ID matches any Actor
1239 AActor* Actor = IActorInformation::GetActorByID(ID);
1240 if (!Actor)
1241 {
1242 return;
1243 }
1244
1245 APIDDrone* Drone = Cast<APIDDrone>(Actor);
1246 if (!Drone)
1247 {
1248 return;
1249 }
1250
1251 // Parse rest of the string to Transform
1252 TArray<FString> Components;
1253 TransformString.ParseIntoArray(Components, TEXT(","), true);
1254
1255 if (Components.Num() >= 3)
1256 {
1257 FVector Location;
1258 FQuat Rotation;
1259
1260 // Convert the first three components to float values for location
1261 float X = FCString::Atof(*Components[0]);
1262 float Y = FCString::Atof(*Components[1]);
1263 float Z = FCString::Atof(*Components[2]);
1264
1265 Location = FVector(X, Y, Z);
1266
1267 if (Components.Num() >= 6)
1268 {
1269 // If there are six or more components, try to parse them as rotation values
1270 float Pitch = FCString::Atof(*Components[3]);
1271 float Yaw = FCString::Atof(*Components[4]);
1272 float Roll = FCString::Atof(*Components[5]);
1273
1274 // Convert the Euler angles to a quaternion
1275 Rotation = FQuat(FRotator(Pitch, Yaw, Roll));
1276 }
1277
1278 FTransform Transform;
1279 Transform.SetLocation(Location);
1280 Transform.SetRotation(Rotation);
1281
1282 // Create new drone parameters
1283 FDroneParameters NewParams;
1285 NewParams.DroneEndAction = EndAction;
1286 //NewParams.Points.Add(Transform);
1287
1288 Drone->ChangeDroneParameters(NewParams);
1289
1290 // Change drone parameters
1291 Drone->MoveDroneToPosition(Transform);
1292 }
1293}
EDroneEndAction DroneEndAction
EDroneAction DroneAction

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 1092 of file ROSCommands.cpp.

1093{
1095}
void HandleMoveDroneTo(const FString &Variable, EDroneEndAction EndAction)

References HandleMoveDroneTo(), and Stop.

Referenced by AddCommands().

◆ HandleMoveWalkerTo()

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

Definition at line 1097 of file ROSCommands.cpp.

1098{
1099 // This function overrides the current parameters of the Walker identified by the given ID,
1100 // moving the Walker to the specified x,y,z position and stopping upon reaching the target.
1101 // Usage: "movewalkerto reindeer 0,0,0" where 'reindeer' is the Walker ID.
1102
1103 FString ID;
1104 FString TransformString;
1105
1106 // Split the ID and rest of the message
1107 TArray<FString> Tokens;
1108 Variable.ParseIntoArray(Tokens, TEXT(" "), true);
1109 if (Tokens.Num() >= 2)
1110 {
1111 ID = Tokens[0];
1112 TransformString = Variable.RightChop(ID.Len() + 1);
1113 }
1114 else
1115 {
1116 return;
1117 }
1118
1119 // Check if this ID matches any Actor
1120 AActor* Actor = IActorInformation::GetActorByID(ID);
1121 if (!Actor)
1122 {
1123 return;
1124 }
1125
1126 AWalker* Walker = Cast<AWalker>(Actor);
1127 if (!Walker)
1128 {
1129 return;
1130 }
1131
1132 // Parse rest of the string to Transform
1133 TArray<FString> Components;
1134 TransformString.ParseIntoArray(Components, TEXT(","), true);
1135
1136 if (Components.Num() >= 3)
1137 {
1138 FVector Location;
1139 FQuat Rotation;
1140
1141 // Convert the first three components to float values for location
1142 float X = FCString::Atof(*Components[0]);
1143 float Y = FCString::Atof(*Components[1]);
1144 float Z = FCString::Atof(*Components[2]);
1145
1146 Location = FVector(X, Y, Z);
1147
1148 if (Components.Num() >= 6)
1149 {
1150 // If there are six or more components, try to parse them as rotation values
1151 float Pitch = FCString::Atof(*Components[3]);
1152 float Yaw = FCString::Atof(*Components[4]);
1153 float Roll = FCString::Atof(*Components[5]);
1154
1155 // Convert the Euler angles to a quaternion
1156 Rotation = FQuat(FRotator(Pitch, Yaw, Roll));
1157 }
1158
1159 FTransform Transform;
1160 Transform.SetLocation(Location);
1161 Transform.SetRotation(Rotation);
1162
1163 // Create new walker parameters
1164 FWalkerParameters NewParams;
1166 NewParams.WalkerEndAction = EndAction;
1167 NewParams.Points.Add(Transform);
1168
1169 // Change Walker parameters
1170 Walker->ChangeWalkerParameters(NewParams);
1171 }
1172}
EWalkerAction WalkerAction
TArray< FTransform > Points
EWalkerEndAction WalkerEndAction

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 1082 of file ROSCommands.cpp.

1083{
1085}
void HandleMoveWalkerTo(const FString &Variable, EWalkerEndAction EndAction)

References Destroy, and HandleMoveWalkerTo().

Referenced by AddCommands().

◆ HandleMoveWalkerToAndStop()

void UROSCommands::HandleMoveWalkerToAndStop ( const FString &  Variable)
private

Definition at line 1087 of file ROSCommands.cpp.

References HandleMoveWalkerTo(), and Stop.

Referenced by AddCommands().

◆ HandlePauseSimulator()

void UROSCommands::HandlePauseSimulator ( const FString &  Variable)
private

Definition at line 364 of file ROSCommands.cpp.

365{
366 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
367 if (AgrarsenseSettings)
368 {
369 AgrarsenseSettings->PauseSimulationEndOfThisFrame();
370 }
371}

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

Referenced by AddCommands().

◆ HandlePrintAllSensors()

void UROSCommands::HandlePrintAllSensors ( const FString &  Variable)
private

Definition at line 731 of file ROSCommands.cpp.

732{
733 PrintActorInformation(Variable, ASensor::StaticClass(), "sensor");
734}
void PrintActorInformation(const FString &Variable, UClass *ActorClass, const FString &ActorTypeName)

References PrintActorInformation().

Referenced by AddCommands().

◆ HandlePrintAllVehicles()

void UROSCommands::HandlePrintAllVehicles ( const FString &  Variable)
private

Definition at line 736 of file ROSCommands.cpp.

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

References PrintActorInformation().

Referenced by AddCommands().

◆ HandlePrintAllWalkers()

void UROSCommands::HandlePrintAllWalkers ( const FString &  Variable)
private

Definition at line 741 of file ROSCommands.cpp.

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

References PrintActorInformation().

◆ HandlePrintAvailableCommands()

void UROSCommands::HandlePrintAvailableCommands ( const FString &  Variable)
private

Definition at line 329 of file ROSCommands.cpp.

330{
331 if (!CommandTopic)
332 {
333 return;
334 }
335
336 FString message = "Available Simulator ROS commands {COMMAND} {VALUE} || ";
337
338 for (const TPair<FString, FCommand>& CommandPair : CommandHandlers)
339 {
340 const FString& CommandString = CommandPair.Key;
341 const FCommand& CommandInfo = CommandPair.Value;
342 if (CommandInfo.DefaultValue.IsEmpty())
343 {
344 message += FString::Printf(TEXT("%s || "), *CommandString);
345 }
346 else
347 {
348 message += FString::Printf(TEXT("%s %s || "), *CommandString, *CommandInfo.DefaultValue);
349 }
350 }
351
352 SimulatorLog::Log(message);
353}
static void Log(const FString &Message, bool LogToTextFile=true, bool LogToROS=true)
FString DefaultValue
Definition: ROSCommands.h:35

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

Referenced by AddCommands().

◆ HandlePrintIds()

void UROSCommands::HandlePrintIds ( const FString &  Variable)
private

Definition at line 785 of file ROSCommands.cpp.

786{
788}
static void PrintAllIds()

References IActorInformation::PrintAllIds().

Referenced by AddCommands().

◆ HandlePrintMaps()

void UROSCommands::HandlePrintMaps ( const FString &  Variable)
private

Definition at line 713 of file ROSCommands.cpp.

714{
715 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
716 if (AgrarsenseSettings)
717 {
718 TArray<FString> Maps = AgrarsenseSettings->GetMapNames();
719
720 FString message;
721
722 for (const FString& map : Maps)
723 {
724 message += FString::Printf(TEXT("%s, "), *map);
725 }
726
727 SimulatorLog::Log(message);
728 }
729}
TArray< FString > GetMapNames() const

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.

356{
357 UWorld* World = GetGameWorld();
358 if (GEngine && World)
359 {
360 GEngine->Exec(World, TEXT("quit force"));
361 }
362}

References GetGameWorld().

Referenced by AddCommands().

◆ HandleResetDrone()

void UROSCommands::HandleResetDrone ( const FString &  Variable)
private

Definition at line 1203 of file ROSCommands.cpp.

1204{
1205 AActor* Actor = IActorInformation::GetActorByID(Variable);
1206 if (Actor)
1207 {
1208 APIDDrone* Drone = Cast<APIDDrone>(Actor);
1209 if (Drone)
1210 {
1211 Drone->ResetDroneEvent();
1212 }
1213 }
1214}

References Drone, and IActorInformation::GetActorByID().

Referenced by AddCommands().

◆ HandleResumeWalker()

void UROSCommands::HandleResumeWalker ( const FString &  Variable)
private

Definition at line 1179 of file ROSCommands.cpp.

1180{
1181 HandleSetWalkerMovement(Variable, false);
1182}
void HandleSetWalkerMovement(const FString &Variable, bool IsPaused)

References HandleSetWalkerMovement().

Referenced by AddCommands().

◆ HandleSetAllSensorsEnabled()

void UROSCommands::HandleSetAllSensorsEnabled ( const FString &  Variable)
private

Definition at line 1295 of file ROSCommands.cpp.

1296{
1297 bool EnableSensors;
1298 if (!TryParseBoolean(Variable, EnableSensors))
1299 {
1300 // Failed to parse, return
1301 return;
1302 }
1303
1304 if (EnableSensors)
1305 {
1307 }
1308 else
1309 {
1311 }
1312}
bool TryParseBoolean(const FString &String, bool &OutBool) const

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

Referenced by AddCommands().

◆ HandleSetGlobalTargetFrameRate()

void UROSCommands::HandleSetGlobalTargetFrameRate ( const FString &  Variable)
private

Definition at line 790 of file ROSCommands.cpp.

791{
792 if (Variable.IsNumeric())
793 {
794 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
795 if (AgrarsenseSettings)
796 {
797 int32 IntValue = FCString::Atoi(*Variable);
798 AgrarsenseSettings->SetGlobalTargetFrameRate(IntValue);
799 }
800 }
801}
void SetGlobalTargetFrameRate(int32 NewTargetFrameRate)

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

Referenced by AddCommands().

◆ HandleSetGlobalTimeDilation()

void UROSCommands::HandleSetGlobalTimeDilation ( const FString &  Variable)
private

Definition at line 803 of file ROSCommands.cpp.

804{
805 if (Variable.IsNumeric())
806 {
807 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
808 if (AgrarsenseSettings)
809 {
810 float FloatValue = FCString::Atof(*Variable);
811 AgrarsenseSettings->SetGlobalTimeDilation(FloatValue);
812 }
813 }
814}
void SetGlobalTimeDilation(float TimeDilation)

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

Referenced by AddCommands().

◆ HandleSetGrassVisibility()

void UROSCommands::HandleSetGrassVisibility ( const FString &  Variable)
private

Definition at line 841 of file ROSCommands.cpp.

842{
843 bool RenderGrass;
844 if (!TryParseBoolean(Variable, RenderGrass))
845 {
846 // Failed to parse, return
847 return;
848 }
849
850 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
851 if (AgrarsenseSettings)
852 {
853 AgrarsenseSettings->SetGrassVisibility(RenderGrass);
854 }
855}
void SetGrassVisibility(bool Visible)

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

Referenced by AddCommands().

◆ HandleSetNaniteMaxPixelsPerEdge()

void UROSCommands::HandleSetNaniteMaxPixelsPerEdge ( const FString &  Variable)
private

Definition at line 1373 of file ROSCommands.cpp.

1374{
1375 if (Variable.IsNumeric())
1376 {
1377 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
1378 if (AgrarsenseSettings)
1379 {
1380 float Value = FCString::Atof(*Variable);
1381 AgrarsenseSettings->SetNaniteMaxPixelsPerEdge(Value);
1382 }
1383 }
1384}
void SetNaniteMaxPixelsPerEdge(float MaxPixelsPerEdge=1.0f)

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

Referenced by AddCommands().

◆ HandleSetQualityLevel()

void UROSCommands::HandleSetQualityLevel ( const FString &  Variable)
private

Definition at line 816 of file ROSCommands.cpp.

817{
818 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
819 if (AgrarsenseSettings)
820 {
821 AgrarsenseSettings->SetQualityLevelFromString(Variable);
822 }
823}
void SetQualityLevelFromString(const FString &QualityLevelString)

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

Referenced by AddCommands().

◆ HandleSetSaveCombinedPointcloudToDisk()

void UROSCommands::HandleSetSaveCombinedPointcloudToDisk ( const FString &  Variable)
private

Definition at line 857 of file ROSCommands.cpp.

858{
859 bool Save;
860 if (!TryParseBoolean(Variable, Save))
861 {
862 // Failed to parse, return
863 return;
864 }
865
867 if (LidarManager)
868 {
869 LidarManager->SetSaveCombinedCloudToDisk(Save);
870 }
871}
void SetSaveCombinedCloudToDisk(bool bSaveCombinedCloud)
static ALidarManager * GetLidarManager(const UObject *WorldContextObject)

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

Referenced by AddCommands().

◆ HandleSetSensorEnabled()

void UROSCommands::HandleSetSensorEnabled ( const FString &  Variable)
private

Definition at line 1324 of file ROSCommands.cpp.

1325{
1326 TArray<FString> Tokens;
1327 Variable.ParseIntoArray(Tokens, TEXT(" "), true);
1328 if (Tokens.Num() < 2)
1329 {
1330 // Not enough arguments, return
1331 return;
1332 }
1333
1334 const FString& ID = Tokens[0];
1335
1336 AActor* Actor = IActorInformation::GetActorByID(ID);
1337 if (!Actor)
1338 {
1339 return;
1340 }
1341
1342 ASensor* Sensor = Cast<ASensor>(Actor);
1343 if (!Sensor)
1344 {
1345 return;
1346 }
1347
1348 FString BooleanString = Tokens[1].ToLower();
1349
1350 bool SimulateSensor;
1351 if (!TryParseBoolean(BooleanString, SimulateSensor))
1352 {
1353 // Failed to parse, return
1354 return;
1355 }
1356
1357 Sensor->SetSimulateSensor(SimulateSensor);
1358}
void SetSimulateSensor(bool SimulateSensor)
Definition: Sensor.h:160

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.

448{
449 if (!Variable.IsNumeric())
450 {
451 return;
452 }
453
454 float Radius = FCString::Atof(*Variable);
455
456 if (UWorld* World = GetGameWorld())
457 {
458 if (ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World))
459 {
460 if (AOverlapSensor* OverlapSensor = Spectator->GetOverlapSensor())
461 {
462 OverlapSensor->SetOverlapBounds(FVector(Radius, Radius, Radius));
463 }
464 }
465 }
466}
static ASpectator * GetSpectator(const UObject *WorldContextObject)

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

Referenced by AddCommands().

◆ HandleSetWalkerMovement()

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

Definition at line 1184 of file ROSCommands.cpp.

1185{
1186 AActor* Actor = IActorInformation::GetActorByID(Variable);
1187 AWalker* Walker = Cast<AWalker>(Actor);
1188 if (!Walker)
1189 {
1190 return;
1191 }
1192
1193 if (IsPaused)
1194 {
1195 Walker->PauseWalker();
1196 }
1197 else
1198 {
1199 Walker->ResumeWalker();
1200 }
1201}

References IActorInformation::GetActorByID(), and Walker.

Referenced by HandleResumeWalker(), and HandleStopWalker().

◆ HandleSetWorldRendering()

void UROSCommands::HandleSetWorldRendering ( const FString &  Variable)
private

Definition at line 825 of file ROSCommands.cpp.

826{
827 bool RenderWorld;
828 if (!TryParseBoolean(Variable, RenderWorld))
829 {
830 // Failed to parse, return
831 return;
832 }
833
834 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
835 if (AgrarsenseSettings)
836 {
837 AgrarsenseSettings->SetWorldRendering(RenderWorld);
838 }
839}
void SetWorldRendering(bool enabled)

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

Referenced by AddCommands().

◆ HandleSetWPO()

void UROSCommands::HandleSetWPO ( const FString &  Variable)
private

Definition at line 1360 of file ROSCommands.cpp.

1361{
1362 if (Variable.IsNumeric())
1363 {
1364 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
1365 if (AgrarsenseSettings)
1366 {
1367 int32 IntValue = FCString::Atoi(*Variable);
1368 AgrarsenseSettings->SetWorldPositionOffsetRenderDistance(IntValue);
1369 }
1370 }
1371}
void SetWorldPositionOffsetRenderDistance(int32 WorldPositionOffsetDistance)

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

Referenced by AddCommands().

◆ HandleSpawnObjects()

void UROSCommands::HandleSpawnObjects ( const FString &  Variable)
private

Definition at line 873 of file ROSCommands.cpp.

874{
876}
static void ParseAndOperateJSONFile(const FString &Path)

References USimulatorJsonParser::ParseAndOperateJSONFile().

Referenced by AddCommands().

◆ HandleStopWalker()

void UROSCommands::HandleStopWalker ( const FString &  Variable)
private

Definition at line 1174 of file ROSCommands.cpp.

1175{
1176 HandleSetWalkerMovement(Variable, true);
1177}

References HandleSetWalkerMovement().

Referenced by AddCommands().

◆ HandleTeleportActorByID()

void UROSCommands::HandleTeleportActorByID ( const FString &  Variable)
private

Definition at line 557 of file ROSCommands.cpp.

558{
559 FString ID;
560 FString TransformString;
561
562 // Split the ID and rest of the message
563 TArray<FString> Tokens;
564 Variable.ParseIntoArray(Tokens, TEXT(" "), true);
565 if (Tokens.Num() >= 2)
566 {
567 ID = Tokens[0];
568 TransformString = Variable.RightChop(ID.Len() + 1);
569 }
570 else
571 {
572 SimulatorLog::Log("Invalid input. Input should be in format: ID,X,Y,Z or ID,X,Y,Z,YAW,PITCH,ROLL");
573 return;
574 }
575
576 // Check if this ID matches any Actor
577 AActor* Actor = IActorInformation::GetActorByID(ID);
578 if (!Actor)
579 {
580 FString log = FString::Printf(TEXT("Could not find Actor with ID: %s"), *ID);
582 return;
583 }
584
585 // Parse rest of the string to Transform
586 TArray<FString> Components;
587 TransformString.ParseIntoArray(Components, TEXT(","), true);
588
589 if (Components.Num() >= 3)
590 {
591 FVector Location;
592 FQuat Rotation;
593
594 // Convert the first three components to float values for location
595 float X = FCString::Atof(*Components[0]);
596 float Y = FCString::Atof(*Components[1]);
597 float Z = FCString::Atof(*Components[2]);
598
599 Location = FVector(X, Y, Z);
600
601 if (Components.Num() >= 6)
602 {
603 // If there are six or more components, try to parse them as rotation values
604 float Pitch = FCString::Atof(*Components[3]);
605 float Yaw = FCString::Atof(*Components[4]);
606 float Roll = FCString::Atof(*Components[5]);
607
608 // Convert the Euler angles to a quaternion
609 Rotation = FQuat(FRotator(Pitch, Yaw, Roll));
610 }
611
612 FTransform Transform;
613 Transform.SetLocation(Location);
614 Transform.SetRotation(Rotation);
615
616 if (InMeters)
617 {
619 }
620
621#if WITH_EDITOR
622 UE_LOG(LogTemp, Warning, TEXT("Teleporting Actor with ID: %s to: %s"), *ID, *TransformString);
623#endif
624
625 // Check if this Actor is Vehicle
626 AVehicle* VehiclePtr = Cast<AVehicle>(Actor);
627 if (VehiclePtr)
628 {
629 // Disable vehicle physics so it can be teleported
630 VehiclePtr->TogglePhysics(false);
631
632 Actor->SetActorTransform(Transform);
633
634 // Enable vehicle physics back on after teleporting vehicle
635 VehiclePtr->TogglePhysics(true);
636 }
637 else
638 {
639 // Else set the Actor transform
640 Actor->SetActorTransform(Transform);
641 }
642 }
643}
void TogglePhysics(bool isOn)
static bool AlignTransformFromGroundInMeters(AActor *Actor, FTransform &InTransform)

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.

527{
528 InMeters = true;
529 HandleTeleportActorByID(Variable);
530 InMeters = false;
531}

References HandleTeleportActorByID(), and InMeters.

Referenced by AddCommands().

◆ HandleTeleportSpectator()

void UROSCommands::HandleTeleportSpectator ( const FString &  Variable)
private

Definition at line 475 of file ROSCommands.cpp.

476{
477 // Split the comma-separated string into components
478 TArray<FString> Components;
479 Variable.ParseIntoArray(Components, TEXT(","), true);
480
481 if (Components.Num() >= 3)
482 {
483 FVector Location;
484 FQuat Rotation;
485
486 // Convert the first three components to float values for location
487 float X = FCString::Atof(*Components[0]);
488 float Y = FCString::Atof(*Components[1]);
489 float Z = FCString::Atof(*Components[2]);
490
491 Location = FVector(X, Y, Z);
492
493 if (Components.Num() >= 6)
494 {
495 // If there are six or more components, try to parse them as rotation values
496 float Pitch = FCString::Atof(*Components[3]);
497 float Yaw = FCString::Atof(*Components[4]);
498 float Roll = FCString::Atof(*Components[5]);
499
500 // Convert the Euler angles to a quaternion
501 Rotation = FQuat(FRotator(Pitch, Yaw, Roll));
502 }
503
504 UWorld* World = GetGameWorld();
505 if (World)
506 {
508 if (Spectator)
509 {
510 FTransform Transform;
511 Transform.SetLocation(Location);
512 Transform.SetRotation(Rotation);
513
514
516 {
518 }
519
520 Spectator->TeleportSpectator(Transform);
521 }
522 }
523 }
524}
void TeleportSpectator(const FTransform &Transform)
Definition: Spectator.cpp:75
bool TeleportSpectatorHeight
Definition: ROSCommands.h:110

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.

534{
535 if (!Variable.IsNumeric())
536 {
537 return;
538 }
539
540 TArray<AActor*> Taggers;
541 UGameplayStatics::GetAllActorsOfClass(GetGameWorld(), ATagger::StaticClass(), Taggers);
542 ATagger* Tagger = Cast<ATagger>(Taggers[0]);
543
544 if (Tagger)
545 {
546 AActor* Actor = Tagger->GetActorByInstanceID(FCString::Atof(*Variable));
547 if (Actor)
548 {
550 {
551 Spectator->TeleportSpectator(Actor->GetActorTransform());
552 }
553 }
554 }
555}

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

Referenced by AddCommands().

◆ HandleTeleportSpectatorHeight()

void UROSCommands::HandleTeleportSpectatorHeight ( const FString &  Variable)
private

Definition at line 468 of file ROSCommands.cpp.

469{
471 HandleTeleportSpectator(Variable);
473}

References HandleTeleportSpectator(), and TeleportSpectatorHeight.

Referenced by AddCommands().

◆ HandleTryDestroyObjectByID()

void UROSCommands::HandleTryDestroyObjectByID ( const FString &  Variable)
private

Definition at line 645 of file ROSCommands.cpp.

646{
647 bool success = IActorInformation::DestroyActorByID(Variable);
648
649 FString Message;
650 if (success)
651 {
652 Message = FString::Printf(TEXT("Object with ID %s successfully destroyed."), *Variable);
653 }
654 else
655 {
656 Message = FString::Printf(TEXT("Failed to destroy object with ID %s."), *Variable);
657 }
658
659 SimulatorLog::Log(Message);
660}
static bool DestroyActorByID(const FString &ID)

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.

374{
375 UAgrarsenseSettings* AgrarsenseSettings = GetSettings();
376 if (AgrarsenseSettings)
377 {
378 AgrarsenseSettings->UnPauseSimulation();
379 }
380}

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

Referenced by AddCommands().

◆ HandleUnrealCommand()

void UROSCommands::HandleUnrealCommand ( const FString &  Variable)
private

Definition at line 438 of file ROSCommands.cpp.

439{
440 UWorld* World = GetGameWorld();
441 if (GEngine && World)
442 {
443 GEngine->Exec(World, *Variable);
444 }
445}

References GetGameWorld().

Referenced by AddCommands().

◆ HandleVehicleMeshVisibility()

void UROSCommands::HandleVehicleMeshVisibility ( const FString &  Variable)
private

Definition at line 1447 of file ROSCommands.cpp.

1448{
1449 TArray<FString> Tokens;
1450 Variable.ParseIntoArray(Tokens, TEXT(" "), true);
1451
1452 if (Tokens.Num() < 2)
1453 {
1454 return;
1455 }
1456
1457 const FString& ID = Tokens[0];
1458 const FString Param = Variable.RightChop(ID.Len() + 1);
1459
1460 bool bVisible = true;
1461 if (!TryParseBoolean(Param, bVisible))
1462 {
1463 return; // Invalid parameter
1464 }
1465
1466 if (AActor* Actor = IActorInformation::GetActorByID(ID))
1467 {
1468 if (AVehicle* Vehicle = Cast<AVehicle>(Actor))
1469 {
1470 Vehicle->SetVehicleMeshVisibility(bVisible);
1471 }
1472 }
1473}

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

Referenced by AddCommands().

◆ HandleVisualizeOverlapSensorsBounds()

void UROSCommands::HandleVisualizeOverlapSensorsBounds ( const FString &  Variable)
private

Definition at line 990 of file ROSCommands.cpp.

991{
992 bool Visualize;
993 if (!TryParseBoolean(Variable, Visualize))
994 {
995 // Failed to parse, return
996 return;
997 }
998
999 UWorld* World = GetGameWorld();
1000 if (World)
1001 {
1002 TArray<AActor*> OverlapSensors;
1003 UGameplayStatics::GetAllActorsOfClass(World, AOverlapSensor::StaticClass(), OverlapSensors);
1004
1005 for (AActor* SensorActor : OverlapSensors)
1006 {
1007 AOverlapSensor* Sensor = Cast<AOverlapSensor>(SensorActor);
1008 if (Sensor)
1009 {
1010 Sensor->SetVisualizeOverlapArea(Visualize);
1011 }
1012 }
1013 }
1014}
void SetVisualizeOverlapArea(bool Visualize)

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

Referenced by AddCommands().

◆ Init()

void UROSCommands::Init ( )
private

Definition at line 46 of file ROSCommands.cpp.

47{
49
51 if (ROSHandler)
52 {
53 ROSHandler->OnROSStateChanged.AddUniqueDynamic(this, &UROSCommands::ROSBridgeStateChanged);
54 }
55
57}
static UROSHandler * GetROSHandle(const UObject *WorldContextObject)
void AddCommands()
Definition: ROSCommands.cpp:84
void SetupROSCommandTopic()
void ROSBridgeStateChanged(EROSState state)
FROSDelegate_ROState OnROSStateChanged
Definition: ROSHandler.h:81

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.

257{
258 // Parse incoming string message into {COMMAND} {VARIABLE} format
259 int32 SpaceIndex;
260 FString Command;
261 FString Variable;
262
263 if (Message.FindChar(' ', SpaceIndex))
264 {
265 // Extract the command as the substring before the first space
266 Command = Message.Left(SpaceIndex).ToLower();
267
268 // Extract the rest of the message as the variable
269 Variable = Message.Mid(SpaceIndex + 1);
270 }
271 else
272 {
273 // If no space is found, consider the entire message as the command
274 Command = Message.ToLower();
275 }
276
277 // Log incoming message into text file for debugging purposes
278 FString CommandMsg = FString::Printf(TEXT("Incoming [command variable]: %s %s"), *Command, *Variable);
279 SimulatorLog::Log(CommandMsg);
280
281 FCommand* CommandInfo = CommandHandlers.Find(Command);
282 if (CommandInfo)
283 {
284 // Check if enough time has passed since the last execution.
285 double CurrentTime = FPlatformTime::Seconds();
286 double TimeSinceLastExecution = CurrentTime - CommandInfo->LastExecutionTime;
287
288 if (TimeSinceLastExecution >= CommandInfo->CooldownTime)
289 {
290 // Call the handler function with the variable.
291 (this->*(CommandInfo->Handler))(Variable);
292
293 // Update the last execution time.
294 CommandInfo->LastExecutionTime = CurrentTime;
295 }
296 else
297 {
298 float CoolDownTimeLeft = CommandInfo->CooldownTime - TimeSinceLastExecution;
299 FString Msg = FString::Printf(TEXT("Command '%s' on cooldown. Retry in %.2f sec."), *Command, CoolDownTimeLeft);
301 }
302 }
303 else
304 {
305 FString Msg = FString::Printf(TEXT("Couldn't find command: '%s'"), *Command);
307 }
308}
double LastExecutionTime
Definition: ROSCommands.h:34
float CooldownTime
Definition: ROSCommands.h:33
CommandHandler Handler
Definition: ROSCommands.h:32

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 746 of file ROSCommands.cpp.

747{
748 TArray<AActor*> Actors;
749 UGameplayStatics::GetAllActorsWithInterface(GetGameWorld(), UActorInformation::StaticClass(), Actors);
750
751 TArray<AActor*> TypedActors;
752 for (AActor* Actor : Actors)
753 {
754 if (Actor->IsA(ActorClass))
755 {
756 TypedActors.Add(Actor);
757 }
758 }
759
760 FString Msg;
761 if (!TypedActors.IsEmpty())
762 {
763 Msg = FString::Printf(TEXT("Simulation has %d %ss \n "), TypedActors.Num(), *ActorTypeName);
764 for (AActor* Actor : TypedActors)
765 {
766 if (Actor)
767 {
768 if (Actor->Implements<UActorInformation>())
769 {
770 FString ActorInfo = IActorInformation::Execute_GetActorInformation(Actor);
771 Msg += FString::Printf(TEXT("%s \n \n "), *ActorInfo);
772 }
773
774 }
775 }
776 }
777 else
778 {
779 Msg = FString::Printf(TEXT("Simulation has 0 %ss."), *ActorTypeName);
780 }
781
783}

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.

195{
196 switch (state)
197 {
200 break;
201
204 break;
205 }
206}

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

Referenced by Init().

◆ SetupROSCommandTopic()

void UROSCommands::SetupROSCommandTopic ( )
private

Definition at line 220 of file ROSCommands.cpp.

221{
222 UWorld* World = GetGameWorld();
223 if (!World)
224 {
225 return;
226 }
227
229 if (!CommandTopic && RosInstance && RosInstance->IsROSConnected())
230 {
231 CommandTopic = NewObject<UTopic>(UTopic::StaticClass());
232 CommandTopic->Init(RosInstance->ROSIntegrationCore, TEXT("/agrarsense/in/commands"), TEXT("std_msgs/String"));
233 CommandTopic->Advertise();
234
235 // Create a std::function callback object
236 std::function<void(TSharedPtr<FROSBaseMsg>)> SubscribeCallback = [this](TSharedPtr<FROSBaseMsg> msg) -> void
237 {
238 auto Concrete = StaticCastSharedPtr<ROSMessages::std_msgs::String>(msg);
239 if (Concrete.IsValid())
240 {
241 FString message = *(Concrete->_Data);
242 AsyncTask(ENamedThreads::GameThread, [this, message]()
243 {
244 // Parse message on GameThread since many commands are NOT thread-safe
245 ParseIncomingMessage(message);
246 });
247 }
248 return;
249 };
250
251 // Subscribe to the topic
252 CommandTopic->Subscribe(SubscribeCallback);
253 }
254}
static UROSIntegrationGameInstance * GetROSGameInstance(const UObject *WorldContextObject)
UROSIntegrationGameInstance * RosInstance
Definition: ROSCommands.h:106
void ParseIncomingMessage(const FString Message)

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.

65{
66 ParseIncomingMessage(Command);
67}

References ParseIncomingMessage().

◆ TryParseBoolean()

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

Attempts to parse a string into a boolean value.

Parameters
StringThe string to parse into a boolean value.
OutBoolA 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.

311{
312 FString LoweredString = String.ToLower();
313
314 if (LoweredString.Equals("true") || LoweredString.Equals("1"))
315 {
316 OutBool = true;
317 return true;
318 }
319 else if (LoweredString.Equals("false") || LoweredString.Equals("0"))
320 {
321 OutBool = false;
322 return true;
323 }
324
325 // Invalid boolean value
326 return false;
327}

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

◆ 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: