freImageDifferenceSOMetricController.h

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: freImageDifferenceSOMetricController.h,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 __freImageDifferenceSOMetricController_h
#define __freImageDifferenceSOMetricController_h

#include "freSetupOptimizationMultiThreadMetricControllerBase.h"

#include "freImageDifferenceSOMetric.h"

namespace FREE
{

        freControllerIDMacro(ImageDifferenceSOMetricControllerBase, "ImageDifferenceSOMetricBase");
template <class TControlledMetric>
class ImageDifferenceSOMetricControllerBase : public SetupOptimizationMultiThreadMetricControllerBase<TControlledMetric>
{
public:  
  DeclareParameterMacro(ReferenceImage);
  DeclareParameterMacro(ResultImage);

        typedef TControlledMetric ComponentType;
  typedef SetupOptimizationMultiThreadMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ImageDifferenceSOMetricControllerBase, SetupOptimizationMultiThreadMetricControllerBase);

protected:
        ImageDifferenceSOMetricControllerBase()
        {
                //Profile settings
                this->UpdateControllerID(ControllerID::ImageDifferenceSOMetricControllerBase);
                this->m_Description = "Base class for image difference metric.";
        };

  virtual void GenerateProfile(CtrlProfile::ControllerProfile& profile,
                  const SessionComponentCache* pComponentCache,
                  bool bRegardOldSetup) const
  {
    Superclass::GenerateProfile(profile,pComponentCache,bRegardOldSetup);

                //Parameters
    profile.Parameters().AddParameter(Superclass::cParam_MetricScales,CtrlProfile::Parameter::PVTDouble,Superclass::cParamDsc_MetricScales,13,"1.0");
                profile.Parameters().AddParameter(cParam_ReferenceImage,CtrlProfile::Parameter::PVTIDPath,cParamDsc_ReferenceImage,1,"");
                profile.Parameters().AddParameter(cParam_ResultImage,CtrlProfile::Parameter::PVTIDPath,cParamDsc_ResultImage,1,"");
  };

        virtual void ActualizeMainComponent(ComponentType* pMainComponent,
                                      SessionComponentCache* pComponentCache,
                                      SessionInfo* pSessionInfo,
                                                                                                                                                        const unsigned int& iActLevel) const
        {
                Superclass::ActualizeMainComponent(pMainComponent, pComponentCache,
                                                                                                                                                         pSessionInfo, iActLevel);

                std::string sTempPath;
                IDPath referenceImagePath;
                IDPath resultImagePath;

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ReferenceImage,sTempPath);
                referenceImagePath = sTempPath;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ResultImage,sTempPath);
                resultImagePath = sTempPath;
  }
    catchAllNPassMacro("Error while retrieving parameter values.");    
    

                pMainComponent->SetReferenceImagePath(referenceImagePath);
                pMainComponent->SetResultImagePath(resultImagePath);
        };

        void
        SetStatisticEntryMainComponent(StatisticEntry& rStatisticEntry,
                                             ComponentType* pMainComponent,
                                             SessionComponentCache* pMainComponentCache,
                                             SessionInfo* pSessionInfo,
                                             StatisticDictionary& rDictionary) const
        {
                typename ComponentType::DecomposedMeasureType values = pMainComponent->GetCurrentDecomposedValue();

                std::string sIDPath = pMainComponentCache->GetIDPath();
                StatisticValueDefinition* pEntry = rDictionary.GetValueDefinitionByName(sIDPath,"mean error");
            
                if (!pEntry) //Entry is not recorded yet, so do so.
                {
                        pEntry = rDictionary.AddValueDefinition(sIDPath,"mean error", "mean pixel difference");
                        rDictionary.AddValueDefinition(sIDPath,"std error", "standard deviation of the pixel difference.");
                        rDictionary.AddValueDefinition(sIDPath,"min error", "minimum pixel difference");
                        rDictionary.AddValueDefinition(sIDPath,"max error", "maximum pixel difference");
                        rDictionary.AddValueDefinition(sIDPath,"mean image error", "mean sum of differences in images)");
                        rDictionary.AddValueDefinition(sIDPath,"std image error", "standard deviation of the image difference");
                        rDictionary.AddValueDefinition(sIDPath,"min image error", "minimum image difference");
                        rDictionary.AddValueDefinition(sIDPath,"max image error", "maximum image difference");
                        rDictionary.AddValueDefinition(sIDPath,"failure", "number of failed evaluations");
                        rDictionary.AddValueDefinition(sIDPath,"mean duration", "mean duration of an evaluation (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"std duration", "standard deviation of an evaluation (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"min duration", "minimum duration of an evaluation (tenth of a second).");
                        rDictionary.AddValueDefinition(sIDPath,"max duration", "maximum duration of an evaluation (tenth of a second).");
                }
          
                for (unsigned int i = 0; i<values.Size(); i++)
                {
                        rStatisticEntry.AddValue(Convert::ToStr(values[i]),pEntry->GetRefID()+i);
                }
        };

};

template <class TControlledMetric>
const char* const ImageDifferenceSOMetricControllerBase<TControlledMetric>::cParam_ReferenceImage = "ReferenceImage";
template <class TControlledMetric>
const char* const ImageDifferenceSOMetricControllerBase<TControlledMetric>::cParamDsc_ReferenceImage = "IDPath of the reference image within the session of the adapted setups used as test basis.";
template <class TControlledMetric>
const char* const ImageDifferenceSOMetricControllerBase<TControlledMetric>::cParam_ResultImage = "ResultImage";
template <class TControlledMetric>
const char* const ImageDifferenceSOMetricControllerBase<TControlledMetric>::cParamDsc_ResultImage = "IDPath of the result image of an adapted setup.";

        freControllerIDMacro(ImageDifference2DSOMetricController, "Image Difference 2D SO Metric");
class ImageDifference2DSOMetricController : public ImageDifferenceSOMetricControllerBase< ImageDifferenceSOMetric<2> >
{
public:  
  typedef ImageDifferenceSOMetric<2> ComponentType;
  typedef ImageDifferenceSOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ImageDifference2DSOMetricController, ImageDifferenceSOMetricControllerBase);

  ImageDifference2DSOMetricController();

};

        freControllerIDMacro(ImageDifference3DSOMetricController, "Image Difference 3D SO Metric");
class ImageDifference3DSOMetricController : public ImageDifferenceSOMetricControllerBase< ImageDifferenceSOMetric<3> >
{
public:  
  typedef ImageDifferenceSOMetric<3> ComponentType;
  typedef ImageDifferenceSOMetricControllerBase<ComponentType> Superclass;

        itkTypeMacro(ImageDifference3DSOMetricController, ImageDifferenceSOMetricControllerBase);

  ImageDifference3DSOMetricController();

};

} //end of namespace free

#endif

---