milxQtModel.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 MILXQTMODEL_H
#define MILXQTMODEL_H

#include "milxQtRenderWindow.h"

#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkPointData.h>
#include <vtkDataArray.h>
#include <vtkFloatArray.h>
#include <vtkPolyData.h>
#include <vtkProperty.h>
#include <vtkAlgorithmOutput.h>
#include <vtkTransform.h>
#include <vtkAbstractTransform.h>
#include <vtkMutableUndirectedGraph.h>
#include <vtkOutlineFilter.h>
#include <vtkCubeAxesActor.h>
//Labelling
#include <vtkLabeledDataMapper.h>
#include <vtkActor2D.h>
#include <vtkImageActor.h>
//Rendering
#include <vtkPolyDataMapper.h>
#include <vtkLODActor.h>

#include "milxModel.h"

static const int defaultChannelValue = 192;
static const float defaultColour = defaultChannelValue/255.0; //HTML Gray



class MILXQT_EXPORT milxQtModel : public milxQtRenderWindow
{
    Q_OBJECT

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

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

    void AddInput(vtkSmartPointer<vtkPolyData> mesh);
    void AddArray(vtkSmartPointer<vtkDataArray> array);
    void SetInput(vtkSmartPointer<vtkPolyData> mesh);
    //void SetInputPointSet(vtkSmartPointer<vtkPointSet> mesh);
//    void SetNumberOfInputs(const int inputs);
//    void SetInput(const int index, vtkSmartPointer<vtkPolyData> mesh);
    void SetPoints(vtkSmartPointer<vtkPoints> modelPoints);
    void SetPolys(vtkSmartPointer<vtkCellArray> modelPolys);
    void SetScalars(vtkSmartPointer<vtkDataArray> modelScalars);
    inline void SetActiveScalars(std::string nameOfArray)
    { model.SetActiveScalars(nameOfArray);  }
    void RemoveScalars();
    void SetVectors(vtkSmartPointer<vtkDataArray> modelVectors);
    void SetTransform(vtkSmartPointer<vtkTransform> transform);
    void SetGraph(vtkSmartPointer<vtkMutableUndirectedGraph> graph);
    inline void SetOpacity(double opacity)
    {
        if(modelled) modelActor->GetProperty()->SetOpacity(opacity);
    }

    //VTK Interfacing
    vtkSmartPointer<vtkPolyData> GetPolyDataInput();
    vtkSmartPointer<vtkPolyData> GetOutput();
#if VTK_MAJOR_VERSION <=5

    inline vtkSmartPointer<vtkAlgorithmOutput> GetOutputPort()
    {
        return model.GetProducerPort();
    }
#endif

    inline vtkSmartPointer<vtkLODActor> GetActor()
    {
        return modelActor;
    }
    inline vtkSmartPointer<vtkActor2D> GetActor2D()
    {
        return modelLabelsActor;
    }
    inline vtkSmartPointer<vtkPolyDataMapper> GetMapper()
    {
        return modelMapper;
    }
    inline vtkIdType GetNumberOfPoints()
    {
        return model.GetNumberOfPoints();
    }
    inline vtkIdType GetNumberOfArrays()
    {
        return model.GetNumberOfArrays();
    }
    inline vtkSmartPointer<vtkPoints> GetPoints()
    {
        return model.GetPoints();
    }
    inline vtkSmartPointer<vtkDataArray> GetScalars()
    {
        return model.GetScalars();
    }
    inline vtkSmartPointer<vtkDataArray> GetVectors()
    {
        return model.GetVectors();
    }
    inline vtkSmartPointer<vtkDataArray> GetNormals()
    {
        return model.GetNormals();
    }
    inline vtkSmartPointer<vtkDataArray> GetTensors()
    {
        return model.GetTensors();
    }
    inline virtual vtkDataSet* GetDataSet()
    {
        return model.Result();
    }
    inline void SetScalarRange(double range[2])
    {
        modelMapper->SetScalarRange(range);
        modelMapper->SetLookupTable(lookupTable);
        modelMapper->Update();
    }
    inline void GetScalarRange(double range[2])
    {
        model.Result()->GetScalarRange(range);
    }
    inline void resetScalarRange()
    {
        if(GetScalars())
            modelMapper->SetScalarRange( model.Result()->GetScalarRange() );
    }
    inline double * GetPoint(vtkIdType id)
    {
        return model.Result()->GetPoints()->GetPoint(id);
    }
    inline vtkSmartPointer<vtkAbstractTransform> GetTransform()
    {
        return vtkAbstractTransform::SafeDownCast(model.GetTransform());
    }
    inline double GetOpacity()
    {
        if(modelled) return modelActor->GetProperty()->GetOpacity();
        return 1.0;
    }
    inline void Update()
    {
        model.Update();
    }

    //Rendering
    inline void setLargeDataSetMode(bool large)
    {
        largeMode = large;
    }
    inline void ImmediateModeRenderingOn()
    {
        if(modelled) modelMapper->ImmediateModeRenderingOn();
    }

