#include <Tagger.h>

Inheritance diagram for ATagger:

Collaboration diagram for ATagger:

[legend]

Public Member Functions
	ATagger ()

void	ExportObjectLocationsToCSV ()

AActor *	GetActorByInstanceID (float InstanceID)

Protected Member Functions
virtual void	BeginPlay () override

virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override

void	CreateCSVFile ()

void	TagExistingActors ()

void	OnActorSpawned (AActor *Actor)

void	TagActor (AActor &Actor)

void	WriteComponentToCSV (const FTaggedActorData Data)

float	SetStencilValue (UPrimitiveComponent &Component, AActor &Actor, const ELabels &Label)

void	TagLandscape (ALandscape *Landscape, AActor &Actor)

ELabels	GetLabelFromString (const FString &String)

ELabels	GetLabelFromStaticComponent (UStaticMeshComponent *StaticMeshComponentPtr)

ELabels	GetLabelFromSkeletalMeshComponent (USkeletalMeshComponent *USkeletalMeshComponentPtr)

ELabels	GetLabelFromPath (const FString &Path, FString &FolderName)

template<typename T >
ELabels	GetLabelFromTag (const T *Object)

Private Attributes
AGeoReferencingSystem *	GeoReferencingSystem = nullptr

UCSVFile *	CSVFile = nullptr

TArray< FTaggedActorData >	TaggedActors

FDelegateHandle	ActorSpawnedDelegateHandle

TMap< FString, ELabels >	LabelMap

bool	TerrainIDCached = false

uint32	CachedTerrainID = 0

float	ID = 1.0f

Detailed Description

Definition at line 50 of file Tagger.h.

Constructor & Destructor Documentation

◆ ATagger()

ATagger::ATagger ( )

Definition at line 26 of file Tagger.cpp.

{
    PrimaryActorTick.bCanEverTick = false;
}

Member Function Documentation

◆ BeginPlay()

void ATagger::BeginPlay ( )

overrideprotectedvirtual

Definition at line 31 of file Tagger.cpp.

{
    Super::BeginPlay();
 
    if (UAgrarsenseSettings::IsPlayingInMainMenu()) 
    {
        return;
    }
 
    UWorld* World = GetWorld();
 
    // Create TMap<FString, ELabels>
    LabelMap = UEnumUtilities::CreateStringEnumMap<ELabels>("/Script/Agrarsense.ELabels");
 
    ActorSpawnedDelegateHandle = World->AddOnActorSpawnedHandler(FOnActorSpawned::FDelegate::CreateUObject(this, &ATagger::OnActorSpawned));
 
    // Tag all existing Actors in the World after small delay
    FTimerHandle Handle;
    World->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this]
        {
            TagExistingActors();
    }), 0.200f, false);
}

References ActorSpawnedDelegateHandle, UAgrarsenseSettings::IsPlayingInMainMenu(), LabelMap, OnActorSpawned(), and TagExistingActors().

◆ CreateCSVFile()

void ATagger::CreateCSVFile ( )

protected

Definition at line 238 of file Tagger.cpp.

{
    GeoReferencingSystem = AGeoReferencingSystem::GetGeoReferencingSystem(GetWorld());
 
    // CSV file settings
    FCSVFileSettings Settings;
    Settings.Delimiter = ECSVDelimiter::Semicolon;
    Settings.Append = false;
    Settings.CreateUnique = true;
    Settings.FileWriteOption = FCSVFileWriteOptions::Queue;
 
    FString MapName = GetWorld()->GetMapName();
    FString FileName = MapName + TEXT("_ObjectLocations");
 
    if (MapName.Contains("dev"))
    {
        Settings.QueueSize = 65536;
    }
 
    CSVFile = UCSVFile::CreateCSVFile(FileName, Settings);
 
    TArray<FString> Header = { TEXT("Name"), TEXT("InstanceID"), TEXT("LocationX"), TEXT("LocationY"),
        TEXT("LocationZ"), TEXT("Yaw"), TEXT("Pitch"), TEXT("Roll"), TEXT("Bounds")};
    if (GeoReferencingSystem)
    {
        Header.Append({ TEXT("Latitude"), TEXT("Longitude"), TEXT("Altitude") });
    }
    CSVFile->WriteRow(Header);
}

References FCSVFileSettings::Append, UCSVFile::CreateCSVFile(), FCSVFileSettings::CreateUnique, CSVFile, FCSVFileSettings::Delimiter, FCSVFileSettings::FileWriteOption, GeoReferencingSystem, Queue, FCSVFileSettings::QueueSize, Semicolon, and UCSVFile::WriteRow().

