frePointSetMediaController.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: frePointSetMediaController.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 __frePointSetMediaController_h
#define __frePointSetMediaController_h

#include "freStoreableMediaControllerBase.h"
#include "frePointSetToXMLStreamObject.h"
#include "freTransformFunctionMedia.h"

#include "itkPointSet.h"

#include "itkIterativeInverseDeformationFieldImageFilter.h"

namespace FREE
{

freControllerIDMacro(PointSetMediaControllerBase, "PointSetMediaBase");
template <class TPixel, unsigned int VDimension>
class PointSetMediaControllerBase : public StoreableMediaControllerBase< itk::PointSet< TPixel, VDimension, itk::DefaultStaticMeshTraits<TPixel, VDimension, VDimension, ScalarType> > >
{
public:
    typedef itk::PointSet< TPixel, VDimension, itk::DefaultStaticMeshTraits<TPixel, VDimension, VDimension, ScalarType> > ComponentType;
    typedef ComponentType ImageType;
    typedef StoreableMediaControllerBase<ComponentType> Superclass;
    typedef typename Superclass::ComponentPointer ComponentPointer;
    typedef typename Superclass::GenericComponentType GenericComponentType;
    typedef typename Superclass::GenericComponentPointer GenericComponentPointer;
    typedef typename Superclass::GenericMediaPointer GenericMediaPointer;
    
    itkTypeMacro(PointSetMediaControllerBase, StoreableMediaControllerBase);

    DeclareParameterMacro(Points);
    DeclareParameterMacro(Values);
    DeclareParameterMacro(PointsSource);

    PointSetMediaControllerBase()
    {
        //Profile settings
        this->UpdateControllerID(ControllerID::PointSetMediaControllerBase);
        this->m_Description = "Base class for media containing point sets.";
    };

    virtual ~PointSetMediaControllerBase()
    {}
    ;

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


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

      typedef typename ImageTypes<VDimension>::TransformationFieldType TransformationFieldType;
      typename TransformationFieldType::Pointer smpTransformField = static_cast< TransformationFieldType*>(pGenericTransformationField);

      //map Pointset
      ComponentPointer smpActualizedPointSet = ComponentType::New();
      typedef typename ComponentType::PointsContainer::Iterator PointDataIterator;

      PointDataIterator pointIter = smpCurrentPointSet->GetPoints()->Begin();
      PointDataIterator pointEnd = smpCurrentPointSet->GetPoints()->End();

      long lPointID = 0;
      while(pointIter != pointEnd)
      {
          typename ComponentType::PointType currentPoint = pointIter.Value();
          typename TransformationFieldType::PixelType translation;
          translation.Fill(0.0);

          typename TransformationFieldType::IndexType index;
          if (smpTransformField->TransformPhysicalPointToIndex(currentPoint, index))
          {
              translation = smpTransformField->GetPixel(index);
          }

          currentPoint = currentPoint+translation;
          smpActualizedPointSet->SetPoint(lPointID++, currentPoint);
          ++pointIter;
      }

      GenericMediaPointer smpResult = smpActualizedPointSet.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.");

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

      typedef TransformFunctionMedia<ScalarType, VDimension, VDimension> TransformationFunctionType;
      typename TransformationFunctionType::Pointer smpTransformFunction = dynamic_cast< TransformationFunctionType*>(pGenericTransformationFunction);
      if (smpTransformFunction.IsNull()) throwCtrlExceptionMacro("","Transformation function was passed, but seems to be wrong type.");

      //transform Pointset
      ComponentPointer smpActualizedPointSet = ComponentType::New();
      typedef typename ComponentType::PointsContainer::Iterator PointDataIterator;

      PointDataIterator pointIter = smpCurrentPointSet->GetPoints()->Begin();
      PointDataIterator pointEnd = smpCurrentPointSet->GetPoints()->End();

      long lPointID = 0;
      while(pointIter != pointEnd)
      {
          typename ComponentType::PointType currentPoint = pointIter.Value();

          typename ComponentType::PointType transformedPoint = smpTransformFunction->GetTransform()->TransformPoint(currentPoint);

          smpActualizedPointSet->SetPoint(lPointID++, transformedPoint);
          ++pointIter;
      }

