freSetupInterpolator.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: freSetupInterpolator.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 "freSetupInterpolator.h"
#include "freExceptions.h"
#include "freControllerBase.h"


namespace FREE
{



void
SetupInterpolator::
SetStartSetup(Setup* pSetup)
{
  m_pStartSetup = pSetup;
  ResetIteration();
}; 

Setup*
SetupInterpolator::
GetStartSetup()
{ return m_pStartSetup; };

void
SetupInterpolator::
SetStopSetup(Setup* pSetup) 
{
  m_pStopSetup = pSetup;
  ResetIteration();
}; 

Setup*
SetupInterpolator::
GetStopSetup()
{ return m_pStopSetup; };

void
SetupInterpolator::
SetIterations(const int iIterations)
{ 
  m_Iterations = iIterations;
  ResetIteration();
};

const int
SetupInterpolator::
GetIterations()
{ return m_Iterations; };

const int
SetupInterpolator::
GetCurrentIteration()
{ return m_CurrentIteration; };

void
SetupInterpolator::
ResetIteration()
{ m_CurrentIteration = 0; };

void
SetupInterpolator::
SetSetupName(const std::string&  sName)
{ m_sName = sName; };

const std::string
SetupInterpolator::
GetSetupName()
{ return m_sName; };

void
SetupInterpolator::
ResetName()
{ m_sName = ""; };

Setup::Pointer
SetupInterpolator::
InterpolateSetup(const int iActIteration, const int iIterations)
{
  if (!m_pStartSetup) throwExceptionMacro("Interpolation aborted, no start setup set.");
  if (!m_pStopSetup) throwExceptionMacro("Interpolation aborted, no stop setup set.");
        if ((iActIteration> iIterations+1) | (iActIteration<0)) throwExceptionMacro("Interpolation aborted, iteration out of range (1.."<<iIterations<<") : "<<iActIteration);

  Setup::Pointer pInterpolatedSetup = Setup::New();
  *pInterpolatedSetup = *m_pStartSetup;

  if (m_sName!="") pInterpolatedSetup->SetName(m_sName);
  pInterpolatedSetup->SetName(pInterpolatedSetup->GetName()+"_"+FREE::Convert::ToStr(iActIteration)+"_"+FREE::Convert::ToStr(iIterations+1));

  Setup::SectionVector sections = pInterpolatedSetup->GetSections();
  for (int iSection = 0; iSection < sections.size(); iSection++)
  {
    ComponentSetup* pSection = sections[iSection];
    InterpolateComponent(pSection,iSection,iActIteration,iIterations);
  };

  return pInterpolatedSetup;
};

Setup::Pointer
SetupInterpolator::
InterpolateSetup(const int iActIteration)
{
  return InterpolateSetup(iActIteration, m_Iterations);
};

Setup::Pointer
SetupInterpolator::
InterpolateNext()
{
  if (m_CurrentIteration>m_Iterations+1) return NULL;
  Setup::Pointer pNew = InterpolateSetup(m_CurrentIteration, m_Iterations);
  m_CurrentIteration++;
  return pNew;
};

SetupInterpolator::
SetupInterpolator()
{
  ResetIteration();
  ResetName();
  m_Iterations = 0;
  m_sName = "";
  m_pStartSetup = NULL;
  m_pStopSetup = NULL;
};

SetupInterpolator::
~SetupInterpolator()  {};

void
SetupInterpolator::
InterpolateParameter(ComponentSetup* pInterpolate, ComponentSetup* pStart, ComponentSetup* pStop, const std::string& sKey, const int& iActIteration, const int& iIterations)
{
  GenericComponentController* pController = m_Central.GetController(pStart->GetControllerID());
        if (!pController) throwExceptionMacro("No controller found for component (ComponentID: "<<pStart->GetComponentID()<<"; ControllerID: "<<pStart->GetControllerID()<<")");

  CtrlProfile::Parameter* pParam = pController->GetProfile(0)->Parameters().GetElement(sKey);

  if (!pParam) throwExceptionMacro("Parameter not found in controller profile. Missing key: " << sKey);

  Parameter::ParameterValueType paramType = pParam->GetValueType();

  if ((paramType==Parameter::PVTDouble) | (paramType==Parameter::PVTInteger) | (paramType==Parameter::PVTLong) | (paramType==Parameter::PVTULong))
  {
    if (!pStart->Parameters().ParameterExists(sKey)) throwExceptionMacro("Parameter not found in start setup. Missing key: " << sKey);
    if (!pStop->Parameters().ParameterExists(sKey)) throwExceptionMacro("Parameter not found in stop setup. Missing key: " << sKey);

    for (int iLevelIndex=0; iLevelIndex<pStart->Parameters().ParameterLayerCount(sKey); iLevelIndex++)
    {
      for (int iIndex=0; iIndex<pStart->Parameters().ParameterSize(sKey); iIndex++)
      {
        double startValue;
        double stopValue;
        if ((pStart->Parameters().GetParameterValue(sKey,startValue,iIndex,iLevelIndex)) &
            (pStop->Parameters().GetParameterValue(sKey,stopValue,iIndex,iLevelIndex)))
        {
          double newValue = startValue+((stopValue-startValue)*iActIteration/(iIterations+1));
          switch (paramType)
          {
            case Parameter::PVTULong: pInterpolate->Parameters().SetParameterValue(sKey,(unsigned long)newValue,iIndex,iLevelIndex); break;
            case Parameter::PVTLong: pInterpolate->Parameters().SetParameterValue(sKey,(long)newValue,iIndex,iLevelIndex); break;
            case Parameter::PVTInteger: pInterpolate->Parameters().SetParameterValue(sKey,(int)newValue,iIndex,iLevelIndex); break;
            default: pInterpolate->Parameters().SetParameterValue(sKey,newValue,iIndex,iLevelIndex);
          };
        };//else at least one of the parameters is empty and cannot be interpolated (e.g. no initial reference points)
      };
    };
  };
};

void
SetupInterpolator::
InterpolateComponent(ComponentSetup *pComponent, const int& iSectionID, const int& iActIteration, const int& iIterations)
{
  Setup::SectionVector startSections = m_pStartSetup->GetSections();
  Setup::SectionVector stopSections = m_pStopSetup->GetSections();

  ComponentSetup* pStartSection = startSections[iSectionID];
  ComponentSetup* pStopSection = stopSections[iSectionID];

  if (!pStopSection) throwExceptionMacro("Section not found in stop setup. SectionID: " << iSectionID);
  
  ComponentSetup* pStart = m_pStartSetup->GetComponentByIDPath(pComponent->GetIDPath());
  ComponentSetup* pStop = m_pStopSetup->GetComponentByIDPath(pComponent->GetIDPath());

  if (!pStart) throwExceptionMacro("Component not found in start setup. ComponentID: " << pComponent->GetIDPath().operator std::string());
  if (!pStop) throwExceptionMacro("Component not found in stop setup. ComponentID: " << pComponent->GetIDPath().operator std::string());

  for (int iIndex=0; iIndex<pComponent->Parameters().Size(); iIndex++)
  {
    std::string  sKey = pComponent->Parameters().GetParameterName(iIndex);
    InterpolateParameter(pComponent,pStart,pStop,sKey,iActIteration,iIterations);
  };

  for (int iIndex=0; iIndex<pComponent->Components().Size(); iIndex++)
  { //interpolate the subcomponents
    std::string  sKey = pComponent->Parameters().GetParameterName(iIndex);
    InterpolateComponent(pComponent->Components().GetElement(iIndex),iSectionID,iActIteration,iIterations);
  };
};

}//End of Namespace free

---