freInterpolatorCtrlrs.cxx

Go to the documentation of this file.

/*=========================================================================
 
  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freInterpolatorCtrlrs.cxx,v $
  Language:  C++
 
 
        
  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.
 
=========================================================================*/
#include "freInterpolatorCtrlrs.h"

#include "freNearestNeighborInterpolateController.h"
#include "freLinearInterpolateController.h"
#include "freBSplineInterpolateController.h"

namespace FREE
{

#ifndef __FREE_DISABLE_DLL_INTERFACE

namespace
{

extern "C"
#ifdef _WIN32
    __declspec( dllexport )
#endif
    void FREEGetControllerList(int& iControllerCount, const char**& pControllerIDs)
{
    ::FREE::InterpolatorCtrlrs::GetControllerList(iControllerCount, pControllerIDs);
};

extern "C"
#ifdef _WIN32
    __declspec( dllexport )
#endif
    GenericComponentController* FREECreateController(const char* pControllerID)
{
    return ::FREE::InterpolatorCtrlrs::CreateController(pControllerID);
};

extern "C"
#ifdef _WIN32
    __declspec( dllexport )
#endif
    bool FREEDeleteController (GenericComponentController* pController)
{
    if (pController)
    {
        delete pController;
    }
    return true;
};

extern "C"
#ifdef _WIN32
    __declspec( dllexport )
#endif
    void FREELinkCentralAsDedicated (::FREE::ControllerCentral::ControllerListType* pDedicatedControllerList,
                                     ::FREE::ControllerCentral::LibraryHandleListType* pDedicatedLibraryHandles,
                                     ::FREE::ProgressEventBase* pfnOnControl, ::FREE::ProgressEventBase* pfnOnBuild,
                                     ::FREE::ControllerCentral::CtrlCallbackListType* pCtrlCallbackList,
                                     ::FREE::ControllerCentral::CtrlProgressListType* pCtrlProgressList,
                                     ::itk::MutexLock* pGlobalCallbackMutex,
                                     ::itk::MutexLock* pGlobalProgressMutex)
{
    ::FREE::ControllerCentral::LinkControllerCentralAsDedicated(pDedicatedControllerList,pDedicatedLibraryHandles,pfnOnControl,pfnOnBuild,pCtrlCallbackList,pCtrlProgressList,pGlobalCallbackMutex,pGlobalProgressMutex);
}


} 

#endif // __FREE_DISABLE_DLL_INTERFACE



void InterpolatorCtrlrs::RegisterAllControllers(ControllerCentral* pCentral)
{
    int iCount = 0;
    const char** pControllerIDs = 0;

    InterpolatorCtrlrs::GetControllerList(iCount,pControllerIDs);

    for (int iPos = 0; iPos < iCount; iPos++)
    {
        pCentral->RegisterController(InterpolatorCtrlrs::CreateController(pControllerIDs[iPos]));
    }

    if (pControllerIDs)
        delete pControllerIDs;
};

void InterpolatorCtrlrs::GetControllerList(int& iControllerCount, const char**& pControllerIDs)
{
    typedef std::vector<const char*> ControllerListType;
    ControllerListType internalControllerList;

    //Interpolators
    internalControllerList.push_back(ControllerID::NearestNeighbor2DInterpolateController);
    internalControllerList.push_back(ControllerID::Linear2DInterpolateController);
    internalControllerList.push_back(ControllerID::BSpline2DInterpolateController);

    internalControllerList.push_back(ControllerID::NearestNeighbor3DInterpolateController);
    internalControllerList.push_back(ControllerID::Linear3DInterpolateController);
    internalControllerList.push_back(ControllerID::BSpline3DInterpolateController);

    //create export array with controller names.
    iControllerCount = internalControllerList.size();
    pControllerIDs = new const char*[iControllerCount];
    for (unsigned int iPos = 0; iPos<iControllerCount; iPos++)
    {
        pControllerIDs[iPos] = internalControllerList.at(iPos);
    }
};

GenericComponentController* InterpolatorCtrlrs::CreateController(const char* pControllerID)
{
    std::string sControllerID(pControllerID);

    //Interpolators
    if (sControllerID == ControllerID::NearestNeighbor2DInterpolateController)
        return(GenericComponentController*)new NearestNeighbor2DInterpolateController;
    if (sControllerID == ControllerID::Linear2DInterpolateController)
        return(GenericComponentController*)new Linear2DInterpolateController;
    if (sControllerID == ControllerID::BSpline2DInterpolateController)
        return(GenericComponentController*)new BSpline2DInterpolateController;

    if (sControllerID == ControllerID::NearestNeighbor3DInterpolateController)
        return(GenericComponentController*)new NearestNeighbor3DInterpolateController;
    if (sControllerID == ControllerID::Linear3DInterpolateController)
        return(GenericComponentController*)new Linear3DInterpolateController;
    if (sControllerID == ControllerID::BSpline3DInterpolateController)
        return(GenericComponentController*)new BSpline3DInterpolateController;

    return NULL;
};


} //end of namespace free

---