freImageClassificationSOMetric.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: freImageClassificationSOMetric.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 __freImageClassificationSOMetric_txx
#define __freImageClassificationSOMetric_txx

#include "freImageClassificationSOMetric.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
ImageClassificationSOMetric<VImageDimension>::
SetReferenceImagePath(const IDPath& path)
{
  itkDebugMacro("setting ReferenceImagePath to " << path.ToStr() );
  this->m_ReferenceImagePath = path;
  this->Modified(); \
};

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

template <unsigned int VImageDimension>
ImageClassificationSOMetric<VImageDimension>::
ImageClassificationSOMetric()
{
  m_ResultImagePath.Reset();
  m_ReferenceImagePath.Reset();
  m_FMeasureWeight = 0.0;
};

template <unsigned int VImageDimension>
void
ImageClassificationSOMetric<VImageDimension>::
InitializeValueComputation() const
{
                m_dSensitivityMean = 0.0;
                m_dSensitivityDev = 0.0;
                m_dMinSensitivity = itk::NumericTraits< double >::max();
                m_dMaxSensitivity = 0.0;

                m_dSpecMean = 0.0;
                m_dSpecDev = 0.0;
                m_dMinSpec = itk::NumericTraits< double >::max();
                m_dMaxSpec = 0.0;

    m_dPPVMean = 0.0;
                m_dPPVDev = 0.0;
                m_dMinPPV = itk::NumericTraits< double >::max();
                m_dMaxPPV = 0.0;

                m_dNPVMean = 0.0;
                m_dNPVDev = 0.0;
                m_dMinNPV = itk::NumericTraits< double >::max();
                m_dMaxNPV = 0.0;

                m_dFMMean = 0.0;
                m_dFMDev = 0.0;
                m_dMinFM = itk::NumericTraits< double >::max();
                m_dMaxFM = 0.0;

    m_lFailedProcessings = 0;

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

                m_TPs.clear();
                m_FPs.clear();
                m_TNs.clear();
                m_FNs.clear();
                m_Durations.clear();
};

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

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

