#include <Camera.h>

Inheritance diagram for ACamera:

[legend]

Collaboration diagram for ACamera:

[legend]

Public Member Functions
	ACamera (const FObjectInitializer &ObjectInitializer)

virtual void	Init (FCameraBaseParameters parameters, bool SimulateSensor=true)

virtual ESensorTypes	GetSensorType () const override

void	ChangeCameraParameters (FCameraBaseParameters newParameters)

FCameraBaseParameters	GetCameraParameters ()

void	AddPostProcessingMaterial (const FString &Path, float Weight=1.0f)

void	RemovePostProcessingMaterial (UMaterial *Material)

USceneCaptureComponent2D *	GetCaptureComponent2D () const

UTextureRenderTarget2D *	GetCaptureRenderTarget2D () const

void	AddWidgetToWindow (UWidget *WidgetToAdd)

void	RemoveWidgetFromWindow (UWidget *WidgetToRemove)

void	SetShadowRendering (bool RenderShadows)

void	DisableShowFlags ()

void	SetTemporalAA (bool SetTemporal)

void	ResizeCamera (int32 Width=1280, int32 Height=720)

void	AddHiddenActor (AActor *Actor)

void	SaveCurrentFrameToDisk ()

int32	GetCameraWidth () const

int32	GetCameraHeight () const

void	SetUseGimbal (bool UseGimbal)

virtual FString	GetParametersAsString () const override

Public Member Functions inherited from ASensor
	ASensor (const FObjectInitializer &ObjectInitializer)

FString	ExportToJsonFile (const FString &FileName)

virtual ESensorTypes	GetSensorType () const

FString	GetSensorIdentifier () const

void	SetSensorIdentifier (const FString newIdentifier)

FString	GetSensorName () const

virtual FString	GetParametersAsString () const

AVehicle *	IsAttachedToVehicle () const

void	SetSensorName (const FString newName)

FString	GetTopicName ()

UTopic *	GetROSTopic () const

void	SetSimulateSensor (bool SimulateSensor)

bool	CanSimulateSensor () const

ASensorModel *	GetSensorModel () const

void	SetSensorModel (ASensorModel *NewSensorModel)

FORCEINLINE bool	IsROSConnected () const

UROSIntegrationGameInstance *	GetROSGameInstance () const

virtual FString	GetActorID_Implementation () const override

virtual FString	GetActorName_Implementation () const override

virtual FString	GetActorInformation_Implementation () const override

virtual void	SetActorName_Implementation (const FString &NewActorName) override

virtual void	SetActorIDAndName_Implementation (const FString &NewActorName, const FString &NewID) override

void	SetParentActorPtr (AActor *ParentActorPtr)

Public Member Functions inherited from IActorInformation
FString	GetActorID () const

FString	GetActorName () const

FString	GetActorInformation () const

void	SetActorName (const FString &NewActorName)

void	SetActorIDAndName (const FString &NewActorName, const FString &NewID)

Public Attributes
TEnumAsByte< ETextureRenderTargetFormat >	TextureFormat = ETextureRenderTargetFormat::RTF_RGBA8

FCameraDelegate_OnWindowClosed	OnCameraWindowClosed

FCameraDelegate_OnWindowResized	OnCameraWindowResized

Public Attributes inherited from ASensor
FSensorDestroy	OnSensorDestroy

FString	AttachedToComponent

FName	AttachedToBone

Protected Member Functions
virtual void	BeginPlay () override

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

void	PreActorTick (UWorld *World, ELevelTick TickType, float DeltaSeconds)

void	EndOfFrame (UWorld *World, ELevelTick TickType, float DeltaSeconds)

void	EndOfFrameParellel (float DeltaTime)

virtual void	AddProcessingToFrameBuffer (TArray< FColor > &buffer)

void	ApplyGammaCorrectionLUT (TArray< FColor > &Buffer)

void	SendImageDataToROS (const TArray< FColor > &FrameBuffer, int32 Width, int32 Height)

void	HidePrimitiveComponent (UPrimitiveComponent *PrimitiveComponent)

void	SaveImageToDisk (const TArray< FColor > FrameBuffer, int32 Width, int32 Height)

void	SaveCameraMetaDataToDisk (const FString &ImageName)

void	CreateLogFile () override

Protected Member Functions inherited from ASensor
virtual void	BeginPlay () override

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

FString	CreateTimeStampString () const

virtual void	CreateROSTopic ()

virtual void	DestroyROSTopic ()

virtual void	CreateDataSavePath ()

bool	IsLogFileCreated ()

virtual void	CreateLogFile ()

void	WriteToLogFile (const FString &Message)

Protected Attributes
bool	UseParallelLateTick = true

FDelegateHandle	OnPreTickDelegate

FDelegateHandle	OnPostTickDelegate

FString	CameraName = "Camera "

FString	FilePrefix = "Data/Camera_"

UTextureRenderTarget2D *	CaptureRenderTarget = nullptr

USceneCaptureComponent2D *	CaptureComponent2D = nullptr

UTexture2D *	CaptureFrameTexture

TSharedPtr< FUnrealWindow >	UnrealWindow

FTickEntry	TickEntry

TWeakObjectPtr< UMaterialInstanceDynamic >	IceMaterialInstance

TWeakObjectPtr< UMaterial >	PhysicLensDistortion

APIDDrone *	DronePtr = nullptr

FRotator	SensorSetRotation

bool	AllowGimbal = true

Protected Attributes inherited from ASensor
UTopic *	ROSTopic = nullptr

bool	SendDataToROS = true

ULogFile *	LogFile = nullptr

AActor *	ParentActor = nullptr

FString	FileSavePath

UROSIntegrationGameInstance *	ROSInstance = nullptr

Private Member Functions
void	StartFrameGrabber ()

void	ReleaseFrameGrabber ()

void	FrameGrabberCapture ()

void	OnWindowClosed (const TSharedRef< SWindow > &Window)

void	SetupCamera (FCameraBaseParameters parameters)

bool	ShouldSimulate (const float DeltaSeconds)

Private Attributes
TSharedPtr< FFrameGrabber >	FrameGrabber

FCameraBaseParameters	CameraParameters

FCameraBaseParameters	TempParams

AGeoReferencingSystem *	GeoReferencingSystem = nullptr

bool	ParametersChanged = false

FOnWindowClosed	OnWindowClosedDelegate

TSharedPtr< ROSMessages::sensor_msgs::Image >	ImageMsg

int32	ImageWidth = 1280

int32	ImageHeight = 720

bool	SaveCurrentFrameToDiskRequested = false

bool	ShouldSimulateCamera = true

float	CameraFrameRate = 0.0f

float	FrameRateTimer = 0.0f

int32	ImageNumber = 0

uint8 *	BGR8Buffer = nullptr

int32	CurrentBufferSize = 0

Additional Inherited Members
Static Public Member Functions inherited from ASensor
static void	HideComponentForAllCameras (UPrimitiveComponent *PrimitiveComponent)

static TMap< FString, FColor >	GetSemanticColors ()

static TArray< TWeakObjectPtr< UPrimitiveComponent > >	GetComponentsToHide ()

Static Public Member Functions inherited from IActorInformation
static void	SetAndValidateActorIDAndName (FString &ActorName, FString &ActorID, TWeakObjectPtr< AActor > Actor)

static bool	DestroyActorByID (const FString &ID)

static AActor *	GetActorByID (const FString &ID)

template<typename T >
static TArray< T * >	GetActorsWithInterface ()

static void	PrintAllIds ()

Static Protected Member Functions inherited from ASensor
template<typename InStructType >
static FString	StructToString (const InStructType &InStruct)

Static Protected Attributes inherited from ASensor
static FPrimitiveAdded	OnPrimitiveAdded

static const FName	NiagaraPointsInt = "User.PointCount"

static const FName	NiagaraHitPoints = "User.HitPoints"

static const FName	NiagaraHitColors = "User.HitColors"

static const FName	NiagaraPointsFloat = "User.Test"

Detailed Description

Camera sensor base class. All other Camera sensors are inherited from this class.

This creates custom Unreal Engine Window and renders USceneCaptureComponent2D into it. Then the Window screen pixels are read by FrameGrabber API which depending on the Camera type, might add processing on the read pixels. The pixels are then saved to disk if SaveDataToDisk is set to true and data is sent to ROS.

Definition at line 52 of file Camera.h.

Constructor & Destructor Documentation

◆ ACamera()

ACamera::ACamera ( const FObjectInitializer & ObjectInitializer )

Setup new ACamera class

Parameters

FObjectInitializer default ObjectInitializer