      GenericMediaPointer smpResult = smpActualizedPointSet.GetPointer();
      return smpResult;
    };

    virtual bool SaveMedia(std::string sMediaPath, GenericMediaType* pMedia) const
    {
      ComponentPointer smpPointSet;
      try
      {
        smpPointSet = static_cast<ComponentType*>(pMedia);
      }
      catchAllNPassMacro("Error. Media that should be actualized seems not to be of correct type.");
      if (smpPointSet.IsNull()) throwCtrlExceptionMacro("","Media has wrong type. Cannot be casted.");

      PointSetToXMLStreamObject<ComponentType> xmlPointSet;
      xmlPointSet.SetPointSet(smpPointSet);
      xmlPointSet.SaveToFile(sMediaPath);

      return true;
    };

    virtual bool SaveMedia(SessionComponentCache* pCache) const
    {
        if (!pCache->SetupIsAssigned())
            throwCtrlExceptionMacro("","Error. Setup is missing in cache. Point set stores media in component setup");
        if (!pCache->ComponentIsAssigned())
            throwCtrlExceptionMacro("","Error. Point set is missing in cache.");

        ComponentPointer smpPointSet = 0;

        try
        {
          smpPointSet = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pCache));
        }
        catchAllNPassMacro("Error; component in cache wasn't a legal point set. IDPath: "<<pCache->GetIDPath().ToStr());
        if (smpPointSet.IsNull()) throwCtrlExceptionMacro("","Error; component cache wasn't a legal point set. IDPath: "<<pCache->GetIDPath().ToStr());

        int iPointSource = 0;

        Parameter::Pointer smpSources = pCache->Setup()->Parameters().GetParameter(cParam_PointsSource);
        if (smpSources.IsNotNull()) 
        {
          smpSources->GetParameterValue(iPointSource);
        }

        if (iPointSource)
        {
          std::string sMediaFile;
          typename Parameter::Pointer smpFileParameter = pCache->Setup()->Parameters().GetParameter(Superclass::cParam_MediaFile);
          if (smpFileParameter.IsNull())
            throwCtrlExceptionMacro("", "Missing parameter" << Superclass::cParam_MediaFile);

          smpFileParameter->GetParameterValue(sMediaFile);

          PointSetToXMLStreamObject<ComponentType> xmlPointSet;
          xmlPointSet.SetPointSet(smpPointSet);
          xmlPointSet.SaveToFile(sMediaFile);
        }
        else
        {
          SaveSetToSetup(*(pCache->Setup()),*(smpPointSet.GetPointer()));
        }

        return true; //point set is saved to setup
    };

    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 point set media",pCache);

        ComponentSetup* pComponentSetup = pCache->Setup();

        ComponentPointer smpPointSet = ComponentType::New();
        smpPointSet->SetPointData(ComponentType::PointDataContainer::New());
        //needed because in itk 2.4 point set does not generate the value container automaticaly

        int iPointSource = 0;

        Parameter::Pointer smpSources = pComponentSetup->Parameters().GetParameter(cParam_PointsSource);
        if (smpSources.IsNotNull()) 
        {
          smpSources->GetParameterValue(iPointSource);
        }

        if (iPointSource)
        {
          std::string sMediaFile;
          typename Parameter::Pointer smpFileParameter = pComponentSetup->Parameters().GetParameter(Superclass::cParam_MediaFile);
          if (smpFileParameter.IsNull())
            throwCtrlExceptionMacro("", "Missing parameter" << Superclass::cParam_MediaFile);

          smpFileParameter->GetParameterValue(sMediaFile);

          PointSetToXMLStreamObject<ComponentType> xmlPointSet;
          xmlPointSet.SetPointSet(smpPointSet);
          xmlPointSet.LoadFromFile(sMediaFile);
        }
        else
        {
          LoadSetFromSetup(*pComponentSetup,*(smpPointSet.GetPointer()));
        }

        DirectSessionComponentAccessor::SetComponent(smpPointSet,pCache);
        this->ActualizeMediaValidityTag("media",pCache);          

        //add the loaded flag, because the media is kept in memory
        DirectSessionComponentAccessor::SetRepositoryElement("LoadedFlag",itk::LightObject::New(),pCache);

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

        return true;
    };

    virtual unsigned long GetMediaDimension() const
    {
        return VDimension;
    };

    virtual ComponentPointer GetComponent(const SessionComponentCache* pComponentCache) const
    {
      ComponentPointer smpMedia;
      
      //get loading type
      int iPointSource;
      
      try
      {
        SessionAccessor::GetParameterValue(pComponentCache,cParam_PointsSource,iPointSource);
      }
      catchAllNPassMacro("Error while retrieving loading type.");
      
      //The value of the flag isn't important, only its presence or absence
      GenericComponentType* pLoadedFlag = DirectSessionComponentAccessor::GetRepositoryElement("LoadedFlag",pComponentCache);

      if ((!pLoadedFlag) && (iPointSource == 2))
      { //there is no flag indicating that the point set was loaded
        //and it should be loaded on first demand.
        //So load now and add to the cache, therefore
        //exceptionally cast away const.
        SessionComponentCache* pNonConstComponentCache = const_cast<SessionComponentCache*>(pComponentCache);

        if (!LoadMedia(pNonConstComponentCache)) throwCtrlExceptionMacro("", "Unable to load image media.");

        try
        {
          smpMedia = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pNonConstComponentCache));
        }
        catchAllNPassMacro("Error; component loaded wasn't the right media type.");
        if (smpMedia.IsNull()) throwCtrlExceptionMacro("","Error; component loaded wasn't the right media type.");

        //add the loaded flag, because the media is kept in memory
        DirectSessionComponentAccessor::SetRepositoryElement("LoadedFlag",itk::LightObject::New(),pNonConstComponentCache);

        return smpMedia;
      }
      
      return Superclass::GetComponent(pComponentCache);
    }; 

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

      //Parameters
      profile.Parameters().AddParameter(cParam_Points,Parameter::PVTDouble,cParamDsc_Points,VDimension,"0.0",-1);
      profile.Parameters().AddParameter(cParam_Values,Parameter::PVTDouble,cParamDsc_Values,VDimension,"0.0",-1);
      profile.Parameters().AddParameter(cParam_PointsSource,Parameter::PVTInteger,cParamDsc_PointsSource,1,"0");
    };

   virtual ComponentPointer BuildMainComponent(ComponentSetup* pComponentSetup, SessionComponentCache* pComponentCache) const
    {
      int iPointSource;
      
      try
      {
        SessionAccessor::GetParameterValue(pComponentCache,cParam_PointsSource,iPointSource);
      }
      catchAllNPassMacro("Error while retrieving loading type.");

      //generate empty dummy media because component pointer in cache must not be NULL
      ComponentPointer smpPointSet = Superclass::BuildMainComponent(pComponentSetup, pComponentCache);

      if (iPointSource!=2)
      { //preload -> load while building
        if (!LoadMedia(pComponentCache)) throwCtrlExceptionMacro("", "Unable to load point set.");

        try
        {
          smpPointSet = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pComponentCache));
        }
        catchAllNPassMacro("Error; component loaded wasn't a legal point set.");
        if (smpPointSet.IsNull()) throwCtrlExceptionMacro("","Error; component loaded wasn't a legal point set.");
      }
      else
      {
        //Actualize validitiy tag even if no media is loaded yet, because the validity requirement for
        //media images not preloaded is at least equal to now.
        this->ActualizeMediaValidityTag("media",pComponentCache);
      }

      return smpPointSet;
   };

   virtual void LoadSetFromSetup(ComponentSetup& rSetup, ComponentType& rSet) const
   {
      Parameter* pPoints = rSetup.Parameters().GetParameter(cParam_Points);
      if (!pPoints)
          throwCtrlExceptionMacro("", "Missing parameter" << cParam_Points);

      Parameter* pValues = rSetup.Parameters().GetParameter(cParam_Values);
      if (!pValues)
          throwCtrlExceptionMacro("", "Missing parameter" << cParam_Values);

      for (Parameter::LayerCountType iLayer = 0; iLayer<pPoints->LayerCount(); iLayer++)
      {
          typename ComponentType::PointType point = Convert::ParameterLayerToFixedArray<typename ComponentType::PointType>(*(pPoints->GetParameterLayer(iLayer)));
          rSet.GetPoints()->InsertElement(iLayer,point);

          //ComponentType::PixelType value = 0;
          //TODO cast in double as long there is no Getter Function for InternalPixelValueType (float)
          double value = 0;
          if (iLayer<pValues->LayerCount())
              pValues->GetParameterValue(value,0,iLayer);
          rSet.GetPointData()->InsertElement(iLayer,value);
      }
   };

   virtual void SaveSetToSetup(ComponentSetup& pSetup, ComponentType& rSet) const
   {
      Parameter* pPoints = pSetup.Parameters().GetParameter(cParam_Points);
      if (!pPoints)
          throwCtrlExceptionMacro("","Missing parameter" << cParam_Points);

      Parameter* pValues = pSetup.Parameters().GetParameter(cParam_Values);
      if (!pValues)
          throwCtrlExceptionMacro("", "Missing parameter" << cParam_Values);

      pPoints->Reset();
      pPoints->Resize(VDimension);
      pValues->Reset();
      pValues->Resize(1);

      for (typename ComponentType::PointsContainer::ConstIterator iter = rSet.GetPoints()->Begin(); iter != rSet.GetPoints()->End(); ++iter)
      {
          typename ComponentType::PixelType value;
          if (rSet.GetPointData(iter.Index(), &value))
              value = 0;

          //add a new layer to the points parameter
          ParameterLayer* pPointLayer = pPoints->GetParameterLayer(pPoints->AddParameterLayer());
          //copy the point elements into the parameter layer
          Convert::FixedArrayToParameterLayer<typename ComponentType::PointType>(iter.Value(),*pPointLayer);

          //add a new layer to the value parameter
          ParameterLayer* pValueLayer = pValues->GetParameterLayer(pValues->AddParameterLayer());
          pValueLayer->SetValue(value);
      }
   };
};

