from tkinter import *
from tkinter import filedialog
from tkinter import messagebox
from tkinter import ttk
from PIL import Image, ImageTk
import os
import random
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import cv2
import math
import time


width_window = 300.0
height_window = 200.0


def crop_rect(img, rect, ix):
    print("rect!")
    # поворот фрагмента
    center, size, angle = rect[0], rect[1], rect[2]
    center, size = tuple(map(int, center)), tuple(map(int, size))
    height, width = img.shape[0], img.shape[1]
    M = cv2.getRotationMatrix2D(center, angle, 1)
    img_rot = cv2.warpAffine(img[:,:,:3], M, (width, height))
    cut_img = cv2.getRectSubPix(img_rot, size, center)
    
    # сохранить часть изображения/просмотр вырезанного фрагмента
    cv2.imwrite(f'data/cut_parts/{ix}_part.jpg', cut_img)
    cv2.imshow('cut_img', cut_img)
    time.sleep(0.08)
    if cv2.waitKey(1) == ord('q'):
        cv2.destroyAllWindows()
    return img


class CutTool():
    def __init__(self, master):
        # найстройки основного окна
        self.parent = master
        self.parent.title("CutTool")
        self.frame = Frame(self.parent)
        self.frame.pack(fill=BOTH, expand=1)
        self.parent.resizable(width = True, height = True)

        # инициализировать состояние курсора мыши
        self.STATE = {}
        self.STATE['click'] = 0
        self.STATE['x'], self.STATE['y'] = 0, 0

        # ссылка на координаты 
        self.coordList = []
        self.running = False
        
        self.image_container = False
        
        self.step_size = 20
        # ----------------- GUI stuff ---------------------

        # главная панель для маркировки
        self.mainPanel = Canvas(self.frame, cursor='tcross')
        self.mainPanel.bind('<ButtonPress-1>',self.start_motor)
        self.mainPanel.bind('<ButtonRelease-1>',self.stop_motor)
        
        
        self.mainPanel.bind("<Motion>", self.mouseMove)
        self.mainPanel.grid(row = 2, column = 1, rowspan = 4, sticky = W+N)

        # панель управления для навигации по изображениям
        self.ctrPanel = Frame(self.frame)
        self.ctrPanel.grid(row = 6, columмышиn = 1, columnspan = 2, sticky = W+E)

        # отображение положения курсора мыши
        self.disp = Label(self.ctrPanel, text='')
        self.disp.pack(side = RIGHT)
        
        self.loadImage()
        
    def mouseClick(self, event):
        if self.STATE['click'] == 0:
            self.STATE['x'], self.STATE['y'] = event.x, event.y
        print ("mouseClick event --->", self.STATE)

    def mouseMove(self, event):
        if self.running:
            self.draw(event)
        self.disp.config(text = 'x: %d, y: %d' %(event.x, event.y))

    def start_motor(self, event):
        self.running = True
        print("starting motor...")
    
    def stop_motor(self, event):
        print("stopping motor...")
        self.running = False
        self.curve_2d(self.coordList)
        self.coordList = []

    def curve_2d(self, x):
        R = len(x)
        pts = x
        x = np.array(x)
        ptdiff = lambda p1, p2: (p1[0]-p2[0], p1[1]-p2[1])

        diffs = (ptdiff(p1, p2) for p1, p2 in zip (pts, pts[1:]))
        path = sum(math.hypot(*d) for d in  diffs)

        img_array = np.array(self.img)
        img_array2 = np.array(self.img)
        print (img_array.shape)
        global img_
        for ix, i in enumerate(pts):
            if ix == 0: continue
            if ix % self.step_size == 0:
                    
                """
                1 узнать угол между настоящей точкой и прошлой по отношению к оси 'x'
                2 провернуть на этот угол точки для получения прямоугольника 
                """
                a = np.array(pts[ix])
                b = np.array(pts[ix-self.step_size]) 
                ab = a - b
                hypotenuse = np.hypot(ab[0], ab[1])       
                cos_A = ab[0]/hypotenuse
                angle = int(math.degrees(math.acos(cos_A)))   
                # правильное направление             
                if ab[1] < 0:
                    angle = -float(angle)
                else:
                    angle = float(angle)
                rect_ = ((float(a[0]), float(a[1])), (height_window, width_window), angle)
                img_array2_ = crop_rect(img_array, rect_, ix)
                # отображение линии
                box = cv2.boxPoints(rect_)
                box = np.int0(box)
                cv2.drawContours(img_array2, [box], 0, (0,0,255), 2)
                cv2.circle(img_array2, (a[0], a[1]), radius=10, color=(0, 0, 255), thickness=-1)               
                img_ = ImageTk.PhotoImage(image=Image.fromarray(img_array2))
                self.mainPanel.itemconfig(self.image_container, image=img_)  
                # обновить канвас
                self.mainPanel.update()                           

    def loadImage(self):
        # загрузить изображение
        self.img = Image.open("media-info/test.png")
        size = self.img.size
        self.factor = max(size[0]/10000., size[1]/10000., 1.)
        self.img = self.img.resize((int(size[0]/self.factor), int(size[1]/self.factor)))
        print (int(size[0]/self.factor), int(size[1]/self.factor))
        self.tkimg = ImageTk.PhotoImage(self.img)
        self.mainPanel.config(width = max(self.tkimg.width(), 400), height = max(self.tkimg.height(), 400))
        self.image_container = self.mainPanel.create_image(0, 0, image = self.tkimg, anchor=NW)
        
    def draw(self, event):
        self.coordList.append((event.x, event.y))
        self.mainPanel.create_oval(event.x - 3,
                                  event.y - 3,
                                  event.x + 3,
                                  event.y + 3,
                                  fill="red", outline="red")

        
