InteractiveViewer.cpp

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

// -- Core stuff
#include "Action.h"
#include "RendererWidget.h"
#include "InteractiveViewer.h"
#include "SliderSpinBoxWidget.h"
#include "Log.h"
#include "MeshComponent.h"
#include "MeshDataModel.h"
#include "PropertyObject.h"

// -- stl stuff

// -- Qt stuff
#include <QHBoxLayout>
#include <QKeyEvent>
#include <QFileDialog>
#include <QWhatsThis>
#include <QColorDialog>
#include <QToolBar>
#include <QSettings>
#include <QWidgetAction>
#include <QTextStream>
#include <QSplitter>

// -- vtk stuff
#include <vtkDataSetMapper.h>
#include <vtkImageActor.h>
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkUnstructuredGrid.h>
#include <vtkTransform.h>
#include <vtkFloatArray.h>
#include <vtkIdTypeArray.h>
#include <vtkVertex.h>
#include <vtkCellData.h>
#include <vtkCallbackCommand.h>
#include <vtkActor2D.h>
#include <vtkActor.h>
#include <vtkActorCollection.h>
#include <vtkCamera.h>
#include <vtkPointPicker.h>
#include <vtkCellPicker.h>
#include <vtkProp3DCollection.h>
#include <vtkEventQtSlotConnect.h>
#include <vtkSelectionNode.h>
#include <vtkSelection.h>
#include <vtkAreaPicker.h>
#include <vtkRenderedAreaPicker.h>
#include <vtkHardwareSelector.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRendererCollection.h>
#include <vtkExtractSelectedFrustum.h>
#include <vtkPointData.h>
#include <vtkImageProperty.h>

