milxQtImage.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 MILXQTIMAGE_H
#define MILXQTIMAGE_H

#include <QStatusBar>

//VTK Headers
#include <vtkSmartPointer.h>
#include <itkCommand.h>
#include <vtkImageData.h>
#include <vtkMatrix4x4.h>
#include <vtkImageAppend.h>
#include <vtkImagePermute.h>
#include <vtkImageAccumulate.h>
#include <vtkImageMapToWindowLevelColors.h>
#if(VTK_MAJOR_VERSION > 5)
    #include <vtkResliceCursor.h>
    #include <vtkResliceCursorActor.h>
#endif
//ITK Imaging
#include <itkRGBPixel.h>
#include <itkImage.h>
#include <itkVectorImage.h>
//VXL
#include <vnl/vnl_matrix.h>

#include "milxQtRenderWindow.h"
#include "vtkImageViewer3.h" //smili vtk-ext
#include "milxImage.h"

//Typedefs
typedef unsigned char charPixelType;
typedef itk::Image<charPixelType, milx::imgDimension> charImageType;
typedef int intPixelType;
typedef itk::Image<intPixelType, milx::imgDimension> intImageType;
typedef itk::RGBPixel<unsigned char> rgbPixelType;
typedef itk::Image<rgbPixelType, milx::imgDimension> rgbImageType;
typedef float floatPixelType;
typedef itk::Image<floatPixelType, milx::imgDimension> floatImageType;
typedef itk::VectorImage<floatPixelType, milx::imgDimension> vectorImageType;

//Struct for image actors
struct ModelActorItem
{
    vtkSmartPointer<vtkActor> modelActor; //image actor to display in model view
    vtkSmartPointer<vtkActor> parentActor; //The parent actor it's connected to
};

class itkEventQtObserver : public itk::Command
{
public:
    itkNewMacro( itkEventQtObserver );

public:

    void Execute(itk::Object *caller, const itk::EventObject & event)
    {
        Execute( (const itk::Object *)caller, event);
    }

    void Execute(const itk::Object * object, const itk::EventObject & event)
    {
        qApp->processEvents(); //Update Qt event loop to keep application responsive
    }
};

class MILXQT_EXPORT milxQtImage : public milxQtRenderWindow
{
    Q_OBJECT

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

    virtual inline const char * GetNameOfClass() const
    {
      return "milxQtImage";
    }

    //Data Members
    inline QString strippedNamePrefix()
    {
        return prefix + QFileInfo(name).fileName();
    }

    inline void SetInput(vtkSmartPointer<vtkImageData> newImg)
    {
        setData(newImg);
    }
    inline void SetInput(charImageType::Pointer newImg, const bool flipY = true)
    {
        setData(newImg, flipY);
    }
    inline void SetInput(intImageType::Pointer newImg, const bool flipY = true)
    {
      setData(newImg, flipY);
    }
    inline void SetInput(rgbImageType::Pointer newImg, const bool flipY = true)
    {
        setData(newImg, flipY);
    }
    inline void SetInput(floatImageType::Pointer newImg, const bool flipY = true)
    {
        setData(newImg, flipY);
    }
    inline void SetInput(vectorImageType::Pointer newImg, const bool flipY = true)
    {
        setData(newImg, flipY);
    }
    void SetTransform(vtkSmartPointer<vtkTransform> transform);

    void setData(QPointer<milxQtImage> newImg, const bool forceDeepCopy = false);
    void setData(vtkSmartPointer<vtkImageData> newImg);
    void setData(charImageType::Pointer newImg, const bool flipY = true);
    void setData(intImageType::Pointer newImg, const bool flipY = true);
    void setData(rgbImageType::Pointer newImg, const bool flipY = true);
    void setData(floatImageType::Pointer newImg, const bool flipY = true);
    void setData(vectorImageType::Pointer newImg, const bool flipY = true, const bool deepCopy = false);
    void setData(vnl_matrix<double> &newData);
    void setData(const unsigned slice, vnl_matrix<double> &newData);
    void setDisplayData(QPointer<milxQtImage> newImg);
    inline void setSharedData(QPointer<milxQtImage> newImg)
    {   setDisplayData(newImg); }
    void setDisplayData(charImageType::Pointer newImg, const bool flipY = true);
    inline void setSharedData(charImageType::Pointer newImg, const bool flipY = true)
    {   setDisplayData(newImg, flipY);  }
    void setDisplayData(intImageType::Pointer newImg, const bool flipY = true);
    inline void setSharedData(intImageType::Pointer newImg, const bool flipY = true)
    { setDisplayData(newImg, flipY);  }
    void setDisplayData(rgbImageType::Pointer newImg, const bool flipY = true);
    inline void setSharedData(rgbImageType::Pointer newImg, const bool flipY = true)
    {   setDisplayData(newImg, flipY);  }
    void setDisplayData(floatImageType::Pointer newImg, const bool flipY = true);
    inline void setSharedData(floatImageType::Pointer newImg, const bool flipY = true)
    {   setDisplayData(newImg, flipY);  }
    void setDisplayData(vectorImageType::Pointer newImg, const bool flipY = true);
    inline void setSharedData(vectorImageType::Pointer newImg, const bool flipY = true)
    {   setDisplayData(newImg, flipY);  }

