cxViewWrapper2D.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.

Copyright (c) 2008-2014, SINTEF Department of Medical Technology
All rights reserved.

Redistribution and use in source and binary forms, with or without 
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, 
   this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, 
   this list of conditions and the following disclaimer in the documentation 
   and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors 
   may be used to endorse or promote products derived from this software 
   without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
=========================================================================*/

/*
 * cxViewWrapper2D.cpp
 *
 *  \date Mar 24, 2010
 *      \author christiana
 */


#include "cxViewWrapper2D.h"
#include <vector>
#include <vtkCamera.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>

#include <QAction>
#include <QActionGroup>
#include <QMenu>
#include <QMouseEvent>
#include <QWheelEvent>

#include "cxUtilHelpers.h"
#include "cxView.h"
#include "cxSliceProxy.h"
#include "cxSlicerRepSW.h"
#include "cxToolRep2D.h"
#include "cxOrientationAnnotationRep.h"
#include "cxOrientationAnnotation2DRep.h"
#include "cxDisplayTextRep.h"

#include "cxManualTool.h"
#include "cxViewManager.h"
#include "cxTrackingService.h"
#include "cxViewGroup.h"
#include "cxDefinitionStrings.h"
#include "cxSlicePlanes3DRep.h"
#include "cxDefinitionStrings.h"
#include "cxSliceComputer.h"
#include "cxGeometricRep2D.h"
#include "cxTexture3DSlicerRep.h"
#include "cxDataLocations.h"
#include "cxSettings.h"
#include "cxGLHelpers.h"
#include "cxData.h"
#include "cxMesh.h"
#include "cxImage.h"
#include "cxPointMetricRep2D.h"

#include "cxViewFollower.h"
#include "cxVisServices.h"
#include "cx2DZoomHandler.h"
#include "cxNavigation.h"
#include "cxDataRepContainer.h"
#include "vtkRenderWindowInteractor.h"
#include "cxPatientModelService.h"


