ADataCapture Class Reference

#include <DataCapture.h>

Inheritance diagram for ADataCapture:

Collaboration diagram for ADataCapture:

Public Member Functions
	ADataCapture (const FObjectInitializer &ObjectInitializer)
void	SetupDataCapture (FCaptureData NewCaptureData)

Protected Member Functions
virtual void	BeginPlay () override
virtual void	Tick (float DeltaTime) override
virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override

Private Member Functions
void	Capture ()
void	UpdatePositions (const FTransform &Transform)
void	CaptureDataNow ()
void	DestroySensors ()

Private Attributes
FCaptureData	CaptureData
ECaptureStep	CaptureStep = ECaptureStep::WaitingForPositionUpdate
int32	FrameCounter = 0
bool	NeedsPositionUpdate = true

Detailed Description

Definition at line 78 of file DataCapture.h.

Constructor & Destructor Documentation

ADataCapture()

ADataCapture::ADataCapture

(

const FObjectInitializer &

ObjectInitializer

)

Definition at line 18 of file DataCapture.cpp.

                                                                      : Super(ObjectInitializer)
{
    RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneRoot"));
    PrimaryActorTick.bCanEverTick = true;
    PrimaryActorTick.bStartWithTickEnabled = false;
    PrimaryActorTick.TickGroup = TG_PrePhysics;
    SetActorTickEnabled(false);
}

Member Function Documentation

BeginPlay()

void ADataCapture::BeginPlay ( )

overrideprotectedvirtual

Definition at line 159 of file DataCapture.cpp.

{
    Super::BeginPlay();
}

Capture()

void ADataCapture::Capture ( )

private

Definition at line 178 of file DataCapture.cpp.

{
    if (CaptureData.CurrentCaptureIndex >= CaptureData.CapturePositions.Num())
    {
        // if this is the last position, we can stop capturing and destroy the sensors,
        // as well as this Actor.
 
        SetActorTickEnabled(false);
 
        // Destroy this Actor with delay so Camera sensors have time to save the last images
        FTimerHandle Handle;
        GetWorld()->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this]
            {
                DestroySensors();
                Destroy();
            }), 1.0f, false);
 
        return;
    }
 
    switch (CaptureStep)
    {
    case ECaptureStep::WaitingForPositionUpdate:
    {
        // Wait one frame before moving actor
        CaptureStep = ECaptureStep::WaitingAfterPositionUpdate;
        FrameCounter = 0;
        break;
    }
    case ECaptureStep::WaitingAfterPositionUpdate:
    {
        UpdatePositions(CaptureData.CapturePositions[CaptureData.CurrentCaptureIndex]);
 
        // Move to next state
        CaptureStep = ECaptureStep::Capturing;
        FrameCounter = 0;
        break;
    }
    case ECaptureStep::Capturing:
    {
        ++FrameCounter;
        if (FrameCounter >= CaptureData.FramesToKeepInSamePosition)
        {
            CaptureDataNow();
 
            // Prepare for next wait before moving again
            CaptureStep = ECaptureStep::WaitingAfterCapture;
            FrameCounter = 0;
        }
        break;
    }
    case ECaptureStep::WaitingAfterCapture:
    {
        ++FrameCounter;
        if (FrameCounter >= CaptureData.FramesToKeepInSamePosition)
        {
            // Move to next position
            CaptureData.CurrentCaptureIndex++;
            CaptureStep = ECaptureStep::WaitingForPositionUpdate;
            FrameCounter = 0;
        }
        break;
    }
    }
}

References CaptureData, CaptureDataNow(), FCaptureData::CapturePositions, CaptureStep, Capturing, FCaptureData::CurrentCaptureIndex, Destroy, DestroySensors(), FrameCounter, FCaptureData::FramesToKeepInSamePosition, UpdatePositions(), WaitingAfterCapture, WaitingAfterPositionUpdate, and WaitingForPositionUpdate.

Referenced by Tick().

CaptureDataNow()

void ADataCapture::CaptureDataNow ( )

private

Definition at line 267 of file DataCapture.cpp.

{
    for (int32 i = 0; i < CaptureData.Cameras.Num(); i++)
    {
        ACamera* CameraPtr = CaptureData.Cameras[i];
        if (CameraPtr)
        {
            CameraPtr->SaveCurrentFrameToDisk();
        }
    }
 
    for (int32 i = 0; i < CaptureData.Lidars.Num(); i++)
    {
        ALidar* LidarPtr = CaptureData.Lidars[i];
        if (LidarPtr)
        {
            LidarPtr->SaveCurrentPointCloudToDisk();
        }
    }
}

