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);
}
