freConstrainedAccuracySOMetricController.h

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: freConstrainedAccuracySOMetricController.h,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.

=========================================================================*/
#ifndef __freConstrainedAccuracySOMetricController_h
#define __freConstrainedAccuracySOMetricController_h

#include "freAccuracySOMetricController.h"

#include "freConstrainedAccuracySOMetric.h"

namespace FREE
{

freControllerIDMacro(ConstrainedAccuracySOMetricControllerBase, "ConstrainedAccuracySOMetricBase");
template <class TControlledMetric>
class ConstrainedAccuracySOMetricControllerBase : public AccuracySOMetricControllerBase<TControlledMetric>
{
public:  
  DeclareParameterMacro(MaxConstraintPenalty);
  DeclareParameterMacro(FailureThreshold);
  DeclareParameterMacro(Constraints);

        typedef TControlledMetric ComponentType;
  typedef AccuracySOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ConstrainedAccuracySOMetricControllerBase, AccuracySOMetricControllerBase);

protected:
        ConstrainedAccuracySOMetricControllerBase()
        {
                //Profile settings
                this->UpdateControllerID(ControllerID::ConstrainedSetupOptimizationMetricControllerBase);
                this->UpdateControllerID(ControllerID::AccuracySOMetricControllerBase);
                this->UpdateControllerID(ControllerID::ConstrainedAccuracySOMetricControllerBase);
                this->m_Description = "Base class for accuracy registration metric which supports constraints.";
        };

  virtual void GenerateProfile(CtrlProfile::ControllerProfile& profile,
                  const SessionComponentCache* pComponentCache,
                  bool bRegardOldSetup) const
  {
    Superclass::GenerateProfile(profile,pComponentCache,bRegardOldSetup);

                //Parameters
                profile.Parameters().AddParameter(cParam_Constraints,CtrlProfile::Parameter::PVTString,cParamDsc_Constraints,4,"",-1);
                profile.Parameters().AddParameter(cParam_MaxConstraintPenalty,CtrlProfile::Parameter::PVTDouble,cParamDsc_MaxConstraintPenalty,1,"0");
                profile.Parameters().AddParameter(cParam_FailureThreshold,CtrlProfile::Parameter::PVTDouble,cParamDsc_FailureThreshold,1,"0.0");
  };