Definition at line 33 of file Camera.cpp.

                                                            : Super(ObjectInitializer)
{
    PrimaryActorTick.bCanEverTick = true;
    PrimaryActorTick.TickGroup = TG_PostUpdateWork;
 
    CaptureRenderTarget = CreateDefaultSubobject<UTextureRenderTarget2D>(FName(*FString::Printf(TEXT("CaptureRenderTarget"))));
    CaptureRenderTarget->CompressionSettings = TextureCompressionSettings::TC_Default;
    CaptureRenderTarget->SRGB = false;
    CaptureRenderTarget->bAutoGenerateMips = false;
    CaptureRenderTarget->bGPUSharedFlag = true;
    CaptureRenderTarget->AddressX = TextureAddress::TA_Clamp;
    CaptureRenderTarget->AddressY = TextureAddress::TA_Clamp;
 
    CaptureComponent2D = CreateDefaultSubobject<USceneCaptureComponent2D>(FName(*FString::Printf(TEXT("SceneCaptureComponent2D"))));
    CaptureComponent2D->SetupAttachment(RootComponent);
    CaptureComponent2D->PrimitiveRenderMode = ESceneCapturePrimitiveRenderMode::PRM_RenderScenePrimitives;
    CaptureComponent2D->bCaptureOnMovement = false;
    CaptureComponent2D->bCaptureEveryFrame = false;
    CaptureComponent2D->bAlwaysPersistRenderingState = true;
}

References CaptureComponent2D, and CaptureRenderTarget.

Member Function Documentation

◆ AddHiddenActor()

void ACamera::AddHiddenActor ( AActor * Actor )

Definition at line 890 of file Camera.cpp.

{
    if (Actor && CaptureComponent2D)
    {
        CaptureComponent2D->HiddenActors.AddUnique(Actor);
    }
}

References CaptureComponent2D.

◆ AddPostProcessingMaterial()

void ACamera::AddPostProcessingMaterial	(	const FString &	Path,
		float	Weight = `1.0f`
	)

Adds a post-processing material from the specified file path.

Parameters

Path	The file path to the post-processing material.
Weight	The weight or influence of the material. Default is 1.0f.

Definition at line 59 of file Camera.cpp.

{
    UMaterial* PostProcessingMat = Cast<UMaterial>(StaticLoadObject(UMaterial::StaticClass(), nullptr, *Path));
    if (PostProcessingMat && CaptureComponent2D)
    {
        FPostProcessSettings& PostProcessSettings = CaptureComponent2D->PostProcessSettings;
        PostProcessSettings.AddBlendable(PostProcessingMat, Weight);
    }
    else
    {
        const FString ErrorMessage = FString::Printf(TEXT("Failed to add post-processing material to sensor: %s"), *GetSensorName());
        SimulatorLog::Log(ErrorMessage);
    }
}

References CaptureComponent2D, ASensor::GetSensorName(), and SimulatorLog::Log().

Referenced by AInstanceSegmentationCamera::Init(), ASemanticSegmentationCamera::Init(), and ADepthCamera::SetupDepthMaterial().

◆ AddProcessingToFrameBuffer()

void ACamera::AddProcessingToFrameBuffer ( TArray< FColor > & buffer )

protectedvirtual

Reimplemented in ADepthCamera, AInstanceSegmentationCamera, ASemanticSegmentationCamera, and ADVSCamera.

Definition at line 593 of file Camera.cpp.

{
    return;
}

Referenced by FrameGrabberCapture().

◆ AddWidgetToWindow()

void ACamera::AddWidgetToWindow ( UWidget * WidgetToAdd )

Add Widget to custom Unreal Window

Definition at line 842 of file Camera.cpp.

{
    if (UnrealWindow.IsValid() && WidgetToAdd)
    {
        UnrealWindow->AddUWidgetToWindow(WidgetToAdd);
    }
}

References UnrealWindow.

Referenced by SetupCamera().

◆ ApplyGammaCorrectionLUT()

void ACamera::ApplyGammaCorrectionLUT ( TArray< FColor > & Buffer )

protected

Definition at line 598 of file Camera.cpp.

{
    static uint8 GammaLUT[256];
    static bool LUTInitialized = false;
    if (!LUTInitialized)
    {
        LUTInitialized = true;
        for (int32 i = 0; i < 256; ++i)
        {
            float Linear = FMath::Pow(i / 255.0f, 2.2f);
            GammaLUT[i] = FMath::RoundToInt(Linear * 255.0f);
        }
    }
 
    FColor* RESTRICT BufferPtr = Buffer.GetData();
    const int32 Num = Buffer.Num();
 
    const int32 ChunkSize = 512;
    const int32 NumChunks = (Num + ChunkSize - 1) / ChunkSize;
 
    ParallelFor(NumChunks, [BufferPtr, Num](int32 ChunkIndex)
        {
            const int32 Start = ChunkIndex * ChunkSize;
            const int32 End = FMath::Min(Start + ChunkSize, Num);
 
            for (int32 i = Start; i < End; ++i)
            {
                FColor& C = BufferPtr[i];
                C.R = GammaLUT[C.R];
                C.G = GammaLUT[C.G];
                C.B = GammaLUT[C.B];
            }
        }, false);
}

Referenced by ADepthCamera::AddProcessingToFrameBuffer(), AInstanceSegmentationCamera::AddProcessingToFrameBuffer(), and ASemanticSegmentationCamera::AddProcessingToFrameBuffer().

◆ BeginPlay()

void ACamera::BeginPlay ( )

overrideprotectedvirtual

Reimplemented from ASensor.

Definition at line 391 of file Camera.cpp.

{
    Super::BeginPlay();
 
    // Register to PreActorTick where USceneCaptureComponent2D will get rendered.
    OnPreTickDelegate = FWorldDelegates::OnWorldPreActorTick.AddUObject(this, &ACamera::PreActorTick);
 
    // Check if we should use ATickManager which ticks in parallel, or use Post actor tick
    // In there we capture the screen pixels with FrameGrabber API, 
    // might do some extra processing, save image to disk and send data to ROS. 
    if (UseParallelLateTick)
    {
        SetActorTickEnabled(false);
        TickEntry = ATickManager::AddTick(this, BindTick(this, &ACamera::EndOfFrameParellel), ETickType::LateTickParallel);
    }
    else
    {
        SetActorTickEnabled(true);
        OnPostTickDelegate = FWorldDelegates::OnWorldPostActorTick.AddUObject(this, &ACamera::EndOfFrame);
    }
 
    // Get all existing components set to be hidden for all Camera sensors (like Lidar point cloud visualization).
    auto Components = ASensor::GetComponentsToHide();
    for (int32 i = 0; i < Components.Num(); i++)
    {
        UPrimitiveComponent* Primitive = Components[i].Get();
        if (Primitive)
        {
            HidePrimitiveComponent(Primitive);
        }
    }
 
    OnPrimitiveAdded.AddUniqueDynamic(this, &ACamera::HidePrimitiveComponent);
 
    GetWorld()->GetTimerManager().SetTimerForNextTick([this]()
        {
            if (IsValid(this))
            {
                DronePtr = Cast<APIDDrone>(GetAttachParentActor());
                if (!DronePtr)
                {
                    AllowGimbal = false;
                }
            }
        });
}

References ATickManager::AddTick(), AllowGimbal, BindTick(), DronePtr, EndOfFrame(), EndOfFrameParellel(), ASensor::GetComponentsToHide(), HidePrimitiveComponent(), OnPostTickDelegate, OnPreTickDelegate, ASensor::OnPrimitiveAdded, PreActorTick(), TickEntry, and UseParallelLateTick.

◆ ChangeCameraParameters()

void ACamera::ChangeCameraParameters ( FCameraBaseParameters newParameters )

Change Camera parameters on the fly. Callable from blueprint.

Parameters

FCameraBaseParameters CameraParameters struct

Definition at line 54 of file Camera.cpp.

{
    SetupCamera(newParameters);
}

References SetupCamera().

Referenced by ADepthCamera::ChangeDepthCameraParameters(), ADVSCamera::ChangeParametersInternal(), AThermalCamera::ChangeThermalCameraParameters(), ResizeCamera(), and ADataCapture::SetupDataCapture().

◆ CreateLogFile()

void ACamera::CreateLogFile ( )

overrideprotectedvirtual

Create Text file for this sensor if it has not been created already. Text file will be created to ROOT/Data/Run/Logs directory. Filename will be SensorName_ID_UnixTimestamp.txt Can be overriden by individual sensor if needed.

Reimplemented from ASensor.

Definition at line 90 of file Camera.cpp.

