USimulatorJsonParser Class Reference

#include <SimulatorJsonParser.h>

Inheritance diagram for USimulatorJsonParser:

Collaboration diagram for USimulatorJsonParser:

Static Public Member Functions
static void	ParseAndOperateJSONFile (const FString &Path)

Static Private Member Functions
static void	ParseVehicle (const TSharedPtr< FJsonObject > &JsonObject)
static void	ParsePropOrFoliage (const TSharedPtr< FJsonObject > &JsonObject, const FString &ObjectType)
static void	SpawnSensorToVehicle (AVehicle *Vehicle, const TSharedPtr< FJsonObject > &SensorObject, bool HideVehicleMeshForCameras=false)
static void	SpawnSensorWorld (const TSharedPtr< FJsonObject > &SensorObject)
static void	SpawnWalker (const TSharedPtr< FJsonObject > &JsonObject)
static void	ParseWalkerSpawnPoints (const TSharedPtr< FJsonObject > &ParametersObject, FWalkerParameters &WalkerParams)
static void	ChangeWeather (const TSharedPtr< FJsonObject > &JsonObject)
static void	ParseAndSetDroneParameters (APIDDrone *DronePtr, const TSharedPtr< FJsonObject > &JsonObject)
static void	ParseAndSetWheeledVehicleParameters (AVehicle *VehiclePtr, const TSharedPtr< FJsonObject > &JsonObject)
static void	HandleSpectatorMovement (const TSharedPtr< FJsonObject > &JsonObject, AActor *Actor, const FTransform &Transform)
static void	AttachActorToSpectatorCamera (AActor *ActorPtr)
static void	ParseAndSetSemanticColors (const TSharedPtr< FJsonObject > &JsonObject)
static void	ParseCommands (const TSharedPtr< FJsonObject > &JsonObject)
static void	ParseVolumeDeletion (const TSharedPtr< FJsonObject > &JsonObject)
static void	ParseDataCapture (const TSharedPtr< FJsonObject > &JsonObject)
static FTransform	ParseTransform (const FString &FieldName, const TSharedPtr< FJsonObject > &Object)
static FVector4	ParseVector4 (const FString &FieldName, const TSharedPtr< FJsonObject > &Object)
static FThermalCameraParameters	ParseThermalCameraParameters (const TSharedPtr< FJsonObject > &ParametersObject)
static int32	GetIntValueOrDefault (const TSharedPtr< FJsonObject > &JsonObject, const FString &FieldName, int32 DefaultValue)
template<typename T >
static T	ParseParameters (const TSharedPtr< FJsonObject > &ParametersObject)

Static Private Attributes
static bool	IsDataCapture = false
static TArray< ASensor * >	SpawnedSensorsForDataCapture

Detailed Description

Static UBlueprintFunctionLibrary that reads and parses JSON file content. It processes the parsed data and attempts to spawn objects as defined within the JSON file.

Definition at line 34 of file SimulatorJsonParser.h.

Member Function Documentation

AttachActorToSpectatorCamera()

void USimulatorJsonParser::AttachActorToSpectatorCamera ( AActor *  ActorPtr )

staticprivate

Definition at line 890 of file SimulatorJsonParser.cpp.

{
    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();
                    }
                }
            }
        }
    }
}

References ASensor::GetSensorModel(), and UAgrarsenseStatics::GetSpectator().

Referenced by SpawnSensorWorld().

ChangeWeather()

void USimulatorJsonParser::ChangeWeather ( const TSharedPtr< FJsonObject > &  JsonObject )

staticprivate

Definition at line 667 of file SimulatorJsonParser.cpp.

{
    if (!JsonObject.IsValid())
    {
        return;
    }
 
    TSharedPtr<FJsonObject> Parameters = JsonObject->GetObjectField(TEXT("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);
        }
    }
}

References AWeather::GetCurrentWeather(), UAgrarsenseStatics::GetWeatherActor(), and AWeather::UpdateWeather().

Referenced by ParseAndOperateJSONFile().

GetIntValueOrDefault()

int32 USimulatorJsonParser::GetIntValueOrDefault ( const TSharedPtr< FJsonObject > &  JsonObject, const FString &  FieldName, int32  DefaultValue  )

staticprivate

Definition at line 1186 of file SimulatorJsonParser.cpp.

{
    int32 Value = DefaultValue;
 
    if (JsonObject.IsValid() && JsonObject->HasField(FieldName))
    {
        JsonObject->TryGetNumberField(FieldName, Value);
    }
 
    return Value;
}

Referenced by SpawnWalker().

HandleSpectatorMovement()

void USimulatorJsonParser::HandleSpectatorMovement ( const TSharedPtr< FJsonObject > &  JsonObject, AActor *  Actor, const FTransform &  Transform  )

