mitkNodeDisplacementFilter.cpp

Go to the documentation of this file.

/*============================================================================
 
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 "mitkNodeDisplacementFilter.h"
 
 
 
  mitk::NodeDisplacementFilter::NodeDisplacementFilter()
    : m_SelectedInput(-1)
  {
  }
 
  mitk::NodeDisplacementFilter::~NodeDisplacementFilter()
  {
  }
 
  bool mitk::NodeDisplacementFilter::AddNode( mitk::DataNode::Pointer node )
  {
    // Consistency Checks
    if (node.IsNull())
    {
      MITK_WARN("NodeDisplacementFilter")
        << "Null Node passed to NodeDisplacementFilter. Ignoring Node....";
      return false;
    }
    if (node->GetData() == nullptr)
    {
      MITK_WARN("NodeDisplacementFilter")
        << "Empty Node passed to NodeDisplacementFilter. Ignoring Node....";
      return false;
    }
    if(m_SelectedInput == -1)
    {
      MITK_ERROR("NodeDisplacementFilter")
        << "Cannot add nodes before input Stream was selected";
      mitkThrow() << "Cannot add nodes before input Stream was selected";
    }
 
    this->Update(); // make sure we are working on current data
    mitk::NavigationData::Pointer reference;
    if (m_InitialReferencePose.IsNotNull()) //if there is a given reference pose use it
      {reference = m_InitialReferencePose;}
    else //else use the current pose of the given input
      {reference = this->GetOutput(m_SelectedInput);}
 
    if (! reference->IsDataValid())
    {
      MITK_WARN("NodeDisplacementFilter")
        << "Cannot add node while selected tool is not tracked. Ignoring Node....";
      return false;
    }
 
    // find transformation and add node
    mitk::AffineTransform3D::Pointer inverseAffineTransform = mitk::AffineTransform3D::New();
    if ( ! reference->GetAffineTransform3D()->GetInverse(inverseAffineTransform) )
    {
      MITK_ERROR("NodeDisplacementFilter")
        << "Could not get the inverse transformation of the navigation data transformation.";
      mitkThrow() << "Could not get the inverse transformation of the navigation data transformation.";
    }
 
    inverseAffineTransform->Compose(node->GetData()->GetGeometry()->GetIndexToWorldTransform(), true);
    m_Transforms.push_back(inverseAffineTransform);
    m_Nodes.push_back(node);
 
    return true;
  }
 
  bool mitk::NodeDisplacementFilter::RemoveNode(unsigned int i)
  {
    if ( i >= m_Nodes.size() ) { return false; }
 
    m_Nodes.erase(m_Nodes.begin()+i);
    m_Transforms.erase(m_Transforms.begin()+i);
    return true;
  }
 
  int mitk::NodeDisplacementFilter::GetNumberOfNodes()
  {
    return m_Nodes.size();
  }
 
  mitk::DataNode::Pointer mitk::NodeDisplacementFilter::GetNode (unsigned int i)
  {
    if (i < m_Nodes.size() ) { return m_Nodes.at(i); }
    else { return nullptr; }
  }
 
  std::vector< mitk::DataNode::Pointer > mitk::NodeDisplacementFilter::GetNodes()
  {
    return m_Nodes;
  }
 
  void mitk::NodeDisplacementFilter::SelectInput(int i)
  {
    if (i < 0) { mitkThrow() << "Negative Input selected in NodeDisplacementFilter"; }
    if (! (static_cast<unsigned int>(i) < this->GetInputs().size()))
    {
      MITK_ERROR("NodeDisplacementFilter")
        << "Selected input index is larger than actual number of inputs.";
      mitkThrow() << "Selected input index is larger than actual number of inputs in NodeDisplacementFilter";
    }
    m_SelectedInput = i;
  }
 
  mitk::NavigationData::Pointer mitk::NodeDisplacementFilter::GetRawDisplacementNavigationData(unsigned int i)
  {
    mitk::NavigationData::Pointer returnValue = mitk::NavigationData::New();
    if((m_Nodes.size()>i) && (m_Nodes.at(i).IsNotNull()))
      {
      try
        {
          returnValue = mitk::NavigationData::New(m_Nodes.at(i)->GetData()->GetGeometry()->GetIndexToWorldTransform());
        }
      catch (mitk::Exception& e)
        {
          returnValue->SetDataValid(false);
          MITK_WARN << "Excetion while returning navigation data: " << e.GetDescription();
        }
      }
    else
      {
        returnValue->SetDataValid(false);
        MITK_WARN << "Node Nr. " << i << " does not exist!";
      }
 
    return returnValue;
  }
 
  void mitk::NodeDisplacementFilter::GenerateData()
  {
    // copy the navigation data from the inputs to the outputs
    mitk::NavigationDataPassThroughFilter::GenerateData();
 
    // if no reference has been set yet, warn and abort
    if (m_SelectedInput == -1)
    {
      MITK_INFO("NodeDisplacementFilter")
        << "No input has been selected. Only forwarding NavigationData...";
      return;
    }
 
    // cancel, if selected tool is currently not being tracked
    if ( ! this->GetInput(m_SelectedInput)->IsDataValid() ) { return; }
 
    // outputs have been updated, now to transform the nodes
    // 1) Generate Pseudo-Geometry for Reference
    mitk::Geometry3D::Pointer refGeom = this->TransformToGeometry(
      this->GetInput(m_SelectedInput)->GetAffineTransform3D());
 
    // 2) For each node, calculate new position
    for (unsigned int index=0; index < m_Nodes.size(); index++)
    {
      mitk::Geometry3D::Pointer transformGeometry = refGeom->Clone();
 
      // create transformation to the reference position and from there to
      // the node position (node has fixed transformation from reference position)
      transformGeometry->Compose(m_Transforms.at(index), true);
 
      m_Nodes.at(index)->GetData()->SetGeometry(transformGeometry);
    }
  }
 
  void mitk::NodeDisplacementFilter::ResetNodes()
  {
    m_Nodes.clear();
    m_Transforms.clear();
  }
 
mitk::Geometry3D::Pointer mitk::NodeDisplacementFilter::TransformToGeometry(mitk::AffineTransform3D::Pointer transform){
  mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
  g3d->SetIndexToWorldTransform(transform);
  //g3d->TransferItkToVtkTransform(); // update VTK Transform for rendering too //Included in SetIndexToWorldTransform
  g3d->Modified();
  return g3d;
}