mlITKObjectFactory.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 <mlITKSupport.h>
 
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
#define _ML_CREATE_ITK_OBJECT_VOID(ML_OUTDATATYPE, ITKOUTDATATYPE, MLINDATATYPE, ITKINDATATYPE, DIM, CLASS_NAME) \
{                                                                                                                \
  return new CLASS_NAME<ITKINDATATYPE, DIM>();                                                                   \
}                                                                                                                \
 
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
#define _ML_DESTROY_ITK_OBJECT_VOID(MLOUTDATATYPE, ITKOUTDATATYPE, MLINDATATYPE, ITKINDATATYPE, DIM, CLASS_NAME) \
{                                                                                                                \
  delete static_cast<CLASS_NAME<ITKINDATATYPE, DIM>*>(itkFactoryObj);                                            \
}                                                                                                                \
 
 
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
#define _ML_CREATE_ITK_OBJECT_VOID_WO_DT(ML_OUTDATATYPE, ITKOUTDATATYPE, MLINDATATYPE, ITKINDATATYPE, DIM, CLASS_NAME) \
{                                                                                                                      \
  return new CLASS_NAME<DIM>();                                                                                        \
}                                                                                                                      \
 
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
#define _ML_DESTROY_ITK_OBJECT_VOID_WO_DT(MLOUTDATATYPE, ITKOUTDATATYPE, MLINDATATYPE, ITKINDATATYPE, DIM, CLASS_NAME) \
{                                                                                                                      \
  delete static_cast<CLASS_NAME<DIM>*>(itkFactoryObj);                                                                 \
}                                                                                                                      \
 
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
#define MLITKImplementFactoryFuncs(CLASS_NAME, NAMESPACE, NEW_FUNC, DEL_FUNC)                   \
  /*--------------------------------------------------------------------*/                      \
                      \
  /*--------------------------------------------------------------------*/                      \
  static void *CLASS_NAME##Creator(MLDataType dType, unsigned int dim){                         \
    /* Call correct template version of object creation for all types and dims. */              \
    ML_IMPLEMENT_ALL_ITK_6D_CASES("CLASS_NAME##creator())",                                     \
                                  NEW_FUNC,                                                     \
                                  NAMESPACE::CLASS_NAME, dType, dim);                           \
    return nullptr; /* Error */                                                                    \
  }                                                                                             \
                                                                                                \
  /*--------------------------------------------------------------------*/                      \
                      \
                      \
  /*--------------------------------------------------------------------*/                      \
  static void CLASS_NAME##Destructor(void *itkFactoryObj, MLDataType dType, unsigned int dim){  \
    /* Call correct template version of object destruction for all types and dims. */           \
    ML_IMPLEMENT_ALL_ITK_6D_CASES("CLASS_NAME##destructor()",                                   \
                                  DEL_FUNC,                                                     \
                                  NAMESPACE::CLASS_NAME, dType, dim);                           \
  }                                                                                             \
 
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define MLITKObjectFactoryInit(FACTORY, CLASS_NAME) \
  FACTORY._setCreatorAndDestructor(CLASS_NAME##Creator, CLASS_NAME##Destructor);
 
 
ML_START_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class MLITK_SUPPORT_EXPORT MLITKObjectFactory
{
  public:
 
    typedef void *(*MLITKObjectFactoryCreator)(MLDataType dataType, unsigned int dim);
 
    typedef void (*MLITKObjectFactoryDestructor)(void *, MLDataType dataType, unsigned int dim);
 
    MLITKObjectFactory(): _itkObjectVoid(nullptr), _dataType(ML_INVALID_DATA_TYPE), _dimension(0){ }
 
    ~MLITKObjectFactory()                        { _destroyInternalObject(); }
 
    void createObject(MLDataType dType, int dim) { _createInternalObject(dType, dim); }
 
    void createObject(MLDataType dType, ImageVector v){ _createInternalObject(dType, v.getExtDimension()); }
 
    void destroyObject()                         { _destroyInternalObject(); }
 
    void *getObject() const                      { return _itkObjectVoid; }
 
    MLDataType getDataType() const               { return _dataType; }
 
    unsigned int getDimension() const            { return _dimension; }
 
    void _setCreatorAndDestructor(MLITKObjectFactoryCreator    cFunc,
                                  MLITKObjectFactoryDestructor dFunc)
    {
      _creatorFunc    = cFunc;
      _destructorFunc = dFunc;
    }
 
  private:
 
    //-------------------------------------------
    //-------------------------------------------
 
    void _createInternalObject(MLDataType dataType, MLint dim)
    {
      // Remove existing object if there is one.
      _destroyInternalObject();
 
      // Check for valid data type and dimension.
      if (!MLIsValidType(dataType) || (dim < 1) || (dim > 6)){
        ML_PRINT_FATAL_ERROR("MLITKObjectFactory::_createInternalObject(MLDataType, int)",
                             ML_BAD_PARAMETER, "Not creating object.");
        return;
      }
 
      ML_TRY
      {
        // Create object and store data type and dimension.
        _itkObjectVoid = _creatorFunc(dataType, static_cast<unsigned int>(dim));
        _dataType      = dataType;
        _dimension     = static_cast<unsigned int>(dim);
      }
      ML_CATCH_BLOCK(...)
      {
        ML_PRINT_FATAL_ERROR("MLITKObjectFactory::_createInternalObject(MLDataType, int)",
                             ML_UNKNOWN_EXCEPTION, "");
        _itkObjectVoid = nullptr;
        _dataType      = ML_INVALID_DATA_TYPE;
        _dimension     = 0;
      }
    }
 
    void _destroyInternalObject()
    {
      if (_itkObjectVoid){
        ML_TRY
        {
          _destructorFunc(_itkObjectVoid, _dataType, _dimension);
        }
        ML_CATCH_BLOCK(...)
        {
          ML_PRINT_ERROR("MLITKObjectFactory::_destroyInternalObject()", ML_UNKNOWN_EXCEPTION, "");
        }
 
        // Reset pointer and members.
        _itkObjectVoid = nullptr;
        _dataType      = ML_INVALID_DATA_TYPE;
        _dimension     = 0;
      }
    }
 
    MLITKObjectFactory(const MLITKObjectFactory &){}
 
    MLITKObjectFactory &operator=(const MLITKObjectFactory &){ return *this; }
 
 
    //-------------------------------------------
    //-------------------------------------------
    void *_itkObjectVoid;
 
    MLDataType _dataType;
 
    unsigned int _dimension;
 
    MLITKObjectFactoryCreator _creatorFunc;
 
    MLITKObjectFactoryDestructor _destructorFunc;
};
 
ML_END_NAMESPACE