if __name__ == '__main__':
    root = Tk()
    tool = CutTool(root)
    root.resizable(width =  True, height = True)
    root.mainloop()

import bpy, bmesh
from mathutils import Vector, Matrix
import numpy as np 

# получить обьект из сцены
bpy.context.active_object.select_set(False)
foto_obj = bpy.context.scene.objects[0]
bpy.context.view_layer.objects.active = foto_obj
foto_obj.select_set(True)

# Выбрать все грани
me = foto_obj.data
bpy.ops.object.mode_set(mode="EDIT")
bpy.ops.mesh.select_mode(type = 'EDGE')
bpy.ops.mesh.select_all(action = 'SELECT')
"""
Функция Beautify Faces работает только 
с выбранными существующими гранями. 
Переставляет выбранные треугольники, 
чтобы получить более «сбалансированные» 
(т.е. менее длинные и тонкие треугольники).
"""
bpy.ops.mesh.beautify_fill()
bpy.ops.mesh.normals_tools(mode="RESET")

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "aboveActor.generated.h"

UCLASS()
class ABOVE2_API AaboveActor : public AActor
{
	GENERATED_BODY()

public:	
	// Sets default values for this actor's properties
    AaboveActor();
    class USplineComponent* MySpline;
    class APlayerController* MyPlayerController;

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

public:	
	// Called every frame
    virtual void Tick(float DeltaTime) override;
    virtual void PostActorCreated() override;
    void SetPosition();		
};

// Fill out your copyright notice in the Description page of Project Settings.
#include "aboveActor.h"
#include "Logging/LogMacros.h"
#include "Components/SplineComponent.h"
#include "Kismet/GameplayStatics.h"

#include "Components/SplineMeshComponent.h"
#include "Components/SceneComponent.h"
#include "Engine/StaticMesh.h"
#include "Containers/Array.h"


// Sets default values
AaboveActor::AaboveActor()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;
    // Add spline to actor
    this->MySpline = CreateDefaultSubobject<USplineComponent>("MySpline",true);
    SetRootComponent(this->MySpline);
    this->MySpline->bDrawDebug = true;
    this->MyPlayerController = UGameplayStatics::GetPlayerController(this, 0);
    int32 NumberPoints = MySpline->GetNumberOfSplinePoints();
    UE_LOG(LogTemp, Warning, TEXT("Test Log. Num Points %d"), NumberPoints); //Display
}

// Called when the game starts or when spawned
void AaboveActor::BeginPlay()
{
	Super::BeginPlay();
    float LenGth_s = this->MySpline->GetSplineLength();
    FVector actLocation = this->GetActorLocation();
    UE_LOG(LogTemp, Warning, TEXT("SplineLength-->%f, Location-->%s"), LenGth_s, *actLocation.ToString());
}

// Called every frame
void AaboveActor::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
}

// This is called when actor is spawned (at runtime or when you drop it into the world in editor)
void AaboveActor::PostActorCreated()
{
    Super::PostActorCreated();
    SetPosition();
}

void AaboveActor::SetPosition()
{
    FVector startPos = FVector(0.0f,0.0f,20.0f);
    this->SetActorLocation(startPos);
    UE_LOG(LogTemp, Warning, TEXT("START THIS !!!"));
}

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/SplineComponent.h"
#include "DrawDebugHelpers.h"
#include "FlightActor.generated.h"

UCLASS()
class ABOVE2_API AFlightActor : public AActor
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	AFlightActor();

    /** Returns the next flight curve */
    UCurveFloat* GetFlightCurve() { return FlightCurve; };

    /** Returns the next flight spline component */
    USplineComponent* GetFlightSplineComp() { return FlightComp; };

protected:
    /** The FloatCurve corresponding to the next flight spline component */
    UPROPERTY(EditAnywhere)
    UCurveFloat* FlightCurve;

    /** A static mesh for our flight stop */
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* SM;

    /** The spline component that describes the flight path of the next flight */
    UPROPERTY(VisibleAnywhere)
    USplineComponent* FlightComp;
};

// Fill out your copyright notice in the Description page of Project Settings.
#include "FlightActor.h"
#include "Logging/LogMacros.h"

