frePrecisionSOMetric.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: frePrecisionSOMetric.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 "frePrecisionSOMetric.h"

#include "itkNumericTraits.h"
#include "itkPointSet.h"
#include "itkListSample.h"
#include "itkCovarianceCalculator.h"

namespace FREE
{
 
  void
        PrecisionSOMetric::
	Initialize()
        {
    Superclass::Initialize();

                if (this->m_EvaluationMetric.IsNull()) throwExceptionMacro("Error. Cannot calculate metric value, no evaluation metric set.");
    this->m_EvaluationMetric->SetTransform(this->m_Transform);
    this->m_EvaluationMetric->SetAdaptationList(this->m_smpAdaptations);

                this->m_EvaluationMetric->fnOnEvaluationProgress = fnOnEvaluationProgress;

    this->m_EvaluationMetric->Initialize();

    this->EnlistDictionaryEntries(this->m_MetricStatistic.GetDictionary());
  }

void
PrecisionSOMetric::
EnlistInterimResultsToStatistic(const unsigned int iIndex, const DecomposedMeasureType& results, StatisticEntry& entry) const
{
  entry.AddValue(Convert::ToStr(iIndex),1);

  for (unsigned int iResultIndex = 0; iResultIndex < results.size(); iResultIndex++)
  {
    entry.AddValue(Convert::ToStr(results[iResultIndex]),iResultIndex+2);
  }
};

void
PrecisionSOMetric::
EnlistDictionaryEntries(StatisticDictionary& dictionary) const
{
  dictionary.AddValueDefinition(this->GetNameOfClass(),"Sample #", "Nr of the sample used to estimate the precision");
  unsigned int iValueCount = this->m_EvaluationMetric->GetNumberOfValues();

  for (unsigned int iValueIndex = 0; iValueIndex < iValueCount; iValueIndex++)
  {
    dictionary.AddValueDefinition(this->GetNameOfClass(),"evaluation value #"+Convert::ToStr(iValueIndex), "Value #"+Convert::ToStr(iValueIndex)+" of the evaluation metric.");
  }

  dictionary.AddEntryDefinition(this->GetNameOfClass(),"SampleMetricValues",this->GetNameOfClass(),"Values of a sample of the metric");
};

  PrecisionSOMetric::DecomposedMeasureType
        PrecisionSOMetric::
  ComputeDecomposedValue( const ParametersType & parameters ) const
        {
                if (this->m_smpAdaptations.IsNull()) throwExceptionMacro("Error. Cannot calculate metric value, adaptiation list is null.");
                if (this->m_Transform.IsNull()) throwExceptionMacro("Error. Cannot calculate metric value, no setup transform set.");

                if (this->m_Transform->GetNumberOfParameters() != parameters.size()) throwExceptionMacro("Error. Cannot calculate metric value, number of passed parameters is not equal to the parameter size of the transform. Passed parameter count: "<< parameters.size());

                m_Measures.clear();
    
    for(unsigned long iIndex = 0; iIndex < m_SampleSize; iIndex++)
    { //calculate the measures
                        if (this->fnOnNextAdaptation.IsNotNull()) this->fnOnNextAdaptation->Execute(iIndex,"",(void*)this);
                        this->InvokeEvent( NextAdaptationObserverEvent() );

      StatisticEntry* pNewEntry = m_MetricStatistic.GetData().CreateChildEntry(m_MetricStatistic.GetData().GetCurrentEntryID());
      pNewEntry->SetRefID(m_MetricStatistic.GetDictionary().GetEntryDefinitionByName(this->GetNameOfClass(),"SampleMetricValues")->GetRefID());

      DecomposedMeasureType interimValues = this->m_EvaluationMetric->GetDecomposedValue(parameters);
      m_Measures.push_back(interimValues);

      this->EnlistInterimResultsToStatistic(iIndex,interimValues,*pNewEntry);

      //close entry
      pNewEntry->CloseEntry();

      if (fnOnEvaluationDone.IsNotNull()) fnOnEvaluationDone->Execute(iIndex,"",(void*)this);
      this->InvokeEvent( EvaluationDoneObserverEvent() );
    }

    DecomposedMeasureType results(this->GetNumberOfValues());
    results.fill(0.0);

    if (m_Measures.size())
    {
      unsigned int iResultIndex = 0;

      const unsigned int iMeasureCount = this->m_EvaluationMetric->GetNumberOfValues();
      const unsigned int iMeasurementVectorSize = 1;
      typedef itk::Vector<double,iMeasurementVectorSize> MeasurementVectorType;
      typedef itk::Statistics::ListSample< MeasurementVectorType > SampleType;

      typedef itk::Statistics::CovarianceCalculator< SampleType > CovarianceAlgorithmType;
            CovarianceAlgorithmType::Pointer covarianceAlgorithm = CovarianceAlgorithmType::New();

      for (unsigned int iMeasureIndex = 0; iMeasureIndex < iMeasureCount; iMeasureIndex++)
      { //calculate mean, deviation, min and max for one measure value
        double dMinValue = itk::NumericTraits< double >::max();
        double dMaxValue = itk::NumericTraits< double >::NonpositiveMin();

        SampleType::Pointer smpSample = SampleType::New();
              smpSample->SetMeasurementVectorSize(iMeasurementVectorSize);

        for (unsigned int iPos=0; iPos<m_Measures.size(); iPos++)
        {
          MeasurementVectorType mv;
          mv[0]=(m_Measures[iPos])[iMeasureIndex];
                      smpSample->PushBack(mv);
                      //checking for minimum or maximum duration
                      if (mv[0]<dMinValue) dMinValue = mv[0];
                      if (mv[0]>dMaxValue) dMaxValue = mv[0];
              }

          //Calculate mean and variance
        covarianceAlgorithm->SetInputSample( smpSample );
        covarianceAlgorithm->SetMean( 0 );
        covarianceAlgorithm->Update();

        results.SetElement(iResultIndex++,covarianceAlgorithm->GetMean()->GetElement(0));
        const CovarianceAlgorithmType::OutputType* matrix = covarianceAlgorithm->GetOutput();
        results.SetElement(iResultIndex++,sqrt((*matrix)(0,0)));
        results.SetElement(iResultIndex++,dMinValue);
        results.SetElement(iResultIndex++,dMaxValue);
      }
    }

    return results;
        };

PrecisionSOMetric::
PrecisionSOMetric()
{
  m_SampleSize = 100;
  
  m_EvaluationMetric = 0;
};

unsigned int
PrecisionSOMetric::
GetNumberOfValues(void) const
{
  if (m_EvaluationMetric.IsNotNull())
  {
    return m_EvaluationMetric->GetNumberOfValues()*4;
  }
  return 0;
};

} // end namespace FREE

---