namespace camitk {
// ---------------------- singleton ----------------------------
/// the register containing all the viewers (static instantiation, global variable, but global only for this file)
QMap<QString, InteractiveViewer*> InteractiveViewer::viewers;
QString InteractiveViewer::defaultNames[5] = {QString("3DViewer"), QString("axialViewer"), QString("coronalViewer"), QString("sagittalViewer"), QString("arbitraryViewer") };

InteractiveViewer* InteractiveViewer::getNewViewer(QString name, ViewerType type) {
    if (!viewers.contains(name)) {
        //-- Congratulation, you got yourself a new InteractiveViewer! (but are you really sure you need it?)
        viewers[name] = new InteractiveViewer(name, type);
    }

    return viewers.value(name);
}

InteractiveViewer* InteractiveViewer::getViewer(QString name) {
    const std::string nameChar = name.toStdString();

    if (viewers.contains(name)) {
        return viewers.value(name);
    }
    else {
        //-- if this is a default scene, get a new one if it does not exists
        // perform the singleton instantiation here!
        unsigned int i = 0;
        // special case, the first viewer is a 3D viewer

        if (name == defaultNames[i]) {
            return getNewViewer(defaultNames[i], GEOMETRY_VIEWER);
        }

        InteractiveViewer* singletonInstance = nullptr;

        i++;

        while (i < 6 && !singletonInstance) {
            if (name == defaultNames[i]) {
                singletonInstance = getNewViewer(defaultNames[i], SLICE_VIEWER);
            }

            i++;
        }

        // default orientation for axial, sagittal and coronal is not the same
        // See Image Reorientation Action Documentation...
//        singletonInstance->toggleOrientationDecorations(false);
        if (name ==  defaultNames[1]) {   // Axial Viewer
            singletonInstance->getRendererWidget()->setCameraOrientation(RendererWidget::RIGHT_DOWN);
            QString letters[4] = {QString("R"), QString("L"), QString("A"), QString("P") };
            singletonInstance->getRendererWidget()->setOrientationDecorationsLetters(letters);
            singletonInstance->toggleOrientationDecorations(true);
            singletonInstance->getRendererWidget()->getActiveCamera()->ParallelProjectionOn();
        }
        else
            if (name ==  defaultNames[2]) {    // Coronal Viewer
                singletonInstance->getRendererWidget()->setCameraOrientation(RendererWidget::LEFT_BACK);
                QString letters[4] = {QString("R"), QString("L"), QString("S"), QString("I") };
                singletonInstance->getRendererWidget()->setOrientationDecorationsLetters(letters);
                singletonInstance->toggleOrientationDecorations(true);
                singletonInstance->getRendererWidget()->getActiveCamera()->ParallelProjectionOn();
            }
            else
                if (name ==  defaultNames[3]) {    // Sagittal Viewer
                    singletonInstance->getRendererWidget()->setCameraOrientation(RendererWidget::BACK_DOWN);
                    QString letters[4] = {QString("A"), QString("P"), QString("S"), QString("I") };
                    singletonInstance->getRendererWidget()->setOrientationDecorationsLetters(letters);
                    singletonInstance->toggleOrientationDecorations(true);
                    singletonInstance->getRendererWidget()->getActiveCamera()->ParallelProjectionOn();
                }
                else
                    if (name ==  defaultNames[4]) {    // Arbitrary Viewer
			            singletonInstance->getRendererWidget()->setCameraOrientation ( RendererWidget::RIGHT_DOWN );
                        singletonInstance->toggleOrientationDecorations(true);
			            singletonInstance->getRendererWidget()->getActiveCamera()->ParallelProjectionOn();
                    }


        return singletonInstance;
    }
}

InteractiveViewer* InteractiveViewer::get3DViewer() {
    return getViewer(defaultNames[0]);
}

InteractiveViewer* InteractiveViewer::getAxialViewer() {
    return getViewer(defaultNames[1]);
}

InteractiveViewer* InteractiveViewer::getCoronalViewer() {
    return getViewer(defaultNames[2]);
}

InteractiveViewer* InteractiveViewer::getSagittalViewer() {
    return getViewer(defaultNames[3]);
}

InteractiveViewer* InteractiveViewer::getArbitraryViewer() {
    return getViewer(defaultNames[4]);
}

// ---------------------- constructor ----------------------------
InteractiveViewer::InteractiveViewer(QString& name, ViewerType type) : Viewer(name) {

    myType = type;

    // frame is NULL, but the rendererWidget and sliceSlider have to be instantiated
    // (even if the InteractiveViewer is not visible yet, it can still do some actions)
    frame = nullptr;

    //-- create and init the RendererWidget object for display and interactions

    if (myType == SLICE_VIEWER) {
        // block rotations (interactions)
        rendererWidget = new RendererWidget(frame, RendererWidget::TRACKBALL_2D);
        sliceSlider = new SliderSpinBoxWidget(frame);
    }
    else {
        // classic 3D view
        rendererWidget = new RendererWidget(frame);
        sliceSlider = nullptr;
    }

    cameraMap.insert("default", rendererWidget->getActiveCamera());

    //-- create the slice slider if needed
    viewerMenu = nullptr;
    viewerToolbar = nullptr;
    screenshotActionMenu = nullptr;
    displayedTopLevelComponents = 0;

    //-- set picking mode
    pickingEffectIsSelecting = true; // default effect
    isPicking = false; // by default, viewer is not picking

    if (myType == SLICE_VIEWER) {
        // by default, the 2D scenes are set to pick slice pixels
        initPicking(InteractiveViewer::PIXEL_PICKING);
    }
    else {
        // no picking
        initPicking(InteractiveViewer::NO_PICKING);
    }

    //-- current interaction is not changing slice
    isChangingSlice = false;

    //-- connection for selection
    connector = vtkSmartPointer<vtkEventQtSlotConnect>::New();
    connector->Connect(rendererWidget->GetInteractor(), vtkCommand::EndPickEvent, this, SLOT(picked()));

    // create the different properties of the viewers
    createProperties();

    // init from settings
    initSettings();
}

// ---------------------- destructor ----------------------------
InteractiveViewer::~InteractiveViewer() {
    viewers.remove(this->getName());

    delete viewerMenu;
    viewerMenu = nullptr;

    delete viewerToolbar;
    viewerToolbar = nullptr;

    delete frame;
    frame = nullptr;
}

// ---------------------- initSettings ----------------------------
void InteractiveViewer::initSettings() {
    QSettings& settings = Application::getSettings();
    settings.beginGroup(Application::getName() + ".InteractiveViewer." + objectName().simplified().replace(" ", ""));

    // the background color
    QColor bg;
    if (myType == GEOMETRY_VIEWER) {
        // default is white
        bg.setNamedColor(settings.value("backgroundColor", QColor::fromRgbF(1.0, 1.0, 1.0)).toString());
        propertyObject->setProperty(backgroundColorProperty->getName().toStdString().c_str(), bg);
    }
    else {
        // default is black
        bg.setNamedColor(settings.value("backgroundColor", QColor::fromRgbF(0.0, 0.0, 0.0)).toString());
    }

    // the gradient background
    bool gradientBackground;

    if (myType == GEOMETRY_VIEWER) {
        gradientBackground = settings.value("gradientBackground", true).toBool();
        propertyObject->setProperty(backgroundGradientColorProperty->getName().toStdString().c_str(), gradientBackground);
    }
    else {
        gradientBackground = settings.value("gradientBackground", false).toBool();
    }

    // the control mode
    RendererWidget::ControlMode controlMode;

    if (myType == GEOMETRY_VIEWER) {
        controlMode = (RendererWidget::ControlMode) settings.value("controlMode", RendererWidget::TRACKBALL).toInt();
    }
    else {
        controlMode = (RendererWidget::ControlMode) settings.value("controlMode", RendererWidget::TRACKBALL_2D).toInt();
    }

    rendererWidget->setControlMode(controlMode);

    // the initial camera orientation
    RendererWidget::CameraOrientation cameraOrientation;
    cameraOrientation = (RendererWidget::CameraOrientation) settings.value("cameraOrientation", rendererWidget->getCameraOrientation()).toInt();
    rendererWidget->setCameraOrientation(cameraOrientation);

    // highlight mode
    HighlightMode highlightMode = (HighlightMode) settings.value("highlightMode", SELECTION).toInt();
    propertyObject->setProperty(highlightModeProperty->getName().toStdString().c_str(), highlightMode);

    // lines as tubes
    bool linesAsTubes = settings.value("linesAsTubes", false).toBool();    // default false
    propertyObject->setProperty(linesAsTubesProperty->getName().toStdString().c_str(), linesAsTubes);

    // screenshot Action visibility
    bool screenshotActionVisible = settings.value("screenshotActionVisible", false).toBool();
    propertyObject->setProperty(screenshotActionProperty->getName().toStdString().c_str(), screenshotActionVisible);

    // backface culling
    bool backfaceCulling = settings.value("backfaceCulling", false).toBool();    // default false
    propertyObject->setProperty(backfaceCullingProperty->getName().toStdString().c_str(), backfaceCulling);

    // point size
    double pointSize = settings.value("pointSize", 4.0).toDouble();
    propertyObject->setProperty(pointSizeProperty->getName().toStdString().c_str(), pointSize);

    // orientation letters
    if (myType == GEOMETRY_VIEWER) {
        rendererWidget->toggleOrientationDecorations(false);
    }

    settings.endGroup();

    // -- propertyObject event filter delegation
    // This method changes the properties, which will automatically trigger the
    // QEvent::DynamicPropertyChange
    // This in turns will call eventFilter each time
    // As the settings group is opened, it will generate nested beginGroup
    // Therefore the event filter should only be installed at the end,
    // when all properties are set.

    // propertyObject is monitored by the 3D viewer instance (this) when its properties change
    // All event filter on the property object are delegated to the InteractiveViewer class
    // @see eventFilter()
    if (myType == GEOMETRY_VIEWER) {
        propertyObject->installEventFilter(this);
        // trigger change for all the values
        eventFilter(this, new QEvent(QEvent::DynamicPropertyChange));
    }


}

// ---------------------- getWidget ----------------------------
QWidget* InteractiveViewer::getWidget(QWidget* parent) {
    if (!frame) {

        //-- create the actions
        initActions();

        //-- build the frame
        frame = new InteractiveViewerFrame(parent, this);
        frame->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);

        //-- handle layout
        auto* myLayout = new QHBoxLayout(frame);
        auto* horizontalSplitter = new QSplitter(frame);
        myLayout->addWidget(horizontalSplitter);
        myLayout->setSpacing(0);
        myLayout->setMargin(0);

        //-- show the renderer!
        rendererWidget->setParent(frame);
        rendererWidget->show();
        horizontalSplitter->addWidget(rendererWidget);

        connect(rendererWidget, SIGNAL(rightButtonPressed()), this, SLOT(rightClick()));

        //-- create the slider if needed
        if (myType == SLICE_VIEWER) {
            auto* rightSideLayout = new QVBoxLayout;
            rightSideLayout->setSpacing(0);
            rightSideLayout->setMargin(0);

            // add snapshot widget
            screenshotActionMenu = new QToolBar(rendererWidget);
            screenshotActionMenu->addAction(screenshotAction);
            screenshotActionMenu->setEnabled(true);
            screenshotActionMenu->setVisible(false);
            screenshotActionMenu->layout()->setSpacing(0);
            screenshotActionMenu->layout()->setMargin(0);

            rightSideLayout->addWidget(screenshotActionMenu, 0, Qt::AlignCenter);

            // add slider
            sliceSlider->setParent(frame);

            // connect the slider to this scene
            connect(sliceSlider, SIGNAL(valueChanged(int)), this, SLOT(sliderChanged(int)));
            rightSideLayout->addWidget(sliceSlider);
            // add the right side layout
            sideFrame = new QFrame;
            /*sideFrame->setSpacing ( 0 );
            sideFrame->setMargin ( 0 );
            */
            sideFrame->setLayout(rightSideLayout);
            QSizePolicy sideFrameSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
            sideFrame->setSizePolicy(sideFrameSizePolicy);
            sideFrame->setMinimumWidth(15);
            sideFrame->setMaximumWidth(60);

            //myLayout->addWidget ( sideFrame );
            horizontalSplitter->addWidget(sideFrame);
        }
        else {
            sideFrame = nullptr;
        }

        // do this for receiving key-events
        frame->setFocusPolicy(Qt::ClickFocus);

        // TODO A feature disappeared when switching to vtk5...
        // use a vtkOutlineSource to highlight the picked actor (show-hide picked actor bounding box</td>
        // set the what's this text
        initWhatsThis();


        startWhatsThisSection("Mouse bindings");
        addWhatsThisItem("Left", "Rotate");
        addWhatsThisItem("Ctrl+Left", "Pick (flip selection flag for point/cell)");
        addWhatsThisItem("Shift+Left", "Translate selection");
        addWhatsThisItem("Middle", "Pan");
        addWhatsThisItem("Right", "Zoom");
        endWhatsThisSection();
        startWhatsThisSection("Keyboard bindings (upper or lower case)");
        addWhatsThisItem("3", "Toggle 3D red/blue stereo display");
        addWhatsThisItem("A", "Toggle view axes");
        addWhatsThisItem("C", "Toggle color scale");
        addWhatsThisItem("F", "Toggle backface culling");
        addWhatsThisItem("I", "Toggle image interpolation on slices");
        addWhatsThisItem("J", "Joystick interaction mode");
        addWhatsThisItem("L", "Toggle view labels");
        addWhatsThisItem("Alt+L", "Toggle light follows camera");
        addWhatsThisItem("Alt+P", "Toggle point rendering");
        addWhatsThisItem("P", "Pick (flip selection flag for point/cell)");
        addWhatsThisItem("R", "Reset Image Interactor Look Up Table");
        addWhatsThisItem("S", "Take a screenshot");
        addWhatsThisItem("Alt+S", "Toggle surfacerendering");
        addWhatsThisItem("T", "Trackball interaction mode");
        addWhatsThisItem("Alt+W", "Toggle wireframe rendering");
        endWhatsThisSection();


        startWhatsThisSection();
        addWhatsThisItem("SPACE", "Update/refresh view");
        addWhatsThisItem("HOME", "Reset camera to default view point or so that everything is visible");
        addWhatsThisItem("LEFT", "Turn -5&deg; around camera Y axis");
        addWhatsThisItem("Ctrl+LEFT", "Turn -90&deg; around camera Y axis");
        addWhatsThisItem("RIGHT", "Turn 5&deg; around camera Y axis");
        addWhatsThisItem("Ctrl+RIGHT", "Turn 90&deg; around camera Y axis");
        addWhatsThisItem("UP", "Turn -5&deg; around camera X axis");
        addWhatsThisItem("Ctrl+UP", "Turn -90&deg; around camera X axis");
        addWhatsThisItem("DOWN", "Turn 5&deg; around camera X axis");
        addWhatsThisItem("Ctrl+DOWN", "Turn 90&deg; around camera X axis");
        addWhatsThisItem("+", "Move slider a step above");
        addWhatsThisItem("-", "Move slider a step below");
        addWhatsThisItem("PAGE Up", "Move slider a page above");
        addWhatsThisItem("PAGE Down", "Move slider a page down");
        addWhatsThisItem("ESC", "Clear current selection");
        endWhatsThisSection();


        startWhatsThisSection("Other Shortcuts");
        addWhatsThisItem("F1", "Show this help (i.e. the what's this help)");
        addWhatsThisItem("F2", "Print debugging information on console");
        endWhatsThisSection();

        // add the text as whatsThis
        frame->setWhatsThis(whatsThis);
    }
    else {
        if (frame->parentWidget() != parent) {
            bool isVisible = frame->isVisible();
            frame->setParent(parent);
            frame->setVisible(isVisible);
        }
    }

