freCompareHistogramMetricController.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: freCompareHistogramMetricController.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 __freCompareHistogramMetricController_h
#define __freCompareHistogramMetricController_h

#include "freHistogramMetricControllerBase.h"
#include "freTransformControllerBase.h"
#include "freInterpolatorControllerBase.h"

#include "itkCompareHistogramImageToImageMetric.h"

namespace FREE
{

ParameterMacro(TrainHisto, "TrainingHistogram","Defines the training historgram that should be used for comparing.\nIf the training histogram is set, no other training parameters / components are required.");
ParameterMacro(TrainFixed, "TrainingFixedImage","Training fixed image, which will be used to calculate the training historgram.\nOnly required if the histogram is not set directly.");
ParameterMacro(TrainMoving, "TrainingMovingImage","Training moving image, which will be used to calculate the training historgram.\nOnly required if the histogram is not set directly.");

ComponentMacro(TrainTransform, "Transform used to calculate the training histogram.\nOnly required if the histogram is not set directly.");
ComponentMacro(TrainInterpolator, "Interpolator used to calculate the training histogram.\nOnly required if the histogram is not set directly.");

freControllerIDMacro(CompareHistogramMetricControllerBase, "CompareHistogramMetricBase");
template <class TControlledCompareHistogramMetric>
class CompareHistogramMetricControllerBase : public HistogramMetricControllerBase< TControlledCompareHistogramMetric >
{
public:  
  typedef typename TControlledCompareHistogramMetric ComponentType;
  typedef typename ComponentType::Pointer ComponentPointer;
  typedef HistogramMetricControllerBase<ComponentType> Superclass;

  itkTypeMacro(CompareHistogramMetricControllerBase, HistogramMetricControllerBase);

  virtual ~CompareHistogramMetricControllerBase()
  {
  };

protected:
  CompareHistogramMetricControllerBase()
  {
                //Profile settings
    this->UpdateControllerID(ControllerID::CompareHistogramMetricControllerBase);
    this->m_Description = "A metric computes the similarity between the histogram produced by two images overlapping and a training histogram.";

    //Parameters
    m_Profile->Parameters().AddParameter(cParam_TrainHisto,Parameter::PVTDouble,cParamDsc_TrainHisto,2,false,"",true);
    m_Profile->Parameters().AddParameter(cParam_MetricMinimize,Parameter::PVTBool,cParamDsc_MetricMinimize,1,true,"true");              

    //Subcomponents
    m_Profile->SubComponents().AddSubComponent(cComp_TrainTransform,2,csUndefinedController,cCompDsc_TrainTransform);
    m_Profile->SubComponents().AddSubComponent(cComp_TrainInterpolator,2,csUndefinedController,cCompDsc_TrainInterpolator);

    //Profile setting
                CtrlProfile::ProfileOption* pOption;
                  //interpolator
                pOption = m_Profile->Requirements().AddRequirement(cComp_MainInterpolator)->AddProfileOption();
    pOption->Inheritance().AddAncestor(ControllerID::InterpolatorControllerBase);
    pOption->MediaMap().AddMedia("inputImage",ControllerID::ImageMediaControlerBase, DASet, ComponentType::ImageDimension,0,true);
    pOption->CheckForInheritance();
                pOption->CheckForIO();
                  //transform
                pOption = m_Profile->Requirements().AddRequirement(cComp_MainTransform)->AddProfileOption();
    pOption->Inheritance().AddAncestor(ControllerID::TransformControllerBase);
    pOption->MediaMap().AddMedia("movingMedia",ControllerID::MediaControlerBase, DASet, ComponentType::ImageDimension,0,true);
    pOption->MediaMap().AddMedia("fixedMedia",ControllerID::MediaControlerBase, DASet, ComponentType::ImageDimension,0,true);
                pOption->CheckForInheritance();
                pOption->CheckForIO();

          //Media
                std::string sControllerID = "Intensity Image 2D Media";
                if (TControlledCompareHistogramMetric::FixedImageType::GetImageDimension() == 3) sControllerID = "Intensity Image 3D Media";

    m_Profile->MediaMap().AddMedia(cParam_TrainMoving,sControllerID,DASet,TControlledCompareHistogramMetric::FixedImageType::GetImageDimension(),2);
                m_Profile->MediaMap().AddMedia(cParam_TrainFixed,sControllerID,DASet,TControlledCompareHistogramMetric::FixedImageType::GetImageDimension(),2);
  };

