milxQtRenderWindow.h

/*=========================================================================
  The Software is copyright (c) Commonwealth Scientific and Industrial Research Organisation (CSIRO)
  ABN 41 687 119 230.
  All rights reserved.

  Licensed under the CSIRO BSD 3-Clause License
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License in the file LICENSE.md or at

  https://stash.csiro.au/projects/SMILI/repos/smili/browse/license.txt

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
=========================================================================*/
#ifndef MILXQTRENDERWINDOW_H
#define MILXQTRENDERWINDOW_H

#include "milxQtWindow.h"

#include <vtkSmartPointer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <vtkActor.h>
#include <vtkActor2D.h>
#include <vtkActorCollection.h>
#include <vtkAxesActor.h>
#include <vtkLookupTable.h>
#include <vtkImageData.h>
#include <vtkImageActor.h>
#include <vtkEventQtSlotConnect.h>
#include <vtkTable.h>
#include <vtkScalarBarActor.h>
//Widgets
#include <vtkScalarBarWidget.h>
#include <vtkContourWidget.h>
#include <vtkLineWidget2.h>
#include <vtkDistanceWidget.h>
#include <vtkBiDimensionalWidget.h>
#include <vtkAngleWidget.h>
#include <vtkPlaneWidget.h>
#include <vtkBoxWidget2.h>
#include <vtkSphereRepresentation.h>
#include <vtkSphereWidget2.h>
#include <vtkOrientationMarkerWidget.h>
#include <vtkTextWidget.h>

//Enum for views
enum ViewType { AXIAL = 0, CORONAL = 1, SAGITTAL = 2 };
enum ViewerType { SINGLE = 0, SCANNER = 1};
enum OrientationType { RADIOLOGICAL = 0, NEUROLOGICAL = 1};

//Struct for image actors, since actors per view is only possible need to link to parent (otherwise you get white actor)
struct ImageActorItem
{
    vtkSmartPointer<vtkImageActor> parentActor; //The parent actor it's connected to
    vtkSmartPointer<vtkImageActor> imageActor; //image actor to display in 3D view
};

class LabelledAction : public QWidgetAction {
public:
    LabelledAction (const QString& title, QPixmap pix, QWidget *theParent = 0) :
      QWidgetAction(theParent) {
        pWidget = new QWidget(theParent);
        pLayout = new QHBoxLayout();
        pLabel = new QLabel(title);
        pPixmapLabel = new QLabel(title);
        pPixmapLabel->setPixmap(pix);
        pPixmapLabel->setScaledContents(true);
        pLayout->addWidget (pPixmapLabel);
        pLayout->addWidget (pLabel);
        pWidget->setLayout (pLayout);
        setDefaultWidget(pWidget);
    }

    QLabel* label() {
        return pLabel;
    }
    QLabel* pixmapLabel() {
        return pPixmapLabel;
    }

private:
    QLabel *pLabel;
    QLabel *pPixmapLabel;
    QWidget* pWidget;
    QHBoxLayout* pLayout;
};


class MILXQT_EXPORT milxQtRenderWindow : public milxQtWindow
{
    Q_OBJECT

public:
    milxQtRenderWindow(QWidget *theParent = 0, bool contextSystem = true);
    virtual ~milxQtRenderWindow();

    void contextMenuSystem(bool context);

    inline void AddActor(vtkSmartPointer<vtkProp> actor)
    {
        renderer->AddActor(actor);
    }
    inline void AddVolume(vtkSmartPointer<vtkVolume> actor)
    {
        renderer->AddVolume(actor);
    }
    inline void AddActor2D(vtkSmartPointer<vtkProp> actor)
    {
        renderer->AddActor2D(actor);
    }

    inline void SetActor(vtkSmartPointer<vtkProp> actor)
    {
        renderer->AddActor(actor);
    }
    inline void SetActor2D(vtkSmartPointer<vtkProp> actor)
    {
        renderer->AddActor2D(actor);
    }
    inline void SetBackground(double red, double green, double blue)
    {
        renderer->GradientBackgroundOff();
        renderer->SetBackground(red, green, blue);
    }
    inline void SetSize(int height, int width)
    {
        QVTKWidget::GetRenderWindow()->SetSize(width, height);
        int *winSize = QVTKWidget::GetRenderWindow()->GetSize();
        QVTKWidget::resize(winSize[0],winSize[1]);
    }
    inline void SetLookupTable(vtkSmartPointer<vtkLookupTable> lut)
    {
        lookupTable = lut;
    }