staticprivate

Definition at line 842 of file SimulatorJsonParser.cpp.

{
    if (!JsonObject.IsValid() || !Actor)
    {
        return;
    }
 
    bool follow = false;
    bool teleport = false;
    JsonObject->TryGetBoolField(TEXT("followObject"), follow);
    JsonObject->TryGetBoolField(TEXT("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);
            }
        }
    }
}

References UAgrarsenseStatics::GetSimulationLevelManager(), UAgrarsenseStatics::GetSpectator(), ASimulationLevelManager::TakeManualControlOfVehicle(), ASpectator::TeleportSpectator(), and Transform.

Referenced by ParseVehicle(), SpawnSensorWorld(), and SpawnWalker().

ParseAndOperateJSONFile()

void USimulatorJsonParser::ParseAndOperateJSONFile ( const FString &  Path )

static

Try to load json file from Path and operate it based on the JSON content.

Parameters

Path	full path to the JSON file, ex. C:\Agrarsense\Examples\ExampleJsonFiles\lidar.json

Definition at line 64 of file SimulatorJsonParser.cpp.

{
    if (UAgrarsenseSettings::IsPlayingInMainMenu())
    {
        SimulatorLog::Log("SimulatorJsonParser: Spawning objects in main menu is disabled.");
        return;
    }
 
    if (!FPaths::FileExists(Path))
    {
        SimulatorLog::Log(FString::Printf(TEXT("SimulatorJsonParser: Path %s doesn't exist."), *Path));
        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(TEXT("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)
    {
        SpawnedSensorsForDataCapture.Empty();
        IsDataCapture = false;
    }
}

References ChangeWeather(), IsDataCapture, UAgrarsenseSettings::IsPlayingInMainMenu(), SimulatorLog::Log(), ParseAndSetSemanticColors(), ParseCommands(), ParseDataCapture(), ParsePropOrFoliage(), ParseVehicle(), ParseVolumeDeletion(), SpawnedSensorsForDataCapture, SpawnSensorWorld(), and SpawnWalker().

Referenced by UROSCommands::HandleSpawnObjects(), and SDragAndDropWidget::OnDrop().

ParseAndSetDroneParameters()

void USimulatorJsonParser::ParseAndSetDroneParameters ( APIDDrone *  DronePtr, const TSharedPtr< FJsonObject > &  JsonObject  )

staticprivate

Definition at line 707 of file SimulatorJsonParser.cpp.

{
    if (!DronePtr || !JsonObject.IsValid())
    {
        return;
    }
 
    TSharedPtr<FJsonObject> ParametersObject = JsonObject->GetObjectField(TEXT("parameters"));
 
    if (ParametersObject.IsValid())
    {
        // Should use Z value as height from the ground instead of given Z value
        bool ZIsHeightAboveGround = false;
        ParametersObject->TryGetBoolField(TEXT("zIsHeightAboveGround"), ZIsHeightAboveGround);
 
        FDroneParameters DroneParameters;
 
        // Manual parsing due unreal automatic struct parsing doesn't work for enums
        
        // Attempt to parse FDroneParameters from the json
        FString DroneActionObject = ParametersObject->GetStringField(TEXT("droneAction"));
        if (!DroneActionObject.IsEmpty())
        {
            EDroneAction droneAction = GetDroneAction(DroneActionObject.ToLower());
            DroneParameters.DroneAction = droneAction;
        }
 
        FString DroneEndActionObject = ParametersObject->GetStringField(TEXT("droneEndAction"));
        if (!DroneEndActionObject.IsEmpty())
        {
            EDroneEndAction droneEndAction = GetDroneEndAction(DroneEndActionObject);
            DroneParameters.DroneEndAction = droneEndAction;
        }
 
        TSharedPtr<FJsonObject> PointsObject = ParametersObject->GetObjectField(TEXT("points"));
        if (PointsObject.IsValid())
        {
            int32 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);
 
                    if (ZIsHeightAboveGround)
                    {
                        UPhysicsUtilities::AlignTransformFromGroundInMeters(nullptr, PointTransform);
                    }
 
                    DroneParameters.Points.Add(PointTransform);
                }
 
                PointIndex++;
            }
        }
 
        bool ShowForwardArrow = false;
        ParametersObject->TryGetBoolField(TEXT("showForwardArrow"), ShowForwardArrow);
        DroneParameters.ShowForwardArrow = ShowForwardArrow;
 
        bool CollisionsEnabled = false;
        ParametersObject->TryGetBoolField(TEXT("collisionsEnabled"), CollisionsEnabled);
        DroneParameters.CollisionsEnabled = CollisionsEnabled;
 
        bool CreateInnerOverlapSensor = false;
        ParametersObject->TryGetBoolField(TEXT("createInnerOverlapSensor"), CreateInnerOverlapSensor);
        DroneParameters.CreateInnerOverlapSensor = CreateInnerOverlapSensor;
 
        float OverlapRadiusMeters = 25.0f;
        ParametersObject->TryGetNumberField(TEXT("overlapRadiusMeters"), OverlapRadiusMeters);
        DroneParameters.OverlapRadiusMeters = OverlapRadiusMeters;
 
        bool VisualizeOverlap = false;
        ParametersObject->TryGetBoolField(TEXT("visualizeOverlap"), VisualizeOverlap);
        DroneParameters.VisualizeOverlap = VisualizeOverlap;
        
        float InnerOverlapRadiusMeters = 2.0f;
        ParametersObject->TryGetNumberField(TEXT("innerOverlapRadiusMeters"), InnerOverlapRadiusMeters);
        DroneParameters.InnerOverlapRadiusMeters = InnerOverlapRadiusMeters;
 
        float DroneSlowToPointModifier = 1.0f;
        ParametersObject->TryGetNumberField(TEXT("droneSlowToPointModifier"), DroneSlowToPointModifier);
        DroneParameters.DroneSlowToPointModifier = DroneSlowToPointModifier;
 
        bool DebugPointTransforms = false;
        ParametersObject->TryGetBoolField(TEXT("debugPointTransforms"), DebugPointTransforms);
        
        DronePtr->ChangeDroneParameters(DroneParameters);
        DronePtr->SetShowForwardArrow(DroneParameters.ShowForwardArrow);
        DronePtr->SetDrawDebugPoints(DebugPointTransforms);
    }
}