// Sets default values
AFlightActor::AFlightActor()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

    SM = CreateDefaultSubobject<UStaticMeshComponent>(FName("SM"));
    SetRootComponent(SM);

    //Init splines
    FlightComp = CreateDefaultSubobject<USplineComponent>(FName("SplineComp"));

    //Attach them to root component
    FlightComp->SetupAttachment(SM);
}

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "Components/TimelineComponent.h"
#include "Components/BoxComponent.h"
#include "GameFramework/Character.h"
#include "FlightActor.h"
#include "CaptureManager.h" // еще не создано
#include "FlightC.generated.h"

UCLASS(config=Game)
class ABOVE2_API AFlightC : public ACharacter
{
	GENERATED_BODY()

   UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
   class USpringArmComponent* CameraBoom;

   UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
   class UCameraComponent* FollowCamera;

public:
	// Sets default values for this character's properties
	AFlightC();

    FTimeline FlightTimeline;

    UFUNCTION()
    void TickTimeline(float Value);

    /** Base turn rate, in deg/sec. Other scaling may affect final turn rate. */
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
    float BaseTurnRate;

    /** Base look up/down rate, in deg/sec. Other scaling may affect final rate. */
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
    float BaseLookUpRate;

    // еще не создано
    UPROPERTY(EditAnywhere)
    class ACaptureManager* CaptureActor;  //Create a pointer to your another class

    /** The active spline component, meaning the flight path that the character is currently following */
    USplineComponent* ActiveSplineComponent;

    /** The selected flight stop actor */
    AFlightActor* ActiveFlightActor;
    /** Box overlap function */
    UFUNCTION()
    void OnFlightBoxColliderOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);

    /** Executes when we're pressing the FlightPath key bind */
    void FlightPathSelected();

    /** Updates the flight timeline with a new curve and starts the flight */
    void UpdateFlightTimeline(UCurveFloat* CurveFloatToBind);

    UFUNCTION()
    void ResetActiveFlightActor();


protected:
	// Called when the game starts or when spawned
    virtual void BeginPlay() override;

    /*The Box component that detects any nearby flight stops*/
    UPROPERTY(VisibleAnywhere)
    UBoxComponent* FlightBoxCollider;

    /** Called for forwards/backward input */
    void MoveForward(float Value);

    /** Called for side to side input */
    void MoveRight(float Value);

    /**
     * Called via input to turn at a given rate.
     * @param Rate	This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
     */
    void TurnAtRate(float Rate);

    /**
     * Called via input to turn look up/down at a given rate.
     * @param Rate	This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
     */
    void LookUpAtRate(float Rate);

    /** Handler for when a touch input begins. */
    void TouchStarted(ETouchIndex::Type FingerIndex, FVector Location);

    /** Handler for when a touch input stops. */
    void TouchStopped(ETouchIndex::Type FingerIndex, FVector Location);


public:	
	// Called every frame
	virtual void Tick(float DeltaTime) override;

	// Called to bind functionality to input
    virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

    /** Returns CameraBoom subobject **/
    FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
    /** Returns FollowCamera subobject **/
    FORCEINLINE class UCameraComponent* GetFollowCamera() const { return FollowCamera; }
};

// Fill out your copyright notice in the Description page of Project Settings.
#include "FlightC.h"
#include "GameFramework/SpringArmComponent.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "Components/SceneCaptureComponent2D.h"
#include "HeadMountedDisplayFunctionLibrary.h"
#include "Kismet/GameplayStatics.h"
#include "CaptureManager.h"
#include "Logging/LogMacros.h"


// Sets default values
AFlightC::AFlightC()
{
 	// Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;

    // Set size for collision capsule
    GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);

    // set our turn rates for input
    BaseTurnRate = 45.f;
    BaseLookUpRate = 45.f;

    // Don't rotate when the controller rotates. Let that just affect the camera.
    bUseControllerRotationPitch = false;
    bUseControllerRotationYaw = false;
    bUseControllerRotationRoll = false;

    // Create a camera boom (pulls in towards the player if there is a collision)
    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
    CameraBoom->SetupAttachment(RootComponent);
    CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character
    CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller

    // Create a follow camera
    FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
    FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
    FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm

    // Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character)
    // are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)
    FlightBoxCollider = CreateDefaultSubobject<UBoxComponent>(FName("FlightBoxCollider"));
    FlightBoxCollider->SetBoxExtent(FVector(150.f));
    FlightBoxCollider->SetupAttachment(GetRootComponent());

}


// Called when the game starts or when spawned
void AFlightC::BeginPlay()
{
    Super::BeginPlay();
    //Register a function that gets called when the box overlaps with a component
    FlightBoxCollider->OnComponentBeginOverlap.AddDynamic(this, &AFlightC::OnFlightBoxColliderOverlap);

    // еще не создано, см. 4 пункт  
    // https://code911.top/howto/unreal-how-to-delete-link-code-example
    AActor* FoundActor = UGameplayStatics::GetActorOfClass(GetWorld(), ACaptureManager::StaticClass());
    CaptureActor = Cast<ACaptureManager>(FoundActor);
    if (CaptureActor)
    {
        UE_LOG(LogTemp, Warning, TEXT("CaptureActor.... %s"), *CaptureActor->GetFName().ToString());
    }

}

