InteractiveViewer.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2025 Univ. Grenoble Alpes, CNRS, Grenoble INP - UGA, TIMC, 38000 Grenoble, France
 *
 * 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"
#include "InteractiveViewerFrame.h"
 
//-- QT stuff
#include <QPushButton>
#include <QWidgetAction>
#include <QComboBox>
class QToolBar;
class QFrame;
 
//-- 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 PropertyObject;
class Property;
class FrameOfReference;
 
using vtkSmartPointerCamera = vtkSmartPointer<vtkCamera>;
 
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 {
        LOCATION_PICKING = 0,   
        POINT_PICKING    = 1,   
        CELL_PICKING     = 2,   
        AREA_POINT_PICKING = 3, 
        AREA_CELL_PICKING  = 4, 
        PIXEL_PICKING      = 5, 
        NO_PICKING              
    };
 
    enum HighlightMode {
        OFF,            
        SELECTION,      
        SELECTION_ONLY  
    };
 
    enum class CameraOrientation {
        XY, // Show the XY plane (camera perpendicular to Z axis)
        XZ, // Show the XZ plane (camera perpendicular to Y axis)
        YZ, // Show the YZ plane (camera perpendicular to X axis)
        AXIAL, // Shows the Axial plane if the current FrameOfReference has anatomicalOrientation information
        CORONAL, // Shows the Coronal plane if the current FrameOfReference has anatomicalOrientation information
        SAGITTAL, // Shows the Sagittal plane if the current FrameOfReference has anatomicalOrientation information
        CUSTOM // Any other orientation (e.g. freely moving camera in the 3D viewer)
    };
 
 
    Q_INVOKABLE InteractiveViewer(QString& name, camitk::InteractiveViewer::ViewerType type);
 
    virtual ~InteractiveViewer() override;
 
    QString getName() const;
 
    void refresh(Viewer* whoIsAsking = nullptr) override;
 
    QWidget* getWidget() override;
 
    PropertyObject* getPropertyObject() override;
 
    QMenu* getMenu() override;
 
    QToolBar* getToolBar() override;
 
 
 
    virtual void setFrame(const std::shared_ptr<FrameOfReference>& frame);
 
    virtual const FrameOfReference* getFrame() const;
 
 
 
    void resetCamera();
 
    void setActiveCamera(QString cameraName);
 
    void setCameraOrientation(InteractiveViewer::CameraOrientation orientation);
    InteractiveViewer::CameraOrientation getCameraOrientation();
 
 
    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 setFxaaAntialiasing(bool);
 
    void setScreenshotAction(bool);
 
    void setLinesAsTubes(bool tubes);
 
public:
    void keyPressEvent(QKeyEvent* e);
 
    virtual void setHighlightMode();
 
    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 toggleLogo(bool);
 
 
protected:
 
    void init();
 
 
    void initSettings();
 
    ViewerType myType;
 
    void toggleInterpolation();
 
    void resetLUT();
 
    void updateSelectionDisplay(Component*);
 
    QMultiMap<Component*, vtkSmartPointer<vtkProp> > actorMap;
 
    QMap<vtkSmartPointer<vtkActor2D>, QVector3D> transformed2DActors;
 
    std::shared_ptr<FrameOfReference> frameOfReference;
 
    void addActor(Component*, vtkSmartPointer<vtkProp>, const FrameOfReference* sourceFrame = nullptr);
 
    void removeAllActors(Component*);
 
    void updateCurrentFrameOfReferenceColorIndicator();
 
    unsigned int displayedTopLevelComponents;
 
    QMap<QString, vtkSmartPointerCamera> cameraMap;
 
    RendererWidget* rendererWidget;
 
    SliderSpinBoxWidget* sliceSlider;
 
    InteractiveViewerFrame* myWidget;
 
    QFrame* sideFrame;
 
    QToolBar* screenshotActionMenu;
 
    friend void InteractiveViewerFrame::keyPressEvent(QKeyEvent* e);
 
    QMenu* viewerMenu;
 
    QToolBar* viewerToolbar;
 
    void initActions();
 
    void updateActions();
 
    // Combobox in the toolbar to choose the orientation
    QComboBox* orientationCombo;
 
    // Combobox in the toolbar to choose the picking mode
    QComboBox* pickingCombo;
 
    QAction* screenshotAction;
 
    QMenu* renderingMenu;
    QAction* surfaceAction;
    QAction* wireframeAction;
    QAction* pointsAction;
    QAction* colorAction;
    QAction* glyphAction;
 
    QAction* highlightSelectionAction;
    QAction* highlightSelectionOnlyAction;
    QAction* highlightOffAction;
 
    QAction* controlModeTrackballAction;
    QAction* controlModeJoystickAction;
 
    QAction* backgroundColorAction;
 
    QAction* toggleAxesAction;
 
    QAction* toggleOrientationDecorationsAction;
 
    QAction* toggleLogoAction;
 
    QAction* toggleLabelAction;
 
    QAction* toggleLinesAsTubesAction;
 
    QAction* toggleBackfaceCullingAction;
 
    QAction* toggleFxaaAntialiasingAction;
 
    QAction* toggleScreenshotAction;
 
    QAction* pickPointAction;
    QAction* pickCellAction;
    QAction* pickCellRegionAction;
    QAction* pickPointRegionAction;
    QAction* pickLocationAction;
 
 
 
    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* cameraOrientationProperty;
 
 
    Property* backgroundColorProperty;
 
    Property* backgroundGradientColorProperty;
 
    Property* linesAsTubesProperty;
 
    Property* backfaceCullingProperty;
 
    Property* fxaaAntialiasingProperty;
 
    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);
 
};
 
} // namespace camitk
 
Q_DECLARE_METATYPE(camitk::InteractiveViewer::HighlightMode)
 
#endif
 
//**************************************************************************