{
    if (IsValid(LogFile))
    {
        // File has already been created, return
        return;
    }
 
    FLogFileSettings Settings;
    Settings.FileCreationOptions = FFileCreationOptions::Overwrite;
    Settings.FileWriteOptions = FFileWriteOptions::Queue;
    Settings.QueueLength = MAX_int32; // Only write the log after destroying the sensor
    Settings.KeepFileOpen = false;
    Settings.Timestamp = false;
    Settings.OverrideFilePath = true;
    Settings.FilePath = FileSavePath;
 
    LogFile = NewObject<ULogFile>(ULogFile::StaticClass());
    if (IsValid(LogFile))
    {
        const FString FileName = "camera_metadata";
        LogFile->Create(FileName, Settings);
 
        // Write camera metadata first line to explain the values.
        GeoReferencingSystem = AGeoReferencingSystem::GetGeoReferencingSystem(GetWorld());
        if (GeoReferencingSystem)
        {
            WriteToLogFile("timestamp, image_name, X location, Y location, Z location, yaw rotation, pitch rotation, roll rotation, GPS latitude, GPS longitude, GPS altitude");
        }
        else
        {
            WriteToLogFile("timestamp, image_name, X location, Y location, Z location, yaw rotation, pitch rotation, roll rotation");
        }
    }
}

References ULogFile::Create(), FLogFileSettings::FileCreationOptions, FLogFileSettings::FilePath, ASensor::FileSavePath, FLogFileSettings::FileWriteOptions, GeoReferencingSystem, FLogFileSettings::KeepFileOpen, ASensor::LogFile, FLogFileSettings::OverrideFilePath, Overwrite, Queue, FLogFileSettings::QueueLength, FLogFileSettings::Timestamp, and ASensor::WriteToLogFile().

Referenced by FrameGrabberCapture(), and SetupCamera().

◆ DisableShowFlags()

void ACamera::DisableShowFlags ( )

Definition at line 898 of file Camera.cpp.

{
    if (!CaptureComponent2D)
    {
        return;
    }
 
    auto& ShowFlags = CaptureComponent2D->ShowFlags;
 
    ShowFlags.SetDeferredLighting(false);
    ShowFlags.SetSkyLighting(false);
    ShowFlags.SetAmbientOcclusion(false);
    ShowFlags.SetAntiAliasing(false);
    ShowFlags.SetVolumetricFog(false);;
    ShowFlags.SetBloom(false);
    ShowFlags.SetCameraImperfections(false);
    ShowFlags.SetCameraInterpolation(false);
    ShowFlags.SetColorGrading(false);
    ShowFlags.SetDepthOfField(false);
    ShowFlags.SetDiffuse(false);
    ShowFlags.SetDirectionalLights(false);
    ShowFlags.SetDirectLighting(false);
    ShowFlags.SetDynamicShadows(false);
    ShowFlags.SetEyeAdaptation(false);
    ShowFlags.SetFog(false);
    ShowFlags.SetGlobalIllumination(false);
    ShowFlags.SetGrain(false);
    ShowFlags.SetHLODColoration(false);
    ShowFlags.SetHMDDistortion(false);
    ShowFlags.SetLensFlares(false);
    ShowFlags.SetLightComplexity(false);
    ShowFlags.SetLightFunctions(false);
    ShowFlags.SetLightInfluences(false);
    ShowFlags.SetLighting(false);
    ShowFlags.SetLightMapDensity(false);
    ShowFlags.SetLightRadius(false);
    ShowFlags.SetLightShafts(false);
    ShowFlags.SetLODColoration(false);
    ShowFlags.SetMotionBlur(false);
    ShowFlags.SetOnScreenDebug(false);
    ShowFlags.SetParticles(false);
    ShowFlags.SetPointLights(false);
    ShowFlags.SetRefraction(false);
    ShowFlags.SetSceneColorFringe(false);
    ShowFlags.SetScreenSpaceAO(false);
    ShowFlags.SetScreenSpaceReflections(false);
    ShowFlags.SetSkyLighting(false);
    ShowFlags.SetSpotLights(false);
    ShowFlags.SetStationaryLightOverlap(false);
    ShowFlags.SetSubsurfaceScattering(false);
    ShowFlags.SetTonemapper(false);
    ShowFlags.SetVisualizeBuffer(false);
    ShowFlags.SetVisualizeDistanceFieldAO(false);
    ShowFlags.SetVisualizeDOF(false);
    ShowFlags.SetVisualizeHDR(false);
    ShowFlags.SetVisualizeLightCulling(false);
    ShowFlags.SetVisualizeMeshDistanceFields(false);
    ShowFlags.SetVisualizeMotionBlur(false);
    ShowFlags.SetVisualizeOutOfBoundsPixels(false);
    ShowFlags.SetVisualizeSenses(false);
    ShowFlags.SetVisualizeShadingModels(false);
    ShowFlags.SetVisualizeSSR(false);
    ShowFlags.SetVisualizeSSS(false);
}

References CaptureComponent2D.

Referenced by ADepthCamera::Init(), AInstanceSegmentationCamera::Init(), and ASemanticSegmentationCamera::Init().

◆ EndOfFrame()

void ACamera::EndOfFrame	(	UWorld *	World,
		ELevelTick	TickType,
		float	DeltaSeconds
	)

protected

Definition at line 516 of file Camera.cpp.

{
    FrameGrabberCapture();
}

References FrameGrabberCapture().

Referenced by BeginPlay().

◆ EndOfFrameParellel()

void ACamera::EndOfFrameParellel ( float DeltaTime )

protected

Definition at line 521 of file Camera.cpp.

{
    FrameGrabberCapture();
}

References FrameGrabberCapture().

Referenced by BeginPlay().

◆ EndPlay()

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

overrideprotectedvirtual

Reimplemented from ASensor.

Reimplemented in AInstanceSegmentationCamera, ADepthCamera, ADVSCamera, and AThermalCamera.

Definition at line 438 of file Camera.cpp.

{
    Super::EndPlay(EndPlayReason);
 
    FWorldDelegates::OnWorldPreActorTick.Remove(OnPreTickDelegate);
 
    if (UseParallelLateTick)
    {
        ATickManager::RemoveTick(TickEntry);
    }
    else
    {
        FWorldDelegates::OnWorldPostActorTick.Remove(OnPostTickDelegate);
    }
 
    if (UnrealWindow.IsValid())
    {
        OnWindowClosedDelegate.Unbind();
        UnrealWindow->DestroyWindow();
        UnrealWindow.Reset();
    }
 
    ReleaseFrameGrabber();
 
    if (CaptureRenderTarget)
    {
        CaptureRenderTarget->ConditionalBeginDestroy();
        CaptureRenderTarget = nullptr;
    }
 
    if (CaptureComponent2D)
    {
        CaptureComponent2D->UnregisterComponent();
        CaptureComponent2D->ConditionalBeginDestroy();
        CaptureComponent2D = nullptr;
    }
 
    ImageMsg.Reset();
    IceMaterialInstance.Reset();
 
    if (BGR8Buffer)
    {
        delete[] BGR8Buffer;
        BGR8Buffer = nullptr;
    }
    CurrentBufferSize = 0;
}

References BGR8Buffer, CaptureComponent2D, CaptureRenderTarget, CurrentBufferSize, IceMaterialInstance, ImageMsg, OnPostTickDelegate, OnPreTickDelegate, OnWindowClosedDelegate, ReleaseFrameGrabber(), ATickManager::RemoveTick(), TickEntry, UnrealWindow, and UseParallelLateTick.

◆ FrameGrabberCapture()

void ACamera::FrameGrabberCapture ( )

private

Capture screen pixels with FrameGrabber

Definition at line 553 of file Camera.cpp.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACamera::FrameGrabberCapture);
 
    if (!ShouldSimulateCamera || !FrameGrabber.IsValid())
    {
        return;
    }
 
    if (!SendDataToROS && !CameraParameters.SaveImageToDisk && !SaveCurrentFrameToDiskRequested)
    {
        return;
    }
 
    TArray<FCapturedFrameData> Frames = FrameGrabber->GetCapturedFrames();
    if (Frames.Num())
    {
        FCapturedFrameData& LastFrame = Frames.Last();
        TArray<FColor>& ImageBuffer = LastFrame.ColorBuffer;
 
        AddProcessingToFrameBuffer(ImageBuffer);
 
        if (CameraParameters.SaveImageToDisk || SaveCurrentFrameToDiskRequested)
        {
            if (SaveCurrentFrameToDiskRequested)
            {
                CreateLogFile();
                SaveCurrentFrameToDiskRequested = false;
            }
 
            AsyncTask(ENamedThreads::AnyBackgroundThreadNormalTask, [this, ImageBuffer]()
                {
                    SaveImageToDisk(ImageBuffer, ImageWidth, ImageHeight);
                });
        }
 
        SendImageDataToROS(ImageBuffer, ImageWidth, ImageHeight);
    }
}

References AddProcessingToFrameBuffer(), CameraParameters, CreateLogFile(), FrameGrabber, FrameGrabberCapture(), ImageHeight, ImageWidth, SaveCurrentFrameToDiskRequested, SaveImageToDisk(), FCameraBaseParameters::SaveImageToDisk, ASensor::SendDataToROS, SendImageDataToROS(), and ShouldSimulateCamera.

Referenced by EndOfFrame(), EndOfFrameParellel(), and FrameGrabberCapture().