Referenced by ExportObjectLocationsToCSV().

◆ EndPlay()

void ATagger::EndPlay ( const EEndPlayReason::Type EndPlayReason )

overrideprotectedvirtual

Definition at line 55 of file Tagger.cpp.

{
    Super::EndPlay(EndPlayReason);
 
    TaggedActors.Empty();
    ActorSpawnedDelegateHandle.Reset();
}

References ActorSpawnedDelegateHandle, and TaggedActors.

◆ ExportObjectLocationsToCSV()

void ATagger::ExportObjectLocationsToCSV ( )

Definition at line 198 of file Tagger.cpp.

{
    if (TaggedActors.IsEmpty()) 
    {
        return;
    }
 
    CreateCSVFile();
    if (!CSVFile)
    {
        return;
    }
 
    for (const FTaggedActorData& TaggedActorData : TaggedActors)
    {
        AActor* Actor = TaggedActorData.Actor;
        if (!Actor)
        {
            continue;
        }
 
        WriteComponentToCSV(TaggedActorData);
    }
 
    CSVFile->Close();
}

References UCSVFile::Close(), CreateCSVFile(), CSVFile, TaggedActors, and WriteComponentToCSV().

◆ GetActorByInstanceID()

AActor * ATagger::GetActorByInstanceID ( float InstanceID )

Definition at line 225 of file Tagger.cpp.

{
    for (const FTaggedActorData& TaggedActorData : TaggedActors)
    {
        if (TaggedActorData.InstanceID == InstanceID)
        {
            return TaggedActorData.Actor;
        }
    }
 
    return nullptr;
}

References TaggedActors.

Referenced by UROSCommands::HandleDestroyObjectByInstanceID(), and UROSCommands::HandleTeleportSpectatorByInstanceID().

◆ GetLabelFromPath()

ELabels ATagger::GetLabelFromPath	(	const FString &	Path,
		FString &	FolderName
	)

protected

Definition at line 451 of file Tagger.cpp.

{
    ELabels Label = ELabels::None;
 
    // If the Path doesn't contain Models,
    // the asset is not under /Content/Agrarsense/Models directory
    // meaing we ignore it.
    if (!Path.Contains("Models"))
    {
        return Label;
    }
 
    TArray<FString> StringArray;
    Path.ParseIntoArray(StringArray, TEXT("/"), false);
 
    FolderName = StringArray[StringArray.Num() - 2];
 
    Label = GetLabelFromString(FolderName);
 
    return Label;
}

References GetLabelFromString(), and None.

Referenced by GetLabelFromSkeletalMeshComponent(), and GetLabelFromStaticComponent().

◆ GetLabelFromSkeletalMeshComponent()

ELabels ATagger::GetLabelFromSkeletalMeshComponent ( USkeletalMeshComponent * USkeletalMeshComponentPtr )

protected

Definition at line 421 of file Tagger.cpp.

{
    ELabels Label = ELabels::None;
 
    if (!USkeletalMeshComponentPtr)
    {
        return Label;
    }
 
    Label = GetLabelFromTag(USkeletalMeshComponentPtr);
    if (Label != ELabels::None)
    {
        return Label;
    }
 
    USkeletalMesh* PhysicsAsset = USkeletalMeshComponentPtr->GetSkeletalMeshAsset();
    if (PhysicsAsset)
    {
        FString Name;
        Label = GetLabelFromPath(PhysicsAsset->GetPathName(), Name);
 
        if (Label != ELabels::None)
        {
            USkeletalMeshComponentPtr->ComponentTags.Insert(FName(Name), 0);
        }
    }
 
    return Label;
}

References GetLabelFromPath(), GetLabelFromTag(), and None.

Referenced by TagActor().

◆ GetLabelFromStaticComponent()

ELabels ATagger::GetLabelFromStaticComponent ( UStaticMeshComponent * StaticMeshComponentPtr )

protected

Definition at line 391 of file Tagger.cpp.

{
    ELabels Label = ELabels::None;
 
    if (!StaticMeshComponentPtr)
    {
        return Label;
    }
 
    Label = GetLabelFromTag(StaticMeshComponentPtr);
    if (Label != ELabels::None)
    {
        return Label;
    }
 
    UStaticMesh* MeshPtr = StaticMeshComponentPtr->GetStaticMesh();
    if (MeshPtr)
    {
        FString Name;
        Label = GetLabelFromPath(MeshPtr->GetPathName(), Name);
 
        if (Label != ELabels::None)
        {
            StaticMeshComponentPtr->ComponentTags.Insert(FName(Name), 0);
        }
    }
 
    return Label;
}

References GetLabelFromPath(), GetLabelFromTag(), and None.

