mlITKFiniteDifferenceFunctionConnect.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 "mlITKMLBaseWrapper.h"
 
#include <itkImage.h>
#include <itkPoint.h>
#include <itkVector.h>
#include <itkFiniteDifferenceFunction.h>
#include <itkPDEDeformableRegistrationFunction.h>
#include <itkImageFunction.h>
 
// Define voxel types.
typedef itk::Vector<float ,2>                                    Vox2DFloatVecType ;
typedef itk::Vector<float ,3>                                    Vox3DFloatVecType ;
typedef itk::Vector<float ,4>                                    Vox4DFloatVecType ;
typedef itk::Vector<float ,6>                                    Vox6DFloatVecType ;
typedef itk::Vector<float ,8>                                    Vox8DFloatVecType ;
 
typedef itk::Vector<double,2>                                    Vox2DDoubleVecType;
typedef itk::Vector<double,3>                                    Vox3DDoubleVecType;
typedef itk::Vector<double,4>                                    Vox4DDoubleVecType;
typedef itk::Vector<double,6>                                    Vox6DDoubleVecType;
typedef itk::Vector<double,8>                                    Vox8DDoubleVecType;
 
// Define images using the upper voxel types.
typedef itk::Image<MLint8,            2>                         Img2OfVoxInt8Type       ;
typedef itk::Image<MLint16,           2>                         Img2OfVoxInt16Type      ;
typedef itk::Image<MLint32,           2>                         Img2OfVoxInt32Type      ;
typedef itk::Image<MLuint8,           2>                         Img2OfVoxUInt8Type      ;
typedef itk::Image<MLuint16,          2>                         Img2OfVoxUInt16Type     ;
typedef itk::Image<MLuint32,          2>                         Img2OfVoxUInt32Type     ;
typedef itk::Image<MLfloat,           2>                         Img2OfVoxFloatType      ;
typedef itk::Image<MLdouble,          2>                         Img2OfVoxDoubleType     ;
typedef itk::Image<Vox2DFloatVecType, 2>                         Img2OfVox2DFloatVecType ;
typedef itk::Image<Vox2DDoubleVecType,2>                         Img2OfVox2DDoubleVecType;
typedef itk::Image<Vox3DFloatVecType, 2>                         Img2OfVox3DFloatVecType ;
typedef itk::Image<Vox3DDoubleVecType,2>                         Img2OfVox3DDoubleVecType;
typedef itk::Image<Vox4DFloatVecType, 2>                         Img2OfVox4DFloatVecType ;
typedef itk::Image<Vox4DDoubleVecType,2>                         Img2OfVox4DDoubleVecType;
typedef itk::Image<Vox6DFloatVecType, 2>                         Img2OfVox6DFloatVecType ;
typedef itk::Image<Vox6DDoubleVecType,2>                         Img2OfVox6DDoubleVecType;
typedef itk::Image<Vox8DFloatVecType, 2>                         Img2OfVox8DFloatVecType ;
typedef itk::Image<Vox8DDoubleVecType,2>                         Img2OfVox8DDoubleVecType;
 