// Called every frame
void AFlightC::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

    //If the timeline has started, advance it by DeltaSeconds
    if (FlightTimeline.IsPlaying()) FlightTimeline.TickTimeline(DeltaTime);

}

// Called to bind functionality to input
void AFlightC::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    // Set up gameplay key bindings
    check(PlayerInputComponent);
    PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
    PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);

    PlayerInputComponent->BindAxis("MoveForward", this, &AFlightC::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AFlightC::MoveRight);

    // Bind the functions that execute on key press
    PlayerInputComponent->BindAction("FlightPath", IE_Pressed, this, &AFlightC::FlightPathSelected);

    // We have 2 versions of the rotation bindings to handle different kinds of devices differently
    // "turn" handles devices that provide an absolute delta, such as a mouse.
    // "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
    PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
    PlayerInputComponent->BindAxis("TurnRate", this, &AFlightC::TurnAtRate);
    PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
    PlayerInputComponent->BindAxis("LookUpRate", this, &AFlightC::LookUpAtRate);

    // handle touch devices
    PlayerInputComponent->BindTouch(IE_Pressed, this, &AFlightC::TouchStarted);
    PlayerInputComponent->BindTouch(IE_Released, this, &AFlightC::TouchStopped);

}

void AFlightC::TickTimeline(float Value)
{
    float SplineLength = ActiveSplineComponent->GetSplineLength();
    // Get the new location based on the provided values from the timeline.
    // The reason we're multiplying Value with SplineLength is because all our designed curves in the UE4 editor have a time range of 0 - X.
    // Where X is the total flight time
    FVector NewLocation = ActiveSplineComponent->GetLocationAtDistanceAlongSpline(Value * SplineLength, ESplineCoordinateSpace::World);

    SetActorLocation(NewLocation);

    FRotator NewRotation = ActiveSplineComponent->GetRotationAtDistanceAlongSpline(Value * SplineLength, ESplineCoordinateSpace::World);

    //We're not interested in the pitch value of the above rotation so we make sure to set it to zero
    NewRotation.Pitch = 0;
    SetActorRotation(NewRotation);

    // еще не создано, см. 4 пункт 
    CaptureActor->TestFunc(NewLocation);

}

FVector GetSplinePointLocationInConstructionScript(USplineComponent* SplineComponent, int32 PointIndex)
{
// Check if the SplineComponent is valid
if (!SplineComponent)
{
    UE_LOG(LogTemp, Error, TEXT("Invalid SplineComponent"));
    return FVector::ZeroVector;
}

// Check if the PointIndex is valid
if (PointIndex < 0 || PointIndex >= SplineComponent->GetNumberOfSplinePoints())
{
    UE_LOG(LogTemp, Error, TEXT("Invalid PointIndex"));
    return FVector::ZeroVector;
}

// Get the location of the spline point
FVector SplinePointLocation = SplineComponent->GetLocationAtSplinePoint(PointIndex, ESplineCoordinateSpace::World);
return SplinePointLocation;
}


void AFlightC::OnFlightBoxColliderOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
    if (OtherActor->IsA<AFlightActor>())
    {
        //Store a reference of the nearby flight stop actor
        ActiveFlightActor = Cast<AFlightActor>(OtherActor);
    }
}
void AFlightC::FlightPathSelected()
{
    GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Orange, TEXT("KLICK BUTTON"));

    // get actor in scene by class
    AActor* FoundActor = UGameplayStatics::GetActorOfClass(GetWorld(), AFlightActor::StaticClass());
    AFlightActor* GameManager = Cast<AFlightActor>(FoundActor);

    ActiveFlightActor = Cast<AFlightActor>(GameManager);

    if (ActiveFlightActor)
    {
        //Get the next flight path's spline component and update the flight timeline with the corresponding curve
        ActiveSplineComponent = ActiveFlightActor->GetFlightSplineComp();
        UpdateFlightTimeline(ActiveFlightActor->GetFlightCurve());
    }
}

void AFlightC::UpdateFlightTimeline(UCurveFloat* CurveFloatToBind)
{
    UE_LOG(LogTemp, Warning, TEXT("...UpdateFlightTimeline"));
    //Initialize a timeline
    FlightTimeline = FTimeline();

    FOnTimelineFloat ProgressFunction;

    //Bind the function that ticks the timeline
    ProgressFunction.BindUFunction(this, FName("TickTimeline"));

    //Assign the provided curve and progress function for our timeline
    FlightTimeline.AddInterpFloat(CurveFloatToBind, ProgressFunction);
    FlightTimeline.SetLooping(false);
    FlightTimeline.PlayFromStart();

    //Set the timeline's length to match the last key frame based on the given curve
    FlightTimeline.SetTimelineLengthMode(TL_LastKeyFrame);

    //The ResetActiveFlightActor executes when the timeline finishes.
    //By calling ResetActiveFlightActor at the end of the timeline we make sure to reset any invalid references on ActiveFlightActor
    FOnTimelineEvent TimelineEvent;
    TimelineEvent.BindUFunction(this, FName("ResetActiveFlightActor"));
    FlightTimeline.SetTimelineFinishedFunc(TimelineEvent);
}

