mlITKMLBaseWrapper.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 "mlInitSystemITKSupport.h"

#include "mlModuleIncludes.h"
#include <itkLightObject.h>
 
ML_START_NAMESPACE
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class MLITK_SUPPORT_EXPORT ITKWrapperBase : public Base
{
public:
  ITKWrapperBase(){};
 
  void setITKPointer(itk::LightObject::Pointer obj)
  {
    _itkObject = obj;
  }
 
  template<class T>
  T::Pointer getITKPointer()
  {
    return dynamic_cast<T*>(_itkObject.GetPointer());
  }
 
private:
  itk::LightObject::Pointer _itkObject;
 
protected:
  ML_ABSTRACT_CLASS_HEADER(ITKWrapperBase);
};
 
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
template <typename OBJ_TYPE, typename WRAPPER_CLASS_NAME> class ITKTypedPointerWrapper
{
public:
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  ITKTypedPointerWrapper()
  {
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  void addOutputBaseField(Module& module, const char* outputFieldName)
  {
    if (!outputFieldName) {
      ML_PRINT_ERROR("ITKTypedPointerWrapper::addOutputBaseField", ML_BAD_POINTER_OR_0,
                     "Passed field name pointer is nullptr. Ignoring call.");
      return;
    }
    if (_baseField) {
      ML_PRINT_ERROR("ITKTypedPointerWrapper::addOutputBaseField", ML_BAD_STATE, "Ignoring multiple field add.");
      return;
    }
 
    _baseField = module.addBase(outputFieldName);
    _baseField->addAllowedType<WRAPPER_CLASS_NAME>();
    _baseField->setBaseValue(&_baseWrapper);
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  void addInputBaseField(Module& module, const char* inputFieldName)
  {
    if (!inputFieldName) {
      ML_PRINT_ERROR("ITKMLBaseWrapper::addInputBaseField", ML_BAD_POINTER_OR_0,
                     "Passed field name pointer is nullptr. Ignoring call.");
      return;
    }
    if (_baseField) {
      ML_PRINT_ERROR("ITKMLBaseWrapper::addInputBaseField", ML_BAD_STATE, "Ignoring multiple field add.");
      return;
    }
 
    _baseField = module.addBase(inputFieldName);
    _baseField->addAllowedType<WRAPPER_CLASS_NAME>();
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  void setNewOutputBaseFieldObject(OBJ_TYPE::Pointer newObject)
  {
    _baseWrapper.setITKPointer(newObject);
    if (_baseField) {
      _baseField->touch();
    }
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  BaseField* getOutputBaseField()
  {
    return _baseField;
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  BaseField* getInputBaseField()
  {
    return _baseField;
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  OBJ_TYPE::Pointer getWrappedOutputObject()
  {
    return _baseWrapper.template getITKPointer<OBJ_TYPE>();
  }
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  OBJ_TYPE::Pointer getWrappedInputObject()
  {
 
    if (_baseField) {
      /* Get the pointer to the connected object and check its type.*/
      /* If the type is valid then return a the pointer to the wrapped input object.*/
      // Get base object from connected input.
      WRAPPER_CLASS_NAME* wrapperBasePtr = _baseField->getTypedBaseValue<WRAPPER_CLASS_NAME*>();
      return wrapperBasePtr ? wrapperBasePtr->template getITKPointer<OBJ_TYPE>() : nullptr;
    }
 
    /* No valid object connected to base field. */
    return nullptr;
  }
 
protected:
  WRAPPER_CLASS_NAME _baseWrapper;

  BaseField* _baseField = nullptr;
};
 
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
#define ML_CREATE_ITK_POINTER_WRAPPER_H(CLASS_NAME, PARENT_BASE_CLASS_NAME, ML_EXPORT_MACRO)                           \
                                                                                                                       \
  /* Specialization of ITKWrapperBase */                                                                               \
  class ML_EXPORT_MACRO ITK##CLASS_NAME##Wrapper : public PARENT_BASE_CLASS_NAME                                       \
  {                                                                                                                    \
  public:                                                                                                              \
    ITK##CLASS_NAME##Wrapper() = default;                                                                              \
                                                                                                                       \
  private:                                                                                                             \
    /* The header part of the runtime type system interface. */                                                        \
    ML_CLASS_HEADER(ITK##CLASS_NAME##Wrapper);                                                                         \
  };                                                                                                                   \
                                                                                                                       \
  typedef ITKTypedPointerWrapper<CLASS_NAME, ITK##CLASS_NAME##Wrapper> CLASS_NAME##Wrapper;                            \
 
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
#define ML_CREATE_ITK_POINTER_WRAPPER_CPP(CLASS_NAME, PARENT_BASE_CLASS_NAME)                                          \
                                                                                                                       \
  /* The .cpp part of the runtime type system interface. */                                                            \
  ML_CLASS_SOURCE(ITK##CLASS_NAME##Wrapper, PARENT_BASE_CLASS_NAME);
 
 
ML_END_NAMESPACE