        virtual void ActualizeMainComponent(ComponentType* pMainComponent,
                                      SessionComponentCache* pComponentCache,
                                      SessionInfo* pSessionInfo,
                                                                                                                                                        const unsigned int& iActLevel) const
        {
                Superclass::ActualizeMainComponent(pMainComponent, pComponentCache,
                                                                                                                                                         pSessionInfo, iActLevel);

                double dMaxPenalty;
                double dThreshold;

    Parameter::Pointer smpConstraints = SessionAccessor::GetParameter(pComponentCache,cParam_Constraints);
                if (smpConstraints.IsNull()) throwExceptionMacro("Missing parameter: " << cParam_Constraints);

                for (unsigned int index = 0; index < smpConstraints->LayerCount(); index++)
                {
                        int iParamID;
                        std::string sRelationType;
                        std::string sTerm;
                        double dBarrierSize;

                        if (!smpConstraints->GetParameterValue(iParamID,0,index)) throwExceptionMacro("Faulty parameter; cannot retrieve parameter id. constraint #: " << index);
                        if (!smpConstraints->GetParameterValue(sRelationType,1,index)) throwExceptionMacro("Faulty parameter; cannot retrieve relation type. constraint #: " << index);
                        if (!smpConstraints->GetParameterValue(sTerm,2,index)) throwExceptionMacro("Faulty parameter; cannot retrieve constraint term. constraint #: " << index);
                        if (!smpConstraints->GetParameterValue(dBarrierSize,3,index)) throwExceptionMacro("Faulty parameter; cannot retrieve barrier size. constraint #: " << index);

      SetupParameterConstraint::Pointer smpNewCnstr = SetupParameterConstraint::New(iParamID,Convert::ToRelationType(sRelationType),sTerm);
                        pMainComponent->AddConstraint(*(smpNewCnstr.GetPointer()),dBarrierSize);
                }

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_MaxConstraintPenalty,dMaxPenalty);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_FailureThreshold,dThreshold);
    }
    catchAllNPassMacro("Error while retrieving parameter values.");    

                pMainComponent->SetMaxConstraintPenalty(dMaxPenalty);
                pMainComponent->SetFailureThreshold(dThreshold);
        };

        void
        SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
        {
                typename ComponentType::DecomposedMeasureType values = pMainComponent->GetCurrentDecomposedValue();

                std::string sIDPath = pMainComponentCache->GetIDPath();
                StatisticValueDefinition* pEntry = rDictionary.GetValueDefinitionByName(sIDPath,"mean error");
            
                if (!pEntry) //Entry is not recorded yet, so do so.
                {
                        pEntry = rDictionary.AddValueDefinition(sIDPath,"mean error", "mean error of the registration.");
                        rDictionary.AddValueDefinition(sIDPath,"std error", "standard deviation of the error.");
                        rDictionary.AddValueDefinition(sIDPath,"min error", "minimum error of the registration.");
                        rDictionary.AddValueDefinition(sIDPath,"max error", "maximum error of the registration.");
                        rDictionary.AddValueDefinition(sIDPath,"failure", "number of failed registration.");
                        rDictionary.AddValueDefinition(sIDPath,"unevaluated points", "number of reference points that could not be evaluated.");
                        rDictionary.AddValueDefinition(sIDPath,"mean duration", "mean duration of a registration (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"std duration", "standard deviation of a registration (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"min duration", "minimum duration of a registration (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"max duration", "maximum duration of a registration (tenth of a second).");
  
                        for (unsigned int i = 0; i<values.Size()-10; i++)
                        {
                                rDictionary.AddValueDefinition(sIDPath,"constraint penalty #"+Convert::ToStr(i), "penalty of the constraint #"+Convert::ToStr(i));
                        }
                }
          
                for (unsigned int i = 0; i<values.Size(); i++)
                {
                        rStatisticEntry.AddValue(Convert::ToStr(values[i]),pEntry->GetRefID()+i);
                }
        };

};

template <class TControlledMetric>
const char* const ConstrainedAccuracySOMetricControllerBase<TControlledMetric>::cParam_Constraints = "Constraints";
template <class TControlledMetric>
const char* const ConstrainedAccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_Constraints = "The constraints of the metric. First element is the ID of the constrained parameter, second value indicates the type of relation (0: equal; 1: lesser or equal; 2: greater or equal). The third value is the constraint term. The fourth value is the barrier size.\nParameter IDs, if used in the term have an underscore as prefix.\nExample: 1 | 2 | (_2 * 4) + _3\nBy this constrained parameter 1 should be greater or equal four times parameter 2 + parameter 3.";

template <class TControlledMetric>
const char* const ConstrainedAccuracySOMetricControllerBase<TControlledMetric>::cParam_MaxConstraintPenalty = "MaxConstraintPenalty";
template <class TControlledMetric>
const char* const ConstrainedAccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_MaxConstraintPenalty = "Maximum penalty the barrier function of a constraint can return. This value will be scaled be metric scales, if there is any defined for a constrained.";

template <class TControlledMetric>
const char* const ConstrainedAccuracySOMetricControllerBase<TControlledMetric>::cParam_FailureThreshold = "FailureThreshold";
template <class TControlledMetric>
const char* const ConstrainedAccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_FailureThreshold = "Threshold for the penalty computation, if the penalty is equal or above this threshold, the computation will be accounted as a failure. No evaluations of the adaptations will be done. A value of 0.0 or less deactivates the threshold.";

freControllerIDMacro(ConstrainedAccuracy2DSOMetricController, "Constrained Accuracy 2D SO Metric");

class ConstrainedAccuracy2DSOMetricController : public ConstrainedAccuracySOMetricControllerBase< ConstrainedAccuracySOMetric<2> >
{
public:  
  typedef ConstrainedAccuracySOMetric<2> ComponentType;
  typedef ConstrainedAccuracySOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ConstrainedAccuracy2DSOMetricController, ConstrainedAccuracySOMetricControllerBase);

  ConstrainedAccuracy2DSOMetricController();

};

freControllerIDMacro(ConstrainedAccuracy3DSOMetricController, "Constrained Accuracy 3D SO Metric");

class ConstrainedAccuracy3DSOMetricController : public ConstrainedAccuracySOMetricControllerBase< ConstrainedAccuracySOMetric<3> >
{
public:  
  typedef ConstrainedAccuracySOMetric<3> ComponentType;
  typedef ConstrainedAccuracySOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ConstrainedAccuracy3DSOMetricController, ConstrainedAccuracySOMetricControllerBase);

  ConstrainedAccuracy3DSOMetricController();

};

} //end of namespace free

#endif

---