void AFlightC::ResetActiveFlightActor()
{
    UE_LOG(LogTemp, Warning, TEXT("...ResetActiveFlightActor")); //Display
    ActiveFlightActor = nullptr;
}

void AFlightC::TouchStarted(ETouchIndex::Type FingerIndex, FVector Location)
{
    // jump, but only on the first touch
    if (FingerIndex == ETouchIndex::Touch1)
    {
        Jump();
    }
}

void AFlightC::TouchStopped(ETouchIndex::Type FingerIndex, FVector Location)
{
    if (FingerIndex == ETouchIndex::Touch1)
    {
        StopJumping();
    }
}

void AFlightC::TurnAtRate(float Rate)
{
    // calculate delta for this frame from the rate information
    AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}

void AFlightC::LookUpAtRate(float Rate)
{
    // calculate delta for this frame from the rate information
    AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}

void AFlightC::MoveForward(float Value)
{
    if ((Controller != NULL) && (Value != 0.0f))
    {
        // find out which way is forward
        const FRotator Rotation = Controller->GetControlRotation();
        const FRotator YawRotation(0, Rotation.Yaw, 0);

        // get forward vector
        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
        AddMovementInput(Direction, Value);
    }
}

void AFlightC::MoveRight(float Value)
{
    if ( (Controller != NULL) && (Value != 0.0f) )
    {
        // find out which way is right
        const FRotator Rotation = Controller->GetControlRotation();
        const FRotator YawRotation(0, Rotation.Yaw, 0);

        // get right vector
        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
        // add movement in that direction
        AddMovementInput(Direction, Value);
    }
}

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

class ASceneCapture2D;
class UMaterial;

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Containers/Queue.h"
#include "CaptureManager.generated.h"


USTRUCT()
struct FRenderRequestStruct{
    GENERATED_BODY()

    TArray<FColor> Image;
    FRenderCommandFence RenderFence;

    FRenderRequestStruct(){

    }
};


USTRUCT()
struct FFloatRenderRequestStruct{
    GENERATED_BODY()

    TArray<FFloat16Color> Image;
    FRenderCommandFence RenderFence;

    FFloatRenderRequestStruct(){

    }
};


UCLASS(Blueprintable)
class ABOVE2_API  ACaptureManager : public AActor
{
    GENERATED_BODY()

public:
    // Sets default values for this actor's properties
     ACaptureManager();

    // Captured Data Sub-Directory Name
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Capture")
    FString SubDirectoryName = "";

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Capture")
    int NumDigits = 6;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Capture")
    int FrameWidth = 640;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Capture")
    int FrameHeight = 480;

    // If not UsePNG, JPEG format is used (For Non-Color purposes PNG is necessary, elsewise compression will mess with labels!)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Capture")
    bool UsePNG = false;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Capture")
    bool UseFloat = false;

    // Color Capture Components
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Capture")
    ASceneCapture2D* CaptureComponent;

    //UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Capture")
    //ASceneCapture2D* SegmentationCapture = nullptr;

    // PostProcessMaterial used for segmentation
    UPROPERTY(EditAnywhere, Category="Capture")
    UMaterial* PostProcessMaterial = nullptr;

    UPROPERTY(EditAnywhere, Category="Logging")
    bool VerboseLogging = false;

protected:
    // RenderRequest Queue
    TQueue<FRenderRequestStruct*> RenderRequestQueue;

    // FloatRenderRequest Queue
    TQueue<FFloatRenderRequestStruct*> RenderFloatRequestQueue;
    int ImgCounter = 0;

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

    void SetupCaptureComponent();

    // Creates an async task that will save the captured image to disk
    void RunAsyncImageSaveTask(TArray64<uint8> Image, FString ImageName);
    FString ToStringWithLeadingZeros(int32 Integer, int32 MaxDigits);

public:
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    UFUNCTION(BlueprintCallable, Category = "ImageCapture")
    void CaptureNonBlocking();

    UFUNCTION(BlueprintCallable, Category = "ImageCapture")
    void CaptureFloatNonBlocking();
public:
    UFUNCTION()
    void TestFunc(FVector NewLocation); //FVector NewLocation

};


class AsyncSaveImageToDiskTask : public FNonAbandonableTask{
    public:
        AsyncSaveImageToDiskTask(TArray64<uint8> Image, FString ImageName);
        ~AsyncSaveImageToDiskTask();

    // Required by UE4!
    FORCEINLINE TStatId GetStatId() const{
        RETURN_QUICK_DECLARE_CYCLE_STAT(AsyncSaveImageToDiskTask, STATGROUP_ThreadPoolAsyncTasks);
    }

protected:
    TArray64<uint8> ImageCopy;
    FString FileName = "";

public:
    void DoWork();
};

