freImageMediaControllerBase.txx

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: freImageMediaControllerBase.txx,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 __freImageMediaControllerBase_txx
#define __freImageMediaControllerBase_txx

#include "freImageMediaControllerBase.h"
#include "freExceptions.h"

namespace FREE
{



template <class TImage>
const char* const ImageMediaControllerBase<TImage> :: cParam_ImageSource = "ImageSource";
template <class TImage>
const char* const ImageMediaControllerBase<TImage> :: cParamDsc_ImageSource = "Indicates the source of the image. 0: user dependent. 1: load by file. 2: by callback.";
template <class TImage>
const char* const ImageMediaControllerBase<TImage> :: cParam_LoadingType = "LoadingType";
template <class TImage>
const char* const ImageMediaControllerBase<TImage> :: cParamDsc_LoadingType = "Defines the loading type of the image media. 0: load media when session is build (preload). 1: load media when needed the first time and keep media. 2: load media everytime it is needed, don't cache it in memory.";

template <class TImage>
ImageMediaControllerBase<TImage>::
ImageMediaControllerBase()
{
  //Profile settings
  this->UpdateControllerID(ControllerID::ImageMediaControllerBase);
  this->m_Description = "Base class for media based on itk::image.";
};

template <class TImage>
void
ImageMediaControllerBase<TImage>::
GenerateProfile(CtrlProfile::ControllerProfile& profile,
                const SessionComponentCache* pComponentCache,
                bool bRegardOldSetup) const
{
  Superclass::GenerateProfile(profile, pComponentCache, bRegardOldSetup);

        //Parameters
  profile.Parameters().AddParameter(cParam_ImageSource,Parameter::PVTInteger,cParamDsc_ImageSource,1,"0");
  profile.Parameters().AddParameter(cParam_LoadingType,Parameter::PVTInteger,cParamDsc_LoadingType,1,"0");

  //Media
  profile.MediaMap().AddMedia("media",this->ControllerID(), DAGet, this->GetMediaDimension());
};

template <class TImage>
ValidityTag::Pointer
ImageMediaControllerBase<TImage>::
GetMediaValidityTagRequirement(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
  if (mediaID == "media")
  {
    int iLoadingType;
    
    try
    {
      SessionAccessor::GetParameterValue(pComponentCache,cParam_LoadingType,iLoadingType);
    }
    catchAllNPassMacro("Error while retrieving loading type.");

    if (iLoadingType == 2)
    { //media is not keept in memory and therefore should allways be loaded,
      //so validity tag requirements is always "now"
      return ValidityTag::New();
    }
  }

  return Superclass::GetMediaValidityTagRequirement(mediaID, pComponentCache);
}

template <class TImage>
unsigned long
ImageMediaControllerBase<TImage>::
GetMediaDimension() const
{
  return TImage::GetImageDimension();
};

template <class TImage>
typename ImageMediaControllerBase<TImage>::ComponentPointer
ImageMediaControllerBase<TImage>::
BuildMainComponent(ComponentSetup* pComponentSetup, SessionComponentCache* pComponentCache) const
{
  int iLoadingType;
  
  try
  {
    SessionAccessor::GetParameterValue(pComponentCache,cParam_LoadingType,iLoadingType);
  }
  catchAllNPassMacro("Error while retrieving loading type.");

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

  if (iLoadingType==0)
  { //preload -> load while building
    if (!LoadMedia(pComponentCache)) throwCtrlExceptionMacro("", "Unable to load image media.");

    try
    {
      smpImage = dynamic_cast<ComponentType*>(DirectSessionComponentAccessor::GetComponent(pComponentCache));
    }
    catchAllNPassMacro("Error; component loaded wasn't the right media type.");
    if (smpImage.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(),pComponentCache);
  }

  //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 smpImage;
};

template <class TImage>
typename ImageMediaControllerBase<TImage>::ComponentPointer
ImageMediaControllerBase<TImage>::
GetComponent(const SessionComponentCache* pComponentCache) const
{
  ComponentPointer smpMedia;
  
  //get loading type
  int iLoadingType;
  
  try
  {
    SessionAccessor::GetParameterValue(pComponentCache,cParam_LoadingType,iLoadingType);
  }
  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)
  { //there is no flag indicating that the image was loaded,
    //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.");

    if (iLoadingType==2)
    { //don't cache media, media is stored in the smart pointer smpMedia,
      //so set component smart pointer (set by LoadMedia) to an empty dummy
      //media again.
      ComponentPointer smpDummy = ComponentType::New();
      DirectSessionComponentAccessor::SetComponent(smpDummy,pNonConstComponentCache);
    }
    else
    {
      //add the loaded flag, because the media is kept in memory
      DirectSessionComponentAccessor::SetRepositoryElement("LoadedFlag",itk::LightObject::New(),pNonConstComponentCache);
    }
    return smpMedia;
  }
  else
  { //it was preloaded so handle like other components
    return Superclass::GetComponent(pComponentCache);
  }
}; 


template <class TImage>
typename ImageMediaControllerBase<TImage>::GenericMediaPointer
ImageMediaControllerBase<TImage>::
GetMediaCasted(const MediaID& mediaID,ComponentType* pComponent, SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
        if (mediaID == "media")
  { 
    GenericMediaPointer smpMedia = this->GetGenericComponent(pComponentCache);
    return smpMedia;
  }

  return Superclass::GetMediaCasted(mediaID, pComponent, pComponentCache, pSessionInfo);
}; 

} //end of namespace free

#endif

---