typedef itk::Image<MLint8,            3>                         Img3OfVoxInt8Type       ;
typedef itk::Image<MLint16,           3>                         Img3OfVoxInt16Type      ;
typedef itk::Image<MLint32,           3>                         Img3OfVoxInt32Type      ;
typedef itk::Image<MLuint8,           3>                         Img3OfVoxUInt8Type      ;
typedef itk::Image<MLuint16,          3>                         Img3OfVoxUInt16Type     ;
typedef itk::Image<MLuint32,          3>                         Img3OfVoxUInt32Type     ;
typedef itk::Image<MLfloat,           3>                         Img3OfVoxFloatType      ;
typedef itk::Image<MLdouble,          3>                         Img3OfVoxDoubleType     ;
typedef itk::Image<Vox2DFloatVecType, 3>                         Img3OfVox2DFloatVecType ;
typedef itk::Image<Vox2DDoubleVecType,3>                         Img3OfVox2DDoubleVecType;
typedef itk::Image<Vox3DFloatVecType, 3>                         Img3OfVox3DFloatVecType ;
typedef itk::Image<Vox3DDoubleVecType,3>                         Img3OfVox3DDoubleVecType;
typedef itk::Image<Vox4DFloatVecType, 3>                         Img3OfVox4DFloatVecType ;
typedef itk::Image<Vox4DDoubleVecType,3>                         Img3OfVox4DDoubleVecType;
typedef itk::Image<Vox6DFloatVecType, 3>                         Img3OfVox6DFloatVecType ;
typedef itk::Image<Vox6DDoubleVecType,3>                         Img3OfVox6DDoubleVecType;
typedef itk::Image<Vox8DFloatVecType, 3>                         Img3OfVox8DFloatVecType ;
typedef itk::Image<Vox8DDoubleVecType,3>                         Img3OfVox8DDoubleVecType;
 
 
// Define difference functions on the upperly defined image types.
typedef itk::FiniteDifferenceFunction<Img2OfVoxInt8Type       >   FiniteDifferenceFunctionImg2OfVoxInt8Type       ;
typedef itk::FiniteDifferenceFunction<Img2OfVoxInt16Type      >   FiniteDifferenceFunctionImg2OfVoxInt16Type      ;
typedef itk::FiniteDifferenceFunction<Img2OfVoxInt32Type      >   FiniteDifferenceFunctionImg2OfVoxInt32Type      ;
typedef itk::FiniteDifferenceFunction<Img2OfVoxUInt8Type      >   FiniteDifferenceFunctionImg2OfVoxUInt8Type      ;
typedef itk::FiniteDifferenceFunction<Img2OfVoxUInt16Type     >   FiniteDifferenceFunctionImg2OfVoxUInt16Type     ;
typedef itk::FiniteDifferenceFunction<Img2OfVoxUInt32Type     >   FiniteDifferenceFunctionImg2OfVoxUInt32Type     ;
typedef itk::FiniteDifferenceFunction<Img2OfVoxFloatType      >   FiniteDifferenceFunctionImg2OfVoxFloatType      ;
typedef itk::FiniteDifferenceFunction<Img2OfVoxDoubleType     >   FiniteDifferenceFunctionImg2OfVoxDoubleType     ;
typedef itk::FiniteDifferenceFunction<Img2OfVox2DFloatVecType >   FiniteDifferenceFunctionImg2OfVox2DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img2OfVox2DDoubleVecType>   FiniteDifferenceFunctionImg2OfVox2DDoubleVecType;
typedef itk::FiniteDifferenceFunction<Img2OfVox3DFloatVecType >   FiniteDifferenceFunctionImg2OfVox3DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img2OfVox3DDoubleVecType>   FiniteDifferenceFunctionImg2OfVox3DDoubleVecType;
typedef itk::FiniteDifferenceFunction<Img2OfVox4DFloatVecType >   FiniteDifferenceFunctionImg2OfVox4DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img2OfVox4DDoubleVecType>   FiniteDifferenceFunctionImg2OfVox4DDoubleVecType;
typedef itk::FiniteDifferenceFunction<Img2OfVox6DFloatVecType >   FiniteDifferenceFunctionImg2OfVox6DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img2OfVox6DDoubleVecType>   FiniteDifferenceFunctionImg2OfVox6DDoubleVecType;
typedef itk::FiniteDifferenceFunction<Img2OfVox8DFloatVecType >   FiniteDifferenceFunctionImg2OfVox8DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img2OfVox8DDoubleVecType>   FiniteDifferenceFunctionImg2OfVox8DDoubleVecType;
 
typedef itk::FiniteDifferenceFunction<Img3OfVoxInt8Type       >   FiniteDifferenceFunctionImg3OfVoxInt8Type       ;
typedef itk::FiniteDifferenceFunction<Img3OfVoxInt16Type      >   FiniteDifferenceFunctionImg3OfVoxInt16Type      ;
typedef itk::FiniteDifferenceFunction<Img3OfVoxInt32Type      >   FiniteDifferenceFunctionImg3OfVoxInt32Type      ;
typedef itk::FiniteDifferenceFunction<Img3OfVoxUInt8Type      >   FiniteDifferenceFunctionImg3OfVoxUInt8Type      ;
typedef itk::FiniteDifferenceFunction<Img3OfVoxUInt16Type     >   FiniteDifferenceFunctionImg3OfVoxUInt16Type     ;
typedef itk::FiniteDifferenceFunction<Img3OfVoxUInt32Type     >   FiniteDifferenceFunctionImg3OfVoxUInt32Type     ;
typedef itk::FiniteDifferenceFunction<Img3OfVoxFloatType      >   FiniteDifferenceFunctionImg3OfVoxFloatType      ;
typedef itk::FiniteDifferenceFunction<Img3OfVoxDoubleType     >   FiniteDifferenceFunctionImg3OfVoxDoubleType     ;
typedef itk::FiniteDifferenceFunction<Img3OfVox2DFloatVecType >   FiniteDifferenceFunctionImg3OfVox2DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img3OfVox2DDoubleVecType>   FiniteDifferenceFunctionImg3OfVox2DDoubleVecType;
typedef itk::FiniteDifferenceFunction<Img3OfVox3DFloatVecType >   FiniteDifferenceFunctionImg3OfVox3DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img3OfVox3DDoubleVecType>   FiniteDifferenceFunctionImg3OfVox3DDoubleVecType;
typedef itk::FiniteDifferenceFunction<Img3OfVox4DFloatVecType >   FiniteDifferenceFunctionImg3OfVox4DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img3OfVox4DDoubleVecType>   FiniteDifferenceFunctionImg3OfVox4DDoubleVecType;
typedef itk::FiniteDifferenceFunction<Img3OfVox6DFloatVecType >   FiniteDifferenceFunctionImg3OfVox6DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img3OfVox6DDoubleVecType>   FiniteDifferenceFunctionImg3OfVox6DDoubleVecType;
typedef itk::FiniteDifferenceFunction<Img3OfVox8DFloatVecType >   FiniteDifferenceFunctionImg3OfVox8DFloatVecType ;
typedef itk::FiniteDifferenceFunction<Img3OfVox8DDoubleVecType>   FiniteDifferenceFunctionImg3OfVox8DDoubleVecType;
 