◆ GetCameraHeight()

int32 ACamera::GetCameraHeight ( ) const

inline

Definition at line 207 of file Camera.h.

    {
        return ImageHeight;
    }

Referenced by ADVSCamera::ChangeParametersInternal(), ADVSCamera::Init(), and ADVSCamera::SimulateDVS().

◆ GetCameraParameters()

FCameraBaseParameters ACamera::GetCameraParameters ( )

inline

Get current Camera parameters

Returns: FCameraBaseParameters struct

Definition at line 91 of file Camera.h.

    {
        return CameraParameters;
    }

Referenced by USimulatorJsonExporter::ExportSensorToJSON(), and ADataCapture::SetupDataCapture().

◆ GetCameraWidth()

int32 ACamera::GetCameraWidth ( ) const

inline

Definition at line 201 of file Camera.h.

    {
        return ImageWidth;
    }

Referenced by ADVSCamera::ChangeParametersInternal(), ADVSCamera::Init(), and ADVSCamera::SimulateDVS().

◆ GetCaptureComponent2D()

USceneCaptureComponent2D * ACamera::GetCaptureComponent2D ( ) const

inline

Get CaptureComponent USceneCaptureComponent2D pointer.

Returns: USceneCaptureComponent2D pointer

Definition at line 114 of file Camera.h.

    {
        return CaptureComponent2D;
    }

Referenced by ADepthCamera::SetupDepthMaterial(), and AThermalCamera::SetupMaterial().

◆ GetCaptureRenderTarget2D()

UTextureRenderTarget2D * ACamera::GetCaptureRenderTarget2D ( ) const

inline

Get UTextureRenderTarget2D pointer.

Returns: UTextureRenderTarget2D pointer

Definition at line 124 of file Camera.h.

    {
        return CaptureRenderTarget;
    }

◆ GetParametersAsString()

virtual FString ACamera::GetParametersAsString ( ) const

inlineoverridevirtual

Get current LidarParameters struct fields as one string.

Reimplemented from ASensor.

Reimplemented in ADepthCamera, ADVSCamera, and AThermalCamera.

Definition at line 221 of file Camera.h.

    {
        return StructToString(CameraParameters);
    }

◆ GetSensorType()

virtual ESensorTypes ACamera::GetSensorType ( ) const

inlineoverridevirtual

Get type of the sensor

Returns: Sensor's type

Reimplemented from ASensor.

Reimplemented in ADepthCamera, ADVSCamera, AInstanceSegmentationCamera, ASemanticSegmentationCamera, and AThermalCamera.

Definition at line 74 of file Camera.h.

    { 
        return ESensorTypes::RGBCamera; 
    }

References RGBCamera.

Referenced by SetupCamera(), and StartFrameGrabber().

◆ HidePrimitiveComponent()

void ACamera::HidePrimitiveComponent ( UPrimitiveComponent * PrimitiveComponent )

protected

Definition at line 633 of file Camera.cpp.

{
    if (PrimitiveComponent && CaptureComponent2D)
    {
        CaptureComponent2D->HideComponent(PrimitiveComponent);
    }
}

References CaptureComponent2D.

Referenced by BeginPlay().

◆ Init()

void ACamera::Init	(	FCameraBaseParameters	parameters,
		bool	SimulateSensor = `true`
	)

virtual

Initialize new Camera sensor

Parameters

FCameraBaseParameters CameraParameters struct

Reimplemented in ADepthCamera, ADVSCamera, AInstanceSegmentationCamera, ASemanticSegmentationCamera, and AThermalCamera.

Definition at line 83 of file Camera.cpp.

{
    CreateDataSavePath();
    SetSimulateSensor(SimulateSensor);
    SetupCamera(parameters);
}

References ASensor::CreateDataSavePath(), ASensor::SetSimulateSensor(), and SetupCamera().

Referenced by USensorFactory::SpawnCamera().

◆ OnWindowClosed()

void ACamera::OnWindowClosed ( const TSharedRef< SWindow > & Window )

private

On camera window closed event

Parameters

Window reference to SWindow pointer

Definition at line 829 of file Camera.cpp.

{
#if WITH_EDITOR
    UE_LOG(LogTemp, Warning, TEXT("Camera.cpp: Camera window closed. Destroying Camera sensor.."));
#endif
 
    // Broadcast event that this Camera sensor is about be destroyed when user has clicked Window Close button.
    OnCameraWindowClosed.Broadcast(this);
 
    // Destroy this camera sensor
    this->Destroy();
}

References Destroy, and OnCameraWindowClosed.

Referenced by SetupCamera().

◆ PreActorTick()

void ACamera::PreActorTick	(	UWorld *	World,
		ELevelTick	TickType,
		float	DeltaSeconds
	)

protected

Definition at line 486 of file Camera.cpp.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACamera::PreActorTick);
 
    // If this Camera sensor is attached to Drone, keep the camera steady kind of like a Gimbal.
    if (AllowGimbal && DronePtr && !DronePtr->IsVehicleInGarage())
    {
        if (SensorSetRotation == FRotator::ZeroRotator)
        {
            // Save garage sensor values
            SensorSetRotation = GetTransform().Rotator();
        }
        FRotator gimbalRot = FRotator(SensorSetRotation.Pitch, GetActorRotation().Yaw, SensorSetRotation.Roll);
        SetActorRotation(gimbalRot);
    }
 
    if (ShouldSimulate(DeltaSeconds) && CaptureComponent2D)
    {
        // Capture scene now.
        // We could use CaptureSceneDeferred but it would not work if World (Spectator) Rendering is disabled.
        CaptureComponent2D->CaptureScene();
 
        // Inform FrameGrabber to capture this frame
        if (FrameGrabber.IsValid())
        {
            FrameGrabber->CaptureThisFrame(FFramePayloadPtr());
        }
    }
}

References AllowGimbal, CaptureComponent2D, DronePtr, FrameGrabber, AVehicle::IsVehicleInGarage(), PreActorTick(), SensorSetRotation, and ShouldSimulate().

Referenced by BeginPlay(), and PreActorTick().

◆ ReleaseFrameGrabber()

void ACamera::ReleaseFrameGrabber ( )

private

Release FrameGrabber and destroy UTexture2D

Definition at line 672 of file Camera.cpp.

{
    if (FrameGrabber.IsValid())
    {
        FrameGrabber->StopCapturingFrames();
        FrameGrabber->Shutdown();
        FrameGrabber.Reset();
    }
 
    if (CaptureFrameTexture)
    {
        CaptureFrameTexture->RemoveFromRoot();
        CaptureFrameTexture->ConditionalBeginDestroy();
        CaptureFrameTexture = nullptr;
    }
}

References CaptureFrameTexture, and FrameGrabber.

Referenced by EndPlay(), and StartFrameGrabber().

◆ RemovePostProcessingMaterial()

void ACamera::RemovePostProcessingMaterial ( UMaterial * Material )

Removes a specified post-processing material.

Parameters

Material A pointer to the material to be removed.

Definition at line 74 of file Camera.cpp.

{
    if (CaptureComponent2D)
    {
        FPostProcessSettings& PostProcessSettings = CaptureComponent2D->PostProcessSettings;
        PostProcessSettings.RemoveBlendable(Material);
    }
}

References CaptureComponent2D.

Referenced by ADepthCamera::SetupDepthMaterial().

◆ RemoveWidgetFromWindow()

void ACamera::RemoveWidgetFromWindow ( UWidget * WidgetToRemove )

Remove Widget from custom Unreal Window

Definition at line 850 of file Camera.cpp.

{
    if (UnrealWindow.IsValid() && WidgetToRemove)
    {
        UnrealWindow->RemoveUWidgetFromWindow(WidgetToRemove);
    }
}

References UnrealWindow.

◆ ResizeCamera()

void ACamera::ResizeCamera	(	int32	Width = `1280`,
		int32	Height = `720`
	)

Resize camera and custom Unreal Window certain size

Definition at line 878 of file Camera.cpp.

{
    if (Width == 0 || Height == 0)
    {
        return;
    }
 
    CameraParameters.Width = Width;
    CameraParameters.Height = Height;
    ChangeCameraParameters(CameraParameters);
}

References CameraParameters, ChangeCameraParameters(), FCameraBaseParameters::Height, and FCameraBaseParameters::Width.

◆ SaveCameraMetaDataToDisk()

void ACamera::SaveCameraMetaDataToDisk ( const FString & ImageName )

protected

Definition at line 794 of file Camera.cpp.