    inline vtkSmartPointer<vtkImageData> GetOutput()
    {
        return imageData;
    }
    inline charImageType::Pointer GetCharImage()
    {
        return imageChar;
    }
    inline intImageType::Pointer GetIntImage()
    {
        return imageInt;
    }
    inline rgbImageType::Pointer GetRGBImage()
    {
        return imageRGB;
    }
    inline floatImageType::Pointer GetFloatImage()
    {
        return imageFloat;
    }
    inline vectorImageType::Pointer GetVectorImage()
    {
        return imageVector;
    }
#if VTK_MAJOR_VERSION <= 5

    inline vtkAlgorithmOutput* GetOutputPort()
    {   return imageData->GetProducerPort();   }
#endif

    inline vtkImageActor* GetImageActor()
    {
        return viewer->GetImageActor();
    }
#if(VTK_MAJOR_VERSION > 5)
    inline void SetCursor(vtkResliceCursor *newCursor)
    {
        viewer->SetCursor(newCursor);
    }
#else
    inline void SetCursor(vtkCursor3D *newCursor)
    {
      viewer->SetCursor(newCursor);
    }
#endif

#if(VTK_MAJOR_VERSION > 5)
    inline vtkResliceCursor* GetCursor()
    {
        return viewer->GetCursor();
    }
#else
    inline vtkCursor3D* GetCursor()
    {
      return viewer->GetCursor();
    }
#endif

#if(VTK_MAJOR_VERSION > 5)
    inline void SetCursorActor(vtkResliceCursorActor *newCursorActor)
    {
        viewer->SetCursorActor(newCursorActor);
    }
#else
    inline void SetCursorActor(vtkActor *newCursorActor)
    {
      viewer->SetCursorActor(newCursorActor);
    }
#endif

    inline vtkProp3D* GetCursorActor()
    {
        return viewer->GetCursorActor();
    }
    inline int* GetDisplayExtent()
    {
        return GetImageActor()->GetDisplayExtent();
    }
    inline virtual vtkDataSet* GetDataSet()
    {
        return imageData;
    }
    inline virtual vtkRenderWindowInteractor* GetVTKInteractor()
    {
        return viewer->GetRenderWindow()->GetInteractor();
    }

    //Flags
    inline void set8BitImage()
    {
        eightbit = true;
        rgb = false;
        vectorised = false;
    }
    inline bool is8BitImage()
    {
        return eightbit;
    }
    inline void set32BitImage()
    {
        eightbit = false;
        integer = true;
        rgb = false;
        vectorised = false;
    }
    inline bool is32BitImage()
    {
        return integer;
    }
    inline void setRGBImage()
    {
        eightbit = false;
        rgb = true;
        vectorised = false;
    }
    inline bool isRGBImage()
    {
        return rgb;
    }
    inline void setFloatingPointImage()
    {
        eightbit = false;
        rgb = false;
        vectorised = false;
    }
    inline bool isFloatingPointImage()
    {
        return (!eightbit && !rgb && !vectorised);
    }
    inline void setVectorImage()
    {
        eightbit = false;
        rgb = false;
        vectorised = true;
    }
    inline bool isVectorImage()
    {
        return vectorised;
    }
    inline bool isVTKImage()
    {
        return usingVTKImage;
    }

