milxQtShapeModel.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 MILXQTSHAPEMODEL_H
#define MILXQTSHAPEMODEL_H

//milxSSM3D
#include <itkStatisticalShapeTimepointModel.h>

#include <milxQtAliases.h>
#include <milxQtRenderWindow.h>
#include <milxQtModel.h>

typedef itk::StatisticalShapeModelBase<double> ShapeModelBaseType;
typedef itk::StatisticalShapeTimepointModel<double> ShapeModelType;

class MILXQT_PLUGIN_EXPORT milxQtShapeModel : public milxQtRenderWindow
{
    Q_OBJECT

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

    inline virtual bool isLoaded()
    {   return m_loaded;    }

public slots:
    void LoadModel(const QString filename);
    inline virtual void openModel(const QString filename)
    {
        LoadModel(filename);
    }
    inline virtual void SaveModel(const QString filename)
    {
        m_StandardSSM->Update();
        m_StandardSSM->SaveModel(filename.toStdString().c_str());
    }
    inline virtual void saveModel(const QString filename)
    {
        SaveModel(filename);
    }

    virtual void SetInputCollection(vtkPolyDataCollection* meshes);
    virtual void SetInputCollection(vtkPolyDataCollection* meshes, QStringList &filenames);
    inline void SetPrecision(float modePrecision)
    {
        m_SSM->SetPrecision(modePrecision);
    }
    inline void AddShape(vtkPolyData *shape)
    {   m_SSM->AddShape(shape);  }
    inline vtkPolyData* GetShape(unsigned int index)
    {   return m_SSM->GetShape(index);  }
    inline vtkPolyData* GetAlignedShape(unsigned int index)
    {   return m_SSM->GetProcrustesAlignedSurface(index);  }
    inline vtkPolyData* GetProcrustesAlignedSurface(unsigned int index)
    {   return m_SSM->GetProcrustesAlignedSurface(index);  }

    inline vtkPolyData* GetMeanShape()
    {
        if(m_modelled) return m_SSM->GetMeanShape();
        return NULL;
    }
    QPointer<milxQtModel> getMeanModel();
    inline int GetNumberOfModes()
    {
        if(m_modelled) return m_SSM->GetNumberOfModes();
        return -1;
    }
    inline int GetNumberOfShapes()
    {   return m_SSM->GetNumberOfShapes();   }
    inline QList< int > getCaseIDs()
    {   return m_caseIDs;   }
    virtual vtkDataSet* GetDataSet();

    virtual void createMenu(QMenu *menu);

    virtual void generateSSM();
    virtual void generateMeanModel(vtkSmartPointer<vtkPolyData> shape = NULL);
    void generateModels(const bool display = true);
    void generateAlignedModels(const bool display = true);
    virtual void generateModes();
    virtual void generateCollectionBasedOnMode();
    void generateVectorField();
    void generateTensorField();
    void generateCorrespondences();

    void mean();
    void aligned();
    void original();
    void modesAsVectors();
    void modesAsTensors();
    void modesAsCollection();
    void procrustes();
    void alignment();
    void alignedMeshes();
    void originalMeshes();
    void pointIds();
    void coordinates();
    void replaceOriginal();
    void correspondences();

    void compactness();
    void specificity();
    void generalisability();
    void eigenvalues();
    void eigenmodes();
    void parameters();

signals:
    void collectionAvailable(vtkPolyDataCollection*, QStringList&);
    void resultAvailable(milxQtRenderWindow*);
    void resultAvailable(milxQtModel*);

protected:
    bool m_loaded; 
    bool m_modelled; 
    bool m_meaned; 
    bool m_shapesModelled; 
    bool m_alignedShapesModelled; 
    bool m_modes; 
    bool m_vector; 
    bool m_tensor; 
    bool m_correspond; 
    int m_mode; 

    //----Context----
    QAction* actionMean; 
    QAction* actionAligned; 
    QAction* actionOriginal; 
    QAction* actionModesAsVectors; 
    QAction* actionModesAsTensors; 
    QAction* actionModesAsCollection; 
    //-------------
    QAction* actionAlignment; 
    QAction* actionOriginalMeshes; 
    QAction* actionAlignedMeshes; 
    QAction* actionPointIDs; 
    QAction* actionCoordinates; 
    QAction* actionCorrespond; 
    //-------------
    QAction* actionReplaceOriginal; 
    //----Plot----
    QMenu* plotMenu; 
    QAction* actionCompact; 
    QAction* actionSpecificity; 
    QAction* actionGeneralise; 
    QAction* actionValues; 
    QAction* actionModes; 
    QAction* actionParameters; 
    //----Procrustes----
    QMenu* alignMenu; 
    QActionGroup* alignGroup; 
    QAction* actionRigid; 
    QAction* actionSimilarity; 
    QAction* actionAffine; 

    ShapeModelType::Pointer m_StandardSSM; 
    ShapeModelBaseType::Pointer m_SSM; 

    QList< int > m_caseIDs; 
    QList< QPointer<milxQtModel> > m_models; 
    QList< QPointer<milxQtModel> > m_alignedModels; 

    QPointer<milxQtModel> m_meanModel; 
    QPointer<milxQtModel> m_modesVectorModel; 
    QPointer<milxQtModel> m_modesTensorModel; 
    QPointer<milxQtModel> m_correspondences; 

    virtual void updateLookupTable();
    virtual void reset();
    void outputSnapshots(const QString filename);
    void createActions();
    void createConnections();
    void setupTooltips();
    void contextMenuEvent(QContextMenuEvent *event);

private:

};

#endif // MILXQTSHAPEMODEL_H