References UPhysicsUtilities::AlignTransformFromGroundInMeters(), APIDDrone::ChangeDroneParameters(), FDroneParameters::CollisionsEnabled, FDroneParameters::CreateInnerOverlapSensor, FDroneParameters::DroneAction, FDroneParameters::DroneEndAction, FDroneParameters::DroneSlowToPointModifier, GetDroneAction(), GetDroneEndAction(), FDroneParameters::InnerOverlapRadiusMeters, FDroneParameters::OverlapRadiusMeters, ParseTransform(), FDroneParameters::Points, APIDDrone::SetDrawDebugPoints(), APIDDrone::SetShowForwardArrow(), FDroneParameters::ShowForwardArrow, and FDroneParameters::VisualizeOverlap.

Referenced by ParseVehicle().

ParseAndSetSemanticColors()

void USimulatorJsonParser::ParseAndSetSemanticColors ( const TSharedPtr< FJsonObject > &  JsonObject )

staticprivate

Definition at line 935 of file SimulatorJsonParser.cpp.

{
    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);
            }
        }
    }
}

References UMaterialParameterCollectionUtilities::LoadMaterialParameterCollectionInstance(), SimulatorLog::Log(), and UMaterialParameterCollectionUtilities::UpdateMaterialCollectionVectorValue().

Referenced by ParseAndOperateJSONFile().

ParseAndSetWheeledVehicleParameters()

void USimulatorJsonParser::ParseAndSetWheeledVehicleParameters ( AVehicle *  VehiclePtr, const TSharedPtr< FJsonObject > &  JsonObject  )

staticprivate

Definition at line 807 of file SimulatorJsonParser.cpp.

{
    if (!VehiclePtr || !JsonObject.IsValid() || !JsonObject->HasField(TEXT("parameters")))
    {
        return;
    }
 
    // Get current vehicle parameters
    FWheeledVehicleParameters Parameters = VehiclePtr->GetVehicleParameters();
 
    // parse and set new parameters from json
    TSharedPtr<FJsonObject> ParametersObject = JsonObject->GetObjectField(TEXT("parameters"));
 
    Parameters = ParseParameters<FWheeledVehicleParameters>(ParametersObject);
    
    // Get cargo load separately
    FString cargoLoad = "empty";
    ParametersObject->TryGetStringField(TEXT("cargoLoad"), cargoLoad);
    
    // Get correct enum using string
    const UEnum* Enum = StaticEnum<ForwarderCargoLoad>();
    FString Normalized = cargoLoad.TrimStartAndEnd().ToLower();
    for (int32 i = 0; i < Enum->NumEnums(); ++i)
    {
        FString Name = Enum->GetNameStringByIndex(i).ToLower();
        if (Name == Normalized)
        {
            Parameters.CargoLoad = static_cast<ForwarderCargoLoad>(Enum->GetValueByIndex(i));
            break;
        }
    }
 
    VehiclePtr->SetVehicleParameters(Parameters);
}

