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 1ed382ae80..dbe4ea384f 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;
 
-    MaskRegInterface* pMaskInterface = dynamic_cast<MaskRegInterface*>(m_LoadedAlgorithm.GetPointer());
-
     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);
     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);
   }
 
   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.mapper/src/internal/QmitkMatchPointMapper.cpp b/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.cpp
index 2139b33768..a83619fb53 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.cpp
@@ -1,582 +1,582 @@
 /*============================================================================
 
 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_mapper_Activator.h"
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Mitk
 #include <mitkImageAccessByItk.h>
 #include <mitkStatusBar.h>
 #include "mitkImageMappingHelper.h"
 #include "mitkMAPRegistrationWrapper.h"
 #include "mitkMatchPointPropertyTags.h"
 #include "mitkRegistrationHelper.h"
 #include <mitkResultNodeGenerationHelper.h>
 #include <mitkUIDHelper.h>
 #include <mitkAlgorithmHelper.h>
 #include <mitkResultNodeGenerationHelper.h>
 #include <mitkNodePredicateDataProperty.h>
 #include <mitkNodePredicateFunction.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 
 // Qmitk
 #include "QmitkMatchPointMapper.h"
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QErrorMessage>
 #include <QThreadPool>
 
 const std::string QmitkMatchPointMapper::VIEW_ID = "org.mitk.views.matchpoint.mapper";
 
 QmitkMatchPointMapper::QmitkMatchPointMapper()
     : m_Parent(nullptr), m_preparedForBinaryInput(false)
 {
 }
 
 void QmitkMatchPointMapper::SetFocus()
 {
     //m_Controls.buttonPerformImageProcessing->setFocus();
 }
 
 void QmitkMatchPointMapper::CreateConnections()
 {
     connect(m_Controls.registrationNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnRegNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
     connect(m_Controls.inputNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnInputNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
     connect(m_Controls.referenceNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnReferenceNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
 
     connect(m_Controls.m_cbManualRef, SIGNAL(clicked()), this, SLOT(OnManualRefChecked()));
     connect(m_Controls.m_cbLinkFactors, SIGNAL(clicked()), this, SLOT(OnLinkSampleFactorChecked()));
 
     connect(m_Controls.m_sbXFactor, SIGNAL(valueChanged(double)), this, SLOT(OnXFactorChanged(double)));
 
     connect(m_Controls.m_pbMap, SIGNAL(clicked()), this, SLOT(OnMapBtnPushed()));
     connect(m_Controls.m_pbRefine, SIGNAL(clicked()), this, SLOT(OnRefineBtnPushed()));
 }
 
 void QmitkMatchPointMapper::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 QmitkMatchPointMapper::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(true);
     this->m_Controls.inputNodeSelector->SetDataStorage(this->GetDataStorage());
     this->m_Controls.inputNodeSelector->SetSelectionIsOptional(false);
     this->m_Controls.referenceNodeSelector->SetDataStorage(this->GetDataStorage());
     this->m_Controls.referenceNodeSelector->SetSelectionIsOptional(false);
 
     this->m_Controls.registrationNodeSelector->SetInvalidInfo("Select valid registration.");
     this->m_Controls.registrationNodeSelector->SetEmptyInfo("Assuming identity mapping. Select registration to change.");
     this->m_Controls.registrationNodeSelector->SetPopUpTitel("Select registration.");
     this->m_Controls.registrationNodeSelector->SetPopUpHint("Select a registration object that should be used for the mapping of the input data. If no registration is selected, identity will be assumed for the mapping.");
 
     this->m_Controls.inputNodeSelector->SetInvalidInfo("Select input data.");
     this->m_Controls.inputNodeSelector->SetPopUpTitel("Select input data.");
     this->m_Controls.inputNodeSelector->SetPopUpHint("Select the input data for the mapping. (Images or point sets are supported so far).");
     this->m_Controls.referenceNodeSelector->SetInvalidInfo("Select the reference image.");
     this->m_Controls.referenceNodeSelector->SetPopUpTitel("Select the reference image.");
     this->m_Controls.referenceNodeSelector->SetPopUpHint("Select the reference image that specifies the target geometrie the input should be mapped into.");
 
     this->ConfigureRegNodePredicate();
     this->ConfigureNodePredicates();
 
     // show first page
     m_Controls.m_tabs->setCurrentIndex(0);
 
     this->CreateConnections();
     this->CheckInputs();
     this->ConfigureProgressInfos();
     this->ConfigureMappingControls();
 }
 
 /** Method checks if the currently selected reg node has a direct kernel that
 * can be decomposed in a rotation matrix and a offset. If this is true, true
 * is returned. In all other cases false is returned.*/
 bool  QmitkMatchPointMapper::IsAbleToRefineGeometry() const
 {
     bool result = false;
 
     if (this->m_spSelectedRegNode.IsNotNull())
     {
         const mitk::MAPRegistrationWrapper* wrapper = dynamic_cast<const mitk::MAPRegistrationWrapper*>
             (this->m_spSelectedRegNode->GetData());
 
         //if the helper does not return null, we can refine the geometry.
         result = mitk::MITKRegistrationHelper::getAffineMatrix(wrapper, false).IsNotNull();
     }
 
     return result;
 }
 
 bool  QmitkMatchPointMapper::IsBinaryInput() const
 {
     mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
     mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
     mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
 
     mitk::NodePredicateOr::Pointer maskPredicate = mitk::NodePredicateOr::New(isLegacyMask, isLabelSet);
 
     bool result = false;
 
     if(this->m_spSelectedInputNode.IsNotNull())
     {
       result = maskPredicate->CheckNode(this->m_spSelectedInputNode);
     }
 
     return result;
 }
 
 bool  QmitkMatchPointMapper::IsPointSetInput() const
 {
     bool result = false;
 
     if (this->m_spSelectedInputNode.IsNotNull())
     {
         result = dynamic_cast<const mitk::PointSet*>(this->m_spSelectedInputNode->GetData()) != nullptr;
     }
 
     return result;
 }
 
 mitk::DataNode::Pointer QmitkMatchPointMapper::GetAutoRefNodeByReg()
 {
     mitk::DataNode::Pointer spResult = nullptr;
 
     if (this->m_spSelectedRegNode.IsNotNull() && this->m_spSelectedRegNode->GetData())
     {
         std::string nodeName;
         mitk::BaseProperty* uidProp = m_spSelectedRegNode->GetData()->GetProperty(mitk::Prop_RegAlgTargetData);
 
         if (uidProp)
         {
             //search for the target node
             mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
                 uidProp);
             spResult = this->GetDataStorage()->GetNode(predicate);
         }
     }
     if (spResult.IsNull() && this->m_spSelectedInputNode.IsNotNull())
     {
         //no really reference is available -> use the input as reference
         spResult = this->m_spSelectedInputNode;
         if (this->m_spSelectedRefNode != spResult)
         {
           m_Controls.m_teLog->append(
             QString("<font color='gray'><i>Cannot determine reference automatically. Use input image as reference.</i></font>"));
         }
     }
 
     return spResult;
 }
 
 void QmitkMatchPointMapper::ConfigureRegNodePredicate(const mitk::DataNode* input)
 {
   mitk::NodePredicateBase::ConstPointer nodePredicate = mitk::MITKRegistrationHelper::RegNodePredicate();
 
   if (input != nullptr)
   {
-    int dimension = 0;
+    unsigned int dimension = 0;
 
     auto inputImage = dynamic_cast<mitk::Image*>(input->GetData());
     auto pointset = dynamic_cast<const mitk::PointSet*>(input->GetData());
     if (inputImage)
     {
       dimension = inputImage->GetDimension();
 
       if (inputImage->GetTimeSteps() > 1)
       {
         //images has multiple time steps -> remove one dimension.
         dimension -= 1;
       }
     }
     else if (pointset)
     {
       dimension = 3;
     }
 
     auto dimCheck = [dimension](const mitk::DataNode * node)
     {
       const mitk::MAPRegistrationWrapper* wrapper = dynamic_cast < const mitk::MAPRegistrationWrapper* >(node->GetData());
 
       return wrapper != nullptr && wrapper->GetMovingDimensions() == dimension;
     };
     mitk::NodePredicateFunction::Pointer hasCorrectDim = mitk::NodePredicateFunction::New(dimCheck);
 
     nodePredicate = mitk::NodePredicateAnd::New(nodePredicate, hasCorrectDim).GetPointer();
   }
 
   this->m_Controls.registrationNodeSelector->SetNodePredicate(nodePredicate);
 }
 
 std::function<bool(const mitk::DataNode *)> GenerateDimCheckLambda(unsigned int dim)
 {
   auto dimCheck = [dim](const mitk::DataNode * node)
   {
     auto inputImage = dynamic_cast<mitk::Image*>(node->GetData());
 
     return inputImage != nullptr &&
       (inputImage->GetDimension() == dim ||
       (inputImage->GetDimension() == dim + 1 && inputImage->GetTimeSteps()>1));
   };
 
   return dimCheck;
 }
 
 void QmitkMatchPointMapper::ConfigureNodePredicates(const mitk::DataNode* reg)
 {
   auto isImage = mitk::MITKRegistrationHelper::ImageNodePredicate();
   auto isPointSet = mitk::MITKRegistrationHelper::PointSetNodePredicate();
 
   auto isData = mitk::NodePredicateOr::New(isImage, isPointSet);
 
-  mitk::NodePredicateBase::ConstPointer inputPredicate = isData;
-  mitk::NodePredicateBase::ConstPointer refPredicate = isImage;
+  mitk::NodePredicateBase::ConstPointer inputPredicate = isData.GetPointer();
+  mitk::NodePredicateBase::ConstPointer refPredicate = isImage.GetPointer();
 
   if (reg != nullptr)
   {
     const mitk::MAPRegistrationWrapper* wrapper = dynamic_cast <const mitk::MAPRegistrationWrapper*>(reg->GetData());
 
     if (wrapper != nullptr)
     {
       auto movingDim = wrapper->GetMovingDimensions();
 
       auto dimCheck = GenerateDimCheckLambda(movingDim);
       auto hasCorrectDim = mitk::NodePredicateFunction::New(dimCheck);
 
       if (movingDim == 3)
       {
         //Remark: Point sets are always 3D
         auto is3DInput = mitk::NodePredicateOr::New(isPointSet, mitk::NodePredicateAnd::New(isImage, hasCorrectDim));
-        inputPredicate = is3DInput;
+        inputPredicate = is3DInput.GetPointer();
       }
       else
       {
         auto is2DInput = mitk::NodePredicateAnd::New(isImage, hasCorrectDim);
-        inputPredicate = is2DInput;
+        inputPredicate = is2DInput.GetPointer();
       }
 
       auto targetDim = wrapper->GetTargetDimensions();
 
       auto targetDimCheck = GenerateDimCheckLambda(targetDim);
       auto hasCorrectTargetDim = mitk::NodePredicateFunction::New(targetDimCheck);
 
       auto isRef = mitk::NodePredicateAnd::New(isImage, hasCorrectTargetDim);
       refPredicate = isRef;
 
     }
   }
   this->m_Controls.inputNodeSelector->SetNodePredicate(inputPredicate);
   this->m_Controls.referenceNodeSelector->SetNodePredicate(refPredicate);
 }
 
 void QmitkMatchPointMapper::CheckInputs()
 {
     this->m_spSelectedRegNode = this->m_Controls.registrationNodeSelector->GetSelectedNode();
     this->m_spSelectedInputNode = this->m_Controls.inputNodeSelector->GetSelectedNode();
     this->m_spSelectedRefNode = this->m_Controls.referenceNodeSelector->GetSelectedNode();
 
     if (!(m_Controls.m_cbManualRef->isChecked()))
     {
         auto autoRefNode = this->GetAutoRefNodeByReg();
         if (this->m_spSelectedRefNode != autoRefNode)
         {
           this->m_spSelectedRefNode = autoRefNode;
           QmitkSingleNodeSelectionWidget::NodeList selection;
 
           if (this->m_spSelectedRefNode.IsNotNull())
           {
             selection.append(this->m_spSelectedRefNode);
           }
           this->m_Controls.referenceNodeSelector->SetCurrentSelection(selection);
         }
     }
 
     if (this->m_spSelectedRefNode.IsNotNull() && this->m_spSelectedRefNode->GetData()
         && this->m_spSelectedRefNode->GetData()->GetTimeSteps() > 1)
     {
         m_Controls.m_teLog->append(
             QString("<font color='gray'><i>Selected reference image has multiple time steps. Only geometry of time step 1 is used as reference.</i></font>"));
     }
 }
 
 void QmitkMatchPointMapper::ConfigureMappingControls()
 {
     bool validInput = m_spSelectedInputNode.IsNotNull();
     bool validReg = m_spSelectedRegNode.IsNotNull();
     bool validRef = m_spSelectedRefNode.IsNotNull();
 
     this->m_Controls.referenceNodeSelector->setEnabled(this->m_Controls.m_cbManualRef->isChecked());
     this->m_Controls.m_pbMap->setEnabled(validInput  && validRef && validReg);
     this->m_Controls.m_pbRefine->setEnabled(validInput && validReg
         && this->IsAbleToRefineGeometry() && !this->IsPointSetInput());
 
     if (validInput && validReg)
     {
         this->m_Controls.m_leMappedName->setText(tr("mapped_by_") + QString::fromStdString(
             m_spSelectedRegNode->GetName()));
     }
     else
     {
         this->m_Controls.m_leMappedName->setText(tr("mappedData"));
     }
 
     if (this->IsBinaryInput() != this->m_preparedForBinaryInput)
     {
         if (this->IsBinaryInput())
         {
             m_Controls.m_teLog->append(
                 QString("<font color='gray'><i>Binary input (mask) detected. Preparing for mask mapping (default interpolation: nearest neigbour; padding value: 0)</i></font>"));
 
             this->m_Controls.m_comboInterpolator->setCurrentIndex(0);
             this->m_Controls.m_sbErrorValue->setValue(0);
             this->m_Controls.m_sbPaddingValue->setValue(0);
         }
         else
         {
             this->m_Controls.m_comboInterpolator->setCurrentIndex(1);
         }
 
         this->m_preparedForBinaryInput = this->IsBinaryInput();
     }
 
     OnLinkSampleFactorChecked();
 }
 
 void QmitkMatchPointMapper::ConfigureProgressInfos()
 {
 
 }
 
 void QmitkMatchPointMapper::OnRegNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   mitk::DataNode::Pointer regNode;
   if (!nodes.isEmpty())
   {
     regNode = nodes.front();
   }
 
   this->ConfigureNodePredicates(regNode);
   this->CheckInputs();
   this->ConfigureMappingControls();
 }
 
 void QmitkMatchPointMapper::OnInputNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   mitk::DataNode::Pointer inputNode;
   if (!nodes.isEmpty())
   {
     inputNode = nodes.front();
   }
 
   this->ConfigureRegNodePredicate(inputNode);
   this->CheckInputs();
   this->ConfigureMappingControls();
 }
 
 void QmitkMatchPointMapper::OnReferenceNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
 {
   this->CheckInputs();
   this->ConfigureMappingControls();
 }
 
 void QmitkMatchPointMapper::OnManualRefChecked()
 {
     this->CheckInputs();
     this->ConfigureMappingControls();
 }
 
 void QmitkMatchPointMapper::OnLinkSampleFactorChecked()
 {
     this->m_Controls.m_sbYFactor->setEnabled(!(this->m_Controls.m_cbLinkFactors->isChecked()));
     this->m_Controls.m_sbZFactor->setEnabled(!(this->m_Controls.m_cbLinkFactors->isChecked()));
 
     if (m_Controls.m_cbLinkFactors->isChecked())
     {
         this->m_Controls.m_sbYFactor->setValue(this->m_Controls.m_sbXFactor->value());
         this->m_Controls.m_sbZFactor->setValue(this->m_Controls.m_sbXFactor->value());
     }
 }
 
 
 void QmitkMatchPointMapper::OnMapBtnPushed()
 {
     SpawnMappingJob();
 }
 
 void QmitkMatchPointMapper::OnRefineBtnPushed()
 {
     SpawnMappingJob(true);
 }
 
 void QmitkMatchPointMapper::SpawnMappingJob(bool doGeometryRefinement)
 {
     if (m_Controls.m_checkClearLog->checkState() == Qt::Checked)
     {
         this->m_Controls.m_teLog->clear();
     }
 
     /////////////////////////
     //create job and put it into the thread pool
     QmitkMappingJob* pJob = new QmitkMappingJob();
     pJob->setAutoDelete(true);
 
     pJob->m_spInputData = this->m_spSelectedInputNode->GetData();
     pJob->m_InputDataUID = mitk::EnsureUID(this->m_spSelectedInputNode->GetData());
     pJob->m_doGeometryRefinement = doGeometryRefinement;
 
     pJob->m_spRegNode = m_spSelectedRegNode;
     if (m_spSelectedRegNode.IsNull())
     {
         pJob->m_spRegNode = mitk::DataNode::New();
         pJob->m_spRegNode->SetData(mitk::GenerateIdentityRegistration3D().GetPointer());
         pJob->m_spRegNode->SetName("Auto_Generated_Identity_Transform");
         m_Controls.m_teLog->append(
             QString("<font color='gray'><i>No registration selected. Preforming mapping with identity transform</i></font>"));
     }
 
     if (!doGeometryRefinement)
     {
         pJob->m_spRefGeometry = m_spSelectedRefNode->GetData()->GetGeometry()->Clone().GetPointer();
 
         //check for super/sub sampling
         if (m_Controls.m_groupActivateSampling->isChecked())
         {
             //change the pixel count and  spacing of the geometry
             mitk::BaseGeometry::BoundsArrayType geoBounds = pJob->m_spRefGeometry->GetBounds();
             auto oldSpacing = pJob->m_spRefGeometry->GetSpacing();
             mitk::Vector3D geoSpacing;
 
             geoSpacing[0] = oldSpacing[0] / m_Controls.m_sbXFactor->value();
             geoSpacing[1] = oldSpacing[1] / m_Controls.m_sbYFactor->value();
             geoSpacing[2] = oldSpacing[2] / m_Controls.m_sbZFactor->value();
 
             geoBounds[1] = geoBounds[1] * m_Controls.m_sbXFactor->value();
             geoBounds[3] = geoBounds[3] * m_Controls.m_sbYFactor->value();
             geoBounds[5] = geoBounds[5] * m_Controls.m_sbZFactor->value();
 
             pJob->m_spRefGeometry->SetBounds(geoBounds);
             pJob->m_spRefGeometry->SetSpacing(geoSpacing);
 
             auto oldOrigin = pJob->m_spRefGeometry->GetOrigin();
 
             //if we change the spacing we must also correct the origin to ensure
             //that the voxel matrix still covers the same space. This is due the fact
             //that the origin is not in the corner of the voxel matrix, but in the center
             // of the voxel that is in the corner.
             mitk::Point3D newOrigin;
             for (mitk::Point3D::SizeType i = 0; i < 3; ++i)
             {
               newOrigin[i] = 0.5* (geoSpacing[i] - oldSpacing[i]) + oldOrigin[i];
             }
 
             pJob->m_spRefGeometry->SetOrigin(newOrigin);
         }
     }
 
     pJob->m_MappedName = m_Controls.m_leMappedName->text().toStdString();
     pJob->m_allowUndefPixels = m_Controls.m_groupAllowUndefPixels->isChecked();
     pJob->m_paddingValue = m_Controls.m_sbPaddingValue->value();
     pJob->m_allowUnregPixels = m_Controls.m_groupAllowUnregPixels->isChecked();
     pJob->m_errorValue = m_Controls.m_sbErrorValue->value();
     pJob->m_InterpolatorLabel = m_Controls.m_comboInterpolator->currentText().toStdString();
 
     switch (m_Controls.m_comboInterpolator->currentIndex())
     {
     case 0:
         pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::NearestNeighbor;
         break;
 
     case 1:
         pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::Linear;
         break;
 
     case 2:
         pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::BSpline_3;
         break;
 
     case 3:
         pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::WSinc_Hamming;
         break;
 
     case 4:
         pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::WSinc_Welch;
         break;
     }
 
     connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnMapJobError(QString)));
     connect(pJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)), this,
         SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
         Qt::BlockingQueuedConnection);
     connect(pJob, SIGNAL(AlgorithmInfo(QString)), this, SLOT(OnMappingInfo(QString)));
 
     m_Controls.m_teLog->append(QString("<b><font color='blue'>Started mapping job. Name: ") +
         m_Controls.m_leMappedName->text() + QString("</font></b>"));
 
     QThreadPool* threadPool = QThreadPool::globalInstance();
     threadPool->start(pJob);
 }
 
 
 
 void QmitkMatchPointMapper::OnMapJobError(QString err)
 {
     Error(err);
 }
 
 void QmitkMatchPointMapper::OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData,
     const QmitkMappingJob* job)
 {
     m_Controls.m_teLog->append(QString("<b><font color='blue'>Mapped entity stored. Name: ") +
         QString::fromStdString(job->m_MappedName) + QString("</font></b>"));
 
     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();
 
     this->CheckInputs();
     this->ConfigureMappingControls();
 }
 
 void QmitkMatchPointMapper::OnMappingInfo(QString info)
 {
     m_Controls.m_teLog->append(QString("<font color='gray'><i>") + info + QString("</i></font>"));
 }
 
 void QmitkMatchPointMapper::OnXFactorChanged(double d)
 {
     if (m_Controls.m_cbLinkFactors->isChecked())
     {
         this->m_Controls.m_sbYFactor->setValue(d);
         this->m_Controls.m_sbZFactor->setValue(d);
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.cpp b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.cpp
index 328c486acb..52c2f6262b 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.cpp
@@ -1,795 +1,795 @@
 /*============================================================================
 
 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_visualizer_Activator.h"
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Mitk
 #include <mitkStatusBar.h>
 #include <mitkProperties.h>
 #include <mitkColorProperty.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateDataProperty.h>
 #include <mitkNodePredicateFunction.h>
 #include "mitkRegVisDirectionProperty.h"
 #include "mitkRegVisStyleProperty.h"
 #include "mitkRegVisColorStyleProperty.h"
 #include "mitkRegVisPropertyTags.h"
 #include "mitkRegVisHelper.h"
 #include "mitkMatchPointPropertyTags.h"
 #include "mitkRegistrationHelper.h"
 
 // Qmitk
 #include "QmitkMatchPointRegistrationVisualizer.h"
 
 // Qt
 #include <QMessageBox>
 #include <QErrorMessage>
 
 const std::string QmitkMatchPointRegistrationVisualizer::VIEW_ID =
 "org.mitk.views.matchpoint.visualizer";
 
 QmitkMatchPointRegistrationVisualizer::QmitkMatchPointRegistrationVisualizer()
     : m_Parent(nullptr), m_internalUpdateGuard(false), m_spSelectedFOVRefNode(nullptr),
     m_spSelectedRegNode(nullptr)
 {
 }
 
 void QmitkMatchPointRegistrationVisualizer::SetFocus()
 {
 }
 
 void QmitkMatchPointRegistrationVisualizer::CreateConnections()
 {
     connect(m_Controls->registrationNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
     connect(m_Controls->fovReferenceNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
 
     connect(m_Controls->m_pbStyleGrid, SIGNAL(clicked()), this, SLOT(OnStyleButtonPushed()));
     connect(m_Controls->m_pbStyleGlyph, SIGNAL(clicked()), this, SLOT(OnStyleButtonPushed()));
     connect(m_Controls->m_pbStylePoints, SIGNAL(clicked()), this, SLOT(OnStyleButtonPushed()));
 
     connect(m_Controls->m_comboDirection, SIGNAL(currentIndexChanged(int)), this,
         SLOT(OnDirectionChanged(int)));
     connect(m_Controls->m_pbUpdateViz, SIGNAL(clicked()), this, SLOT(OnUpdateBtnPushed()));
 
     connect(m_Controls->radioColorUni, SIGNAL(toggled(bool)), m_Controls->btnUniColor,
         SLOT(setEnabled(bool)));
     connect(m_Controls->radioColorVecMag, SIGNAL(toggled(bool)), m_Controls->groupColorCoding,
         SLOT(setEnabled(bool)));
 
     connect(m_Controls->m_pbStyleGrid, SIGNAL(toggled(bool)), m_Controls->tabGrid,
         SLOT(setEnabled(bool)));
 
     connect(m_Controls->cbVevMagInterlolate, SIGNAL(toggled(bool)), this,
         SLOT(OnColorInterpolationChecked(bool)));
 
     connect(m_Controls->m_checkUseRefSize, SIGNAL(clicked()), this, SLOT(TransferFOVRefGeometry()));
     connect(m_Controls->m_checkUseRefSpacing, SIGNAL(clicked()), this, SLOT(TransferFOVRefGeometry()));
     connect(m_Controls->m_checkUseRefOrigin, SIGNAL(clicked()), this, SLOT(TransferFOVRefGeometry()));
     connect(m_Controls->m_checkUseRefOrientation, SIGNAL(clicked()), this, SLOT(TransferFOVRefGeometry()));
 }
 
 void QmitkMatchPointRegistrationVisualizer::Error(QString msg)
 {
     mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
     MITK_ERROR << msg.toStdString().c_str();
 }
 
 void QmitkMatchPointRegistrationVisualizer::CreateQtPartControl(QWidget* parent)
 {
     m_Controls = new Ui::MatchPointRegVisControls;
 
     // 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->fovReferenceNodeSelector->SetDataStorage(this->GetDataStorage());
     this->m_Controls->fovReferenceNodeSelector->SetSelectionIsOptional(false);
     m_Controls->registrationNodeSelector->SetInvalidInfo("Select registration.");
     m_Controls->registrationNodeSelector->SetPopUpTitel("Select registration.");
     m_Controls->registrationNodeSelector->SetPopUpHint("Select the registration object whose registration visualization should be edited.");
     m_Controls->fovReferenceNodeSelector->SetInvalidInfo("Select a FOV reference image.");
     m_Controls->fovReferenceNodeSelector->SetPopUpTitel("Select a FOV reference image.");
     m_Controls->fovReferenceNodeSelector->SetPopUpHint("Select the the image that should be used to define the field of view (FOV) for the registration visualization. The visualization will use the image geometry (size, orientation, spacing...).");
 
     this->ConfigureNodePredicates();
 
     this->m_Controls->btnVecMagColorSmall->setDisplayColorName(false);
     this->m_Controls->btnVecMagColorMedium->setDisplayColorName(false);
     this->m_Controls->btnVecMagColorLarge->setDisplayColorName(false);
     this->m_Controls->btnVecMagColorNeg->setDisplayColorName(false);
     this->m_Controls->btnUniColor->setDisplayColorName(false);
     this->m_Controls->btnStartGridColor->setDisplayColorName(false);
 
     this->CreateConnections();
 
     this->m_Controls->radioColorUni->setChecked(false);
     this->m_Controls->radioColorVecMag->setChecked(true);
 
     this->CheckInputs();
     this->LoadStateFromNode();
     this->ConfigureVisualizationControls();
 }
 
 void QmitkMatchPointRegistrationVisualizer::ConfigureNodePredicates()
 {
   m_Controls->registrationNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::RegNodePredicate());
 
   auto geometryCheck = [](const mitk::DataNode * node)
   {
     return node->GetData() && node->GetData()->GetGeometry();
   };
   mitk::NodePredicateFunction::Pointer hasGeometry = mitk::NodePredicateFunction::New(geometryCheck);
 
-  mitk::NodePredicateBase::Pointer nodePredicate = mitk::NodePredicateAnd::New(mitk::MITKRegistrationHelper::ImageNodePredicate(), hasGeometry);
-  m_Controls->fovReferenceNodeSelector->SetNodePredicate(nodePredicate);
+  auto nodePredicate = mitk::NodePredicateAnd::New(mitk::MITKRegistrationHelper::ImageNodePredicate().GetPointer(), hasGeometry.GetPointer());
+  m_Controls->fovReferenceNodeSelector->SetNodePredicate(nodePredicate.GetPointer());
 }
 
 mitk::MAPRegistrationWrapper* QmitkMatchPointRegistrationVisualizer::GetCurrentRegistration()
 {
     mitk::MAPRegistrationWrapper* result = nullptr;
 
     if (this->m_spSelectedRegNode.IsNotNull())
     {
         result = dynamic_cast<mitk::MAPRegistrationWrapper*>(this->m_spSelectedRegNode->GetData());
         assert(result);
     }
 
     return result;
 }
 
 mitk::DataNode::Pointer QmitkMatchPointRegistrationVisualizer::GetSelectedRegNode() const
 {
     return m_Controls->registrationNodeSelector->GetSelectedNode();
 }
 
 mitk::DataNode::Pointer QmitkMatchPointRegistrationVisualizer::GetRefNodeOfReg(bool target) const
 {
     mitk::DataNode::Pointer spResult = nullptr;
 
     if (this->m_spSelectedRegNode.IsNotNull() && m_spSelectedRegNode->GetData())
     {
         std::string nodeName;
         mitk::BaseProperty* uidProp;
 
         if (target)
         {
           uidProp = m_spSelectedRegNode->GetData()->GetProperty(mitk::Prop_RegAlgTargetData);
         }
         else
         {
           uidProp = m_spSelectedRegNode->GetData()->GetProperty(mitk::Prop_RegAlgMovingData);
         }
 
         if (uidProp)
         {
             //search for the target node
             mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
                 uidProp);
             spResult = this->GetDataStorage()->GetNode(predicate);
         }
     }
 
     return spResult;
 }
 
 mitk::DataNode::Pointer QmitkMatchPointRegistrationVisualizer::GetSelectedDataNode()
 {
   return m_Controls->fovReferenceNodeSelector->GetSelectedNode();
 }
 
 void QmitkMatchPointRegistrationVisualizer::CheckInputs()
 {
   this->m_spSelectedRegNode = this->GetSelectedRegNode();
 
   this->InitRegNode();
 
   this->m_spSelectedFOVRefNode = this->GetSelectedDataNode();
 }
 
 void QmitkMatchPointRegistrationVisualizer::ConfigureVisualizationControls()
 {
     if (!m_internalUpdateGuard)
     {
         m_internalUpdateGuard = true;
         m_Controls->groupViz->setVisible(this->m_spSelectedRegNode.IsNotNull());
 
         m_Controls->m_pbUpdateViz->setEnabled(this->m_spSelectedRegNode.IsNotNull());
         m_Controls->m_boxSettings->setEnabled(this->m_spSelectedRegNode.IsNotNull());
         m_Controls->m_boxStyles->setEnabled(this->m_spSelectedRegNode.IsNotNull());
 
         this->ActualizeRegInfo(this->GetCurrentRegistration());
 
         this->m_Controls->m_checkUseRefSize->setEnabled(this->m_spSelectedRegNode.IsNotNull()
             && this->m_spSelectedFOVRefNode.IsNotNull());
         this->m_Controls->m_checkUseRefOrigin->setEnabled(this->m_spSelectedRegNode.IsNotNull()
             && this->m_spSelectedFOVRefNode.IsNotNull());
         this->m_Controls->m_checkUseRefSpacing->setEnabled(this->m_spSelectedRegNode.IsNotNull()
             && this->m_spSelectedFOVRefNode.IsNotNull());
 
         m_internalUpdateGuard = false;
     }
 }
 
 void QmitkMatchPointRegistrationVisualizer::StoreStateInNode()
 {
     if (this->m_spSelectedRegNode.IsNotNull())
     {
         //general
         this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisDirection,
             mitk::RegVisDirectionProperty::New(this->m_Controls->m_comboDirection->currentIndex()));
 
         this->m_spSelectedRegNode->SetBoolProperty(mitk::nodeProp_RegVisGrid,
             this->m_Controls->m_pbStyleGrid->isChecked());
         this->m_spSelectedRegNode->SetBoolProperty(mitk::nodeProp_RegVisGlyph,
             this->m_Controls->m_pbStyleGlyph->isChecked());
         this->m_spSelectedRegNode->SetBoolProperty(mitk::nodeProp_RegVisPoints,
             this->m_Controls->m_pbStylePoints->isChecked());
 
         //Visualization
         if (this->m_Controls->radioColorUni->isChecked())
         {
             this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisColorStyle,
                 mitk::RegVisColorStyleProperty::New(0));
         }
         else
         {
             this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisColorStyle,
                 mitk::RegVisColorStyleProperty::New(1));
         }
 
         float tmpColor[3];
 
         tmpColor[0] = this->m_Controls->btnUniColor->color().redF();
         tmpColor[1] = this->m_Controls->btnUniColor->color().greenF();
         tmpColor[2] = this->m_Controls->btnUniColor->color().blueF();
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorUni,
             mitk::ColorProperty::New(tmpColor), nullptr, true);
 
         tmpColor[0] = this->m_Controls->btnVecMagColorNeg->color().redF();
         tmpColor[1] = this->m_Controls->btnVecMagColorNeg->color().greenF();
         tmpColor[2] = this->m_Controls->btnVecMagColorNeg->color().blueF();
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor1Value,
             mitk::ColorProperty::New(tmpColor), nullptr, true);
 
         tmpColor[0] = this->m_Controls->btnVecMagColorSmall->color().redF();
         tmpColor[1] = this->m_Controls->btnVecMagColorSmall->color().greenF();
         tmpColor[2] = this->m_Controls->btnVecMagColorSmall->color().blueF();
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor2Value,
             mitk::ColorProperty::New(tmpColor), nullptr, true);
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor2Magnitude,
             mitk::DoubleProperty::New(this->m_Controls->sbVecMagSmall->value()), nullptr, true);
 
         tmpColor[0] = this->m_Controls->btnVecMagColorMedium->color().redF();
         tmpColor[1] = this->m_Controls->btnVecMagColorMedium->color().greenF();
         tmpColor[2] = this->m_Controls->btnVecMagColorMedium->color().blueF();
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor3Value,
             mitk::ColorProperty::New(tmpColor), nullptr, true);
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor3Magnitude,
             mitk::DoubleProperty::New(this->m_Controls->sbVecMagMedium->value()), nullptr, true);
 
         tmpColor[0] = this->m_Controls->btnVecMagColorLarge->color().redF();
         tmpColor[1] = this->m_Controls->btnVecMagColorLarge->color().greenF();
         tmpColor[2] = this->m_Controls->btnVecMagColorLarge->color().blueF();
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor4Value,
             mitk::ColorProperty::New(tmpColor), nullptr, true);
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor4Magnitude,
             mitk::DoubleProperty::New(this->m_Controls->sbVecMagLarge->value()), nullptr, true);
 
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorInterpolate,
             mitk::BoolProperty::New(this->m_Controls->cbVevMagInterlolate->isChecked()), nullptr, true);
 
         //Grid Settings
         this->m_spSelectedRegNode->SetIntProperty(mitk::nodeProp_RegVisGridFrequence,
             this->m_Controls->m_sbGridFrequency->value());
         this->m_spSelectedRegNode->SetBoolProperty(mitk::nodeProp_RegVisGridShowStart,
             this->m_Controls->m_groupShowStartGrid->isChecked());
         tmpColor[0] = this->m_Controls->btnStartGridColor->color().redF();
         tmpColor[1] = this->m_Controls->btnStartGridColor->color().greenF();
         tmpColor[2] = this->m_Controls->btnStartGridColor->color().blueF();
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGridStartColor,
             mitk::ColorProperty::New(tmpColor), nullptr, true);
 
         //FOV
         mitk::Vector3D value;
         value[0] = this->m_Controls->m_sbFOVSizeX->value();
         value[1] = this->m_Controls->m_sbFOVSizeY->value();
         value[2] = this->m_Controls->m_sbFOVSizeZ->value();
         this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVSize,
             mitk::Vector3DProperty::New(value));
 
         value[0] = this->m_Controls->m_sbGridSpX->value();
         value[1] = this->m_Controls->m_sbGridSpY->value();
         value[2] = this->m_Controls->m_sbGridSpZ->value();
         this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVSpacing,
             mitk::Vector3DProperty::New(value));
 
         mitk::Point3D origin;
         origin[0] = this->m_Controls->m_sbFOVOriginX->value();
         origin[1] = this->m_Controls->m_sbFOVOriginY->value();
         origin[2] = this->m_Controls->m_sbFOVOriginZ->value();
         this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVOrigin,
             mitk::Point3dProperty::New(origin));
 
         mitk::Vector3D orientationRow1;
         mitk::Vector3D orientationRow2;
         mitk::Vector3D orientationRow3;
         orientationRow1.SetVnlVector(m_FOVRefOrientation.GetVnlMatrix().get_row(0));
         orientationRow2.SetVnlVector(m_FOVRefOrientation.GetVnlMatrix().get_row(1));
         orientationRow3.SetVnlVector(m_FOVRefOrientation.GetVnlMatrix().get_row(2));
         this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVOrientation1,
             mitk::Vector3DProperty::New(orientationRow1));
         this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVOrientation2,
             mitk::Vector3DProperty::New(orientationRow2));
         this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVOrientation3,
             mitk::Vector3DProperty::New(orientationRow3));
 
     }
 }
 
 void QmitkMatchPointRegistrationVisualizer::LoadStateFromNode()
 {
     if (this->m_spSelectedRegNode.IsNotNull())
     {
         mitk::RegVisDirectionProperty* directionProp = nullptr;
 
         if (this->m_spSelectedRegNode->GetProperty(directionProp, mitk::nodeProp_RegVisDirection))
         {
             this->m_Controls->m_comboDirection->setCurrentIndex(directionProp->GetValueAsId());
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisDirection) + QString(" has not the assumed type."));
         }
 
         bool styleActive = false;
 
         if (this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisGrid, styleActive))
         {
             this->m_Controls->m_pbStyleGrid->setChecked(styleActive);
             this->m_Controls->tabGrid->setEnabled(styleActive);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisGrid) + QString(" has not the assumed type."));
         }
 
         if (this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisGlyph, styleActive))
         {
             this->m_Controls->m_pbStyleGlyph->setChecked(styleActive);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisGlyph) + QString(" has not the assumed type."));
         }
 
         if (this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisPoints, styleActive))
         {
             this->m_Controls->m_pbStylePoints->setChecked(styleActive);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisPoints) + QString(" has not the assumed type."));
         }
 
         ///////////////////////////////////////////////////////
         //visualization
         mitk::RegVisColorStyleProperty* colorStyleProp = nullptr;
 
         if (this->m_spSelectedRegNode->GetProperty(colorStyleProp, mitk::nodeProp_RegVisColorStyle))
         {
             this->m_Controls->radioColorUni->setChecked(colorStyleProp->GetValueAsId() == 0);
             this->m_Controls->radioColorVecMag->setChecked(colorStyleProp->GetValueAsId() == 1);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisColorStyle) + QString(" has not the assumed type."));
         }
 
         QColor tmpColor;
         float colorUni[3] = { 0.0, 0.0, 0.0 };
         this->m_spSelectedRegNode->GetColor(colorUni, nullptr, mitk::nodeProp_RegVisColorUni);
         tmpColor.setRgbF(colorUni[0], colorUni[1], colorUni[2]);
         this->m_Controls->btnUniColor->setColor(tmpColor);
 
         float color1[3] = { 0.0, 0.0, 0.0 };
         this->m_spSelectedRegNode->GetColor(color1, nullptr, mitk::nodeProp_RegVisColor1Value);
         tmpColor.setRgbF(color1[0], color1[1], color1[2]);
         this->m_Controls->btnVecMagColorNeg->setColor(tmpColor);
 
         float color2[3] = { 0.25, 0.25, 0.25 };
         this->m_spSelectedRegNode->GetColor(color2, nullptr, mitk::nodeProp_RegVisColor2Value);
         tmpColor.setRgbF(color2[0], color2[1], color2[2]);
         this->m_Controls->btnVecMagColorSmall->setColor(tmpColor);
 
         float color3[3] = { 0.5, 0.5, 0.5 };
         this->m_spSelectedRegNode->GetColor(color3, nullptr, mitk::nodeProp_RegVisColor3Value);
         tmpColor.setRgbF(color3[0], color3[1], color3[2]);
         this->m_Controls->btnVecMagColorMedium->setColor(tmpColor);
 
         float color4[3] = { 1.0, 1.0, 1.0 };
         this->m_spSelectedRegNode->GetColor(color4, nullptr, mitk::nodeProp_RegVisColor4Value);
         tmpColor.setRgbF(color4[0], color4[1], color4[2]);
         this->m_Controls->btnVecMagColorLarge->setColor(tmpColor);
 
         double mag2 = 0;
         this->m_spSelectedRegNode->GetPropertyValue(mitk::nodeProp_RegVisColor2Magnitude, mag2);
         double mag3 = 0;
         this->m_spSelectedRegNode->GetPropertyValue(mitk::nodeProp_RegVisColor3Magnitude, mag3);
         double mag4 = 0;
         this->m_spSelectedRegNode->GetPropertyValue(mitk::nodeProp_RegVisColor4Magnitude, mag4);
 
         bool interpolate = true;
         this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisColorInterpolate, interpolate);
 
         this->m_Controls->sbVecMagSmall->setValue(mag2);
         this->m_Controls->sbVecMagMedium->setValue(mag3);
         this->m_Controls->sbVecMagLarge->setValue(mag4);
 
         this->m_Controls->cbVevMagInterlolate->setChecked(interpolate);
 
         ///////////////////////////////////////////////////////
         //Grid general
         bool showStart = false;
 
         if (this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisGridShowStart, showStart))
         {
             this->m_Controls->m_groupShowStartGrid->setChecked(showStart);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisGridShowStart) + QString(" is not correctly defined."));
         }
 
         int gridFrequ = 5;
 
         if (this->m_spSelectedRegNode->GetIntProperty(mitk::nodeProp_RegVisGridFrequence, gridFrequ))
         {
             this->m_Controls->m_sbGridFrequency->setValue(gridFrequ);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisGridFrequence) + QString(" is not correctly defined."));
         }
 
         float colorStart[3] = { 0.0, 0.0, 0.0 };
         this->m_spSelectedRegNode->GetColor(colorStart, nullptr, mitk::nodeProp_RegVisGridStartColor);
         tmpColor.setRgbF(colorStart[0], colorStart[1], colorStart[2]);
         this->m_Controls->btnStartGridColor->setColor(tmpColor);
 
         ///////////////////////////////////////////////////////
         //FOV
         mitk::Vector3DProperty* valueProp = nullptr;
 
         if (this->m_spSelectedRegNode->GetProperty(valueProp, mitk::nodeProp_RegVisFOVSize))
         {
             this->m_Controls->m_sbFOVSizeX->setValue(valueProp->GetValue()[0]);
             this->m_Controls->m_sbFOVSizeY->setValue(valueProp->GetValue()[1]);
             this->m_Controls->m_sbFOVSizeZ->setValue(valueProp->GetValue()[2]);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisFOVSize) + QString(" is not correctly defined."));
         }
 
         if (this->m_spSelectedRegNode->GetProperty(valueProp, mitk::nodeProp_RegVisFOVSpacing))
         {
             this->m_Controls->m_sbGridSpX->setValue(valueProp->GetValue()[0]);
             this->m_Controls->m_sbGridSpY->setValue(valueProp->GetValue()[1]);
             this->m_Controls->m_sbGridSpZ->setValue(valueProp->GetValue()[2]);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisFOVSpacing) + QString(" is not correctly defined."));
         }
 
         mitk::Point3dProperty* originProp = nullptr;
 
         if (this->m_spSelectedRegNode->GetProperty(originProp, mitk::nodeProp_RegVisFOVOrigin))
         {
             this->m_Controls->m_sbFOVOriginX->setValue(originProp->GetValue()[0]);
             this->m_Controls->m_sbFOVOriginY->setValue(originProp->GetValue()[1]);
             this->m_Controls->m_sbFOVOriginZ->setValue(originProp->GetValue()[2]);
         }
         else
         {
             this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
                 mitk::nodeProp_RegVisFOVOrigin) + QString(" is not correctly defined."));
         }
 
         mitk::Vector3DProperty* orientationProp1;
         mitk::Vector3DProperty* orientationProp2;
         mitk::Vector3DProperty* orientationProp3;
 
         if (this->m_spSelectedRegNode->GetProperty(orientationProp1, mitk::nodeProp_RegVisFOVOrientation1) &&
             this->m_spSelectedRegNode->GetProperty(orientationProp2, mitk::nodeProp_RegVisFOVOrientation2) &&
             this->m_spSelectedRegNode->GetProperty(orientationProp3, mitk::nodeProp_RegVisFOVOrientation3))
         {
             this->m_Controls->m_sbFOVOriginX->setValue(originProp->GetValue()[0]);
             this->m_Controls->m_sbFOVOriginY->setValue(originProp->GetValue()[1]);
             this->m_Controls->m_sbFOVOriginZ->setValue(originProp->GetValue()[2]);
             m_FOVRefOrientation.GetVnlMatrix().set_row(0, orientationProp1->GetValue().GetVnlVector());
             m_FOVRefOrientation.GetVnlMatrix().set_row(1, orientationProp2->GetValue().GetVnlVector());
             m_FOVRefOrientation.GetVnlMatrix().set_row(2, orientationProp3->GetValue().GetVnlVector());
         }
         else
         {
             m_FOVRefOrientation.SetIdentity();
 
             this->Error(QString("Cannot configure plugin controlls correctly. One of the node propertiesy ") +
                 QString(mitk::nodeProp_RegVisFOVOrientation1) + QString(mitk::nodeProp_RegVisFOVOrientation2) +
                 QString(mitk::nodeProp_RegVisFOVOrientation3) + QString(" is not correctly defined."));
         }
 
         this->UpdateOrientationMatrixWidget();
     }
 }
 
 void QmitkMatchPointRegistrationVisualizer::CheckAndSetDefaultFOVRef()
 {
     //check if node has a default reference node.
     mitk::DataNode::Pointer defaultRef = this->GetRefNodeOfReg(
         this->m_Controls->m_comboDirection->currentIndex() ==
         1); //direction value 1 = show inverse mapping -> we need the target image used for the registration.
 
     //if there is a default node and no m_spSelectedFOVRefNode is set -> set default node and transfer values
     if (defaultRef.IsNotNull() && this->m_spSelectedFOVRefNode.IsNull())
     {
       //there is a default ref and no ref lock -> select default ref and transfer its values
       this->m_spSelectedFOVRefNode = defaultRef;
       QmitkSingleNodeSelectionWidget::NodeList selection({ defaultRef });
       this->m_Controls->fovReferenceNodeSelector->SetCurrentSelection(selection);
       this->m_Controls->m_checkUseRefSize->setChecked(true);
       this->m_Controls->m_checkUseRefOrigin->setChecked(true);
       this->m_Controls->m_checkUseRefSpacing->setChecked(true);
       this->m_Controls->m_checkUseRefOrientation->setChecked(true);
     }
 
     if (this->m_spSelectedFOVRefNode.IsNotNull())
     {
       //auto transfere values
       this->TransferFOVRefGeometry();
     }
 }
 
 void QmitkMatchPointRegistrationVisualizer::OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
 {
   this->CheckInputs();
   this->LoadStateFromNode();
   this->CheckAndSetDefaultFOVRef();
   this->ConfigureVisualizationControls();
 }
 
 void QmitkMatchPointRegistrationVisualizer::ActualizeRegInfo(mitk::MAPRegistrationWrapper*
     currentReg)
 {
     std::stringstream descriptionString;
 
     m_Controls->m_teRegInfo->clear();
 
     if (currentReg)
     {
         descriptionString << "Moving dimension: " << currentReg->GetMovingDimensions() << "<br/>";
         descriptionString << "Target dimension: " << currentReg->GetTargetDimensions() << "<br/>";
         descriptionString << "Limited moving representation: " <<
             currentReg->HasLimitedMovingRepresentation() << "<br/>";
         descriptionString << "Limited target representation: " <<
             currentReg->HasLimitedTargetRepresentation() << "<br/>";
 
         mitk::MAPRegistrationWrapper::TagMapType tagMap = currentReg->GetTags();
 
         descriptionString << "<br/><b>Tags:</b><br/>";
 
         for (mitk::MAPRegistrationWrapper::TagMapType::const_iterator pos = tagMap.begin();
             pos != tagMap.end(); ++pos)
         {
             descriptionString << pos->first << " : " << pos->second << "<br/>";
         }
     }
     else
     {
         descriptionString << "<font color='red'>no registration selected!</font>";
     }
 
     m_Controls->m_teRegInfo->insertHtml(QString::fromStdString(descriptionString.str()));
 
 }
 
 void QmitkMatchPointRegistrationVisualizer::OnDirectionChanged(int)
 {
     this->CheckAndSetDefaultFOVRef();
     this->ConfigureVisualizationControls();
 }
 
 void QmitkMatchPointRegistrationVisualizer::OnUpdateBtnPushed()
 {
     this->StoreStateInNode();
 
     mitk::Geometry3D::Pointer gridDesc;
     unsigned int gridFrequ = 5;
 
     mitk::GetGridGeometryFromNode(this->m_spSelectedRegNode, gridDesc, gridFrequ);
 
     this->GetCurrentRegistration()->SetGeometry(gridDesc);
     mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 void QmitkMatchPointRegistrationVisualizer::OnStyleButtonPushed()
 {
 
 }
 
 void QmitkMatchPointRegistrationVisualizer::OnColorInterpolationChecked(bool checked)
 {
     if (checked)
     {
         this->m_Controls->labelVecMagSmall->setText(QString("="));
         this->m_Controls->labelVecMagMedium->setText(QString("="));
         this->m_Controls->labelVecMagLarge->setText(QString("="));
     }
     else
     {
         this->m_Controls->labelVecMagSmall->setText(QString(">"));
         this->m_Controls->labelVecMagMedium->setText(QString(">"));
         this->m_Controls->labelVecMagLarge->setText(QString(">"));
     }
 }
 
 mitk::ScalarType QmitkMatchPointRegistrationVisualizer::GetSaveSpacing(mitk::ScalarType gridRes,
     mitk::ScalarType spacing, unsigned int maxGridRes) const
 {
     mitk::ScalarType newSpacing = spacing;
     mitk::ScalarType scaling = gridRes / maxGridRes;
 
     if (scaling > 1.0)
     {
         newSpacing = spacing * scaling;
     }
 
     return newSpacing;
 }
 
 void QmitkMatchPointRegistrationVisualizer::TransferFOVRefGeometry()
 {
     if (this->m_spSelectedFOVRefNode.IsNotNull())
     {
         assert(this->m_spSelectedFOVRefNode->GetData());
         assert(this->m_spSelectedFOVRefNode->GetData()->GetGeometry());
 
         mitk::BaseGeometry* gridRef = this->m_spSelectedFOVRefNode->GetData()->GetGeometry();
 
         mitk::Vector3D spacing = gridRef->GetSpacing();
         mitk::Point3D origin = gridRef->GetOrigin();
         mitk::Geometry3D::BoundsArrayType bounds = gridRef->GetBounds();
         mitk::AffineTransform3D::ConstPointer fovTransform = gridRef->GetIndexToWorldTransform();
 
 
         if (this->m_Controls->m_checkUseRefSize->isChecked())
         {
             this->m_Controls->m_sbFOVSizeX->setValue((bounds[1] - bounds[0])*spacing[0]);
             this->m_Controls->m_sbFOVSizeY->setValue((bounds[3] - bounds[2])*spacing[1]);
             this->m_Controls->m_sbFOVSizeZ->setValue((bounds[5] - bounds[4])*spacing[2]);
         }
 
         if (this->m_Controls->m_checkUseRefSpacing->isChecked())
         {
 
             this->m_Controls->m_sbGridSpX->setValue(GetSaveSpacing((bounds[1] - bounds[0]), spacing[0], 20));
             this->m_Controls->m_sbGridSpY->setValue(GetSaveSpacing((bounds[3] - bounds[2]), spacing[1], 20));
             this->m_Controls->m_sbGridSpZ->setValue(GetSaveSpacing((bounds[5] - bounds[4]), spacing[2], 20));
 
         }
 
         if (this->m_Controls->m_checkUseRefOrigin->isChecked())
         {
             this->m_Controls->m_sbFOVOriginX->setValue(origin[0]);
             this->m_Controls->m_sbFOVOriginY->setValue(origin[1]);
             this->m_Controls->m_sbFOVOriginZ->setValue(origin[2]);
         }
 
         if (this->m_Controls->m_checkUseRefOrientation->isChecked())
         {
             this->m_FOVRefOrientation = fovTransform->GetMatrix();
             this->UpdateOrientationMatrixWidget();
         }
 
     }
 }
 
 void QmitkMatchPointRegistrationVisualizer::UpdateOrientationMatrixWidget()
 {
     for (unsigned int r = 0; r < 3; ++r)
     {
         for (unsigned int c = 0; c < 3; ++c)
         {
             this->m_Controls->m_tableOrientation->item(r,
                 c)->setText(QString::number(this->m_FOVRefOrientation.GetVnlMatrix().get(r, c)));
         }
     }
 }
 
 void QmitkMatchPointRegistrationVisualizer::InitRegNode()
 {
     if (this->m_spSelectedRegNode.IsNotNull())
     {
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGrid, mitk::BoolProperty::New(true));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGlyph, mitk::BoolProperty::New(false));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisPoints, mitk::BoolProperty::New(false));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisDirection,
             mitk::RegVisDirectionProperty::New());
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorStyle,
             mitk::RegVisColorStyleProperty::New(1));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorUni, mitk::ColorProperty::New(0,
             0.5, 0));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGridFrequence,
             mitk::IntProperty::New(3));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGridShowStart,
             mitk::BoolProperty::New(false));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGridStartColor,
             mitk::ColorProperty::New(0.5, 0, 0));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVSize,
             mitk::Vector3DProperty::New(mitk::Vector3D(100.0)));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVSpacing,
             mitk::Vector3DProperty::New(mitk::Vector3D(5.0)));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor1Value, mitk::ColorProperty::New(0,
             0, 0.5));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor2Value, mitk::ColorProperty::New(0,
             0.7, 0));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor2Magnitude,
             mitk::DoubleProperty::New(1));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor3Value, mitk::ColorProperty::New(1,
             1, 0));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor3Magnitude,
             mitk::DoubleProperty::New(5));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor4Value, mitk::ColorProperty::New(1,
             0, 0));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor4Magnitude,
             mitk::DoubleProperty::New(15));
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorInterpolate,
             mitk::BoolProperty::New(true));
 
         mitk::Point3D origin;
         origin.Fill(0.0);
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVOrigin,
             mitk::Point3dProperty::New(mitk::Point3D(origin)));
 
         mitk::Vector3D vec(0.0);
         vec.SetElement(0, 1.0);
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVOrientation1,
             mitk::Vector3DProperty::New(vec));
         vec.Fill(0.0);
         vec.SetElement(1, 1.0);
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVOrientation2,
             mitk::Vector3DProperty::New(vec));
         vec.Fill(0.0);
         vec.SetElement(2, 1.0);
         this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVOrientation3,
             mitk::Vector3DProperty::New(vec));
 
     }
 }