C++ (Cpp) Pointer::GetRegistration Examples

Example #1

mitk::DataNode::Pointer
  mitk::generateRegistrationResultNode(const std::string& nodeName, mitk::MAPRegistrationWrapper::Pointer resultReg, const std::string& algorithmUID, const std::string& movingNodeUID, const std::string& targetNodeUID)
{
  if (resultReg.IsNull())
  {
    mitkThrow() << "Cannot generate registration result node. Passed registration wrapper points to NULL.";
  }

  mitk::DataNode::Pointer m_spRegNode = mitk::DataNode::New();
  m_spRegNode->SetData(resultReg);
  m_spRegNode->SetName(nodeName);
  resultReg->SetProperty(mitk::Prop_RegAlgUsed, mitk::StringProperty::New(algorithmUID));
  resultReg->SetProperty(mitk::Prop_RegAlgMovingData, mitk::StringProperty::New(movingNodeUID));
  resultReg->SetProperty(mitk::Prop_RegAlgTargetData, mitk::StringProperty::New(targetNodeUID));
  resultReg->SetProperty(mitk::Prop_RegUID, mitk::StringProperty::New(resultReg->GetRegistration()->getRegistrationUID()));

  return m_spRegNode;
};

Example #2

File: QmitkSimpleRegistrationView.cpp Project: Cdebus/MITK

void QmitkSimpleRegistrationView::OnRegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer spResultRegistration, const QmitkRegistrationJob* job)
{
  mitk::Image::Pointer movingImage = dynamic_cast<mitk::Image*>(m_MovingImageNode->GetData());
  mitk::Image::Pointer image;

  if (m_RegistrationType==0 && !m_Controls->m_ResampleBox->isChecked())
  {
    image = mitk::ImageMappingHelper::refineGeometry(movingImage, spResultRegistration, true);

    mitk::DiffusionPropertyHelper::CopyProperties(movingImage, image, true);
    auto reg = spResultRegistration->GetRegistration();
    typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
    CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
    corrector->SetImage( image );
    corrector->CorrectDirections( mitk::MITKRegistrationHelper::getAffineMatrix(reg, false)->GetMatrix().GetVnlMatrix() );
  }
  else
  {
    if (!mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(movingImage))
    {
      image = mitk::ImageMappingHelper::map(movingImage, spResultRegistration, false, 0, job->m_spTargetData->GetGeometry(), false, 0, mitk::ImageMappingInterpolator::BSpline_3);
    }
    else
    {
      typedef itk::ComposeImageFilter < ITKDiffusionVolumeType > ComposeFilterType;
      ComposeFilterType::Pointer composer = ComposeFilterType::New();

      ItkDwiType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(movingImage);
      for (unsigned int i=0; i<itkVectorImagePointer->GetVectorLength(); ++i)
      {
        itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
        filter->SetInput( itkVectorImagePointer);
        filter->SetChannelIndex(i);
        filter->Update();

        mitk::Image::Pointer gradientVolume = mitk::Image::New();
        gradientVolume->InitializeByItk( filter->GetOutput() );
        gradientVolume->SetImportChannel( filter->GetOutput()->GetBufferPointer() );

        mitk::Image::Pointer registered_mitk_image = mitk::ImageMappingHelper::map(gradientVolume, spResultRegistration, false, 0, job->m_spTargetData->GetGeometry(), false, 0, mitk::ImageMappingInterpolator::BSpline_3);

        ITKDiffusionVolumeType::Pointer registered_itk_image = ITKDiffusionVolumeType::New();
        mitk::CastToItkImage(registered_mitk_image, registered_itk_image);
        composer->SetInput(i, registered_itk_image);
      }

      composer->Update();

      image = mitk::GrabItkImageMemory( composer->GetOutput() );
      mitk::DiffusionPropertyHelper::CopyProperties(movingImage, image, true);

      auto reg = spResultRegistration->GetRegistration();
      typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
      CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
      corrector->SetImage( image );
      corrector->CorrectDirections( mitk::MITKRegistrationHelper::getAffineMatrix(reg, false)->GetMatrix().GetVnlMatrix() );
    }
  }

  if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image))
    mitk::DiffusionPropertyHelper::InitializeImage( image );

  mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
  resultNode->SetData(image);

  if (m_MovingImageNode.IsNotNull())
  {
    m_MovingImageNode->SetVisibility(false);
    QString name = m_MovingImageNode->GetName().c_str();
    if (m_RegistrationType==0)
      resultNode->SetName((name+"_registered (rigid)").toStdString().c_str());
    else
      resultNode->SetName((name+"_registered (affine)").toStdString().c_str());
  }
  else
  {
    if (m_RegistrationType==0)
      resultNode->SetName("Registered (rigid)");
    else
      resultNode->SetName("Registered (affine)");
  }
//  resultNode->SetOpacity(0.6);
//  resultNode->SetColor(0.0, 0.0, 1.0);
  GetDataStorage()->Add(resultNode);

  mitk::RenderingManager::GetInstance()->InitializeViews( resultNode->GetData()->GetTimeGeometry(),
                                                          mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                          true);

  if (m_Controls->m_RegOutputBox->isChecked())
  {
    mitk::DataNode::Pointer registration_node = mitk::DataNode::New();
    registration_node->SetData(spResultRegistration);
    if (m_RegistrationType==0)
      registration_node->SetName("Registration Object (rigid)");
    else
      registration_node->SetName("Registration Object (affine)");
    GetDataStorage()->Add(registration_node, resultNode);
  }

  this->GetRenderWindowPart()->RequestUpdate();

  m_Controls->m_RegistrationStartButton->setEnabled(true);
  m_Controls->m_RegistrationStartButton->setText("Start Registration");

  m_MovingImageNode = nullptr;

  TractoChanged();
}