    inline bool isDisplayFlipped()
    {
        return flipped;
    }
    inline bool isInterpolated()
    {
        if(viewer->GetImageActor()->GetInterpolate())
            return true;
        else
            return false;
    }
    inline bool isOriented()
    {
        return orientAct->isChecked();
    }
    inline bool isCrosshair()
    {
      return cursorAct->isChecked();
    }

    inline void setActualNumberOfDimensions(const size_t dims)
    {
        actualNumberOfDimensions = dims;
    }
    inline size_t getActualNumberOfDimensions()
    {
        return actualNumberOfDimensions;
    }

    void trackView(milxQtImage *windowToTrack, ViewType viewTo);

    //VTK Filters
    vtkSmartPointer<vtkImageData> butterWorthHighPass(vtkSmartPointer<vtkImageData> img);

public slots:
    void userEvent(QMouseEvent *event = NULL);
    void userEvent(QKeyEvent *event);
    void userEvent(QWheelEvent *event);
    virtual void updateCoords(vtkObject *obj);
    void updateSlice(vtkObject *obj);
    void updateTrackedView(vtkObject *obj);
    virtual void contour();

    void autoLevel(float percentile=0.99);
    void setLevel(int level);
    inline vtkImageMapToWindowLevelColors* GetWindowLevel()
    {
        return viewer->GetWindowLevel();
    }
    double GetIntensityWindow();
    void SetIntensityWindow(double window);
    double GetIntensityLevel();
    void SetIntensityLevel(double level);
#if (ITK_REVIEW || ITK_VERSION_MAJOR > 3)

    void overlay(QString filename = "");
    void overlayContour(QString filename = "");
    void computeContour();
#endif // (ITK_REVIEW || ITK_VERSION_MAJOR > 3)

    void blend(QString filename = "", float opacity = -1.0);
    void blend(milxQtImage *imageToMatch, float opacity = -1.0);
    void volumeRendering();
    void imageInformation();
    void rescale();
    void relabel();
    void histogramEqualisation();
    void gradientMagnitude();
    void sobelEdges();
    void cannyEdges();
    void laplacian();
    void normalize();
    void invertIntensity();
    void matchInfo(milxQtImage *imageToMatch);
    void matchInfo(QString filename = "");
    void matchHistogram(milxQtImage *imageToMatch);
    void matchHistogram(QString filename = "");
    void resample(QString filename = "");
    void mask(QString filename = "");
    void subsample(size_t xSampleFactor = 0, size_t ySampleFactor = 0, size_t zSampleFactor = 0);
    void crop(QString filename = "");
    void resampleLabel(QString filename = "");
    void transform(QString filename = "", QString refImgFilename = "", bool inverse = false);
    void checkerBoard(QString filename = "", int numberOfSquares = 0);
    void checkerBoard(milxQtImage *img, int numberOfSquares = 0);
    void distanceMap(bool signedDistance = true, bool inside = false);
    void thresholdAbove(float value = 0, float level = 0);
    void thresholdBelow(float value = 0, float level = 0);
    void threshold(float value = 0, float blevel = 0, float alevel = 0);
    void binaryThreshold(float value = 0, float blevel = 0, float alevel = 0);
    void otsu(int bins = 0);
    void otsuMultiple(int bins = 0, int labels = 0);
    void flip(bool xAxis = false, bool yAxis = false, bool zAxis = false, bool aboutOrigin = true);
    void surface(const float value = numeric_limits<float>::max());
    void polyData();
    void magnitude();
    void component(int index = -1);
    void pseudoImage();
    void vectorField(int subsampleFactor = 0, float scaling = 0.0);
    void streamLines();
    void anisotropicDiffusion();
    void gaussianSmooth();
    void bilateral();
    void median();
    void zeros(const unsigned long xSize, const unsigned long ySize, const unsigned long zSize, milxQtImage *refImage = NULL);
    void resize(double outputSpacing = 0.0);
    void resize(const unsigned long xSize, const unsigned long ySize, const unsigned long zSize, milxQtImage *refImage = NULL);
    void add(milxQtImage *img);
    void add(QString filename = "");
    void subtract(milxQtImage *img);
    void subtract(QString filename = "");
    void multiply(milxQtImage *img);
    void multiply(QString filename = "");
    void scale(float scaling);
    void convolve(milxQtImage *img);

    //VTK Filters
    void highpass();

