freTransformationCtrlrs.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: freTransformationCtrlrs.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 "freTransformationCtrlrs.h"

#include "freTranslationTransformController.h"
#include "freScaleTransformController.h"
#include "freSimilarity2DTransformController.h"
#include "freVersorTransformController.h"
#include "freVersorRigid3DTransformController.h"
#include "freAffineTransformController.h"
#include "freBSplineDeformableTransformController.h"
#include "freCenteredAffineTransformController.h"
#include "freEuler3DTransformController.h"
#include "freCenteredEuler3DTransformController.h"
#include "freRigid2DTransformController.h"
#include "freCenteredRigid2DTransformController.h"

namespace FREE
{

#ifndef __FREE_DISABLE_DLL_INTERFACE

namespace
{

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

extern "C"
#ifdef _WIN32
    __declspec( dllexport )
#endif
    GenericComponentController* FREECreateController(const char* pControllerID)
{
    return ::FREE::TransformationCtrlrs::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 TransformationCtrlrs::RegisterAllControllers(ControllerCentral* pCentral)
{
    int iCount = 0;
    const char** pControllerIDs = 0;

    TransformationCtrlrs::GetControllerList(iCount,pControllerIDs);

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

    if (pControllerIDs)
        delete pControllerIDs;
};

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

    //Transformations
    internalControllerList.push_back(ControllerID::Translation2DTransformController);
    internalControllerList.push_back(ControllerID::Scale2DTransformController);
    internalControllerList.push_back(ControllerID::Rigid2DTransformController);
    internalControllerList.push_back(ControllerID::Similarity2DTransformController);
    internalControllerList.push_back(ControllerID::Affine2DTransformController);
    internalControllerList.push_back(ControllerID::BSpline3rdOrder2DTransformController);
    internalControllerList.push_back(ControllerID::CenteredRigid2DTransformController);
    internalControllerList.push_back(ControllerID::CenteredAffine2DTransformController);

    internalControllerList.push_back(ControllerID::Translation3DTransformController);
    internalControllerList.push_back(ControllerID::Scale3DTransformController);
    internalControllerList.push_back(ControllerID::Euler3DTransformController);
    internalControllerList.push_back(ControllerID::VersorTransformController);
    internalControllerList.push_back(ControllerID::VersorRigid3DTransformController);
    internalControllerList.push_back(ControllerID::Affine3DTransformController);
    internalControllerList.push_back(ControllerID::BSpline3rdOrder3DTransformController);
    internalControllerList.push_back(ControllerID::CenteredAffine3DTransformController);
    internalControllerList.push_back(ControllerID::CenteredEuler3DTransformController);

    //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* TransformationCtrlrs::CreateController(const char* pControllerID)
{
    std::string sControllerID(pControllerID);

    //Transformations
    if (sControllerID == ControllerID::Translation2DTransformController)
        return(GenericComponentController*)new Translation2DTransformController;
    if (sControllerID == ControllerID::Scale2DTransformController)
        return(GenericComponentController*)new Scale2DTransformController;
    if (sControllerID == ControllerID::Rigid2DTransformController)
        return(GenericComponentController*)new Rigid2DTransformController;
    if (sControllerID == ControllerID::Similarity2DTransformController)
        return(GenericComponentController*)new Similarity2DTransformController;
    if (sControllerID == ControllerID::Affine2DTransformController)
        return(GenericComponentController*)new Affine2DTransformController;
    if (sControllerID == ControllerID::BSpline3rdOrder2DTransformController)
        return(GenericComponentController*)new BSpline3rdOrder2DTransformController;
    if (sControllerID == ControllerID::CenteredRigid2DTransformController)
        return(GenericComponentController*)new CenteredRigid2DTransformController;
    if (sControllerID == ControllerID::CenteredAffine2DTransformController)
        return(GenericComponentController*)new CenteredAffine2DTransformController;

    if (sControllerID == ControllerID::Translation3DTransformController)
        return(GenericComponentController*)new Translation3DTransformController;
    if (sControllerID == ControllerID::Scale3DTransformController)
        return(GenericComponentController*)new Scale3DTransformController;
    if (sControllerID == ControllerID::Euler3DTransformController)
        return(GenericComponentController*)new Euler3DTransformController;
    if (sControllerID == ControllerID::VersorTransformController)
        return(GenericComponentController*)new VersorTransformController;
    if (sControllerID == ControllerID::VersorRigid3DTransformController)
        return(GenericComponentController*)new VersorRigid3DTransformController;
    if (sControllerID == ControllerID::Affine3DTransformController)
        return(GenericComponentController*)new Affine3DTransformController;
    if (sControllerID == ControllerID::BSpline3rdOrder3DTransformController)
        return(GenericComponentController*)new BSpline3rdOrder3DTransformController;
    if (sControllerID == ControllerID::CenteredAffine3DTransformController)
        return(GenericComponentController*)new CenteredAffine3DTransformController;
    if (sControllerID == ControllerID::CenteredEuler3DTransformController)
        return(GenericComponentController*)new CenteredEuler3DTransformController;

    return NULL;
};


} //end of namespace free

---