cxLandmarkRegistrationWidget.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
 
CustusX is released under a BSD 3-Clause license.
 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#include "cxLandmarkRegistrationWidget.h"
 
#include <sstream>
#include <QVBoxLayout>
#include <QPushButton>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QHeaderView>
#include <QLabel>
#include <QSlider>
#include <QCheckBox>
#include <vtkDoubleArray.h>
#include <vtkImageData.h>
 
#include "cxTypeConversions.h"
#include "cxManualTool.h"
#include "cxPatientModelService.h"
#include "cxRegistrationService.h"
#include "cxViewService.h"
#include"cxData.h"
#include "cxLogger.h"
#include "cxLandmark.h"
#include "cxTrackingService.h"
#include "cxLandmarkListener.h"
 
namespace cx
{
LandmarkRegistrationWidget::LandmarkRegistrationWidget(RegServicesPtr services, QWidget* parent, QString objectName, QString windowTitle, bool showAccuracy) :
        RegistrationBaseWidget(services, parent, objectName, windowTitle), mVerticalLayout(new QVBoxLayout(this)),
        mLandmarkTableWidget(new QTableWidget(this)), mAvarageAccuracyLabel(new QLabel(QString(" "), this)),
        mActiveLandmark(""),
        mLandmarkListener(new LandmarkListener(services)), mShowAccuracy(showAccuracy),
        mMouseClickSample(nullptr)
{
        //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);
 
        mMouseClickSample = new QCheckBox("Resample with mouse clicks in anyplane view.", this);
        mMouseClickSample->setToolTip("Allow mouse clicks in 2D anyplane view to sample patient landmarks.");
        mMouseClickSample->hide();
}
 
LandmarkRegistrationWidget::~LandmarkRegistrationWidget()
{
}
 
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->patient()->get_rMpr().coord(p_r);
                this->setManualToolPosition(p_r);
        }
 
}
 
void LandmarkRegistrationWidget::setManualToolPosition(Vector3D p_r)
{
        Transform3D rMpr = mServices->patient()->get_rMpr();
        Vector3D p_pr = rMpr.inv().coord(p_r);
 
        // set the picked point as offset tip
        ToolPtr tool = mServices->tracking()->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->patient()->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)
{
        this->selectFirstLandmarkIfUnselected();
        QWidget::showEvent(event);
        mMouseClickSample->setChecked(false);
        mLandmarkListener->showRep();
        connect(mServices->patient().get(), &PatientModelService::landmarkPropertiesChanged,this, &LandmarkRegistrationWidget::landmarkUpdatedSlot);
        connect(mServices->patient()->getPatientLandmarks().get(), &Landmarks::landmarkAdded, this, &LandmarkRegistrationWidget::landmarkUpdatedSlot);
        connect(mServices->patient()->getPatientLandmarks().get(), &Landmarks::landmarkRemoved, this, &LandmarkRegistrationWidget::landmarkUpdatedSlot);
 
        connect(mServices->view().get(), &ViewService::activeLayoutChanged, mLandmarkListener.get(), &LandmarkListener::showRep);
 
        //mManager->restart();
        mServices->registration()->setLastRegistrationTime(QDateTime::currentDateTime());
        this->setModified();
 
}
 
void LandmarkRegistrationWidget::selectFirstLandmarkIfUnselected()
{
        std::vector<Landmark> landmarks = this->getAllLandmarks();
        if(mActiveLandmark.isEmpty() || mActiveLandmark.toInt() > landmarks.size())
        {
                if(landmarks.size() > 0)
                {
                        QString firstLandmarkUid = landmarks[0].getUid();
                        this->activateLandmark(firstLandmarkUid);
                }
        }
        if(!mActiveLandmark.isEmpty() && landmarks.empty())
                this->activateLandmark("");
}
 
void LandmarkRegistrationWidget::hideEvent(QHideEvent* event)
{
        QWidget::hideEvent(event);
        mMouseClickSample->setChecked(false);
        disconnect(mServices->patient().get(), &PatientModelService::landmarkPropertiesChanged, this, &LandmarkRegistrationWidget::landmarkUpdatedSlot);
        disconnect(mServices->patient()->getPatientLandmarks().get(), &Landmarks::landmarkAdded, this, &LandmarkRegistrationWidget::landmarkUpdatedSlot);
        disconnect(mServices->patient()->getPatientLandmarks().get(), &Landmarks::landmarkRemoved, this, &LandmarkRegistrationWidget::landmarkUpdatedSlot);
        disconnect(mServices->view().get(), &ViewService::activeLayoutChanged, mLandmarkListener.get(), &LandmarkListener::showRep);
        mLandmarkListener->hideRep();
}
 
void LandmarkRegistrationWidget::prePaintEvent()
{
        mLandmarkTableWidget->blockSignals(true);
        mLandmarkTableWidget->clear();
 
        QString fixedName;
        DataPtr fixedData = boost::dynamic_pointer_cast<Data>(mServices->registration()->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());
        QStringList headerItems(QStringList() << "Name" << "Status" << "Coordinates");
        if (mShowAccuracy)
        {
                mLandmarkTableWidget->setColumnCount(4);
                headerItems.append("Accuracy (mm)");
        }
        else
                mLandmarkTableWidget->setColumnCount(3);
 
        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->patient()->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();
        this->selectFirstLandmarkIfUnselected();
}
 
QString LandmarkRegistrationWidget::getNextLandmark()
{
        std::vector<Landmark> lm = this->getAllLandmarks();
 
        int size = int(lm.size());
        for (unsigned i=0; int(i) < 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->patient()->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->patient()->setLandmarkName(uid, name);
        }
        if (column == 1)
        {
                Qt::CheckState state = item->checkState();
                mServices->patient()->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();
        this->selectFirstLandmarkIfUnselected();
}
 
void LandmarkRegistrationWidget::updateAverageAccuracyLabel()
{
        QString fixedName;
        DataPtr fixedData = boost::dynamic_pointer_cast<Data>(mServices->registration()->getFixedData());
        if (fixedData)
                fixedName = fixedData->getName();
 
        if(this->isAverageAccuracyValid() && mShowAccuracy)
        {
                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->patient()->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->registration()->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();
}
 
void LandmarkRegistrationWidget::mouseClickSampleStateChanged()
{
        if(mMouseClickSample->isChecked())
                connect(mServices->view().get(), &ViewService::pointSampled, this, &LandmarkRegistrationWidget::pointSampled);
        else
                disconnect(mServices->view().get(), &ViewService::pointSampled, this, &LandmarkRegistrationWidget::pointSampled);
}
 
QTableWidgetItem * LandmarkRegistrationWidget::getLandmarkTableItem()
{
        if(!mLandmarkTableWidget)
                return NULL;
 
        int row = mLandmarkTableWidget->currentRow();
        int column = mLandmarkTableWidget->currentColumn();
 
        if((row < 0) && (mLandmarkTableWidget->rowCount() >= 0))
                row = 0;
        if((column < 0) && (mLandmarkTableWidget->columnCount() >= 0))
                column = 0;
 
        QTableWidgetItem* item = mLandmarkTableWidget->item(row, column);
 
        return item;
}
 
}//namespace cx