freOrientImageFilterController.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: freOrientImageFilterController.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 __freOrientImageFilterController_h
#define __freOrientImageFilterController_h

#include "freImageToImageFilterControllerBase.h"

#include "itkOrientImageFilter.h"

namespace FREE
{

namespace Convert
{
  std::string ToStr(const itk::SpatialOrientation::ValidCoordinateOrientationFlags& orient);
  itk::SpatialOrientation::ValidCoordinateOrientationFlags ToCoordinateOrientation(const std::string& sValue);
}

  freControllerIDMacro(OrientImageFilterControllerBase, "OrientImageFilterBase");
template <class TInputImage, unsigned int VDimension >
class OrientImageFilterControllerBase : public ImageToImageFilterControllerBase< itk::OrientImageFilter<TInputImage, TInputImage> >
{
public:  
  typedef itk::OrientImageFilter<TInputImage, TInputImage> ComponentType;
  typedef ImageToImageFilterControllerBase<ComponentType> Superclass;
  typedef OrientImageFilterControllerBase<TInputImage, VDimension> Self;

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

  DeclareParameterMacro(UseImageDirection);
  DeclareParameterMacro(GivenCoordinateOrientation);
  DeclareParameterMacro(DesiredCoordinateOrientation);
  DeclareParameterMacro(UseReferenceImageDirection);

  DeclareMediaIDMacro(referenceImage);

  itkTypeMacro(OrientImageFilterControllerBase, ImageToImageFilterControllerBase);

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

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

    //Parameters
    profile.Parameters().AddParameter(cParam_UseImageDirection,Parameter::PVTBool,cParamDsc_UseImageDirection,1,"false");
    profile.Parameters().AddParameter(cParam_GivenCoordinateOrientation,Parameter::PVTString,cParamDsc_GivenCoordinateOrientation,1,"RIP");
    profile.Parameters().AddParameter(cParam_DesiredCoordinateOrientation,Parameter::PVTString,cParamDsc_DesiredCoordinateOrientation,1,"RIP");
    profile.Parameters().AddParameter(cParam_UseReferenceImageDirection,Parameter::PVTBool,cParamDsc_UseReferenceImageDirection,1,"false");

    unsigned int iMediaGroupID = 0; //normaly the reference image is not needed

    if (bRegardOldSetup)
    {
      Parameter* pParamUseRefImage = pComponentCache->Setup()->Parameters().GetParameter(cParam_UseReferenceImageDirection);

      if (!pParamUseRefImage) throwCtrlExceptionMacro("","Error. Parameter "<<cParam_UseReferenceImageDirection<<"could not be found in old setup. Please ensure the creation of valid setups.");
      bool bUse = false;
      pParamUseRefImage->GetParameterValue(bUse);

      if (bUse) iMediaGroupID = 1;
    }

    //Media
    profile.MediaMap().AddMedia(MediaID_referenceImage,ControllerID::ImageMediaControllerBase,DASet,TInputImage::GetImageDimension(),iMediaGroupID);
  };

        virtual void ActualizeMainComponent(ComponentType* pMainComponent,
                                      SessionComponentCache* pComponentCache,
                                      SessionInfo* pSessionInfo,
                                                                                                                                                        const unsigned int& iActLevel) const
  {
    Superclass::ActualizeMainComponent(pMainComponent,pComponentCache, pSessionInfo, iActLevel);
    
          bool bUseImage;
          bool bUseReferenceImage;
    std::string sGivenOrientation;
    std::string sDesiredOrientation;

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_UseImageDirection,bUseImage);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_UseReferenceImageDirection,bUseReferenceImage);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_GivenCoordinateOrientation,sGivenOrientation);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_DesiredCoordinateOrientation,sDesiredOrientation);
    }
    catchAllNPassMacro("Error while retrieving parameter values.");

    pMainComponent->SetUseImageDirection(bUseImage);
    if (!bUseImage)
    {
      pMainComponent->SetGivenCoordinateOrientation(Convert::ToCoordinateOrientation(sGivenOrientation));
    }

    if (!bUseReferenceImage)
    {
      pMainComponent->SetDesiredCoordinateOrientation(Convert::ToCoordinateOrientation(sDesiredOrientation));
    }
    else
    { //get reference image directions

      SessionAccessor::GenericMediaPointer smpGenericReferenceImage = SessionAccessor::GetLinkedMedia(MediaID_referenceImage,pComponentCache,pSessionInfo);
      if (smpGenericReferenceImage.IsNull()) throwCtrlExceptionMacro("","Cannot get desired image direction. No reference image linked. Please check media linkage.");

      typedef typename itk::ImageBase<VDimension> ReferenceImageType;

      ReferenceImageType* pRefImage = 0;

      try
      {
        pRefImage = dynamic_cast<ReferenceImageType*>(smpGenericReferenceImage.GetPointer());
      }
      catchAllNPassMacro("Error while casting initial image");
      if (!pRefImage) throwCtrlExceptionMacro("","Error while casting initial image.");

      pMainComponent->SetDesiredCoordinateDirection(pRefImage->GetDirection());
    }
  };

};

template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: cParam_UseImageDirection = "UseImageDirection";
template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: cParamDsc_UseImageDirection = "Use image directions of the input image to determine the orientation. If true GivenCoordinateOrientation will be ignored.";
template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: cParam_GivenCoordinateOrientation = "GivenCoordinateOrientation";
template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: cParamDsc_GivenCoordinateOrientation = "Specifies the orientation of the input image coded as a three letter code (see itk::OrientImageFilter documentation). Will be ignored if UseImageDirection is true.";
template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: cParam_DesiredCoordinateOrientation = "DesiredCoordinateOrientation";
template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: cParamDsc_DesiredCoordinateOrientation = "Specifies the orientation of the output image coded as a three letter code (see itk::OrientImageFilter documentation). Will be ignored if UseReferenceImageDirection is true.";
template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: cParam_UseReferenceImageDirection = "UseReferenceImageDirection";
template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: cParamDsc_UseReferenceImageDirection = "Use image directions of the reference image to determine the orientation of the output. If true DesiredCoordinateOrientation will be ignored.";

template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: MediaID_referenceImage = "referenceImage";
template <class TInputImage, unsigned int VDimension >
const char* const OrientImageFilterControllerBase<TInputImage, VDimension> :: MediaIDDsc_referenceImage = "Reference image used to retrieve the desired output direction.";

freControllerIDMacro(Orient3DImageFilterController, "Orient 3D Image Filter");
class Orient3DImageFilterController : public OrientImageFilterControllerBase< ImageTypes<3>::InternalImageType, 3 >
{
public:  
  typedef OrientImageFilterControllerBase< ImageTypes<3>::InternalImageType, 3 > Superclass;
  typedef Orient3DImageFilterController Self;

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

  itkTypeMacro(Orient3DImageFilterController, OrientImageFilterControllerBase);

  Orient3DImageFilterController();
};

} //end of namespace free

#endif

---