freAccuracySOMetricController.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: freAccuracySOMetricController.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 __freAccuracySOMetricController_h
#define __freAccuracySOMetricController_h

#include "freSetupOptimizationMultiThreadMetricControllerBase.h"

#include "freAccuracySOMetric.h"

namespace FREE
{

        freControllerIDMacro(AccuracySOMetricControllerBase, "AccuracySOMetricBase");
template <class TControlledMetric>
class AccuracySOMetricControllerBase : public SetupOptimizationMultiThreadMetricControllerBase<TControlledMetric>
{
public:  
  DeclareParameterMacro(UseField);
  DeclareParameterMacro(ComputeAdaptationMean);
  DeclareParameterMacro(ResultField);
  DeclareParameterMacro(ReferenceField);
  DeclareParameterMacro(ReferencePoints);
  DeclareParameterMacro(MovingPoints);

        typedef TControlledMetric ComponentType;
  typedef SetupOptimizationMultiThreadMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(AccuracySOMetricControllerBase, SetupOptimizationMultiThreadMetricControllerBase);

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

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

                //Parameters
    profile.Parameters().AddParameter(Superclass::cParam_MetricScales,CtrlProfile::Parameter::PVTDouble,Superclass::cParamDsc_MetricScales,9,"1.0");
                profile.Parameters().AddParameter(cParam_UseField,CtrlProfile::Parameter::PVTBool,cParamDsc_UseField,1,"true");
                profile.Parameters().AddParameter(cParam_ComputeAdaptationMean,CtrlProfile::Parameter::PVTBool,cParamDsc_ComputeAdaptationMean,1,"true");
                profile.Parameters().AddParameter(cParam_ReferenceField,CtrlProfile::Parameter::PVTIDPath,cParamDsc_ReferenceField,1,"");
                profile.Parameters().AddParameter(cParam_ResultField,CtrlProfile::Parameter::PVTIDPath,cParamDsc_ResultField,1,"");
                profile.Parameters().AddParameter(cParam_ReferencePoints,Parameter::PVTIDPath,cParamDsc_ReferencePoints,1,"");
                profile.Parameters().AddParameter(cParam_MovingPoints,CtrlProfile::Parameter::PVTIDPath,cParamDsc_MovingPoints,1,"");
  };

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

                bool bUseField;
    bool bComputeAdaptationMean;
                std::string sTempPath;
                IDPath referenceFieldPath;
                IDPath resultFieldPath;
                IDPath referencePointsPath;
                IDPath movingPointsPath;

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_UseField,bUseField);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ComputeAdaptationMean,bComputeAdaptationMean);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ReferenceField,sTempPath);
                referenceFieldPath = sTempPath;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ResultField,sTempPath);
                resultFieldPath = sTempPath;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ReferencePoints,sTempPath);
                referencePointsPath = sTempPath;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_MovingPoints,sTempPath);
                movingPointsPath = sTempPath;
    }
    catchAllNPassMacro("Error while retrieving parameter values.");    

                pMainComponent->SetUseField(bUseField);
                pMainComponent->SetComputeAdaptationMean(bComputeAdaptationMean);
                pMainComponent->SetReferenceFieldPath(referenceFieldPath);
                pMainComponent->SetReferencePointsPath(referencePointsPath);
                pMainComponent->SetMovingPointsPath(movingPointsPath);
    pMainComponent->SetResultFieldPath(resultFieldPath);
        };

        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.
                {
      if (pMainComponent->GetComputeAdaptationMean())
      {
                          pEntry = rDictionary.AddValueDefinition(sIDPath,"mean adaptation error", "mean of all mean error of all adaptations.");
                          rDictionary.AddValueDefinition(sIDPath,"std dev error", "mean standard deviation of all adaptations.");
      }
      else
      {
                          pEntry = rDictionary.AddValueDefinition(sIDPath,"mean error", "mean error of the processed setup.");
                          rDictionary.AddValueDefinition(sIDPath,"std dev image error", "standard deviation of the error of the processed setup.");
      }
                        rDictionary.AddValueDefinition(sIDPath,"min adaptation error", "minimum error of the processed setup.");
                        rDictionary.AddValueDefinition(sIDPath,"max adaptation error", "maximum error of the processed setup.");
                        rDictionary.AddValueDefinition(sIDPath,"failure", "number of failed processings.");
                        rDictionary.AddValueDefinition(sIDPath,"unevaluated points", "number of reference points that could not be evaluated.");
                        rDictionary.AddValueDefinition(sIDPath,"mean duration", "mean duration of processing the setup (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"std duration", "standard deviation of processing the setup (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"min duration", "minimum duration of processing the setup (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"max duration", "maximum duration of processing the setup (tenth of a second).");
                }
          
                for (unsigned int i = 0; i<values.Size(); i++)
                {
                        rStatisticEntry.AddValue(Convert::ToStr(values[i]),pEntry->GetRefID()+i);
                }
        };

};

template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParam_UseField = "UseField";
template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_UseField = "Indicates if the metric should use a reference field or reference points to evaluate accuracy of the registrations.";

template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParam_ComputeAdaptationMean = "ComputeAdaptationMean";
template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_ComputeAdaptationMean = "Indicates how the mean error and standard deviation is calculated. If true, the mean error is the mean of mean errors of all adaptations and std dev is the mean of all std deviations. If false, the mean error is the mean of all point errors or field errors and std dev is his deviation. Both options are equal for the mean error, if all adaptation have the same point count/field size, otherwiese the first option will be biased towards adaptions with larger point count/field size.";

template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParam_ReferenceField = "ReferenceField";
template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_ReferenceField = "IDPath of the reference field within the session of the adapted setups used as test basis. Only required of UseField is true.";

template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParam_ResultField = "ResultField";
template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_ResultField = "IDPath of the result field of the processed session of the adapted setups used as test basis. This path is always required.";

template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParam_ReferencePoints = "ReferencePoints";
template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_ReferencePoints = "IDPath of the reference points within the session of the adapted setups used as test basis. Only required of UseField is false.";

template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParam_MovingPoints = "MovingPoints";
template <class TControlledMetric>
const char* const AccuracySOMetricControllerBase<TControlledMetric>::cParamDsc_MovingPoints = "IDPath of the reference field within the session of the adapted setups used as test basis. Only required of UseField is false.";

        freControllerIDMacro(Accuracy2DSOMetricController, "Accuracy 2D SO Metric");
class Accuracy2DSOMetricController : public AccuracySOMetricControllerBase< AccuracySOMetric<2> >
{
public:  
  typedef AccuracySOMetric<2> ComponentType;
  typedef AccuracySOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(Accuracy2DSOMetricController, AccuracySOMetricControllerBase);

  Accuracy2DSOMetricController();

};

        freControllerIDMacro(Accuracy3DSOMetricController, "Accuracy 3D SO Metric");
class Accuracy3DSOMetricController : public AccuracySOMetricControllerBase< AccuracySOMetric<3> >
{
public:  
  typedef AccuracySOMetric<3> ComponentType;
  typedef AccuracySOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(Accuracy3DSOMetricController, AccuracySOMetricControllerBase);

  Accuracy3DSOMetricController();

};

} //end of namespace free

#endif

---