freImageDifferenceSOMetric.txx

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: freImageDifferenceSOMetric.txx,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 __freImageDifferenceSOMetric_txx
#define __freImageDifferenceSOMetric_txx

#include "freImageDifferenceSOMetric.h"
#include "freGenericSetupToImageAdaptor.h"
#include "freImageSampleCharacteristicsCalculator.h"
#include "freSessionProcessor.h"

#include "freImageIO.h"
#include "itkNumericTraits.h"
#include "itkAbsoluteValueDifferenceImageFilter.h"

#include <time.h>

namespace FREE
{
 
template <unsigned int VImageDimension>
void
ImageDifferenceSOMetric<VImageDimension>::
SetReferenceImagePath(const IDPath& path)
{
  itkDebugMacro("setting ReferenceImagePath to " << path.ToStr() );
  this->m_ReferenceImagePath = path;
  this->Modified(); \
};

template <unsigned int VImageDimension>
void
ImageDifferenceSOMetric<VImageDimension>::
SetResultImagePath(const IDPath& path)
{
  itkDebugMacro("setting ResultImagePath to " << path.ToStr() );
  this->m_ResultImagePath = path;
  this->Modified(); \
};

template <unsigned int VImageDimension>
ImageDifferenceSOMetric<VImageDimension>::
ImageDifferenceSOMetric()
{
  m_ResultImagePath.Reset();
  m_ReferenceImagePath.Reset();
};

template <unsigned int VImageDimension>
void
ImageDifferenceSOMetric<VImageDimension>::
InitializeValueComputation() const
{
                m_dErrorMean = 0.0;
                m_dErrorDev = 0.0;
                m_dMinError = itk::NumericTraits< double >::max();
                m_dMaxError = 0.0;
                m_lFailedProcessings = 0;

                m_dImageErrorMean = 0.0;
                m_dImageErrorDev = 0.0;
                m_dMinImageError = itk::NumericTraits< double >::max();
                m_dMaxImageError = 0.0;

                m_dDurMean = 0.0;
                m_dDurDev = 0.0;
                m_dMinDur = itk::NumericTraits< double >::max();
                m_dMaxDur = 0.0;

                m_Errors.clear();
                m_Vars.clear();
                m_Samplesize.clear();
                m_Durations.clear();
};

template <unsigned int VImageDimension>
void
ImageDifferenceSOMetric<VImageDimension>::
InitializeMonitor(MonitorType& monitor) const
{
  //dont have to initialize anything
};

template <unsigned int VImageDimension>
void
ImageDifferenceSOMetric<VImageDimension>::
InitializeThread(ThreadType& thread) const
{
  thread.SetResultImagePath(this->m_ResultImagePath);
  thread.SetReferenceImagePath(this->m_ReferenceImagePath);
};

template <unsigned int VImageDimension>
typename ImageDifferenceSOMetric<VImageDimension>::DecomposedMeasureType
ImageDifferenceSOMetric<VImageDimension>::
ComputeMeasure(MonitorType& monitor) const
{
  //get all the data from the monitor
  this->m_lFailedProcessings = monitor.GetFailureCount();

  typename MonitorType::AdaptationIDListType evaluations = monitor.GetListOfEvaluatedAdaptations();

  for (typename MonitorType::AdaptationIDListType::const_iterator pos = evaluations.begin(); pos != evaluations.end(); ++pos)
  { //go through all evaluated adaptations and store results;
    EvaluationResultType results;
    monitor.GetAdaptationResults(*pos,results);

    if (this->m_dMinError > results.GetMinError()) this->m_dMinError = results.GetMinError();
    if (this->m_dMaxError < results.GetMaxError()) this->m_dMaxError = results.GetMaxError();

    this->m_Errors.push_back(results.GetError());
    this->m_Vars.push_back(results.GetVariance());
    this->m_ImageErrors.push_back(results.GetImageError());
    this->m_Samplesize.push_back(results.GetSamplesize());
    this->m_Durations.push_back(results.GetDuration());
  }

  //Calculate the mean pixel error of the whole adaptation list
  unsigned long lTotalSamples = 0;

  try
  {
    for (unsigned int iIndex=0; iIndex<m_Errors.size(); iIndex++)
    {
      m_dErrorMean += m_Errors[iIndex] * m_Samplesize[iIndex];
      m_dErrorDev += m_Vars[iIndex] * (m_Samplesize[iIndex]-1);
      lTotalSamples += m_Samplesize[iIndex];
    }

    if (m_Errors.size()==0) m_dMinError = 0.0; //there was no test case, at least no successfully evaluated test case

    if (lTotalSamples>0) m_dErrorMean /= lTotalSamples;
    if (lTotalSamples>1) m_dErrorDev /= lTotalSamples-1;

    m_dErrorDev = sqrt(m_dErrorDev);
  }
  catchAllNPassMacro("Unkown error while computing the pixel error.");

  try
  {
    //Calculate the mean image error of the whole adaptation list
    for (unsigned int iIndex=0; iIndex<m_ImageErrors.size(); iIndex++)
    {
      m_dImageErrorMean += m_ImageErrors[iIndex];
      if (m_ImageErrors[iIndex]<m_dMinImageError) m_dMinImageError = m_ImageErrors[iIndex];
      else if (m_ImageErrors[iIndex]>m_dMaxImageError) m_dMaxImageError = m_ImageErrors[iIndex];
    }
    if (m_ImageErrors.size()!=0) m_dImageErrorMean /= m_ImageErrors.size();

    if (m_ImageErrors.size()>1)
    {
      for (unsigned int iIndex=0; iIndex<m_ImageErrors.size(); iIndex++)
      {
        m_dImageErrorDev += (m_ImageErrors[iIndex]-m_dImageErrorMean)*(m_ImageErrors[iIndex]-m_dImageErrorMean);
      }
      m_dImageErrorDev = sqrt(m_dImageErrorDev/(m_ImageErrors.size()-1));
    }
  }
  catchAllNPassMacro("Unkown error while computing the image error.");

  try
  {
    //Calculate mean duration
    for (unsigned int iIndex=0; iIndex<m_Durations.size(); iIndex++)
    {
      m_dDurMean += m_Durations[iIndex];
      if (m_Durations[iIndex]< m_dMinDur) m_dMinDur = m_Durations[iIndex];
      else if (m_Durations[iIndex]> m_dMaxDur) m_dMaxDur = m_Durations[iIndex];
    }

    if (m_Durations.size()==0) m_dMinDur = 0.0; //there was no test case, at least no successfully evaluated test case
    if (m_Durations.size()>0) m_dDurMean /= m_Durations.size();

    if (m_Durations.size()>1)
    {
      for (unsigned int iIndex=0; iIndex<m_Durations.size(); iIndex++)
      {
        m_dDurDev += (m_Durations[iIndex] - m_dDurMean)*(m_Durations[iIndex] - m_dDurMean);
      }
      m_dDurDev = sqrt(m_dDurDev / (m_Durations.size()-1));
    }
  }
  catchAllNPassMacro("Unkown error while computing the duration.");


  DecomposedMeasureType results(13);

  results.SetElement(0,m_dErrorMean);
  results.SetElement(1,m_dErrorDev);
  results.SetElement(2,m_dMinError);
  results.SetElement(3,m_dMaxError);
  results.SetElement(4,m_dImageErrorMean);
  results.SetElement(5,m_dImageErrorDev);
  results.SetElement(6,m_dMinImageError);
  results.SetElement(7,m_dMaxImageError);
  results.SetElement(8,m_lFailedProcessings);
  results.SetElement(9,m_dDurMean);
  results.SetElement(10,m_dDurDev);
  results.SetElement(11,m_dMinDur);
  results.SetElement(12,m_dMaxDur);

  return results;
};

} // end namespace FREE

#endif

---