    return frame;
}

// ---------------------- getPropertyObject ----------------------------
QObject* InteractiveViewer::getPropertyObject() {
    if (myType == GEOMETRY_VIEWER) {
        return propertyObject;
    }
    else {
        return nullptr;
    }
}

// ---------------------- getName ----------------------------
QString InteractiveViewer::getName() const {
    return objectName();
}

// ---------------- numberOfViewedComponent ----------------
unsigned int InteractiveViewer::numberOfViewedComponent() {
    return actorMap.size();
}

// ---------------------- refresh ----------------------------
void InteractiveViewer::refresh(Viewer* v) {

    //-- do not refresh if the widget was not created
    if (!frame) {
        return;
    }

    //-- first remove non active Component (if InteractiveViewer was called by itself, no need to do that)
    if (v != this) {
        //-- check all present
        QList<Component*> compRendered = actorMap.keys();
        foreach (Component* comp, compRendered) {
            if (!Application::isAlive(comp)) {
                // remove from the renderer and map
                removeAllActors(comp);
            }
        }
    }

    //-- now check the full component list
    ComponentList allComponents = Application::getAllComponents();

    switch (myType) {
        case GEOMETRY_VIEWER:
            // check all Components
            foreach (Component* comp, allComponents) {
                // remove from the renderer and map
                removeAllActors(comp);

                // check if the Component is to be displayed here
                if (comp->getVisibility(this)) {
                    if (comp->getRepresentation() == Component::GEOMETRY) {
                        //-- set the correct rendering parameters
                        updateSelectionDisplay(comp);

                        //-- check the line as tube representation
                        bool linesAsTubes = propertyObject->property(linesAsTubesProperty->getName().toStdString().c_str()).toBool();
                        if (linesAsTubes) {
                            comp->setLinesAsTubes(linesAsTubes);
                        }

                        //-- add the correct actors (NULL is return if the actor is not appropriate, i.e. hidden or not in proper mode)
                        addActor(comp, comp->getActor(InterfaceGeometry::Surface));
                        addActor(comp, comp->getActor(InterfaceGeometry::Wireframe));
                        addActor(comp, comp->getActor(InterfaceGeometry::Points));

                        for (unsigned int i = 0; i < comp->getNumberOfProp(); i++) {
                            addActor(comp, comp->getProp(i));
                        }
                    }
                    else {
                        if (comp->getRepresentation() == Component::SLICE) {
                            addActor(comp, comp->get3DImageActor());

                            for (unsigned int i = 0; i < comp->getNumberOfProp(); i++) {
                                addActor(comp, comp->getProp(i));
                            }
                        }
                    }
                }
                if (comp->getFrameVisibility(this)) {
                    addActor(comp, comp->getFrameAxisActor());
                }

            }

            break;

        case SLICE_VIEWER:
            // remove all from the renderer and map
            QList<Component*> compRendered = actorMap.keys();
            foreach (Component* comp, compRendered) {
                removeAllActors(comp);
            }

            // only display the last selected (if exists otherwise the last added)
            int idOfLastSelected = Application::getSelectedComponents().size() - 1;

            if (idOfLastSelected >= 0) {
                while (idOfLastSelected >= 0 && !(Application::getSelectedComponents() [idOfLastSelected]->getVisibility(this) && Application::getSelectedComponents() [idOfLastSelected]->getRepresentation() == Component::SLICE)) {
                    idOfLastSelected--;
                }
            }

            if (idOfLastSelected >= 0) {

                // there is valid Component to display
                Component* comp = Application::getSelectedComponents() [idOfLastSelected];
                // add both the slices, the plane used for picking and the pixel highlighter
                addActor(comp, comp->getPixelActor());
                addActor(comp, comp->get2DImageActor());
                addActor(comp, comp->getPickPlaneActor());

                for (unsigned int i = 0; i < comp->getNumberOfProp(); i++) {
                    addActor(comp, comp->getProp(i));
                }

                // set the slider range and update widgets values
                sliceSlider->setRange(0, comp->getNumberOfSlices() - 1);
                sliceSlider->setValue(comp->getSlice());
            }
            else {

                // no selection, get the last added Component
                idOfLastSelected = allComponents.size() - 1;

                while (idOfLastSelected >= 0 && !(allComponents[idOfLastSelected]->getVisibility(this) && allComponents[idOfLastSelected]->getRepresentation() == Component::SLICE)) {
                    idOfLastSelected--;
                }

                if (idOfLastSelected >= 0) {

                    // there is valid Component to display
                    Component* comp = allComponents[idOfLastSelected];
                    // add both the slices, the plane used for picking and the pixel highlighter
                    addActor(comp, comp->getPixelActor());
                    addActor(comp, comp->get2DImageActor());
                    addActor(comp, comp->getPickPlaneActor());

                    for (unsigned int i = 0; i < comp->getNumberOfProp(); i++) {
                        addActor(comp, comp->getProp(i));
                    }

                    // set the slider range and update widgets values
                    sliceSlider->setRange(0, comp->getNumberOfSlices() - 1);
                    sliceSlider->setValue(comp->getSlice());
                }
            }

            break;
    }

    // refresh only camera on slice viewer which are not being picked nor is changing slice or geometry viewer which needs additional refresh
    if (displayedTopLevelComponents == (unsigned) Application::getTopLevelComponents().size()) {
        rendererWidget->updateAxes();

        // refresh only camera on slice viewer which are not being picked or geometry viewer which needs additional refresh
        if (((myType == SLICE_VIEWER) && !isPicking)) {
            if (!isChangingSlice) {
                resetCamera();
            }
            else
                // just reset clipping range
            {
                rendererWidget->resetClippingPlanes();
            }
            // TODO add a boolean "Reset camera when picking" that can be set on or off
            // and saved as a setting
        }
        rendererWidget->refresh();
    }
    else {
        // there is some difference => reset camera in case of Geometry Viewer
        rendererWidget->updateAxes();
        resetCamera();
        displayedTopLevelComponents = Application::getTopLevelComponents().size();
    }

    //-- update actions
    updateActions();
}

