freMattesMutualInformationMetricController.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: freMattesMutualInformationMetricController.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 __freMattesMutualInformationMetricController_h
#define __freMattesMutualInformationMetricController_h

#include "freImageToImageMetricControllerBase.h"

#include "freIntensityImageMediaController.h"

#include "itkMattesMutualInformationImageToImageMetric.h"

namespace FREE
{

  freControllerIDMacro(MattesMutualInformationMetricControllerBase, "MattesMutualInformationMetricBase"); 
template <class TImageType>
class MattesMutualInformationMetricControllerBase : public ImageToImageMetricControllerBase< itk::MattesMutualInformationImageToImageMetric<TImageType,TImageType> >
{
public:  
  typedef itk::MattesMutualInformationImageToImageMetric<TImageType,TImageType> ComponentType;
  typedef ImageToImageMetricControllerBase<ComponentType> Superclass;

  itkTypeMacro(MattesMutualInformationMetricControllerBase, ImageToImageMetricControllerBase); 

  DeclareParameterMacro(NrOfSmpl);
  DeclareParameterMacro(NrOfBins);
  DeclareParameterMacro(AbsoluteSamples);
  DeclareParameterMacro(UseAllSamples);
  DeclareParameterMacro(InitialSeed);
  DeclareParameterMacro(UseInitialSeed);

  DeclareMediaIDMacro(sampleImage);

protected:
  MattesMutualInformationMetricControllerBase()
  {
                //Profile settings
    this->UpdateControllerID(ControllerID::MattesMutualInformationMetricControllerBase);
    this->m_Description = "A mutual information metric. Based on the work of Mattes et. al..";

        };

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

      //Parameters
      profile.Parameters().AddParameter(cParam_NrOfSmpl,Parameter::PVTDouble,cParamDsc_NrOfSmpl,1,"100",-1,true);
      profile.Parameters().AddParameter(cParam_NrOfBins,Parameter::PVTULong,cParamDsc_NrOfBins,1,"10",-1,true);
      profile.Parameters().AddParameter(cParam_AbsoluteSamples,Parameter::PVTBool,cParamDsc_AbsoluteSamples,1,"true",-1,true);
      profile.Parameters().AddParameter(cParam_UseAllSamples,Parameter::PVTBool,cParamDsc_UseAllSamples,1,"false");
      profile.Parameters().AddParameter(cParam_InitialSeed,CtrlProfile::Parameter::PVTInteger,cParamDsc_InitialSeed,1,"21021978");
      profile.Parameters().AddParameter(cParam_UseInitialSeed,CtrlProfile::Parameter::PVTBool,cParamDsc_UseInitialSeed,1,"false");

      unsigned int iGroupID = 0;

      if (bRegardOldSetup)
      {
        bool bAbsolute;

        Parameter* pParamAbs = pComponentCache->Setup()->Parameters().GetParameter(cParam_AbsoluteSamples);

        if (!pParamAbs) throwCtrlExceptionMacro("","Error. Parameter "<<cParam_AbsoluteSamples<<" could not be found in old setup. Please ensure the creation of valid setups.");

        pParamAbs->GetParameterValue(bAbsolute);

        if (!bAbsolute)
        {
          //the sample number should be relative to the size of the sample image,
          //so it is necessary now
          iGroupID = 1;
        }
      }

      profile.MediaMap().AddMedia(MediaID_sampleImage,ControllerID::IntensityImageMediaControllerBase,DASet,TImageType::GetImageDimension(),iGroupID);
  };

