freMediaActualizerController.cxx

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: freMediaActualizerController.cxx,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.

=========================================================================*/

#include "freMediaActualizerController.h"
#include "freTransformFieldMediaController.h"
#include "freTransformFunctionMediaController.h"

namespace FREE
{
DefineParameterMacro(MediaActualizerController,PersistentResult,"PersistentResult","Indicates if the result should be cached internally and only will be recomputed if the source of the filter is outdated. Keeping the image persistent accelerates the processing, but requires more memory.");
DefineParameterMacro(MediaActualizerController,UseField,"UseField","Indicates if the media should be actualized by using a field (true) or by using a transformation function (false).");

DefineMediaIDMacro(MediaActualizerController,deformationField,"deformationField","The deformation field that can be used for actualization.");
DefineMediaIDMacro(MediaActualizerController,transformFunction,"deformationTransformFunction","The transformation function that can be used for actualization.");

ValidityTag::Pointer
MediaActualizerController::
GetMediaValidityTag(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Passed component cache is NULL.");

  if ((mediaID!=MediaID_deformationField) && (mediaID!=MediaID_transformFunction))
  { //it could be one of the media that should be actualized
    //so check for stored tags, because they may be persistent
    std::string sElementKey = SessionComponentRepositoryKeys::MediaValidity(mediaID);
    SessionComponentCache::GenericComponentPointer smpGenericTag = DirectSessionComponentAccessor::GetRepositoryElement(sElementKey,pComponentCache);

    ValidityTag::Pointer smpTag;

    if (smpGenericTag.IsNotNull())
    { //there is a tag saved for the media
      try
      {
        smpTag = dynamic_cast<ValidityTag*>(smpGenericTag.GetPointer());
      }
      catchAllNPassMacro("Error; cannot determine the media validity tag. Found a repository element, but element was not of type ValidityTag. MediaID :" << mediaID);
      if (smpTag.IsNull()) throwCtrlExceptionMacro("","Error; cannot determine the media validity tag. Found a repository element, but element was not of type ValidityTag. MediaID :" << mediaID);
    }
    else
    { //the media has never been actualized before, so its tag is always outdated
      smpTag = ValidityTag::NewNull();
    }
    return smpTag;
  }
  else
  {
    //Media is deformation field or transform function
    ComponentMediaLink::Pointer smpLink = pComponentCache->Setup()->MediaLinks().GetElement(mediaID);
    if (smpLink.IsNotNull())
    { //there is a link for the media, so get the validity tag
      try
      {
        return SessionAccessor::GetValidityTag(smpLink->GetSourceIDPath(),pComponentCache);
      }
      catchAllNPassMacro("Error while retrieving validity tag. Media ID: "<<mediaID<<" ; link: "<<smpLink->GetSourceIDPath().ToStr());
    }
    else
    {
      return Superclass::GetMediaValidityTag(mediaID, pComponentCache);
    }
  }
}; 


ValidityTag::Pointer
MediaActualizerController::
GetMediaValidityTagRequirement(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Passed component cache is NULL.");

  if ((mediaID!=MediaID_deformationField) && (mediaID!=MediaID_transformFunction))
  { //it is a media that should be actualized
    ValidityTag::Pointer smpReq = ValidityTag::New(this->GetMediaValidityTag(mediaID,pComponentCache)->GetTimeStamp());


    //check the deformation field
    ValidityTag::Pointer smpActualizerReq;

    if (UseField(pComponentCache))
    {
      smpActualizerReq = this->GetMediaValidityTagRequirement(MediaID_deformationField,pComponentCache);
    }
    else
    {
      smpActualizerReq = this->GetMediaValidityTagRequirement(MediaID_transformFunction,pComponentCache);
    }

    if (smpReq->IsOutdated(smpActualizerReq))
    { //deformation field is newer then media, so there is a need for actualization.
        smpReq->SetTag(smpActualizerReq);
    }
    return smpReq;
  }

  ComponentMediaLink::Pointer smpLink = pComponentCache->Setup()->MediaLinks().GetElement(mediaID);
  if (smpLink.IsNotNull())
  { //there is a link for the media, so get the validity tag requirement
    try
    {
      return SessionAccessor::GetValidityTagRequirement(smpLink->GetSourceIDPath(),pComponentCache);
    }
    catchAllNPassMacro("Error while retrieving validity tag requirement. Media ID: "<<mediaID<<" ; link: "<<smpLink->GetSourceIDPath().ToStr());
  }
  else
  {
    return Superclass::GetMediaValidityTagRequirement(mediaID, pComponentCache);
  }
}; 

bool
MediaActualizerController::
UseField(SessionComponentCache* pComponentCache) const
{
  bool bUseField = true;
  SessionAccessor::GetParameterValue(pComponentCache,cParam_UseField,bUseField);

  return bUseField;
}

std::string
MediaActualizerController::
GetMediaControllerID(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
  if (!pComponentCache) throwCtrlExceptionMacro("","Passed component cache is NULL.");

  ComponentMediaLink::Pointer smpLink = pComponentCache->Setup()->MediaLinks().GetElement(mediaID);
  if (smpLink.IsNotNull())
  { //there is a link for the media, so get controller id
    try
    {
      return SessionAccessor::GetMediaControllerID(smpLink->GetSourceIDPath(),pComponentCache);
    }
    catchAllNPassMacro("Error while retrieving controller id. Media ID: "<<mediaID<<" ; link: "<<smpLink->GetSourceIDPath().ToStr());
  }

        return csUndefinedController;
}; 

MediaActualizerController::
MediaActualizerController()
{
  //Profile settings
  this->UpdateControllerID(ControllerID::MediaActualizerController);
  this->m_Description = "Actualizes media via a given deformation field";
};

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