    //Operators
    milxQtModel& operator=(const milxQtModel &operand);

public slots:
    //Display
    void refresh();
    inline void reset()
    {
        generateModel(colourRed, colourGreen, colourBlue);
    }
    void toggleInterpolation(bool quiet = false);
    inline void interpolateDisplay(bool quiet = false)
    {   toggleInterpolation(quiet);    }
    inline void disableInterpolateDisplay(bool quiet = false)
    {   interpAct->setChecked(false);   interpolateDisplay(quiet);   }
    inline void enableInterpolateDisplay(bool quiet = false)
    {   interpAct->setChecked(true);   interpolateDisplay(quiet);   }
    void toggleSpecular(bool quiet = false);
    inline void specularDisplay(bool quiet = false)
    {   toggleSpecular(quiet);    }
    inline void disableSpecularDisplay(bool quiet = false)
    {   specularAct->setChecked(false);   specularDisplay(quiet);    }
    inline void enableSpecularDisplay(bool quiet = false)
    {   specularAct->setChecked(true);   specularDisplay(quiet);    }
    virtual void copyToContextMenu(QMenu *copyMenu);

    //Computation
    coordinate& centroid();
    double centroidSize(bool average = false);
    vnl_matrix<double>& covarianceMatrix();

    //Filters
    void undoProcessing();
    void clean();
    void triangulate();
    void decimate(double factor = 0.0);
    void quadricDecimate(double factor = 0.0);
    void clusterDecimate();
    void renameScalars(QString newName = "");
    void threshold(double lowValue = 0.0, double upValue = 0.0);
    void thresholdScalars(double lowValue = 0.0, double upValue = 0.0, double outsideVal = 0.0);
    void thresholdScalarsBinary(double lowValue = 0.0, double upValue = 0.0, double insideVal = 1.0, double outsideVal = 0.0);
    void maskScalars(QString filename = "");
    void gradient();
    void smooth(int iterations = 0);
    void smoothSinc(int iterations = 0);
    void curvature();
    void transform(QString filename = "", bool inverse = false);
    void loadScalars(QString filename = "");
    void removeScalars();
    inline void append(milxQtModel *mdl)
    {
        AddInput(mdl->GetOutput());
    }
    void modelInfo();
    void matchInfo(QString filename = "", bool rescale = true, double factor = 1.0);
    void registerICP(QString filename = "", bool similarity = false);
    void registerLandmarks(QString filename = "", bool similarity = false);
    void voxelise();
    virtual void contour();
    virtual void selectPointsInContour();
    virtual void weightGaussianFromContour(float stddev = -1.0, float clampValue = -1.0);
    void texture();
    void changeColour(float red = -1, float green = -1, float blue = -1);
    void changeOpacity(float opacity = -1);
    void normals(const bool turnOn = false);
    void rotate(bool xAxis = false, bool yAxis = false, bool zAxis = false, float angle = 90);
    void flip(bool xAxis = false, bool yAxis = false, bool zAxis = false);
    void background(bool white = false);
    void enableOutline(vtkDataObject *dataOutline = NULL);
    void disableOutline();
    void outlineDisplay();
    void enableCubeAxes(double *range = NULL, double *bounds = NULL);
    void disableCubeAxes();
    void cubeAxesDisplay(double *range = NULL);
    void removeOverlays();
    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);
    void outputScalars(QString filename = "");
    virtual void viewToXYPlane();
    virtual void viewToZXPlane();
    virtual void viewToZYPlane();
    void showArray(QAction * action);
    void showArray(const QString arrayName);
    virtual void updateLookupTable();

    virtual void createMenu(QMenu *menu);

    //Generators
    void generateDelaunayGraph(float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateDelaunay2DTriangulation();
    void generateDelaunayTriangulation(float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateVertices(float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateVerticesAs(const GlyphType glyphType = Circle, float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateTubes(float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    inline void generateEdges(float red = defaultColour, float green = defaultColour, float blue = defaultColour)
    {
        generateTubes(red, blue, green);
    }
    void generatePointModel(double newScale = 1.0, float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateSampledPoints(float distance = 0.0, float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateVectorField(double newScale = 0.0, float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateTensorField(double newScale = 0.0, float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateStreamLines(vtkSmartPointer<vtkImageData> seeds, float timestep = 0.0);
    void generateHedgehog(double newScale = 0.0, float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateNormals(int pointNormals = 0);
    void generateModel(float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateLabels();
    void generatePointIDsScalars();
    void generatePoints(float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateWireframe(float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateSurface(float red = defaultColour, float green = defaultColour, float blue = defaultColour);
    void generateIsoSurface(vtkSmartPointer<vtkImageData> img, int contourNumber = -1, double value = 0.0);
    void generatePolyDataFromImage(vtkSmartPointer<vtkImageData> img);
    void generateKMeansClustering(int numberOfClusters = 0);
    void generateQuantisedPoints(float quantiseFactor = 0.0);
    void generateCappedBoundaries();
    void generateRegionLabels();
    void generateElevation();
    //~ void generateReebGraphs();

    virtual void updateCoords(vtkObject *obj);

signals:
    void surfaceToImage(vtkSmartPointer<vtkPolyData> );
    void resultAvailable(milxQtRenderWindow*);
    void resultAvailable(milxQtModel*);

protected:
    //Flags
    bool appended; 
    bool modelled; 
    bool labelled; 
    bool scalarsSet; 
    bool transformed; 
    bool computedCentroid; 
    bool computedCovariance; 
    bool largeMode; 
    bool outlineBefore; 
    bool cubeAxesBefore; 
    bool undidProcess; 

    float colourRed; 
    float colourGreen; 
    float colourBlue; 

    milx::Model model; 

    //Data attributes
    coordinate modelCentroid; 
    vnl_matrix<double> modelCovarianceMatrix; 

    //Display Attributes
    vtkSmartPointer<vtkPolyDataMapper> modelMapper; 
    vtkSmartPointer<vtkLODActor> modelActor; 
    vtkSmartPointer<vtkLODActor> delaunayActor; 
    vtkSmartPointer<vtkActor2D> modelLabelsActor; 
    vtkSmartPointer<vtkActor> outlineActor; 
    vtkSmartPointer<vtkOutlineFilter> outlineMesh; 
    vtkSmartPointer<vtkCubeAxesActor> cubeAxesActor; 

    //------------------
    //Generate Menu
    QMenu* generateMenu; 
    QAction* genModelAct; 
    QAction* genVerticesAct; 
    QAction* genNormalsAct; 
    QAction* genVectorsAct; 
    QAction* genTensorsAct; 
    QAction* genHedgehogAct; 
    QAction* genDelaunayAct; 
    QAction* genDelaunayTri2DAct; 
    QAction* genDelaunayTriAct; 
    QAction* genLabelsAct; 
    QAction* genPointIDsAct; 
    QAction* genPointModelAct; 
    QAction* genSamplesAct; 
    QAction* genKmeansAct; 
    QAction* genQuantiseAct; 
    QAction* genCapBoundaries; 
    QAction* genRegionLabels; 
    QAction* genElevation; 
    QAction* genReebGraph; 
    //Operations Menu
    QMenu* operateMenu; 
    QAction* cleanAct; 
    QAction* triAct; 
    QAction* decimateAct; 
    QAction* quadricDecimateAct; 
    QAction* clusterDecimateAct; 
    QAction* smoothAct; 
    QAction* smoothSincAct; 
    QAction* curvatureAct; 
    //Transform Menu
    QMenu* transformMenu; 
    QAction* transformAct; 
    QAction* matchAct; 
    QAction* registerAct; 
    QAction* registerLandmarkAct; 
    QAction* voxeliseAct; 
    //Scalars Menu
    QMenu* scalarMenu; 
    QActionGroup* scalarsGroup; 
    QAction* renameScalarsAct; 
    QAction* thresholdAct; 
    QAction* thresholdScalarsAct; 
    QAction* thresholdScalarsBinaryAct; 
    QAction* maskScalarsAct; 
    QAction* gradientAct; 
    QAction* removeScalarsAct; 
    QAction* scalarsAct; 
    QAction* outScalarsAct; 
    //Show Menu
    QMenu* showMenu; 
    QAction* normalsAct; 
    QAction* centroidAct; 
    QAction* outlineAct; 
    QAction* cubeAxesAct; 
    QAction* overlaysAct; 
    //Contour menu
    QAction* selectPointsAct; 
    QAction* weightAct; 

    //Context Menu
    //menu defined in milxQtWindow
    //------------------
    QAction* doAct; 
    //------------------
    QAction* infoAct; 
    QAction* textureAct; 
    QAction* flipAct; 
    QAction* rotateAct; 
    //------------------
    QAction* colourAct; 
    QAction* interpAct; 
    QAction* specularAct; 

    //View Menu
    //------------------
    QActionGroup* displayGroup; 
    QAction* pointsAct; 
    QAction* wireframeAct; 
    QAction* surfaceAct; 
    QActionGroup* arrayGroup; 
    QMenu* arrayMenu; 
    //------------------

    //Helper Members
    void resetFlags();
    void createActions();
    void createConnections();
    void setupTooltips();
    void contextMenuEvent(QContextMenuEvent *event);
    QMenu* basicContextMenu();
    QMenu* generationMenu();
    QMenu* operationsMenu();
    QMenu* transformsMenu();
    QMenu* scalarsMenu();
    QMenu* arraysMenu();

private:
    QPointer<milxQtModel> normalsModel;
    QPointer<milxQtModel> centroidModel;
    QPointer<milxQtModel> outlineModel;
};

#endif // MILXQTMODEL_H