SimulatorJsonParser.cpp

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "SimulatorJsonParser.h"
 
#include "Agrarsense/AssetLibrary/AssetLibrary.h"
#include "Agrarsense/Utils/MaterialParameterCollectionUtilities.h"
#include "Agrarsense/Utils/PlatformUtilities.h"
#include "Agrarsense/Utils/EnumUtilities.h"
 
#include "Agrarsense/InstancedRendering/InstancedActor.h"
#include "Agrarsense/Logging/SimulatorLog.h"
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Agrarsense/Weather/Weather.h"
#include "Agrarsense/Spectator/Spectator.h"
#include "Agrarsense/Settings/AgrarsenseSettings.h"
#include "Agrarsense/Managers/SimulationLevelManager.h"
 
#include "Agrarsense/Vehicle/Vehicle.h"
#include "Agrarsense/Vehicle/PIDDrone.h"
 
#include "Agrarsense/Volume/DeletionVolume.h"
 
#include "Agrarsense/Sensor/SensorModel.h"
#include "Agrarsense/Sensor/Sensor.h"
#include "Agrarsense/Sensor/Camera/Camera.h"
#include "Agrarsense/Sensor/Camera/DVSCamera.h"
#include "Agrarsense/Sensor/Camera/ThermalCamera.h"
#include "Agrarsense/Sensor/Camera/DepthCamera.h"
#include "Agrarsense/Sensor/Camera/DVSCameraParameters.h"
#include "Agrarsense/Sensor/Camera/SemanticSegmentationCamera.h"
#include "Agrarsense/Sensor/Camera/CameraBaseParameters.h"
#include "Agrarsense/Sensor/SensorsManagerComponent.h"
#include "Agrarsense/Sensor/SensorFactory.h"
#include "Agrarsense/Sensor/Lidar/Lidar.h"
#include "Agrarsense/Sensor/Radar/Radar.h"
 
#include "Agrarsense/DataCapture/PhotoCapture.h"
 
#include "Kismet/GameplayStatics.h"
#include "Camera/PlayerCameraManager.h"
#include "GenericPlatform/GenericPlatformFile.h"
#include "Serialization/JsonSerializer.h"
#include "Serialization/JsonWriter.h"
#include "Misc/DefaultValueHelper.h"
#include "HAL/PlatformFileManager.h"
#include "GameFramework/Pawn.h"
#include "Misc/FileHelper.h"
#include "Dom/JsonObject.h"
#include "GameFramework/PlayerController.h"
#include "CollisionQueryParams.h"
#include "Engine/GameViewportClient.h"
#include "Engine/EngineTypes.h"
#include "Engine/Engine.h"
#include "Engine/World.h"
 
bool USimulatorJsonParser::IsDataCapture = false;
TArray<ACamera*> USimulatorJsonParser::SpawnedCameras;
 
void USimulatorJsonParser::ParseAndOperateJSONFile(const FString& Path)
{
    if (UAgrarsenseSettings::IsPlayingInMainMenu())
    {
        SimulatorLog::Log("SimulatorJsonParser: Spawning objects in main menu is disabled.");
        return;
    }
 
    if (!FPaths::FileExists(Path))
    {
        SimulatorLog::Log("SimulatorJsonParser: Path doesn't exist.");
        return;
    }
 
    if (!FPaths::GetExtension(Path).Equals(TEXT("json"), ESearchCase::IgnoreCase))
    {
        SimulatorLog::Log("SimulatorJsonParser: Invalid file extension. Only .json files are supported.");
        return;
    }
 
    FString JsonString;
    if (!FFileHelper::LoadFileToString(JsonString, *Path))
    {
        SimulatorLog::Log("SimulatorJsonParser: Failed to read the json file.");
        return;
    }
 
    TSharedPtr<FJsonObject> RootJsonObject = MakeShareable(new FJsonObject);
    TSharedRef<TJsonReader<TCHAR>> Reader = TJsonReaderFactory<TCHAR>::Create(JsonString);
    if (!FJsonSerializer::Deserialize(Reader, RootJsonObject))
    {
        SimulatorLog::Log("SimulatorJsonParser: Failed to deserialize json file.");
        return;
    }
 
    const TArray<TSharedPtr<FJsonValue>>* JsonObjects;
    if (!RootJsonObject->TryGetArrayField("objects", JsonObjects))
    {
        SimulatorLog::Log("json content doesn't contain 'objects' field. Make sure your json structure is correct.");
        return;
    }
 
    // The key in the JSON object that we are searching for
    FString FieldTypeString = "type";
 
    // Pre-process incoming json objects
    bool JsonContainsSensorType = false;
    bool JsonContainsDataCaptureType = false;
    TArray<TSharedPtr<FJsonObject>> FilteredJsonObjects;
 
    for (const TSharedPtr<FJsonValue>& JsonObjectValue : *JsonObjects)
    {
        if (JsonObjectValue->Type != EJson::Object)
        {
            continue;
        }
 
        TSharedPtr<FJsonObject> JsonObject = JsonObjectValue->AsObject();
        FString ObjectType;
        if (!JsonObject->TryGetStringField(FieldTypeString, ObjectType))
        {
            continue;
        }
 
        // Convert ObjectType to lowercase to avoid case-sensitive checks below.
        ObjectType.ToLowerInline();
 
        FilteredJsonObjects.Add(JsonObject);
 
        if (ObjectType == "sensor")
        {
            JsonContainsSensorType = true;
        }
        else if (ObjectType == "datacapture")
        {
            JsonContainsDataCaptureType = true;
        }
    }
 
    // Check if both "sensor" and "datacapture" types are present in the JSON.
    // If so, set IsDataCapture to true, indicating that spawned sensors should be tracked
    // and added to the ADataCapture actor.
    IsDataCapture = JsonContainsSensorType && JsonContainsDataCaptureType;
 
    // Process json objects
    for (const TSharedPtr<FJsonObject>& JsonObject : FilteredJsonObjects)
    {
        FString ObjectType;
        if (!JsonObject->TryGetStringField(FieldTypeString, ObjectType))
        {
            continue;
        }
 
        ObjectType.ToLowerInline();
 
        if (ObjectType == "vehicle")
        {
            ParseVehicle(JsonObject);
        }
        else if (ObjectType == "weather")
        {
            ChangeWeather(JsonObject);
        }
        else if (ObjectType == "walker")
        {
            SpawnWalker(JsonObject);
        }
        else if (ObjectType == "sensor")
        {
            SpawnSensorWorld(JsonObject);
        }
        else if (ObjectType == "prop")
        {
            ParsePropOrFoliage(JsonObject, "prop");
        }
        else if (ObjectType == "foliage")
        {
            ParsePropOrFoliage(JsonObject, "foliage");
        }
        else if (ObjectType == "semanticcolors")
        {
            ParseAndSetSemanticColors(JsonObject);
        }
        else if (ObjectType == "commands")
        {
            ParseCommands(JsonObject);
        }
        else if (ObjectType == "volumedeletion")
        {
            ParseVolumeDeletion(JsonObject);
        }
        else if (ObjectType == "datacapture")
        {
            ParseDataCapture(JsonObject);
        }
    }
 
    // If IsDataCapture was true, clear array.
    if (IsDataCapture)
    {
        SpawnedCameras.Empty();
        IsDataCapture = false;
    }
}
 