typedef itk::PDEDeformableRegistrationFunction<Img3OfVoxFloatType,
                                               Img3OfVoxFloatType,
                                               Img3OfVox3DFloatVecType> PDEDeformableRegFunction3DF3DF3DFVType    ;
 
ML_START_NAMESPACE
 
  //----------------------------------------------------------
  //----------------------------------------------------------
  class MLITK_SUPPORT_EXPORT ITKFiniteDifferenceFunctionWrapper : public Base
  {
  public:
 
    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    ITKFiniteDifferenceFunctionWrapper() 
    {
      // Initialize all pointers to NULL. Only those pointers are going to
      // be defined which can be instantiated by the module exporting an
      // object of this class.
      m_FiniteDifferenceFunctionImg2OfVoxInt8Type        = nullptr;
      m_FiniteDifferenceFunctionImg2OfVoxInt16Type       = nullptr;
      m_FiniteDifferenceFunctionImg2OfVoxInt32Type       = nullptr;
      m_FiniteDifferenceFunctionImg2OfVoxUInt8Type       = nullptr;
      m_FiniteDifferenceFunctionImg2OfVoxUInt16Type      = nullptr;
      m_FiniteDifferenceFunctionImg2OfVoxUInt32Type      = nullptr;
      m_FiniteDifferenceFunctionImg2OfVoxFloatType       = nullptr;
      m_FiniteDifferenceFunctionImg2OfVoxDoubleType      = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox2DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox2DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox3DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox3DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox4DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox4DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox6DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox6DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox8DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg2OfVox8DFloatVecType  = nullptr;
 
      m_FiniteDifferenceFunctionImg3OfVoxInt8Type        = nullptr;
      m_FiniteDifferenceFunctionImg3OfVoxInt16Type       = nullptr;
      m_FiniteDifferenceFunctionImg3OfVoxInt32Type       = nullptr;
      m_FiniteDifferenceFunctionImg3OfVoxUInt8Type       = nullptr;
      m_FiniteDifferenceFunctionImg3OfVoxUInt16Type      = nullptr;
      m_FiniteDifferenceFunctionImg3OfVoxUInt32Type      = nullptr;
      m_FiniteDifferenceFunctionImg3OfVoxFloatType       = nullptr;
      m_FiniteDifferenceFunctionImg3OfVoxDoubleType      = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox2DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox2DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox3DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox3DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox4DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox4DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox6DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox6DDoubleVecType = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox8DFloatVecType  = nullptr;
      m_FiniteDifferenceFunctionImg3OfVox8DDoubleVecType = nullptr;
 
      m_PDEDeformableRegFunction3DF3DF3DFVType           = nullptr;
    }
 
    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    FiniteDifferenceFunctionImg2OfVoxInt8Type        ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVoxInt8Type        *){ return m_FiniteDifferenceFunctionImg2OfVoxInt8Type        ; }
    FiniteDifferenceFunctionImg2OfVoxInt16Type       ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVoxInt16Type       *){ return m_FiniteDifferenceFunctionImg2OfVoxInt16Type       ; }
    FiniteDifferenceFunctionImg2OfVoxInt32Type       ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVoxInt32Type       *){ return m_FiniteDifferenceFunctionImg2OfVoxInt32Type       ; }
    FiniteDifferenceFunctionImg2OfVoxUInt8Type       ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVoxUInt8Type       *){ return m_FiniteDifferenceFunctionImg2OfVoxUInt8Type       ; }
    FiniteDifferenceFunctionImg2OfVoxUInt16Type      ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVoxUInt16Type      *){ return m_FiniteDifferenceFunctionImg2OfVoxUInt16Type      ; }
    FiniteDifferenceFunctionImg2OfVoxUInt32Type      ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVoxUInt32Type      *){ return m_FiniteDifferenceFunctionImg2OfVoxUInt32Type      ; }
    FiniteDifferenceFunctionImg2OfVoxFloatType       ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVoxFloatType       *){ return m_FiniteDifferenceFunctionImg2OfVoxFloatType       ; }
    FiniteDifferenceFunctionImg2OfVoxDoubleType      ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVoxDoubleType      *){ return m_FiniteDifferenceFunctionImg2OfVoxDoubleType      ; }
    FiniteDifferenceFunctionImg2OfVox2DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox2DFloatVecType  *){ return m_FiniteDifferenceFunctionImg2OfVox2DFloatVecType  ; }
    FiniteDifferenceFunctionImg2OfVox2DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox2DDoubleVecType *){ return m_FiniteDifferenceFunctionImg2OfVox2DDoubleVecType ; }
    FiniteDifferenceFunctionImg2OfVox3DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox3DFloatVecType  *){ return m_FiniteDifferenceFunctionImg2OfVox3DFloatVecType  ; }
    FiniteDifferenceFunctionImg2OfVox3DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox3DDoubleVecType *){ return m_FiniteDifferenceFunctionImg2OfVox3DDoubleVecType ; }
    FiniteDifferenceFunctionImg2OfVox4DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox4DFloatVecType  *){ return m_FiniteDifferenceFunctionImg2OfVox4DFloatVecType  ; }
    FiniteDifferenceFunctionImg2OfVox4DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox4DDoubleVecType *){ return m_FiniteDifferenceFunctionImg2OfVox4DDoubleVecType ; }
    FiniteDifferenceFunctionImg2OfVox6DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox6DFloatVecType  *){ return m_FiniteDifferenceFunctionImg2OfVox6DFloatVecType  ; }
    FiniteDifferenceFunctionImg2OfVox6DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox6DDoubleVecType *){ return m_FiniteDifferenceFunctionImg2OfVox6DDoubleVecType ; }
    FiniteDifferenceFunctionImg2OfVox8DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox8DFloatVecType  *){ return m_FiniteDifferenceFunctionImg2OfVox8DFloatVecType  ; }
    FiniteDifferenceFunctionImg2OfVox8DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg2OfVox8DDoubleVecType *){ return m_FiniteDifferenceFunctionImg2OfVox8DDoubleVecType ; }
 
    FiniteDifferenceFunctionImg3OfVoxInt8Type        ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVoxInt8Type        *){ return m_FiniteDifferenceFunctionImg3OfVoxInt8Type        ; }
    FiniteDifferenceFunctionImg3OfVoxInt16Type       ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVoxInt16Type       *){ return m_FiniteDifferenceFunctionImg3OfVoxInt16Type       ; }
    FiniteDifferenceFunctionImg3OfVoxInt32Type       ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVoxInt32Type       *){ return m_FiniteDifferenceFunctionImg3OfVoxInt32Type       ; }
    FiniteDifferenceFunctionImg3OfVoxUInt8Type       ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVoxUInt8Type       *){ return m_FiniteDifferenceFunctionImg3OfVoxUInt8Type       ; }
    FiniteDifferenceFunctionImg3OfVoxUInt16Type      ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVoxUInt16Type      *){ return m_FiniteDifferenceFunctionImg3OfVoxUInt16Type      ; }
    FiniteDifferenceFunctionImg3OfVoxUInt32Type      ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVoxUInt32Type      *){ return m_FiniteDifferenceFunctionImg3OfVoxUInt32Type      ; }
    FiniteDifferenceFunctionImg3OfVoxFloatType       ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVoxFloatType       *){ return m_FiniteDifferenceFunctionImg3OfVoxFloatType       ; }
    FiniteDifferenceFunctionImg3OfVoxDoubleType      ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVoxDoubleType      *){ return m_FiniteDifferenceFunctionImg3OfVoxDoubleType      ; }
    FiniteDifferenceFunctionImg3OfVox2DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox2DFloatVecType  *){ return m_FiniteDifferenceFunctionImg3OfVox2DFloatVecType  ; }
    FiniteDifferenceFunctionImg3OfVox2DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox2DDoubleVecType *){ return m_FiniteDifferenceFunctionImg3OfVox2DDoubleVecType ; }
    FiniteDifferenceFunctionImg3OfVox3DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox3DFloatVecType  *){ return m_FiniteDifferenceFunctionImg3OfVox3DFloatVecType  ; }
    FiniteDifferenceFunctionImg3OfVox3DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox3DDoubleVecType *){ return m_FiniteDifferenceFunctionImg3OfVox3DDoubleVecType ; }
    FiniteDifferenceFunctionImg3OfVox4DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox4DFloatVecType  *){ return m_FiniteDifferenceFunctionImg3OfVox4DFloatVecType  ; }
    FiniteDifferenceFunctionImg3OfVox4DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox4DDoubleVecType *){ return m_FiniteDifferenceFunctionImg3OfVox4DDoubleVecType ; }
    FiniteDifferenceFunctionImg3OfVox6DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox6DFloatVecType  *){ return m_FiniteDifferenceFunctionImg3OfVox6DFloatVecType  ; }
    FiniteDifferenceFunctionImg3OfVox6DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox6DDoubleVecType *){ return m_FiniteDifferenceFunctionImg3OfVox6DDoubleVecType ; }
    FiniteDifferenceFunctionImg3OfVox8DFloatVecType  ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox8DFloatVecType  *){ return m_FiniteDifferenceFunctionImg3OfVox8DFloatVecType  ; }
    FiniteDifferenceFunctionImg3OfVox8DDoubleVecType ::Pointer GetFiniteDifferenceFunction(FiniteDifferenceFunctionImg3OfVox8DDoubleVecType *){ return m_FiniteDifferenceFunctionImg3OfVox8DDoubleVecType ; }
 
    PDEDeformableRegFunction3DF3DF3DFVType           ::Pointer GetFiniteDifferenceFunction(PDEDeformableRegFunction3DF3DF3DFVType           *){ return m_PDEDeformableRegFunction3DF3DF3DFVType           ; }
 
    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    bool isFiniteDifferenceFunctionValid(PagedImage *outImg, bool usePDEDeformableFunc=false)
    {
      if (!outImg){ return false; }
 
      // Get properties of output image and its data type. From those properties we need
      // to determine whether the corresponding FiniteDifferenceFunctionType is available.
      const MLDataType dt   = outImg->getDataType();
      const size_t numComps = MLTypeGetNumComponents(dt);
      const MLint imgDim    = outImg->getImageExtent().getExtDimension();
 
      // If the pointer member for the specific dimension and data type is non NULL
      // then return true, otherwise false.
      if (!usePDEDeformableFunc){
        if (2==imgDim){
          if ((MLint8Type   == dt) && m_FiniteDifferenceFunctionImg2OfVoxInt8Type        ){ return true; }
          if ((MLint16Type  == dt) && m_FiniteDifferenceFunctionImg2OfVoxInt16Type       ){ return true; }
          if ((MLint32Type  == dt) && m_FiniteDifferenceFunctionImg2OfVoxInt32Type       ){ return true; }
          if ((MLuint8Type  == dt) && m_FiniteDifferenceFunctionImg2OfVoxUInt8Type       ){ return true; }
          if ((MLuint16Type == dt) && m_FiniteDifferenceFunctionImg2OfVoxUInt16Type      ){ return true; }
          if ((MLuint32Type == dt) && m_FiniteDifferenceFunctionImg2OfVoxUInt32Type      ){ return true; }
          if ((MLfloatType  == dt) && m_FiniteDifferenceFunctionImg2OfVoxFloatType       ){ return true; }
          if ((MLdoubleType == dt) && m_FiniteDifferenceFunctionImg2OfVoxDoubleType      ){ return true; }
          if ((2 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox2DFloatVecType  ){ return true; }
          if ((2 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox2DDoubleVecType ){ return true; }
          if ((3 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox3DFloatVecType  ){ return true; }
          if ((3 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox3DDoubleVecType ){ return true; }
          if ((4 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox4DFloatVecType  ){ return true; }
          if ((4 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox4DDoubleVecType ){ return true; }
          if ((6 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox6DFloatVecType  ){ return true; }
          if ((6 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox6DDoubleVecType ){ return true; }
          if ((8 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox8DFloatVecType  ){ return true; }
          if ((8 == numComps)      && m_FiniteDifferenceFunctionImg2OfVox8DDoubleVecType ){ return true; }
        }
        if (3==imgDim){
          if ((MLint8Type   == dt) && m_FiniteDifferenceFunctionImg3OfVoxInt8Type        ){ return true; }
          if ((MLint16Type  == dt) && m_FiniteDifferenceFunctionImg3OfVoxInt16Type       ){ return true; }
          if ((MLint32Type  == dt) && m_FiniteDifferenceFunctionImg3OfVoxInt32Type       ){ return true; }
          if ((MLuint8Type  == dt) && m_FiniteDifferenceFunctionImg3OfVoxUInt8Type       ){ return true; }
          if ((MLuint16Type == dt) && m_FiniteDifferenceFunctionImg3OfVoxUInt16Type      ){ return true; }
          if ((MLuint32Type == dt) && m_FiniteDifferenceFunctionImg3OfVoxUInt32Type      ){ return true; }
          if ((MLfloatType  == dt) && m_FiniteDifferenceFunctionImg3OfVoxFloatType       ){ return true; }
          if ((MLdoubleType == dt) && m_FiniteDifferenceFunctionImg3OfVoxDoubleType      ){ return true; }
          if ((2 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox2DFloatVecType  ){ return true; }
          if ((2 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox2DDoubleVecType ){ return true; }
          if ((3 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox3DFloatVecType  ){ return true; }
          if ((3 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox3DDoubleVecType ){ return true; }
          if ((4 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox4DFloatVecType  ){ return true; }
          if ((4 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox4DDoubleVecType ){ return true; }
          if ((6 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox6DFloatVecType  ){ return true; }
          if ((6 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox6DDoubleVecType ){ return true; }
          if ((8 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox8DFloatVecType  ){ return true; }
          if ((8 == numComps)      && m_FiniteDifferenceFunctionImg3OfVox8DDoubleVecType ){ return true; }
        }
      }
      if (usePDEDeformableFunc && (3==imgDim)){
        if   ((3 == numComps)      && m_PDEDeformableRegFunction3DF3DF3DFVType           ){ return true; }
      }
 
      return false;
    }
 
    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    void SetFiniteDifferenceFunctionImg2OfVoxInt8Type        (FiniteDifferenceFunctionImg2OfVoxInt8Type        ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVoxInt8Type        = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVoxInt16Type       (FiniteDifferenceFunctionImg2OfVoxInt16Type       ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVoxInt16Type       = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVoxInt32Type       (FiniteDifferenceFunctionImg2OfVoxInt32Type       ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVoxInt32Type       = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVoxUInt8Type       (FiniteDifferenceFunctionImg2OfVoxUInt8Type       ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVoxUInt8Type       = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVoxUInt16Type      (FiniteDifferenceFunctionImg2OfVoxUInt16Type      ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVoxUInt16Type      = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVoxUInt32Type      (FiniteDifferenceFunctionImg2OfVoxUInt32Type      ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVoxUInt32Type      = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVoxFloatType       (FiniteDifferenceFunctionImg2OfVoxFloatType       ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVoxFloatType       = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVoxDoubleType      (FiniteDifferenceFunctionImg2OfVoxDoubleType      ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVoxDoubleType      = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox2DFloatVecType  (FiniteDifferenceFunctionImg2OfVox2DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox2DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox2DDoubleVecType (FiniteDifferenceFunctionImg2OfVox2DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox2DDoubleVecType = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox3DFloatVecType  (FiniteDifferenceFunctionImg2OfVox3DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox3DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox3DDoubleVecType (FiniteDifferenceFunctionImg2OfVox3DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox3DDoubleVecType = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox4DFloatVecType  (FiniteDifferenceFunctionImg2OfVox4DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox4DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox4DDoubleVecType (FiniteDifferenceFunctionImg2OfVox4DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox4DDoubleVecType = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox6DFloatVecType  (FiniteDifferenceFunctionImg2OfVox6DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox6DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox6DDoubleVecType (FiniteDifferenceFunctionImg2OfVox6DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox6DDoubleVecType = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox8DFloatVecType  (FiniteDifferenceFunctionImg2OfVox8DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox8DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg2OfVox8DDoubleVecType (FiniteDifferenceFunctionImg2OfVox8DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg2OfVox8DDoubleVecType = ptr; }
 
    void SetFiniteDifferenceFunctionImg3OfVoxInt8Type        (FiniteDifferenceFunctionImg3OfVoxInt8Type        ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVoxInt8Type        = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVoxInt16Type       (FiniteDifferenceFunctionImg3OfVoxInt16Type       ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVoxInt16Type       = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVoxInt32Type       (FiniteDifferenceFunctionImg3OfVoxInt32Type       ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVoxInt32Type       = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVoxUInt8Type       (FiniteDifferenceFunctionImg3OfVoxUInt8Type       ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVoxUInt8Type       = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVoxUInt16Type      (FiniteDifferenceFunctionImg3OfVoxUInt16Type      ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVoxUInt16Type      = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVoxUInt32Type      (FiniteDifferenceFunctionImg3OfVoxUInt32Type      ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVoxUInt32Type      = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVoxFloatType       (FiniteDifferenceFunctionImg3OfVoxFloatType       ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVoxFloatType       = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVoxDoubleType      (FiniteDifferenceFunctionImg3OfVoxDoubleType      ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVoxDoubleType      = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox2DFloatVecType  (FiniteDifferenceFunctionImg3OfVox2DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox2DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox2DDoubleVecType (FiniteDifferenceFunctionImg3OfVox2DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox2DDoubleVecType = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox3DFloatVecType  (FiniteDifferenceFunctionImg3OfVox3DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox3DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox3DDoubleVecType (FiniteDifferenceFunctionImg3OfVox3DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox3DDoubleVecType = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox4DFloatVecType  (FiniteDifferenceFunctionImg3OfVox4DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox4DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox4DDoubleVecType (FiniteDifferenceFunctionImg3OfVox4DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox4DDoubleVecType = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox6DFloatVecType  (FiniteDifferenceFunctionImg3OfVox6DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox6DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox6DDoubleVecType (FiniteDifferenceFunctionImg3OfVox6DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox6DDoubleVecType = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox8DFloatVecType  (FiniteDifferenceFunctionImg3OfVox8DFloatVecType  ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox8DFloatVecType  = ptr; }
    void SetFiniteDifferenceFunctionImg3OfVox8DDoubleVecType (FiniteDifferenceFunctionImg3OfVox8DDoubleVecType ::Pointer ptr){ m_FiniteDifferenceFunctionImg3OfVox8DDoubleVecType = ptr; }
 
    void SetPDEDeformableRegFunction3DF3DF3DFVType           (PDEDeformableRegFunction3DF3DF3DFVType           ::Pointer ptr){ m_PDEDeformableRegFunction3DF3DF3DFVType           = ptr; }
 
  private:
    ITKFiniteDifferenceFunctionWrapper(const ITKFiniteDifferenceFunctionWrapper&) = delete;
 
    ITKFiniteDifferenceFunctionWrapper& operator=(const ITKFiniteDifferenceFunctionWrapper&) = delete;
 
    FiniteDifferenceFunctionImg2OfVoxInt8Type        ::Pointer   m_FiniteDifferenceFunctionImg2OfVoxInt8Type        ;
    FiniteDifferenceFunctionImg2OfVoxInt16Type       ::Pointer   m_FiniteDifferenceFunctionImg2OfVoxInt16Type       ;
    FiniteDifferenceFunctionImg2OfVoxInt32Type       ::Pointer   m_FiniteDifferenceFunctionImg2OfVoxInt32Type       ;
    FiniteDifferenceFunctionImg2OfVoxUInt8Type       ::Pointer   m_FiniteDifferenceFunctionImg2OfVoxUInt8Type       ;
    FiniteDifferenceFunctionImg2OfVoxUInt16Type      ::Pointer   m_FiniteDifferenceFunctionImg2OfVoxUInt16Type      ;
    FiniteDifferenceFunctionImg2OfVoxUInt32Type      ::Pointer   m_FiniteDifferenceFunctionImg2OfVoxUInt32Type      ;
    FiniteDifferenceFunctionImg2OfVoxFloatType       ::Pointer   m_FiniteDifferenceFunctionImg2OfVoxFloatType       ;
    FiniteDifferenceFunctionImg2OfVoxDoubleType      ::Pointer   m_FiniteDifferenceFunctionImg2OfVoxDoubleType      ;
    FiniteDifferenceFunctionImg2OfVox2DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg2OfVox2DFloatVecType  ;
    FiniteDifferenceFunctionImg2OfVox2DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg2OfVox2DDoubleVecType ;
    FiniteDifferenceFunctionImg2OfVox3DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg2OfVox3DFloatVecType  ;
    FiniteDifferenceFunctionImg2OfVox3DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg2OfVox3DDoubleVecType ;
    FiniteDifferenceFunctionImg2OfVox4DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg2OfVox4DFloatVecType  ;
    FiniteDifferenceFunctionImg2OfVox4DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg2OfVox4DDoubleVecType ;
    FiniteDifferenceFunctionImg2OfVox6DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg2OfVox6DFloatVecType  ;
    FiniteDifferenceFunctionImg2OfVox6DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg2OfVox6DDoubleVecType ;
    FiniteDifferenceFunctionImg2OfVox8DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg2OfVox8DFloatVecType  ;
    FiniteDifferenceFunctionImg2OfVox8DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg2OfVox8DDoubleVecType ;
 
    FiniteDifferenceFunctionImg3OfVoxInt8Type        ::Pointer   m_FiniteDifferenceFunctionImg3OfVoxInt8Type        ;
    FiniteDifferenceFunctionImg3OfVoxInt16Type       ::Pointer   m_FiniteDifferenceFunctionImg3OfVoxInt16Type       ;
    FiniteDifferenceFunctionImg3OfVoxInt32Type       ::Pointer   m_FiniteDifferenceFunctionImg3OfVoxInt32Type       ;
    FiniteDifferenceFunctionImg3OfVoxUInt8Type       ::Pointer   m_FiniteDifferenceFunctionImg3OfVoxUInt8Type       ;
    FiniteDifferenceFunctionImg3OfVoxUInt16Type      ::Pointer   m_FiniteDifferenceFunctionImg3OfVoxUInt16Type      ;
    FiniteDifferenceFunctionImg3OfVoxUInt32Type      ::Pointer   m_FiniteDifferenceFunctionImg3OfVoxUInt32Type      ;
    FiniteDifferenceFunctionImg3OfVoxFloatType       ::Pointer   m_FiniteDifferenceFunctionImg3OfVoxFloatType       ;
    FiniteDifferenceFunctionImg3OfVoxDoubleType      ::Pointer   m_FiniteDifferenceFunctionImg3OfVoxDoubleType      ;
    FiniteDifferenceFunctionImg3OfVox2DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg3OfVox2DFloatVecType  ;
    FiniteDifferenceFunctionImg3OfVox2DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg3OfVox2DDoubleVecType ;
    FiniteDifferenceFunctionImg3OfVox3DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg3OfVox3DFloatVecType  ;
    FiniteDifferenceFunctionImg3OfVox3DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg3OfVox3DDoubleVecType ;
    FiniteDifferenceFunctionImg3OfVox4DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg3OfVox4DFloatVecType  ;
    FiniteDifferenceFunctionImg3OfVox4DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg3OfVox4DDoubleVecType ;
    FiniteDifferenceFunctionImg3OfVox6DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg3OfVox6DFloatVecType  ;
    FiniteDifferenceFunctionImg3OfVox6DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg3OfVox6DDoubleVecType ;
    FiniteDifferenceFunctionImg3OfVox8DFloatVecType  ::Pointer   m_FiniteDifferenceFunctionImg3OfVox8DFloatVecType  ;
    FiniteDifferenceFunctionImg3OfVox8DDoubleVecType ::Pointer   m_FiniteDifferenceFunctionImg3OfVox8DDoubleVecType ;
 
    PDEDeformableRegFunction3DF3DF3DFVType           ::Pointer   m_PDEDeformableRegFunction3DF3DF3DFVType           ;
 
  private:
    ML_CLASS_HEADER(ITKFiniteDifferenceFunctionWrapper);
  };
 
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  class MLITK_SUPPORT_EXPORT FiniteDifferenceFunctionWrapper
  {
  public:
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    FiniteDifferenceFunctionWrapper()
    {}
 
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    void addOutputBaseField(Module& module, const char* outputFieldName)
    {
      if (!outputFieldName) {
        ML_PRINT_ERROR("FiniteDifferenceFunctionWrapper::addOutputBaseField", ML_BAD_POINTER_OR_0,
                       "Passed field name pointer is nullptr. Ignoring call.");
        return;
      }
      if (_baseField) {
        ML_PRINT_ERROR("FiniteDifferenceFunctionWrapper::addOutputBaseField", ML_BAD_STATE, "Ignoring multiple field add.");
        return;
      }
 
      _baseField = module.addBase(outputFieldName);
      _baseField->addAllowedType<ITKFiniteDifferenceFunctionWrapper>();
      _baseField->setBaseValue(&_baseWrapper);
    }
 
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    void addInputBaseField(Module& module, const char* inputFieldName)
    {
      if (!inputFieldName) {
        ML_PRINT_ERROR("FiniteDifferenceFunctionWrapper::addInputBaseField", ML_BAD_POINTER_OR_0,
                       "Passed field name pointer is nullptr. Ignoring call.");
        return;
      }
      if (_baseField) {
        ML_PRINT_ERROR("FiniteDifferenceFunctionWrapper::addInputBaseField", ML_BAD_STATE, "Ignoring multiple field add.");
        return;
      }
 
      _baseField = module.addBase(inputFieldName);
      _baseField->addAllowedType<ITKFiniteDifferenceFunctionWrapper>();
    }
 
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    void setNewOutputBaseFieldObject(ITKFiniteDifferenceFunctionWrapper* newObject)
    {
      if (_baseField) {
        _baseField->setBaseValue(newObject);
      }
    }
 
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    BaseField* getOutputBaseField()
    {
      return _baseField;
    }
 
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    BaseField* getInputBaseField()
    {
      return _baseField;
    }
 
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    ITKFiniteDifferenceFunctionWrapper* getWrappedOutputObject()
    {
      return &_baseWrapper;
    }
 
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    ITKFiniteDifferenceFunctionWrapper* getWrappedInputObject()
    {
      return _baseField ? _baseField->getTypedBaseValue<ITKFiniteDifferenceFunctionWrapper*>() : nullptr;
    }
 
  protected:
    ITKFiniteDifferenceFunctionWrapper _baseWrapper;
 
    BaseField* _baseField = nullptr;
  };
 
 
 
ML_END_NAMESPACE