InteractiveViewer.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 INTERACTIVE_VIEWER_H
#define INTERACTIVE_VIEWER_H

// -- Core stuff
#include "CamiTKAPI.h"
#include "Component.h"
#include "Viewer.h"
#include "RendererWidget.h"

//-- QT stuff
#include <QFrame>
#include <QPushButton>
#include <QWidgetAction>
#include <QComboBox>
class QToolBar;

//-- vtk stuff
#include <vtkType.h>
#include <vtkSmartPointer.h>

//-- vtk stuff classes
class vtkActor;
class vtkPicker;
class vtkProp;
class vtkObject;
class vtkCamera;
class vtkEventQtSlotConnect;

namespace camitk {
// -- Core stuff classes
class SliderSpinBoxWidget;
class GeometricObject;
class InterfaceGeometry;
class InterfaceBitMap;
class InteractiveViewer;
class MeshDataFilterModel;
class PropertyObject;
class Property;

using vtkSmartPointerCamera = vtkSmartPointer<vtkCamera>;

class InteractiveViewerFrame : public QFrame {
public:
    InteractiveViewerFrame(QWidget* parent, InteractiveViewer* s3D) : QFrame(parent), myInteractiveViewer(s3D) {}

    void keyPressEvent(QKeyEvent*) override;

protected:
    InteractiveViewer* myInteractiveViewer;
};

class CAMITK_API InteractiveViewer : public Viewer {
    Q_OBJECT
    Q_ENUMS(HighlightMode RendererWidget::ControlMode RendererWidget::CameraOrientation)    // so that it can be used in property editor

public:
    enum ViewerType {
        SLICE_VIEWER,     
        GEOMETRY_VIEWER  
    };

    enum PickingMode {
        PIXEL_PICKING,  
        POINT_PICKING,  
        CELL_PICKING,   
        AREA_CELL_PICKING, 
        AREA_POINT_PICKING, 
        NO_PICKING     
    };

    enum HighlightMode {
        OFF,            
        SELECTION,      
        SELECTION_ONLY 
    };


    static InteractiveViewer* getNewViewer(QString, ViewerType type);

    static InteractiveViewer* getViewer(QString);

    static InteractiveViewer* get3DViewer();

    static InteractiveViewer* getAxialViewer();

    static InteractiveViewer* getCoronalViewer();

    static InteractiveViewer* getSagittalViewer();

    static InteractiveViewer* getArbitraryViewer();

    ~InteractiveViewer() override;

    QString getName() const;

    unsigned int numberOfViewedComponent() override;

    void refresh(Viewer* whoIsAsking = nullptr) override;

    QWidget* getWidget(QWidget* parent) override;

    QObject* getPropertyObject() override;

    QMenu* getMenu() override;

    QToolBar* getToolBar() override;


    void refreshRenderer();

    void resetCamera();

    void setActiveCamera(QString cameraName);

    vtkSmartPointer<vtkCamera> getCamera(QString cameraName = "default");

    void screenshot(QString);

public slots:
    void screenshot();

public:
    virtual void setGradientBackground(bool);

    virtual void setBackgroundColor(QColor);

public slots:
    void setBackfaceCulling(bool);

    void setScreenshotAction(bool);

public:
    // bool getBackfaceCulling() const;

public slots:
    void setLinesAsTubes(bool tubes);

public:
    void keyPressEvent(QKeyEvent* e);

    virtual void setHighlightMode(InteractiveViewer::HighlightMode);

    inline RendererWidget* getRendererWidget() {
        return rendererWidget;
    }



    void setColorScale(bool);

    bool getColorScale() const;

    void setColorScaleMinMax(double m, double M);

    void setColorScaleTitle(QString t);

    void initPicking(PickingMode);

    void getBoundsOfSelected(double* bound);

    void getBounds(double* bound);

    void setSideFrameVisible(bool);

public slots:

    void sliderChanged(int);

