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