freTransformFieldMediaController.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: freTransformFieldMediaController.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 __freTransformFieldMediaController_h
#define __freTransformFieldMediaController_h

#include "freImageMediaControllerBase.h"
#include "freImageIO.h"
#include "freTransformFunctionMedia.h"

#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkAddImageFilter.h"
#include "itkWarpVectorImageFilter.h"
#include "itkVectorLinearInterpolateImageFunction.h"

namespace FREE
{

  freControllerIDMacro(TransformFieldMediaControllerBase, "TransformFieldMediaBase");
template <class TVector, unsigned int VDimension>
class TransformFieldMediaControllerBase : public ImageMediaControllerBase< itk::Image< TVector, VDimension > >
{
public:  
  typedef itk::Image< TVector, VDimension > ComponentType;
  typedef ComponentType FieldType;
  typedef ImageMediaControllerBase<ComponentType> Superclass;
  typedef TransformFieldMediaControllerBase<TVector, VDimension> Self;
  typedef typename Superclass::ComponentPointer ComponentPointer;
  typedef typename Superclass::GenericComponentType GenericComponentType;
  typedef typename Superclass::GenericComponentPointer GenericComponentPointer;
  typedef typename Superclass::GenericMediaPointer GenericMediaPointer;

  itkTypeMacro(TransformFieldMediaControllerBase, ImageMediaControllerBase);

  TransformFieldMediaControllerBase()
  {
    //Profile settings
    this->UpdateControllerID(ControllerID::TransformFieldMediaControllerBase);
    this->m_Description = "Base class for media containing transformation fields.";
        };

  virtual ~TransformFieldMediaControllerBase() {};

  virtual GenericMediaPointer ComputeActualizedMedia(GenericMediaType* pGenericMedia,
                                                     GenericMediaType* pGenericTransformationField) const
  {
    if (!pGenericMedia) throwCtrlExceptionMacro("","Passed media is NULL.");
    if (!pGenericTransformationField) throwCtrlExceptionMacro("","Passed transform field is NULL.");

    typename FieldType::Pointer smpCurrentField;
    try
    {
      smpCurrentField = dynamic_cast<FieldType*>(pGenericMedia);
    }
    catchAllNPassMacro("Error. Media that should be actualized seems not to be of correct type.");
    if (smpCurrentField.IsNull()) throwCtrlExceptionMacro("","Media has wrong type. Cannot be casted.");

    typename FieldType::Pointer smpTransformField = static_cast< FieldType*>(pGenericTransformationField);

    //To compute a valid actual transformation field, we need to map the actual field by the
    //subsequent field and then add both vector
    //fields. This way of processing is needed because of the back mapping scheme used by itk.
    typedef itk::AddImageFilter<FieldType,FieldType,FieldType> AddFilterType;
    typedef itk::WarpVectorImageFilter<FieldType,FieldType,FieldType> WarpFilterType;
    
    typename WarpFilterType::Pointer warpFilter = WarpFilterType::New();
    typename AddFilterType::Pointer addFilter = AddFilterType::New();

    warpFilter->SetInput(smpCurrentField);
    warpFilter->SetDeformationField(smpTransformField);
    warpFilter->SetOutputSpacing(smpTransformField->GetSpacing());
    warpFilter->SetOutputOrigin(smpTransformField->GetOrigin());
    addFilter->SetInput1(warpFilter->GetOutput());
    addFilter->SetInput2(smpTransformField);
    smpCurrentField = addFilter->GetOutput();
    addFilter->Update();

    GenericMediaPointer smpResult = smpCurrentField.GetPointer();

    return smpResult;
  };

