PhotoCapture.cpp

Go to the documentation of this file.

// Copyright (c) 2024 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "PhotoCapture.h"
#include "Agrarsense/Sensor/Camera/Camera.h"
#include "Agrarsense/Utils/CoordinateConversionUtilities.h"
#include "Agrarsense/Logging/SimulatorLog.h"
 
#include "GeoReferencingSystem.h"
#include "TimerManager.h"
 
APhotoCapture::APhotoCapture(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
    RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneRoot"));
    PrimaryActorTick.bCanEverTick = true;
    PrimaryActorTick.bStartWithTickEnabled = false;
    PrimaryActorTick.TickGroup = TG_PrePhysics;
    SetActorTickEnabled(false);
}
 
void APhotoCapture::SetupPhotoCapture(FCaptureData NewCaptureData)
{
    CaptureData = NewCaptureData;
 
    if (CaptureData.UseGPSLocation)
    {
        AGeoReferencingSystem* GeoReferencingSystem = AGeoReferencingSystem::GetGeoReferencingSystem(GetWorld());
 
        if (GeoReferencingSystem)
        {
            for (FTransform& Transform : CaptureData.CapturePositions)
            {
                FVector Location = Transform.GetLocation();
 
                FGeographicCoordinates GeographicCoordinates;
                GeographicCoordinates.Latitude = Location.X;
                GeographicCoordinates.Longitude = Location.Y;
                GeographicCoordinates.Altitude = Location.Z;
 
                const FVector InUnrealCoordinates = UCoordinateConversionUtilities::GeographicToUnrealCoordinates(GeoReferencingSystem, GeographicCoordinates);
 
                Transform.SetLocation(InUnrealCoordinates);
            }
        }
        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);
            }
        }
 
        UpdateCameraPositions(CaptureData.CapturePositions[0]);
 
        // Enable This Actor tick with delay
        FTimerHandle Handle;
        GetWorld()->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this]
            {
                UpdateCameraPositions(CaptureData.CapturePositions[0]);
                SetActorTickEnabled(true);
            }), 0.1f, false);
    }
    else
    {
        DestroyCameras();
        Destroy();
    }
}
 
void APhotoCapture::BeginPlay()
{
    Super::BeginPlay();
}
 
void APhotoCapture::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    Capture();
}
 
void APhotoCapture::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    CaptureData.Cameras.Empty();
    CaptureData.CapturePositions.Empty();
}
 
void APhotoCapture::Capture()
{
    // A bit convoluted logic due to its not guaranteed that we can move actor 
    // and save the camera image in the same frame.
 
    if (CaptureData.CurrentCaptureIndex < CaptureData.CapturePositions.Num())
    {
        FrameCounter++;
        UpdateCameraPositions(CaptureData.CapturePositions[CaptureData.CurrentCaptureIndex]);
        if (FrameCounter >= CaptureData.FramesToKeepInSamePosition)
        {
            FrameCounter = 0;
            if (CaptureData.CurrentCaptureIndex != CaptureData.CapturePositions.Num())
            {
                CaptureData.CurrentCaptureIndex++;
                CaptureImages();
            }
        }
    }
 
    if (CaptureData.CurrentCaptureIndex == CaptureData.CapturePositions.Num())
    {
        // Disable tick
        SetActorTickEnabled(false);
 
        // Destroy this Actor with delay so Camera sensors has time to save the last images
        FTimerHandle Handle;
        GetWorld()->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this]
            {
                DestroyCameras();
                Destroy();
            }), 1.0f, false);
    }
}
 
void APhotoCapture::UpdateCameraPositions(const FTransform& Transform)
{
    for (int32 i = 0; i < CaptureData.Cameras.Num(); i++)
    {
        ACamera* CameraPtr = CaptureData.Cameras[i];
        if (CameraPtr)
        {
            CameraPtr->SetActorTransform(Transform);
        }
    }
}
 
void APhotoCapture::CaptureImages()
{
    for (int32 i = 0; i < CaptureData.Cameras.Num(); i++)
    {
        ACamera* CameraPtr = CaptureData.Cameras[i];
        if (CameraPtr)
        {
            CameraPtr->SaveCurrentFrameToDisk();
        }
    }
}
 
void APhotoCapture::DestroyCameras()
{
    for (int32 i = 0; i < CaptureData.Cameras.Num(); i++)
    {
        ACamera* CameraPtr = CaptureData.Cameras[i];
        if (CameraPtr)
        {
            CameraPtr->Destroy();
        }
    }
}