  virtual GenericComponentType* GetSubComponentCasted(ComponentType* pMainComponent, const ComponentID& compID,
                                                      SessionComponentCache* pMainComponentCache) const
  {
          if (compID == cComp_TrainInterpolator) return pMainComponent->GetTrainingInterpolator ();
          if (compID == cComp_TrainTransform) return pMainComponent->GetTrainingTransform ();

          return Superclass::GetSubComponentCasted(pMainComponent, compID, pMainComponentCache);
  }; 

  virtual void SetSubComponentCasted(GenericComponentType* pSubComponent, ComponentType* pMainComponent,
                               const ComponentID compID, SessionComponentCache* pMainComponentCache) const
  {
    if (compID == cComp_TrainInterpolator) pMainComponent->SetTrainingInterpolator( dynamic_cast< ComponentType::InterpolatorType* > (pSubComponent) );
          else if (compID == cComp_TrainTransform) pMainComponent->SetTrainingTransform( dynamic_cast< ComponentType::TransformType* > (pSubComponent) );
    else Superclass::SetSubComponentCasted(pSubComponent, pMainComponent, compID, pMainComponentCache);
  }; 

  virtual void SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia,
                                                                                                                  ComponentType* pComponent,
                              SessionComponentCache* pComponentCache,
                              SessionInfo* pSessionInfo) const
        {
                if (mediaID == cParam_TrainMoving) pComponent->SetTrainingMovingImage(dynamic_cast<ComponentType::MovingMarkerImageType*>(pMedia));
                else if (mediaID == cParam_TrainFixed) pComponent->SetTrainingFixedImage(dynamic_cast<ComponentType::FixedMarkerImageType*>(pMedia));
                else Superclass::SetMediaCasted(mediaID, pMedia, pComponent, pComponentCache, pSessionInfo);
        }; 

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

                if (b1stTime)
                {
                        Parameter* pParameter = pComponentSetup->Parameters().GetElement(cParam_TrainHisto);
                        if (!pParameter) throwCtrlExceptionMacro("","Missing parameter: "<<cParam_TrainHisto<<". Please ensure correct initializiation of the setup");
                
                        if (pParameter->Size()!=0)
                        { //There is a histogram
                                for (Parameter::LayerCountType index = 0; index < pParameter->LayerCount(); index++)
                                {
                                        ComponentType::HistogramPointer::MeasurmentVectorType measure = Convert::ParameterLayerToFixedArray<ComponentType::HistogramPointer::MeasurmentVectorType>(pParameter->GetParameterLayer(index));
                                        pMainComponent->GetTrainingHistogram().SetFrequency(measure,1);
                                }
                        }
                        else
                        { //no histogram, so compute it.

                                //all subcomponents and media should have been set in the building process of the session.
                                if (!pMainComponent->GetTrainingTransform()) throwCtrlExceptionMacro("","Missing transform for calculation of histogram. No histogram set, hence histogram must be calculated. Please set histogram directly or set training components (transform, interpolator, and images)");
                                if (!pMainComponent->GetTrainingInterpolator()) throwCtrlExceptionMacro("","Missing interpolator for calculation of histogram. No histogram set, hence histogram must be calculated. Please set histogram directly or set training components (transform, interpolator, and images)");
                                if (!pMainComponent->GetTrainingMovingImage()) throwCtrlExceptionMacro("","Missing training moving image for calculation of histogram. No histogram set, hence histogram must be calculated. Please set histogram directly or set training components (transform, interpolator, and images)");
                                if (!pMainComponent->GetTrainingFixedImage()) throwCtrlExceptionMacro("","Missing training fixed image for calculation of histogram. No histogram set, hence histogram must be calculated. Please set histogram directly or set training components (transform, interpolator, and images)");

                                pMainComponent->Initialize();
                        }
                }

                //TODO: Histogramm roi der trainings bilder
        };
};

} //end of namespace free

#endif

---