sd::frontend::Loader::Loader(const std::string& loaderName,
const sd::frontend::AlgorithmInfo& out,
const std::string& parameters)
: BlackBoxAlgorithm(loaderName, out, AlgorithmInfo(), parameters)
{
setGhostView();
}
void QmitkMatchPoint::OnRegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer
spResultRegistration, const QmitkRegistrationJob* pRegJob)
{
mitk::DataNode::Pointer spResultRegistrationNode = mitk::generateRegistrationResultNode(
pRegJob->m_JobName, spResultRegistration, pRegJob->GetLoadedAlgorithm()->getUID()->toStr(),
pRegJob->m_MovingDataUID, pRegJob->m_TargetDataUID);
if (pRegJob->m_StoreReg)
{
m_Controls.m_teLog->append(
QString("<b><font color='blue'> Storing registration object in data manager ... </font></b>"));
this->GetDataStorage()->Add(spResultRegistrationNode);
this->GetRenderWindowPart()->RequestUpdate();
}
if (m_Controls.m_checkMapEntity->checkState() == Qt::Checked)
{
QmitkMappingJob* pMapJob = new QmitkMappingJob();
pMapJob->setAutoDelete(true);
pMapJob->m_spInputData = pRegJob->m_spMovingData;
pMapJob->m_InputDataUID = pRegJob->m_MovingDataUID;
pMapJob->m_spRegNode = spResultRegistrationNode;
pMapJob->m_doGeometryRefinement = false;
pMapJob->m_spRefGeometry = pRegJob->m_spTargetData->GetGeometry()->Clone().GetPointer();
pMapJob->m_MappedName = pRegJob->m_JobName + 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(OnMapJobError(QString)));
connect(pMapJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
Qt::BlockingQueuedConnection);
connect(pMapJob, SIGNAL(AlgorithmInfo(QString)), this, SLOT(OnAlgorithmInfo(QString)));
m_Controls.m_teLog->append(
QString("<b><font color='blue'>Started mapping input data...</font></b>"));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pMapJob);
}
void QmitkRegistrationJob::OnMapAlgorithmEvent(::itk::Object *, const itk::EventObject &event)
{
const map::events::AlgorithmEvent *pAlgEvent = dynamic_cast<const map::events::AlgorithmEvent *>(&event);
const map::events::AlgorithmIterationEvent *pIterationEvent =
dynamic_cast<const map::events::AlgorithmIterationEvent *>(&event);
const map::events::AlgorithmWrapperEvent *pWrapEvent =
dynamic_cast<const map::events::AlgorithmWrapperEvent *>(&event);
const map::events::AlgorithmResolutionLevelEvent *pLevelEvent =
dynamic_cast<const map::events::AlgorithmResolutionLevelEvent *>(&event);
const map::events::InitializingAlgorithmEvent *pInitEvent =
dynamic_cast<const map::events::InitializingAlgorithmEvent *>(&event);
const map::events::StartingAlgorithmEvent *pStartEvent =
dynamic_cast<const map::events::StartingAlgorithmEvent *>(&event);
const map::events::StoppingAlgorithmEvent *pStoppingEvent =
dynamic_cast<const map::events::StoppingAlgorithmEvent *>(&event);
const map::events::StoppedAlgorithmEvent *pStoppedEvent =
dynamic_cast<const map::events::StoppedAlgorithmEvent *>(&event);
const map::events::FinalizingAlgorithmEvent *pFinalizingEvent =
dynamic_cast<const map::events::FinalizingAlgorithmEvent *>(&event);
const map::events::FinalizedAlgorithmEvent *pFinalizedEvent =
dynamic_cast<const map::events::FinalizedAlgorithmEvent *>(&event);
if (pInitEvent)
{
emit AlgorithmStatusChanged(QString("Initializing algorithm ..."));
}
else if (pStartEvent)
{
emit AlgorithmStatusChanged(QString("Starting algorithm ..."));
}
else if (pStoppingEvent)
{
emit AlgorithmStatusChanged(QString("Stopping algorithm ..."));
}
else if (pStoppedEvent)
{
emit AlgorithmStatusChanged(QString("Stopped algorithm ..."));
if (!pStoppedEvent->getComment().empty())
{
emit AlgorithmInfo(QString("Stopping condition: ") + QString::fromStdString(pStoppedEvent->getComment()));
}
}
else if (pFinalizingEvent)
{
emit AlgorithmStatusChanged(QString("Finalizing algorithm and results ..."));
}
else if (pFinalizedEvent)
{
emit AlgorithmStatusChanged(QString("Finalized algorithm ..."));
}
else if (pIterationEvent)
{
const IIterativeAlgorithm *pIterative =
dynamic_cast<const IIterativeAlgorithm *>(this->m_spLoadedAlgorithm.GetPointer());
map::algorithm::facet::IterativeAlgorithmInterface::IterationCountType count = 0;
bool hasCount = false;
if (pIterative && pIterative->hasIterationCount())
{
hasCount = true;
count = pIterative->getCurrentIteration();
}
emit AlgorithmIterated(QString::fromStdString(pIterationEvent->getComment()), hasCount, count);
}
else if (pLevelEvent)
{
const IMultiResAlgorithm *pResAlg =
dynamic_cast<const IMultiResAlgorithm *>(this->m_spLoadedAlgorithm.GetPointer());
map::algorithm::facet::MultiResRegistrationAlgorithmInterface::ResolutionLevelCountType count = 0;
bool hasCount = false;
QString info = QString::fromStdString(pLevelEvent->getComment());
if (pResAlg && pResAlg->hasLevelCount())
{
count = pResAlg->getCurrentLevel() + 1;
hasCount = true;
info = QString("Level #") + QString::number(pResAlg->getCurrentLevel() + 1) + QString(" ") + info;
}
emit LevelChanged(info, hasCount, count);
}
else if (pAlgEvent && !pWrapEvent)
{
emit AlgorithmInfo(QString::fromStdString(pAlgEvent->getComment()));
}
}
void QmitkMatchPoint::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
QmitkRegistrationJob* pJob = new QmitkRegistrationJob(m_LoadedAlgorithm);
pJob->setAutoDelete(true);
pJob->m_spTargetData = m_spSelectedTargetData;
pJob->m_spMovingData = m_spSelectedMovingData;
pJob->m_TargetDataUID = mitk::EnsureUID(this->m_spSelectedTargetNode->GetData());
pJob->m_MovingDataUID = mitk::EnsureUID(this->m_spSelectedMovingNode->GetData());
if (m_spSelectedTargetMaskData.IsNotNull())
{
pJob->m_spTargetMask = m_spSelectedTargetMaskData;
pJob->m_TargetMaskDataUID = mitk::EnsureUID(this->m_spSelectedTargetMaskNode->GetData());
}
if (m_spSelectedMovingMaskData.IsNotNull())
{
pJob->m_spMovingMask = m_spSelectedMovingMaskData;
pJob->m_MovingMaskDataUID = mitk::EnsureUID(this->m_spSelectedMovingMaskNode->GetData());
}
pJob->m_JobName = m_Controls.m_leRegJobName->text().toStdString();
pJob->m_StoreReg = true;
connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnRegJobError(QString)));
connect(pJob, SIGNAL(Finished()), this, SLOT(OnRegJobFinished()));
connect(pJob, SIGNAL(RegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer,
const QmitkRegistrationJob*)), this,
SLOT(OnRegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer, const QmitkRegistrationJob*)),
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)));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pJob);
}