    inline void RemoveAllActors()
    {
        renderer->RemoveAllViewProps();
    }
    inline void RemoveActor(vtkSmartPointer<vtkProp> actor)
    {
        renderer->RemoveActor(actor);
    }
    inline void RemoveActor2D(vtkSmartPointer<vtkProp> actor)
    {
        renderer->RemoveActor(actor);
    }

    inline vtkActorCollection* GetActors()
    {
        return renderer->GetActors();
    }
    inline vtkVolumeCollection* GetVolumes()
    {
        return renderer->GetVolumes();
    }
    inline virtual vtkImageActor* GetImageActor()
    {
        if(!imageActors.empty())
            return imageActors.last().imageActor;       //Implement in derived class
        else
            return NULL;
    }
    inline vtkLookupTable* GetLookupTable()
    {
        return lookupTable;
    }
    inline void SetScalarBar(vtkScalarBarActor* bar)
    {
        scalarBar->SetScalarBarActor(bar);
    }
    inline vtkScalarBarActor* GetScalarBar()
    {
      return scale;
    }
    inline void GetBackground(double &red, double &green, double &blue)
    {
        renderer->GetBackground(red, green, blue);
    }
    inline virtual vtkDataSet* GetDataSet()
    {
        return NULL;       //Implement in derived class that uses images
    }

    inline void SetRenderer(vtkRenderer* rnder)
    {
        renderer = rnder;
    }
    inline vtkRenderer* GetRenderer()
    {
        return renderer;
    }
    inline virtual vtkRenderWindowInteractor* GetVTKInteractor()
    {
        return QVTKWidget::GetRenderWindow()->GetInteractor();
    }

    inline void OffScreenRenderingOn()
    {
        QVTKWidget::GetRenderWindow()->OffScreenRenderingOn();
    }
    inline void OffScreenRenderingOff()
    {
        QVTKWidget::GetRenderWindow()->OffScreenRenderingOff();
    }

    inline void Render()
    {
        QVTKWidget::GetRenderWindow()->Render();
    }

    void enableUpdates(QStatusBar *bar);

public slots:
    void addModelActor(vtkSmartPointer<vtkActor> mdlActor);
    void removeModelActor(vtkSmartPointer<vtkActor> mdlActor);
    void addActor(vtkSmartPointer<vtkActor> imgActor, vtkMatrix4x4 *transformMatrix = NULL);
    void addImageActor(vtkSmartPointer<vtkImageActor> imgActor, vtkMatrix4x4 *transformMatrix = NULL);
    void removeImageActor(vtkSmartPointer<vtkImageActor> imgActor);
    void importFrom(milxQtRenderWindow *windowToImportFrom);
    inline void importViewFrom(milxQtRenderWindow *windowToImportFrom)
    {   importFrom(windowToImportFrom);   }
    virtual void updateTextActor(vtkObject * obj, unsigned long, void * client_data, void *, vtkCommand * command);
    virtual void updateImageActor(vtkObject * obj, unsigned long, void * client_data, void *, vtkCommand * command);
    virtual void updateImageActor(vtkSmartPointer<vtkImageActor> actor);

    void userEvent(QMouseEvent *event = NULL);
    void userEvent(QKeyEvent *event);
    void userEvent(QWheelEvent *event);

    void refresh();
    inline vtkSmartPointer<vtkMatrix4x4> getTransformMatrix()
    {   return transformMatrix;   }
    void reset();
    inline bool isLoaded()
    {
        return loaded;
    }
    void linkProgressEventOf(vtkObject * obj);
    virtual void updateCoords(vtkObject *obj);
    virtual void contour();
    void contourAsPolyData();
    void contourAsNodePolyData();
    void contourInitFromPolyData(QString filename = "");
    void enableAxes(float xScale = 1.0, float yScale = 1.0, float zScale = 1.0);
    void disableAxes();
    void axesDisplay();
    void disableOrient();
    void orientDisplay();
    virtual void background(bool white = false);
    void lighting();
    void textDisplay();
    void crosshair();

