freGenericSetupToImageAdaptor.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: freGenericSetupToImageAdaptor.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 "freGenericSetupToImageAdaptor.h"
#include "freComponentSetupBrowser.h"
#include "freControllerCentral.h"

namespace FREE
{



void
GenericSetupToImageAdaptor::
SetTemplateSetup(Setup* pSetup)
{
  if (m_pTemplateSetup != pSetup)
  {
        m_pTemplateSetup = pSetup;
    RestartAdaptation();
  }
};
 
Setup*
GenericSetupToImageAdaptor::
GetTemplateSetup()
{ return m_pTemplateSetup;};

const Adaptation::AdaptationList&
GenericSetupToImageAdaptor::
GetAdaptationList()
{
  return *(m_AdaptationList.GetPointer());
};

void
GenericSetupToImageAdaptor::
AddAdaptation (const Adaptation::Adaptation& adaptation)
{
 m_AdaptationList->AddElement(adaptation);
}

void
GenericSetupToImageAdaptor::
AddAdaptations (const Adaptation::AdaptationList& adaptations)
{
 RestartAdaptation();
 m_AdaptationList->AddElements(adaptations);
}

void
GenericSetupToImageAdaptor::
Reset()
{
 RestartAdaptation();
 m_AdaptationList->Reset();
};

const int
GenericSetupToImageAdaptor::
GetCurrentAdaptationID()
{ return m_iCurrentAdaptation; };

void
GenericSetupToImageAdaptor::
RestartAdaptation()
{ m_iCurrentAdaptation = -1;};

bool
GenericSetupToImageAdaptor::
EndOfAdaptation()
{
        return m_iCurrentAdaptation+1>=m_AdaptationList->Size();
};

Setup::Pointer GenericSetupToImageAdaptor::AdaptSetup(int iActualAdaptationItemID)
{
  if (!m_pTemplateSetup) throwExceptionMacro("Template setup has not be defined.");
  if ((iActualAdaptationItemID<0) | (iActualAdaptationItemID>=m_AdaptationList->Size())) return NULL;

  Setup::Pointer result = Setup::New();
  *(result.GetPointer()) = *m_pTemplateSetup;

  AdaptSetup(*(m_AdaptationList->GetElement(iActualAdaptationItemID)),*result);

  return result;
};

Setup::Pointer
GenericSetupToImageAdaptor::
AdaptNextSetup()
{
  m_iCurrentAdaptation++;
  Setup::Pointer result = AdaptSetup(m_iCurrentAdaptation);
  return result;
};

GenericSetupToImageAdaptor::
GenericSetupToImageAdaptor()
{
  RestartAdaptation();
  m_pTemplateSetup = NULL;
  m_AdaptationList = Adaptation::AdaptationList::New();
};

GenericSetupToImageAdaptor::
~GenericSetupToImageAdaptor() {};

void
GenericSetupToImageAdaptor::
AdaptSetup(const Adaptation::Adaptation& adaptation, Setup& rSetup)
{
  ComponentSetupBrowser search(rSetup.GetRootComponent());

  //check all adaption components
  Adaptation::Adaptation::ElementsCountType iIndex;
  for (iIndex = 0; iIndex < adaptation.Size(); iIndex++)
  {
    Adaptation::AdaptationComponent* pAdaptComp = adaptation.GetElement(iIndex);
                search.Reset();

    //get all components in setup that match the id of the adaptation component
    search.SearchForComponents(pAdaptComp->GetComponentPath());
                
    switch (pAdaptComp->GetAdaptationMode())
    {
      case Adaptation::AdaptationComponent::AMOverwrite:
        {
          if (pAdaptComp->GetComponentPath().IsAbsolute())
          { //you can overwrite only with absolut pathes
            ComponentSetup* pCompSetup = 0;
            if (search.GetFindings().size()>0)
            {
              pCompSetup = search.GetFindings().front();
            }
            OverwriteComponent(pAdaptComp,pCompSetup,rSetup);
          }
          break;
        }
      case Adaptation::AdaptationComponent::AMReplace:
        {
                for (ComponentSetupBrowser::FindingsType::iterator it = search.GetFindings().begin(); it != search.GetFindings().end(); it++)
                {
            ReplaceComponent(pAdaptComp,(*it));
                }
          break;
        }
      case Adaptation::AdaptationComponent::AMExtend:
        {
                for (ComponentSetupBrowser::FindingsType::iterator it = search.GetFindings().begin(); it != search.GetFindings().end(); it++)
                {
            ExtendComponent(pAdaptComp,(*it));
                }
          break;
        }
      case Adaptation::AdaptationComponent::AMAdapt:
        {
                for (ComponentSetupBrowser::FindingsType::iterator it = search.GetFindings().begin(); it != search.GetFindings().end(); it++)
                {
            AdaptComponent(pAdaptComp,(*it));
                }
          break;
        }
    }
        }
};

bool
GenericSetupToImageAdaptor::
ValidateController(const ComponentSetup* pAdaptComp, const ComponentSetup* pComponentSetup)
{
        bool bValidController = true;

  if ((pAdaptComp->GetControllerID() != csUndefinedController))
        { //controller is important so check it.
    GenericComponentController* pController = ControllerCentral::GetController(pComponentSetup->GetControllerID());
    if (pController) bValidController = pController->IsRelatedTo(pAdaptComp->GetControllerID());
        }
  return bValidController;
}

void
GenericSetupToImageAdaptor::
AdaptComponent(const ComponentSetup* pAdaptComp, ComponentSetup* pComponentSetup)
{
        bool bValidController = ValidateController(pAdaptComp,pComponentSetup);

  if (bValidController)
  {
    //check parameters
    for (ParameterCollection::ParameterCountType iParamIndex=0; iParamIndex < pAdaptComp->Parameters().Size(); iParamIndex++)
    {
        Parameter* pAdapParam = pAdaptComp->Parameters().GetParameter(iParamIndex);
        
        if (pComponentSetup->Parameters().ParameterExists(pAdapParam->GetParameterName()))
        { //parameter exists in the setup so adapt
          *(pComponentSetup->Parameters().GetParameter(pAdapParam->GetParameterName())) = *pAdapParam;
        }
    }

    //check media
    for (ComponentMediaLinks::ElementsCountType iMediaIndex=0; iMediaIndex < pAdaptComp->MediaLinks().Size(); iMediaIndex++)
    {
      ComponentMediaLink* pAdapLink = pAdaptComp->MediaLinks().GetElement(iMediaIndex);
      ComponentMediaLink* pCompLink = pComponentSetup->MediaLinks().GetElement(pAdapLink->GetMediaID());
      if (pCompLink)
      { //parameter exists in the setup so adapt
        pComponentSetup->MediaLinks().DeleteElement(pComponentSetup->MediaLinks().GetElementIndex(pAdapLink->GetMediaID()));
        pComponentSetup->MediaLinks().AddElement(*pAdapLink);
      }
    }
  }

  //go for sub components
  for (int iPos=0; iPos<pAdaptComp->Components().Size(); iPos++)
  {
    ComponentSetup* pSubAdapComp = pAdaptComp->Components().GetElement(iPos);
    ComponentSetup* pSubComp = pComponentSetup->Components().GetElement(pSubAdapComp->GetComponentID());

    if (pSubComp)
    { //adapt sub component
      AdaptComponent(pSubAdapComp, pSubComp);
    }
  }
}; 

void
GenericSetupToImageAdaptor::
ExtendComponent(const ComponentSetup* pAdaptComp, ComponentSetup* pComponentSetup)
{
        bool bValidController = ValidateController(pAdaptComp,pComponentSetup);

  if (bValidController)
  {
    //check parameters
    for (ParameterCollection::ParameterCountType iParamIndex=0; iParamIndex < pAdaptComp->Parameters().Size(); iParamIndex++)
    {
        Parameter* pAdapParam = pAdaptComp->Parameters().GetParameter(iParamIndex);
        
        if (pComponentSetup->Parameters().ParameterExists(pAdapParam->GetParameterName()))
        { //parameter does exist in the setup so adapt
          *(pComponentSetup->Parameters().GetParameter(pAdapParam->GetParameterName())) = *pAdapParam;
        }
        else
        { //doesn't exist so add it
          Parameter* pParam = pComponentSetup->Parameters().AddParameter(pAdapParam->GetParameterName());
          *pParam = *pAdapParam;
        }
    }

    //check media
    for (ComponentMediaLinks::ElementsCountType iMediaIndex=0; iMediaIndex < pAdaptComp->MediaLinks().Size(); iMediaIndex++)
    {
      ComponentMediaLink* pAdapLink = pAdaptComp->MediaLinks().GetElement(iMediaIndex);
      ComponentMediaLink* pCompLink = pComponentSetup->MediaLinks().GetElement(pAdapLink->GetMediaID());
      if (pCompLink)
      { //delete old link
        pComponentSetup->MediaLinks().DeleteElement(pComponentSetup->MediaLinks().GetElementIndex(pAdapLink->GetMediaID()));
      }
      pComponentSetup->MediaLinks().AddElement(*pAdapLink);
    }
  }

  //go for sub components
  for (int iPos=0; iPos<pAdaptComp->Components().Size(); iPos++)
  {
    ComponentSetup* pSubAdapComp = pAdaptComp->Components().GetElement(iPos);
    ComponentSetup* pSubComp = pComponentSetup->Components().GetElement(pSubAdapComp->GetComponentID());

    if (pSubComp)
    { //adapt sub component
      ExtendComponent(pSubAdapComp, pSubComp);
    }
  }
}; 

void
GenericSetupToImageAdaptor::
ReplaceComponent(const ComponentSetup* pAdaptComp, ComponentSetup* pComponentSetup)
{
  //keep component id but change everything else
  pComponentSetup->SetControllerID(pAdaptComp->GetControllerID());

  pComponentSetup->Parameters() = pAdaptComp->Parameters();
  pComponentSetup->MediaLinks() = pAdaptComp->MediaLinks();
  pComponentSetup->Components() = pAdaptComp->Components();
}; 

void
GenericSetupToImageAdaptor::
OverwriteComponent(const ComponentSetup* pAdaptComp, ComponentSetup* pComponentSetup, Setup& rSetup)
{
  if (!pComponentSetup)
  { //component doesn't exist, so establish one
    ComponentSetupCollection::ElementsCountType iNewIndex = rSetup.GetRootComponent()->Components().AddElement(pAdaptComp->GetComponentID());
    pComponentSetup = rSetup.GetRootComponent()->Components().GetElement(iNewIndex);
  }
  //now "replace" it
  ReplaceComponent(pAdaptComp,pComponentSetup);
}; 

}//End of Namespace free

---