// Fill out your copyright notice in the Description page of Project Settings.

#include "CaptureManager.h"
#include "Runtime/Engine/Classes/Engine/Engine.h"

#include "Engine/SceneCapture2D.h"
#include "Components/SceneCaptureComponent2D.h"
#include "Engine/TextureRenderTarget2D.h"
#include "Kismet/GameplayStatics.h"
#include "ShowFlags.h"

#include "Materials/Material.h"

#include "RHICommandList.h"

#include "ImageWrapper/Public/IImageWrapper.h"
#include "ImageWrapper/Public/IImageWrapperModule.h"

#include "ImageUtils.h"

#include "Modules/ModuleManager.h"
#include "FlightC.h"

#include "Misc/FileHelper.h"

// Sets default values
ACaptureManager::ACaptureManager()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;

}

// Called when the game starts or when spawned
void ACaptureManager::BeginPlay()
{
    Super::BeginPlay();

    if(CaptureComponent){ // nullptr check
        SetupCaptureComponent();
        UE_LOG(LogTemp, Warning, TEXT("CaptureComponent.... %s"), *CaptureComponent->GetFName().ToString());
    } else{
        UE_LOG(LogTemp, Error, TEXT("No CaptureComponent set!"));
    }

}

// Called every frame
void ACaptureManager::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    if(UseFloat){
        // READ FLOAT IMAGE
        if(!RenderFloatRequestQueue.IsEmpty()){
            // Peek the next RenderRequest from queue
            FFloatRenderRequestStruct* nextRenderRequest = nullptr;
            RenderFloatRequestQueue.Peek(nextRenderRequest);

            if(nextRenderRequest){
                if(nextRenderRequest->RenderFence.IsFenceComplete()){
                    // Load the image wrapper module
                    IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));

                    FString fileName = "";
                    fileName = FPaths::ProjectSavedDir() + SubDirectoryName + "/img" + "_" + ToStringWithLeadingZeros(ImgCounter, NumDigits);
                    fileName += ".exr"; // Add file ending

                    static TSharedPtr<IImageWrapper> imageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::EXR); //EImageFormat::PNG //EImageFormat::JPEG
                    imageWrapper->SetRaw(nextRenderRequest->Image.GetData(), nextRenderRequest->Image.GetAllocatedSize(), FrameWidth, FrameHeight, ERGBFormat::RGBA, 16);
                    const TArray64<uint8>& PngData = imageWrapper->GetCompressed(0);
                    FFileHelper::SaveArrayToFile(PngData, *fileName);

                     // Delete the first element from RenderQueue
                    RenderFloatRequestQueue.Pop();
                    delete nextRenderRequest;

                    ImgCounter += 1;
                }
            }
        }
    }
    // READ UINT8 IMAGE
    // Read pixels once RenderFence is completed
    else{
        if(!RenderRequestQueue.IsEmpty()){
            // Peek the next RenderRequest from queue
            FRenderRequestStruct* nextRenderRequest = nullptr;
            RenderRequestQueue.Peek(nextRenderRequest);
            if(nextRenderRequest){ //nullptr check
                if(nextRenderRequest->RenderFence.IsFenceComplete()){ // Check if rendering is done, indicated by RenderFence
                    // Load the image wrapper module
                    IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
                    // Decide storing of data, either jpeg or png
                    FString fileName = "";
                    if(UsePNG){
                        //Generate image name
                        fileName = FPaths::ProjectSavedDir() + SubDirectoryName + "/img" + "_" + ToStringWithLeadingZeros(ImgCounter, NumDigits);
                        fileName += ".png"; // Add file ending

                        // Prepare data to be written to disk
                        static TSharedPtr<IImageWrapper> imageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG); //EImageFormat::PNG //EImageFormat::JPEG
                        imageWrapper->SetRaw(nextRenderRequest->Image.GetData(), nextRenderRequest->Image.GetAllocatedSize(), FrameWidth, FrameHeight, ERGBFormat::BGRA, 8);
                        const TArray64<uint8>& ImgData = imageWrapper->GetCompressed(5);
                        //const TArray<uint8>& ImgData =  static_cast<TArray<uint8, FDefaultAllocator>> (imageWrapper->GetCompressed(5));
                        RunAsyncImageSaveTask(ImgData, fileName);
                    } else{
                        // Generate image name
                        fileName = FPaths::ProjectSavedDir() + SubDirectoryName + "/img" + "_" + ToStringWithLeadingZeros(ImgCounter, NumDigits);
                        fileName += ".jpeg"; // Add file ending

                        // Prepare data to be written to disk
                        static TSharedPtr<IImageWrapper> imageWrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::JPEG); //EImageFormat::PNG //EImageFormat::JPEG
                        imageWrapper->SetRaw(nextRenderRequest->Image.GetData(), nextRenderRequest->Image.GetAllocatedSize(), FrameWidth, FrameHeight, ERGBFormat::BGRA, 8);
                        const TArray64<uint8>& ImgData = imageWrapper->GetCompressed(0);
                        //const TArray<uint8>& ImgData = static_cast<TArray<uint8, FDefaultAllocator>> (imageWrapper->GetCompressed(0));
                        RunAsyncImageSaveTask(ImgData, fileName);
                    }
                    if(VerboseLogging && !fileName.IsEmpty()){
                        UE_LOG(LogTemp, Warning, TEXT("%f"), *fileName);
                    }

                    ImgCounter += 1;

                    // Delete the first element from RenderQueue
                    RenderRequestQueue.Pop();
                    delete nextRenderRequest;
                }
            }
        }
    }
}