    //Viewing
    virtual void viewToXYPlane();
    inline void viewToAxial()
    {
        viewToXYPlane();
    }
    virtual void viewToZXPlane();
    inline void viewToCoronal()
    {
        viewToZXPlane();
    }
    virtual void viewToZYPlane();
    inline void viewToSagittal()
    {
        viewToZYPlane();
    }
    inline int getDefaultOrientation()
    {   return orientationView;  }
    inline void setDefaultOrientation(int orientMode)
    {   orientationView = orientMode;  }
    inline int getView()
    {   return currentView;   }
    void setView(int viewMode);
    void enableActionBasedOnView();
    inline void disableDefaultView()
    {   useDefaultView = false; }
    inline void enableDefaultView()
    {   useDefaultView = true;  }
    inline void setDefaultView(int viewMode)
    {   defaultView = viewMode;   }
    void saveView(QString filename = "");
    void saveViewFile();
    void loadView(QString filename = "");
    void loadViewFile();
    virtual void enableScale(QString title = "", const bool quiet = false, double minRange = 0.0, double maxRange = 0.0, int noOfLabels = 3) {}
    virtual void disableScale();
    virtual inline void enableCrosshair()
    {
        if(rendered)
        {
            renderWindow->SetCurrentCursor(VTK_CURSOR_CROSSHAIR);
            crosshairAct->setChecked(true);
        }
    }
    virtual inline void disableCrosshair()
    {
        renderWindow->SetCurrentCursor(0);
        crosshairAct->setChecked(false);
    }

