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
 
//**************************************************************************