{
    if (!IsValid(LogFile))
    {
        // If the log file located in base class is not valid, return here.
        return;
    }
 
    const FVector ActorPosition = GetActorLocation();
    const FRotator ActorRotation = GetActorRotation();
 
    const FString TimeStamp = CreateTimeStampString();
    FString MetaData;
    
    if (GeoReferencingSystem)
    {
        FGeographicCoordinates GeoCoordinates = UCoordinateConversionUtilities::UnrealToGeographicCoordinates(GeoReferencingSystem, ActorPosition);
        MetaData = FString::Printf(TEXT("%s, %s, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.8f, %.8f, %.8f"),
            *TimeStamp, *ImageName,
            ActorPosition.X, ActorPosition.Y, ActorPosition.Z,
            ActorRotation.Pitch, ActorRotation.Yaw, ActorRotation.Roll,
            GeoCoordinates.Latitude, GeoCoordinates.Longitude, GeoCoordinates.Altitude);
    }
    else
    {
        MetaData = FString::Printf(TEXT("%s, %s, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f"),
            *TimeStamp, *ImageName,
            ActorPosition.X, ActorPosition.Y, ActorPosition.Z,
            ActorRotation.Pitch, ActorRotation.Yaw, ActorRotation.Roll);
    }
 
    // Write to the log file (this is written after sensor is destroyed)
    WriteToLogFile(MetaData);
}

References ASensor::CreateTimeStampString(), GeoReferencingSystem, ASensor::LogFile, UCoordinateConversionUtilities::UnrealToGeographicCoordinates(), and ASensor::WriteToLogFile().

Referenced by SaveImageToDisk().

◆ SaveCurrentFrameToDisk()

void ACamera::SaveCurrentFrameToDisk ( )

inline

Saves this frame to disk even if CameraParameters.SaveImageToDisk is set to false.

Definition at line 192 of file Camera.h.

    {
        if (!CameraParameters.SaveImageToDisk) 
        {
            SaveCurrentFrameToDiskRequested = true;
        }
    }

Referenced by ADataCapture::CaptureDataNow().

◆ SaveImageToDisk()

void ACamera::SaveImageToDisk	(	const TArray< FColor >	FrameBuffer,
		int32	Width,
		int32	Height
	)

protected

Save Image data as png to disk

Parameters

FrameBuffer	Image buffer
width	Image width
height	Image height

Definition at line 753 of file Camera.cpp.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACamera::SaveImageToDisk);
 
    if (FrameBuffer.IsEmpty() || Width == 0 || Height == 0)
    {
        return;
    }
 
    int32 Size = Width * Height;
    if (FrameBuffer.Num() != Size)
    {
        const FString Msg = "Camera sensor: Unable to save Image to disk. FrameBuffer size and resolution don't match!";
        SimulatorLog::Log(Msg);
        return;
    }
 
    const FString ImageName = FString::Printf(TEXT("image_%d.png"), ImageNumber);
    const FString FullFileName = FString::Printf(TEXT("%s%s"), *FileSavePath, *ImageName);
    ++ImageNumber;
 
    SaveCameraMetaDataToDisk(ImageName);
 
    FIntPoint DestSize(Width, Height);
    TImagePixelData<FColor> PixelData(DestSize);
    PixelData.Pixels = FrameBuffer;
 
    // Create ImageTask
    TUniquePtr<FImageWriteTask> ImageTask = MakeUnique<FImageWriteTask>();
    ImageTask->PixelData = MakeUnique<TImagePixelData<FColor>>(PixelData);
    ImageTask->Filename = FullFileName;
    ImageTask->Format = EImageFormat::PNG;
    ImageTask->CompressionQuality = (int32)EImageCompressionQuality::Default;
    ImageTask->bOverwriteFile = true;
    ImageTask->PixelPreProcessors.Add(TAsyncAlphaWrite<FColor>(255));
 
    // Get Screenshot config and enqueue image save task
    FHighResScreenshotConfig& HighResScreenshotConfig = GetHighResScreenshotConfig();
    TFuture<bool> CompletionFuture = HighResScreenshotConfig.ImageWriteQueue->Enqueue(MoveTemp(ImageTask));
}

References ASensor::FileSavePath, ImageNumber, SimulatorLog::Log(), SaveCameraMetaDataToDisk(), and SaveImageToDisk().

Referenced by FrameGrabberCapture(), and SaveImageToDisk().

◆ SendImageDataToROS()

void ACamera::SendImageDataToROS	(	const TArray< FColor > &	FrameBuffer,
		int32	Width,
		int32	Height
	)

protected

Construct ROS Image msg and send data to ROS topic

Parameters

FrameBuffer	Pixel array
width	Image width
height	Image height

Definition at line 689 of file Camera.cpp.

{
    TRACE_CPUPROFILER_EVENT_SCOPE(ACamera::SendImageDataToROS);
 
    UTopic* Topic = GetROSTopic();
    if (!SendDataToROS
        || !Topic
        || !IsROSConnected()
        || FrameBuffer.IsEmpty()
        || !ImageMsg.IsValid())
    {
        return;
    }
 
    // Cast TArray<FColor> into uint8[] data with all channels (RBGA)
    // If you want to send RGBA data, uncomment the following lines
    // and comment the BGR8Buffer conversion below
    //ImageMsg->encoding = "bgra8";
    //ImageMsg->step = Width * 4;
    //ImageMsg->data = const_cast<uint8*>(reinterpret_cast<const uint8*>(FrameBuffer.GetData()));
 
    // Convert TArray<FColor> to uint8[] data without alpha channel
    // By removing alpha channel, we reduce ~25% of ROS bandwidth, 
    // but costs a bit more in processing time here
    const int32 BufferSize = Width * Height * 3;
    if (!BGR8Buffer || CurrentBufferSize != BufferSize)
    {
        // Resize buffer if needed
        delete[] BGR8Buffer;
        BGR8Buffer = new uint8[BufferSize];
        CurrentBufferSize = BufferSize;
    }
 
    const FColor* RESTRICT Source = FrameBuffer.GetData();
    uint8* RESTRICT Dest = BGR8Buffer;
    const int32 PixelCount = FrameBuffer.Num();
    const int32 ChunkSize = 512;
    const int32 NumChunks = (PixelCount + ChunkSize - 1) / ChunkSize;
 
    ParallelFor(NumChunks, [Source, Dest, ChunkSize, PixelCount](int32 ChunkIndex)
        {
            const int32 StartIndex = ChunkIndex * ChunkSize;
            const int32 EndIndex = FMath::Min(StartIndex + ChunkSize, PixelCount);
 
            for (int32 i = StartIndex; i < EndIndex; ++i)
            {
                const FColor& Pixel = Source[i];
                const int32 j = i * 3;
                Dest[j + 0] = Pixel.B;
                Dest[j + 1] = Pixel.G;
                Dest[j + 2] = Pixel.R;
            }
        }, false);
 
    ImageMsg->data = BGR8Buffer;
    ImageMsg->step = Width * 3;
 
    ImageMsg->height = Height;
    ImageMsg->width = Width;
    ImageMsg->header.time = FROSTime::Now();
 
    Topic->Publish(ImageMsg);
}

References BGR8Buffer, CurrentBufferSize, ASensor::GetROSTopic(), ImageMsg, ASensor::IsROSConnected(), ASensor::SendDataToROS, and SendImageDataToROS().

Referenced by FrameGrabberCapture(), and SendImageDataToROS().

◆ SetShadowRendering()

void ACamera::SetShadowRendering ( bool RenderShadows )

Set should this camera USceneCaptureComponent2D render shadows

Definition at line 858 of file Camera.cpp.

{
    if (CaptureComponent2D)
    {
        auto& CameraShowFlags = CaptureComponent2D->ShowFlags;
        CameraShowFlags.SetDynamicShadows(RenderShadows);
        CameraShowFlags.SetContactShadows(RenderShadows);
        CameraShowFlags.SetCapsuleShadows(RenderShadows);
    }
}

References CaptureComponent2D.

Referenced by ADepthCamera::Init(), AInstanceSegmentationCamera::Init(), ASemanticSegmentationCamera::Init(), and AThermalCamera::Init().

◆ SetTemporalAA()

void ACamera::SetTemporalAA ( bool SetTemporal )

Set USceneCaptureComponent2D TemporalAA on or off.

Definition at line 869 of file Camera.cpp.

{
    if (CaptureComponent2D)
    {
        auto& CameraShowFlags = CaptureComponent2D->ShowFlags;
        CameraShowFlags.SetTemporalAA(SetTemporal);
    }
}

References CaptureComponent2D.

Referenced by SetupCamera().

◆ SetupCamera()

void ACamera::SetupCamera ( FCameraBaseParameters parameters )

private

Setup all needed things to make Camera operate.

Definition at line 126 of file Camera.cpp.

{
    if (!CaptureComponent2D)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("Camera.cpp: CaptureComponent2D is nullptr!"));
