freImageClassificationSOMetricThread.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: freImageClassificationSOMetricThread.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 __freImageClassificationSOMetricThread_txx
#define __freImageClassificationSOMetricThread_txx

#include "freImageClassificationSOMetricThread.h"

#include "freSessionProcessor.h"
#include "freImageSampleCharacteristicsCalculator.h"

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

namespace FREE
{

template <unsigned int VImageDimension>
void
ImageClassificationSOMetricThread<VImageDimension>:: 
SetResultImagePath(const IDPath& path)
{
  this->LockExecutionMutex();
    this->m_ResultImagePath = path;
  this->UnlockExecutionMutex();
};

template <unsigned int VImageDimension>
const IDPath&
ImageClassificationSOMetricThread<VImageDimension>:: 
GetResultImagePath() const {return m_ResultImagePath;};

template <unsigned int VImageDimension>
void
ImageClassificationSOMetricThread<VImageDimension>:: 
SetReferenceImagePath(const IDPath& path)
{
  this->LockExecutionMutex();
    this->m_ReferenceImagePath = path;
  this->UnlockExecutionMutex();
};

template <unsigned int VImageDimension>
const IDPath&
ImageClassificationSOMetricThread<VImageDimension>:: 
GetReferenceImagePath() const {return m_ReferenceImagePath;};

template <unsigned int VImageDimension>
void
ImageClassificationSOMetricThread<VImageDimension>:: 
SetLowerClassThreshold(const double& dLower)
{
  this->LockExecutionMutex();
    this->m_dLower = dLower;
  this->UnlockExecutionMutex();
};

template <unsigned int VImageDimension>
const double&
ImageClassificationSOMetricThread<VImageDimension>:: 
GetLowerClassThreshold() const {return m_dLower;};

template <unsigned int VImageDimension>
void
ImageClassificationSOMetricThread<VImageDimension>:: 
SetUpperClassThreshold(const double& dUpper)
{
  this->LockExecutionMutex();
    this->m_dUpper = dUpper;
  this->UnlockExecutionMutex();
};

template <unsigned int VImageDimension>
const double&
ImageClassificationSOMetricThread<VImageDimension>:: 
GetUpperClassThreshold() const {return m_dUpper;};

template <unsigned int VImageDimension>
ImageClassificationSOMetricThread<VImageDimension>:: 
ImageClassificationSOMetricThread()
{
  m_ReferenceImagePath.Reset();
  m_ResultImagePath.Reset();
  m_dUpper = 0;
  m_dLower = 0;
};

template <unsigned int VImageDimension>
ImageClassificationSOMetricThread<VImageDimension>:: 
~ImageClassificationSOMetricThread() {};

template <unsigned int VImageDimension>
bool
ImageClassificationSOMetricThread<VImageDimension>:: 
ProcessSetup(Setup* pAdaptationSetup) throw()
{
  bool result = false;

  ControllerCentral::AddOnProgressEvent(this->m_EvaluatedSessionProgressEvent);

  SessionProcessor processor;

  try
        {

    processor.SetSetup(pAdaptationSetup);
    processor.DefineOutput("resultImage", this->m_ResultImagePath);

    processor.InitializeSession();
        
    this->m_EvaluatedSessionProgressEvent->SetACR(processor.GetSessionInfo()->GetSessionCache());

    clock_t start = clock();

    typename ImageType::Pointer smpResult = processor.GetCastedOutput<ImageType>("resultImage");
                
    clock_t stop = clock();
    double dDuration = (stop-start) / (CLOCKS_PER_SEC/10); //convert clocks to thenth second

    //evaluating registration result
    typename ImageType::Pointer smpReference = NULL;

    if (m_ReferenceImagePath.IsEmpty()) throwExceptionMacro("Error: Reference image path is null, but should be used to measure the adaptation. Ensure correct initialisation of the metric.");
    try
    {
      typename SessionAccessor::GenericMediaPointer smpGenReference = SessionAccessor::GetMedia(m_ReferenceImagePath, processor.GetSessionInfo());
      smpReference = static_cast<ImageType*>(smpGenReference.GetPointer());
    }
    catchAllNPassMacro("Error: cannot retrieve reference image. Ensure correct IDPath. Used path: "<<m_ReferenceImagePath.ToStr());

    if (smpResult->GetLargestPossibleRegion() != smpReference->GetLargestPossibleRegion()) throwExceptionMacro("Error: Reference and result image must have the same largest possible region! reference: " <<smpReference->GetLargestPossibleRegion()<<" result: "<<smpResult->GetLargestPossibleRegion());

    EvaluateResult(smpResult, smpReference);
                m_Results.SetDuration((unsigned long)dDuration);

    result = true;
        }
        catch( FREE::ExceptionBase & err ) 
        { 
                this->m_FailureComment = std::string(err.what());
        } 
        catch(...)
        {
                this->m_FailureComment = "unkown error";
        }

  processor.ResetSession();

  ControllerCentral::RemoveOnProgressEvent(m_EvaluatedSessionProgressEvent);

  return result;
};

template <unsigned int VImageDimension>
void
ImageClassificationSOMetricThread<VImageDimension>:: 
EvaluateResult(ImageType* pResultImage, ImageType* pReferenceImage)
{
        unsigned long lTP = 0;
        unsigned long lFP = 0;
        unsigned long lTN = 0;
        unsigned long lFN = 0;

  typedef itk::ImageRegionConstIterator<ImageType> ImageIterator;
        ImageIterator resultIt(pResultImage,pResultImage->GetBufferedRegion());
        ImageIterator referenceIt(pReferenceImage,pReferenceImage->GetBufferedRegion());

  referenceIt.GoToBegin();
  for ( resultIt.GoToBegin(); !resultIt.IsAtEnd(); ++resultIt, ++referenceIt )
        {
    typename ImageType::PixelType resultPixel = resultIt.Get();
    typename ImageType::PixelType referencePixel = referenceIt.Get();

    bool referenceClass = (referencePixel>=m_dLower) && (referencePixel<=m_dUpper);
    bool resultClass = (resultPixel>=m_dLower) && (resultPixel<=m_dUpper);

    if (resultClass)
    {
      if (referenceClass) lTP++;
      else lFP++;
    }
    else
    {
      if (!referenceClass) lTN++;
      else lFN++;
    }
        }

  this->m_Results.SetTP(lTP);
  this->m_Results.SetFP(lFP);
  this->m_Results.SetTN(lTN);
  this->m_Results.SetFN(lFN);
};

} // end namespace FREE

#endif

---