developer_doc/15.3.3-beta/cx_landmark_registration_widget_8cpp_source.html

 /*=========================================================================

 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 "cxLandmarkRegistrationWidget.h"


 #include <sstream>

 #include <QVBoxLayout>

 #include <QPushButton>

 #include <QTableWidget>

 #include <QTableWidgetItem>

 #include <QHeaderView>

 #include <QLabel>

 #include <QSlider>

 #include <vtkDoubleArray.h>

 #include <vtkImageData.h>


 #include "cxTypeConversions.h"

 #include "cxManualTool.h"

 #include "cxPatientModelService.h"

 #include "cxRegistrationService.h"

 #include"cxData.h"

 #include "cxLogger.h"

 #include "cxLandmark.h"

 #include "cxTrackingService.h"


 namespace cx

 {

 LandmarkRegistrationWidget::LandmarkRegistrationWidget(RegServices services, QWidget* parent,

         QString objectName, QString windowTitle) :

         RegistrationBaseWidget(services, parent, objectName, windowTitle), mVerticalLayout(new QVBoxLayout(this)),

                 mLandmarkTableWidget(new QTableWidget(this)), mAvarageAccuracyLabel(new QLabel(QString(" "), this))

 {

         //table widget

         connect(mLandmarkTableWidget, SIGNAL(cellClicked(int, int)), this, SLOT(cellClickedSlot(int, int)));

         connect(mLandmarkTableWidget, SIGNAL(cellChanged(int,int)), this, SLOT(cellChangedSlot(int,int)));


         this->setLayout(mVerticalLayout);

 }


 LandmarkRegistrationWidget::~LandmarkRegistrationWidget()

 {

 }


 QString LandmarkRegistrationWidget::defaultWhatsThis() const

 {

         return "<html>"

                 "<h3>Registration.</h3>"

                 "<p>Interface for registrating.</p>"

                 "<p><i></i></p>"

                 "</html>";

 }


 void LandmarkRegistrationWidget::cellClickedSlot(int row, int column)

 {

         if (row < 0 || column < 0)

                 return;


         if (!mLandmarkTableWidget)

                 reportDebug("mLandmarkTableWidget is null");


         mActiveLandmark = mLandmarkTableWidget->item(row, column)->data(Qt::UserRole).toString();


         LandmarkMap targetData = this->getTargetLandmarks();

         if (targetData.count(mActiveLandmark))

         {

                 Vector3D p_d = targetData[mActiveLandmark].getCoord();

                 Vector3D p_r = this->getTargetTransform().coord(p_d);

                 Vector3D p_pr = mServices.patientModelService->get_rMpr().coord(p_r);

                 this->setManualToolPosition(p_r);

         }


 }


 void LandmarkRegistrationWidget::setManualToolPosition(Vector3D p_r)

 {

         Transform3D rMpr = mServices.patientModelService->get_rMpr();

         Vector3D p_pr = rMpr.inv().coord(p_r);


         // set the picked point as offset tip

         ToolPtr tool = mServices.trackingService->getManualTool();

         Vector3D offset = tool->get_prMt().vector(Vector3D(0, 0, tool->getTooltipOffset()));

         p_pr -= offset;

         p_r = rMpr.coord(p_pr);


         // TODO set center here will not do: must handle

         mServices.patientModelService->setCenter(p_r);

         Vector3D p0_pr = tool->get_prMt().coord(Vector3D(0, 0, 0));

         tool->set_prMt(createTransformTranslate(p_pr - p0_pr) * tool->get_prMt());

 }


 void LandmarkRegistrationWidget::showEvent(QShowEvent* event)

 {

         QWidget::showEvent(event);

         connect(mServices.patientModelService.get(), &PatientModelService::landmarkPropertiesChanged,

                         this, &LandmarkRegistrationWidget::landmarkUpdatedSlot);


 //      mManager->restart();

         mServices.registrationService->setLastRegistrationTime(QDateTime::currentDateTime());

         this->setModified();

 }


 void LandmarkRegistrationWidget::hideEvent(QHideEvent* event)

 {

         QWidget::hideEvent(event);

         disconnect(mServices.patientModelService.get(), &PatientModelService::landmarkPropertiesChanged,

                         this, &LandmarkRegistrationWidget::landmarkUpdatedSlot);

 }


 void LandmarkRegistrationWidget::prePaintEvent()

 {

         mLandmarkTableWidget->blockSignals(true);

         mLandmarkTableWidget->clear();


         QString fixedName;

         DataPtr fixedData = boost::dynamic_pointer_cast<Data>(mServices.registrationService->getFixedData());

         if (fixedData)

                 fixedName = fixedData->getName();


         std::vector<Landmark> landmarks = this->getAllLandmarks();

         LandmarkMap targetData = this->getTargetLandmarks();

         Transform3D rMtarget = this->getTargetTransform();


         //ready the table widget

         mLandmarkTableWidget->setRowCount((int)landmarks.size());

         mLandmarkTableWidget->setColumnCount(4);

         QStringList headerItems(QStringList() << "Name" << "Status" << "Coordinates" << "Accuracy (mm)");

         mLandmarkTableWidget->setHorizontalHeaderLabels(headerItems);

         mLandmarkTableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);

         mLandmarkTableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);


         for (unsigned i = 0; i < landmarks.size(); ++i)

         {

                 std::vector<QTableWidgetItem*> items(4); // name, status, coordinates, accuracy


                 LandmarkProperty prop = mServices.patientModelService->getLandmarkProperties()[landmarks[i].getUid()];

                 Vector3D coord = landmarks[i].getCoord();

                 coord = rMtarget.coord(coord); // display coordinates in space r (in principle, this means all coords should be equal)


                 items[0] = new QTableWidgetItem(qstring_cast(prop.getName()));

                 items[0]->setToolTip(QString("Landmark name. Double-click to rename."));


                 items[1] = new QTableWidgetItem;


                 if (prop.getActive())

                         items[1]->setCheckState(Qt::Checked);

                 else

                         items[1]->setCheckState(Qt::Unchecked);

                 items[1]->setToolTip(QString("Check to use landmark in current registration."));


                 QString coordText = "Not sampled";

                 if (targetData.count(prop.getUid()))

                 {

                         int width = 5;

                         int prec = 1;

                         coordText = tr("(%1, %2, %3)").arg(coord[0], width, 'f', prec).arg(coord[1], width, 'f', prec).arg(

                                 coord[2], width, 'f', prec);

                 }


                 items[2] = new QTableWidgetItem(coordText);

                 items[2]->setToolTip(QString("Landmark coordinates of target [%1] in reference space.").arg(this->getTargetName()));


                 items[3] = new QTableWidgetItem(tr("%1").arg(this->getAccuracy(landmarks[i].getUid())));

                 items[3]->setToolTip(QString("Distance from target [%1] to fixed [%2].").arg(this->getTargetName()).arg(fixedName));


                 for (unsigned j = 0; j < items.size(); ++j)

                 {

                         items[j]->setData(Qt::UserRole, qstring_cast(prop.getUid()));

                         mLandmarkTableWidget->setItem(i, j, items[j]);

                 }


                 //highlight selected row

                 if (prop.getUid() == mActiveLandmark)

                 {

                         mLandmarkTableWidget->setCurrentItem(items[2]);

                 }

         }


         this->updateAverageAccuracyLabel();

         mLandmarkTableWidget->blockSignals(false);

 }


 void LandmarkRegistrationWidget::activateLandmark(QString uid)

 {

     mActiveLandmark = uid;

     this->setModified();

 }


 QString LandmarkRegistrationWidget::getNextLandmark()

 {

     std::vector<Landmark> lm = this->getAllLandmarks();


     for (int i=0; i<lm.size()-1; ++i)

     {

         if (lm[i].getUid()==mActiveLandmark)

         {

             return lm[i+1].getUid();

         }

     }


     return "";

 }


 std::vector<Landmark> LandmarkRegistrationWidget::getAllLandmarks() const

 {

         std::vector<Landmark> retval;

         LandmarkMap targetData = this->getTargetLandmarks();

         std::map<QString, LandmarkProperty> dataData = mServices.patientModelService->getLandmarkProperties();

         std::map<QString, LandmarkProperty>::iterator iter;


         for (iter = dataData.begin(); iter != dataData.end(); ++iter)

         {

                 if (targetData.count(iter->first))

                         retval.push_back(targetData[iter->first]);

                 else

                         retval.push_back(Landmark(iter->first));

         }


         std::sort(retval.begin(), retval.end());


         return retval;

 }


 void LandmarkRegistrationWidget::cellChangedSlot(int row, int column)

 {

         QTableWidgetItem* item = mLandmarkTableWidget->item(row, column);

         QString uid = item->data(Qt::UserRole).toString();


         if (column == 0)

         {

                 QString name = item->text();

                 mServices.patientModelService->setLandmarkName(uid, name);

         }

         if (column == 1)

         {

                 Qt::CheckState state = item->checkState();

                 mServices.patientModelService->setLandmarkActive(uid, state == Qt::Checked);

                 this->performRegistration(); // automatic when changing active state (Mantis #0000674)s

         }

         if (column == 2)

         {

                 QString val = item->text();

                 // remove formatting stuff:

                 val = val.replace('(', " ");

                 val = val.replace(')', " ");

                 val = val.replace(',', " ");


                 Transform3D rMtarget = this->getTargetTransform();


                 Vector3D p_r = Vector3D::fromString(val);

                 Vector3D p_target = rMtarget.inv().coord(p_r);

                 this->setTargetLandmark(uid, p_target);

         }

 }


 void LandmarkRegistrationWidget::landmarkUpdatedSlot()

 {

 //  - This has too many side effects when we use the landmarks for several different registrations,

 //      i.e. image2image, patient, fast... Rather register explicitly, and add it to the buttons where you

 //  want the automation, such as in the patient reg sampler. (Mantis #0000674)

 //      this->performRegistration();

     this->setModified();

 }


 void LandmarkRegistrationWidget::updateAverageAccuracyLabel()

 {

         QString fixedName;

         DataPtr fixedData = boost::dynamic_pointer_cast<Data>(mServices.registrationService->getFixedData());

         if (fixedData)

                 fixedName = fixedData->getName();


         if(this->isAverageAccuracyValid())

         {

                 mAvarageAccuracyLabel->setText(tr("Mean accuracy %1 mm").arg(this->getAverageAccuracy(), 0, 'f', 2));

                 mAvarageAccuracyLabel->setToolTip(QString("Average landmark accuracy from target [%1] to fixed [%2].").arg(this->getTargetName()).arg(fixedName));

         }

         else

         {

                 mAvarageAccuracyLabel->setText(" ");

                 mAvarageAccuracyLabel->setToolTip("");

         }

 }


 bool LandmarkRegistrationWidget::isAverageAccuracyValid()

 {

         int numActiveLandmarks = 0;

         this->getAverageAccuracy(numActiveLandmarks);

         if(numActiveLandmarks < 3)

                 return false;

         return true;

 }


 double LandmarkRegistrationWidget::getAverageAccuracy()

 {

         int numActiveLandmarks = 0;

         return this->getAverageAccuracy(numActiveLandmarks);

 }


 double LandmarkRegistrationWidget::getAverageAccuracy(int& numActiveLandmarks)

 {

         std::map<QString, LandmarkProperty> props = mServices.patientModelService->getLandmarkProperties();


         double sum = 0;

         numActiveLandmarks = 0;

         std::map<QString, LandmarkProperty>::iterator it = props.begin();

         for (; it != props.end(); ++it)

         {

                 if (!it->second.getActive()) //we don't want to take into account not active landmarks

                         continue;

                 QString uid = it->first;

                 double val = this->getAccuracy(uid);

                 if (!similar(val, 1000.0))

                 {

                         sum = sum + val;

                         numActiveLandmarks++;

                 }

         }

         if (numActiveLandmarks == 0)

                 return 1000;

         return sum / numActiveLandmarks;

 }


 double LandmarkRegistrationWidget::getAccuracy(QString uid)

 {

         DataPtr fixedData = mServices.registrationService->getFixedData();

         if (!fixedData)

                 return 1000.0;


         Landmark masterLandmark = fixedData->getLandmarks()->getLandmarks()[uid];

         Landmark targetLandmark = this->getTargetLandmarks()[uid];

         if (masterLandmark.getUid().isEmpty() || targetLandmark.getUid().isEmpty())

                 return 1000.0;


         Vector3D p_master_master = masterLandmark.getCoord();

         Vector3D p_target_target = targetLandmark.getCoord();

         Transform3D rMmaster = fixedData->get_rMd();

         Transform3D rMtarget = this->getTargetTransform();


         Vector3D p_target_r = rMtarget.coord(p_target_target);

         Vector3D p_master_r = rMmaster.coord(p_master_master);


         return (p_target_r - p_master_r).length();

 }


 }//namespace cx

qstring_cast
QString qstring_cast(const T &val)
Definition: cxTypeConversions.h:67

cx::Landmark::getUid
QString getUid() const
Definition: cxLandmark.cpp:54

cx::LandmarkRegistrationWidget::performRegistration
virtual void performRegistration()=0

cx::LandmarkRegistrationWidget::showEvent
virtual void showEvent(QShowEvent *event)
updates internal info before showing the widget
Definition: cxLandmarkRegistrationWidget.cpp:121

cx::RegistrationBaseWidget::mServices
RegServices mServices
Definition: cxRegistrationBaseWidget.h:56

cx::LandmarkRegistrationWidget::mAvarageAccuracyLabel
QLabel * mAvarageAccuracyLabel
label showing the average accuracy
Definition: cxLandmarkRegistrationWidget.h:101

cx::PatientModelService::landmarkPropertiesChanged
void landmarkPropertiesChanged()
emitted when global info about a landmark changed

cx::Landmark
One landmark, or fiducial, coordinate.
Definition: cxLandmark.h:61

cxLogger.h

cx::Transform3D
Transform3D Transform3D
Transform3D is a representation of an affine 3D transform.
Definition: cxLandmarkPatientRegistrationWidget.h:55

cxManualTool.h

cx::LandmarkRegistrationWidget::activateLandmark
void activateLandmark(QString uid)
Definition: cxLandmarkRegistrationWidget.cpp:212

cx::LandmarkProperty::getUid
QString getUid() const
Definition: cxLandmark.cpp:196

cx::LandmarkRegistrationWidget::getNextLandmark
QString getNextLandmark()
Definition: cxLandmarkRegistrationWidget.cpp:221

cxTypeConversions.h

cx::LandmarkRegistrationWidget::mVerticalLayout
QVBoxLayout * mVerticalLayout
vertical layout is used
Definition: cxLandmarkRegistrationWidget.h:99

cx::RegistrationBaseWidget
Definition: cxRegistrationBaseWidget.h:49

cx::similar
bool similar(const DoubleBoundingBox3D &a, const DoubleBoundingBox3D &b, double tol)
Definition: cxBoundingBox3D.cpp:249

cx::LandmarkRegistrationWidget::hideEvent
virtual void hideEvent(QHideEvent *event)
Definition: cxLandmarkRegistrationWidget.cpp:132

cx::RegServices
Definition: cxRegServices.h:54

cx::LandmarkRegistrationWidget::landmarkUpdatedSlot
void landmarkUpdatedSlot()
Definition: cxLandmarkRegistrationWidget.cpp:288

cx::DataPtr
boost::shared_ptr< class Data > DataPtr
Definition: cxRegistrationApplicator.h:43

cx::LandmarkRegistrationWidget::getTargetTransform
virtual Transform3D getTargetTransform() const =0
Return transform from target space to reference space.

cx::Data::getName
virtual QString getName() const
Definition: cxData.cpp:83

cx::LandmarkRegistrationWidget::~LandmarkRegistrationWidget
virtual ~LandmarkRegistrationWidget()
Definition: cxLandmarkRegistrationWidget.cpp:69

cx::LandmarkRegistrationWidget::cellClickedSlot
virtual void cellClickedSlot(int row, int column)
when a landmark i selected from the table
Definition: cxLandmarkRegistrationWidget.cpp:82

coord
Vector3d coord(const Vector3d &v) const
transform a coordinate [x,y,z,1].

cx::createTransformTranslate
Transform3D createTransformTranslate(const Vector3D &translation)
Definition: cxTransform3D.cpp:185

cx::LandmarkRegistrationWidget::prePaintEvent
virtual void prePaintEvent()
populates the table widget
Definition: cxLandmarkRegistrationWidget.cpp:139

cxTrackingService.h

cx::Landmark::getCoord
Vector3D getCoord() const
Definition: cxLandmark.cpp:59

cx::LandmarkRegistrationWidget::getAccuracy
double getAccuracy(QString uid)
Definition: cxLandmarkRegistrationWidget.cpp:355

cxLandmarkRegistrationWidget.h

cx::Vector3D
Eigen::Vector3d Vector3D
Vector3D is a representation of a point or vector in 3D.
Definition: cxVector3D.h:63

cx::LandmarkRegistrationWidget::setManualToolPosition
void setManualToolPosition(Vector3D p_r)
Definition: cxLandmarkRegistrationWidget.cpp:104

cx::LandmarkRegistrationWidget::getTargetLandmarks
virtual LandmarkMap getTargetLandmarks() const =0

cx::Data
Superclass for all data objects.
Definition: cxData.h:69

cxRegistrationService.h

cx::LandmarkRegistrationWidget::updateAverageAccuracyLabel
void updateAverageAccuracyLabel()
Definition: cxLandmarkRegistrationWidget.cpp:297

cx::LandmarkMap
std::map< QString, class Landmark > LandmarkMap
Definition: cxLandmarkRegistrationWidget.h:49

cx::LandmarkRegistrationWidget::mActiveLandmark
QString mActiveLandmark
uid of surrently selected landmark.
Definition: cxLandmarkRegistrationWidget.h:104

cx::CoreServices::trackingService
TrackingServicePtr trackingService
Definition: cxCoreServices.h:72

cx::LandmarkProperty::getName
QString getName() const
Definition: cxLandmark.cpp:206

cx::LandmarkRegistrationWidget::getAllLandmarks
std::vector< Landmark > getAllLandmarks() const
get all the landmarks from the image and the datamanager
Definition: cxLandmarkRegistrationWidget.cpp:236

cxLandmark.h

cx::LandmarkRegistrationWidget::defaultWhatsThis
virtual QString defaultWhatsThis() const
Returns a short description of what this widget will do for you.
Definition: cxLandmarkRegistrationWidget.cpp:73

cx::LandmarkProperty
Definition: cxLandmark.h:111

cx::LandmarkRegistrationWidget::setTargetLandmark
virtual void setTargetLandmark(QString uid, Vector3D p_target)=0

cx::CoreServices::patientModelService
PatientModelServicePtr patientModelService
Definition: cxCoreServices.h:71

cx::OptimizedUpdateWidget::setModified
virtual void setModified()
Definition: cxOptimizedUpdateWidget.cpp:52

cx::LandmarkRegistrationWidget::getTargetName
virtual QString getTargetName() const =0

cx::LandmarkRegistrationWidget::getAverageAccuracy
double getAverageAccuracy()
Definition: cxLandmarkRegistrationWidget.cpp:325

cxData.h

cx::LandmarkProperty::getActive
bool getActive() const
Definition: cxLandmark.cpp:201

cx::reportDebug
void reportDebug(QString msg)
Definition: cxLogger.cpp:89

cx::RegServices::registrationService
RegistrationServicePtr registrationService
Definition: cxRegServices.h:60

cxPatientModelService.h

cx::LandmarkRegistrationWidget::mLandmarkTableWidget
QTableWidget * mLandmarkTableWidget
the table widget presenting the landmarks
Definition: cxLandmarkRegistrationWidget.h:100

cx::LandmarkRegistrationWidget::cellChangedSlot
void cellChangedSlot(int row, int column)
reacts when the user types in a (landmark) name
Definition: cxLandmarkRegistrationWidget.cpp:256

cx::ToolPtr
boost::shared_ptr< class Tool > ToolPtr
Definition: cxVideoConnectionWidget.h:65