freDiscreteGaussianImageFilterController.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: freDiscreteGaussianImageFilterController.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 __freDiscreteGaussianImageFilterController_h
#define __freDiscreteGaussianImageFilterController_h

#include "freImageToImageFilterControllerBase.h"

#include "itkDiscreteGaussianImageFilter.h"

namespace FREE
{

  freControllerIDMacro(DiscreteGaussianImageFilterControllerBase, "DiscreteGaussianImageFilterBase");
template <class TInputImage>
class DiscreteGaussianImageFilterControllerBase : public ImageToImageFilterControllerBase< itk::DiscreteGaussianImageFilter<TInputImage, TInputImage> >
{
public:  
  typedef itk::DiscreteGaussianImageFilter<TInputImage, TInputImage> ComponentType;
  typedef ImageToImageFilterControllerBase<ComponentType> Superclass;
  typedef DiscreteGaussianImageFilterControllerBase<TInputImage> Self;

  typedef typename ComponentType::Pointer ComponentPointer;
  typedef typename Superclass::GenericComponentType GenericComponentType;
  typedef typename Superclass::GenericComponentPointer GenericComponentPointer;
  typedef typename Superclass::GenericMediaPointer GenericMediaPointer;

  itkTypeMacro(DiscreteGaussianImageFilterControllerBase, ImageToImageFilterControllerBase);

  DeclareParameterMacro(UseImageSpacing);
  DeclareParameterMacro(FilterDimensionality);
  DeclareParameterMacro(MaximumError);
  DeclareParameterMacro(MaximumKernelWidth);
  DeclareParameterMacro(Variance);

protected:
  DiscreteGaussianImageFilterControllerBase()
  {
    //Profile settings
    this->UpdateControllerID(ControllerID::DiscreteGaussianImageFilterControllerBase);
    this->m_Description = "Basis for itk::DiscreteGaussianImageFilter";
  };

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

    //Parameters
    profile.Parameters().AddParameter(cParam_UseImageSpacing,Parameter::PVTBool,cParamDsc_UseImageSpacing,1,"true");
    profile.Parameters().AddParameter(cParam_FilterDimensionality,Parameter::PVTInteger,cParamDsc_FilterDimensionality,1,Convert::ToStr(TInputImage::GetImageDimension()));
    profile.Parameters().AddParameter(cParam_MaximumError,Parameter::PVTDouble,cParamDsc_MaximumError,TInputImage::GetImageDimension(),"0.01");
    profile.Parameters().AddParameter(cParam_MaximumKernelWidth,Parameter::PVTLong,cParamDsc_MaximumKernelWidth,1,"32");
    profile.Parameters().AddParameter(cParam_Variance,Parameter::PVTDouble,cParamDsc_Variance,TInputImage::GetImageDimension(),"0.0");
  };

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

    bool bUseSpacing;
    long lMaxKernel;
    int iDim;

    typename ComponentType::ArrayType vars;
    typename ComponentType::ArrayType errors;

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_UseImageSpacing,bUseSpacing);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_MaximumKernelWidth,lMaxKernel);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_FilterDimensionality,iDim);
    }
    catchAllNPassMacro("Error while getting parameters.");

    try
    {
      Parameter::Pointer smpVarParam = SessionAccessor::GetParameter(pComponentCache,cParam_Variance);
      if (smpVarParam.IsNull()) throwCtrlExceptionMacro("","Error. Parameter "<<cParam_Variance<<" is missing. Please check your setup.");

      for (unsigned int iIndex = 0; iIndex<TInputImage::GetImageDimension(); iIndex++)
      {
        double dVar;
        smpVarParam->GetParameterValue(dVar,iIndex);
        vars[iIndex] = dVar;
      }
    }
    catchAllNPassMacro("Error while gettin variances");

    try
    {
      Parameter::Pointer smpErrorParam = SessionAccessor::GetParameter(pComponentCache,cParam_MaximumError);
      if (smpErrorParam.IsNull()) throwCtrlExceptionMacro("","Error. Parameter "<<cParam_MaximumError<<" is missing. Please check your setup.");

      for (unsigned int iIndex = 0; iIndex<TInputImage::GetImageDimension(); iIndex++)
      {
        double dError;
        smpErrorParam->GetParameterValue(dError,iIndex);
        errors[iIndex] = dError;
      }
    }
    catchAllNPassMacro("Error while gettin variances");

    pMainComponent->SetUseImageSpacing(bUseSpacing);
    pMainComponent->SetMaximumKernelWidth(lMaxKernel);
    pMainComponent->SetFilterDimensionality(iDim);
    pMainComponent->SetMaximumError(errors);
    pMainComponent->SetVariance(vars);
  };

};

template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParam_UseImageSpacing = "UseImageSpacing";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParamDsc_UseImageSpacing = "Indicates if variance will be evaluated as pixel units (false) or in real world units (true).";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParam_FilterDimensionality = "FilterDimensionality";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParamDsc_FilterDimensionality = "Indicates how many dimensions should be filtered.";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParam_MaximumError = "MaximumError";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParamDsc_MaximumError = "Maximum error allowed by the trucation of the kernel. The value can be set for each dimension.";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParam_MaximumKernelWidth = "MaximumKernelWidth";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParamDsc_MaximumKernelWidth = "Maximum width the kernel may have, even if its error is greater then the maximum error.";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParam_Variance = "Variance";
template <class TInputImage>
const char* const DiscreteGaussianImageFilterControllerBase<TInputImage> :: cParamDsc_Variance = "Variance of the filter. The value can be set for each dimension.";

freControllerIDMacro(DiscreteGaussian2DImageFilterController, "Discrete Gaussian 2D Image Filter");
class DiscreteGaussian2DImageFilterController : public DiscreteGaussianImageFilterControllerBase< ImageTypes<2>::InternalImageType >
{
public:  
  typedef DiscreteGaussianImageFilterControllerBase< ImageTypes<2>::InternalImageType > Superclass;
  typedef DiscreteGaussian2DImageFilterController Self;

  typedef Superclass::ComponentType ComponentType;
  typedef ComponentType::Pointer ComponentPointer;
  typedef Superclass::GenericComponentType GenericComponentType;
  typedef Superclass::GenericComponentPointer GenericComponentPointer;
  typedef Superclass::GenericMediaPointer GenericMediaPointer;

  itkTypeMacro(DiscreteGaussian2DImageFilterController, DiscreteGaussianImageFilterControllerBase);

  DiscreteGaussian2DImageFilterController();
};

freControllerIDMacro(DiscreteGaussian3DImageFilterController, "Discrete Gaussian 3D Image Filter");
class DiscreteGaussian3DImageFilterController : public DiscreteGaussianImageFilterControllerBase< ImageTypes<3>::InternalImageType >
{
public:  
  typedef DiscreteGaussianImageFilterControllerBase< ImageTypes<3>::InternalImageType > Superclass;
  typedef DiscreteGaussian3DImageFilterController Self;

  typedef Superclass::ComponentType ComponentType;
  typedef ComponentType::Pointer ComponentPointer;
  typedef Superclass::GenericComponentType GenericComponentType;
  typedef Superclass::GenericComponentPointer GenericComponentPointer;
  typedef Superclass::GenericMediaPointer GenericMediaPointer;

  itkTypeMacro(DiscreteGaussian3DImageFilterController, DiscreteGaussianImageFilterControllerBase);

  DiscreteGaussian3DImageFilterController();
};

} //end of namespace free

#endif

---