mlITKSpecialFieldsSupport.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
// Include dll-specific settings.
#include "mlInitSystemITKSupport.h"
 
#include "mlModuleIncludes.h"
 
#include "mlMultiFields.h"
 
#include "mlPointList.h"
#include "mlVectorList.h"
#include "mlXMarkerList.h"
#include "mlITKFiniteDifferenceFunctionConnect.h"
 
#include <itkPolyLineParametricPath.h>
#include <itkFiniteDifferenceFunction.h>
 
ML_START_NAMESPACE
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template<class POLYLINEPATHTYPE>
typename POLYLINEPATHTYPE::Pointer ITKPolylineFromBasePointer(Base *baseVal, bool emptyDefaultToOneZeroVal=true)
{
  XMarkerListContainer *xmlc = nullptr;
  XMarkerList          *xml  = nullptr;
  PointList            *pl   = nullptr;
  VectorList           *vl   = nullptr;
 
  // Get base field.
  if (baseVal){
    // Check for different base object types.
    if (ML_BASE_IS_A(baseVal, XMarkerListContainer)){ xmlc = static_cast<XMarkerListContainer*>(baseVal); }
    else if (ML_BASE_IS_A(baseVal, XMarkerList))    { xml  = static_cast<XMarkerList*>(baseVal);          }
    else if (ML_BASE_IS_A(baseVal, PointList))      { pl   = static_cast<PointList*>(baseVal);            }
    else if (ML_BASE_IS_A(baseVal, VectorList))     { vl   = static_cast<VectorList*>(baseVal);           }
    else{ /* No valid type in base field. That can happen. */ }
  }
 
  // Get number of points from list.
  size_t numVals = (xmlc ? xmlc->getList()->size() : 
                   (xml  ? xml->size()            : 
                   (pl   ? static_cast<size_t>(pl->getNum()) : 
                   (vl   ? static_cast<size_t>(vl->getNum()) : 0))));
 
 
  // Determine maximum point dimension, clamp it to 6.
  int maxDim = POLYLINEPATHTYPE::VertexType::IndexDimension;
  if (maxDim > 6){
    maxDim = 6;
    ML_PRINT_WARNING("ITKPolylineFromBasePointer", ML_BAD_DIMENSION, "Too high dimension of itk Polyline. Only 6 dimensions will be converted.");
  }
 
  if (numVals > 0){
 
    // Create point set object.
    typename POLYLINEPATHTYPE::Pointer outputPolyline = POLYLINEPATHTYPE::New();                                             
 
    // A point to be added.
    typename POLYLINEPATHTYPE::VertexType point;
 
    // Insert all list elements into the NodeContainer.
    for (size_t c=0; c < numVals; ++c){
      // Get point list value if we have such a list.
      Vector6 plVal(0);
      if (pl){
        float px=0, py=0, pz=0; 
        pl->getValue(c, px, py, pz); 
        plVal[0] = px;
        plVal[1] = py;
        plVal[2] = pz;
      }
 
      // Get point list value if we have such a list.
      Vector6 vlVal(0);
      int vecType=0;
      if (vl){
        float px=0, py=0, pz=0; 
        vl->getPoint(c, vecType, px, py, pz);
        vlVal[0]=px;
        vlVal[1]=py;
        vlVal[2]=pz;
      }
 
      // get position from any of the lists.
      Vector6 mlVec((xmlc ? (static_cast<XMarker*>(xmlc->getList()->getItemAt(c)))->pos :
                    (xml  ? (static_cast<XMarker*>(xml->getItemAt(c)))->pos             :
                    (pl   ? plVal                                            :
                    (vl   ? vlVal                                            : Vector6(0))))));
 
      // Copy point components.
      for (int j=0;j< maxDim ;j++){ point[j] = mlVec[j]; }
      outputPolyline->AddVertex(point);
    }
 
    return outputPolyline;
  }
  else{
    // Create and return default (empty) point set object.
    typename POLYLINEPATHTYPE::Pointer outputPolyline = POLYLINEPATHTYPE::New();
    if (emptyDefaultToOneZeroVal){
      // Add at least one point at coordinates (0,...,0).
      typename POLYLINEPATHTYPE::VertexType point;
      outputPolyline->AddVertex(point);
    }
    return outputPolyline;
  }
}
 
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template<class FINITE_DIFFERENCE_FUNCTION_TYPE>
typename FINITE_DIFFERENCE_FUNCTION_TYPE::Pointer ITKDifferenceFunctionFromBasePointer(Base *baseVal)
{
  // Return value to be validated with function from connection.
  typename FINITE_DIFFERENCE_FUNCTION_TYPE::Pointer defaultFunction = nullptr;
 
  // Pointer to ITKFiniteDifferenceFunctionWrapper if there is one connected.
  ITKFiniteDifferenceFunctionWrapper* functionObject = mlbase_cast<ITKFiniteDifferenceFunctionWrapper*>(baseVal);
  if (functionObject) {
    defaultFunction = functionObject->GetFiniteDifferenceFunction(static_cast<FINITE_DIFFERENCE_FUNCTION_TYPE*>(nullptr));
  }
  else {
    // Create and return a default difference function.
    //defaultFunction = FINITE_DIFFERENCE_FUNCTION_TYPE::New();                                             
  }
 
  // Return the found or the default function.
  return defaultFunction;
}
 
ML_END_NAMESPACE