KernelFactory.h

/***************************************************************************************
*                                                                                      *
*                                     Deformetrica                                     *
*                                                                                      *
*    Copyright Inria and the University of Utah.  All rights reserved. This file is    *
*    distributed under the terms of the MIT License. This file is also distributed     *
*    under the terms of the Inria Non-Commercial License Agreement.                    *
*                                                                                      *
*                                                                                      *
****************************************************************************************/

#ifndef _KernelFactory_h
#define _KernelFactory_h

#include "itkSimpleFastMutexLock.h"

#include "ExactKernel.h"
#include "FGTKernel.h"


template <class TScalar, unsigned int PointDim>
class KernelFactory
{
public:

      // typedef :

      typedef enum
      {
            Exact,      
#ifdef USE_CUDA
            CUDAExact,  
#endif
            FGT,        
            P3M         
      } KernelEnumType;

      typedef ExactKernel<TScalar, PointDim> KernelBaseType;

      typedef typename KernelBaseType::VNLVectorType VNLVectorType;
      typedef typename KernelBaseType::VNLMatrixType VNLMatrixType;



      // Encapsulation method(s) :

      KernelEnumType GetKernelCode() const { return m_WhichKernel; }
      void UseExactKernel() { m_Mutex.Lock(); m_WhichKernel = Exact; m_Mutex.Unlock();}
#ifdef USE_CUDA
      void UseCUDAExactKernel() { m_Mutex.Lock(); m_WhichKernel = CUDAExact; m_Mutex.Unlock();}
#endif
      void UseFGTKernel() { m_Mutex.Lock(); m_WhichKernel = FGT; m_Mutex.Unlock();}
      void UseP3MKernel() { m_Mutex.Lock(); m_WhichKernel = P3M; m_Mutex.Unlock();}

      VNLMatrixType GetDataDomain() const { return m_DataDomain; }
      void SetDataDomain(VNLMatrixType DD);

      TScalar GetWorkingSpacingRatio() const { return m_WorkingSpacingRatio; }
      void SetWorkingSpacingRatio(TScalar d) { m_Mutex.Lock(); m_WorkingSpacingRatio = d; m_Mutex.Unlock(); }

      TScalar GetPaddingFactor() const { return m_PaddingFactor; }
      void SetPaddingFactor(TScalar d) { m_Mutex.Lock(); m_PaddingFactor = d; m_Mutex.Unlock(); }



      // Other method(s) :

      static KernelFactory<TScalar, PointDim>* Instantiate();

      KernelBaseType* CreateKernelObject();

      KernelBaseType* CreateKernelObject(
                  const VNLMatrixType& X,
                  const VNLMatrixType& W,
                  TScalar h);

// NOTE: make sure to assign the target image when using P3M
//   void SetWorkingImage(ImageType* img);
// ImagePointer GetWorkingImage() const { return m_WorkingImage; }



protected:

      // Constructor(s) / Destructor :

      KernelFactory();

      ~KernelFactory();

      // Attribute(s)

      KernelEnumType m_WhichKernel;

      // Information of image domain for heuristically determining parameters
      // ImagePointer m_WorkingImage;

      VNLMatrixType m_DataDomain;

      TScalar m_WorkingSpacingRatio;

      TScalar m_PaddingFactor;



private:

      // Attribute(s)

      static itk::SimpleFastMutexLock m_Mutex;

      static bool m_IsInstantiated;

      static KernelFactory* m_SingletonInstance;


}; /* class KernelFactory */


#ifndef MU_MANUAL_INSTANTIATION
#include "KernelFactory.txx"
#endif


#endif /* _KernelFactory_h */