freMaskedROICoupleController.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: freMaskedROICoupleController.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 __freMaskedROICoupleController_h
#define __freMaskedROICoupleController_h

#include "freROICoupleController.h"
#include "freROI.h"

#include "itkNearestNeighborInterpolateImageFunction.h"
#include "itkWarpImageFilter.h" 

namespace FREE
{
  freControllerIDMacro(MaskedROICoupleControllerBase, "MaskedROICoupleBase");
template<unsigned int VImageDimension>
class MaskedROICoupleControllerBase : public ROICoupleControllerBase< ImageMaskedROICouple<VImageDimension> >
{
public:  
  typedef ImageMaskedROICouple<VImageDimension> ComponentType;
  typedef ROICoupleControllerBase<ComponentType> Superclass;

  itkTypeMacro(MaskedROICoupleControllerBase, ROICoupleControllerBase);

protected:
  MaskedROICoupleControllerBase()
  {
    this->UpdateControllerID(ControllerID::MaskedROICoupleControllerBase);
    this->m_Description = "A couple of masked ROIs (e.g. for registration, only abstrace, not for practical use";
  };

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

    //Parameter info
    profile.Parameters().AddParameter(cParam_ROI_M_MaskFile,Parameter::PVTURI,cParamDsc_ROI_M_MaskFile,1,"",1,false,3);
    profile.Parameters().AddParameter(cParam_ROI_M_MaskFileFeedback,Parameter::PVTBool,cParamDsc_ROI_M_MaskFileFeedback,1,"false",1,false,4);
    profile.Parameters().AddParameter(cParam_ROI_F_MaskFile,Parameter::PVTURI,cParamDsc_ROI_F_MaskFile,1,"",1,false,3);
    profile.Parameters().AddParameter(cParam_ROI_F_MaskFileFeedback,Parameter::PVTBool,cParamDsc_ROI_F_MaskFileFeedback,1,"false",1,false,4);
  };

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

                bool bFeedback;
                std::string sMaskFile;

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ROI_M_MaskFile,sMaskFile);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ROI_M_MaskFileFeedback,bFeedback);
    }
    catchAllNPassMacro("Error while retrieving parameter values.");

                if (!pMainComponent->Moving().GetMask())
                { //There is no mask loaded yet so try to
                        if (sMaskFile!="") pMainComponent->Moving().SetMask(sMaskFile);

                        if (!pMainComponent->Moving().GetMask())
                        { //Warp moving mask by interim Transformation
                                try
                                {
                                        if (pMainComponent->Moving().GetMask()!=NULL)
                                        {
                                                typedef typename ImageTypes< VImageDimension >::MaskType MaskType;
                                                typedef typename ImageTypes< VImageDimension >::TransformationFieldType TransformationFieldType;
                                                typedef itk::WarpImageFilter< MaskType, MaskType, TransformationFieldType > WarpType;
                                                typedef itk::NearestNeighborInterpolateImageFunction< MaskType, ScalarType > InterpolatorType;

                                                typename WarpType::Pointer warp = WarpType::New();
                                                typename InterpolatorType::Pointer interpolator = InterpolatorType::New();

                                                warp->SetInput(pMainComponent->Moving().GetMask());
                                                warp->SetInterpolator(interpolator);
            //TODO Wenn es den Transformierer gibt, dann muss diese ganze Maskenanpassung raus aus dem
            //ActualizeComponent und rein in die ActualizeMedia methode, jetzt erst einmal nur auskommentiert,
            //damit man real free kompilieren kann
            //                                          warp->SetDeformationField(((RegistrationProcessorBase<VImageDimension>*)pSessionInfo->GetRegistrationProcessor())->GetFinalTransformationField());

                                                warp->SetOutputSpacing(pMainComponent->Moving().GetMask()->GetSpacing());
                                                warp->SetOutputOrigin(pMainComponent->Moving().GetMask()->GetOrigin());
                                                warp->SetEdgePaddingValue(0);
                                                warp->Update();

                                                pMainComponent->Moving().SetMask(warp->GetOutput());
                                        };
                                }
                                catchAllNPassMacro("Error while actualizing moving mask by warp filter.");
                        }
                }
                if (bFeedback) MakeCallback(ccfROIMoving,&(pMainComponent->Moving().GetMaskSmartPointer()),pComponentCache);

    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ROI_F_MaskFile,sMaskFile);
      SessionAccessor::GetParameterValue(pComponentCache,cParam_ROI_F_MaskFileFeedback,bFeedback);
    }
    catchAllNPassMacro("Error while retrieving parameter values.");

                if (!pMainComponent->Fixed().GetMask())
                { //There is no mask loaded yet so try to
                        if (sMaskFile!="") pMainComponent->Fixed().SetMask(sMaskFile);
                }
                if (bFeedback) MakeCallback(ccfROIFixed,&(pMainComponent->Fixed().GetMaskSmartPointer()),pComponentCache);
        };
};

  freControllerIDMacro(MaskedROICouple2DController, "Masked ROI Couple 2D");
class MaskedROICouple2DController : public MaskedROICoupleControllerBase< 2 >
{
public:  
  itkTypeMacro(MaskedROICouple2DController, MaskedROICoupleControllerBase);

  MaskedROICouple2DController();
};

  freControllerIDMacro(MaskedROICouple3DController, "Masked ROI Couple 3D");
class MaskedROICouple3DController : public MaskedROICoupleControllerBase< 3 >
{
public:  
  itkTypeMacro(MaskedROICouple3DController, MaskedROICoupleControllerBase);

  MaskedROICouple3DController();
};

} //end of namespace free

#endif

---