freImageDifferenceSOMetricThread.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: freImageDifferenceSOMetricThread.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 __freImageDifferenceSOMetricThread_txx
#define __freImageDifferenceSOMetricThread_txx

#include "freImageDifferenceSOMetricThread.h"

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

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

namespace FREE
{

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

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

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

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

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

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

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

  ControllerCentral::AddOnProgressEvent(this->m_EvaluatedSessionProgressEvent);

  try
        {
    SessionProcessor processor;

    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());

    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";
        }

  ControllerCentral::RemoveOnProgressEvent(m_EvaluatedSessionProgressEvent);

  return result;
};

template <unsigned int VImageDimension>
void
ImageDifferenceSOMetricThread<VImageDimension>:: 
EvaluateResult(ImageType* pResultImage, ImageType* pReferenceImage)
{
  //calculating difference between reference and final image
        typedef itk::AbsoluteValueDifferenceImageFilter< ImageType, ImageType, ImageType > AbsDiffFilterType;
        typename AbsDiffFilterType::Pointer smpDiffFilter = AbsDiffFilterType::New();

        smpDiffFilter->SetInput1(pReferenceImage);
        smpDiffFilter->SetInput2(pResultImage);
        smpDiffFilter->Update();
  typename ImageType::Pointer smpDifImage = smpDiffFilter->GetOutput();

        //computing mean and variance of the field difference
        typedef ImageSampleCharacteristicsCalculator<ImageType> CharCalculator;

  CharCalculator calculator;
        calculator.SetImage(smpDifImage);
        calculator.Compute();

        this->m_Results.SetError(calculator.GetMean());
        this->m_Results.SetVariance(calculator.GetVariance());
        this->m_Results.SetSamplesize(pResultImage->GetLargestPossibleRegion().GetNumberOfPixels());

        //checking for minimum or maximum and calculate image error;
  double dImageError = 0.0;
  double dMin = itk::NumericTraits< double >::max();
  double dMax = 0.0;

  typedef itk::ImageRegionConstIterator<ImageType> ImageIterator;
        ImageIterator it(smpDifImage,smpDifImage->GetBufferedRegion());

  for ( it.GoToBegin(); !it.IsAtEnd(); ++it )
        {
    dImageError += it.Get();
                if (it.Get()<dMin) dMin = it.Get();
                if (it.Get()>dMax) dMax = it.Get();
        }

  this->m_Results.SetImageError(dImageError);
  this->m_Results.SetMinError(dMin);
  this->m_Results.SetMaxError(dMax);
};

} // end namespace FREE

#endif

---