MeshComponent.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2018 Univ. Grenoble Alpes, CNRS, TIMC-IMAG UMR 5525 (GMCAO)
 *
 * Visit http://camitk.imag.fr for more information
 *
 * This file is part of CamiTK.
 *
 * CamiTK is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * CamiTK is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with CamiTK.  If not, see <http://www.gnu.org/licenses/>.
 *
 * $CAMITK_LICENCE_END$
 ****************************************************************************/

#ifndef MESHCOMPONENT_H
#define MESHCOMPONENT_H

#include "Component.h"
#include "MeshSelectionModel.h"

#include <QTableView>

class vtkPointSet;
class vtkSelection;
class vtkSelectionNode;

class QTableView;
class QComboBox;

namespace camitk {

class MeshDataModel;
class MeshDataView;
class MeshSelectionView;

class CAMITK_API MeshComponent : public Component {
    Q_OBJECT
public:

    enum DataType {
        SCALARS = 1,  
        VECTORS = 2,  
        TENSORS = 4,  
        OTHERS = 8    
    };

    enum FieldType {
        POINTS = 1,  
        CELLS = 2,   
        MESH = 4     
    };

    enum SpecificRepresentation {
        VECTOR_3D,          
        NORM,               
        FIRST_COMPONENT,    
        SECOND_COMPONENT,   
        THIRD_COMPONENT     
        //@TODO COLOR,      ///< 3D data are represented as a specific color @TODO need to build a specific color map LUT containing as many colors as there is point/cell
    };

    enum VectorRepresentation {
        HEDGE_HOG,         
        ARROW,             
        UNSCALED_ARROW       
    };

    MeshComponent(const QString& file);

    MeshComponent(vtkSmartPointer<vtkPointSet> aPointSet, const QString& name);

    MeshComponent(Component* parentComponent, vtkSmartPointer<vtkPointSet> aPointSet, const QString& name);

    ~MeshComponent() override;

    void pointPicked(vtkIdType pointId, bool) override;

    void cellPicked(vtkIdType cellId, bool) override;

    vtkIdType getPickedPointId();

    vtkIdType getPickedCellId();

    void updateProperty(QString, QVariant) {}

    unsigned int getNumberOfPropertyWidget() override;

    QWidget* getPropertyWidgetAt(unsigned int i = 0) override;

    QPixmap getIcon() override;

    QList< vtkSmartPointer<vtkSelectionNode> >& getSelections();

    unsigned int getNumberOfSelections() const;

    vtkSmartPointer<vtkSelection> getActiveSelection() const;

    vtkSmartPointer<vtkSelectionNode> getSelection(const QString& name) const;

    vtkSmartPointer<vtkSelectionNode> getSelectionAt(unsigned int index) const;

    int getSelectionIndex(const QString& name) const;

    virtual int addSelection(const QString& name, int fieldType, int contentType,  vtkSmartPointer< vtkAbstractArray > array, MeshSelectionModel::InsertionPolicy policy = MeshSelectionModel::REPLACE);

    virtual int addToSelectedSelection(int fieldType, int contentType,  vtkSmartPointer< vtkAbstractArray > array, MeshSelectionModel::InsertionPolicy policy = MeshSelectionModel::REPLACE);

    int getNumberOfDataArray(int fieldFlag = POINTS | CELLS);

    vtkSmartPointer<vtkDataArray> getDataArray(FieldType fieldType, const QString& arrayName);

    vtkSmartPointer<vtkDataArray> getDataArray(FieldType fieldType, int index);

    void addDataArray(FieldType fieldType, const QString& name, vtkSmartPointer<vtkDataArray> data);

    void removeDataArray(FieldType fieldType, const QString& name);

    void addPointData(const QString& name, vtkSmartPointer<vtkDataArray> data);

    void addCellData(const QString& name, vtkSmartPointer<vtkDataArray> data);

    MeshDataModel* getDataModel();

    vtkSmartPointer<vtkFieldData> getFieldData(FieldType);

    bool getDataRepresentationVisibility(FieldType, const QString&) ;

    void setDataRepresentationVisibility(FieldType, const QString&, bool);

    void setDataRepresentationOff(int dataType = SCALARS | VECTORS | TENSORS);

    void setVectorRepresentation(VectorRepresentation);

    static const QMap< int, QString >& getFieldNames();

    static const QString getFieldName(const FieldType);

    static const QMap< int, QString >& getDataTypeNames();

    static const QString getDataTypeName(const DataType);

    static const DataType getDataType(vtkSmartPointer<vtkDataArray>);

    static const QString getDataTypeName(vtkSmartPointer<vtkDataArray>);

    static const QString getSpecificRepresentationName(const SpecificRepresentation);

protected:

    virtual void initRepresentation(vtkSmartPointer<vtkPointSet>);

    virtual void initSelection();

    virtual void initData();

    virtual void initDynamicProperties();

protected slots:

    void changeSelectedSelection(const QItemSelection& selected, const QItemSelection& deselected);

    void removeSelectedSelections();

    void removeSelectedData();

    void displayTypePolicyChanged(int);

    void vectorRepresentationPolicyChanged(int);

private:

    void initRepresentation() {}

    void init();

    vtkIdType pickedPointId;

    vtkIdType pickedCellId;

    vtkSmartPointer<vtkSelection> currentSelection;

    QList< vtkSmartPointer<vtkSelectionNode> > selectionList;

    MeshSelectionModel* selectionModel;

    MeshSelectionView* selectionView;

    QWidget* selectionWidget;

    QAction* removeSelections;

    QAction* mergeSelection;

    QAction* inspectSelection;

    QComboBox* insertionPolicyBox;

    MeshDataModel* dataModel;

    MeshDataView* dataView;

    QWidget* dataWidget;

    QComboBox* displayTypePolicyBox;

    QComboBox* vectorRepresentationPolicyBox;

    QMap<QString, vtkSmartPointer<vtkDataArray> > specific3DDataRepresentation;

    unsigned int numberOfCellDataSpecificRepresentation;

    QMap<vtkSmartPointer<vtkDataArray>, bool> dataRepresentationVisibility;

    QStringList vectorActors;

    void createDataRepresentation(FieldType, const QString&, SpecificRepresentation representation = VECTOR_3D) ;

    // Returns the very specific name used for the additional prop that represent this data
    const QString getDataPropName(FieldType, const QString&);

    void setScalarDataRepresentationOn(vtkSmartPointer<vtkDataArray>);

    static QMap< int, QString > initFieldNames();

    static QMap< int, QString > initDataNames();

    QAction* removeData;

    QAction* inspectData;

};

}

#endif // MESHCOMPONENT_H