References FWheeledVehicleParameters::CargoLoad, AVehicle::GetVehicleParameters(), and AVehicle::SetVehicleParameters().

Referenced by ParseVehicle().

ParseCommands()

void USimulatorJsonParser::ParseCommands ( const TSharedPtr< FJsonObject > &  JsonObject )

staticprivate

Definition at line 983 of file SimulatorJsonParser.cpp.

{
    // 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);
                }
            }
        }
    }
}

Referenced by ParseAndOperateJSONFile().

ParseDataCapture()

void USimulatorJsonParser::ParseDataCapture ( const TSharedPtr< FJsonObject > &  JsonObject )

staticprivate

Definition at line 1040 of file SimulatorJsonParser.cpp.

{
    if (!JsonObject.IsValid() || !GEngine || !GEngine->GameViewport)
    {
        return;
    }
 
    FCaptureData CaptureData;
    TSharedPtr<FJsonObject> ParametersObject = JsonObject->GetObjectField(TEXT("parameters"));
 
    if (ParametersObject.IsValid())
    {
        // Should use Z value as height from the ground instead of given Z value
        bool ZIsHeightAboveGround = false;
        ParametersObject->TryGetBoolField(TEXT("zIsHeightAboveGround"), ZIsHeightAboveGround);
 
        bool UseGPS = false;
        UseGPS = ParametersObject->GetBoolField(TEXT("useGPSLocation"));
        CaptureData.UseGPSLocation = UseGPS;
        CaptureData.UseHeightAboveGround = ZIsHeightAboveGround;
 
        CaptureData.CaptureRotatedViews = ParametersObject->GetBoolField(TEXT("captureRotatedViews"));
 
        TSharedPtr<FJsonObject> PointsObject = ParametersObject->GetObjectField(TEXT("points"));
        if (PointsObject.IsValid())
        {
            int32 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);
 
                    if (ZIsHeightAboveGround && !UseGPS)
                    {
                        UPhysicsUtilities::AlignTransformFromGroundInMeters(nullptr, PointTransform);
                    }
 
                    CaptureData.CapturePositions.Add(PointTransform);
                }
 
                PointIndex++;
            }
        }
    }
 
    UWorld* World = GEngine->GameViewport->GetWorld();
    if (CaptureData.CapturePositions.Num() != 0 && SpawnedSensorsForDataCapture.Num() != 0 && World)
    {
 
        CaptureData.Sensors.Append(SpawnedSensorsForDataCapture);
        ADataCapture* DataCaptureActor = World->SpawnActor<ADataCapture>(ADataCapture::StaticClass(), CaptureData.CapturePositions[0]);
        DataCaptureActor->SetupDataCapture(CaptureData);
    }
}

References UPhysicsUtilities::AlignTransformFromGroundInMeters(), FCaptureData::CapturePositions, FCaptureData::CaptureRotatedViews, ParseTransform(), FCaptureData::Sensors, ADataCapture::SetupDataCapture(), SpawnedSensorsForDataCapture, FCaptureData::UseGPSLocation, and FCaptureData::UseHeightAboveGround.

Referenced by ParseAndOperateJSONFile().

ParseParameters()

template<typename T >

static T USimulatorJsonParser::ParseParameters ( const TSharedPtr< FJsonObject > &  ParametersObject )

inlinestaticprivate

Templated function to parse parameters from JSON object into specific struct. Requires the struct type T to have a StaticStruct method compatible with FJsonObjectConverter::JsonObjectToUStruct.

Parameters

SensorObject

The JSON object from which to parse the parameters.

Returns

An instance of type T populated with data from the JSON object.

Definition at line 95 of file SimulatorJsonParser.h.

    {
        T Params;
 
        if (ParametersObject.IsValid())
        {
            FJsonObjectConverter::JsonObjectToUStruct(ParametersObject.ToSharedRef(), T::StaticStruct(), &Params);
        }
 
        return Params;
    }

ParsePropOrFoliage()

void USimulatorJsonParser::ParsePropOrFoliage ( const TSharedPtr< FJsonObject > &  JsonObject, const FString &  ObjectType  )

staticprivate

Definition at line 282 of file SimulatorJsonParser.cpp.