    virtual void scaleDisplay(const bool forceDisplay = false) {}
    virtual void colourMapToRainbow(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToVTK(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToGray(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToSeismic(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToLogGray(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToJet(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToNIH(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToNIH_Fire(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToAAL(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToFS(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToHOT(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToCOOL(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToCOOLWARM(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToKnee(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToBone(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToSpectral(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToGNUPlot(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToCubeHelix(double minRange = 0.0, double maxRange = 0.0);
    virtual void colourMapToHSV(double minRange = 0.0, double maxRange = 0.0);
    virtual void updateLookupTable();

    void generateRender();

    //Custom
    inline void setCustomActionGroup(QActionGroup *actionGrp)
    {
        windowActionGroup = actionGrp;
    }
    void createCustomConnections(QList<QAction *> actionsInMenu);
    void createCustomConnections(QMenu *fromMenu);
    virtual void customOperation();

    virtual void createMenu(QMenu *menu);

    bool openModelUsingQt(const QString filename, vtkSmartPointer<vtkPolyData> &data);

signals:
    void imageAvailable(vtkImageData*, QString );
    void modelAvailable(vtkPolyData*, QString );
    void tableToPlot(vtkSmartPointer<vtkTable>, QString);
    void modified(vtkSmartPointer<vtkImageActor> );

protected:
    //Flags
    bool loaded; 
    bool rendered; 
    bool axesBefore; 
    bool scaleBefore; 
    bool customScalarBar; 
    bool logScale; 
    bool useDefaultView; 
    bool orientationAxes; 
    bool contextMenuEnabled; 

    //Variables
    int defaultView; 
    int currentView; 
    int orientationView; 

    //Window Menu
    QMenu* windowPropertiesMenu; 
    QAction* backgroundAct; 
    QAction* axesAct; 
    QAction* lightingAct; 
    QAction* lineAct; 
    QAction* distanceAct; 
    QAction* biDirectionAct; 
    QAction* angleAct; 
    QAction* planeAct; 
    QAction* boxAct; 
    QAction* sphereAct; 
    QAction* humanAct; 
    QAction* textAct; 
    QAction* crosshairAct; 

    //Contouring Menu
    QMenu* contourMenu; 
    QAction* contourAct; 
    QAction* contourPolyDataAct; 
    QAction* contourNodePolyDataAct; 
    QAction* contourInitAct; 
//    QAction* contourImageAct; //!< Save contour surface points as binary image.

    //View Menu
    QMenu* viewMenu; 
    QActionGroup* viewGroup; 
    QAction* viewXY; 
    QAction* viewZY; 
    QAction* viewZX; 
    QAction* saveViewAct; 
    QAction* loadViewAct; 
    QAction* saveViewFileAct; 
    QAction* loadViewFileAct; 
    QAction* scaleAct; 
    QMenu* colourMapMenu; 
    QActionGroup* mapGroup; 
    QAction* actionDefault; 
    QAction* actionJet; 
    QAction* actionRainbow; 
    QAction* actionInvRainbow; 
    LabelledAction* actionGray; 
    LabelledAction* actionSeismic; 
    QAction* actionLogGray; 
    QAction* actionNIH; 
    QAction* actionNIH_FIRE; 
    QAction* actionAAL; 
    QAction* actionFS; 
    LabelledAction* actionHOT; 
    QAction* actionCOOL; 
    LabelledAction* actionCOOLWARM; 
    QAction* actionKnee; 
    LabelledAction* actionBone; 
    LabelledAction* actionSpectral; 
    LabelledAction* actionGNUPlot; 
    LabelledAction* actionCubeHelix; 
    LabelledAction* actionHSV; 

    //Actions
    QAction* resetAct; 
    QAction* refreshAct; 

    QPoint dragStartPosition; 

    vtkSmartPointer<vtkEventQtSlotConnect> Connector; 
    vtkSmartPointer<vtkMatrix4x4> transformMatrix; 

    //VTK Rendering Internals
    vtkSmartPointer<vtkRenderer> renderer; 
    vtkSmartPointer<vtkRenderWindow> renderWindow; 
    vtkSmartPointer<vtkLookupTable> lookupTable; 
    vtkSmartPointer<vtkCamera> camera; 

    vtkSmartPointer<vtkScalarBarActor> scale; 
    vtkSmartPointer<vtkScalarBarWidget> scalarBar; 
    vtkSmartPointer<vtkAxesActor> axes; 
    vtkSmartPointer<vtkAxesActor> orientAxes; 
    vtkSmartPointer<vtkPointPicker> dataPicker; 

    //Widgets
    vtkSmartPointer<vtkContourWidget> contourWidget; 
    vtkSmartPointer<vtkLineWidget2> lineWidget; 
    vtkSmartPointer<vtkDistanceWidget> distanceWidget; 
    vtkSmartPointer<vtkBiDimensionalWidget> biDirectionWidget; 
    vtkSmartPointer<vtkAngleWidget> angleWidget; 
    vtkSmartPointer<vtkPlaneWidget> planeWidget; 
    vtkSmartPointer<vtkBoxWidget2> boxWidget; 
    vtkSmartPointer<vtkSphereRepresentation> sphereRep; 
    vtkSmartPointer<vtkSphereWidget2> sphereWidget; 
    vtkSmartPointer<vtkOrientationMarkerWidget> humanGlyph; 
    QList< vtkSmartPointer<vtkTextWidget> > textWidgets; 
    QList< vtkSmartPointer<vtkTextActor> > textActors; 
    QList<ImageActorItem> imageActors; 

    QStatusBar *updateBar; 

    QActionGroup* windowActionGroup; 

    void createActions();
    void createConnections();
    void contextMenuEvent(QContextMenuEvent *event);
    QMenu* colourMapsMenu();
    void dragMoveEvent(QDragMoveEvent *event);
    void dragLeaveEvent(QDragLeaveEvent *event);
    void dragEnterEvent(QDragEnterEvent *event);
    void mouseDoubleClickEvent(QMouseEvent *event);
    void dropEvent(QDropEvent *event);

    virtual void SetupWidgets(vtkRenderWindowInteractor *interactor);

    void setupHumanGlyph(vtkSmartPointer<vtkMatrix4x4> mat = NULL);

private:

};

#endif // MILXQTRENDERWINDOW_H