namespace cx
{

ViewWrapper2D::ViewWrapper2D(ViewPtr view, VisServicesPtr backend) :
        ViewWrapper(backend),
        mOrientationActionGroup(new QActionGroup(view.get()))
{
        mView = view;
        this->connectContextMenu(mView);

        // disable vtk interactor: this wrapper IS an interactor
        mView->getRenderWindow()->GetInteractor()->Disable();
        mView->getRenderer()->GetActiveCamera()->SetParallelProjection(true);
        double clipDepth = 1.0; // 1mm depth, i.e. all 3D props rendered outside this range is not shown.
        double length = clipDepth*10;
        mView->getRenderer()->GetActiveCamera()->SetPosition(0,0,length);
        mView->getRenderer()->GetActiveCamera()->SetClippingRange(length-clipDepth, length+0.1);
        connect(settings(), SIGNAL(valueChangedFor(QString)), this, SLOT(settingsChangedSlot(QString)));

        // slice proxy
        mSliceProxy = SliceProxy::create(mServices->getPatientService());

        mDataRepContainer.reset(new DataRepContainer());
        mDataRepContainer->setSliceProxy(mSliceProxy);
        mDataRepContainer->setView(mView);

        mViewFollower = ViewFollower::create(mServices->getPatientService());
        mViewFollower->setSliceProxy(mSliceProxy);

        addReps();

        mZoom2D.reset(new Zoom2DHandler());
        connect(mZoom2D.get(), SIGNAL(zoomChanged()), this, SLOT(viewportChanged()));
        setOrientationMode(SyncedValue::create(0)); // must set after addreps()

        connect(mServices->getToolManager().get(), SIGNAL(activeToolChanged(const QString&)), this, SLOT(activeToolChangedSlot()));
        connect(mView.get(), SIGNAL(resized(QSize)), this, SLOT(viewportChanged()));
        connect(mView.get(), SIGNAL(shown()), this, SLOT(showSlot()));
        connect(mView.get(), SIGNAL(mousePress(int, int, Qt::MouseButtons)), this, SLOT(mousePressSlot(int, int, Qt::MouseButtons)));
        connect(mView.get(), SIGNAL(mouseMove(int, int, Qt::MouseButtons)), this, SLOT(mouseMoveSlot(int, int, Qt::MouseButtons)));
        connect(mView.get(), SIGNAL(mouseWheel(int, int, int, int, Qt::MouseButtons)), this, SLOT(mouseWheelSlot(int, int, int, int, Qt::MouseButtons)));

        this->activeToolChangedSlot();
        this->updateView();
}

ViewWrapper2D::~ViewWrapper2D()
{
        if (mView)
                mView->removeReps();
}

void ViewWrapper2D::appendToContextMenu(QMenu& contextMenu)
{
        QAction* obliqueAction = new QAction("Oblique", &contextMenu);
        obliqueAction->setCheckable(true);
        obliqueAction->setData(qstring_cast(otOBLIQUE));
        obliqueAction->setChecked(getOrientationType() == otOBLIQUE);
        connect(obliqueAction, SIGNAL(triggered()), this, SLOT(orientationActionSlot()));

        QAction* ortogonalAction = new QAction("Ortogonal", &contextMenu);
        ortogonalAction->setCheckable(true);
        ortogonalAction->setData(qstring_cast(otORTHOGONAL));
        ortogonalAction->setChecked(getOrientationType() == otORTHOGONAL);
        connect(ortogonalAction, SIGNAL(triggered()), this, SLOT(orientationActionSlot()));

        //TODO remove actiongroups?
        mOrientationActionGroup->addAction(obliqueAction);
        mOrientationActionGroup->addAction(ortogonalAction);

        contextMenu.addSeparator();
        contextMenu.addAction(obliqueAction);
        contextMenu.addAction(ortogonalAction);
        contextMenu.addSeparator();

        mZoom2D->addActionsToMenu(&contextMenu);
}

void ViewWrapper2D::setViewGroup(ViewGroupDataPtr group)
{
        ViewWrapper::setViewGroup(group);

        mZoom2D->setGroupData(group);
        connect(group.get(), SIGNAL(optionsChanged()), this, SLOT(optionChangedSlot()));
        this->optionChangedSlot();
}

void ViewWrapper2D::optionChangedSlot()
{
        ViewGroupData::Options options = mGroupData->getOptions();

        if (mPickerGlyphRep)
        {
                mPickerGlyphRep->setMesh(options.mPickerGlyph);
        }
}

void ViewWrapper2D::orientationActionSlot()
{
        QAction* theAction = static_cast<QAction*>(sender());if(!theAction)
        return;

        ORIENTATION_TYPE type = string2enum<ORIENTATION_TYPE>(theAction->data().toString());
        mOrientationMode->set(type);
}


void ViewWrapper2D::addReps()
{
        // annotation rep
        mOrientationAnnotationRep = OrientationAnnotationSmartRep::New();
        mView->addRep(mOrientationAnnotationRep);

        // plane type text rep
        mPlaneTypeText = DisplayTextRep::New();
        mPlaneTypeText->addText(QColor(Qt::green), "not initialized", Vector3D(0.98, 0.02, 0.0));
        mView->addRep(mPlaneTypeText);

        //data name text rep
        mDataNameText = DisplayTextRep::New();
        mDataNameText->addText(QColor(Qt::green), "not initialized", Vector3D(0.02, 0.02, 0.0));
        mView->addRep(mDataNameText);

        // tool rep
        mToolRep2D = ToolRep2D::New(mServices->getSpaceProvider(), "Tool2D_" + mView->getName());
        mToolRep2D->setSliceProxy(mSliceProxy);
        mToolRep2D->setUseCrosshair(true);
//  mToolRep2D->setUseToolLine(false);
        mView->addRep(mToolRep2D);

        mPickerGlyphRep = GeometricRep2D::New("PickerGlyphRep_" + mView->getName());
        mPickerGlyphRep->setSliceProxy(mSliceProxy);
        if (mGroupData)
        {
                mPickerGlyphRep->setMesh(mGroupData->getOptions().mPickerGlyph);
        }
        mView->addRep(mPickerGlyphRep);
}

void ViewWrapper2D::settingsChangedSlot(QString key)
{
        if (key == "View/showDataText")
        {
                this->updateView();
        }
        if (key == "View/showOrientationAnnotation")
        {
                this->updateView();
        }
        if (key == "useGPU2DRendering")
        {
                this->updateView();
        }
        if (key == "Navigation/anyplaneViewOffset")
        {
                this->updateView();
        }
}

void ViewWrapper2D::resetMultiSlicer()
{
        if (mSliceRep)
        {
                mView->removeRep(mSliceRep);
                mSliceRep.reset();
        }
        if (mMultiSliceRep)
                mView->removeRep(mMultiSliceRep);
        if (!settings()->value("useGPU2DRendering").toBool())
                return;

//      std::cout << "using gpu multislicer" << std::endl;
        mMultiSliceRep = Texture3DSlicerRep::New();
        mMultiSliceRep->setShaderPath(DataLocations::findConfigFolder("/shaders"));
        mMultiSliceRep->setSliceProxy(mSliceProxy);
        mView->addRep(mMultiSliceRep);
        if (mGroupData)
                mMultiSliceRep->setImages(mGroupData->getImages(DataViewProperties::createSlice2D()));
        this->viewportChanged();
}

void ViewWrapper2D::viewportChanged()
{
        if (!mView->getRenderer()->IsActiveCameraCreated())
                return;

        mView->setZoomFactor(mZoom2D->getFactor());

        double viewHeight = mView->getViewport_s().range()[1];
        mView->getRenderer()->GetActiveCamera()->SetParallelScale(viewHeight / 2);

        // Heuristic guess for a good clip depth. The point is to show 3D data clipped in 2D
        // with a suitable thickness projected onto the plane.
        double clipDepth = 2.0; // i.e. all 3D props rendered outside this range is not shown.
        double length = clipDepth*10;
        clipDepth = viewHeight/120 + 1.5;
        mView->getRenderer()->GetActiveCamera()->SetPosition(0,0,length);
        mView->getRenderer()->GetActiveCamera()->SetClippingRange(length-clipDepth, length+0.1);

        mSliceProxy->setToolViewportHeight(viewHeight);
        double anyplaneViewOffset = settings()->value("Navigation/anyplaneViewOffset").toDouble();
        mSliceProxy->initializeFromPlane(mSliceProxy->getComputer().getPlaneType(), false, Vector3D(0, 0, 1), true, viewHeight, anyplaneViewOffset, true);

        DoubleBoundingBox3D BB_vp = getViewport();
        Transform3D vpMs = mView->get_vpMs();
        DoubleBoundingBox3D BB_s = transform(vpMs.inv(), BB_vp);
        PLANE_TYPE plane = mSliceProxy->getComputer().getPlaneType();

        mToolRep2D->setViewportData(vpMs, BB_vp);
        if (mSlicePlanes3DMarker)
        {
                mSlicePlanes3DMarker->getProxy()->setViewportData(plane, mSliceProxy, BB_s);
        }

        mViewFollower->setView(BB_s);
}

DoubleBoundingBox3D ViewWrapper2D::getViewport() const
{
        QSize size = mView->size();
        Vector3D p0_d(0, 0, 0);
        Vector3D p1_d(size.width(), size.height(), 0);
        DoubleBoundingBox3D BB_vp(p0_d, p1_d);
        return BB_vp;
}

void ViewWrapper2D::showSlot()
{
        activeToolChangedSlot();
        viewportChanged();
}

void ViewWrapper2D::initializePlane(PLANE_TYPE plane)
{
//  mOrientationAnnotationRep->setPlaneType(plane);
        mPlaneTypeText->setText(0, qstring_cast(plane));
//      double viewHeight = mView->heightMM() / mZoom2D->getFactor();
        double viewHeight = mView->getViewport_s().range()[1];
        mSliceProxy->initializeFromPlane(plane, false, Vector3D(0, 0, 1), true, viewHeight, 0.25);
//      double anyplaneViewOffset = settings()->value("Navigation/anyplaneViewOffset").toDouble();
//      mSliceProxy->initializeFromPlane(plane, false, Vector3D(0, 0, 1), true, 1, 0);
        mOrientationAnnotationRep->setSliceProxy(mSliceProxy);

        // do this to force sync global and local type - must think on how we want this to work
        this->changeOrientationType(getOrientationType());

        bool isOblique = mSliceProxy->getComputer().getOrientationType() == otOBLIQUE;
        mToolRep2D->setUseCrosshair(!isOblique);
//  mToolRep2D->setUseToolLine(!isOblique);

}

ORIENTATION_TYPE ViewWrapper2D::getOrientationType() const
{
        return mSliceProxy->getComputer().getOrientationType();
}

void ViewWrapper2D::orientationModeChanged()
{
        ORIENTATION_TYPE type = static_cast<ORIENTATION_TYPE>(mOrientationMode->get().toInt());

if      (type == this->getOrientationType())
        return;
        if (!mSliceProxy)
        return;

        SliceComputer computer = mSliceProxy->getComputer();
        computer.switchOrientationMode(type);

        PLANE_TYPE plane = computer.getPlaneType();
//  mOrientationAnnotationRep->setPlaneType(plane);
                                        mPlaneTypeText->setText(0, qstring_cast(plane));
                                        mSliceProxy->setComputer(computer);
                                }

void ViewWrapper2D::changeOrientationType(ORIENTATION_TYPE type)
{
        mOrientationMode->set(type);
}

ViewPtr ViewWrapper2D::getView()
{
        return mView;
}

void ViewWrapper2D::imageAdded(ImagePtr image)
{
        this->updateView();

        // removed this side effect: unwanted when loading a patient, might also be unwanted to change scene when adding/removing via gui?
        //Navigation().centerToView(mViewGroup->getImages());
}

void ViewWrapper2D::updateView()
{
        QString text;
        if (mGroupData)
        {
                std::vector<ImagePtr> images = mGroupData->getImages(DataViewProperties::createSlice2D());
                ImagePtr image;
                if (!images.empty())
                        image = images.back(); // always show last in vector

                if (image)
                {
                        Vector3D c = image->get_rMd().coord(image->boundingBox().center());
                        mSliceProxy->setDefaultCenter(c);
                }

                // slice rep
                if (settings()->value("useGPU2DRendering").toBool())
                {
                        this->resetMultiSlicer();
                        text = this->getAllDataNames(DataViewProperties::createSlice2D()).join("\n");
                }
                else
                {
                        if (mMultiSliceRep)
                        {
                                mView->removeRep(mMultiSliceRep);
                                mMultiSliceRep.reset();
                        }

                        if (!mSliceRep)
                        {
                                mSliceRep = SliceRepSW::New("SliceRep_" + mView->getName());
                                mSliceRep->setSliceProxy(mSliceProxy);
                                mView->addRep(mSliceRep);
                        }

                        QStringList textList;
                        mSliceRep->setImage(image);

                        // list all meshes and one image.
                        std::vector<MeshPtr> mesh = mGroupData->getMeshes(DataViewProperties::createSlice2D());
                        for (unsigned i = 0; i < mesh.size(); ++i)
                        textList << qstring_cast(mesh[i]->getName());
                        if (image)
                        textList << image->getName();
                        text = textList.join("\n");
                }
        }

        bool show = settings()->value("View/showDataText").value<bool>();
        if (!show)
                text = QString();

        //update data name text rep
        mDataNameText->setText(0, text);
        mDataNameText->setFontSize(std::max(12, 22 - 2 * text.size()));

        mOrientationAnnotationRep->setVisible(settings()->value("View/showOrientationAnnotation").value<bool>());

        mDataRepContainer->updateSettings();
//      mViewFollower->ensureCenterWithinView();
}



void ViewWrapper2D::imageRemoved(const QString& uid)
{
        updateView();
}

void ViewWrapper2D::dataViewPropertiesChangedSlot(QString uid)
{
        DataPtr data = mServices->getPatientService()->getData(uid);
        DataViewProperties properties = mGroupData->getProperties(uid);

        if (properties.hasSlice2D())
                this->dataAdded(data);
        else
                this->dataRemoved(uid);

}

void ViewWrapper2D::dataAdded(DataPtr data)
{
        if (boost::dynamic_pointer_cast<Image>(data))
        {
                this->imageAdded(boost::dynamic_pointer_cast<Image>(data));
        }
        else
        {
                mDataRepContainer->addData(data);
        }
        this->updateView();
}

void ViewWrapper2D::dataRemoved(const QString& uid)
{
        mDataRepContainer->removeData(uid);
        this->updateView();
}

void ViewWrapper2D::activeToolChangedSlot()
{
        ToolPtr activeTool = mServices->getToolManager()->getActiveTool();
        mSliceProxy->setTool(activeTool);
}

void ViewWrapper2D::setOrientationMode(SyncedValuePtr value)
{
        if (mOrientationMode)
                disconnect(mOrientationMode.get(), SIGNAL(changed()), this, SLOT(orientationModeChanged()));
        mOrientationMode = value;
        if (mOrientationMode)
                connect(mOrientationMode.get(), SIGNAL(changed()), this, SLOT(orientationModeChanged()));

        orientationModeChanged();
}

void ViewWrapper2D::mousePressSlot(int x, int y, Qt::MouseButtons buttons)
{
        if (buttons & Qt::LeftButton)
        {
                if (this->getOrientationType() == otORTHOGONAL)
                {
                        setAxisPos(qvp2vp(QPoint(x,y)));
                }
                else
                {
                        mClickPos = qvp2vp(QPoint(x,y));
                        this->shiftAxisPos(Vector3D(0,0,0)); // signal the maual tool that something is happening (important for playback tool)
                }
        }
}

void ViewWrapper2D::mouseMoveSlot(int x, int y, Qt::MouseButtons buttons)
{
        if (buttons & Qt::LeftButton)
        {
                if (this->getOrientationType() == otORTHOGONAL)
                {
                        setAxisPos(qvp2vp(QPoint(x,y)));
                }
                else
                {
                        Vector3D p = qvp2vp(QPoint(x,y));
                        this->shiftAxisPos(p - mClickPos);
                        mClickPos = p;
                }
        }
}


void ViewWrapper2D::mouseWheelSlot(int x, int y, int delta, int orientation, Qt::MouseButtons buttons)
{
        // scale zoom in log space
        double val = log10(mZoom2D->getFactor());
        val += delta / 120.0 / 20.0; // 120 is normal scroll resolution, x is zoom resolution
        double newZoom = pow(10.0, val);

        mZoom2D->setFactor(newZoom);

        Navigation(mServices).centerToTooltip(); // side effect: center on tool
}

Vector3D ViewWrapper2D::qvp2vp(QPoint pos_qvp)
{
        QSize size = mView->size();
        Vector3D pos_vp(pos_qvp.x(), size.height() - pos_qvp.y(), 0.0); // convert from left-handed qt space to vtk space display/viewport
        return pos_vp;
}

void ViewWrapper2D::shiftAxisPos(Vector3D delta_vp)
{
        delta_vp = -delta_vp;
        ToolPtr tool = mServices->getToolManager()->getManualTool();

        Transform3D sMr = mSliceProxy->get_sMr();
        Transform3D rMpr = mServices->getPatientService()->get_rMpr();
        Transform3D prMt = tool->get_prMt();
        Transform3D vpMs = mView->get_vpMs();
        Vector3D delta_s = vpMs.inv().vector(delta_vp);

        Vector3D delta_pr = (rMpr.inv() * sMr.inv()).vector(delta_s);

        // MD is the actual tool movement in patient space, matrix form
        Transform3D MD = createTransformTranslate(delta_pr);
        // set new tool position to old modified by MD:
        tool->set_prMt(MD * prMt);
}

void ViewWrapper2D::setAxisPos(Vector3D click_vp)
{
        ToolPtr tool = mServices->getToolManager()->getManualTool();

        Transform3D sMr = mSliceProxy->get_sMr();
        Transform3D rMpr = mServices->getPatientService()->get_rMpr();
        Transform3D prMt = tool->get_prMt();

        // find tool position in s
        Vector3D tool_t(0, 0, tool->getTooltipOffset());
        Vector3D tool_s = (sMr * rMpr * prMt).coord(tool_t);

        // find click position in s.
        Transform3D vpMs = mView->get_vpMs();
        Vector3D click_s = vpMs.inv().coord(click_vp);

        // compute the new tool position in slice space as a synthesis of the plane part of click and the z part of original.
        Vector3D cross_s(click_s[0], click_s[1], tool_s[2]);
        // compute the position change and transform to patient.
        Vector3D delta_s = cross_s - tool_s;
        Vector3D delta_pr = (rMpr.inv() * sMr.inv()).vector(delta_s);

        // MD is the actual tool movement in patient space, matrix form
        Transform3D MD = createTransformTranslate(delta_pr);
        // set new tool position to old modified by MD:
        tool->set_prMt(MD * prMt);
}

void ViewWrapper2D::setSlicePlanesProxy(SlicePlanesProxyPtr proxy)
{
        mSlicePlanes3DMarker = SlicePlanes3DMarkerIn2DRep::New("uid");
        PLANE_TYPE plane = mSliceProxy->getComputer().getPlaneType();
        mSlicePlanes3DMarker->setProxy(plane, proxy);

        DoubleBoundingBox3D BB_vp = getViewport();
        Transform3D vpMs = mView->get_vpMs();
        mSlicePlanes3DMarker->getProxy()->setViewportData(plane, mSliceProxy, transform(vpMs.inv(), BB_vp));

        mView->addRep(mSlicePlanes3DMarker);
}

//------------------------------------------------------------------------------
}