{
    FString Model;
    if (!JsonObject->TryGetStringField(TEXT("model"), Model))
    {
        // If json doesn't specifiy model, return
        return;
    }
 
    bool RandomZRotation = false;
    bool SnapToGround = false;
    JsonObject->TryGetBoolField(TEXT("snap_to_ground"), SnapToGround);
    JsonObject->TryGetBoolField(TEXT("random_z_rotation"), RandomZRotation);
 
    FString Name, ID;
    JsonObject->TryGetStringField(TEXT("name"), Name);
    JsonObject->TryGetStringField(TEXT("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);
    }
}

References UEnumUtilities::ConvertStringToFoliageType(), UEnumUtilities::ConvertStringToPropType(), ParseTransform(), UAssetLibrary::SpawnFoliage(), and UAssetLibrary::SpawnProp().

Referenced by ParseAndOperateJSONFile().

ParseThermalCameraParameters()

FThermalCameraParameters USimulatorJsonParser::ParseThermalCameraParameters ( const TSharedPtr< FJsonObject > &  ParametersObject )

staticprivate

Definition at line 1162 of file SimulatorJsonParser.cpp.

{
    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(TEXT("cameraParameters"));
        if (CameraParametersObject.IsValid())
        {
            ThermalCameraParams.CameraParameters = ParseParameters<FCameraBaseParameters>(CameraParametersObject);
        }
    }
 
    return ThermalCameraParams;
}

References FThermalCameraParameters::AllowCustomNoiseResolution, FThermalCameraParameters::CameraParameters, FThermalCameraParameters::ColdColor, FThermalCameraParameters::HeightResolutionNoise, ParseVector4(), FThermalCameraParameters::WarmColor, and FThermalCameraParameters::WidthResolutionNoise.

Referenced by SpawnSensorWorld().

ParseTransform()

FTransform USimulatorJsonParser::ParseTransform ( const FString &  FieldName, const TSharedPtr< FJsonObject > &  Object  )

staticprivate

Definition at line 1103 of file SimulatorJsonParser.cpp.

{
    FTransform SpawnTransform;
 
    const TSharedPtr<FJsonObject>* SpawnPointObject = nullptr;
    if (!Object->TryGetObjectField(FieldName, SpawnPointObject))
    {
        return SpawnTransform;
    }
 
    const auto& SPO = *SpawnPointObject->Get();
 
    double LocationX = 0.0, LocationY = 0.0, LocationZ = 0.0;
    if (!SPO.TryGetNumberField(TEXT("x"), LocationX) ||
        !SPO.TryGetNumberField(TEXT("y"), LocationY) ||
        !SPO.TryGetNumberField(TEXT("z"), LocationZ))
    {
        return SpawnTransform;
    }
 
    double Yaw = 0.0, Pitch = 0.0, Roll = 0.0;
    SPO.TryGetNumberField(TEXT("yaw"), Yaw);
    SPO.TryGetNumberField(TEXT("pitch"), Pitch);
    SPO.TryGetNumberField(TEXT("roll"), Roll);
 
    const FVector Location(LocationX, LocationY, LocationZ);
    const FRotator Rotation(Pitch, Yaw, Roll);
    SpawnTransform.SetLocation(Location);
    SpawnTransform.SetRotation(Rotation.Quaternion());
 
    double ScaleX = 1.0, ScaleY = 1.0, ScaleZ = 1.0;
    if (SPO.TryGetNumberField(TEXT("scaleX"), ScaleX) &&
        SPO.TryGetNumberField(TEXT("scaleY"), ScaleY) &&
        SPO.TryGetNumberField(TEXT("scaleZ"), ScaleZ))
    {
        SpawnTransform.SetScale3D(FVector(ScaleX, ScaleY, ScaleZ));
    }
 
    return SpawnTransform;
}

Referenced by ParseAndSetDroneParameters(), ParseDataCapture(), ParsePropOrFoliage(), ParseVehicle(), ParseVolumeDeletion(), ParseWalkerSpawnPoints(), SpawnSensorToVehicle(), and SpawnSensorWorld().

ParseVector4()

FVector4 USimulatorJsonParser::ParseVector4 ( const FString &  FieldName, const TSharedPtr< FJsonObject > &  Object  )

staticprivate

Definition at line 1144 of file SimulatorJsonParser.cpp.

{
    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;
}

Referenced by ParseThermalCameraParameters().

ParseVehicle()

void USimulatorJsonParser::ParseVehicle ( const TSharedPtr< FJsonObject > &  JsonObject )

staticprivate

Definition at line 209 of file SimulatorJsonParser.cpp.