Referenced by TagActor().

◆ GetLabelFromString()

ELabels ATagger::GetLabelFromString ( const FString & String )

protected

Definition at line 375 of file Tagger.cpp.

{
    const ELabels* FoundLabel = LabelMap.Find(String);
    if (FoundLabel)
    {
        return *FoundLabel;
    }
    else
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("Tagger.cpp: Missing Label: %s"), *String);
#endif
        return ELabels::None;
    }
}

References LabelMap, and None.

Referenced by GetLabelFromPath().

◆ GetLabelFromTag()

template<typename T >

ELabels ATagger::GetLabelFromTag ( const T * Object )

inlineprotected

Definition at line 95 of file Tagger.h.

    {
        if (!Object->ComponentTags.IsEmpty())
        {
            return GetLabelFromString(Object->ComponentTags[0].ToString());
        }
 
        return ELabels::None;
    }

References None.

Referenced by GetLabelFromSkeletalMeshComponent(), and GetLabelFromStaticComponent().

◆ OnActorSpawned()

void ATagger::OnActorSpawned ( AActor * Actor )

protected

Definition at line 87 of file Tagger.cpp.

{
    if (Actor)
    {
        TagActor(*Actor);
    }
}

References TagActor().

Referenced by BeginPlay().

◆ SetStencilValue()

float ATagger::SetStencilValue	(	UPrimitiveComponent &	Component,
		AActor &	Actor,
		const ELabels &	Label
	)

protected

Definition at line 170 of file Tagger.cpp.

{
    Component.SetRenderCustomDepth(true);
 
    const int32 ActorLabelStencilValue = static_cast<int32>(Label) + 1;
    float ActorLabelStencilValueFloat = static_cast<float>(ActorLabelStencilValue);
 
#if ENGINE_MAJOR_VERSION < 5 || (ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION <= 5)
    ActorLabelStencilValueFloat = static_cast<float>(ActorLabelStencilValue - 1);
#endif
 
    Component.SetCustomDepthStencilValue(ActorLabelStencilValue);
 
    float CurrentID = ID;
 
    // Set custom primitive data, used for instance segmentation.
    Component.SetCustomPrimitiveDataVector4(4,
        FVector4(CurrentID,
            ActorLabelStencilValueFloat,
            0.0f,
            0.0f));
 
    // Increase ID counter
    ID += 1.0f;
 
    return CurrentID;
}

References ID.

Referenced by TagActor().

◆ TagActor()

void ATagger::TagActor ( AActor & Actor )

protected

Definition at line 101 of file Tagger.cpp.

{
//#ifndef InstanceSegmentationPass_EXISTS
//  AInstancedActor* InstancedActor = Cast<AInstancedActor>(&Actor);
//  if (InstancedActor)
//  {
//      if (InstancedActor->IsCustomDepthSetup())
//      {
//          // Custom depth has been setup beforehand. Return
//          return;
//      }
//  }
//
//  AWalker* Walker = Cast<AWalker>(&Actor);
//  if (Walker)
//  {
//      // If the actor is AWalker, return. These are tagged in editor.
//      return;
//  }
//#endif
 
    // Check if this is a Landscape actor
    // if so, apply same ID and label to all landscape and its components.
    ALandscape* Landscape = Cast<ALandscape>(&Actor);
    if (Landscape)
    {
        TagLandscape(Landscape, Actor);
        return;
    }
 
    // Iterate all static meshes
    TArray<UStaticMeshComponent*> StaticMeshComponents;
    Actor.GetComponents<UStaticMeshComponent>(StaticMeshComponents);
    for (UStaticMeshComponent* Component : StaticMeshComponents)
    {
        if (Component)
        {
            ELabels Label = GetLabelFromStaticComponent(Component);
            float InstanceSegmentationID = SetStencilValue(*Component, Actor, Label);
 
            FTaggedActorData ActorData;
            ActorData.Actor = &Actor;
            ActorData.InstanceID = InstanceSegmentationID;
            ActorData.StaticMeshComponent = Component;
            ActorData.Label = Label;
            TaggedActors.Add(ActorData);
        }
    }
 
    // Iterate all skeletal meshes
    TArray<USkeletalMeshComponent*> SkeletalMeshComponents;
    Actor.GetComponents<USkeletalMeshComponent>(SkeletalMeshComponents);
    for (USkeletalMeshComponent* Component : SkeletalMeshComponents)
    {
        if (Component)
        {
            ELabels Label = GetLabelFromSkeletalMeshComponent(Component);
            float InstanceSegmentationID = SetStencilValue(*Component, Actor, Label);
 
            FTaggedActorData ActorData;
            ActorData.Actor = &Actor;
            ActorData.InstanceID = InstanceSegmentationID;
            ActorData.SkeletalMeshComponent = Component;
            ActorData.Label = Label;
            TaggedActors.Add(ActorData);
        }
    }
}