template <class TPixel, unsigned int VDimension>
const char* const PointSetMediaControllerBase<TPixel, VDimension> :: cParam_Points = "Points";
template <class TPixel, unsigned int VDimension>
const char* const PointSetMediaControllerBase<TPixel, VDimension> :: cParamDsc_Points = "Points of the point set.";
template <class TPixel, unsigned int VDimension>
const char* const PointSetMediaControllerBase<TPixel, VDimension> :: cParam_Values= "Values";
template <class TPixel, unsigned int VDimension>
const char* const PointSetMediaControllerBase<TPixel, VDimension> :: cParamDsc_Values = "Values assigned to each point with same ID/layer. If no value is set for a point the default value will be 0.";
template <class TPixel, unsigned int VDimension>
const char* const PointSetMediaControllerBase<TPixel, VDimension> :: cParam_PointsSource = "PointsSource";
template <class TPixel, unsigned int VDimension>
const char* const PointSetMediaControllerBase<TPixel, VDimension> :: cParamDsc_PointsSource = "Defines where the location of the point set data (therefore target of loading and saving processes) is.\n0: Setup\n1: File\n2: File (load only if needed)";

freControllerIDMacro(PointSet2DMediaController, "Point Set 2D Media");
class PointSet2DMediaController : public PointSetMediaControllerBase< InternalImagePixelType, 2>
{
public:
    typedef PointSetMediaControllerBase<InternalImagePixelType, 2> Superclass;
    typedef Superclass::ComponentType ComponentType;

    itkTypeMacro(PointSet2DMediaController, PointSetMediaControllerBase);

    PointSet2DMediaController();

    virtual ~PointSet2DMediaController();
};

freControllerIDMacro(PointSet3DMediaController, "Point Set 3D Media");
class PointSet3DMediaController : public PointSetMediaControllerBase< InternalImagePixelType, 3>
{
public:
    typedef PointSetMediaControllerBase<InternalImagePixelType, 3> Superclass;
    typedef Superclass::ComponentType ComponentType;

    itkTypeMacro(PointSet3DMediaController, PointSetMediaControllerBase);

    PointSet3DMediaController();

    virtual ~PointSet3DMediaController();
};

} //end of namespace free

#endif

---