ATagger Class Reference

#include <Tagger.h>

Inheritance diagram for ATagger:

Collaboration diagram for ATagger:

Public Member Functions
	ATagger ()
void	ExportObjectLocationsToCSV ()
AActor *	TryGetActorByInstanceID (int32 LabelIndex, int32 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)
int32	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
TMap< ELabels, int32 >	LabelCounters

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 222 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("Label"), 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 180 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().

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()

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

protected

Definition at line 151 of file Tagger.cpp.

{
    Component.SetRenderCustomDepth(true);
 
    const int32 ActorLabelStencilValue = static_cast<int32>(Label);
    float ActorLabelStencilValueFloat = static_cast<float>(ActorLabelStencilValue);
 
    Component.SetCustomDepthStencilValue(ActorLabelStencilValue + 1);
 
    int32& Counter = LabelCounters.FindOrAdd(Label);    // default 0 on first use
    Counter += 1;                                           // assign next id
    const int32 CurrentIntID = Counter;                     // 1..n for this label
    const float CurrentID = static_cast<float>(CurrentIntID);
 
    // Write custom primitive data (X=per-label instance id, Y=semantic/stencil)
    Component.SetCustomPrimitiveDataVector4f(4,
        FVector4f(CurrentID,
            ActorLabelStencilValueFloat,
            0.0f,
            0.0f));
 
    Component.MarkRenderStateDirty();
 
    /*UE_LOG(LogTemp, Log, TEXT("Per-label ID %f -> Actor %s (Label %d)"),
        CurrentID, *Actor.GetName(), static_cast<int32>(Label));*/
 
    return CurrentIntID;
}

References LabelCounters.

Referenced by TagActor().

TagActor()

void ATagger::TagActor ( AActor &  Actor )

protected

Definition at line 101 of file Tagger.cpp.

{
    // 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);
            int32 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);
            int32 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 341 of file Tagger.cpp.

{
    if (!Landscape) 
    {
        return;
    }
 
    // Do not change. hardcoded values for landscape.
    // So each landscape section has same ID and label.
    constexpr float LANDSCAPE_LABEL = 1.0f;
    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->SetCustomPrimitiveDataVector4f(4,
                FVector4f(LANDSCAPE_ID,
                    LANDSCAPE_LABEL,
                    0.0f,
                    0.0f));
#endif
        }
    }
}

References Terrain.

Referenced by TagActor().

TryGetActorByInstanceID()

AActor * ATagger::TryGetActorByInstanceID	(	int32	LabelIndex,
		int32	InstanceID
	)

Definition at line 207 of file Tagger.cpp.

{
    const ELabels Label = static_cast<ELabels>(LabelIndex);
 
    for (const FTaggedActorData& TaggedActorData : TaggedActors)
    {
        if (TaggedActorData.Label == Label && TaggedActorData.InstanceID == InstanceID)
        {
            return TaggedActorData.Actor;
        }
    }
 
    return nullptr;
}

References TaggedActors.

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

WriteComponentToCSV()

void ATagger::WriteComponentToCSV ( const FTaggedActorData &  Data )

protected

Definition at line 252 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 ? 13 : 11);
 
    // Mesh name
    Row.Add(MeshName);
 
    // Label as: Label (NUM) like Forwarder (18)
    const UEnum* LabelsEnum = StaticEnum<ELabels>();
    const int32 LabelIndex = static_cast<int32>(static_cast<uint8>(Data.Label));
    const FString LabelName = LabelsEnum
        ? LabelsEnum->GetNameStringByValue((int64)LabelIndex)
        : TEXT("Unknown");
    Row.Add(FString::Printf(TEXT("%s (%d)"), *LabelName, LabelIndex));
 
    // Instance ID
    Row.Add(FString::FromInt(Data.InstanceID));
 
    // Transform
    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));
 
    // Optional: Georeferenced coords
    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::Label, 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.

LabelCounters

TMap<ELabels, int32> ATagger::LabelCounters

private

Definition at line 125 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(), TagActor(), TagExistingActors(), and TryGetActorByInstanceID().

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