void USimulatorJsonParser::ParseVehicle(const TSharedPtr<FJsonObject>& JsonObject)
{
    FString Model;
    if (!JsonObject->TryGetStringField("model", Model))
    {
        // If json doesn't specifiy model, return
        return;
    }
 
    FString Name, ID;
    JsonObject->TryGetStringField("name", Name);
    JsonObject->TryGetStringField("id", ID);
    if (ID.IsEmpty())
    {
        ID = Model;
    }
 
    FTransform SpawnTransform = ParseTransform("spawnPoint", JsonObject);
 
    bool DestroyCollidedObjectsOnSpawn = false;
    JsonObject->TryGetBoolField("destroyOverlappingObjects", DestroyCollidedObjectsOnSpawn);
 
    EVehicleTypes VehicleType = UEnumUtilities::ConvertStringToVehicleType(Model);
    AVehicle* VehiclePtr = UAssetLibrary::SpawnVehicle(VehicleType, SpawnTransform, Name, ID, false, 150.0f, DestroyCollidedObjectsOnSpawn);
 
    if (VehiclePtr)
    {
        if (VehicleType == EVehicleTypes::Drone)
        {
            ParseAndSetDroneParameters(Cast<APIDDrone>(VehiclePtr), JsonObject);
        }
        else 
        {
            ParseAndSetWheeledVehicleParameters(VehiclePtr, JsonObject);
        }
 
        HandleSpectatorMovement(JsonObject, Cast<AActor>(VehiclePtr), SpawnTransform);
    }
    else
    {
        // If Vehicle is nullptr, return
        return;
    }
 
    // Parse possible sensors which will be attached to spawned vehicle
    const TArray<TSharedPtr<FJsonValue>>* SensorJsonObjects;
    if (JsonObject->TryGetArrayField("sensors", SensorJsonObjects))
    {
        for (const TSharedPtr<FJsonValue>& SensorValue : *SensorJsonObjects)
        {
            if (SensorValue->Type == EJson::Object)
            {
                TSharedPtr<FJsonObject> SensorJsonObject = SensorValue->AsObject();
                SpawnSensorToVehicle(VehiclePtr, SensorJsonObject);
            }
        }
    }
}
 
void USimulatorJsonParser::ParsePropOrFoliage(const TSharedPtr<FJsonObject>& JsonObject, const FString& ObjectType)
{
    FString Model;
    if (!JsonObject->TryGetStringField("model", Model))
    {
        // If json doesn't specifiy model, return
        return;
    }
 
    bool RandomZRotation = false;
    bool SnapToGround = false;
    JsonObject->TryGetBoolField("snap_to_ground", SnapToGround);
    JsonObject->TryGetBoolField("random_z_rotation", RandomZRotation);
 
    FString Name, ID;
    JsonObject->TryGetStringField("name", Name);
    JsonObject->TryGetStringField("id", ID);
 
    FTransform SpawnTransform = ParseTransform("spawnPoint", JsonObject);
 
    if (ObjectType.Equals("prop", ESearchCase::IgnoreCase))
    {
        EPropTypes Type = UEnumUtilities::ConvertStringToPropType(Model);
        UAssetLibrary::SpawnProp(Type, SpawnTransform, Name, ID, RandomZRotation, SnapToGround);
    }
    else if (ObjectType.Equals("foliage", ESearchCase::IgnoreCase))
    {
        EFoliageTypes Type = UEnumUtilities::ConvertStringToFoliageType(Model);
        UAssetLibrary::SpawnFoliage(Type, SpawnTransform, Name, ID, RandomZRotation, SnapToGround);
    }
}
 