    //Display
    void interpolateDisplay(const bool quietly = false);
    inline void disableInterpolateDisplay()
    {   viewer->GetImageActor()->InterpolateOn();   interpolateDisplay();   }
    inline void enableInterpolateDisplay()
    {   viewer->GetImageActor()->InterpolateOff();   interpolateDisplay();   }
    void applyOrientDisplay(const bool quietly = false);
    inline void disableApplyOrientDisplay()
    {   orientAct->setChecked(false);   applyOrientDisplay();   }
    inline void enableApplyOrientDisplay()
    {   orientAct->setChecked(true);   applyOrientDisplay();   }
    void setDefaultOrientation(int orientMode);
    virtual void enableScale(QString title = "", const bool quiet = false, double minRange = 0.0, double maxRange = 0.0, int noOfLabels = 3);
    virtual void scaleDisplay(const bool forceDisplay = false);
    virtual void showCrosshair(const bool quietly = false);
    virtual inline void enableCrosshair()
    {
        if(viewerSetup)
        {
            viewer->EnableCursor();
            cursorAct->setChecked(true);
        }
    }
    virtual inline void disableCrosshair()
    {
        viewer->DisableCursor();
        cursorAct->setChecked(false);
    }
    virtual inline void enableCrosshairPointer()
    {
        if(rendered)
        {
            viewer->GetRenderWindow()->SetCurrentCursor(VTK_CURSOR_CROSSHAIR);
            crosshairAct->setChecked(true);
        }
    }
    virtual inline void disableCrosshairPointer()
    {
        viewer->GetRenderWindow()->SetCurrentCursor(0);
        crosshairAct->setChecked(false);
    }
#if VTK_MAJOR_VERSION > 5

    virtual void resliceMode(const bool quietly = false);
    virtual inline void enableResliceMode()
    {
        printDebug("Oblique slicing enabled. Use Shift + Left Mouse.");
        viewer->GetInteractorStyle()-> SetInteractionModeToImage3D();
        resliceAct->setChecked(true);
    }
    virtual inline void disableResliceMode()
    {
        viewer->GetInteractorStyle()->SetInteractionModeToImageSlicing();
        resliceAct->setChecked(false);
    }
#endif

    void setView(int viewMode);
    virtual void viewToXYPlane();
    virtual void viewToZXPlane();
    virtual void viewToZYPlane();
    inline void setCrosshairPosition(double *position)
    {
        viewer->SetCursorFocalPoint(position);
        viewer->UpdateCursor();
    }
    inline double* getCrosshairPosition()
    {   return viewer->GetCursorFocalPoint();   }
    virtual void updateLookupTable();
    void histogram(int bins = 256, float belowValue = 0, float aboveValue = 255, bool plotHistogram = true);
    void surfacePlot();
    void setSlice(int slice);
    inline int getSlice()
    {
        return viewer->GetSlice();
    }
    inline double getIntensityWindow()
    {
        return viewer->GetWindowLevel()->GetWindow();
    }
    inline double getIntensityLevel()
    {
        return viewer->GetWindowLevel()->GetLevel();
    }
    inline void setIntensityWindow(double window)
    {
        viewer->GetWindowLevel()->SetWindow(window);
    }
    inline void setIntensityLevel(double level)
    {
        viewer->GetWindowLevel()->SetLevel(level);
    }
    void refresh();
    void reset();

    virtual void createMenu(QMenu *menu);

    void generateImage(const bool quietly = false);
    void generateVoxelisedSurface(vtkSmartPointer<vtkPolyData> surfaceToVoxelise, double *bounds = NULL, double *spacing = NULL);

    //Custom
    virtual void customOperation();
    void updateModelActor(vtkObject * obj, unsigned long, void * client_data, void *, vtkCommand * command);
    void updateDisplay(QPointer<milxQtImage> img);

signals:
    void imageToSurface(vtkSmartPointer<vtkImageData>, const float );
    void imageToPolyData(vtkSmartPointer<vtkImageData> );
    void imageToPseudoImage(vectorImageType::Pointer );
    void imageToVectorField(vectorImageType::Pointer, floatImageType::Pointer, int, float);
    void imageToTensorField(vectorImageType::Pointer, floatImageType::Pointer, int, float );
    void imageToStreamLines(vectorImageType::Pointer, floatImageType::Pointer );
    void imageToVolume(vtkSmartPointer<vtkImageData> , bool);
    void imageToPlot(vtkSmartPointer<vtkImageData>, int);
    void modified(QPointer<milxQtImage> );
    void coordinateChanged(int, int, int);

protected:
    //Flags
    bool usingVTKImage; 
    bool imported; 
    bool appendedData; 
    bool eightbit; 
    bool integer; 
    bool rgb; 
    bool vectorised; 
    bool viewerSetup; 
    bool volume; 
    bool flipped; 
    bool track; 