References FCaptureData::Cameras, CaptureData, FCaptureData::Lidars, ACamera::SaveCurrentFrameToDisk(), and ALidar::SaveCurrentPointCloudToDisk().

Referenced by Capture().

DestroySensors()

void ADataCapture::DestroySensors ( )

private

Definition at line 288 of file DataCapture.cpp.

{
    for (int32 i = 0; i < CaptureData.Sensors.Num(); i++)
    {
        ASensor* SensorPtr = CaptureData.Sensors[i];
        if (SensorPtr)
        {
            SensorPtr->Destroy();
        }
    }
}

References CaptureData, and FCaptureData::Sensors.

Referenced by Capture(), and SetupDataCapture().

EndPlay()

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

overrideprotectedvirtual

Definition at line 170 of file DataCapture.cpp.

{
    Super::EndPlay(EndPlayReason);
 
    CaptureData.Cameras.Empty();
    CaptureData.CapturePositions.Empty();
}

References FCaptureData::Cameras, CaptureData, and FCaptureData::CapturePositions.

SetupDataCapture()

void ADataCapture::SetupDataCapture

(

FCaptureData

NewCaptureData

)

Definition at line 27 of file DataCapture.cpp.

{
    // Separate Cameras and Lidars from the Sensors array into their respective arrays
    // after JsonParser has populated the Sensors array.
    for (ASensor* Sensor : NewCaptureData.Sensors)
    {
        if (ACamera* CameraPtr = Cast<ACamera>(Sensor))
        {
            NewCaptureData.Cameras.Add(CameraPtr);
        }
        else if (ALidar* LidarPtr = Cast<ALidar>(Sensor))
        {
            NewCaptureData.Lidars.Add(LidarPtr);
        }
    }
 
    CaptureData = NewCaptureData;
 
    if (CaptureData.UseGPSLocation)
    {
        AGeoReferencingSystem* GeoReferencingSystem = AGeoReferencingSystem::GetGeoReferencingSystem(GetWorld());
 
        if (GeoReferencingSystem)
        {
            for (FTransform& CaptureTransform : CaptureData.CapturePositions)
            {
                FVector Location = CaptureTransform.GetLocation();
 
                float StoredZ = Location.Z;
 
                FGeographicCoordinates GeographicCoordinates;
                GeographicCoordinates.Latitude = Location.X;
                GeographicCoordinates.Longitude = Location.Y;
                GeographicCoordinates.Altitude = Location.Z;
 
                FVector InUnrealCoordinates = UCoordinateConversionUtilities::GeographicToUnrealCoordinates(GeoReferencingSystem, GeographicCoordinates);
 
                if (!CaptureData.UseHeightAboveGround) 
                {
                    CaptureTransform.SetLocation(InUnrealCoordinates);
                }
                else 
                {
                    // If user gives wanted Z in meters from the ground, compute the height
                    InUnrealCoordinates.Z = StoredZ;
                    CaptureTransform.SetLocation(InUnrealCoordinates);
                    UPhysicsUtilities::AlignTransformFromGroundInMeters(this, CaptureTransform);
                }
            }
        }
        else
        {
            SimulatorLog::Log("Couldn't convert GPS coordinates into Unreal transform because couldn't find GeoReferencingSystem.");
        }
    }
 
    if (CaptureData.CaptureRotatedViews)
    {
        // Loop through CapturePositions and add 4 additional positions for 360-degree capture
        TArray<FTransform> NewCapturePositions;
 
        for (const FTransform& OriginalTransform : CaptureData.CapturePositions)
        {
            FVector OriginalPosition = OriginalTransform.GetLocation();
            FRotator OriginalRotation = OriginalTransform.GetRotation().Rotator();
            int32 NumPhotos = 4;
 
            NewCapturePositions.Add(OriginalTransform);
 
            for (int32 i = 0; i < NumPhotos; i++)
            {
                FTransform CameraTransform = FTransform::Identity;
 
                switch (i)
                {
                case 0: // Front
                    CameraTransform.SetLocation(OriginalPosition + FVector(0, 100, 0));
                    CameraTransform.SetRotation(FQuat(OriginalRotation));
                    break;
                case 1: // Back
                    CameraTransform.SetLocation(OriginalPosition + FVector(0, -100, 0));
                    CameraTransform.SetRotation(FQuat(OriginalRotation + FRotator(0, 180, 0)));
                    break;
                case 2: // Left
                    CameraTransform.SetLocation(OriginalPosition + FVector(-100, 0, 0));
                    CameraTransform.SetRotation(FQuat(OriginalRotation + FRotator(0, 90, 0)));
                    break;
                case 3: // Right
                    CameraTransform.SetLocation(OriginalPosition + FVector(100, 0, 0));
                    CameraTransform.SetRotation(FQuat(OriginalRotation + FRotator(0, 270, 0)));
                    break;
                }
 
                // Add the new position to NewCapturePositions
                NewCapturePositions.Add(CameraTransform);
            }
        }
 
        CaptureData.CapturePositions = NewCapturePositions;
    }
 
    if (CaptureData.CapturePositions.Num() != 0 && CaptureData.Cameras.Num() != 0)
    {
        for (int32 i = 0; i < CaptureData.Cameras.Num(); i++)
        {
            ACamera* CameraPtr = CaptureData.Cameras[i];
            if (CameraPtr)
            {
                FCameraBaseParameters params = CameraPtr->GetCameraParameters();
                params.SaveImageToDisk = false;
                params.SendDataToROS = false;
                CameraPtr->ChangeCameraParameters(params);
            }
        }
 
        UpdatePositions(CaptureData.CapturePositions[0]);
 
        // Enable This Actor tick with delay
        FTimerHandle Handle;
        GetWorld()->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this]
            {
                UpdatePositions(CaptureData.CapturePositions[0]);
                SetActorTickEnabled(true);
            }), 0.1f, false);
    }
    else
    {
        DestroySensors();
        Destroy();
    }
}