void ACaptureManager::SetupCaptureComponent(){
    if(!IsValid(CaptureComponent)){
        UE_LOG(LogTemp, Error, TEXT("SetupCaptureComponent: CaptureComponent is not valid!"));
        return;
    }

    // Create RenderTargets
    UTextureRenderTarget2D* renderTarget2D = NewObject<UTextureRenderTarget2D>();

    // Float Capture
    if(UseFloat){
        renderTarget2D->RenderTargetFormat = ETextureRenderTargetFormat::RTF_RGBA32f;
        renderTarget2D->InitCustomFormat(FrameWidth, FrameHeight, PF_FloatRGBA, true); // PF_B8G8R8A8 disables HDR which will boost storing to disk due to less image information
        UE_LOG(LogTemp, Warning, TEXT("Set Render Format for DepthCapture.."));
    }
    // Color Capture
    else{
        renderTarget2D->RenderTargetFormat = ETextureRenderTargetFormat::RTF_RGBA8; //8-bit color format
        renderTarget2D->InitCustomFormat(FrameWidth, FrameHeight, PF_B8G8R8A8, true); // PF... disables HDR, which is most important since HDR gives gigantic overhead, and is not needed!
        UE_LOG(LogTemp, Warning, TEXT("Set Render Format for Color-Like-Captures"));
    }

    renderTarget2D->bGPUSharedFlag = true; // demand buffer on GPU

    // Assign RenderTarget
    CaptureComponent->GetCaptureComponent2D()->TextureTarget = renderTarget2D;
    // Set Camera Properties
    CaptureComponent->GetCaptureComponent2D()->CaptureSource = ESceneCaptureSource::SCS_FinalColorLDR;
    CaptureComponent->GetCaptureComponent2D()->TextureTarget->TargetGamma = GEngine->GetDisplayGamma();
    CaptureComponent->GetCaptureComponent2D()->ShowFlags.SetTemporalAA(true);
    // lookup more showflags in the UE4 documentation..

    // Assign PostProcess Material if assigned
    if(PostProcessMaterial){ // check nullptr
        CaptureComponent->GetCaptureComponent2D()->AddOrUpdateBlendable(PostProcessMaterial);
    } else {
        UE_LOG(LogTemp, Log, TEXT("No PostProcessMaterial is assigend"));
    }
    UE_LOG(LogTemp, Warning, TEXT("Initialized RenderTarget!"));


    FVector startPos = FVector(0.0f,0.0f,20.0f);
    CaptureComponent->SetActorLocation(startPos);
    UE_LOG(LogTemp, Error, TEXT("New ActorLocation ------>%s"), *CaptureComponent->GetActorLocation().ToString());
}

void ACaptureManager::CaptureNonBlocking(){
    if(!IsValid(CaptureComponent)){
        UE_LOG(LogTemp, Error, TEXT("CaptureColorNonBlocking: CaptureComponent was not valid!"));
        return;
    }
    UE_LOG(LogTemp, Warning, TEXT("Entering: CaptureNonBlocking"));
    CaptureComponent->GetCaptureComponent2D()->TextureTarget->TargetGamma = 1.2f;
    // CaptureComponent->GetCaptureComponent2D()->TextureTarget->TargetGamma = GEngine->GetDisplayGamma();

    // Get RenderConterxt
    FTextureRenderTargetResource* renderTargetResource = CaptureComponent->GetCaptureComponent2D()->TextureTarget->GameThread_GetRenderTargetResource();
    UE_LOG(LogTemp, Warning, TEXT("Got display gamma"));
    struct FReadSurfaceContext{
        FRenderTarget* SrcRenderTarget;
        TArray<FColor>* OutData;
        FIntRect Rect;
        FReadSurfaceDataFlags Flags;
    };
    UE_LOG(LogTemp, Warning, TEXT("Inited ReadSurfaceContext"));
    // Init new RenderRequest
    FRenderRequestStruct* renderRequest = new FRenderRequestStruct();
    UE_LOG(LogTemp, Warning, TEXT("inited renderrequest"));

    // Setup GPU command
    FReadSurfaceContext readSurfaceContext = {
        renderTargetResource,
        &(renderRequest->Image),
        FIntRect(0,0,renderTargetResource->GetSizeXY().X, renderTargetResource->GetSizeXY().Y),
        FReadSurfaceDataFlags(RCM_UNorm, CubeFace_MAX)
    };
    UE_LOG(LogTemp, Warning, TEXT("GPU Command complete"));

    // Send command to GPU
    /* Up to version 4.22 use this
    ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER(
        SceneDrawCompletion,//ReadSurfaceCommand,
        FReadSurfaceContext, Context, readSurfaceContext,
    {
        RHICmdList.ReadSurfaceData(
            Context.SrcRenderTarget->GetRenderTargetTexture(),
            Context.Rect,
            *Context.OutData,
            Context.Flags
        );
    });
    */
    // Above 4.22 use this
    ENQUEUE_RENDER_COMMAND(SceneDrawCompletion)(
    [readSurfaceContext](FRHICommandListImmediate& RHICmdList){
        RHICmdList.ReadSurfaceData(
            readSurfaceContext.SrcRenderTarget->GetRenderTargetTexture(),
            readSurfaceContext.Rect,
            *readSurfaceContext.OutData,
            readSurfaceContext.Flags
        );
    });

    // Notifiy new task in RenderQueue
    RenderRequestQueue.Enqueue(renderRequest);

    // Set RenderCommandFence
    renderRequest->RenderFence.BeginFence();
}

