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

#include <map>

#include "muParser.h"

namespace FREE
{




void
SetupParameterTraitsGenerator::
ResetParameterConstraints()
{
  this->m_Constraints.Reset();
  this->m_bTraitsInitialized = false;
};

void
SetupParameterTraitsGenerator::
AddParameterConstraint(const SetupParameterConstraint& constraint)
{
  this->m_Constraints.AddElement(constraint);
  this->m_bTraitsInitialized = false;
};

void
SetupParameterTraitsGenerator::
AddParameterConstraints(const SetupParameterConstraints& constraints)
{
  this->m_Constraints.AddElements(constraints);
  this->m_bTraitsInitialized = false;
};


SetupParameterTraitsGenerator::
SetupParameterTraitsGenerator()
{
        this->m_bTraitsInitialized = false;
  this->m_Constraints.Reset();
};

void
SetupParameterTraitsGenerator::
AddParameterTypes(const ParameterTypeList& typeList)
{
        this->m_ParameterTypes = typeList;
};


SetupParameterTraitsGenerator::ParameterTraitsList
SetupParameterTraitsGenerator::
ComputeParametersTraits( const ParametersType & p, ParametersType& validP) const
{
        if (m_ParameterTypes.size()!=p.size()) throwExceptionMacro("Size of the saved parameter type list and the passed value vector are not equal. Ensure same size to allow a proper computation; check if type list was properly initialized befor calling this function.");
        return ComputeParametersTraits(this->m_ParameterTypes,p,validP);
}

SetupParameterTraitsGenerator::ParameterTraitsList
SetupParameterTraitsGenerator::
ComputeParametersTraits( const ParameterTypeList& typeList, const ParametersType & p,
                                                                                                 ParametersType& validP) const
{
  ParameterTraitsList result;
        m_iNumberOfParameters = typeList.size();
        
        if (m_iNumberOfParameters!=p.size()) throwExceptionMacro("Size of the parameter type list and the value vector are not equal. Ensure same size to allow a proper computation.");

  if (!m_bTraitsInitialized)
  {  //compute sequence of the parameter
    m_ParameterOrder = GetParameterOrder();
    this->m_bTraitsInitialized = true;
  }

  m_TempParamValues = p;

  for (ParameterIDsType::const_iterator pos = m_ParameterOrder.begin(); pos!=m_ParameterOrder.end(); ++pos)
  { //search
    SetupParameterConstraintList paramCnstr= m_Constraints.GetElementsByDestination(*pos);

    SetupParameterTraits traits = ComputeTraits(*pos, typeList[*pos], m_TempParamValues[*pos], paramCnstr);

    result.push_back(traits);

    m_TempParamValues[*pos] = traits.InitialValue();
  }

  validP = m_TempParamValues;
  return result;
};

SetupParameterTraitsGenerator::ParameterIDsType
SetupParameterTraitsGenerator::
GetParameterOrder() const
{
  ParameterIDsType list;
  ParameterIDsType sortedList;

  for (unsigned int iIndex=0; iIndex<m_iNumberOfParameters; iIndex++)
  {
    list.push_back(iIndex);
  }

  typedef std::pair<int,int> LookUpPair;
  typedef std::multimap<int,int> LookUpList;
  LookUpList cnstrLookUp;

  // break up constraints to every contributing constraint parameter
  for (unsigned int iIndex=0; iIndex<this->m_Constraints.Size(); iIndex++)
  {
    const SetupParameterConstraint* pConstraint = m_Constraints.GetElement(iIndex);
    const SetupParameterConstraint::ParameterIDsType& constraintParams = pConstraint->GetConstraintParameters();
    for (unsigned int iIndex2=0; iIndex2<constraintParams.size(); iIndex2++)
    {
      cnstrLookUp.insert(LookUpPair(pConstraint->GetDestinationID(), constraintParams[iIndex2]));
    }
  }

  //begin with the order computation
  while (list.size())
  {
    bool bIndependetFound = false;

    for (unsigned int iIndex = 0; iIndex<list.size(); iIndex++)
    {
      if (cnstrLookUp.find(list[iIndex]) == cnstrLookUp.end())
      { //there is no constraint for this parameter, so it will
        //be the next independent parameter
        bIndependetFound = true;
        int cnstrID = list[iIndex]; 
        sortedList.push_back(cnstrID);
        list.erase(list.begin()+iIndex);

        //remove every element from the look up where this parameter
        // is the constraint element, because now it has a value, so
        // parameters depending, can also be evaluated.
        //
        // Would be faster if set pos to the return of cnstrLookUp.erease(pos)
        // but cygwin gcc had problems compiling, so choosen a statement that
        // could be compiled by gcc and vc++, even if it lacks performance and
        // elegance *sigh*}
        LookUpList::iterator pos = cnstrLookUp.begin();
        while (pos != cnstrLookUp.end())
        {
          if (pos->second == cnstrID)
          {
            cnstrLookUp.erase(pos);
            pos = cnstrLookUp.begin();
          }
          else
          {
            ++pos;
          }
        }

        break; //skip for loop start all over again
      }
    }

    if (!bIndependetFound) throwExceptionMacro("Error. Constraints for parameters are circular dependent.");
  }

  return sortedList;
};

SetupParameterTraits
SetupParameterTraitsGenerator::
ComputeTraits(const int& iParamID, const Parameter::ParameterValueType& parameterType,
                                                        const double& dValue, const SetupParameterConstraintList& constraints) const
{
  double dInitialValue = dValue;
  double dLowerBound = itk::NumericTraits< double >::NonpositiveMin();
  bool bBoundedBelow = false;
  double dUpperBound = itk::NumericTraits< double >::max();
  bool bBoundedAbove = false;
  double dQuantisation = 0.0;

  if (parameterType == Parameter::PVTInteger) dQuantisation = 1.0;

  //Check the constraints

  for (SetupParameterConstraintList::const_iterator pos = constraints.begin(); pos!=constraints.end(); ++pos)
  {
    //evaluate constraint term
    double dConstraintValue = 0.0;

    mu::Parser parser;
    //define variable for parser
    const SetupParameterConstraint::ParameterIDsType& sourceIDs = (*pos)->GetConstraintParameters();
    
    for (unsigned int iIndex = 0; iIndex<sourceIDs.size(); iIndex++)
    {
      if ((sourceIDs[iIndex]<0) || (sourceIDs[iIndex]>=m_iNumberOfParameters))
        throwExceptionMacro("Error. Invalid parameter ID. ID in constraint term is out of bound. Invalid ID: " << sourceIDs[iIndex] <<"; number of available parameters: " << this->m_iNumberOfParameters);
      
      parser.DefineVar("_"+Convert::ToStr(sourceIDs[iIndex]),&(m_TempParamValues[sourceIDs[iIndex]]));
    }

    parser.SetExpr((*pos)->GetConstraintTerm());

    try
    {
      dConstraintValue = parser.Eval();
    }
    catch(mu::Parser::exception_type &e)
    {
      std::string sE = e.GetMsg();
                  std::string sLocation;
                  GetClassLocationMacro( sLocation );
      FREE::LogException("muParser based exception", sE, sLocation); \
                  throw FREE::ExceptionBase( "muParser exception", "Error: "+sE, sLocation, __FILE__, __LINE__); \
    }
    catchAllNPassMacro("Error while evaluating constrained term by muParser");

    //evaluate constraint
    if ((*pos)->GetRelationType() == SetupParameterConstraint::RTEqual)
    {
      dInitialValue = dConstraintValue;
    }
    else if ((*pos)->GetRelationType() == SetupParameterConstraint::RTGreaterOrEqual)
    {
      if (dLowerBound < dConstraintValue)
      {
        dLowerBound = dConstraintValue;
        bBoundedBelow = true;
      }
    }
    else if ((*pos)->GetRelationType() == SetupParameterConstraint::RTLesserOrEqual)
    {
      if (dUpperBound > dConstraintValue)
      {
        dUpperBound = dConstraintValue;
        bBoundedAbove = true;
      }
    }
  }

  //check value for bound violation
  unsigned int iBoundViolation = 0;
  if (dInitialValue < dLowerBound)
  {
    dInitialValue = dLowerBound;
    iBoundViolation++;
  }
  if (dInitialValue > dUpperBound)
  {
    dInitialValue = dUpperBound;
    iBoundViolation++;
  }

  if (iBoundViolation>1) throwExceptionMacro("Error. Both parameter bound overlap. Parameter ID: "<<iParamID<<"; lower bound: "<<dLowerBound<<"; upper bound: "<<dUpperBound);

        if ((parameterType == Parameter::PVTInteger) || (parameterType == Parameter::PVTLong) || (parameterType == Parameter::PVTULong)) dInitialValue = floor(dInitialValue);

  return SetupParameterTraits(dInitialValue, parameterType, dLowerBound, bBoundedBelow,
                              dUpperBound, bBoundedAbove, dQuantisation);
};

}//End of Namespace free

---