#endif
        return;
    }
 
    CameraParameters = parameters;
 
    SendDataToROS = CameraParameters.SendDataToROS;
 
    if (CameraParameters.TargetFrameRate != 0.0f)
    {
        CameraFrameRate = 1.0f / CameraParameters.TargetFrameRate;
    }
 
    const bool UsePostProcessingEffects = CameraParameters.PostProcessingEffects;
    auto& PostProcessSettings = CaptureComponent2D->PostProcessSettings;
 
    if (parameters.UsePhysicLensDistortionEffect)
    {
        if (!PhysicLensDistortion.IsValid())
        {
            const FString Path = "/Game/Agrarsense/Materials/PostProcessingMaterials/PhysicLensDistortion.PhysicLensDistortion";
            PhysicLensDistortion = Cast<UMaterial>(StaticLoadObject(UMaterial::StaticClass(), nullptr, *Path));
 
            if (PhysicLensDistortion.IsValid())
            {
                PostProcessSettings.AddBlendable(PhysicLensDistortion.Get(), 1.0f);
#if WITH_EDITOR
                UE_LOG(LogTemp, Warning, TEXT("Camera.cpp: Added physics lens distortion effect."));
#endif
            }
        }
    }
    else if (PhysicLensDistortion.IsValid())
    {
        PostProcessSettings.RemoveBlendable(PhysicLensDistortion.Get());
        PhysicLensDistortion.Reset();
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("Camera.cpp: Removed physics lens distortion effect."));
#endif
    }
 
    if (parameters.UseIceLensEffect)
    {
        if (!IceMaterialInstance.IsValid())
        {
            const FString Path = "/Game/Agrarsense/Materials/PostProcessingMaterials/CameraPostProcessEffects/m_ice_lens_effect";
            UMaterial* LoadedIceMaterial = Cast<UMaterial>(StaticLoadObject(UMaterial::StaticClass(), nullptr, *Path));
 
            // Create UMaterialInstanceDynamic from LoadedIceMaterial
            IceMaterialInstance = UMaterialInstanceDynamic::Create(LoadedIceMaterial, nullptr);
            if (IceMaterialInstance.IsValid())
            {
                // Add material to CaptureComponent2D PostProcessSettings 
                PostProcessSettings.AddBlendable(IceMaterialInstance.Get(), 1.0f);
#if WITH_EDITOR
                UE_LOG(LogTemp, Warning, TEXT("Camera.cpp: Added ice lens effect."));
#endif
            }
        }
 
        UMaterialInstanceDynamic* IceMatInstance = IceMaterialInstance.Get();
        if (IceMatInstance)
        {
            // Set IceMaterialInstance scalar parameters values
            IceMatInstance->SetScalarParameterValue(FName("Strength"), parameters.IceLensEffectStrength);
            IceMatInstance->SetScalarParameterValue(FName("Angle"), parameters.IceLensEffectAngle);
#if WITH_EDITOR
            UE_LOG(LogTemp, Warning, TEXT("Camera.cpp: Changed ice lens effect parameters."));
#endif
        }
    }
    else if (IceMaterialInstance.IsValid())
    {
        UMaterialInstanceDynamic* IceMatInstance = IceMaterialInstance.Get();
        if (IceMatInstance)
        {
            // Remove material from CaptureComponent2D PostProcessSettings
            PostProcessSettings.RemoveBlendable(IceMatInstance);
            IceMaterialInstance.Reset();
 
#if WITH_EDITOR
            UE_LOG(LogTemp, Warning, TEXT("Camera.cpp: Removed ice lens effect."));
#endif
        }
    }
 
    ImageWidth = CameraParameters.Width;
    ImageHeight = CameraParameters.Height;
    const float TargetGamma = CameraParameters.TargetGamma;
    const bool Enable16BitFormat = CameraParameters.Enable16BitFormat;
 
    CaptureRenderTarget->InitCustomFormat(ImageWidth, ImageHeight, Enable16BitFormat ? PF_FloatRGB : PF_B8G8R8A8, !UsePostProcessingEffects);
 
    CaptureRenderTarget->TargetGamma = TargetGamma;
 
    // Set PostProcessSettings override (on or off)
    PostProcessSettings.bOverride_AutoExposureMethod = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AutoExposureBias = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AutoExposureMinBrightness = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AutoExposureMaxBrightness = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AutoExposureSpeedUp = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AutoExposureSpeedDown = UsePostProcessingEffects;
    PostProcessSettings.bOverride_HistogramLogMin = UsePostProcessingEffects;
    PostProcessSettings.bOverride_HistogramLogMax = UsePostProcessingEffects;
    PostProcessSettings.bOverride_CameraShutterSpeed = UsePostProcessingEffects;
    PostProcessSettings.bOverride_CameraISO = UsePostProcessingEffects;
    PostProcessSettings.bOverride_DepthOfFieldFstop = UsePostProcessingEffects;
    PostProcessSettings.bOverride_DepthOfFieldMinFstop = UsePostProcessingEffects;
    PostProcessSettings.bOverride_DepthOfFieldBladeCount = UsePostProcessingEffects;
    PostProcessSettings.bOverride_FilmSlope = UsePostProcessingEffects;
    PostProcessSettings.bOverride_FilmToe = UsePostProcessingEffects;
    PostProcessSettings.bOverride_FilmShoulder = UsePostProcessingEffects;
    PostProcessSettings.bOverride_FilmWhiteClip = UsePostProcessingEffects;
    PostProcessSettings.bOverride_FilmBlackClip = UsePostProcessingEffects;
    PostProcessSettings.bOverride_MotionBlurAmount = UsePostProcessingEffects;
    PostProcessSettings.bOverride_MotionBlurMax = UsePostProcessingEffects;
    PostProcessSettings.bOverride_MotionBlurPerObjectSize = UsePostProcessingEffects;
    PostProcessSettings.bOverride_WhiteTemp = UsePostProcessingEffects;
    PostProcessSettings.bOverride_WhiteTint = UsePostProcessingEffects;
    PostProcessSettings.bOverride_ColorContrast = UsePostProcessingEffects;
    PostProcessSettings.bOverride_SceneFringeIntensity = UsePostProcessingEffects;
    PostProcessSettings.bOverride_ChromaticAberrationStartOffset = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AmbientOcclusionIntensity = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AmbientOcclusionRadius = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AmbientOcclusionStaticFraction = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AmbientOcclusionFadeDistance = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AmbientOcclusionPower = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AmbientOcclusionBias = UsePostProcessingEffects;
    PostProcessSettings.bOverride_AmbientOcclusionQuality = UsePostProcessingEffects;
    PostProcessSettings.bOverride_BloomMethod = UsePostProcessingEffects;
    PostProcessSettings.bOverride_BloomIntensity = UsePostProcessingEffects;
    PostProcessSettings.bOverride_BloomThreshold = UsePostProcessingEffects;
    PostProcessSettings.bOverride_LensFlareIntensity = UsePostProcessingEffects;
    PostProcessSettings.bOverride_DepthOfFieldFocalDistance = UsePostProcessingEffects;
    PostProcessSettings.bOverride_DepthOfFieldDepthBlurAmount = UsePostProcessingEffects;
    PostProcessSettings.bOverride_DepthOfFieldDepthBlurRadius = UsePostProcessingEffects;
 
    // Set PostProcessSettings values
    PostProcessSettings.CameraShutterSpeed = CameraParameters.ShutterSpeed;
    PostProcessSettings.CameraISO = CameraParameters.ISO;
    PostProcessSettings.DepthOfFieldFstop = CameraParameters.Aperture;
    PostProcessSettings.DepthOfFieldFocalDistance = CameraParameters.FocalDistance;
    PostProcessSettings.DepthOfFieldDepthBlurAmount = CameraParameters.DepthBlurAmount;
    PostProcessSettings.DepthOfFieldDepthBlurRadius = CameraParameters.DepthBlurRadius;
    PostProcessSettings.DepthOfFieldMinFstop = CameraParameters.DofMinFStop;
    PostProcessSettings.DepthOfFieldBladeCount = CameraParameters.DofBladeCount;
    PostProcessSettings.FilmSlope = CameraParameters.FilmSlope;
    PostProcessSettings.FilmToe = CameraParameters.FilmToe;
    PostProcessSettings.FilmShoulder = CameraParameters.FilmShoulder;
    PostProcessSettings.FilmBlackClip = CameraParameters.FilmBlackClip;
    PostProcessSettings.FilmWhiteClip = CameraParameters.FilmWhiteClip;
    PostProcessSettings.AutoExposureMinBrightness = CameraParameters.ExposureMinBrightness;
    PostProcessSettings.AutoExposureMaxBrightness = CameraParameters.ExposureMaxBrightness;
    PostProcessSettings.AutoExposureSpeedUp = CameraParameters.ExposureSpeedUp;
    PostProcessSettings.AutoExposureSpeedDown = CameraParameters.ExposureSpeedDown;
    PostProcessSettings.MotionBlurAmount = CameraParameters.MotionBlurIntensity;
    PostProcessSettings.MotionBlurMax = CameraParameters.MotionBlurMax;
    PostProcessSettings.MotionBlurPerObjectSize = CameraParameters.MotionBlurMinObjSize;
    PostProcessSettings.LensFlareIntensity = CameraParameters.LensFlareIntensity;
    PostProcessSettings.BloomIntensity = CameraParameters.BloomIntensity;
    PostProcessSettings.WhiteTemp = CameraParameters.WhiteTemp;
    PostProcessSettings.WhiteTint = CameraParameters.WhiteTint;
    PostProcessSettings.SceneFringeIntensity = CameraParameters.ChromAberrIntensity;
    PostProcessSettings.ChromaticAberrationStartOffset = CameraParameters.ChromAberrOffset;
 
    CaptureComponent2D->FOVAngle = CameraParameters.FOV;
    CaptureComponent2D->TextureTarget = CaptureRenderTarget;
 
    if (CameraParameters.MaxViewDistanceInCmOverride > 0)
    {
        CaptureComponent2D->MaxViewDistanceOverride = CameraParameters.MaxViewDistanceInCmOverride;
    }
    else
    {
        CaptureComponent2D->MaxViewDistanceOverride = -1.0f; // Infinite
    }
 
    if (CameraParameters.UseHDR && GetSensorType() == ESensorTypes::RGBCamera)
    {
        // Enable HDR on CaptureSource, only allowed for RGB Camera for now.
        CaptureComponent2D->CaptureSource = ESceneCaptureSource::SCS_FinalToneCurveHDR;
    }
    else
    {
        CaptureComponent2D->CaptureSource = ESceneCaptureSource::SCS_FinalColorLDR;
    }
 
    CaptureComponent2D->bUseRayTracingIfEnabled = true;
    CaptureComponent2D->UpdateContent();
    CaptureComponent2D->Activate();
 
    SetTemporalAA(CameraParameters.UseTemporalAA);
 
    const FString Encoding = "bgr8";
 
    // Create ROS Image message
    ImageMsg.Reset();
    ImageMsg = MakeShared<ROSMessages::sensor_msgs::Image>();
    ImageMsg->header.frame_id = "world";
    ImageMsg->height = ImageWidth;
    ImageMsg->width = ImageHeight;
    ImageMsg->encoding = Encoding;
    ImageMsg->is_bigendian = 0;
    ImageMsg->step = ImageWidth * 4;
 
    CreateROSTopic();
 
    if (!UnrealWindow.IsValid())
    {
        // Create and setup UnrealWindow
        const FString WindowName = GetSensorIdentifier() + " Window";
        UnrealWindow = MakeShareable(new FUnrealWindow(ImageWidth, ImageHeight, WindowName, UAgrarsenseSettings::ShouldStartWindowMinimized()));
 
        // Set on Window closed event
        OnWindowClosedDelegate.BindUObject(this, &ACamera::OnWindowClosed);
        UnrealWindow->GetSWindow()->SetOnWindowClosed(OnWindowClosedDelegate);
 
        // try to create Camera parameter Widget from path
        FSoftClassPath WidgetClassPath(TEXT("/Game/Agrarsense/Widgets/Camera/WBP_CameraControlsMenu.WBP_CameraControlsMenu_C"));
        UClass* WidgetClass = WidgetClassPath.TryLoadClass<UUserWidget>();
 
        APlayerController* PlayerController = UGameplayStatics::GetPlayerController(GetWorld(), 0);
 
        if (WidgetClass && PlayerController)
        {
            UCameraWidgetBase* WidgetInstance = CreateWidget<UCameraWidgetBase>(PlayerController, WidgetClass);
            if (WidgetInstance)
            {
                bool ShowGuide = false;
                WidgetInstance->Setup(this, ShowGuide);
                this->AddWidgetToWindow(WidgetInstance);
            }
        }
    }
 
    bool Resized = false;
    if (UnrealWindow.IsValid())
    {
        UnrealWindow->SetupComponent(CaptureRenderTarget);
        if (UnrealWindow->GetWindowWidth() != ImageWidth || UnrealWindow->GetWindowHeight() != ImageHeight)
        {
            UnrealWindow->ResizeWindow(ImageWidth, ImageHeight);
            Resized = true;
        }
    }
 
    StartFrameGrabber();
 
    if (Resized)
    {
        OnCameraWindowResized.Broadcast(this, CameraParameters);
    }
 
    if (CameraParameters.SaveImageToDisk)
    {
        CreateLogFile();
    }
}