References FTaggedActorData::Actor, GetLabelFromSkeletalMeshComponent(), GetLabelFromStaticComponent(), FTaggedActorData::InstanceID, FTaggedActorData::Label, SetStencilValue(), FTaggedActorData::SkeletalMeshComponent, FTaggedActorData::StaticMeshComponent, TaggedActors, and TagLandscape().

Referenced by OnActorSpawned(), and TagExistingActors().

◆ TagExistingActors()

void ATagger::TagExistingActors ( )

protected

Definition at line 63 of file Tagger.cpp.

{
    TArray<AActor*> Actors;
    UGameplayStatics::GetAllActorsOfClass(GetWorld(), AActor::StaticClass(), Actors);
 
    TaggedActors.Reserve(Actors.Num());
 
    // Sort actors based on distance to the origin (0,0,0)
    // This way we can ensure that the actors are tagged in a consistent order each run
    const FVector Origin(0.0f, 0.0f, 0.0f);
    Actors.Sort([&](const AActor& A, const AActor& B)
        {
            return FVector::DistSquared(A.GetActorLocation(), Origin) < FVector::DistSquared(B.GetActorLocation(), Origin);
        });
 
    for (AActor* Actor : Actors)
    {
        if (Actor)
        {
            TagActor(*Actor);
        }
    }
}

References TagActor(), and TaggedActors.

Referenced by BeginPlay().

◆ TagLandscape()

void ATagger::TagLandscape	(	ALandscape *	Landscape,
		AActor &	Actor
	)

protected

Definition at line 344 of file Tagger.cpp.

{
    if (!Landscape) 
    {
        return;
    }
 
    constexpr float LANDSCAPE_ID = 0.0f;
 
    // For some reason we needed to loop UStaticMeshComponents instead of ULandscapeComponents
    TArray<UStaticMeshComponent*> StaticMeshComponents;
    Actor.GetComponents<UStaticMeshComponent>(StaticMeshComponents);
    for (UStaticMeshComponent* Component : StaticMeshComponents)
    {
        if (Component)
        {
            Component->SetRenderCustomDepth(true);
            Component->SetCustomDepthStencilValue(static_cast<int32>(ELabels::Terrain) + 1);
 
#ifdef InstanceSegmentationPass_EXISTS
            // Set custom primitive data, used for instance segmentation.
            Component->SetCustomPrimitiveDataVector4(4,
                FVector4(LANDSCAPE_ID,
                    (float)CastEnum(ELabels::Terrain),
                    0.0f,
                    0.0f));
#endif
        }
    }
}

References CastEnum(), and Terrain.

Referenced by TagActor().

◆ WriteComponentToCSV()

void ATagger::WriteComponentToCSV ( const FTaggedActorData Data )

protected

Definition at line 268 of file Tagger.cpp.