{
    FString Model;
    if (!JsonObject->TryGetStringField(TEXT("model"), Model))
    {
        // If json doesn't specifiy model, return
        return;
    }
 
    FString Name, ID;
    JsonObject->TryGetStringField(TEXT("name"), Name);
    JsonObject->TryGetStringField(TEXT("id"), ID);
    if (ID.IsEmpty())
    {
        ID = Model;
    }
 
    EVehicleTypes VehicleType = UEnumUtilities::ConvertStringToVehicleType(Model);
    bool IsDrone = VehicleType == EVehicleTypes::Drone;
 
    FTransform SpawnTransform = ParseTransform("spawnPoint", JsonObject);
 
    // Should use Z value as height from the ground instead of given Z value
    bool ZIsHeightAboveGround = false;
    JsonObject->TryGetBoolField(TEXT("zIsHeightAboveGround"), ZIsHeightAboveGround);
    if (ZIsHeightAboveGround) 
    {
        UPhysicsUtilities::AlignTransformFromGroundInMeters(nullptr, SpawnTransform);
    }
 
    bool DestroyCollidedObjectsOnSpawn = false;
    JsonObject->TryGetBoolField(TEXT("destroyOverlappingObjects"), DestroyCollidedObjectsOnSpawn);
 
    AVehicle* VehiclePtr = UAssetLibrary::SpawnVehicle(VehicleType, SpawnTransform, Name, ID, false, 150.0f, DestroyCollidedObjectsOnSpawn);
 
    if (VehiclePtr)
    {
        if (IsDrone)
        {
            ParseAndSetDroneParameters(Cast<APIDDrone>(VehiclePtr), JsonObject);
        }
        else 
        {
            ParseAndSetWheeledVehicleParameters(VehiclePtr, JsonObject);
        }
 
        HandleSpectatorMovement(JsonObject, Cast<AActor>(VehiclePtr), SpawnTransform);
    }
    else
    {
        // If Vehicle is nullptr, return
        return;
    }
 
 
    bool HideVehicleMeshForCameras = false;
    JsonObject->TryGetBoolField(TEXT("hideVehicleMeshForCameras"), HideVehicleMeshForCameras);
 
    // Parse possible sensors which will be attached to spawned vehicle
    const TArray<TSharedPtr<FJsonValue>>* SensorJsonObjects;
    if (JsonObject->TryGetArrayField(TEXT("sensors"), SensorJsonObjects))
    {
        for (const TSharedPtr<FJsonValue>& SensorValue : *SensorJsonObjects)
        {
            if (SensorValue->Type == EJson::Object)
            {
                TSharedPtr<FJsonObject> SensorJsonObject = SensorValue->AsObject();
                SpawnSensorToVehicle(VehiclePtr, SensorJsonObject, HideVehicleMeshForCameras);
            }
        }
    }
}

References UPhysicsUtilities::AlignTransformFromGroundInMeters(), UEnumUtilities::ConvertStringToVehicleType(), Drone, HandleSpectatorMovement(), ParseAndSetDroneParameters(), ParseAndSetWheeledVehicleParameters(), ParseTransform(), SpawnSensorToVehicle(), and UAssetLibrary::SpawnVehicle().

Referenced by ParseAndOperateJSONFile().

ParseVolumeDeletion()

void USimulatorJsonParser::ParseVolumeDeletion ( const TSharedPtr< FJsonObject > &  JsonObject )

staticprivate

Definition at line 1010 of file SimulatorJsonParser.cpp.

{
    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)
        {
            Volume->ChangeOverlapBounds(Bounds);
            Volume->DestroyOverlappingActors(OnlyDestroyTrees);
        }
    }
}

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

Referenced by ParseAndOperateJSONFile().

ParseWalkerSpawnPoints()

void USimulatorJsonParser::ParseWalkerSpawnPoints ( const TSharedPtr< FJsonObject > &  ParametersObject, FWalkerParameters &  WalkerParams  )

staticprivate

Definition at line 631 of file SimulatorJsonParser.cpp.