// ---------------------- refreshRenderer ----------------------------
void InteractiveViewer::refreshRenderer() {
    rendererWidget->refresh();
}

// ---------------------- removeAllActors ----------------------------
void InteractiveViewer::removeAllActors(Component* comp) {
    QList<vtkSmartPointer<vtkProp> > actorRendered = actorMap.values(comp);
    foreach (vtkSmartPointer<vtkProp> a, actorRendered) {
        rendererWidget->removeProp(a);
    }
    // remove from the list
    actorMap.remove(comp);
}

// ---------------------- addActor ----------------------------
void InteractiveViewer::addActor(Component* comp, vtkSmartPointer<vtkProp> a) {
    if (a) {
        rendererWidget->addProp(a);
        actorMap.insert(comp, a);
    }
}

// ---------------------- getMenu ----------------------------
QMenu* InteractiveViewer::getMenu() {
    if (frame && !viewerMenu) {
        //-- create the main menu
        viewerMenu = new QMenu(objectName());
        viewerMenu->setTearOffEnabled(true);

        //-- add actions to the menu
        QMenu* options = new QMenu("View Options");
        options->addAction(backgroundColorAction);
        options->addAction(toggleCopyrightAction);
        options->addAction(toggleAxesAction);
        if (myType == SLICE_VIEWER) {
            options->addAction(toggleOrientationDecorationsAction);
            options->addAction(toggleScreenshotAction);
        }

        // AxesView mode
        QMenu* cameraOrientationMenu = new QMenu("Camera Orientation");
        options->addMenu(cameraOrientationMenu);
        cameraOrientationMenu->addAction(cameraOrientationRightDownAction);
        cameraOrientationMenu->addAction(cameraOrientationLeftUpAction);
        cameraOrientationMenu->addAction(cameraOrientationRightUpAction);

        if (myType == GEOMETRY_VIEWER) {
            options->addSeparator();
            //options->addAction(toggleAxesAction);
            options->addAction(toggleLabelAction);
            options->addAction(toggleLinesAsTubesAction);
            options->addAction(toggleBackfaceCullingAction);

            // display mode
            QMenu* highlightMenu = new QMenu("Highlight Mode");
            options->addMenu(highlightMenu);
            highlightMenu->addAction(highlightOffAction);
            highlightMenu->addAction(highlightSelectionAction);
            highlightMenu->addAction(highlightSelectionOnlyAction);

            // camera menu
            QMenu* controlModeMenu = new QMenu("Camera Control");
            controlModeMenu->addAction(controlModeTrackballAction);
            controlModeMenu->addAction(controlModeJoystickAction);
            options->addMenu(controlModeMenu);

            // force toolbar creation and add it
            options->addSeparator();
            options->addAction(getToolBar()->toggleViewAction());
        }

        viewerMenu->addMenu(options);

        if (myType == GEOMETRY_VIEWER) {
            viewerMenu->addSeparator();
            // picking menu
            QMenu* pickingMenu = new QMenu("&Picking");
            pickingMenu->addAction(pickPointAction);
            pickingMenu->addAction(pickCellAction);
            viewerMenu->addMenu(pickingMenu);

            viewerMenu->addMenu(renderingMenu);
        }

        viewerMenu->addAction(screenshotAction);

        //-- update actions
        updateActions();
    }

    return viewerMenu;
}

