diff --git a/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrection.cpp b/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrection.cpp
index 28f1720909..67acaa8b43 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrection.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrection.cpp
@@ -1,722 +1,720 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "org_mitk_gui_qt_matchpoint_framereg_Activator.h"
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
#include <berryISelectionProvider.h>
#include <berryQModelIndexObject.h>
// Mitk
#include <mitkStatusBar.h>
#include <mitkPointSet.h>
#include <mitkImageTimeSelector.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateDimension.h>
#include <mitkNodePredicateGeometry.h>
#include <mitkMAPAlgorithmInfoSelection.h>
#include <mitkRegistrationHelper.h>
#include <mitkResultNodeGenerationHelper.h>
// Qmitk
#include "QmitkMatchPointFrameCorrection.h"
#include <QmitkRegistrationJob.h>
#include <QmitkMappingJob.h>
// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QErrorMessage>
#include <QThreadPool>
#include <QDateTime>
// MatchPoint
#include <mapImageRegistrationAlgorithmInterface.h>
#include <mapPointSetRegistrationAlgorithmInterface.h>
#include <mapRegistrationAlgorithmInterface.h>
#include <mapMaskedRegistrationAlgorithmInterface.h>
#include <mapAlgorithmEvents.h>
#include <mapAlgorithmWrapperEvent.h>
#include <mapExceptionObjectMacros.h>
#include <mapConvert.h>
#include <mapDeploymentDLLAccess.h>
const std::string QmitkMatchPointFrameCorrection::VIEW_ID =
"org.mitk.views.matchpoint.algorithm.framereg";
QmitkMatchPointFrameCorrection::QmitkMatchPointFrameCorrection()
: m_Parent(nullptr), m_LoadedDLLHandle(nullptr), m_LoadedAlgorithm(nullptr), m_CanLoadAlgorithm(false), m_Working(false)
{
m_spSelectedTargetData = nullptr;
m_spSelectedTargetMaskData = nullptr;
}
QmitkMatchPointFrameCorrection::~QmitkMatchPointFrameCorrection()
{
// remove selection service
berry::ISelectionService* s = this->GetSite()->GetWorkbenchWindow()->GetSelectionService();
if (s)
{
s->RemoveSelectionListener(m_AlgorithmSelectionListener.data());
}
}
void QmitkMatchPointFrameCorrection::SetFocus()
{
}
void QmitkMatchPointFrameCorrection::CreateConnections()
{
connect(m_Controls.imageNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.maskNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
// ------
// Tab 1 - Shared library loading interface
// ------
connect(m_Controls.m_pbLoadSelected, SIGNAL(clicked()), this, SLOT(OnLoadAlgorithmButtonPushed()));
// -----
// Tab 2 - Execution
// -----
connect(m_Controls.m_pbStartReg, SIGNAL(clicked()), this, SLOT(OnStartRegBtnPushed()));
connect(m_Controls.m_pbSaveLog, SIGNAL(clicked()), this, SLOT(OnSaveLogBtnPushed()));
// -----
// Tab 4 - Frames
// -----
connect(m_Controls.m_btnFrameSelAll, SIGNAL(clicked()), this, SLOT(OnFramesSelectAllPushed()));
connect(m_Controls.m_btnFrameDeSelAll, SIGNAL(clicked()), this, SLOT(OnFramesDeSelectAllPushed()));
connect(m_Controls.m_btnFrameInvert, SIGNAL(clicked()), this, SLOT(OnFramesInvertPushed()));
}
const map::deployment::DLLInfo* QmitkMatchPointFrameCorrection::GetSelectedAlgorithmDLL() const
{
return m_SelectedAlgorithmInfo;
}
void QmitkMatchPointFrameCorrection::OnSelectedAlgorithmChanged()
{
std::stringstream descriptionString;
::map::deployment::DLLInfo::ConstPointer currentItemInfo = GetSelectedAlgorithmDLL();
if (!currentItemInfo)
{
return;
}
m_Controls.m_teAlgorithmDetails->updateInfo(currentItemInfo);
m_Controls.m_lbSelectedAlgorithm->setText(QString::fromStdString(
currentItemInfo->getAlgorithmUID().getName()));
// enable loading
m_CanLoadAlgorithm = true;
this->AdaptFolderGUIElements();
}
void QmitkMatchPointFrameCorrection::OnLoadAlgorithmButtonPushed()
{
map::deployment::DLLInfo::ConstPointer dllInfo = GetSelectedAlgorithmDLL();
if (!dllInfo)
{
Error(QString("No valid algorithm is selected. Cannot load algorithm. ABORTING."));
return;
}
::map::deployment::DLLHandle::Pointer tempDLLHandle = ::map::deployment::openDeploymentDLL(
dllInfo->getLibraryFilePath());
::map::algorithm::RegistrationAlgorithmBase::Pointer tempAlgorithm
= ::map::deployment::getRegistrationAlgorithm(tempDLLHandle);
if (tempAlgorithm.IsNull())
{
Error(QString("Error. Cannot load selected algorithm."));
return;
}
this->m_LoadedAlgorithm = tempAlgorithm;
this->m_LoadedDLLHandle = tempDLLHandle;
this->m_Controls.m_AlgoConfigurator->setAlgorithm(m_LoadedAlgorithm);
this->AdaptFolderGUIElements();
this->ConfigureNodeSelectorPredicates();
this->CheckInputs();
this->ConfigureRegistrationControls();
this->ConfigureProgressInfos();
this->m_Controls.m_tabs->setCurrentIndex(1);
}
void QmitkMatchPointFrameCorrection::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
m_Controls.m_teLog->append(QString("<font color='red'><b>") + msg + QString("</b></font>"));
}
void QmitkMatchPointFrameCorrection::AdaptFolderGUIElements()
{
m_Controls.m_pbLoadSelected->setEnabled(m_CanLoadAlgorithm);
}
void QmitkMatchPointFrameCorrection::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Parent = parent;
this->m_Controls.imageNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.imageNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.maskNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.maskNodeSelector->SetSelectionIsOptional(true);
this->m_Controls.imageNodeSelector->SetInvalidInfo("Select dymamic image.");
this->m_Controls.imageNodeSelector->SetPopUpTitel("Select dynamic image.");
this->m_Controls.imageNodeSelector->SetPopUpHint("Select a dynamic image (time resolved) that should be frame corrected.");
this->m_Controls.maskNodeSelector->SetInvalidInfo("Select target mask.");
this->m_Controls.maskNodeSelector->SetPopUpTitel("Select target mask.");
this->m_Controls.maskNodeSelector->SetPopUpHint("Select a target mask (mask of the target/first frame).");
m_Controls.m_tabs->setCurrentIndex(0);
m_Controls.m_mapperSettings->AllowSampling(false);
m_AlgorithmSelectionListener.reset(new
berry::SelectionChangedAdapter<QmitkMatchPointFrameCorrection>(this,
&QmitkMatchPointFrameCorrection::OnAlgorithmSelectionChanged));
// register selection listener
GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddSelectionListener(
m_AlgorithmSelectionListener.data());
this->ConfigureNodeSelectorPredicates();
this->CreateConnections();
this->AdaptFolderGUIElements();
this->CheckInputs();
this->ConfigureProgressInfos();
this->ConfigureRegistrationControls();
berry::ISelection::ConstPointer selection =
GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.matchpoint.algorithm.browser");
this->UpdateAlgorithmSelection(selection);
}
void QmitkMatchPointFrameCorrection::ConfigureNodeSelectorPredicates()
{
auto isImage = mitk::MITKRegistrationHelper::ImageNodePredicate();
mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
mitk::NodePredicateBase::Pointer maskDimensionPredicate = mitk::NodePredicateOr::New(mitk::NodePredicateDimension::New(3), mitk::NodePredicateDimension::New(4)).GetPointer();
mitk::NodePredicateDimension::Pointer imageDimensionPredicate = mitk::NodePredicateDimension::New(4);
m_Controls.imageNodeSelector->setEnabled(m_LoadedAlgorithm.IsNotNull());
m_Controls.maskNodeSelector->setEnabled(m_LoadedAlgorithm.IsNotNull());
m_Controls.imageNodeSelector->SetNodePredicate(mitk::NodePredicateAnd::New(isImage, imageDimensionPredicate));
mitk::NodePredicateAnd::Pointer maskPredicate = mitk::NodePredicateAnd::New(mitk::NodePredicateOr::New(isLegacyMask, isLabelSet), maskDimensionPredicate);
if (m_spSelectedTargetData != nullptr)
{
auto hasSameGeometry = mitk::NodePredicateGeometry::New(m_spSelectedTargetData->GetGeometry());
hasSameGeometry->SetCheckPrecision(1e-10);
maskPredicate = mitk::NodePredicateAnd::New(maskPredicate, hasSameGeometry);
}
m_Controls.maskNodeSelector->SetNodePredicate(maskPredicate);
}
void QmitkMatchPointFrameCorrection::CheckInputs()
{
mitk::DataNode::Pointer oldTargetNode = m_spSelectedTargetNode;
m_spSelectedTargetNode = nullptr;
m_spSelectedTargetData = nullptr;
m_spSelectedTargetMaskNode = nullptr;
m_spSelectedTargetMaskData = nullptr;
if (m_LoadedAlgorithm.IsNull())
{
m_Controls.m_lbLoadedAlgorithmName->setText(
QString("<font color='red'>No algorithm seleted!</font>"));
}
else
{
- typedef ::map::algorithm::facet::MaskedRegistrationAlgorithmInterface<3, 3> MaskRegInterface;
-
m_spSelectedTargetNode = m_Controls.imageNodeSelector->GetSelectedNode();
if (m_spSelectedTargetNode.IsNotNull())
{
m_spSelectedTargetData = m_spSelectedTargetNode->GetData();
}
m_spSelectedTargetMaskNode = m_Controls.maskNodeSelector->GetSelectedNode();
if (m_spSelectedTargetMaskNode.IsNotNull())
{
m_spSelectedTargetMaskData = dynamic_cast<mitk::Image*>(m_spSelectedTargetMaskNode->GetData());
}
}
if (oldTargetNode != m_spSelectedTargetNode)
{
ConfigureFrameList();
}
}
mitk::DataStorage::SetOfObjects::Pointer QmitkMatchPointFrameCorrection::GetRegNodes() const
{
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetAll();
mitk::DataStorage::SetOfObjects::Pointer result = mitk::DataStorage::SetOfObjects::New();
for (mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end();
++pos)
{
if (mitk::MITKRegistrationHelper::IsRegNode(*pos))
{
result->push_back(*pos);
}
}
return result;
}
std::string QmitkMatchPointFrameCorrection::GetDefaultJobName() const
{
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetRegNodes().GetPointer();
mitk::DataStorage::SetOfObjects::ElementIdentifier newIndex = 0;
bool isUnique = false;
std::string baseName = "corrected #";
if (m_spSelectedTargetNode.IsNotNull())
{
baseName = m_spSelectedTargetNode->GetName() + "corrected #";
}
std::string result = baseName;
while (!isUnique)
{
++newIndex;
result = baseName + ::map::core::convert::toStr(newIndex);
isUnique = this->GetDataStorage()->GetNamedNode(result) == nullptr;
}
return result;
}
void QmitkMatchPointFrameCorrection::ConfigureRegistrationControls()
{
m_Controls.m_tabSelection->setEnabled(!m_Working);
m_Controls.m_leRegJobName->setEnabled(!m_Working);
m_Controls.m_pbStartReg->setEnabled(false);
m_Controls.imageNodeSelector->setEnabled(!m_Working);
m_Controls.maskNodeSelector->setEnabled(!m_Working);
if (m_LoadedAlgorithm.IsNotNull())
{
m_Controls.m_tabSettings->setEnabled(!m_Working);
m_Controls.m_tabExclusion->setEnabled(!m_Working);
m_Controls.m_tabExecution->setEnabled(true);
m_Controls.m_pbStartReg->setEnabled(m_spSelectedTargetNode.IsNotNull() && !m_Working);
m_Controls.m_leRegJobName->setEnabled(!m_Working);
typedef ::map::algorithm::facet::MaskedRegistrationAlgorithmInterface<3, 3> MaskRegInterface;
const MaskRegInterface* pMaskReg = dynamic_cast<const MaskRegInterface*>
(m_LoadedAlgorithm.GetPointer());
m_Controls.maskNodeSelector->setVisible(pMaskReg != nullptr);
m_Controls.label_TargetMask->setVisible(pMaskReg != nullptr);
if (!pMaskReg)
{
m_Controls.maskNodeSelector->SetCurrentSelection(QmitkSingleNodeSelectionWidget::NodeList());
}
this->m_Controls.m_lbLoadedAlgorithmName->setText(
QString::fromStdString(m_LoadedAlgorithm->getUID()->toStr()));
}
else
{
m_Controls.m_tabSettings->setEnabled(false);
m_Controls.m_tabExclusion->setEnabled(false);
m_Controls.m_tabExecution->setEnabled(false);
this->m_Controls.m_lbLoadedAlgorithmName->setText(
QString("<font color='red'>no algorithm loaded!</font>"));
m_Controls.maskNodeSelector->setVisible(false);
m_Controls.label_TargetMask->setVisible(false);
}
if (!m_Working)
{
this->m_Controls.m_leRegJobName->setText(QString::fromStdString(this->GetDefaultJobName()));
}
}
void QmitkMatchPointFrameCorrection::ConfigureProgressInfos()
{
const IIterativeAlgorithm* pIterative = dynamic_cast<const IIterativeAlgorithm*>
(m_LoadedAlgorithm.GetPointer());
const IMultiResAlgorithm* pMultiRes = dynamic_cast<const IMultiResAlgorithm*>
(m_LoadedAlgorithm.GetPointer());
m_Controls.m_progBarIteration->setVisible(pIterative);
m_Controls.m_lbProgBarIteration->setVisible(pIterative);
if (pIterative)
{
QString format = "%p% (%v/%m)";
if (!pIterative->hasMaxIterationCount())
{
format = "%v";
m_Controls.m_progBarIteration->setMaximum(0);
}
else
{
m_Controls.m_progBarIteration->setMaximum(pIterative->getMaxIterations());
}
m_Controls.m_progBarIteration->setFormat(format);
}
if (pMultiRes)
{
m_Controls.m_progBarLevel->setMaximum(pMultiRes->getResolutionLevels());
}
else
{
m_Controls.m_progBarLevel->setMaximum(1);
}
m_Controls.m_progBarIteration->reset();
m_Controls.m_progBarLevel->reset();
m_Controls.m_progBarFrame->reset();
}
void QmitkMatchPointFrameCorrection::ConfigureFrameList()
{
m_Controls.m_listFrames->clear();
if (m_spSelectedTargetData.IsNotNull())
{
mitk::TimeGeometry::ConstPointer tg = m_spSelectedTargetData->GetTimeGeometry();
for (unsigned int i = 1; i < tg->CountTimeSteps(); ++i)
{
QString lable = "Timepoint #" + QString::number(i) + QString(" (") + QString::number(
tg->GetMinimumTimePoint(i)) + QString(" ms - " + QString::number(tg->GetMaximumTimePoint(
i)) + QString(" ms)"));
QListWidgetItem* item = new QListWidgetItem(lable, m_Controls.m_listFrames);
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setCheckState(Qt::Checked);
}
}
}
void QmitkMatchPointFrameCorrection::OnFramesSelectAllPushed()
{
for (int row = 0; row < m_Controls.m_listFrames->count(); row++)
{
QListWidgetItem* item = m_Controls.m_listFrames->item(row);
item->setCheckState(Qt::Checked);
}
};
void QmitkMatchPointFrameCorrection::OnFramesDeSelectAllPushed()
{
for (int row = 0; row < m_Controls.m_listFrames->count(); row++)
{
QListWidgetItem* item = m_Controls.m_listFrames->item(row);
item->setCheckState(Qt::Unchecked);
}
};
void QmitkMatchPointFrameCorrection::OnFramesInvertPushed()
{
for (int row = 0; row < m_Controls.m_listFrames->count(); row++)
{
QListWidgetItem* item = m_Controls.m_listFrames->item(row);
if (item->checkState() == Qt::Unchecked)
{
item->setCheckState(Qt::Checked);
}
else
{
item->setCheckState(Qt::Unchecked);
}
}
};
mitk::TimeFramesRegistrationHelper::IgnoreListType
QmitkMatchPointFrameCorrection::GenerateIgnoreList() const
{
mitk::TimeFramesRegistrationHelper::IgnoreListType result;
for (int row = 0; row < m_Controls.m_listFrames->count(); row++)
{
QListWidgetItem* item = m_Controls.m_listFrames->item(row);
if (item->checkState() == Qt::Unchecked)
{
result.push_back(row + 1);
}
}
return result;
}
void QmitkMatchPointFrameCorrection::OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
{
if (!m_Working)
{
ConfigureNodeSelectorPredicates();
CheckInputs();
ConfigureRegistrationControls();
}
}
void QmitkMatchPointFrameCorrection::OnStartRegBtnPushed()
{
this->m_Working = true;
////////////////////////////////
//configure GUI
this->ConfigureProgressInfos();
m_Controls.m_progBarIteration->reset();
m_Controls.m_progBarLevel->reset();
this->ConfigureRegistrationControls();
if (m_Controls.m_checkClearLog->checkState() == Qt::Checked)
{
this->m_Controls.m_teLog->clear();
}
/////////////////////////
//create job and put it into the thread pool
QmitkFramesRegistrationJob* pJob = new QmitkFramesRegistrationJob(m_LoadedAlgorithm);
pJob->setAutoDelete(true);
pJob->m_spTargetData = m_spSelectedTargetData;
pJob->m_TargetDataUID = mitk::EnsureUID(this->m_spSelectedTargetNode->GetData());
pJob->m_IgnoreList = this->GenerateIgnoreList();
if (m_spSelectedTargetMaskData.IsNotNull())
{
pJob->m_spTargetMask = m_spSelectedTargetMaskData;
pJob->m_TargetMaskDataUID = mitk::EnsureUID(this->m_spSelectedTargetMaskNode->GetData());
}
pJob->m_MappedName = m_Controls.m_leRegJobName->text().toStdString();
m_Controls.m_mapperSettings->ConfigureJobSettings(pJob);
connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnRegJobError(QString)));
connect(pJob, SIGNAL(Finished()), this, SLOT(OnRegJobFinished()));
connect(pJob, SIGNAL(ResultIsAvailable(mitk::Image::Pointer, const QmitkFramesRegistrationJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::Image::Pointer, const QmitkFramesRegistrationJob*)),
Qt::BlockingQueuedConnection);
connect(pJob, SIGNAL(AlgorithmInfo(QString)), this, SLOT(OnAlgorithmInfo(QString)));
connect(pJob, SIGNAL(AlgorithmStatusChanged(QString)), this,
SLOT(OnAlgorithmStatusChanged(QString)));
connect(pJob, SIGNAL(AlgorithmIterated(QString, bool, unsigned long)), this,
SLOT(OnAlgorithmIterated(QString, bool, unsigned long)));
connect(pJob, SIGNAL(LevelChanged(QString, bool, unsigned long)), this, SLOT(OnLevelChanged(QString,
bool, unsigned long)));
connect(pJob, SIGNAL(FrameRegistered(double)), this, SLOT(OnFrameRegistered(double)));
connect(pJob, SIGNAL(FrameMapped(double)), this, SLOT(OnFrameMapped(double)));
connect(pJob, SIGNAL(FrameProcessed(double)), this, SLOT(OnFrameProcessed(double)));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pJob);
}
void QmitkMatchPointFrameCorrection::OnSaveLogBtnPushed()
{
QDateTime currentTime = QDateTime::currentDateTime();
QString fileName = tr("registration_log_") + currentTime.toString(tr("yyyy-MM-dd_hh-mm-ss")) +
tr(".txt");
fileName = QFileDialog::getSaveFileName(nullptr, tr("Save registration log"), fileName,
tr("Text files (*.txt)"));
if (fileName.isEmpty())
{
QMessageBox::critical(nullptr, tr("No file selected!"),
tr("Cannot save registration log file. Please selected a file."));
}
else
{
std::ofstream file;
std::ios_base::openmode iOpenFlag = std::ios_base::out | std::ios_base::trunc;
file.open(fileName.toStdString().c_str(), iOpenFlag);
if (!file.is_open())
{
mitkThrow() << "Cannot open or create specified file to save. File path: "
<< fileName.toStdString();
}
file << this->m_Controls.m_teLog->toPlainText().toStdString() << std::endl;
file.close();
}
}
void QmitkMatchPointFrameCorrection::OnRegJobError(QString err)
{
Error(err);
};
void QmitkMatchPointFrameCorrection::OnRegJobFinished()
{
this->m_Working = false;
this->GetRenderWindowPart()->RequestUpdate();
this->CheckInputs();
this->ConfigureRegistrationControls();
this->ConfigureProgressInfos();
};
void QmitkMatchPointFrameCorrection::OnMapResultIsAvailable(mitk::Image::Pointer spMappedData,
const QmitkFramesRegistrationJob* job)
{
m_Controls.m_teLog->append(QString("<b><font color='blue'>Corrected image stored. Name: ") +
QString::fromStdString(job->m_MappedName) + QString("</font></b>"));
mitk::DataNode::Pointer spResultNode = mitk::generateMappedResultNode(job->m_MappedName,
spMappedData.GetPointer(), "", job->m_TargetDataUID, false, job->m_InterpolatorLabel);
this->GetDataStorage()->Add(spResultNode, this->m_spSelectedTargetNode);
this->GetRenderWindowPart()->RequestUpdate();
};
void QmitkMatchPointFrameCorrection::OnMapJobError(QString err)
{
Error(err);
};
void QmitkMatchPointFrameCorrection::OnAlgorithmIterated(QString info, bool hasIterationCount,
unsigned long currentIteration)
{
if (hasIterationCount)
{
m_Controls.m_progBarIteration->setValue(currentIteration);
}
m_Controls.m_teLog->append(info);
};
void QmitkMatchPointFrameCorrection::OnLevelChanged(QString info, bool hasLevelCount,
unsigned long currentLevel)
{
if (hasLevelCount)
{
m_Controls.m_progBarLevel->setValue(currentLevel);
}
m_Controls.m_teLog->append(QString("<b><font color='green'>") + info + QString("</font></b>"));
};
void QmitkMatchPointFrameCorrection::OnAlgorithmStatusChanged(QString info)
{
m_Controls.m_teLog->append(QString("<b><font color='blue'>") + info + QString(" </font></b>"));
};
void QmitkMatchPointFrameCorrection::OnAlgorithmInfo(QString info)
{
m_Controls.m_teLog->append(QString("<font color='gray'><i>") + info + QString("</i></font>"));
};
void QmitkMatchPointFrameCorrection::OnFrameProcessed(double progress)
{
m_Controls.m_teLog->append(QString("<b><font color='blue'>Frame processed...</font></b>"));
m_Controls.m_progBarFrame->setValue(100 * progress);
};
void QmitkMatchPointFrameCorrection::OnFrameRegistered(double progress)
{
m_Controls.m_teLog->append(QString("<b><font color='blue'>Frame registered...</font></b>"));
m_Controls.m_progBarFrame->setValue(100 * progress);
};
void QmitkMatchPointFrameCorrection::OnFrameMapped(double progress)
{
m_Controls.m_teLog->append(QString("<b><font color='blue'>Frame mapped...</font></b>"));
m_Controls.m_progBarFrame->setValue(100 * progress);
};
void QmitkMatchPointFrameCorrection::OnAlgorithmSelectionChanged(const
berry::IWorkbenchPart::Pointer& sourcepart,
const berry::ISelection::ConstPointer& selection)
{
// check for null selection
if (selection.IsNull())
{
return;
}
if (sourcepart != this)
{
UpdateAlgorithmSelection(selection);
}
}
void QmitkMatchPointFrameCorrection::UpdateAlgorithmSelection(berry::ISelection::ConstPointer
selection)
{
mitk::MAPAlgorithmInfoSelection::ConstPointer currentSelection =
selection.Cast<const mitk::MAPAlgorithmInfoSelection>();
if (currentSelection)
{
mitk::MAPAlgorithmInfoSelection::AlgorithmInfoVectorType infoVector =
currentSelection->GetSelectedAlgorithmInfo();
if (!infoVector.empty())
{
// only the first selection is of interest, the rest will be skipped.
this->m_SelectedAlgorithmInfo = infoVector[0];
}
}
this->OnSelectedAlgorithmChanged();
};
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.cpp b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.cpp
index c5a21125a8..d68abd2709 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.cpp
@@ -1,486 +1,486 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Mitk
#include <mitkStatusBar.h>
#include <mitkNodePredicateDataProperty.h>
#include <mitkMAPRegistrationWrapper.h>
#include "mitkRegVisPropertyTags.h"
#include "mitkMatchPointPropertyTags.h"
#include "mitkRegEvaluationObject.h"
#include "mitkRegistrationHelper.h"
#include "mitkRegEvaluationMapper2D.h"
#include <mitkAlgorithmHelper.h>
#include <mitkResultNodeGenerationHelper.h>
#include <mitkUIDHelper.h>
// Qmitk
#include "QmitkRenderWindow.h"
#include "QmitkMatchPointRegistrationManipulator.h"
#include <QmitkMappingJob.h>
// Qt
#include <QMessageBox>
#include <QErrorMessage>
#include <QTimer>
#include <QThreadPool>
//MatchPoint
#include <mapRegistrationManipulator.h>
#include <mapPreCachedRegistrationKernel.h>
#include <mapCombinedRegistrationKernel.h>
#include <mapNullRegistrationKernel.h>
#include <mapRegistrationCombinator.h>
#include <itkCompositeTransform.h>
#include <boost/math/constants/constants.hpp>
const std::string QmitkMatchPointRegistrationManipulator::VIEW_ID =
"org.mitk.views.matchpoint.registration.manipulator";
const std::string QmitkMatchPointRegistrationManipulator::HelperNodeName =
"RegistrationManipulationEvaluationHelper";
QmitkMatchPointRegistrationManipulator::QmitkMatchPointRegistrationManipulator()
: m_Parent(nullptr), m_activeManipulation(false),
m_currentSelectedTimeStep(0), m_internalUpdate(false)
{
m_currentSelectedPosition.Fill(0.0);
}
QmitkMatchPointRegistrationManipulator::~QmitkMatchPointRegistrationManipulator()
{
if (this->m_EvalNode.IsNotNull() && this->GetDataStorage().IsNotNull())
{
this->GetDataStorage()->Remove(this->m_EvalNode);
}
}
void QmitkMatchPointRegistrationManipulator::SetFocus()
{
}
void QmitkMatchPointRegistrationManipulator::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
}
void QmitkMatchPointRegistrationManipulator::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Parent = parent;
this->m_Controls.registrationNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.registrationNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.movingNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.movingNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.targetNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.targetNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.registrationNodeSelector->SetInvalidInfo("Select base registration.");
this->m_Controls.registrationNodeSelector->SetPopUpTitel("Select registration.");
this->m_Controls.registrationNodeSelector->SetPopUpHint("Select a registration object that should be used as starting point for the manual manipulation.");
this->m_Controls.movingNodeSelector->SetInvalidInfo("Select moving image.");
this->m_Controls.movingNodeSelector->SetPopUpTitel("Select moving image.");
this->m_Controls.movingNodeSelector->SetPopUpHint("Select the moving image for the evaluation. This is the image that will be mapped by the registration.");
this->m_Controls.targetNodeSelector->SetInvalidInfo("Select target image.");
this->m_Controls.targetNodeSelector->SetPopUpTitel("Select target image.");
this->m_Controls.targetNodeSelector->SetPopUpHint("Select the target image for the evaluation.");
this->ConfigureNodePredicates();
connect(m_Controls.pbStart, SIGNAL(clicked()), this, SLOT(OnStartBtnPushed()));
connect(m_Controls.pbCancel, SIGNAL(clicked()), this, SLOT(OnCancelBtnPushed()));
connect(m_Controls.pbStore, SIGNAL(clicked()), this, SLOT(OnStoreBtnPushed()));
connect(m_Controls.evalSettings, SIGNAL(SettingsChanged(mitk::DataNode*)), this, SLOT(OnSettingsChanged(mitk::DataNode*)));
- connect(m_Controls.radioSelectedReg, SIGNAL(toggled(bool)), this, SLOT(OnSelectionChanged()));
+ connect(m_Controls.radioSelectedReg, SIGNAL(toggled(bool)), this, SLOT(OnRegSourceChanged()));
connect(m_Controls.comboCenter, SIGNAL(currentIndexChanged(int)), this, SLOT(OnCenterTypeChanged(int)));
connect(m_Controls.manipulationWidget, SIGNAL(RegistrationChanged(map::core::RegistrationBase*)), this, SLOT(OnRegistrationChanged()));
connect(m_Controls.registrationNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.movingNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.targetNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
this->m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
connect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
m_Controls.radioNewReg->setChecked(true);
m_EvalNode = this->GetDataStorage()->GetNamedNode(HelperNodeName);
this->CheckInputs();
this->StopSession();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationManipulator::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
this->m_SliceChangeListener.RenderWindowPartActivated(renderWindowPart);
}
void QmitkMatchPointRegistrationManipulator::RenderWindowPartDeactivated(
mitk::IRenderWindowPart* renderWindowPart)
{
this->m_SliceChangeListener.RenderWindowPartDeactivated(renderWindowPart);
}
void QmitkMatchPointRegistrationManipulator::ConfigureNodePredicates()
{
this->m_Controls.registrationNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::RegNodePredicate());
this->m_Controls.movingNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::ImageNodePredicate());
this->m_Controls.targetNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::ImageNodePredicate());
}
void QmitkMatchPointRegistrationManipulator::CheckInputs()
{
if (!m_activeManipulation)
{
this->m_SelectedPreRegNode = this->m_Controls.registrationNodeSelector->GetSelectedNode();
this->m_SelectedMovingNode = this->m_Controls.movingNodeSelector->GetSelectedNode();
this->m_SelectedTargetNode = this->m_Controls.targetNodeSelector->GetSelectedNode();
if (this->m_SelectedPreRegNode.IsNotNull())
{
mitk::MAPRegistrationWrapper* regWrapper = dynamic_cast<mitk::MAPRegistrationWrapper*>(m_SelectedPreRegNode->GetData());
if (regWrapper)
{
this->m_SelectedPreReg = dynamic_cast<MAPRegistrationType*>(regWrapper->GetRegistration());
}
}
if (this->m_SelectedMovingNode.IsNull() && this->m_SelectedPreRegNode.IsNotNull())
{
mitk::BaseProperty* uidProp = m_SelectedPreRegNode->GetData()->GetProperty(mitk::Prop_RegAlgMovingData);
if (uidProp)
{
//search for the moving node
mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
uidProp);
mitk::DataNode::Pointer movingNode = this->GetDataStorage()->GetNode(predicate);
if (movingNode.IsNotNull())
{
this->m_SelectedMovingNode = movingNode;
QmitkSingleNodeSelectionWidget::NodeList selection({ movingNode });
this->m_Controls.movingNodeSelector->SetCurrentSelection(selection);
}
}
}
if (this->m_SelectedTargetNode.IsNull() && this->m_SelectedPreRegNode.IsNotNull())
{
mitk::BaseProperty* uidProp = m_SelectedPreRegNode->GetData()->GetProperty(mitk::Prop_RegAlgTargetData);
if (uidProp)
{
//search for the target node
mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
uidProp);
mitk::DataNode::Pointer targetNode = this->GetDataStorage()->GetNode(predicate);
if (targetNode.IsNotNull())
{
this->m_SelectedTargetNode = targetNode;
QmitkSingleNodeSelectionWidget::NodeList selection({ targetNode });
this->m_Controls.targetNodeSelector->SetCurrentSelection(selection);
}
}
}
}
}
-void QmitkMatchPointRegistrationManipulator::OnSelectionChanged()
+void QmitkMatchPointRegistrationManipulator::OnRegSourceChanged()
{
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationManipulator::OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
{
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationManipulator::NodeRemoved(const mitk::DataNode* node)
{
if (node == this->m_SelectedMovingNode
|| node == this->m_SelectedTargetNode
|| node == this->m_EvalNode)
{
if (node == this->m_EvalNode)
{
this->m_EvalNode = nullptr;
}
if (this->m_activeManipulation)
{
MITK_INFO << "Stopped current MatchPoint manual registration session, because at least one relevant node was removed from storage.";
}
this->OnCancelBtnPushed();
}
}
void QmitkMatchPointRegistrationManipulator::ConfigureControls()
{
if (!m_activeManipulation)
{
QString name = "ManuelRegistration";
if (m_SelectedPreRegNode.IsNotNull())
{
name = QString::fromStdString(m_SelectedPreRegNode->GetName()) + " manual refined";
}
this->m_Controls.lbNewRegName->setText(name);
}
//config settings widget
this->m_Controls.groupReg->setEnabled(!m_activeManipulation);
this->m_Controls.pbStart->setEnabled(this->m_SelectedMovingNode.IsNotNull()
&& this->m_SelectedTargetNode.IsNotNull()
&& !m_activeManipulation
&& (this->m_Controls.radioNewReg->isChecked() || this->m_SelectedPreReg.IsNotNull()));
this->m_Controls.lbNewRegName->setEnabled(m_activeManipulation);
this->m_Controls.checkMapEntity->setEnabled(m_activeManipulation);
this->m_Controls.tabWidget->setEnabled(m_activeManipulation);
this->m_Controls.pbCancel->setEnabled(m_activeManipulation);
this->m_Controls.pbStore->setEnabled(m_activeManipulation);
this->m_Controls.registrationNodeSelector->setEnabled(!m_activeManipulation && this->m_Controls.radioSelectedReg->isChecked());
this->m_Controls.movingNodeSelector->setEnabled(!m_activeManipulation);
this->m_Controls.targetNodeSelector->setEnabled(!m_activeManipulation);
}
void QmitkMatchPointRegistrationManipulator::InitSession()
{
if (this->m_Controls.radioNewReg->isChecked())
{ //init to map the image centers
auto movingCenter = m_SelectedMovingNode->GetData()->GetTimeGeometry()->GetCenterInWorld();
auto targetCenter = m_SelectedTargetNode->GetData()->GetTimeGeometry()->GetCenterInWorld();
this->m_Controls.manipulationWidget->Initialize(movingCenter, targetCenter);
}
else
{ //use selected pre registration as baseline
m_Controls.manipulationWidget->Initialize(m_SelectedPreReg);
}
this->m_CurrentRegistrationWrapper = mitk::MAPRegistrationWrapper::New();
this->m_CurrentRegistration = m_Controls.manipulationWidget->GetInterimRegistration();
this->m_CurrentRegistrationWrapper->SetRegistration(m_CurrentRegistration);
this->m_Controls.comboCenter->setCurrentIndex(0);
this->OnCenterTypeChanged(0);
//reinit view
mitk::RenderingManager::GetInstance()->InitializeViews(m_SelectedTargetNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
//generate evaluation node
mitk::RegEvaluationObject::Pointer regEval = mitk::RegEvaluationObject::New();
regEval->SetRegistration(this->m_CurrentRegistrationWrapper);
regEval->SetTargetNode(this->m_SelectedTargetNode);
regEval->SetMovingNode(this->m_SelectedMovingNode);
this->m_EvalNode = mitk::DataNode::New();
this->m_EvalNode->SetData(regEval);
mitk::RegEvaluationMapper2D::SetDefaultProperties(this->m_EvalNode);
this->m_EvalNode->SetName(HelperNodeName);
this->m_EvalNode->SetBoolProperty("helper object", true);
this->GetDataStorage()->Add(this->m_EvalNode);
this->m_Controls.evalSettings->SetNode(this->m_EvalNode);
this->m_activeManipulation = true;
}
void QmitkMatchPointRegistrationManipulator::StopSession()
{
this->m_activeManipulation = false;
if (this->m_EvalNode.IsNotNull())
{
this->GetDataStorage()->Remove(this->m_EvalNode);
}
this->m_EvalNode = nullptr;
this->m_CurrentRegistration = nullptr;
this->m_CurrentRegistrationWrapper = nullptr;
m_Controls.manipulationWidget->Initialize();
}
void QmitkMatchPointRegistrationManipulator::OnRegistrationChanged()
{
this->m_EvalNode->Modified();
this->m_CurrentRegistrationWrapper->Modified();
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::OnSliceChanged()
{
mitk::Point3D currentSelectedPosition = GetRenderWindowPart()->GetSelectedPosition(nullptr);
unsigned int currentSelectedTimeStep = GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
if (m_currentSelectedPosition != currentSelectedPosition
|| m_currentSelectedTimeStep != currentSelectedTimeStep
|| m_selectedNodeTime > m_currentPositionTime)
{
//the current position has been changed or the selected node has been changed since the last position validation -> check position
m_currentSelectedPosition = currentSelectedPosition;
m_currentSelectedTimeStep = currentSelectedTimeStep;
m_currentPositionTime.Modified();
if (this->m_EvalNode.IsNotNull())
{
this->m_EvalNode->SetProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::GenericProperty<mitk::Point3D>::New(currentSelectedPosition));
}
if (m_activeManipulation && m_Controls.comboCenter->currentIndex() == 2)
{ //update transform with the current position.
m_Controls.manipulationWidget->SetCenterOfRotation(m_currentSelectedPosition);
}
}
}
void QmitkMatchPointRegistrationManipulator::OnSettingsChanged(mitk::DataNode*)
{
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::OnStartBtnPushed()
{
this->InitSession();
this->OnSliceChanged();
this->GetRenderWindowPart()->RequestUpdate();
this->CheckInputs();
this->ConfigureControls();
}
void QmitkMatchPointRegistrationManipulator::OnCancelBtnPushed()
{
this->StopSession();
this->CheckInputs();
this->ConfigureControls();
if (this->GetRenderWindowPart())
{
this->GetRenderWindowPart()->RequestUpdate();
}
}
void QmitkMatchPointRegistrationManipulator::OnStoreBtnPushed()
{
mitk::MAPRegistrationWrapper::Pointer newRegWrapper = mitk::MAPRegistrationWrapper::New();
map::core::RegistrationBase::Pointer newReg = this->m_Controls.manipulationWidget->GenerateRegistration();
newRegWrapper->SetRegistration(newReg);
mitk::DataNode::Pointer spResultRegistrationNode = mitk::generateRegistrationResultNode(
this->m_Controls.lbNewRegName->text().toStdString(), newRegWrapper, "org.mitk::manual_registration",
mitk::EnsureUID(m_SelectedMovingNode->GetData()), mitk::EnsureUID(m_SelectedTargetNode->GetData()));
this->GetDataStorage()->Add(spResultRegistrationNode);
if (m_Controls.checkMapEntity->checkState() == Qt::Checked)
{
QmitkMappingJob* pMapJob = new QmitkMappingJob();
pMapJob->setAutoDelete(true);
pMapJob->m_spInputData = this->m_SelectedMovingNode->GetData();
pMapJob->m_InputDataUID = mitk::EnsureUID(m_SelectedMovingNode->GetData());
pMapJob->m_spRegNode = spResultRegistrationNode;
pMapJob->m_doGeometryRefinement = false;
pMapJob->m_spRefGeometry = this->m_SelectedTargetNode->GetData()->GetGeometry()->Clone().GetPointer();
pMapJob->m_MappedName = this->m_Controls.lbNewRegName->text().toStdString() + std::string(" mapped moving data");
pMapJob->m_allowUndefPixels = true;
pMapJob->m_paddingValue = 100;
pMapJob->m_allowUnregPixels = true;
pMapJob->m_errorValue = 200;
pMapJob->m_InterpolatorLabel = "Linear Interpolation";
pMapJob->m_InterpolatorType = mitk::ImageMappingInterpolator::Linear;
connect(pMapJob, SIGNAL(Error(QString)), this, SLOT(Error(QString)));
connect(pMapJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
Qt::BlockingQueuedConnection);
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pMapJob);
}
this->StopSession();
this->CheckInputs();
this->ConfigureControls();
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData,
const QmitkMappingJob* job)
{
mitk::DataNode::Pointer spMappedNode = mitk::generateMappedResultNode(job->m_MappedName,
spMappedData, job->GetRegistration()->getRegistrationUID(), job->m_InputDataUID,
job->m_doGeometryRefinement, job->m_InterpolatorLabel);
this->GetDataStorage()->Add(spMappedNode);
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::OnCenterTypeChanged(int index)
{
ConfigureTransformCenter(index);
if (this->m_EvalNode.IsNotNull())
{
this->m_EvalNode->Modified();
}
this->m_CurrentRegistrationWrapper->Modified();
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPointRegistrationManipulator::ConfigureTransformCenter(int centerType)
{
if (centerType == 0)
{ //image center
auto center = m_SelectedMovingNode->GetData()->GetTimeGeometry()->GetCenterInWorld();
m_Controls.manipulationWidget->SetCenterOfRotationIsRelativeToTarget(false);
m_Controls.manipulationWidget->SetCenterOfRotation(center);
}
else if (centerType == 1)
{ //world origin
mitk::Point3D center;
center.Fill(0.0);
m_Controls.manipulationWidget->SetCenterOfRotationIsRelativeToTarget(false);
m_Controls.manipulationWidget->SetCenterOfRotation(center);
}
else
{ //current selected point
m_Controls.manipulationWidget->SetCenterOfRotationIsRelativeToTarget(true);
m_Controls.manipulationWidget->SetCenterOfRotation(m_currentSelectedPosition);
}
}
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.h b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.h
index ed2e7b7ce8..1c3e0abf8f 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.h
+++ b/Plugins/org.mitk.gui.qt.matchpoint.manipulator/src/internal/QmitkMatchPointRegistrationManipulator.h
@@ -1,150 +1,150 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef __Q_MITK_MATCHPOINT_REGISTRATION_MANIPULATOR_H
#define __Q_MITK_MATCHPOINT_REGISTRATION_MANIPULATOR_H
#include <QmitkAbstractView.h>
#include <mitkIRenderWindowPartListener.h>
#include <QmitkSliceNavigationListener.h>
#include <mitkMAPRegistrationWrapper.h>
#include <itkEuler3DTransform.h>
#include "ui_QmitkMatchPointRegistrationManipulator.h"
class QmitkMappingJob;
/*!
\brief QmitkMatchPointRegistrationManipulator
\warning This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
\sa QmitkFunctionality
\ingroup ${plugin_target}_internal
*/
class QmitkMatchPointRegistrationManipulator : public QmitkAbstractView, public mitk::IRenderWindowPartListener
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
/**
* Creates smartpointer typedefs
*/
berryObjectMacro(QmitkMatchPointRegistrationManipulator);
QmitkMatchPointRegistrationManipulator();
~QmitkMatchPointRegistrationManipulator() override;
void CreateQtPartControl(QWidget *parent) override;
protected slots:
/// \brief Called when the user clicks the GUI button
void OnStartBtnPushed();
void OnCancelBtnPushed();
void OnStoreBtnPushed();
void OnSettingsChanged(mitk::DataNode*);
- void OnSelectionChanged();
+ void OnRegSourceChanged();
void OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
void OnRegistrationChanged();
void OnCenterTypeChanged(int);
void OnSliceChanged();
void OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData, const QmitkMappingJob* job);
void Error(QString msg);
protected:
void NodeRemoved(const mitk::DataNode* node) override;
void SetFocus() override;
void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
Ui::MatchPointRegistrationManipulatorControls m_Controls;
private:
QWidget *m_Parent;
/** Methods returns a list of all eval nodes in the data manager.*/
QList<mitk::DataNode::Pointer> GetEvalNodes();
/**
* Checks if appropriated nodes are selected in the data manager. If nodes are selected,
* they are stored m_spSelectedRegNode, m_spSelectedInputNode and m_spSelectedRefNode.
* They are also checked for validity.*/
void CheckInputs();
/**
* Updates the state of controls regarding to the state of the view and it objects.*/
void ConfigureControls();
/**
Configure the node selectors predicates according to the selected algorithm.
*/
void ConfigureNodePredicates();
/** Initialize the state of the view, so the manipulation can start.*/
void InitSession();
/** Stops session, removes all obsolete members (e.g. RegEvalObject). After that the view is in a valid but inactive state.*/
void StopSession();
void ConfigureTransformCenter(int centerType);
mitk::DataNode::Pointer m_EvalNode;
QmitkSliceNavigationListener m_SliceChangeListener;
itk::TimeStamp m_selectedNodeTime;
itk::TimeStamp m_currentPositionTime;
bool m_activeManipulation;
/** @brief currently valid selected position in the inspector*/
mitk::Point3D m_currentSelectedPosition;
/** @brief indicates if the currently selected position is valid for the currently selected fit.
* This it is within the input image */
unsigned int m_currentSelectedTimeStep;
mitk::DataNode::Pointer m_SelectedPreRegNode;
mitk::DataNode::Pointer m_SelectedMovingNode;
mitk::DataNode::Pointer m_SelectedTargetNode;
mitk::MAPRegistrationWrapper::Pointer m_CurrentRegistrationWrapper;
map::core::RegistrationBase::Pointer m_CurrentRegistration;
using MAPRegistrationType = map::core::Registration<3, 3>;
MAPRegistrationType::Pointer m_SelectedPreReg;
bool m_internalUpdate;
static const std::string HelperNodeName;
};
#endif // MatchPoint_h