{
    AActor* Actor = Data.Actor;
 
    if (!Actor)
    {
        return;
    }
 
    FString AssetPath;
    FString MeshName;
    FVector Location = Actor->GetActorLocation();
    FRotator Rotation = Actor->GetActorRotation();
    FBoxSphereBounds Bounds;
 
    // Try StaticMeshComponent first
    if (Data.StaticMeshComponent && Data.StaticMeshComponent->GetStaticMesh())
    {
        UStaticMesh* StaticMesh = Data.StaticMeshComponent->GetStaticMesh();
        AssetPath = StaticMesh->GetPathName();
        MeshName = StaticMesh->GetName();
        Bounds = StaticMesh->GetBounds();
    }
    // If not valid, try SkeletalMeshComponent
    else if (Data.SkeletalMeshComponent && Data.SkeletalMeshComponent->GetSkeletalMeshAsset())
    {
        USkeletalMesh* SkeletalMesh = Data.SkeletalMeshComponent->GetSkeletalMeshAsset();
        AssetPath = SkeletalMesh->GetPathName();
        MeshName = SkeletalMesh->GetName();
        Bounds = SkeletalMesh->GetBounds();
    }
    else
    {
        return;
    }
 
    // Check asset path
    if (!AssetPath.StartsWith(TEXT("/Game/Agrarsense/Models")))
    {
        return;
    }
 
    TArray<FString> Row;
    Row.Reserve(GeoReferencingSystem ? 12 : 9);
 
    Row.Add(MeshName);
    Row.Add(FString::Printf(TEXT("%.0f"), Data.InstanceID));
 
    // TODO add semantic label to the CSV
    Row.Add(FString::Printf(TEXT("%.2f"), Location.X));
    Row.Add(FString::Printf(TEXT("%.2f"), Location.Y));
    Row.Add(FString::Printf(TEXT("%.2f"), Location.Z));
    Row.Add(FString::Printf(TEXT("%.2f"), Rotation.Yaw));
    Row.Add(FString::Printf(TEXT("%.2f"), Rotation.Pitch));
    Row.Add(FString::Printf(TEXT("%.2f"), Rotation.Roll));
 
    // Bounds
    Row.Add(FString::Printf(TEXT("Origin=(%.2f,%.2f,%.2f),BoxExtent=(%.2f,%.2f,%.2f),SphereRadius=%.2f"),
            Bounds.Origin.X, Bounds.Origin.Y, Bounds.Origin.Z,
            Bounds.BoxExtent.X, Bounds.BoxExtent.Y, Bounds.BoxExtent.Z,
            Bounds.SphereRadius));
 
    if (GeoReferencingSystem)
    {
        const FGeographicCoordinates GeoCoords = UCoordinateConversionUtilities::UnrealToGeographicCoordinates(GeoReferencingSystem, Location);
        Row.Add(FString::Printf(TEXT("%.8f"), GeoCoords.Latitude));
        Row.Add(FString::Printf(TEXT("%.8f"), GeoCoords.Longitude));
        Row.Add(FString::Printf(TEXT("%.8f"), GeoCoords.Altitude));
    }
 
    if (CSVFile)
    {
        CSVFile->WriteRow(Row);
    }
}

References FTaggedActorData::Actor, CSVFile, GeoReferencingSystem, FTaggedActorData::InstanceID, FTaggedActorData::SkeletalMeshComponent, FTaggedActorData::StaticMeshComponent, UCoordinateConversionUtilities::UnrealToGeographicCoordinates(), and UCSVFile::WriteRow().

Referenced by ExportObjectLocationsToCSV().

Member Data Documentation

◆ ActorSpawnedDelegateHandle

FDelegateHandle ATagger::ActorSpawnedDelegateHandle

private

Definition at line 113 of file Tagger.h.

Referenced by BeginPlay(), and EndPlay().

◆ CachedTerrainID

uint32 ATagger::CachedTerrainID = 0

private

Definition at line 119 of file Tagger.h.

◆ CSVFile

UCSVFile* ATagger::CSVFile = nullptr

private

Definition at line 109 of file Tagger.h.

Referenced by CreateCSVFile(), ExportObjectLocationsToCSV(), and WriteComponentToCSV().

◆ GeoReferencingSystem

AGeoReferencingSystem* ATagger::GeoReferencingSystem = nullptr

private

Definition at line 107 of file Tagger.h.

Referenced by CreateCSVFile(), and WriteComponentToCSV().

◆ ID

float ATagger::ID = 1.0f

private

Definition at line 123 of file Tagger.h.

Referenced by SetStencilValue().

◆ LabelMap

TMap<FString, ELabels> ATagger::LabelMap

private

Definition at line 115 of file Tagger.h.

Referenced by BeginPlay(), and GetLabelFromString().

◆ TaggedActors

TArray<FTaggedActorData> ATagger::TaggedActors

private

Definition at line 111 of file Tagger.h.

Referenced by EndPlay(), ExportObjectLocationsToCSV(), GetActorByInstanceID(), TagActor(), and TagExistingActors().

◆ TerrainIDCached

bool ATagger::TerrainIDCached = false

private

Definition at line 117 of file Tagger.h.

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

Unreal/Agrarsense/Source/Agrarsense/Tagger/Tagger.h
Unreal/Agrarsense/Source/Agrarsense/Tagger/Tagger.cpp

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ATagger()

Member Function Documentation

◆ BeginPlay()

◆ CreateCSVFile()

◆ EndPlay()

◆ ExportObjectLocationsToCSV()

◆ GetActorByInstanceID()

◆ GetLabelFromPath()

◆ GetLabelFromSkeletalMeshComponent()

◆ GetLabelFromStaticComponent()

◆ GetLabelFromString()

◆ GetLabelFromTag()

◆ OnActorSpawned()

◆ SetStencilValue()

◆ TagActor()

◆ TagExistingActors()

◆ TagLandscape()

◆ WriteComponentToCSV()

Member Data Documentation

◆ ActorSpawnedDelegateHandle

◆ CachedTerrainID

◆ CSVFile

◆ GeoReferencingSystem

◆ ID

◆ LabelMap

◆ TaggedActors

◆ TerrainIDCached