  virtual GenericMediaPointer ComputeActualizedMediaByFunction(GenericMediaType* pGenericMedia,
                                                               GenericMediaType* pGenericTransformationFunction) const
  {
    if (!pGenericMedia) throwCtrlExceptionMacro("","Passed media is NULL.");
    if (!pGenericTransformationFunction) throwCtrlExceptionMacro("","Passed transform function is NULL.");

    typename FieldType::Pointer smpCurrentField;
    try
    {
      smpCurrentField = dynamic_cast<FieldType*>(pGenericMedia);
    }
    catchAllNPassMacro("Error. Media that should be actualized seems not to be of correct type.");
    if (smpCurrentField.IsNull()) throwCtrlExceptionMacro("","Media has wrong type. Cannot be casted.");

    typedef TransformFunctionMedia<ScalarType, VDimension, VDimension> TransformationFunctionType;
    typename TransformationFunctionType::Pointer smpTransformFunction = static_cast< TransformationFunctionType*>(pGenericTransformationFunction);

    //To compute a valid actual transformation field, we need to map the actual field by the
    //the transform function and then add the vector of the function and the field value
    //This way of processing is needed because of the back mapping scheme used by itk.

    //allocate the result field
    typename FieldType::Pointer smpResultField = FieldType::New(); 
    smpResultField->SetOrigin(smpCurrentField->GetOrigin());
    smpResultField->SetSpacing(smpCurrentField->GetSpacing());
    smpResultField->SetRegions(smpCurrentField->GetLargestPossibleRegion());
    smpResultField->Allocate();

    //establish interpolater
    typedef itk::VectorLinearInterpolateImageFunction<FieldType, ScalarType> VectorInterpolatorType;
    typename VectorInterpolatorType::Pointer interpolator = VectorInterpolatorType::New();
    interpolator->SetInputImage(smpCurrentField);

    //establish iterators
    typedef itk::ImageRegionIterator<FieldType> IteratorType;
    IteratorType itrResult(smpResultField,smpCurrentField->GetLargestPossibleRegion());
    IteratorType itrCurrent(smpCurrentField,smpCurrentField->GetLargestPossibleRegion());

    //process the field
    typedef typename FieldType::PointType PointType;
    typedef typename FieldType::PixelType PixelType;
    PointType actPoint;
    for (itrCurrent.GoToBegin(); !(itrCurrent.IsAtEnd()); ++itrCurrent, ++itrResult)
    {
        smpCurrentField->TransformIndexToPhysicalPoint(itrCurrent.GetIndex(),actPoint);

        //transform point and get vector
        PointType transformedPoint = smpTransformFunction->GetTransform()->TransformPoint(actPoint);
        PixelType fieldVector = interpolator->Evaluate(transformedPoint).GetDataPointer();

        //now add the transform vector to the field vector and set the result vield
        PixelType resultVector = fieldVector + (transformedPoint - actPoint);

        itrResult.Set(resultVector);
    }

    GenericMediaPointer smpResult = smpResultField.GetPointer();

    return smpResult;
  };

  virtual bool LoadMedia(SessionComponentCache* pCache) const
  {
      if (!pCache) throwCtrlExceptionMacro("", "Cannot load media. Passed session cache is NULL.");

      if (!pCache->SetupIsAssigned()) throwCtrlExceptionMacro("", "Cannot load media. Passed session cache has no setup.");

      this->NotifyProgress(1,"Loading transformation field media",pCache);

      ComponentSetup* pComponentSetup = pCache->Setup();

      int iSource;
      std::string sFile;

      ComponentPointer component;
      try
      {
        SessionAccessor::GetParameterValue(pCache,Superclass::cParam_MediaFile,sFile);
        SessionAccessor::GetParameterValue(pCache,Superclass::cParam_ImageSource,iSource);
      }
      catchAllNPassMacro("Error while retrieving parameter values.");

      if (iSource==1)
      { //load from file
          typedef itk::ImageFileReader<ComponentType> TransformFieldImageReaderType;

        try
        {
                            typename TransformFieldImageReaderType::Pointer transformFieldReader = TransformFieldImageReaderType::New();
                            transformFieldReader->SetFileName(sFile.c_str());
                            component = transformFieldReader->GetOutput();
                            transformFieldReader->Update();
        }
        catchAllNPassMacro("Error, while loading transformation field from file ("<<sFile<<")");
      }
      else if (iSource==2)
      { //callback
        if (!MakeCallback(0,&component,pCache)) throwExceptionMacro("Unable to retreave the field by callback.");
        if (component.IsNull()) throwExceptionMacro("No field specified by callback.");
      }

      DirectSessionComponentAccessor::SetComponent(component,pCache);

      this->ActualizeMediaValidityTag("media",pCache);

      this->NotifyProgress(1,"Loading finished",pCache);

      return true;
  };