    void xAngleChanged(double angle);

    void yAngleChanged(double angle);

    void zAngleChanged(double angle);

    void toggleCopyright(bool);

protected:

    InteractiveViewer(QString& name, ViewerType type);

    static QMap<QString, InteractiveViewer*> viewers;

    static QString defaultNames[5];




    void initSettings();

    ViewerType myType;

    void toggleInterpolation();

    void updateSelectionDisplay(Component*);

    QMultiMap<Component*, vtkSmartPointer<vtkProp> > actorMap;

    void addActor(Component*, vtkSmartPointer<vtkProp>);

    void removeAllActors(Component*);

    unsigned int displayedTopLevelComponents;

    QMap<QString, vtkSmartPointerCamera> cameraMap;

    RendererWidget* rendererWidget;

    SliderSpinBoxWidget* sliceSlider;

    InteractiveViewerFrame* frame;

    QFrame* sideFrame;

    QToolBar* screenshotActionMenu;

    friend void InteractiveViewerFrame::keyPressEvent(QKeyEvent* e);

    QMenu* viewerMenu;

    QToolBar* viewerToolBar;

    QComboBox* scalarDataComboBox;

    MeshDataFilterModel* scalarDataModel;

    void initActions();

    void updateActions();

    QAction* screenshotAction;

    QMenu* renderingMenu;
    QAction* surfaceAction;
    QAction* wireframeAction;
    QAction* pointsAction;
    QAction* colorAction;
    QAction* glyphAction;
    QWidgetAction* scalarDataColorAction;

    QAction* highlightSelectionAction;
    QAction* highlightSelectionOnlyAction;
    QAction* highlightOffAction;

    QAction* controlModeTrackballAction;
    QAction* controlModeJoystickAction;

    QAction* cameraOrientationRightDownAction;
    QAction* cameraOrientationLeftUpAction;
    QAction* cameraOrientationRightUpAction;

    QAction* backgroundColorAction;

    QAction* toggleAxesAction;

    QAction* toggleOrientationDecorationsAction;

    QAction* toggleCopyrightAction;

    QAction* toggleLabelAction;

    QAction* toggleLinesAsTubesAction;

    QAction* toggleBackfaceCullingAction;

    QAction* toggleScreenshotAction;

    QAction* pickPointAction;
    QAction* pickCellAction;
    QAction* pickCellRegionAction;
    QAction* pickPointRegionAction;



    std::vector <Component*> pickedComponent;

    PickingMode pickingMode;

    bool isPicking;

    bool isChangingSlice;

    bool pickingEffectIsSelecting;

    bool pickingEffectUpdated;

    vtkSmartPointer<vtkEventQtSlotConnect> connector;


    QString whatsThis;

    bool oddWhatsThis;

    void initWhatsThis();

    void startWhatsThisSection(const QString& title = "");

    void endWhatsThisSection();

    void addWhatsThisItem(const QString& key, const QString& description);


    PropertyObject* propertyObject;

    Property* highlightModeProperty;

    Property* backgroundColorProperty;

    Property* backgroundGradientColorProperty;

    Property* linesAsTubesProperty;

    Property* backfaceCullingProperty;

    Property* screenshotActionProperty;

    Property* pointSizeProperty;

    void createProperties();

    bool eventFilter(QObject* object, QEvent* event) override;


protected slots:
    void renderingActorsChanged();

    void highlightModeChanged(QAction* selectedAction);

    void cameraOrientationChanged(QAction* selectedAction);

    void viewControlModeChanged(QAction*);

    void backgroundColor();

    void toggleAxes(bool);

    void toggleOrientationDecorations(bool);

    void pickingModeChanged(QAction*);

    void picked();

    void rightClick();

    void setLabel(bool);

    void setGlyph(bool);




};

}

Q_DECLARE_METATYPE(camitk::InteractiveViewer::HighlightMode)

#endif

//**************************************************************************