    //Parameters
    profile.Parameters().AddParameter(cParam_PersistentResult,Parameter::PVTBool,cParamDsc_PersistentResult,1,"true");
    profile.Parameters().AddParameter(cParam_UseField,Parameter::PVTBool,cParamDsc_UseField,1,"true");

    //Media
    profile.MediaMap().AddMedia(MediaID_deformationField,ControllerID::TransformFieldMediaControllerBase,DASet,CtrlProfile::Media::DT_AllDimensions,0);
    profile.MediaMap().AddMedia(MediaID_transformFunction,ControllerID::TransformFunctionMediaControllerBase,DASet,CtrlProfile::Media::DT_AllDimensions,0);

     //template for target media
    profile.MediaMap().AddMedia("targetMedia",ControllerID::MediaControllerBase,DAAny)->SetIsTemplate(true);
  };

MediaActualizerController::
GenericMediaPointer
MediaActualizerController::
GetMediaCasted(const MediaID& mediaID, ComponentType* pComponent,
                                                   SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  if ((mediaID!=MediaID_deformationField) && (mediaID!=MediaID_transformFunction))
  {
    //check if there is a media link
    ComponentMediaLink::Pointer smpLink = pComponentCache->Setup()->MediaLinks().GetElement(mediaID);
    if (smpLink.IsNotNull())
    { //there is a link for the media, so it might need a little update
      GenericMediaPointer smpMedia;

      ValidityTag::Pointer smpVal = this->GetMediaValidityTag(mediaID,pComponentCache);
      ValidityTag::Pointer smpValReq = this->GetMediaValidityTagRequirement(mediaID,pComponentCache);

      bool bKeep = true;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_PersistentResult,bKeep);

      if (smpVal->IsOutdated(smpValReq) || (!bKeep))
      { //media is outdated -> compute actualized media
        this->NotifyProgress(1,"Media outdated -> actualize",pComponentCache);


        if (UseField(pComponentCache))
        {
          ComponentMediaLink::Pointer smpFieldLink = pComponentCache->Setup()->MediaLinks().GetElement(MediaID_deformationField);
          if (smpFieldLink.IsNull()) throwCtrlExceptionMacro("","Error, cannot actualize media. Deformation field is not defined.");

          try
          {
            //actualize media
            smpMedia = pComponent->ActualizeMediaByField(pSessionInfo,smpLink->GetSourceIDPath(),smpFieldLink->GetSourceIDPath());
          }
          catchAllNPassMacro("Error while actualizing the media.");
        }
        else
        {
          ComponentMediaLink::Pointer smpFunctLink = pComponentCache->Setup()->MediaLinks().GetElement(MediaID_transformFunction);
          if (smpFunctLink.IsNull()) throwCtrlExceptionMacro("","Error, cannot actualize media. Transform function is not defined.");

          try
          {
            //actualize media
            smpMedia = pComponent->ActualizeMediaByFunction(pSessionInfo,smpLink->GetSourceIDPath(),smpFunctLink->GetSourceIDPath());
          }
          catchAllNPassMacro("Error while actualizing the media.");
        }
        
        if (bKeep) DirectSessionComponentAccessor::SetRepositoryElement(mediaID,smpMedia,pComponentCache);
        this->ActualizeMediaValidityTag(mediaID,pComponentCache);
      }
      else
      { //media is up to date and cached, so just return
        smpMedia = DirectSessionComponentAccessor::GetRepositoryElement(mediaID,pComponentCache);
      }
      return smpMedia;
    }
  }
    
        return Superclass::GetMediaCasted(mediaID, pComponent, pComponentCache, pSessionInfo);
}; 
  
void
MediaActualizerController::
SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia,
                                                                                                                        ComponentType* pComponent, SessionComponentCache* pComponentCache,
                              SessionInfo* pSessionInfo) const
        {
                if (mediaID == MediaID_deformationField)
    {
      //deformationField will be ordered by the component when needed
    }
                else if (mediaID == MediaID_transformFunction)
    {
      //transformFunction will be requested by the component when needed
    }
                else Superclass::SetMediaCasted(mediaID, pMedia, pComponent, pComponentCache, pSessionInfo);
        }; 


} //end of namespace free

---