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

#include <sstream>
#include <QVBoxLayout>
#include <QPushButton>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QHeaderView>
#include <QLabel>
#include <QSlider>
#include <vtkDoubleArray.h>
#include <vtkImageData.h>
#include "cxLogger.h"
#include "cxPickerRep.h"
#include "cxLabeledComboBoxWidget.h"
#include "cxSettings.h"
#include "cxLandmarkRep.h"
#include "cxView.h"
#include "cxTypeConversions.h"
#include "cxSelectDataStringProperty.h"
#include "cxRegistrationService.h"
#include "cxPatientModelService.h"
#include "cxViewService.h"
#include "cxRepContainer.h"
#include "cxTrackingService.h"
#include "cxLandmarkListener.h"
#include "cxActiveData.h"
#include "cxMesh.h"
#include "cxTime.h"

namespace cx
{
CenterlinePointsWidget::CenterlinePointsWidget(RegServicesPtr services, QWidget* parent,
        QString objectName, QString windowTitle, bool useRegistrationFixedPropertyInsteadOfActiveImage) :
    LandmarkRegistrationWidget(services, parent, objectName, windowTitle, false),
        mUseRegistrationFixedPropertyInsteadOfActiveImage(useRegistrationFixedPropertyInsteadOfActiveImage)
{
        if(mUseRegistrationFixedPropertyInsteadOfActiveImage)
                mCurrentProperty.reset(new StringPropertyRegistrationFixedImage(services->registration(), services->patient()));
        else
                mCurrentProperty = StringPropertySelectData::New(mServices->patient());
    connect(mCurrentProperty.get(), &Property::changed, this, &CenterlinePointsWidget::onCurrentImageChanged);

        mLandmarkListener->useOnlyOneSourceUpdatedFromOutside();

        mActiveToolProxy = ActiveToolProxy::New(services->tracking());
        connect(mActiveToolProxy.get(), SIGNAL(toolVisible(bool)), this, SLOT(enableButtons()));
        connect(mActiveToolProxy.get(), SIGNAL(activeToolChanged(const QString&)), this, SLOT(enableButtons()));

        //pushbuttons
        mAddLandmarkButton = new QPushButton("New Landmark", this);
        mAddLandmarkButton->setToolTip("Add landmark");
        mAddLandmarkButton->setDisabled(true);
        connect(mAddLandmarkButton, SIGNAL(clicked()), this, SLOT(addLandmarkButtonClickedSlot()));

        mEditLandmarkButton = new QPushButton("Resample", this);
        mEditLandmarkButton->setToolTip("Resample existing landmark");
        mEditLandmarkButton->setDisabled(true);
        connect(mEditLandmarkButton, SIGNAL(clicked()), this, SLOT(editLandmarkButtonClickedSlot()));

    mRemoveLandmarkButton = new QPushButton("Clear", this);
    mRemoveLandmarkButton->setToolTip("Clear selected landmark");
    mRemoveLandmarkButton->setDisabled(true);
    connect(mRemoveLandmarkButton, SIGNAL(clicked()), this, SLOT(removeLandmarkButtonClickedSlot()));

    mCreateCenterlineButton = new QPushButton("Create centerline", this);
    mCreateCenterlineButton->setToolTip("Create centerline from landmarks");
    mCreateCenterlineButton->setDisabled(true);
    connect(mCreateCenterlineButton, SIGNAL(clicked()), this, SLOT(createCenterlineButtonClickedSlot()));

        //layout
        mVerticalLayout->addWidget(new LabeledComboBoxWidget(this, mCurrentProperty));
        mVerticalLayout->addWidget(mLandmarkTableWidget);
    mVerticalLayout->addWidget(mAvarageAccuracyLabel);

        QHBoxLayout* landmarkButtonsLayout = new QHBoxLayout;
        landmarkButtonsLayout->addWidget(mAddLandmarkButton);
        landmarkButtonsLayout->addWidget(mEditLandmarkButton);
    landmarkButtonsLayout->addWidget(mRemoveLandmarkButton);
    landmarkButtonsLayout->addWidget(mCreateCenterlineButton);
        mVerticalLayout->addLayout(landmarkButtonsLayout);
}

CenterlinePointsWidget::~CenterlinePointsWidget()
{
}

void CenterlinePointsWidget::onCurrentImageChanged()
{
        DataPtr data = mCurrentProperty->getData();

        mLandmarkListener->setLandmarkSource(data);
        this->enableButtons();

        if (data && !mServices->registration()->getFixedData())
                mServices->registration()->setFixedData(data);

        this->setModified();
}

PickerRepPtr CenterlinePointsWidget::getPickerRep()
{
        return mServices->view()->get3DReps(0, 0)->findFirst<PickerRep>();
}

DataPtr CenterlinePointsWidget::getCurrentData() const
{
        return mLandmarkListener->getLandmarkSource();
}

void CenterlinePointsWidget::addLandmarkButtonClickedSlot()
{
        PickerRepPtr PickerRep = this->getPickerRep();
        if (!PickerRep)
        {
                reportError("Need a 3D view to set landmarks.");
                return;
        }

        DataPtr image = this->getCurrentData();
        if (!image)
                return;

        QString uid = mServices->patient()->addLandmark();
        Vector3D pos_r = PickerRep->getPosition();
        Vector3D pos_d = image->get_rMd().inv().coord(pos_r);
        image->getLandmarks()->setLandmark(Landmark(uid, pos_d));

    this->activateLandmark(uid);
}


void CenterlinePointsWidget::editLandmarkButtonClickedSlot()
{
        PickerRepPtr PickerRep = this->getPickerRep();
        if (!PickerRep)
        {
                reportError("Need a 3D view to edit landmarks.");
                return;
        }

        DataPtr image = this->getCurrentData();
        if (!image)
                return;

        QString uid = mActiveLandmark;
        Vector3D pos_r = PickerRep->getPosition();
        Vector3D pos_d = image->get_rMd().inv().coord(pos_r);
        image->getLandmarks()->setLandmark(Landmark(uid, pos_d));

    this->activateLandmark(this->getNextLandmark());
}

void CenterlinePointsWidget::removeLandmarkButtonClickedSlot()
{
    DataPtr image = this->getCurrentData();
    if (!image)
        return;

    QString next = this->getNextLandmark();
    image->getLandmarks()->removeLandmark(mActiveLandmark);
    this->activateLandmark(next);
}

void CenterlinePointsWidget::createCenterlineButtonClickedSlot()
{
        DataPtr image = this->getCurrentData();
        if (!image)
                return;

    Transform3D rMd = image->get_rMd();

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

    vtkPolyDataPtr outputPositions = vtkPolyDataPtr::New();
    vtkPointsPtr points = vtkPointsPtr::New();
    vtkCellArrayPtr lines = vtkCellArrayPtr::New();

    for(int i=0; i<landmarkVector.size(); i++)
    {
        LandmarkProperty prop = mServices->patient()->getLandmarkProperties()[landmarkVector[i].getUid()];
        if (prop.getActive())
        {
            Vector3D pos = landmarkVector[i].getCoord();
            pos = rMd.coord(pos);
            points->InsertNextPoint(pos(0),pos(1),pos(2));
        }
    }
    for(int i=0; i<points->GetNumberOfPoints()-1; i++)
    {
        vtkIdType connection[2] = {i, i+1};
        lines->InsertNextCell(2, connection);
    }

    outputPositions->SetPoints(points);
    outputPositions->SetLines(lines);

    QString filename;
    QString format = timestampSecondsFormatNice();
    filename = "CenterlineFromPoints " + QDateTime::currentDateTime().toString(format);

    MeshPtr mesh = mServices->patient()->createSpecificData<Mesh>(filename, filename);
    mesh->setVtkPolyData(outputPositions);
    mesh->setColor(QColor(0, 0, 255, 255));
    mServices->patient()->insertData(mesh);
    mServices->view()->autoShowData(mesh);
}

void CenterlinePointsWidget::cellClickedSlot(int row, int column)
{
        LandmarkRegistrationWidget::cellClickedSlot(row, column);
        this->enableButtons();
}

void CenterlinePointsWidget::enableButtons()
{
        bool selected = !mLandmarkTableWidget->selectedItems().isEmpty();
        bool loaded = this->getCurrentData() != 0;

        mEditLandmarkButton->setEnabled(selected);
    mRemoveLandmarkButton->setEnabled(selected);
    mCreateCenterlineButton->setEnabled(selected);
        mAddLandmarkButton->setEnabled(loaded);

        DataPtr image = this->getCurrentData();
        if (image)
        {
                mAddLandmarkButton->setToolTip(QString("Add landmark to image %1").arg(image->getName()));
                mEditLandmarkButton->setToolTip(QString("Resample landmark in image %1").arg(image->getName()));
        }
//      this->setModified();
}

void CenterlinePointsWidget::showEvent(QShowEvent* event)
{
        mServices->view()->setRegistrationMode(rsIMAGE_REGISTRATED);
        LandmarkRegistrationWidget::showEvent(event);

        if(!mUseRegistrationFixedPropertyInsteadOfActiveImage)
        {
                ActiveDataPtr activeData = mServices->patient()->getActiveData();
                ImagePtr image = activeData->getActive<Image>();
                if (image)
                        mCurrentProperty->setValue(image->getUid());
        }
}

void CenterlinePointsWidget::hideEvent(QHideEvent* event)
{
        mServices->view()->setRegistrationMode(rsNOT_REGISTRATED);
        LandmarkRegistrationWidget::hideEvent(event);

}

void CenterlinePointsWidget::prePaintEvent()
{
    LandmarkRegistrationWidget::prePaintEvent();

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

        //update buttons
    mCreateCenterlineButton->setEnabled(!landmarks.empty() && !mActiveLandmark.isEmpty());
        mEditLandmarkButton->setEnabled(!landmarks.empty() && !mActiveLandmark.isEmpty());
}

LandmarkMap CenterlinePointsWidget::getTargetLandmarks() const
{
        DataPtr image = this->getCurrentData();
        if (!image)
                return LandmarkMap();

        return image->getLandmarks()->getLandmarks();
}

Transform3D CenterlinePointsWidget::getTargetTransform() const
{
        DataPtr image = this->getCurrentData();
        if (!image)
                return Transform3D::Identity();
        return image->get_rMd();
}

void CenterlinePointsWidget::setTargetLandmark(QString uid, Vector3D p_target)
{
        DataPtr image = this->getCurrentData();
        if (!image)
                return;
        image->getLandmarks()->setLandmark(Landmark(uid, p_target));
}

QString CenterlinePointsWidget::getTargetName() const
{
        DataPtr image = this->getCurrentData();
        if (!image)
                return "None";
        return image->getName();
}


}//namespace cx