RendererWidget.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2014 UJF-Grenoble 1, 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 RENDERERWIDGET_H
#define RENDERERWIDGET_H

// -- Core stuff
#include "CamiTKAPI.h"

// -- VTK stuff
#include <QVTKWidget.h>
#include <vtkSmartPointer.h>
#include <vtkInteractorStyle.h>

// -- VTK stuff classes
class vtkRenderer;
class vtkInteractorStyle;
class vtkPicker;
class vtkProp;
class vtkActor;
class vtkActor2D;
class vtkScalarBarActor;
class vtkEventQtSlotConnect;
class vtkCallbackCommand;
class vtkCamera;
class vtkAxesActor;
class vtkAnnotatedCubeActor;
class vtkScalarBarWidget;
class vtkUnsignedCharArray;
class vtkTextMapper;

namespace camitk {
// -- Core stuff classes
class GeometricObject;

class vtkInteractorStylePick : public vtkInteractorStyle {

public :

    static vtkInteractorStylePick * New();
    vtkTypeRevisionMacro ( vtkInteractorStylePick, vtkInteractorStyle );

    void PrintSelf ( ostream& os, vtkIndent indent );

    void SetAreaPicking(bool b);

    virtual void OnLeftButtonDown();

    virtual void OnLeftButtonUp();

    virtual void OnMouseMove();

protected :

    vtkInteractorStylePick();
    ~vtkInteractorStylePick();

    virtual void Pick();

    void RedrawRubberBand();

    int StartPosition[2];
    int EndPosition[2];

    int Moving;

    vtkUnsignedCharArray* PixelArray;

    bool AreaPicking;

// private :
//
//     vtkInteractorStylePick ( const vtkInteractorStylePick& ); // Not implemented
//     void operator= ( const vtkInteractorStylePick& ); // Not implemented

};

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

public :

    enum CameraOrientation {
        RIGHT_DOWN,  
        LEFT_UP,     
        RIGHT_UP,    
        LEFT_BACK,   
        BACK_DOWN,   

    };

    enum ControlMode {
        JOYSTICK,       
        TRACKBALL,      
        TRACKBALL_2D,   
        NONE
    };

//     enum InteractionMode {
//  CONTROL, ///< mouse interaction mode (\see ControlMode)
//  PICKING, ///< picking mode
//  AREA_PICKING ///< area picking mode
//     };

    enum MouseButtonState {
        NO_BUTTON,      
        LEFT_BUTTON,    
        MIDDLE_BUTTON,  
        RIGHT_BUTTON    
    };

    enum ScreenshotFormat {
        PNG = 0,  
        JPG,      
        BMP,      
        PS,       
        EPS,      
        PDF,      
        TEX,      
        SVG,      
        OBJ,      
        RIB,      
        VRML,     
        NOT_SUPPORTED
    };

    class ScreenshotFormatInfo {
    public:
        ScreenshotFormat type;
        QString extension;
        QString description;
        ScreenshotFormatInfo(ScreenshotFormat t, QString e, QString d) : type(t), extension(e), description(d) {}
        ScreenshotFormatInfo() : type(NOT_SUPPORTED), extension(""), description("Not supported") {}
    };

    RendererWidget(QWidget* parent = 0, ControlMode mode = RendererWidget::TRACKBALL);

    ~RendererWidget();


    //InteractionMode getInteractionMode() const;

    //void setInteractionMode(InteractionMode mode);

    void setAreaPicking(bool areaPicking);

    ControlMode getControlMode() const;

    void setControlMode(ControlMode mode);

    void setPicker(vtkSmartPointer<vtkAbstractPropPicker> woodyWood);

    void pick();

    void pickActor(int x, int y);

    void keyPressEvent(QKeyEvent* e);

    static const ScreenshotFormatInfo * getScreenshotFormatInfo(unsigned int);

    static const ScreenshotFormatInfo * getScreenshotFormatInfo(ScreenshotFormat);

    void screenshot(QString filename);

    void refresh();

    void setBackfaceCulling(bool);

    bool getBackfaceCulling() const;

    void setCameraOrientation( RendererWidget::CameraOrientation );

    RendererWidget::CameraOrientation getCameraOrientation(  ) const;

    void setLightFollowCamera(bool);

    bool getLightFollowCamera() const;

    void setPointSize(double size);

    double getPointSize() const;

    void rotateCamera(double angle, int axe);

    void resetCamera();

    void resetCamera(double *bounds);

    void getCameraSettings(double *position, double *focalPoint, double *viewUp);

    void setActiveCamera( vtkCamera * cam );

    vtkCamera * getActiveCamera();

    void getMouse3DCoordinates(double & x, double & y, double & z);

    void setBackgroundColor(double, double, double);

    void getBackgroundColor(double&, double&, double&);

    bool getGradientBackground();

    void setGradientBackground(bool);

    void toogle3DRedBlue();

    void toggleCopyright(bool);

    void toggleAxes(bool);

    void updateAxes();

    void toggleOrientationDecorations(bool);

    void setOrientationDecorationsLetters(QString letters[4]);


    void setColorScale(bool);

    bool getColorScale() const;

    void setColorScaleMinMax(double m, double M);

    void setColorScaleTitle(QString t);

    void computeVisiblePropBounds(double *bounds);



    void addProp(vtkSmartPointer<vtkProp> p, bool refresh=false);

    bool containsProp(vtkSmartPointer<vtkProp>);

    void removeProp(vtkSmartPointer<vtkProp> p, bool refresh=false);

    void actorTransform(vtkSmartPointer<vtkActor>, double *, int , double **, double *, double *);



protected slots:
    //void leftClick();

    //void leftRelease();

    //void rightClick();

    void startPicking();

    void endPicking();


signals :

    void actorPicked(vtkSmartPointer<vtkPicker>);

    void rightButtonPressed();



protected:

    virtual void mousePressEvent(QMouseEvent* event);

    virtual void mouseReleaseEvent(QMouseEvent* event);

    virtual void mouseMoveEvent(QMouseEvent* event);

protected :

    vtkSmartPointer<QVTKInteractor> interactor;

    vtkSmartPointer<vtkInteractorStyle> controlInteractorStyle;

    //InteractionMode interactionMode;

    ControlMode controlMode;


    void resetCameraSettings();

    vtkSmartPointer<vtkRenderer> renderer;

    bool backfaceCulling;

    CameraOrientation cameraOrientation;

    bool lightFollowCamera;

    double pointSize;

    bool rendering3DRedBlue;

    //vtkSmartPointer<vtkEventQtSlotConnect> connector;

    static void divertionCallback(vtkObject * caller, unsigned long eid, void *clientdata, void *calldata) {};

    vtkSmartPointer<vtkCallbackCommand> pickingButtonDiverter;

    bool pickingDiverter;

    vtkSmartPointer<vtkInteractorStylePick> pickInteractorStyle;


    static void buildScreenshotMap();

    static const ScreenshotFormatInfo * getScreenshotFormatInfo(QString);

    bool displayGradient;

    bool displayCopyright;

    vtkSmartPointer<vtkActor2D> copyrightTextActor;

    bool displayColorScale;

    vtkSmartPointer<vtkScalarBarActor> colorScale;

    vtkSmartPointer<vtkScalarBarWidget> colorBarWidget;

    vtkSmartPointer<vtkAxesActor> axes;

    vtkSmartPointer<vtkAnnotatedCubeActor> annotatedCube;

    vtkSmartPointer<vtkActor2D> orientationDecorationActors[4];
    vtkSmartPointer<vtkTextMapper> orientationDecorationsTextMapper[4];


};

}

#endif //RENDERERWIDGET_H