{
    if (ParametersObject->HasField(TEXT("points")))
    {
        // If the JSON has "points" field, parse those points into WalkerParams.Points
        TSharedPtr<FJsonObject> PointsObject = ParametersObject->GetObjectField(TEXT("points"));
        if (PointsObject.IsValid())
        {
            int32 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(TEXT("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);
    }
}

References ParseTransform(), and FWalkerParameters::Points.

Referenced by SpawnWalker().

SpawnSensorToVehicle()

void USimulatorJsonParser::SpawnSensorToVehicle ( AVehicle *  Vehicle, const TSharedPtr< FJsonObject > &  SensorObject, bool  HideVehicleMeshForCameras = false  )

staticprivate

Definition at line 314 of file SimulatorJsonParser.cpp.

{
    if (!Vehicle || !SensorObject.IsValid())
    {
        return;
    }
 
    USensorsManagerComponent* VehicleSensorManager = Vehicle->GetSensorsManager();
    if (!VehicleSensorManager)
    {
        return;
    }
 
    TSharedPtr<FJsonObject> ParametersObject = SensorObject->GetObjectField(TEXT("parameters"));
    if (!ParametersObject.IsValid())
    {
        return;
    }
 
    // Sensor spawn point (relative)
    FTransform RelativeTransform = ParseTransform("spawnPoint", SensorObject);
 
    // Parse ESensorTypes from string
    FString SensorTypeString;
    SensorObject->TryGetStringField(TEXT("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(TEXT("name"), Name);
    SensorObject->TryGetStringField(TEXT("id"), SensorIdentifier);
 
    FString AttachedToComponent;
    SensorObject->TryGetStringField(TEXT("attachedToComponent"), AttachedToComponent);
 
    FString AttachedToBoneString;
    FName AttachedToBone;
    if (SensorObject->TryGetStringField(TEXT("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, ParseParameters<FDepthCameraParameters>(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::InstanceSegmentationCamera:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnInstanceSegmentationCamera(RelativeTransform, true, SensorIdentifier, Name, ParseParameters<FCameraBaseParameters>(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        case ESensorTypes::DVSCamera:
            SensorPtr = Cast<ASensor>(VehicleSensorManager->SpawnDVSCamera(RelativeTransform, true, SensorIdentifier, Name, ParseParameters<FDVSCameraParameters>(ParametersObject), true, TempActor, AttachToComponent, AttachedToBone));
            break;
 
        default:
            break;
    }
 
    if (HideVehicleMeshForCameras)
    {
        if (ACamera* CameraPtr = Cast<ACamera>(SensorPtr))
        {
            CameraPtr->AddHiddenActor(Vehicle);
        }
    }
 
    // 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(TEXT("useGimbal"), UseGimbal);
            CameraPtr->SetUseGimbal(UseGimbal);
        }
    }
}

References UEnumUtilities::ConvertStringToSensorType(), DepthCamera, DVSCamera, InstanceSegmentationCamera, Lidar, ParseTransform(), Radar, RGBCamera, SemanticSegmentationCamera, ThermalCamera, and Vehicle.

Referenced by ParseVehicle().

SpawnSensorWorld()

void USimulatorJsonParser::SpawnSensorWorld ( const TSharedPtr< FJsonObject > &  SensorObject )

staticprivate

Definition at line 422 of file SimulatorJsonParser.cpp.

{
    UWorld* World = nullptr;
    if (GEngine && GEngine->GameViewport)
    {
        World = GEngine->GameViewport->GetWorld();
    }
 
    if (!World 
        || !SensorObject.IsValid() 
        || !SensorObject->HasField(TEXT("parameters"))
        || !SensorObject->HasField(TEXT("model")))
    {
        return;
    }
 
    TSharedPtr<FJsonObject> ParametersObject = SensorObject->GetObjectField(TEXT("parameters"));
    if (!ParametersObject.IsValid())
    {
        return;
    }
 
    FString SensorTypeString, SensorName, SensorIdentifier;
    SensorObject->TryGetStringField(TEXT("model"), SensorTypeString);
    SensorObject->TryGetStringField(TEXT("name"), SensorName);
    SensorObject->TryGetStringField(TEXT("id"), SensorIdentifier);
 
    FTransform SpawnTransform = ParseTransform("spawnPoint", SensorObject);
 
    // Should use Z value as height from the ground instead of given Z value
    bool ZIsHeightAboveGround = false;
    SensorObject->TryGetBoolField(TEXT("zIsHeightAboveGround"), ZIsHeightAboveGround);
    if (ZIsHeightAboveGround)
    {
        UPhysicsUtilities::AlignTransformFromGroundInMeters(nullptr, SpawnTransform);
    }
 
    AActor* ActorPtr = nullptr;
    ESensorTypes SensorType = UEnumUtilities::ConvertStringToSensorType(SensorTypeString);
 
    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, ParseParameters<FDepthCameraParameters>(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::InstanceSegmentationCamera:
            ActorPtr = Cast<AActor>(WorldSensorManager->SpawnInstanceSegmentationCamera(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, ParseParameters<FDVSCameraParameters>(ParametersObject), true, TempActor, nullptr, NAME_None));
            break;
 
        default:
            break;
    }
 
    if (IsDataCapture) 
    {
        ACamera* CameraPtr = Cast<ACamera>(ActorPtr);
        if (CameraPtr) 
        {
            SpawnedSensorsForDataCapture.Add(Cast<ASensor>(ActorPtr));
        }
 
        ALidar* LidarPtr = Cast<ALidar>(ActorPtr);
        if (LidarPtr)
        {
            SpawnedSensorsForDataCapture.Add(Cast<ASensor>(ActorPtr));
        }
    }
 
    bool AttachToSpectator = false;
    SensorObject->TryGetBoolField(TEXT("attachToSpectator"), AttachToSpectator);
 
    if (AttachToSpectator)
    {
        AttachActorToSpectatorCamera(ActorPtr);
    }
    else
    {
        HandleSpectatorMovement(SensorObject, ActorPtr, SpawnTransform);
    }
}

References UPhysicsUtilities::AlignTransformFromGroundInMeters(), AttachActorToSpectatorCamera(), UEnumUtilities::ConvertStringToSensorType(), DepthCamera, DVSCamera, ASimulationLevelManager::GetSensorsManager(), UAgrarsenseStatics::GetSimulationLevelManager(), HandleSpectatorMovement(), InstanceSegmentationCamera, IsDataCapture, Lidar, SimulatorLog::Log(), ParseThermalCameraParameters(), ParseTransform(), Radar, RGBCamera, SemanticSegmentationCamera, SpawnedSensorsForDataCapture, and ThermalCamera.

Referenced by ParseAndOperateJSONFile().

SpawnWalker()

void USimulatorJsonParser::SpawnWalker ( const TSharedPtr< FJsonObject > &  JsonObject )

staticprivate

Definition at line 545 of file SimulatorJsonParser.cpp.

{
    if (!JsonObject.IsValid())
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: Invalid JsonObject");
        return;
    }
 
    FString WalkerTypeString;
    if (!JsonObject->TryGetStringField(TEXT("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(TEXT("parameters"));
    if (!ParametersObject.IsValid())
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: ParametersObject is invalid or missing");
        return;
    }
 
    FString WalkerActionString;
    if (!ParametersObject->TryGetStringField(TEXT("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(TEXT("spawnPoint")))
    {
        SimulatorLog::Log("SimulatorJsonParser failed to parse Walker json: Roaming Walker requires spawnPoint");
        return;
    }
 
    // Retrieve the WalkerEndAction
    FString WalkerEndActionString;
    ParametersObject->TryGetStringField(TEXT("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);
    WalkerParams.CreateTransformTopic = true;
 
    bool CreateTransformTopic = false;
    if (ParametersObject->TryGetBoolField(TEXT("createTransformTopic"), CreateTransformTopic))
    {
        UE_LOG(LogTemp, Warning, TEXT("The boolean value is %s"), (CreateTransformTopic ? TEXT("true") : TEXT("false")));
        WalkerParams.CreateTransformTopic = CreateTransformTopic;
    }
    
    // Parse points or spawnPoint into WalkerParams.Points
    ParseWalkerSpawnPoints(ParametersObject, WalkerParams);
 
    // Retrieve optional name and id fields
    FString Name, ID;
    ParametersObject->TryGetStringField(TEXT("name"), Name);
    ParametersObject->TryGetStringField(TEXT("id"), ID);
 
    // Retrieve the startAutomatically field
    bool StartAutomatically = true;
    if (ParametersObject->HasField(TEXT("startAutomatically")))
    {
        ParametersObject->TryGetBoolField(TEXT("startAutomatically"), StartAutomatically);
    }
 
    // Finally spawn the Walker
    AWalker* Walker = UAssetLibrary::SpawnWalker(WalkerParams, Name, ID, StartAutomatically);
    if (Walker)
    {
        HandleSpectatorMovement(JsonObject, Cast<AActor>(Walker), WalkerParams.Points[0]);
    }
}

References UEnumUtilities::ConvertStringToWalkerActionType(), UEnumUtilities::ConvertStringToWalkerEndActionType(), UEnumUtilities::ConvertStringToWalkerType(), FWalkerParameters::CreateTransformTopic, GetIntValueOrDefault(), HandleSpectatorMovement(), SimulatorLog::Log(), NONE, ParseWalkerSpawnPoints(), FWalkerParameters::Points, Roaming, UAssetLibrary::SpawnWalker(), Walker, FWalkerParameters::WalkerAction, FWalkerParameters::WalkerEndAction, FWalkerParameters::WalkerSpeed, and FWalkerParameters::WalkerType.

Referenced by ParseAndOperateJSONFile().

Member Data Documentation

IsDataCapture

bool USimulatorJsonParser::IsDataCapture = false

staticprivate

Definition at line 107 of file SimulatorJsonParser.h.

Referenced by ParseAndOperateJSONFile(), and SpawnSensorWorld().

SpawnedSensorsForDataCapture

TArray< ASensor * > USimulatorJsonParser::SpawnedSensorsForDataCapture

staticprivate

Definition at line 109 of file SimulatorJsonParser.h.

Referenced by ParseAndOperateJSONFile(), ParseDataCapture(), and SpawnSensorWorld().

---

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

• Unreal/Agrarsense/Source/Agrarsense/JSON/SimulatorJsonParser.h
• Unreal/Agrarsense/Source/Agrarsense/JSON/SimulatorJsonParser.cpp