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


namespace FREE
{



unsigned int
SetupTransform::
GetNumberOfParameters(void) const
{
        return m_ParameterIDs.size();
};

const SetupTransform::ParametersType&
SetupTransform::
GetParameters(void) const
{
        return m_Parameters;
};

unsigned int
SetupTransform::
GetInputSpaceDimension(void) const
{
        return 0;
};

unsigned int
SetupTransform::
GetOutputSpaceDimension(void) const
{
        return 0;
};

void
SetupTransform::
SetParameters( const ParametersType & p)
{
        if (GetNumberOfParameters() != p.size()) throwExceptionMacro("Error. Number of passed parameter values is not equal to the parameter size of the transform. Passed parameter count: "<< p.size() << "; tranform parameter count: "<<GetNumberOfParameters());
        m_ParameterTraits = ComputeParametersTraits(p,m_Parameters);
        m_bTraitsInitialized = true;
};

void
SetupTransform::
SetParametersDirectly( const ParametersType & p)
{
        if (GetNumberOfParameters() != p.size()) throwExceptionMacro("Error. Number of passed parameter values is not equal to the parameter size of the transform. Passed parameter count: "<< p.size() << "; tranform parameter count: "<<GetNumberOfParameters());
        m_ParameterTraits = ComputeParametersTraits(p);
        m_Parameters = p;
        m_bTraitsInitialized = true;
};

void
SetupTransform::
SetParametersByValue ( const ParametersType & p )
{
        SetParameters(p);
};

void
SetupTransform::
SetFixedParameters( const ParametersType & p)
{
        if (GetNumberOfParameters() != p.size()) throwExceptionMacro("Error. Number of passed parameter values is not equal to the parameter size of the transform. Passed parameter count: "<< p.size() << "; tranform parameter count: "<<GetNumberOfParameters());
        m_ParameterTraits = ComputeParametersTraits(p,m_Parameters);
        m_bTraitsInitialized = true;
};

const SetupTransform::ParametersType&
SetupTransform::
GetFixedParameters( ) const
{
        return m_Parameters;
};

SetupTransform::ParameterTraitsList
SetupTransform::
ComputeParametersTraits( const ParametersType & p) const
{
        ParametersType temp;
        return ComputeParametersTraits(p,temp);
};

SetupTransform::ParameterTraitsList
SetupTransform::
ComputeParametersTraits( const ParametersType & p, ParametersType& validP) const
{
        ParameterTraitsList result;

        if (!m_pReferenceSetup) throwExceptionMacro("Error: cannot compute traites. No reference setup defined to determine parameter value type.");

        validP = p;

        for (unsigned int i= 0; i<this->m_Parameters.Size(); i++)
        { //determine the parameter value type for every parameter 
                Parameter::ParameterValueType pvt = this->GetParameterValueType(m_ParameterIDs[i]);
                SetupParameterTraits paramTraits(p[i],pvt);
                if ((pvt == Parameter::PVTInteger) || (pvt == Parameter::PVTLong)  || (pvt == Parameter::PVTULong))
                {
                        validP[i] = floor(p[i]);
                }

                result.push_back(paramTraits);
        }

        return result;
};

const SetupTransform::ParameterTraitsList&
SetupTransform::
GetParametersTraits(void)
{
        if (!m_bTraitsInitialized)
        {
                m_ParameterTraits = ComputeParametersTraits(m_Parameters);
    m_bTraitsInitialized = true;
        }

        return m_ParameterTraits;
};

std::string
SetupTransform::
GetTransformTypeAsString() const
{
        return GetNameOfClass();
};

Setup::Pointer
SetupTransform::
GenerateTransformedSetup()
{
        if (!m_pReferenceSetup) throwExceptionMacro("Error: cannot transform setup. No reference setup defined.");
        if (GetNumberOfParameters() != m_Parameters.size()) throwExceptionMacro("Error. Cannot transform setup, number of passed parameter values is not equal to the parameter size of the transform. Passed parameter count: "<< m_Parameters.size());

        TransformSetup();
  Setup::Pointer result = m_smpTransformedSetup;
  m_smpTransformedSetup = 0;
        return result;
};

void
SetupTransform::
SetAutoInitialValues(bool bAutoValues)
{
        m_bAutoInitialValue = bAutoValues;
};

bool
SetupTransform::
GetAutoInitialValues()
{
        return m_bAutoInitialValue;
};

void
SetupTransform::
SetReferenceSetup(Setup* pSetup)
{
        m_pReferenceSetup = pSetup;
        if (m_bAutoInitialValue) GetInitialValues();
};

void
SetupTransform::
ResetParameterIDs()
{
        m_ParameterIDs.clear();
        m_bTraitsInitialized = false;
        m_Parameters.SetSize(GetNumberOfParameters());
        m_Parameters.Fill(0);
};

void
SetupTransform::
AddParameterID(const IDPath& idPath)
{
        m_ParameterIDs.push_back(idPath);
        m_bTraitsInitialized = false;
        m_Parameters.SetSize(GetNumberOfParameters());
        m_Parameters.Fill(0);

};

SetupTransform::
SetupTransform()
{
        m_pReferenceSetup = 0;
  m_smpTransformedSetup = 0;
        m_Parameters.Fill(0);
        m_bAutoInitialValue = true;
        m_bTraitsInitialized = false;
}; 

SetupTransform::
~SetupTransform() {};

void
SetupTransform::
TransformSetup()
{

  m_smpTransformedSetup = Setup::New();

  m_smpTransformedSetup->operator =(*m_pReferenceSetup);

        ComponentSetupBrowser search(m_smpTransformedSetup->GetComponentByIDPath(cIDPRoot));

        for (unsigned int iIndex=0; iIndex<m_ParameterIDs.size(); iIndex++)
        {
                search.Reset();
                search.SearchForComponents(m_ParameterIDs[iIndex]);

                ComponentSetupBrowser::FindingsType::iterator it;
                for (it = search.GetFindings().begin(); it != search.GetFindings().end(); it++)
                {
      IDPath parameterID = m_ParameterIDs[iIndex].GetParameterIDPath();

                        (*it)->Parameters().SetParameterValueByIDPath(parameterID,m_Parameters[iIndex]);
                }
        }
};

void
SetupTransform::
GetInitialValues()
{
        ComponentSetupBrowser search(m_pReferenceSetup->GetComponentByIDPath(cIDPRoot));

        ParametersType  newParameters(m_ParameterIDs.size());
        newParameters.Fill(0.0);

        for (unsigned int iIndex=0; iIndex<m_ParameterIDs.size(); iIndex++)
        {
                search.Reset();
                search.SearchForComponents(m_ParameterIDs[iIndex]);

                if (search.GetFindings().size()!=0)
                {
                        double value;
      IDPath parameterID = m_ParameterIDs[iIndex].GetParameterIDPath();

                        search.GetFindings().at(0)->Parameters().GetParameterValueByIDPath(parameterID,value);
                        newParameters.SetElement(iIndex,value);
                }
        }

        SetParameters(newParameters);
};

Parameter::ParameterValueType
SetupTransform::
GetParameterValueType(const IDPath& paramID) const
{
        if (!m_pReferenceSetup) throwExceptionMacro("Error: cannot determine parameter value type; reference setup is NULL.");

        IDPath compID = paramID.GetParentComponentIDPath();

        ComponentSetup* pComp = m_pReferenceSetup->GetComponentByIDPath(compID);

        if (!pComp) throwExceptionMacro("Error: cannot find component of the specified parameter within setup. Parameter IDPath: "<<paramID.ToStr());
        if (!pComp->ControllerIsAssigned()) throwExceptionMacro("Error: cannot determine parameter value type; controller of component is not assigned. Please ensure a valid setup. Parameter IDPath: "<<paramID.ToStr());

        GenericComponentController* pController = ControllerCentral::GetController(pComp->GetControllerID());

        if (!pController) throwExceptionMacro("Error: cannot find controller specified be component. Parameter IDPath: "<<paramID.ToStr()<<"; ControllerID: "<<pComp->GetControllerID());

        CtrlProfile::Parameter* pParamProfile = pController->GetProfile(0)->Parameters().GetElement(paramID.GetParameterName());
        if (!pParamProfile) throwExceptionMacro("Error: cannot find parameter in the profile of the controller. Parameter IDPath: "<<paramID.ToStr()<<"; ControllerID: "<<pComp->GetControllerID());

        return pParamProfile->GetValueType();
};

}//End of Namespace free

---