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

#include "freEvolutionaryStrategyOptimizerController.h"

#include "freESRandomMultiParentSelectorController.h"
#include "freESDominantRecombinatorController.h"
#include "freESIntermediateRecombinatorController.h"
#include "freESRankRecombinatorController.h"
#include "freESDiscriminativeRecombinatorController.h"
#include "freESAdaptiveNormalMutationController.h"
#include "freESAdaptiveScaleMutationController.h"
#include "freESAsymmetricMutationController.h"
#include "freESPlusSelectionController.h"
#include "freESCommaSelectionController.h"
#include "freESCMAMutationController.h"

namespace FREE
{

#ifndef __FREE_DISABLE_DLL_INTERFACE

namespace
{

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

extern "C"
#ifdef _WIN32
    __declspec( dllexport )
#endif
    GenericComponentController* FREECreateController(const char* pControllerID)
{
    return ::FREE::EvolutionaryStrategyCtrlrs::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);
}


} // end of anonymous namspace of dll interface

#endif // __FREE_DISABLE_DLL_INTERFACE



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

    EvolutionaryStrategyCtrlrs::GetControllerList(iCount,pControllerIDs);

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

    if (pControllerIDs)
        delete pControllerIDs;
};

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

    //Optimizers
    internalControllerList.push_back(ControllerID::EvolutionaryStrategyOptimizerController);

    //ES
    internalControllerList.push_back(ControllerID::ESRandomMultiParentSelectorController);
    internalControllerList.push_back(ControllerID::ESDominantRecombinatorController);
    internalControllerList.push_back(ControllerID::ESIntermediateRecombinatorController);
    internalControllerList.push_back(ControllerID::ESRankRecombinatorController);
    internalControllerList.push_back(ControllerID::ESDiscriminativeRecombinatorController);
    internalControllerList.push_back(ControllerID::ESAdaptiveNormalMutationController);
    internalControllerList.push_back(ControllerID::ESAdaptiveScaleMutationController);
    internalControllerList.push_back(ControllerID::ESAsymmetricMutationController);
    internalControllerList.push_back(ControllerID::ESCMAMutationController);
    internalControllerList.push_back(ControllerID::ESPlusSelectionController);
    internalControllerList.push_back(ControllerID::ESCommaSelectionController);

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

    if (sControllerID == ControllerID::EvolutionaryStrategyOptimizerController)
        return(GenericComponentController*)new EvolutionaryStrategyOptimizerController;

    if (sControllerID == ControllerID::ESRandomMultiParentSelectorController)
        return(GenericComponentController*)new ESRandomMultiParentSelectorController;
    if (sControllerID == ControllerID::ESDominantRecombinatorController)
        return(GenericComponentController*)new ESDominantRecombinatorController;
    if (sControllerID == ControllerID::ESIntermediateRecombinatorController)
        return(GenericComponentController*)new ESIntermediateRecombinatorController;
    if (sControllerID == ControllerID::ESRankRecombinatorController)
        return(GenericComponentController*)new ESRankRecombinatorController;
    if (sControllerID == ControllerID::ESDiscriminativeRecombinatorController)
        return(GenericComponentController*)new ESDiscriminativeRecombinatorController;
    if (sControllerID == ControllerID::ESAdaptiveNormalMutationController)
        return(GenericComponentController*)new ESAdaptiveNormalMutationController;
    if (sControllerID == ControllerID::ESAdaptiveScaleMutationController)
        return(GenericComponentController*)new ESAdaptiveScaleMutationController;
    if (sControllerID == ControllerID::ESAsymmetricMutationController)
        return(GenericComponentController*)new ESAsymmetricMutationController;
    if (sControllerID == ControllerID::ESCMAMutationController)
        return(GenericComponentController*)new ESCMAMutationController;
    if (sControllerID == ControllerID::ESPlusSelectionController)
        return(GenericComponentController*)new ESPlusSelectionController;
    if (sControllerID == ControllerID::ESCommaSelectionController)
        return(GenericComponentController*)new ESCommaSelectionController;

    return NULL;
};


} //end of namespace free

---