/**
* Progam made by Olivier Bernard, associate professor
* at Institut National des Sciences Appliquees (INSA) Lyon,
* CREATIS Laboratory,
* 69621 Villeurbanne, France,
* 07th of May 2014
*/

#ifndef _OpenHeartGUI_h
#define _OpenHeartGUI_h

#include <vtkImageData.h>
#include <vtkDataSet.h>
#include <vtkLookupTable.h>
#include <vtkPointWidget.h>
#include <vtkImagePlaneWidget.h>
#include <vtkPlane.h>
#include <vtkCellPicker.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
#include <vtkCommand.h>
#include <vtkActor2D.h>
#include <vtkTextProperty.h>
#include <vtkEventQtSlotConnect.h>
#include <vtkTextMapper.h>
#include <vtkCutter.h>
#include <vtkContextView.h>
#include <vtkTable.h>
#include <vtkOrientationMarkerWidget.h>
#include <vtkMatrix4x4.h>
#include <list>

#include "ui_OpenHeartGui.h"
#include <QMainWindow>
#include <QtGui>
#include <QTimer>


using namespace std;

class vtkRenderer;
class vtkEventQtSlotConnect;
class vtkObject;
class vtkCommand;


struct RendererProperties
{
    vtkSmartPointer<vtkLookupTable> lut;
    vtkSmartPointer<vtkImagePlaneWidget> xIPW, yIPW, zIPW;
    vtkSmartPointer<vtkImagePlaneWidget> xyIPW,xzIPW,yzIPW;
    double *position;
    vtkSmartPointer<vtkActor2D> TextActorPixel;
    vtkSmartPointer<vtkTextMapper> TextMapperPixel;
    vtkSmartPointer<vtkActor2D> TextActorMM;
    vtkSmartPointer<vtkTextMapper> TextMapperMM;
    vtkSmartPointer<vtkActor2D> TextActorValue;
    vtkSmartPointer<vtkTextMapper> TextMapperValue;
    vtkSmartPointer<vtkActor2D> TextActorSlice;
    vtkSmartPointer<vtkTextMapper> TextMapperSlice;
    vtkSmartPointer<vtkActor2D> TextActorNumFrame;
    vtkSmartPointer<vtkTextMapper> TextMapperNumFrame;
    vtkSmartPointer<vtkActor2D> TextActorResolution;
    vtkSmartPointer<vtkTextMapper> TextMapperResolution;
    vtkSmartPointer<vtkActor> MeshActor;
    vtkSmartPointer<vtkActor> xCutActor, yCutActor, zCutActor;
    vtkSmartPointer<vtkActor> BasalPointActor;
    vtkSmartPointer<vtkActor> ApexPointActor;
    vtkSmartPointer<vtkActor> LongAxisActor;
    vtkSmartPointer<vtkActor> BoundingBoxActor;
    list<vtkDataSetMapper*> StackMapperList;
    list<vtkDataSetMapper*>::iterator itStackMapperList;
    list<vtkCutter*> StackMapXCutter;
    list<vtkCutter*>::iterator itStackMapXCutter;
    list<vtkCutter*> StackMapYCutter;
    list<vtkCutter*>::iterator itStackMapYCutter;
    list<vtkCutter*> StackMapZCutter;
    list<vtkCutter*>::iterator itStackMapZCutter;
};


class OpenHeartGui : public QMainWindow, public Ui::OpenHeartGui
{
    Q_OBJECT
    public:

        OpenHeartGui();
        ~OpenHeartGui();

        vtkSmartPointer<vtkCellPicker> GetPicker() { return this->Picker; }
        vtkSmartPointer<vtkCellPicker> GetPickerXY() { return this->PickerXY; }
        vtkSmartPointer<vtkCellPicker> GetPickerXZ() { return this->PickerXZ; }
        vtkSmartPointer<vtkCellPicker> GetPickerYZ() { return this->PickerYZ; }
        RendererProperties *GetRendererProperties() { return this->Properties; }
        vtkRenderWindow *GetRenderWindow() { return this->qVTK->GetRenderWindow(); }
        vtkRenderWindow *GetRenderWindowXY() { return this->qVTKXY->GetRenderWindow(); }
        vtkRenderWindow *GetRenderWindowXZ() { return this->qVTKXZ->GetRenderWindow(); }
        vtkRenderWindow *GetRenderWindowYZ() { return this->qVTKYZ->GetRenderWindow(); }
        vtkSmartPointer<vtkRenderer> GetMeshRenderer() { return this->Ren; }
        vtkSmartPointer<vtkRenderer> GetMainRenderer() { return this->Ren; }
        vtkSmartPointer<vtkRenderer> GetXYRenderer() { return this->RenXY; }
        vtkSmartPointer<vtkRenderer> GetXZRenderer() { return this->RenXZ; }
        vtkSmartPointer<vtkRenderer> GetYZRenderer() { return this->RenYZ; }