  virtual bool SaveMedia(SessionComponentCache* pCache) const
  {
      if (!pCache) throwCtrlExceptionMacro("", "Cannot save media. Passed session cache is NULL.");

      if (!pCache->SetupIsAssigned()) throwCtrlExceptionMacro("", "Cannot save media. Passed session cache has no setup.");

      this->NotifyProgress(1,"Saving transformation field media",pCache);

      ComponentSetup* pComponentSetup = pCache->Setup();

      int iSource;
      std::string sFile;

      ComponentPointer component;
      try
      {
        SessionAccessor::GetParameterValue(pCache,Superclass::cParam_MediaFile,sFile);
        SessionAccessor::GetParameterValue(pCache,Superclass::cParam_ImageSource,iSource);
      }
      catchAllNPassMacro("Error while retrieving parameter values.");

      if (iSource!=1)
      {
        this->NotifyProgress(1,"Transforamtion field source is no file, cannot save media to a file",pCache);
        return false;
      }
      else
      { //save to file
          typedef itk::ImageFileWriter<ComponentType> TransformFieldImageWriterType;

        try
        {
          typename GenericComponentType::Pointer smpMedia = DirectSessionComponentAccessor::GetComponent(pCache);

                            typename TransformFieldImageWriterType::Pointer transformFieldWriter = TransformFieldImageWriterType::New();
                            transformFieldWriter->SetFileName(sFile.c_str());
                            transformFieldWriter->SetInput(static_cast<ComponentType*>(smpMedia.GetPointer()));
                            transformFieldWriter->Update();
        }
        catchAllNPassMacro("Error, while loading transformation field from file ("<<sFile<<")");
      }

      this->NotifyProgress(1,"Saving finished",pCache);

      return true;
  };

        virtual bool SaveMedia(std::string sMediaPath, GenericMediaType* pMedia) const
        {
          typedef itk::ImageFileWriter<ComponentType> TransformFieldImageWriterType;
      typename TransformFieldImageWriterType::Pointer transformFieldWriter = TransformFieldImageWriterType::New();
      transformFieldWriter->SetFileName(sMediaPath);
      transformFieldWriter->SetInput(static_cast<ComponentType*>(pMedia));
      transformFieldWriter->Update();

                        return true;
        };

};

  freControllerIDMacro(TransformField2DMediaController, "Transformation Field 2D Media");
class TransformField2DMediaController : public TransformFieldMediaControllerBase< ImageTypes<2>::VectorType, 2>
{
public:  
  typedef TransformFieldMediaControllerBase<ImageTypes<2>::VectorType, 2> Superclass;
        typedef Superclass::ComponentType ComponentType;

  itkTypeMacro(TransformField2DMediaController, TransformFieldMediaControllerBase);

  TransformField2DMediaController();

  virtual ~TransformField2DMediaController();
};

  freControllerIDMacro(TransformField3DMediaController, "Transformation Field 3D Media");
class TransformField3DMediaController : public TransformFieldMediaControllerBase<ImageTypes<3>::VectorType, 3>
{
public:  
  typedef TransformFieldMediaControllerBase<ImageTypes<3>::VectorType, 3> Superclass;
        typedef Superclass::ComponentType ComponentType;

  itkTypeMacro(TransformField3DMediaController, TransformFieldMediaControllerBase);

  TransformField3DMediaController();

  virtual ~TransformField3DMediaController();
};

} //end of namespace free

#endif

---