// ---------------------- getToolBar ----------------------------
QToolBar* InteractiveViewer::getToolBar() {
    if (frame && !viewerToolbar) {
        if (myType == GEOMETRY_VIEWER) {
            viewerToolbar = new QToolBar(objectName() + " Toolbar");
            // ensure object name is set for saving the state
            viewerToolbar->setObjectName(objectName() + " Toolbar");

            viewerToolbar->addAction(pickPointAction);
            viewerToolbar->addAction(pickCellAction);
            viewerToolbar->addAction(pickPointRegionAction);
            viewerToolbar->addAction(pickCellRegionAction);

            viewerToolbar->addSeparator();

            viewerToolbar->addAction(surfaceAction);
            viewerToolbar->addAction(wireframeAction);
            viewerToolbar->addAction(pointsAction);
            if (colorAction) {
                viewerToolbar->addAction(colorAction);
            }
            viewerToolbar->addAction(glyphAction);
            viewerToolbar->addAction(toggleLabelAction);

            viewerToolbar->addSeparator();

            viewerToolbar->addAction(toggleAxesAction);
            viewerToolbar->addAction(screenshotAction);

            viewerToolbar->addSeparator();

            viewerToolbar->addAction(scalarDataColorAction);
        }
        /* if (myType == SLICE_VIEWER) {
            viewerToolBar->addAction(toggleOrientationDecorationsAction);
        }