References UPhysicsUtilities::AlignTransformFromGroundInMeters(), FCaptureData::Cameras, CaptureData, FCaptureData::CapturePositions, FCaptureData::CaptureRotatedViews, ACamera::ChangeCameraParameters(), Destroy, DestroySensors(), UCoordinateConversionUtilities::GeographicToUnrealCoordinates(), ACamera::GetCameraParameters(), FCaptureData::Lidars, SimulatorLog::Log(), FCameraBaseParameters::SaveImageToDisk, FCameraBaseParameters::SendDataToROS, FCaptureData::Sensors, UpdatePositions(), FCaptureData::UseGPSLocation, and FCaptureData::UseHeightAboveGround.

Referenced by USimulatorJsonParser::ParseDataCapture().

Tick()

void ADataCapture::Tick ( float  DeltaTime )

overrideprotectedvirtual

Definition at line 164 of file DataCapture.cpp.

{
    Super::Tick(DeltaTime);
    Capture();
}

References Capture().

UpdatePositions()

void ADataCapture::UpdatePositions ( const FTransform &  Transform )

private

Definition at line 244 of file DataCapture.cpp.

{
    for (int32 i = 0; i < CaptureData.Sensors.Num(); i++)
    {
        ASensor* SensorPtr = CaptureData.Sensors[i];
        if (SensorPtr)
        {
            SensorPtr->SetActorTransform(Transform);
        }
    }
 
    for (int32 i = 0; i < CaptureData.Lidars.Num(); i++)
    {
        ALidar* LidarPtr = CaptureData.Lidars[i];
        if (LidarPtr)
        {
            // The Lidar sensor generates a full point cloud across multiple frames, 
            // so to ensure accurate data capture after moving the actor, we force a reset of the point cloud capture.
            LidarPtr->ForceClearContainers();
        }
    }
}

References CaptureData, ALidar::ForceClearContainers(), FCaptureData::Lidars, FCaptureData::Sensors, and Transform.

Referenced by Capture(), and SetupDataCapture().

Member Data Documentation

CaptureData

FCaptureData ADataCapture::CaptureData

private

Definition at line 110 of file DataCapture.h.

Referenced by Capture(), CaptureDataNow(), DestroySensors(), EndPlay(), SetupDataCapture(), and UpdatePositions().

CaptureStep

ECaptureStep ADataCapture::CaptureStep = ECaptureStep::WaitingForPositionUpdate

private

Definition at line 112 of file DataCapture.h.

Referenced by Capture().

FrameCounter

int32 ADataCapture::FrameCounter = 0

private

Definition at line 114 of file DataCapture.h.

Referenced by Capture().

NeedsPositionUpdate

bool ADataCapture::NeedsPositionUpdate = true

private

Definition at line 116 of file DataCapture.h.

---

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

• Unreal/Agrarsense/Source/Agrarsense/DataCapture/DataCapture.h
• Unreal/Agrarsense/Source/Agrarsense/DataCapture/DataCapture.cpp