void ACaptureManager::CaptureFloatNonBlocking(){
    // Initial Check
    if(!UseFloat){
        UE_LOG(LogTemp, Error, TEXT("Called CaptureFloatNonBlocking but UseFloat is false! Will omit this call to prevent crashes!"));
        return;
    }

    // Get RenderContext
    FTextureRenderTargetResource* renderTargetResource = CaptureComponent->GetCaptureComponent2D()->TextureTarget->GameThread_GetRenderTargetResource();

    // Read the render target surface data back.
    struct FReadSurfaceFloatContext
    {
        FRenderTarget* SrcRenderTarget;
        TArray<FFloat16Color>* OutData;
        FIntRect Rect;
        ECubeFace CubeFace;
    };

    // Init new RenderRequest
    FFloatRenderRequestStruct* renderFloatRequest = new FFloatRenderRequestStruct();

    // Setup GPU command
    //TArray<FFloat16Color> SurfaceData;
    FReadSurfaceFloatContext Context = {
        renderTargetResource,
        &(renderFloatRequest->Image),
        //&SurfaceData,
        FIntRect(0, 0, FrameWidth, FrameHeight),
        ECubeFace::CubeFace_MAX //no cubeface
    };

    ENQUEUE_RENDER_COMMAND(ReadSurfaceFloatCommand)(
        [Context](FRHICommandListImmediate& RHICmdList) {
            RHICmdList.ReadSurfaceFloatData(
                Context.SrcRenderTarget->GetRenderTargetTexture(),
                Context.Rect,
                *Context.OutData,
                Context.CubeFace,
                0,
                0
                );
        });

    RenderFloatRequestQueue.Enqueue(renderFloatRequest);
    renderFloatRequest->RenderFence.BeginFence();
}

FString ACaptureManager::ToStringWithLeadingZeros(int32 Integer, int32 MaxDigits){
    FString result = FString::FromInt(Integer);
    int32 stringSize = result.Len();
    int32 stringDelta = MaxDigits - stringSize;
    if(stringDelta < 0){
        UE_LOG(LogTemp, Error, TEXT("MaxDigits of ImageCounter Overflow!"));
        return result;
    }
    //FIXME: Smarter function for this..
    FString leadingZeros = "";
    for(size_t i=0;i<stringDelta;i++){
        leadingZeros += "0";
    }
    result = leadingZeros + result;

    return result;
}

void ACaptureManager::RunAsyncImageSaveTask(TArray64<uint8> Image, FString ImageName){
    UE_LOG(LogTemp, Warning, TEXT("Running Async Task"));
    (new FAutoDeleteAsyncTask<AsyncSaveImageToDiskTask>(Image, ImageName))->StartBackgroundTask();
}

void ACaptureManager::TestFunc(FVector NewLocation){
    UE_LOG(LogTemp, Warning, TEXT("ACaptureManager's Name is %s"), *this->GetFName().ToString());
    UE_LOG(LogTemp, Warning, TEXT("Location CaptureManager %s"), *this->CaptureComponent->GetActorLocation().ToString());
    CaptureComponent->SetActorLocation(NewLocation);
    CaptureNonBlocking();
}

/*
*******************************************************************
*/

AsyncSaveImageToDiskTask::AsyncSaveImageToDiskTask(TArray64<uint8> Image, FString ImageName){
    ImageCopy = Image;
    FileName = ImageName;
}

AsyncSaveImageToDiskTask::~AsyncSaveImageToDiskTask(){
    UE_LOG(LogTemp, Warning, TEXT("AsyncTaskDone"));
}

void AsyncSaveImageToDiskTask::DoWork(){
    UE_LOG(LogTemp, Warning, TEXT("Starting Work"));
    FFileHelper::SaveArrayToFile(ImageCopy, *FileName);
    UE_LOG(LogTemp, Log, TEXT("Stored Image: %s"), *FileName);
}