template <unsigned int VImageDimension>
typename ImageClassificationSOMetric<VImageDimension>::DecomposedMeasureType
ImageClassificationSOMetric<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);

    this->m_TPs.push_back(results.GetTP());
    this->m_FPs.push_back(results.GetFP());
    this->m_TNs.push_back(results.GetTN());
    this->m_FNs.push_back(results.GetFN());
    this->m_Durations.push_back(results.GetDuration());
  }

  std::vector<double> sensitivities;
  std::vector<double> specitifities;
  std::vector<double> ppvs;
  std::vector<double> npvs;
  std::vector<double> fms;

  try
  {
    for (unsigned int iIndex=0; iIndex<evaluations.size(); iIndex++)
    {
      double dSensitivity = double(m_TPs[iIndex])/double(m_TPs[iIndex]+m_FNs[iIndex]);
      double dSpecifity = double(m_TNs[iIndex])/double(m_FPs[iIndex]+m_TNs[iIndex]);
      double dPPV = double(m_TPs[iIndex])/double(m_TPs[iIndex]+m_FPs[iIndex]);
      double dNPV = double(m_TNs[iIndex])/double(m_TNs[iIndex]+m_FNs[iIndex]);

      if (m_TPs[iIndex]+m_FNs[iIndex]==0) dSensitivity = 1.0;
      if (m_FPs[iIndex]+m_TNs[iIndex]==0) dSpecifity = 1.0;
      if (m_TPs[iIndex]+m_FPs[iIndex]==0) dPPV = 1.0;
      if (m_TNs[iIndex]+m_FNs[iIndex]==0) dNPV = 1.0;

      double dFMeasure = ((1+m_FMeasureWeight)*(dPPV*dSensitivity))/((m_FMeasureWeight*dPPV)+dSensitivity);

      if (dPPV+dSensitivity==0) dFMeasure = 0.0;

      m_dSensitivityMean += dSensitivity;
      m_dSpecMean += dSpecifity;
      m_dPPVMean += dPPV;
      m_dNPVMean += dNPV;
      m_dFMMean += dFMeasure;

      sensitivities.push_back(dSensitivity);
      specitifities.push_back(dSpecifity);
      ppvs.push_back(dPPV);
      npvs.push_back(dNPV);
      fms.push_back(dFMeasure);

      if (dSensitivity<m_dMinSensitivity) m_dMinSensitivity = dSensitivity;
      else if (dSensitivity>m_dMaxSensitivity) m_dMaxSensitivity = dSensitivity;

      if (dSpecifity<m_dMinSpec) m_dMinSpec = dSpecifity;
      else if (dSpecifity>m_dMaxSpec) m_dMaxSpec = dSpecifity;

      if (dPPV<m_dMinPPV) m_dMinPPV = dPPV;
      else if (dPPV>m_dMaxPPV) m_dMaxPPV = dPPV;

      if (dNPV<m_dMinNPV) m_dMinNPV = dNPV;
      else if (dNPV>m_dMaxNPV) m_dMaxNPV = dNPV;

      if (dFMeasure<m_dMinFM) m_dMinFM = dFMeasure;
      else if (dFMeasure>m_dMaxFM) m_dMaxFM = dFMeasure;
    }

    if (evaluations.size()==0)
    { //there was no test case, at least no successfully evaluated test case
      m_dMinSensitivity = 0.0;
      m_dMinSpec = 0.0;
      m_dMinPPV = 0.0;
      m_dMinNPV = 0.0;
      m_dMinFM = 0.0;
    }
    else
    { //mean calculation
      m_dSensitivityMean /= evaluations.size();
      m_dSpecMean /= evaluations.size();
      m_dPPVMean /= evaluations.size();
      m_dNPVMean /= evaluations.size();
      m_dFMMean /= evaluations.size();
    }

    if (evaluations.size()>1)
    { //compute std def
      for (unsigned int iIndex=0; iIndex<evaluations.size(); iIndex++)
      {
        m_dSensitivityDev += (sensitivities[iIndex] - m_dSensitivityMean)*(sensitivities[iIndex] - m_dSensitivityMean);
        m_dSpecDev += (specitifities[iIndex] - m_dSpecMean)*(specitifities[iIndex] - m_dSpecMean);
        m_dPPVDev += (ppvs[iIndex] - m_dPPVMean)*(ppvs[iIndex] - m_dPPVMean);
        m_dNPVDev += (npvs[iIndex] - m_dNPVMean)*(npvs[iIndex] - m_dNPVMean);
        m_dFMDev += (fms[iIndex] - m_dFMMean)*(fms[iIndex] - m_dFMMean);
      }

      m_dSensitivityDev = sqrt(m_dSensitivityDev / (evaluations.size()-1));
      m_dSpecDev = sqrt(m_dSpecDev / (evaluations.size()-1));
      m_dPPVDev = sqrt(m_dPPVDev / (evaluations.size()-1));
      m_dNPVDev = sqrt(m_dNPVDev / (evaluations.size()-1));
      m_dFMDev = sqrt(m_dFMDev / (evaluations.size()-1));
    }
  }
  catchAllNPassMacro("Unkown error while computing the statistical measures.");

  try
  {
    //Calculate mean duration and
    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(25);

  results.SetElement(0,m_dSensitivityMean);
  results.SetElement(1,m_dSensitivityDev);
  results.SetElement(2,m_dMinSensitivity);
  results.SetElement(3,m_dMaxSensitivity);
  results.SetElement(4,m_dSpecMean);
  results.SetElement(5,m_dSpecDev);
  results.SetElement(6,m_dMinSpec);
  results.SetElement(7,m_dMaxSpec);
  results.SetElement(8,m_dPPVMean);
  results.SetElement(9,m_dPPVDev);
  results.SetElement(10,m_dMinPPV);
  results.SetElement(11,m_dMaxPPV);
  results.SetElement(12,m_dNPVMean);
  results.SetElement(13,m_dNPVDev);
  results.SetElement(14,m_dMinNPV);
  results.SetElement(15,m_dMaxNPV);
  results.SetElement(16,m_dFMMean);
  results.SetElement(17,m_dFMDev);
  results.SetElement(18,m_dMinFM);
  results.SetElement(19,m_dMaxFM);
  results.SetElement(20,m_lFailedProcessings);
  results.SetElement(21,m_dDurMean);
  results.SetElement(22,m_dDurDev);
  results.SetElement(23,m_dMinDur);
  results.SetElement(24,m_dMaxDur);

  return results;
};

} // end namespace FREE

#endif

---