Referenced by ChangeCameraParameters(), and Init().

◆ SetUseGimbal()

void ACamera::SetUseGimbal ( bool UseGimbal )

inline

Definition at line 213 of file Camera.h.

    {
        AllowGimbal = UseGimbal;
    }

◆ ShouldSimulate()

bool ACamera::ShouldSimulate ( const float DeltaSeconds )

private

Should this camera sensor be simulated this frame

Definition at line 526 of file Camera.cpp.

{
    if (!CanSimulateSensor())
    {
        ShouldSimulateCamera = false;
        return ShouldSimulateCamera;
    }
 
    if (CameraParameters.TargetFrameRate == 0.0f)
    {
        ShouldSimulateCamera = true;
        return ShouldSimulateCamera;
    }
 
    FrameRateTimer += DeltaSeconds;
    if (FrameRateTimer >= CameraFrameRate)
    {
        FrameRateTimer = 0.0f;
        ShouldSimulateCamera = true;
        return ShouldSimulateCamera;
    }
 
    ShouldSimulateCamera = false;
 
    return ShouldSimulateCamera;
}

References CameraFrameRate, CameraParameters, ASensor::CanSimulateSensor(), FrameRateTimer, ShouldSimulateCamera, and FCameraBaseParameters::TargetFrameRate.

Referenced by PreActorTick().

◆ StartFrameGrabber()

void ACamera::StartFrameGrabber ( )

private

Setup and start FrameGrabber

Definition at line 641 of file Camera.cpp.

{
    if (!UnrealWindow.IsValid())
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("Camera.cpp: UnrealWindow is nullptr!"));
#endif
        return;
    }
 
    // Destroy old FrameGrabber
    ReleaseFrameGrabber();
 
    TSharedPtr<FSceneViewport> SceneViewport = UnrealWindow->GetSceneViewport();
    if (SceneViewport.IsValid() && CaptureRenderTarget)
    {
        EPixelFormat PixelFormat = GetPixelFormatFromRenderTargetFormat(TextureFormat);
        FIntPoint Size = SceneViewport->GetSize();
 
        if (GetSensorType() == ESensorTypes::DVSCamera)
        {
            // Currently only DVS camera needs this texture to render DVS output into separate FUnrealWindow.
            CaptureFrameTexture = UTexture2D::CreateTransient(Size.X, Size.Y, PixelFormat);
            CaptureFrameTexture->UpdateResource();
        }
 
        FrameGrabber = MakeShareable(new FFrameGrabber(SceneViewport.ToSharedRef(), Size, PixelFormat));
        FrameGrabber->StartCapturingFrames();
    }
}

References CaptureFrameTexture, CaptureRenderTarget, DVSCamera, FrameGrabber, GetSensorType(), ReleaseFrameGrabber(), TextureFormat, and UnrealWindow.

Referenced by SetupCamera().

Member Data Documentation

◆ AllowGimbal

bool ACamera::AllowGimbal = true

protected

Definition at line 307 of file Camera.h.

Referenced by BeginPlay(), and PreActorTick().

◆ BGR8Buffer

uint8* ACamera::BGR8Buffer = nullptr

private

Definition at line 380 of file Camera.h.

Referenced by EndPlay(), and SendImageDataToROS().

◆ CameraFrameRate

float ACamera::CameraFrameRate = 0.0f

private

Definition at line 375 of file Camera.h.

Referenced by SetupCamera(), and ShouldSimulate().

◆ CameraName

FString ACamera::CameraName = "Camera "

protected

Camera title name for the new Unreal Window For example: "Camera 2 Window" or "ThermalCamera 1 Window" Accessible in inherited classes.

Definition at line 279 of file Camera.h.

Referenced by ADepthCamera::Init(), ADVSCamera::Init(), AInstanceSegmentationCamera::Init(), ASemanticSegmentationCamera::Init(), and AThermalCamera::Init().

◆ CameraParameters

FCameraBaseParameters ACamera::CameraParameters

private

Current Camera parameters.

Definition at line 351 of file Camera.h.

Referenced by FrameGrabberCapture(), ResizeCamera(), SetupCamera(), and ShouldSimulate().

◆ CaptureComponent2D

USceneCaptureComponent2D* ACamera::CaptureComponent2D = nullptr

protected

Definition at line 287 of file Camera.h.

Referenced by ACamera(), AddHiddenActor(), AddPostProcessingMaterial(), DisableShowFlags(), EndPlay(), HidePrimitiveComponent(), PreActorTick(), RemovePostProcessingMaterial(), SetShadowRendering(), SetTemporalAA(), and SetupCamera().