        virtual void ActualizeMainComponent(ComponentType* pMainComponent,
                                      SessionComponentCache* pComponentCache,
                                      SessionInfo* pSessionInfo,
                                                                                                                                                        const unsigned int& iActLevel) const
        {
    unsigned long lNrOfBins;
    bool bAbsolute;
    bool bAll;
    double dSmpl;

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_NrOfSmpl,dSmpl,0,iActLevel,true);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_NrOfBins,lNrOfBins,0,iActLevel,true);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_AbsoluteSamples,bAbsolute,0,iActLevel,true);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_UseAllSamples,bAll);
    }
    catchAllNPassMacro("Error while retrieving parameter values.");    
    
    unsigned long lNrOfSmpl = static_cast<unsigned long>(dSmpl);

    if (!bAll && !bAbsolute)
    { //use only a percentage of the pixels 
      if (dSmpl<0) throwCtrlExceptionMacro("","Relative number of samples must not be lesser then 0(0%). Pleas check setup. Current value: "<<dSmpl);
      if (dSmpl>1) throwCtrlExceptionMacro("","Relative number of samples must not be greater then 1 (100%). Pleas check setup. Current value: "<<dSmpl);

      typedef TImageType InternalImageType;

      SessionAccessor::GenericMediaPointer smpGenericSampleImage = SessionAccessor::GetLinkedMedia(MediaID_sampleImage,pComponentCache,pSessionInfo);
      if (smpGenericSampleImage.IsNull()) throwCtrlExceptionMacro("","Cannot compute number of samples. No sample image linked. Please check media linkage.");

      InternalImageType* pSampleImage = 0;

      try
      {
        pSampleImage = dynamic_cast<InternalImageType*>(smpGenericSampleImage.GetPointer());
      }
      catchAllNPassMacro("Error while casting sample image");
      if (!pSampleImage) throwCtrlExceptionMacro("","Error while casting sample image.");

      lNrOfSmpl = static_cast<unsigned long>(pSampleImage->GetLargestPossibleRegion().GetNumberOfPixels()*(dSmpl));
    }
    else if (!bAbsolute)
    {
      if (dSmpl<0) throwCtrlExceptionMacro("","Absolute number of samples must not be lesser then 0. Pleas check setup. Current value: "<<dSmpl);
    };

    pMainComponent->SetNumberOfSpatialSamples(lNrOfSmpl);
    pMainComponent->SetNumberOfHistogramBins(lNrOfBins);
    pMainComponent->SetUseAllPixels(bAll);

    if (iActLevel == 0)
    { //initial seed should only be set at the start of an registration (first level)
      try
      {
        Parameter::Pointer smpParamUseSeed = SessionAccessor::GetParameter(pComponentCache,cParam_UseInitialSeed);
        if (smpParamUseSeed.IsNotNull())
        {
          bool bUseSeed;
          smpParamUseSeed->GetParameterValue(bUseSeed);

          int iSeed;

          if (bUseSeed)
          {
            SessionAccessor::GetParameterValue(pComponentCache,cParam_InitialSeed,iSeed,0,iActLevel,true);
            pMainComponent->ReinitializeSeed(iSeed);
          }
        }
      }
      catchAllNPassMacro("Error while initializing random generator with seed.");    
    }
  }

  void
  SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia, ComponentType* pComponent, SessionComponentCache* pComponentCache,
                 SessionInfo* pSessionInfo) const
  {
    if (mediaID == MediaID_sampleImage)
    {
      //sample image must not be set it will be requested by the controller explicitly if needed.
    }
    else Superclass::SetMediaCasted(mediaID, pMedia, pComponent, pComponentCache, pSessionInfo);
  }; 

};

template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParam_NrOfSmpl = "NrOfSmpl";
template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParamDsc_NrOfSmpl = "Number of samples used by the metric. If SampleAbsolute is false, this value indicates the percentage of the pixel count of sampleImage that will be used.";

template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParam_NrOfBins = "NrOfBins";
template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParamDsc_NrOfBins = "Number of histogram bins used for calculating the mi.";

template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParam_AbsoluteSamples = "AbsoluteSamples";
template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParamDsc_AbsoluteSamples = "Indicates if NrOfSmpl is the absolut number of samples (true) or the percentage (0...1 : 0%...100%) of the pixels of sampleImage (false) that should be used.";

template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParam_UseAllSamples = "UseAllSamples";
template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParamDsc_UseAllSamples = "If true all pixels of the image will be used as samples. Does not require sampleImage.";

template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::MediaID_sampleImage = "sampleImage";
template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::MediaIDDsc_sampleImage = "Reference image that can be used to determine the number of samples that should be used. It is only needed if AbsoluteSample is false.";

template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParam_UseInitialSeed = "UseInitialSeed";
template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParamDsc_UseInitialSeed = "If true the seed specified by \"InitialSeed\" will be used to draw the samples. If false, the internal clock will be used as seed.";

template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParam_InitialSeed = "InitialSeed";
template <class TImageType>
const char* const MattesMutualInformationMetricControllerBase<TImageType> 
::cParamDsc_InitialSeed = "The seed for the random generator used to draw the samples.";

  freControllerIDMacro(MattesMutualInformation2DMetricController, "Mattes Mutual Information 2D Metric"); 
class MattesMutualInformation2DMetricController : public MattesMutualInformationMetricControllerBase<InternalImage2DType>
{
public:  
  itkTypeMacro(MattesMutualInformation2DMetricController, MattesMutualInformationMetricControllerBase); 

  MattesMutualInformation2DMetricController();
};

  freControllerIDMacro(MattesMutualInformation3DMetricController, "Mattes Mutual Information 3D Metric"); 
class MattesMutualInformation3DMetricController : public MattesMutualInformationMetricControllerBase<InternalImage3DType>
{
public:  
  itkTypeMacro(MattesMutualInformation3DMetricController, MattesMutualInformationMetricControllerBase); 

  MattesMutualInformation3DMetricController();
};

} //end of namespace free

#endif

---