    //Image Related
    //ITK
    charImageType::Pointer imageChar; 
    intImageType::Pointer imageInt; 
    rgbImageType::Pointer imageRGB; 
    floatImageType::Pointer imageFloat; 
    vectorImageType::Pointer imageVector; 

    size_t actualNumberOfDimensions; 
    ViewType viewToTrack; 

    //VTK
    vtkSmartPointer<vtkImageViewer3> viewer; 
    vtkSmartPointer<vtkImageData> imageData; 
    vtkSmartPointer<vtkImageAppend> imageDataAppended; 
    vtkSmartPointer<vtkImagePermute> permute; 
    vtkSmartPointer<vtkImageAccumulate> hist; 
    QList<ModelActorItem> modelActors; 

    itkEventQtObserver::Pointer observeProgress; 

    double meanValue; 
    double stddevValue; 
    double minValue; 
    double maxValue; 

    //Context Menu
    //menu defined in milxQtWindow
    //------------------
    QMenu* operateMenu; 
    QAction* rescaleAct; 
    QAction* equaliseAct; 
    QAction* computeContourAct; 
    QAction* smoothAct; 
    QAction* gaussianAct; 
    QAction* bilateralAct; 
    QAction* medianAct; 
    QAction* gradMagAct; 
    QAction* sobelAct; 
    QAction* cannyAct; 
    QAction* laplacianAct; 
    QAction* highPassAct; 
    QAction* normAct; 
    QAction* invertAct; 
    QAction* relabelAct; 
    //------------------
    QMenu* transformMenu; 
    QAction* matchAct; 
    QAction* matchHistAct; 
    QAction* resampleSpacingAct; 
    QAction* resampleAct; 
    QAction* resampleLabelAct; 
    QAction* subsampleAct; 
    QAction* transformAct; 
    QAction* maskAct; 
    QAction* cropAct; 
    QAction* checkerAct; 
    QAction* distMapAct; 
    QAction* flipAct; 
    QAction* surfaceAct; 
    QAction* polyDataAct; 
    //------------------
    QMenu* thresholdMenu; 
    QAction* otsuAct; 
    QAction* otsuMultipleAct; 
    QAction* binaryAct; 
    QAction* bandAct; 
    QAction* aboveAct; 
    QAction* belowAct; 
    //------------------
    QMenu* vectorMenu; 
    QAction* vectorMagnitudeAct; 
    QAction* vectorComponentAct; 
    QAction* pseudoImageAct; 
    QAction* vectorFieldAct; 
    QAction* streamLinesAct; 
    //------------------
    QAction* levelAct; 
    QAction* overlayAct; 
    QAction* overlayContourAct; 
    QAction* blendAct; 
    QAction* volRenderAct; 
    QAction* histogramAct; 
    QAction* surfacePlotAct; 
    QAction* infoAct; 
    QAction* interpolateAct; 
    QAction* orientAct; 
    QAction* resliceAct; 
    QAction* cursorAct; 

    void updateData(const bool orient = true);
    void setupEvents();
    //Internal Members
    void createActions();
    void createConnections();
    void contextMenuEvent(QContextMenuEvent *event);
    QMenu* basicContextMenu();
    QMenu* operationsMenu();
    QMenu* thresholdsMenu();
    QMenu* transformsMenu();
    QMenu* vectorsMenu();
    void dropEvent(QDropEvent *event);

    virtual void SetupWidgets(vtkRenderWindowInteractor *interactor);
    inline void updateViewer(vtkObject * obj, unsigned long, void * client_data, void *, vtkCommand * command)
    {
    #if VTK_MAJOR_VERSION <= 5
        viewer->SetInput(imageData);
    #else
        viewer->SetInputData(imageData);
    #endif
    }
    QString getOpenFilename(const QString labelForDialog = "Select Image", QString exts = "");

private:

};

#endif // MILXQTIMAGE_H