◆ CaptureFrameTexture

UTexture2D* ACamera::CaptureFrameTexture

protected

public UTexture2D variable pointer BlueprintReadOnly.

Definition at line 294 of file Camera.h.

Referenced by ReleaseFrameGrabber(), StartFrameGrabber(), and ADVSCamera::UpdateDVSWindowOutput().

◆ CaptureRenderTarget

UTextureRenderTarget2D* ACamera::CaptureRenderTarget = nullptr

protected

Definition at line 284 of file Camera.h.

Referenced by ACamera(), EndPlay(), SetupCamera(), and StartFrameGrabber().

◆ CurrentBufferSize

int32 ACamera::CurrentBufferSize = 0

private

Definition at line 382 of file Camera.h.

Referenced by EndPlay(), and SendImageDataToROS().

◆ DronePtr

APIDDrone* ACamera::DronePtr = nullptr

protected

Definition at line 305 of file Camera.h.

Referenced by BeginPlay(), and PreActorTick().

◆ FilePrefix

FString ACamera::FilePrefix = "Data/Camera_"

protected

Definition at line 281 of file Camera.h.

Referenced by ADepthCamera::Init(), ADVSCamera::Init(), AInstanceSegmentationCamera::Init(), ASemanticSegmentationCamera::Init(), and AThermalCamera::Init().

◆ FrameGrabber

TSharedPtr<FFrameGrabber> ACamera::FrameGrabber

private

FrameGrabber TSharedPtr

Definition at line 335 of file Camera.h.

Referenced by FrameGrabberCapture(), PreActorTick(), ReleaseFrameGrabber(), and StartFrameGrabber().

◆ FrameRateTimer

float ACamera::FrameRateTimer = 0.0f

private

Definition at line 376 of file Camera.h.

Referenced by ShouldSimulate().

◆ GeoReferencingSystem

AGeoReferencingSystem* ACamera::GeoReferencingSystem = nullptr

private

Definition at line 360 of file Camera.h.

Referenced by CreateLogFile(), and SaveCameraMetaDataToDisk().

◆ IceMaterialInstance

TWeakObjectPtr<UMaterialInstanceDynamic> ACamera::IceMaterialInstance

protected

Definition at line 300 of file Camera.h.

Referenced by EndPlay(), and SetupCamera().

◆ ImageHeight

int32 ACamera::ImageHeight = 720

private

Definition at line 369 of file Camera.h.

Referenced by FrameGrabberCapture(), and SetupCamera().

◆ ImageMsg

TSharedPtr<ROSMessages::sensor_msgs::Image> ACamera::ImageMsg

private

Definition at line 366 of file Camera.h.

Referenced by EndPlay(), SendImageDataToROS(), and SetupCamera().

◆ ImageNumber

int32 ACamera::ImageNumber = 0

private

Definition at line 378 of file Camera.h.

Referenced by SaveImageToDisk().

◆ ImageWidth

int32 ACamera::ImageWidth = 1280

private

Definition at line 368 of file Camera.h.

Referenced by FrameGrabberCapture(), and SetupCamera().

◆ OnCameraWindowClosed

FCameraDelegate_OnWindowClosed ACamera::OnCameraWindowClosed

On Camera sensor destroyed event. BlueprintAssignable.

Returns: ACamera pointer

Definition at line 141 of file Camera.h.

Referenced by OnWindowClosed().

◆ OnCameraWindowResized

FCameraDelegate_OnWindowResized ACamera::OnCameraWindowResized

On Camera sensor window resized event. BlueprintAssignable.

Returns: ACamera pointer

Definition at line 148 of file Camera.h.

Referenced by ADVSCamera::EndPlay(), ADVSCamera::Init(), and SetupCamera().

◆ OnPostTickDelegate

FDelegateHandle ACamera::OnPostTickDelegate

protected

Definition at line 240 of file Camera.h.

Referenced by BeginPlay(), and EndPlay().

◆ OnPreTickDelegate

FDelegateHandle ACamera::OnPreTickDelegate

protected

Definition at line 237 of file Camera.h.

Referenced by BeginPlay(), and EndPlay().

◆ OnWindowClosedDelegate

FOnWindowClosed ACamera::OnWindowClosedDelegate

private

Definition at line 364 of file Camera.h.

Referenced by EndPlay(), and SetupCamera().

◆ ParametersChanged

bool ACamera::ParametersChanged = false

private

Definition at line 362 of file Camera.h.

◆ PhysicLensDistortion

TWeakObjectPtr<UMaterial> ACamera::PhysicLensDistortion

protected

Definition at line 302 of file Camera.h.

Referenced by SetupCamera().

◆ SaveCurrentFrameToDiskRequested

bool ACamera::SaveCurrentFrameToDiskRequested = false

private

Definition at line 371 of file Camera.h.

Referenced by FrameGrabberCapture().

◆ SensorSetRotation

FRotator ACamera::SensorSetRotation

protected

Definition at line 306 of file Camera.h.

Referenced by PreActorTick().

◆ ShouldSimulateCamera

bool ACamera::ShouldSimulateCamera = true

private

Definition at line 373 of file Camera.h.

Referenced by FrameGrabberCapture(), and ShouldSimulate().

◆ TempParams

FCameraBaseParameters ACamera::TempParams

private

Definition at line 357 of file Camera.h.

◆ TextureFormat

TEnumAsByte<ETextureRenderTargetFormat> ACamera::TextureFormat = ETextureRenderTargetFormat::RTF_RGBA8

public TEnumAsByte<ETextureRenderTargetFormat> variable BlueprintReadOnly.

Definition at line 134 of file Camera.h.

Referenced by StartFrameGrabber().

◆ TickEntry

FTickEntry ACamera::TickEntry

protected

Definition at line 298 of file Camera.h.

Referenced by BeginPlay(), and EndPlay().

◆ UnrealWindow

TSharedPtr<FUnrealWindow> ACamera::UnrealWindow

protected

Definition at line 296 of file Camera.h.

Referenced by AddWidgetToWindow(), EndPlay(), ADVSCamera::Init(), RemoveWidgetFromWindow(), SetupCamera(), and StartFrameGrabber().

◆ UseParallelLateTick

bool ACamera::UseParallelLateTick = true

protected

Definition at line 235 of file Camera.h.

Referenced by ADVSCamera::ADVSCamera(), BeginPlay(), and EndPlay().

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

Unreal/Agrarsense/Source/Agrarsense/Sensor/Camera/Camera.h
Unreal/Agrarsense/Source/Agrarsense/Sensor/Camera/Camera.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ACamera()

Member Function Documentation

◆ AddHiddenActor()

◆ AddPostProcessingMaterial()

◆ AddProcessingToFrameBuffer()

◆ AddWidgetToWindow()

◆ ApplyGammaCorrectionLUT()

◆ BeginPlay()

◆ ChangeCameraParameters()

◆ CreateLogFile()

◆ DisableShowFlags()

◆ EndOfFrame()

◆ EndOfFrameParellel()

◆ EndPlay()

◆ FrameGrabberCapture()

◆ GetCameraHeight()

◆ GetCameraParameters()

◆ GetCameraWidth()

◆ GetCaptureComponent2D()

◆ GetCaptureRenderTarget2D()

◆ GetParametersAsString()

◆ GetSensorType()

◆ HidePrimitiveComponent()

◆ Init()

◆ OnWindowClosed()

◆ PreActorTick()

◆ ReleaseFrameGrabber()

◆ RemovePostProcessingMaterial()

◆ RemoveWidgetFromWindow()

◆ ResizeCamera()

◆ SaveCameraMetaDataToDisk()

◆ SaveCurrentFrameToDisk()

◆ SaveImageToDisk()

◆ SendImageDataToROS()

◆ SetShadowRendering()

◆ SetTemporalAA()

◆ SetupCamera()

◆ SetUseGimbal()

◆ ShouldSimulate()

◆ StartFrameGrabber()

Member Data Documentation

◆ AllowGimbal

◆ BGR8Buffer

◆ CameraFrameRate

◆ CameraName

◆ CameraParameters

◆ CaptureComponent2D

◆ CaptureFrameTexture

◆ CaptureRenderTarget

◆ CurrentBufferSize

◆ DronePtr

◆ FilePrefix

◆ FrameGrabber

◆ FrameRateTimer

◆ GeoReferencingSystem

◆ IceMaterialInstance

◆ ImageHeight

◆ ImageMsg

◆ ImageNumber

◆ ImageWidth

◆ OnCameraWindowClosed

◆ OnCameraWindowResized

◆ OnPostTickDelegate

◆ OnPreTickDelegate

◆ OnWindowClosedDelegate

◆ ParametersChanged

◆ PhysicLensDistortion

◆ SaveCurrentFrameToDiskRequested

◆ SensorSetRotation

◆ ShouldSimulateCamera

◆ TempParams