cxPickerRep.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.
=========================================================================*/


#include "cxPickerRep.h"

#include "boost/bind.hpp"
#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkRenderer.h>
#include <vtkProperty.h>
#include <vtkImageData.h>
#include <vtkLineSource.h>
//#include <vtkDoubleArray.h>
#include <vtkProbeFilter.h>
#include <vtkSphereSource.h>
#include <vtkRenderWindow.h>
#include <vtkCallbackCommand.h>
#include <vtkPolyDataMapper.h>
//#include <vtkDataSetAttributes.h>
#include <vtkEventQtSlotConnect.h>
//#include <vtkCellPicker.h>
#include "cxMesh.h"
#include "cxPatientModelService.h"
#include "cxLogger.h"
#include "cxImage.h"
#include "cxView.h"
#include "cxTool.h"
#include "cxRegistrationTransform.h"
#include "cxGeometricRep.h"
#include <vtkRenderWindowInteractor.h>
#include "cxLogger.h"
#include "vtkVolumePicker.h"

#include "cxConfig.h"
#ifdef CX_BUILD_MEHDI_VTKMULTIVOLUME
        #include "vtkMultiVolumePicker.h"
                typedef vtkSmartPointer<class vtkMultiVolumePicker> vtkMultiVolumePickerPtr;
//              typedef vtkSmartPointer<class vtkVolumePicker> vtkMultiVolumePickerPtr;
#else
    typedef vtkSmartPointer<class vtkVolumePicker> vtkMultiVolumePickerPtr;
#endif

