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

#include "freMeanSquaresMetricController.h"
#include "freNormalizedCorrelationMetricController.h"
#include "freMutualInformationMetricController.h"
#include "freMattesMutualInformationMetricController.h"
#include "freMutualInformationHistogramMetricController.h"
#include "freMeanReciprocalSquaresMetricController.h"
#include "freDifferenceEnergyMetricController.h"
#include "freDifferenceEntropyMetricController.h"
#include "freEuclidianDistancePointMetricController.h"

namespace FREE
{

#ifndef __FREE_DISABLE_DLL_INTERFACE

namespace
{

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

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

    MetricCtrlrs::GetControllerList(iCount,pControllerIDs);

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

    if (pControllerIDs)
        delete pControllerIDs;
};

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

    //Metrics
    internalControllerList.push_back(ControllerID::MeanSquares2DMetricController);
    internalControllerList.push_back(ControllerID::NormalizedCorrelation2DMetricController);
    internalControllerList.push_back(ControllerID::MutualInformation2DMetricController);
    internalControllerList.push_back(ControllerID::MattesMutualInformation2DMetricController);
    internalControllerList.push_back(ControllerID::MutualInformationHistogram2DMetricController);
    internalControllerList.push_back(ControllerID::MeanReciprocalSquares2DMetricController);
    internalControllerList.push_back(ControllerID::DifferenceEnergy2DMetricController);
    internalControllerList.push_back(ControllerID::DifferenceEntropy2DMetricController);
    internalControllerList.push_back(ControllerID::EuclidianDistancePoint2DMetricController);

    internalControllerList.push_back(ControllerID::MeanSquares3DMetricController);
    internalControllerList.push_back(ControllerID::NormalizedCorrelation3DMetricController);
    internalControllerList.push_back(ControllerID::MutualInformation3DMetricController);
    internalControllerList.push_back(ControllerID::MattesMutualInformation3DMetricController);
    internalControllerList.push_back(ControllerID::MutualInformationHistogram3DMetricController);
    internalControllerList.push_back(ControllerID::MeanReciprocalSquares3DMetricController);
    internalControllerList.push_back(ControllerID::DifferenceEnergy3DMetricController);
    internalControllerList.push_back(ControllerID::DifferenceEntropy3DMetricController);
    internalControllerList.push_back(ControllerID::EuclidianDistancePoint3DMetricController);

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

    //Metrics
    if (sControllerID == ControllerID::MeanSquares2DMetricController)
        return(GenericComponentController*)new MeanSquares2DMetricController;
    if (sControllerID == ControllerID::NormalizedCorrelation2DMetricController)
        return(GenericComponentController*)new NormalizedCorrelation2DMetricController;
    if (sControllerID == ControllerID::MutualInformation2DMetricController)
        return(GenericComponentController*)new MutualInformation2DMetricController;
    if (sControllerID == ControllerID::MattesMutualInformation2DMetricController)
        return(GenericComponentController*)new MattesMutualInformation2DMetricController;
    if (sControllerID == ControllerID::MutualInformationHistogram2DMetricController)
        return(GenericComponentController*)new MutualInformationHistogram2DMetricController;
    if (sControllerID == ControllerID::MeanReciprocalSquares2DMetricController)
        return(GenericComponentController*)new MeanReciprocalSquares2DMetricController;
    if (sControllerID == ControllerID::DifferenceEnergy2DMetricController)
        return(GenericComponentController*)new DifferenceEnergy2DMetricController;
    if (sControllerID == ControllerID::DifferenceEntropy2DMetricController)
        return(GenericComponentController*)new DifferenceEntropy2DMetricController;
    if (sControllerID == ControllerID::EuclidianDistancePoint2DMetricController)
        return(GenericComponentController*)new EuclidianDistancePoint2DMetricController;

    if (sControllerID == ControllerID::MeanSquares3DMetricController)
        return(GenericComponentController*)new MeanSquares3DMetricController;
    if (sControllerID == ControllerID::NormalizedCorrelation3DMetricController)
        return(GenericComponentController*)new NormalizedCorrelation3DMetricController;
    if (sControllerID == ControllerID::MutualInformation3DMetricController)
        return(GenericComponentController*)new MutualInformation3DMetricController;
    if (sControllerID == ControllerID::MattesMutualInformation3DMetricController)
        return(GenericComponentController*)new MattesMutualInformation3DMetricController;
    if (sControllerID == ControllerID::MutualInformationHistogram3DMetricController)
        return(GenericComponentController*)new MutualInformationHistogram3DMetricController;
    if (sControllerID == ControllerID::MeanReciprocalSquares3DMetricController)
        return(GenericComponentController*)new MeanReciprocalSquares3DMetricController;
    if (sControllerID == ControllerID::DifferenceEnergy3DMetricController)
        return(GenericComponentController*)new DifferenceEnergy3DMetricController;
    if (sControllerID == ControllerID::DifferenceEntropy3DMetricController)
        return(GenericComponentController*)new DifferenceEntropy3DMetricController;
    if (sControllerID == ControllerID::EuclidianDistancePoint3DMetricController)
        return(GenericComponentController*)new EuclidianDistancePoint3DMetricController;

    return NULL;
};


} //end of namespace free

---