        vtkImageData *GetCurrentImageData() { return this->ImageData; }
        int *GetDimensions() { return this->Dims; }
        void InterpolationManagement();
        void CreateFromSequenceDataPointer(std::string inputFilename);
        void UpdateForwardViewers();
        void UpdateBackwardViewers();
        int GetCurrentFrame() { return this->CurrentFrame; }
        int GetNumberOfFrames() { return this->NumberOfVolumes; }
        void SetFlagLoopEndToBegin( int val ) { this->FlagLoopEndToBegin = val; }
        void SetFlagLoopBeginToEnd( int val ) { this->FlagLoopBeginToEnd = val; }
        void DisplayMainAxisManagement();
        void DisplayMeshManagement();
        void DisplayModeManagement();
        void HidePlanModeManagement();
        void UpdateCoords(double *pos);
        int GetSelectedButton() { return ViewButton; }
        int GetFlagDisplayText() { return FlagDisplayText; }
        void ComputePointBeforeRotation(double *pt);

    public slots:

        void slotMeshAlpha(int);
        void slotRefreshViewer(int);
        void slotTabChange(int);
        void slotPlay();
        void slotXYView();
        void slotXZView();
        void slotYZView();
        void slot3DView();
        void slotMeshView();
        void slotMeshRepresentation();
        void slotMeshColor();
        void slotMeshCutter();
        void slotTimerEvent();
        void slotBasalPoint();
        void slotApexPoint();
        void slotReslice();
        void slotUpdateCoords(vtkObject*);

    protected:

        int Dims[3];
        int PreviousFrame;
        int CurrentFrame;
        int NumberOfVolumes;
        double BasalPoint[3];
        double ApexPoint[3];
        vtkSmartPointer<vtkRenderer> Ren;
        vtkSmartPointer<vtkRenderer> RenXY;
        vtkSmartPointer<vtkRenderer> RenXZ;
        vtkSmartPointer<vtkRenderer> RenYZ;
        vtkRenderer* RenChart;
        QTimer *Timer;
        vtkEventQtSlotConnect* Connections;

        list<vtkImageData*> StackVolume;
        list<vtkImageData*>::iterator itStackVolume;
        list<vtkPolyData*> StackMesh;
        list<vtkPolyData*>::iterator itStackMesh;
        vtkPolyData * Mesh;
        vtkImageData *ImageData;
        vtkSmartPointer <vtkOrientationMarkerWidget> OrientationWidget;
        RendererProperties *Properties;
        vtkSmartPointer<vtkCellPicker> Picker;
        vtkSmartPointer<vtkCellPicker> PickerXY;
        vtkSmartPointer<vtkCellPicker> PickerXZ;
        vtkSmartPointer<vtkCellPicker> PickerYZ;
        vtkSmartPointer<vtkRenderWindowInteractor> Interactor;
        vtkSmartPointer<vtkRenderWindowInteractor> InteractorXY;
        vtkSmartPointer<vtkRenderWindowInteractor> InteractorXZ;
        vtkSmartPointer<vtkRenderWindowInteractor> InteractorYZ;
        vtkSmartPointer<vtkContextView> ViewChart;
        vtkSmartPointer<vtkTable> TableChart;
        vtkSmartPointer<vtkMatrix4x4> RotationMatrix;
        vtkSmartPointer<vtkTransform> TransformViewOrientation;        
        vtkSmartPointer<vtkMatrix4x4> RotationMatrixInv;
        vtkSmartPointer<vtkTransform> TransformViewOrientationInv;

        int FlagInterpolation;
        int FlagDisplayMesh;
        int FlagDisplayMeshContourX;
        int FlagDisplayMeshContourY;
        int FlagDisplayMeshContourZ;
        int FlagLoopEndToBegin;
        int FlagLoopBeginToEnd;
        int FlagPlay;
        int FlagDisplayText;
        int FlagHidePlan;
        int FlagDisplayMeshContours;
        int FlagLongAxis;
        int FlagDisplayApexPoint;
        int FlagDisplayBasalPoint;
        int FlagDisplayLongAxis;
        int FlagReslice;

        int ViewButton;
        int MeshRepresentation;
        int MeshColor;
        double ZoomLabel;
        double ZoomMain;

        void InstantiateQtVtkRenderers();
        void InitPickers();
        void InitWidgets();
        void InitProperties();
        void InitOrientationAxes();
        void InitPlaneWidget();
        void InitTexts();
        void InitChar();
        void SetCustomInteractorStyle();
        vtkActor2D* AddFixedText(const char *text, float x, float y, float R,float G, float B, int Size);
        void ForceXZView();
        void UpdateClinicalIndices();
        void SetInterfaceColors();
        void CreateLongAxisActor();
        void SetLongAxisView();
        void ResetReslicing();
        void ComputeRotationMatrix();
        void UpdateViewer(int view, double zoom, vtkRenderer *ren);


        /// overloaded resize handler
        virtual void resizeEvent(QResizeEvent* event);

};

#endif