namespace cx
{
PickerRepPtr PickerRep::New(PatientModelServicePtr dataManager, const QString& uid)
{
        return wrap_new(new PickerRep(dataManager), uid);
}
PickerRep::PickerRep(PatientModelServicePtr dataManager) :
        RepImpl(),
        mDataManager(dataManager),
        mPickedPoint(), mSphereRadius(2) //, mConnections(vtkEventQtSlotConnectPtr::New())
{
        mIsDragging = false;
        mViewportListener.reset(new ViewportListener);
        mViewportListener->setCallback(boost::bind(&PickerRep::scaleSphere, this));

        this->mCallbackCommand = vtkCallbackCommandPtr::New();
        this->mCallbackCommand->SetClientData(this);
        this->mCallbackCommand->SetCallback(PickerRep::ProcessEvents);

        mEnabled = true;
        mConnected = false;
        mSnapToSurface = false;
}

void PickerRep::scaleSphere()
{
        if (!mGraphicalPoint)
                return;

        double size = mViewportListener->getVpnZoom();
        double sphereSize = mSphereRadius / 100 / size;
        mGraphicalPoint->setRadius(sphereSize);
}

PickerRep::~PickerRep()
{
}
QString PickerRep::getType() const
{
        return "PickerRep";
}

void PickerRep::setSphereRadius(double radius)
{
        mSphereRadius = radius;
        if (mGraphicalPoint)
                mGraphicalPoint->setRadius(mSphereRadius);
}

void PickerRep::setTool(ToolPtr tool)
{
        if (tool == mTool)
                return;

        if (mTool)
        {
                disconnect(mTool.get(), SIGNAL(toolTransformAndTimestamp(Transform3D, double)), this,
                                SLOT(setModified()));
        }

        mTool = tool;

        if (mTool)
        {
                connect(mTool.get(), SIGNAL(toolTransformAndTimestamp(Transform3D, double)), this,
                                SLOT(setModified()));
                this->setModified();
        }
}

void PickerRep::setGlyph(MeshPtr glyph)
{
        if (!mGlyph)
                mGlyph = glyph;

         if (!mGlyphRep)
         {
                 mGlyphRep = GeometricRep::New("PickerGlyphRep");
                 if (this->getView())
                 {
                         this->getView()->addRep(mGlyphRep);
                 }
         }

         mGlyphRep->setMesh(mGlyph);
}

typedef vtkSmartPointer<class vtkDataSet> vtkDataSetPtr;

void PickerRep::pickLandmark(const Vector3D& clickPosition, vtkRendererPtr renderer)
{
        if (!this->mEnabled)
                return;
        vtkMultiVolumePickerPtr picker = vtkMultiVolumePickerPtr::New();
        int hit = picker->Pick(clickPosition[0], clickPosition[1], 0, renderer);
        if (!hit)
        {
                mIsDragging = false;
                return;
        }

        // search for picked data in manager, emit uid if found.
        vtkDataSetPtr data = picker->GetDataSet();
        if (data)
        {
                std::map<QString, DataPtr> allData = mDataManager->getData();
                for (std::map<QString, DataPtr>::iterator iter = allData.begin(); iter != allData.end(); ++iter)
                {
                        MeshPtr mesh = boost::dynamic_pointer_cast<Mesh>(iter->second);
                        if (mesh && mesh->getVtkPolyData() == data)
                                emit dataPicked(iter->first);

                        ImagePtr image = boost::dynamic_pointer_cast<Image>(iter->second);
                        if (image && image->getBaseVtkImageData() == data)
                                emit dataPicked(iter->first);
                }
        }

        Vector3D pick_w(picker->GetPickPosition());

        if ( data &&
                ((mGraphicalPoint && (data == mGraphicalPoint->getPolyData() ))
           ||(mGlyph          && (data == mGlyph->getVtkPolyData()       ))
           ||(mTool           && (data == mTool->getGraphicsPolyData()   )))
           )
        {
                // We have clicked the picker/tool itself.
                // Store click pos and wait for dragging.
                mClickedPoint = pick_w;
                mIsDragging = true;
                mCallbackCommand->SetAbortFlag(1); // abort this event: interactor does not receive it.
                return;
        }
        else
        {
                mIsDragging = false;
        }

        if (hit && mSnapToSurface)
        {
                mPickedPoint = pick_w;

                if (mGraphicalPoint)
                        mGraphicalPoint->setValue(mPickedPoint);
                this->setGlyphCenter(mPickedPoint);

                emit pointPicked(mPickedPoint);
        }
}

void PickerRep::pickLandmarkSlot(vtkObject* renderWindowInteractor)
{
        vtkRenderWindowInteractorPtr iren = vtkRenderWindowInteractor::SafeDownCast(renderWindowInteractor);

        if (iren == NULL)
                return;

        int pickedPoint[2]; //<x,y>
        iren->GetEventPosition(pickedPoint); //mouse positions are measured in pixels

        vtkRendererPtr renderer = this->getRenderer();
        if (renderer == NULL)
                return;

        Vector3D clickPoint(pickedPoint[0], pickedPoint[1], 0);

        this->pickLandmark(clickPoint, renderer);
}

void PickerRep::onModifiedStartRender()
{
        this->toolHasChanged();
}

void PickerRep::toolHasChanged()
{
        if (!mTool)
                return;
        Transform3D prMt = mTool->get_prMt();
        Transform3D rMpr = mDataManager->get_rMpr();
        Transform3D rMt = rMpr * prMt;
        Vector3D p_r = rMt.coord(Vector3D(0, 0, mTool->getTooltipOffset()));

        mPickedPoint = p_r;
        if (mGraphicalPoint)
                mGraphicalPoint->setValue(mPickedPoint);
        this->setGlyphCenter(mPickedPoint);
}

void PickerRep::setEnabled(bool on)
{
        mEnabled = on;
        if (mSnapToSurface == on)
                return;

        mSnapToSurface = on;

        if (mSnapToSurface)
        {
                if (mGraphicalPoint)
                        mGraphicalPoint->getActor()->SetVisibility(true);
        }
        else
        {
                if (mGraphicalPoint)
                        mGraphicalPoint->getActor()->SetVisibility(false);
        }
}

void PickerRep::ProcessEvents(vtkObject* vtkNotUsed(object), unsigned long event, void* clientdata,
                void* vtkNotUsed(calldata))
{
        PickerRep* self = reinterpret_cast<PickerRep *>(clientdata);

        //okay, let's do the right thing
        switch (event)
        {
        case vtkCommand::LeftButtonPressEvent:
                self->OnLeftButtonDown();
                break;
        case vtkCommand::LeftButtonReleaseEvent:
                self->OnLeftButtonUp();
                break;
        case vtkCommand::MouseMoveEvent:
                self->OnMouseMove();
                break;
        }
}

Vector3D PickerRep::ComputeDisplayToWorld(Vector3D p_d)
{
        double worldPt[4];
        vtkRendererPtr ren = this->getRenderer();
        ren->SetDisplayPoint(p_d.data());
        ren->DisplayToWorld();
        ren->GetWorldPoint(worldPt);
        return Vector3D(worldPt)/worldPt[3];
}

Vector3D PickerRep::ComputeWorldToDisplay(Vector3D p_w)
{
        Vector3D p_d;
        vtkRendererPtr ren = this->getRenderer();
        ren->SetWorldPoint(p_w[0], p_w[1], p_w[2], 1.0);
        ren->WorldToDisplay();
        ren->GetDisplayPoint(p_d.data());
        return p_d;
}

Vector3D PickerRep::getDisplacement()
{
        vtkRenderWindowInteractorPtr interactor = this->getView()->getRenderWindow()->GetInteractor();

//      // find previous pos in world and display:
        Vector3D p_prev_w = mClickedPoint;
//      std::cout << "  p_prev_w  = \t" << p_prev_w << std::endl;
        Vector3D p_prev_d = this->ComputeWorldToDisplay(p_prev_w);
//      std::cout << "  p_prev_d  = \t" << p_prev_d << std::endl;

        // find current pos in world and display, set z-pos in d equal to previous z-pos:
        Vector3D p_current_d(interactor->GetEventPosition()[0], interactor->GetEventPosition()[1], p_prev_d[2]);
//      std::cout << "  p_current_d = \t" << p_current_d << std::endl;
        Vector3D p_current_w = this->ComputeDisplayToWorld(p_current_d);
//      std::cout << "  p_current_w  = \t" << p_current_w << std::endl;

        // both positions are now in the camera focal plane: the diff lies in the view plane.
//      std::cout << "  diff_d   = \t" << p_current_d - p_prev_d << std::endl;
//      std::cout << "  diff_w   = \t" << p_current_w - p_prev_w << std::endl;
        return p_current_w - p_prev_w;
}

void PickerRep::OnLeftButtonDown()
{
        this->pickLandmarkSlot(this->getView()->getRenderWindow()->GetInteractor());
}

void PickerRep::OnMouseMove()
{
        if (mIsDragging)
        {
                mPickedPoint += this->getDisplacement();
                mClickedPoint = mPickedPoint;

                if (mGraphicalPoint)
                        mGraphicalPoint->setValue(mPickedPoint);
                this->setGlyphCenter(mPickedPoint);
                emit pointPicked(mPickedPoint);

                mCallbackCommand->SetAbortFlag(1);
        }
}

void PickerRep::setGlyphCenter(Vector3D pos)
{
        if (mGlyph)
        {
                mGlyph->get_rMd_History()->setRegistration(createTransformTranslate(pos));
        }
}


void PickerRep::OnLeftButtonUp()
{
        if (mIsDragging)
        {
                mIsDragging = false;
                mCallbackCommand->SetAbortFlag(1); // abort this event: interactor does not receive it.
        }
}

void PickerRep::connectInteractor()
{
        if (!this->getView())
                return;
        if (mConnected)
                return;

        vtkRenderWindowInteractorPtr i = this->getView()->getRenderWindow()->GetInteractor();
        i->AddObserver(vtkCommand::MouseMoveEvent, this->mCallbackCommand, 1.0);
        i->AddObserver(vtkCommand::LeftButtonPressEvent, this->mCallbackCommand, 1.0);
        i->AddObserver(vtkCommand::LeftButtonReleaseEvent, this->mCallbackCommand, 1.0);

        mConnected = true;
}

void PickerRep::disconnectInteractor()
{
        if (!this->getView())
                return;
        if (!mConnected)
                return;

        // don't listen for events any more
        this->getView()->getRenderWindow()->GetInteractor()->RemoveObserver(this->mCallbackCommand);

        mConnected = false;
}

void PickerRep::addRepActorsToViewRenderer(ViewPtr view)
{
        if (view == NULL)
        {
                reportDebug("Cannot add rep actor to a NULL view.");
                return;
        }

        this->connectInteractor();

        mGraphicalPoint.reset(new GraphicalPoint3D(this->getRenderer()));
        mGraphicalPoint->setColor(QColor(Qt::blue));
        mGraphicalPoint->setRadius(mSphereRadius);
        mGraphicalPoint->getActor()->SetVisibility(mSnapToSurface);

        // show even if disabled
        if (mGlyphRep)
        {
                this->getView()->addRep(mGlyphRep);
        }

        mViewportListener->startListen(this->getRenderer());
        this->scaleSphere();
}

void PickerRep::removeRepActorsFromViewRenderer(ViewPtr view)
{
        if (view == NULL)
                return;

        this->disconnectInteractor();
        mViewportListener->stopListen();
        mGraphicalPoint.reset();

        if (mGlyphRep)
                view->removeRep(mGlyphRep);
}

Vector3D PickerRep::getPosition() const
{
        return mPickedPoint;
}

} //namespace cx