void USimulatorJsonParser::SpawnSensorToVehicle(AVehicle* Vehicle, const TSharedPtr<FJsonObject>& SensorObject)
{
    if (!Vehicle || !SensorObject.IsValid())
    {
        return;
    }
 
    USensorsManagerComponent* VehicleSensorManager = Vehicle->GetSensorsManager();
    if (!VehicleSensorManager)
    {
        return;
    }
 
    TSharedPtr<FJsonObject> ParametersObject = SensorObject->GetObjectField("parameters");
    if (!ParametersObject.IsValid())
    {
        return;
    }
 
    // Sensor spawn point (relative)
    FTransform RelativeTransform = ParseTransform("spawnPoint", SensorObject);
 
    // Parse ESensorTypes from string
    FString SensorTypeString;
    SensorObject->TryGetStringField("model", SensorTypeString);
    ESensorTypes SensorType = UEnumUtilities::ConvertStringToSensorType(SensorTypeString);
 
    // It's fine if these are empty,
    // USensorsManagerComponent will just generate random name and identifier
    FString SensorIdentifier, Name;
    SensorObject->TryGetStringField("name", Name);
    SensorObject->TryGetStringField("id", SensorIdentifier);
 
    FString AttachedToComponent;
    SensorObject->TryGetStringField("attachedToComponent", AttachedToComponent);
 
    FString AttachedToBoneString;
    FName AttachedToBone;
    if (SensorObject->TryGetStringField("attachedToBone", AttachedToBoneString))
    {
        AttachedToBone = FName(*AttachedToBoneString);
    }
 
    ASensorModel* TempActor = nullptr;
    ASensor* SensorPtr = nullptr;
    USceneComponent* AttachToComponent = VehicleSensorManager->GetComponentByHierarchyName(AttachedToComponent);
 
    // Here sensors are spawned through VehicleSensorManager Actor so it can keep track of the spawned sensors.
    switch (SensorType)
    {
        case ESensorTypes::Lidar:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnLidar(RelativeTransform, true, SensorIdentifier, Name, ParseParameters<FLidarParameters>(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        case ESensorTypes::RGBCamera:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnCamera(RelativeTransform, true, SensorIdentifier, Name, ParseParameters<FCameraBaseParameters>(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        case ESensorTypes::ThermalCamera:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnThermalCamera(RelativeTransform, true, SensorIdentifier, Name, ParseParameters<FThermalCameraParameters>(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        case ESensorTypes::DepthCamera:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnDepthCamera(RelativeTransform, true, SensorIdentifier, Name, ParseDepthCameraParameters(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        case ESensorTypes::Radar:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnRadar(RelativeTransform, true, SensorIdentifier, Name, ParseParameters<FRadarParameters>(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        case ESensorTypes::SemanticSegmentationCamera:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnSegmentationCamera(RelativeTransform, true, SensorIdentifier, Name, ParseParameters<FCameraBaseParameters>(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        case ESensorTypes::DVSCamera:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnDVSCamera(RelativeTransform, true, SensorIdentifier, Name, ParseDVSCameraParameters(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        default:
            break;
    }
 
    // If the vehicle we are attaching is drone,
    // and the spawned sensor is camera
    // check if user has given "useGimbal" parameter.
    if(APIDDrone* DronePtr = Cast<APIDDrone>(Vehicle))
    {
        if (ACamera* CameraPtr = Cast<ACamera>(SensorPtr))
        {
            bool UseGimbal = false;
            SensorObject->TryGetBoolField("useGimbal", UseGimbal);
            CameraPtr->SetUseGimbal(UseGimbal);
        }
    }
}
 
void USimulatorJsonParser::SpawnSensorWorld(const TSharedPtr<FJsonObject>& SensorObject)
{
    if (!SensorObject.IsValid())
    {
        return;
    }
 
    if (!SensorObject->HasField("parameters") || !SensorObject->HasField("model"))
    {
        return;
    }
 
    TSharedPtr<FJsonObject> ParametersObject = SensorObject->GetObjectField("parameters");
    if (!ParametersObject.IsValid())
    {
        return;
    }
 
    FString SensorTypeString, SensorName, SensorIdentifier;
    SensorObject->TryGetStringField("model", SensorTypeString);
    SensorObject->TryGetStringField("name", SensorName);
    SensorObject->TryGetStringField("id", SensorIdentifier);
 
    FTransform SpawnTransform = ParseTransform("spawnPoint", SensorObject);
 
    AActor* ActorPtr = nullptr;
    ESensorTypes SensorType = UEnumUtilities::ConvertStringToSensorType(SensorTypeString);
 
    UWorld* World = nullptr;
 
    if (GEngine && GEngine->GameViewport)
    {
        World = GEngine->GameViewport->GetWorld();
    }
 
    ASimulationLevelManager* SimulationLevelManager = UAgrarsenseStatics::GetSimulationLevelManager(World);
    if (!SimulationLevelManager) 
    {
        SimulatorLog::Log("Failed to spawn Sensor. Reason: Coulnd't to find SimulationLevelManager Actor!");
        return;
    }
 
    USensorsManagerComponent* WorldSensorManager = SimulationLevelManager->GetSensorsManager();
    if (!WorldSensorManager)
    {
        SimulatorLog::Log("Failed to spawn Sensor. Reason:  Coulnd't to find USensorsManagerComponent Component!");
        return;
    }
 
    ASensorModel* TempActor = nullptr;
 
    // Here sensors are spawned through WorldSensorManager Actor so it can keep track of the spawned sensors.
    switch (SensorType)
    {
        case ESensorTypes::Lidar:
            ActorPtr = Cast<AActor>(WorldSensorManager->SpawnLidar(SpawnTransform, false, SensorIdentifier, SensorName, ParseParameters<FLidarParameters>(ParametersObject), true, TempActor, nullptr, NAME_None));
            break;
 
        case ESensorTypes::Radar:
            ActorPtr = Cast<AActor>(WorldSensorManager->SpawnRadar(SpawnTransform, false, SensorIdentifier, SensorName, ParseParameters<FRadarParameters>(ParametersObject), true, TempActor, nullptr, NAME_None));
            break;
 
        case ESensorTypes::RGBCamera:
            ActorPtr = Cast<AActor>(WorldSensorManager->SpawnCamera(SpawnTransform, false, SensorIdentifier, SensorName, ParseParameters<FCameraBaseParameters>(ParametersObject), true, TempActor, nullptr, NAME_None));
            break;
 
        case ESensorTypes::ThermalCamera:
            ActorPtr = Cast<AActor>(WorldSensorManager->SpawnThermalCamera(SpawnTransform, false, SensorIdentifier, SensorName, ParseThermalCameraParameters(ParametersObject), true, TempActor, nullptr, NAME_None));
            break;
 
        case ESensorTypes::DepthCamera:
            ActorPtr = Cast<AActor>(WorldSensorManager->SpawnDepthCamera(SpawnTransform, false, SensorIdentifier, SensorName, ParseDepthCameraParameters(ParametersObject), true, TempActor, nullptr, NAME_None));
            break;
 
        case ESensorTypes::SemanticSegmentationCamera:
            ActorPtr = Cast<AActor>(WorldSensorManager->SpawnSegmentationCamera(SpawnTransform, false, SensorIdentifier, SensorName, ParseParameters<FCameraBaseParameters>(ParametersObject), true, TempActor, nullptr, NAME_None));
            break;
 
        case ESensorTypes::DVSCamera:
            ActorPtr = Cast<AActor>(WorldSensorManager->SpawnDVSCamera(SpawnTransform, false, SensorIdentifier, SensorName, ParseDVSCameraParameters(ParametersObject), true, TempActor, nullptr, NAME_None));
            break;
 
        default:
            break;
    }
 
    if (IsDataCapture) 
    {
        ACamera* CameraPtr = Cast<ACamera>(ActorPtr);
        if (CameraPtr) 
        {
            SpawnedCameras.Add(CameraPtr);
        }
    }
 
    bool AttachToSpectator = false;
    SensorObject->TryGetBoolField("attachToSpectator", AttachToSpectator);
 
    if (AttachToSpectator)
    {
        AttachActorToSpectatorCamera(ActorPtr);
    }
    else
    {
        HandleSpectatorMovement(SensorObject, ActorPtr, SpawnTransform);
    }
}
 
void USimulatorJsonParser::SpawnWalker(const TSharedPtr<FJsonObject>& JsonObject)
{
    if (!JsonObject.IsValid())
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: Invalid JsonObject");
        return;
    }
 
    FString WalkerTypeString;
    if (!JsonObject->TryGetStringField("model", WalkerTypeString))
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: Model field is missing");
        return;
    }
 
    EWalkerType WalkerType = UEnumUtilities::ConvertStringToWalkerType(WalkerTypeString);
    if (WalkerType == EWalkerType::NONE)
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: Walker is None");
        return;
    }
 
    TSharedPtr<FJsonObject> ParametersObject = JsonObject->GetObjectField("parameters");
    if (!ParametersObject.IsValid())
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: ParametersObject is invalid or missing");
        return;
    }
 
    FString WalkerActionString;
    if (!ParametersObject->TryGetStringField("walkerAction", WalkerActionString))
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: walkerAction field is missing");
        return;
    }
 
    EWalkerAction WalkerAction = UEnumUtilities::ConvertStringToWalkerActionType(WalkerActionString);
    if (WalkerAction == EWalkerAction::Roaming && !ParametersObject->HasField("spawnPoint"))
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: Roaming Walker requires spawnPoint");
        return;
    }
 
    // Retrieve the WalkerEndAction
    FString WalkerEndActionString;
    ParametersObject->TryGetStringField("walkerEndAction", WalkerEndActionString);
    EWalkerEndAction WalkerEndAction = UEnumUtilities::ConvertStringToWalkerEndActionType(WalkerEndActionString);
 
    // Create and populate WalkerParameters
    FWalkerParameters WalkerParams;
    WalkerParams.WalkerType = WalkerType;
    WalkerParams.WalkerAction = WalkerAction;
    WalkerParams.WalkerEndAction = WalkerEndAction;
    WalkerParams.WalkerSpeed = GetIntValueOrDefault(ParametersObject, "walkerSpeed", 50);
 
    // Parse points or spawnPoint into WalkerParams.Points
    ParseWalkerSpawnPoints(ParametersObject, WalkerParams);
 
    // Retrieve optional name and id fields
    FString Name, ID;
    ParametersObject->TryGetStringField("name", Name);
    ParametersObject->TryGetStringField("id", ID);
 
    // Retrieve the startAutomatically field
    bool StartAutomatically = true;
    if (ParametersObject->HasField("startAutomatically"))
    {
        ParametersObject->TryGetBoolField("startAutomatically", StartAutomatically);
    }
 
    // Finally spawn the Walker
    AWalker* Walker = UAssetLibrary::SpawnWalker(WalkerParams, Name, ID, StartAutomatically);
    if (Walker)
    {
        HandleSpectatorMovement(JsonObject, Cast<AActor>(Walker), WalkerParams.Points[0]);
    }
}
 
void USimulatorJsonParser::ParseWalkerSpawnPoints(const TSharedPtr<FJsonObject>& ParametersObject, FWalkerParameters& WalkerParams)
{
    if (ParametersObject->HasField("points"))
    {
        // If the JSON has "points" field, parse those points into WalkerParams.Points
        TSharedPtr<FJsonObject> PointsObject = ParametersObject->GetObjectField("points");
        if (PointsObject.IsValid())
        {
            int PointIndex = 0;
            while (true)
            {
                FString PointName = FString::Printf(TEXT("point%d"), PointIndex);
                if (!PointsObject->HasField(PointName))
                {
                    break;
                }
 
                TSharedPtr<FJsonObject> PointObject = PointsObject->GetObjectField(PointName);
                if (PointObject.IsValid())
                {
                    FTransform PointTransform = ParseTransform(PointName, PointsObject);
                    WalkerParams.Points.Add(PointTransform);
                }
 
                PointIndex++;
            }
        }
    }
    else if (ParametersObject->HasField("spawnPoint"))
    {
        // If the JSON doesn't have "points" field but has "spawnPoint", parse that into WalkerParams.Points
        FTransform PointTransform = ParseTransform("spawnPoint", ParametersObject);
        WalkerParams.Points.Add(PointTransform);
    }
}
 
void USimulatorJsonParser::ChangeWeather(const TSharedPtr<FJsonObject>& JsonObject)
{
    if (!JsonObject.IsValid())
    {
        return;
    }
 
    TSharedPtr<FJsonObject> Parameters = JsonObject->GetObjectField("parameters");
    if (Parameters.IsValid() && GEngine && GEngine->GameViewport)
    {
        UWorld* World = GEngine->GameViewport->GetWorld();
        AWeather* WeatherActor = UAgrarsenseStatics::GetWeatherActor(World);
        if (WeatherActor)
        {
            FWeatherParameters Params = WeatherActor->GetCurrentWeather();
            FJsonObjectConverter::JsonObjectToUStruct(Parameters.ToSharedRef(), FWeatherParameters::StaticStruct(), &Params);
            WeatherActor->UpdateWeather(Params, true);
        }
    }
}
 
static EDroneAction GetDroneAction(FString actionstring)
{
    if (actionstring == "stationary") { return EDroneAction::Stationary; }
    if (actionstring == "manual") { return EDroneAction::Manual; }
    if (actionstring == "roaming") { return EDroneAction::Roaming; }
    if (actionstring == "followpath") { return EDroneAction::FollowPath; }
    else { return EDroneAction::Stationary; }
}
 
static EDroneEndAction GetDroneEndAction(FString endActionstring)
{
    if (endActionstring == "destroy") { return EDroneEndAction::Destroy; }
    if (endActionstring == "repeatfrombeginning") { return EDroneEndAction::RepeatFromBeginning; }
    if (endActionstring == "gobackwards") { return EDroneEndAction::GoBackwards; }
    if (endActionstring == "generaterandomnew") { return EDroneEndAction::GenerateRandomNew; }
    if (endActionstring == "stop") { return EDroneEndAction::Stop; }
    else { return EDroneEndAction::Stop; }
}
 
void USimulatorJsonParser::ParseAndSetDroneParameters(APIDDrone* DronePtr, const TSharedPtr<FJsonObject>& JsonObject)
{
    if (!DronePtr || !JsonObject.IsValid())
    {
        return;
    }
 
    TSharedPtr<FJsonObject> ParametersObject = JsonObject->GetObjectField("parameters");
 
    if (ParametersObject.IsValid())
    {
        FDroneParameters DroneParameters;
 
        // Attempt to parse FDroneParameters from the json
        FString DroneActionObject = ParametersObject->GetStringField("droneAction");
        if (!DroneActionObject.IsEmpty())
        {
            EDroneAction droneAction = GetDroneAction(DroneActionObject.ToLower());
            DroneParameters.DroneAction = droneAction;
        }
 
        FString DroneEndActionObject = ParametersObject->GetStringField("droneEndAction");
        if (!DroneEndActionObject.IsEmpty())
        {
            EDroneEndAction droneEndAction = GetDroneEndAction(DroneEndActionObject);
            DroneParameters.DroneEndAction = droneEndAction;
        }
 
        TSharedPtr<FJsonObject> PointsObject = ParametersObject->GetObjectField("points");
        if (PointsObject.IsValid())
        {
            int PointIndex = 0;
            while (true)
            {
                FString PointName = FString::Printf(TEXT("point%d"), PointIndex);
                if (!PointsObject->HasField(PointName))
                {
                    break;
                }
 
                TSharedPtr<FJsonObject> PointObject = PointsObject->GetObjectField(PointName);
                if (PointObject.IsValid())
                {
                    FTransform PointTransform = ParseTransform(PointName, PointsObject);
                    DroneParameters.Points.Add(PointTransform);
                }
 
                PointIndex++;
            }
        }
 
        bool ShowForwardArrow = false;
        ParametersObject->TryGetBoolField("showForwardArrow", ShowForwardArrow);
        
        DronePtr->ChangeDroneParameters(DroneParameters);
        DronePtr->SetShowForwardArrow(ShowForwardArrow);
    }
}
 
void USimulatorJsonParser::ParseAndSetWheeledVehicleParameters(AVehicle* VehiclePtr, const TSharedPtr<FJsonObject>& JsonObject)
{
    if (!VehiclePtr || !JsonObject.IsValid() || !JsonObject->HasField("parameters"))
    {
        return;
    }
 
    // Get current vehicle parameters
    FWheeledVehicleParameters Parameters = VehiclePtr->GetVehicleParameters();
 
    // parse and set new parameters from json
    TSharedPtr<FJsonObject> ParametersObject = JsonObject->GetObjectField("parameters");
    Parameters = ParseParameters<FWheeledVehicleParameters>(ParametersObject);
    VehiclePtr->SetVehicleParameters(Parameters);
}
 
void USimulatorJsonParser::HandleSpectatorMovement(const TSharedPtr<FJsonObject>& JsonObject, AActor* Actor, const FTransform& Transform)
{
    if (!JsonObject.IsValid() || !Actor)
    {
        return;
    }
 
    bool follow = false;
    bool teleport = false;
    JsonObject->TryGetBoolField("followObject", follow);
    JsonObject->TryGetBoolField("teleportSpectator", teleport);
 
    if (!follow && !teleport)
    {
        // If neither is set, return
        return;
    }
 
    if (GEngine && GEngine->GameViewport)
    {
        UWorld* World = GEngine->GameViewport->GetWorld();
        ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World);
        if (Spectator)
        {
            if (follow)
            {
                AVehicle* VehiclePtr = Cast<AVehicle>(Actor);
                if (VehiclePtr)
                {
                    ASimulationLevelManager* SimulationLevelManager = UAgrarsenseStatics::GetSimulationLevelManager(World);
                    if (SimulationLevelManager) 
                    {
                        SimulationLevelManager->TakeManualControlOfVehicle(VehiclePtr);
                    }
                }
                /*else
                {
                    Spectator->FollowActor(Actor, false, 150.0f, 50.0f);
                }*/
            }
            else if (teleport)
            {
                Spectator->TeleportSpectator(Transform);
            }
        }
    }
}
 
void USimulatorJsonParser::AttachActorToSpectatorCamera(AActor* ActorPtr)
{
    if (!ActorPtr || !GEngine || !GEngine->GameViewport)
    {
        return;
    }
 
    UWorld* World = GEngine->GameViewport->GetWorld();
    if (!World)
    {
        return;
    }
 
    ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World);
    APlayerController* PlayerController = UGameplayStatics::GetPlayerController(World, 0);
    if (PlayerController && Spectator)
    {
        APlayerCameraManager* CameraManager = PlayerController->PlayerCameraManager;
        if (CameraManager)
        {
            USceneComponent* CameraRootComponent = CameraManager->GetRootComponent();
            if (CameraRootComponent)
            {
                // Set initial location and rotation to Spectator location
                ActorPtr->SetActorLocation(Spectator->GetActorLocation());
                ActorPtr->SetActorRotation(Spectator->GetActorRotation());
 
                // Now attach ActorPtr to PlayerCameraManager CameraRootComponent so it follows the camera movement
                ActorPtr->AttachToComponent(CameraRootComponent, FAttachmentTransformRules::SnapToTargetNotIncludingScale);
 
                // Delete sensor model from the sensor after attaching to Spectator.
                ASensor* SensorPtr = Cast<ASensor>(ActorPtr);
                if (SensorPtr)
                {
                    auto* SensorModelPtr = SensorPtr->GetSensorModel();
                    if (SensorModelPtr)
                    {
                        SensorModelPtr->Destroy();
                    }
                }
            }
        }
    }
}
 
void USimulatorJsonParser::ParseAndSetSemanticColors(const TSharedPtr<FJsonObject>& JsonObject)
{
    UWorld* World = nullptr;
    if (GEngine && GEngine->GameViewport)
    {
        World = GEngine->GameViewport->GetWorld();
    }
 
    if (!World)
    {
        return;
    }
 
    UMaterialParameterCollectionInstance* CollectionInstance = UMaterialParameterCollectionUtilities::LoadMaterialParameterCollectionInstance(World, "/Game/Agrarsense/Data/Semantic/MPC_SemanticCameraColors");
    if (!CollectionInstance)
    {
        SimulatorLog::Log("ROSJsonParser.cpp: Failed to load MaterialParameterCollectionInstance!");
        return;
    }
 
    // Access the "colors" object
    const TSharedPtr<FJsonObject>* ColorsObjectPtr = nullptr;
    if (JsonObject->TryGetObjectField(TEXT("colors"), ColorsObjectPtr) && ColorsObjectPtr != nullptr)
    {
        const TSharedPtr<FJsonObject>& ColorsObject = *ColorsObjectPtr;
        for (const auto& Elem : ColorsObject->Values)
        {
            FName Type = FName(*Elem.Key);
            FString VectorString = Elem.Value->AsString();
 
            // Parse the FVector4 value from the string
            FVector4 ParsedVector;
            TArray<FString> ParsedValues;
            VectorString.ParseIntoArray(ParsedValues, TEXT(","), true);
            if (ParsedValues.Num() == 4)
            {
                ParsedVector.X = FCString::Atof(*ParsedValues[0]);
                ParsedVector.Y = FCString::Atof(*ParsedValues[1]);
                ParsedVector.Z = FCString::Atof(*ParsedValues[2]);
                ParsedVector.W = FCString::Atof(*ParsedValues[3]);
 
                // try to update the material collection vector value
                bool success = UMaterialParameterCollectionUtilities::UpdateMaterialCollectionVectorValue(CollectionInstance, Type, ParsedVector);
            }
        }
    }
}
 
void USimulatorJsonParser::ParseCommands(const TSharedPtr<FJsonObject>& JsonObject)
{
    // Parse json that contains "commands" array of Unreal console commands to execute
 
    if (!GEngine || !GEngine->GameViewport)
    {
        return;
    }
 
    UWorld* World = GEngine->GameViewport->GetWorld();
    if (World)
    {
        const TArray<TSharedPtr<FJsonValue>>* CommandsArray;
        if (JsonObject->TryGetArrayField(TEXT("commands"), CommandsArray))
        {
            for (const TSharedPtr<FJsonValue>& CommandValue : *CommandsArray)
            {
                FString Command;
                if (CommandValue->TryGetString(Command))
                {
                    GEngine->Exec(World, *Command);
                }
            }
        }
    }
}
 
void USimulatorJsonParser::ParseVolumeDeletion(const TSharedPtr<FJsonObject>& JsonObject)
{
    if (!GEngine || !GEngine->GameViewport || !JsonObject.IsValid())
    {
        return;
    }
 
    // Parse spawn location for this volume
    FTransform SpawnTransform = ParseTransform("spawnPoint", JsonObject);
 
    // We can use ParseTransform function to parse bounds as the json structure is similar.
    FTransform TransformBounds = ParseTransform("bounds", JsonObject);
    FVector Bounds = TransformBounds.GetLocation();
 
    bool OnlyDestroyTrees = true; // default to only destroy trees
    JsonObject->TryGetBoolField(TEXT("onlyDestroyTrees"), OnlyDestroyTrees);
 
    UWorld* World = GEngine->GameViewport->GetWorld();
 
    if (World)
    {
        ADeletionVolume* Volume = World->SpawnActor<ADeletionVolume>(ADeletionVolume::StaticClass(), SpawnTransform);
        if (Volume)
        {
            // Change volume bounds
            Volume->ChangeOverlapBounds(Bounds);
 
            // Destroy all overlapping trees, Actor gets automatically destroyed after calling this
            Volume->DestroyOverlappingActors(OnlyDestroyTrees);
        }
    }
}
 
void USimulatorJsonParser::ParseDataCapture(const TSharedPtr<FJsonObject>& JsonObject)
{
    if (!JsonObject.IsValid() || !GEngine || !GEngine->GameViewport)
    {
        return;
    }
 
    FCaptureData CaptureData;
    TSharedPtr<FJsonObject> ParametersObject = JsonObject->GetObjectField("parameters");
    if (ParametersObject.IsValid())
    {
        TSharedPtr<FJsonObject> PointsObject = ParametersObject->GetObjectField("points");
        if (PointsObject.IsValid())
        {
            int PointIndex = 0;
            while (true)
            {
                FString PointName = FString::Printf(TEXT("point%d"), PointIndex);
                if (!PointsObject->HasField(PointName))
                {
                    break;
                }
 
                TSharedPtr<FJsonObject> PointObject = PointsObject->GetObjectField(PointName);
                if (PointObject.IsValid())
                {
                    FTransform PointTransform = ParseTransform(PointName, PointsObject);
                    CaptureData.CapturePositions.Add(PointTransform);
                }
 
                PointIndex++;
            }
        }
    }
 
    UWorld* World = GEngine->GameViewport->GetWorld();
    if (CaptureData.CapturePositions.Num() != 0 && World)
    {
        CaptureData.Cameras = SpawnedCameras;
        APhotoCapture* PhotoCaptureActor = World->SpawnActor<APhotoCapture>(APhotoCapture::StaticClass(), CaptureData.CapturePositions[0]);
        PhotoCaptureActor->SetupPhotoCapture(CaptureData);
    }
}
 
FTransform USimulatorJsonParser::ParseTransform(const FString& FieldName, const TSharedPtr<FJsonObject>& Object)
{
    FTransform SpawnTransform;
 
    const TSharedPtr<FJsonObject>* SpawnPointObject = nullptr;
    if (Object->TryGetObjectField(FieldName, SpawnPointObject))
    {
        //UE_LOG(LogTemp, Warning, TEXT("Parsing transform!"))
        double LocationX = 0.0, LocationY = 0.0, LocationZ = 0.0;
        double Yaw = 0.0, Pitch = 0.0, Roll = 0.0;
 
        auto& SPO = *SpawnPointObject->Get();
 
        // Attempt to extract location and rotation directly
        bool HasLocation = SPO.TryGetNumberField(TEXT("x"), LocationX) && SPO.TryGetNumberField(TEXT("y"), LocationY) && SPO.TryGetNumberField(TEXT("z"), LocationZ);
 
        // Attempt to get rotation information
        SPO.TryGetNumberField(TEXT("yaw"), Yaw);
        SPO.TryGetNumberField(TEXT("pitch"), Pitch);
        SPO.TryGetNumberField(TEXT("roll"), Roll);
 
        // Attempt to get scale information
        FVector Scale;
        bool ChangeScale = false;
        if (SPO.HasField("scaleX") && SPO.HasField("scaleY") && SPO.HasField("scaleZ"))
        {
            ChangeScale = true;
            SPO.TryGetNumberField(TEXT("scaleX"), Scale.X);
            SPO.TryGetNumberField(TEXT("scaleY"), Scale.Y);
            SPO.TryGetNumberField(TEXT("scaleZ"), Scale.Z);
        }
 
        if (HasLocation)
        {
            //UE_LOG(LogTemp, Warning, TEXT("Has Location!"))
            FVector Location(LocationX, LocationY, LocationZ);
            FRotator Rotation(Pitch, Yaw, Roll);
 
            SpawnTransform.SetLocation(Location);
            SpawnTransform.SetRotation(Rotation.Quaternion());
 
            if (ChangeScale)
            {
                SpawnTransform.SetScale3D(Scale);
            }
        }
    }
 
    return SpawnTransform;
}
 
FVector4 USimulatorJsonParser::ParseVector4(const FString& FieldName, const TSharedPtr<FJsonObject>& Object)
{
    FVector4 Vector;
    const TSharedPtr<FJsonObject>* VectorObject;
 
    if (Object->TryGetObjectField(FieldName, VectorObject))
    {
        double X, Y, Z, W;
        (*VectorObject)->TryGetNumberField(TEXT("x"), X);
        (*VectorObject)->TryGetNumberField(TEXT("y"), Y);
        (*VectorObject)->TryGetNumberField(TEXT("z"), Z);
        (*VectorObject)->TryGetNumberField(TEXT("w"), W);
        Vector = FVector4(X, Y, Z, W);
    }
 
    return Vector;
}
 
FDepthCameraParameters USimulatorJsonParser::ParseDepthCameraParameters(const TSharedPtr<FJsonObject>& ParametersObject)
{
    FDepthCameraParameters DepthCameraParams;
 
    if (ParametersObject.IsValid())
    {
        FJsonObjectConverter::JsonObjectToUStruct(ParametersObject.ToSharedRef(), FDepthCameraParameters::StaticStruct(), &DepthCameraParams);
    }
 
    return DepthCameraParams;
}
 
FThermalCameraParameters USimulatorJsonParser::ParseThermalCameraParameters(const TSharedPtr<FJsonObject>& ParametersObject)
{
    FThermalCameraParameters ThermalCameraParams;
 
    if (ParametersObject.IsValid())
    {
        // Parse fields manually because FJsonObjectConverter::JsonObjectToUStruct couldn't parse these properly.
        ThermalCameraParams.WarmColor = ParseVector4(TEXT("warmColor"), ParametersObject);
        ThermalCameraParams.ColdColor = ParseVector4(TEXT("coldColor"), ParametersObject);
        ParametersObject->TryGetBoolField(TEXT("allowCustomNoiseResolution"), ThermalCameraParams.AllowCustomNoiseResolution);
        ParametersObject->TryGetNumberField(TEXT("widthResolutionNoise"), ThermalCameraParams.WidthResolutionNoise);
        ParametersObject->TryGetNumberField(TEXT("heightResolutionNoise"), ThermalCameraParams.HeightResolutionNoise);
 
        // Parse FCameraBaseParameters
        TSharedPtr<FJsonObject> CameraParametersObject = ParametersObject->GetObjectField("cameraParameters");
        if (CameraParametersObject.IsValid())
        {
            ThermalCameraParams.CameraParameters = ParseParameters<FCameraBaseParameters>(CameraParametersObject);
        }
    }
 
    return ThermalCameraParams;
}
 
FDVSCameraParameters USimulatorJsonParser::ParseDVSCameraParameters(const TSharedPtr<FJsonObject>& ParametersObject)
{
    FDVSCameraParameters DVSCameraParams;
 
    if (ParametersObject.IsValid())
    {
        FJsonObjectConverter::JsonObjectToUStruct(ParametersObject.ToSharedRef(), FDVSCameraParameters::StaticStruct(), &DVSCameraParams);
    }
 
    return DVSCameraParams;
}
 
int USimulatorJsonParser::GetIntValueOrDefault(const TSharedPtr<FJsonObject>& JsonObject, const FString& FieldName, int Default)
{
    int Value = Default;
 
    if (JsonObject.IsValid() && JsonObject->HasField(FieldName))
    {
        JsonObject->TryGetNumberField(FieldName, Value);
    }
 
    return Value;
}