freImageToImageFilterControllerBase.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: freImageToImageFilterControllerBase.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 __freImageToImageFilterControllerBase_txx
#define __freImageToImageFilterControllerBase_txx

#include "freImageToImageFilterControllerBase.h"
#include "freIntensityImageMediaController.h"

namespace FREE
{
template <class TControlledFilter>
const char* const ImageToImageFilterControllerBase<TControlledFilter> :: cParam_PersistentResult = "PersistentResult";
template <class TControlledFilter>
const char* const ImageToImageFilterControllerBase<TControlledFilter> :: cParamDsc_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.";

template <class TControlledFilter>
ValidityTag::Pointer
ImageToImageFilterControllerBase<TControlledFilter>::
GetMediaValidityTagRequirement(const MediaID& mediaID, SessionComponentCache* pComponentCache) const
{
  if (mediaID == "output")
  {
    ValidityTag::Pointer smpReq = ValidityTag::New(this->GetMediaValidityTag(mediaID,pComponentCache)->GetTimeStamp());
    this->CompareValidityTagRequirement("input",smpReq,pComponentCache);
    return smpReq;
  }

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

template <class TControlledFilter>
ImageToImageFilterControllerBase<TControlledFilter>::
ImageToImageFilterControllerBase():ProcessorControllerBase<TControlledFilter>()
{       
  //Profile settings
  this->UpdateControllerID(ControllerID::ImageToImageFilterControllerBase);
  this->m_Description = "Basic class for controller of itk based image filters.";
};

template <class TControlledFilter>
void
ImageToImageFilterControllerBase<TControlledFilter>::
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");

  //Media
  profile.MediaMap().AddMedia("input",ControllerID::IntensityImageMediaControllerBase,DASet,ComponentType::InputImageType::ImageDimension);
  profile.MediaMap().AddMedia("output",ControllerID::IntensityImageMediaControllerBase,DAGet,ComponentType::InputImageType::ImageDimension);
};

template <class TControlledFilter>
typename ImageToImageFilterControllerBase<TControlledFilter>::GenericMediaPointer
ImageToImageFilterControllerBase<TControlledFilter>::
GetMediaCasted(const MediaID& mediaID,ComponentType* pComponent, SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
        if (mediaID == "output")
  {
    ValidityTag::Pointer smpVal = this->GetMediaValidityTag("output",pComponentCache);
    ValidityTag::Pointer smpValReq = this->GetMediaValidityTagRequirement("output",pComponentCache);

    bool bPersistent = false;

    try
    {
      bPersistent = true;
      SessionAccessor::GetParameterValue(pComponentCache,cParam_PersistentResult,bPersistent);
    }
    catchAllNPassMacro("Error; cannot retrieve media \"output\". Parameter is missing in component setup. Missing parameter: "<<cParam_PersistentResult);

    GenericMediaPointer smpMedia;

    if (smpVal->IsOutdated(smpValReq) || (!bPersistent))
    { //output is outdated or not cached -> compute output

      this->NotifyProgress(1,"Output outdated -> actualize",pComponentCache);
      SessionBuilder::LinkMediaToComponent(pComponentCache, pSessionInfo);
      SessionBuilder::ActualizeComponent(pComponentCache, pSessionInfo);

      pComponent->ReleaseDataFlagOn();

      StatisticEntry* pFilterEntry = this->AddStatisticEntry(pComponentCache, pSessionInfo, "FilterOutput", "Computation of the filter output");

      smpMedia = ComputeMedia(mediaID,pComponent,pComponentCache,pSessionInfo);
            
      if (pFilterEntry)
      {
        this->SetStatisticEntry(*pFilterEntry,pComponentCache,pSessionInfo);
        pFilterEntry->CloseEntry();
      }

      if (bPersistent) DirectSessionComponentAccessor::SetRepositoryElement("output",smpMedia,pComponentCache);
      
      this->ResetComponent(pComponentCache,pSessionInfo);

      this->NotifyProgress(1,"Output up to date",pComponentCache);
      this->ActualizeMediaValidityTag("output",pComponentCache);
    }
    else
    {
      smpMedia = DirectSessionComponentAccessor::GetRepositoryElement("output",pComponentCache);
    }

    return smpMedia;
  }

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

template <class TControlledFilter>
void
ImageToImageFilterControllerBase<TControlledFilter>::
ActualizeMainComponent(ComponentType* pMainComponent,
                                      SessionComponentCache* pComponentCache,
                                      SessionInfo* pSessionInfo,
                                                                                                                                                        const unsigned int& iActLevel) const
{
  Superclass::ActualizeMainComponent(pMainComponent,pComponentCache, pSessionInfo, iActLevel);

  bool bPersistent = false;

  try
  {
    bPersistent = true;
    SessionAccessor::GetParameterValue(pComponentCache,cParam_PersistentResult,bPersistent);
  }
  catchAllNPassMacro("Error; cannot actualize setup. Parameter is missing in component setup. Missing parameter: "<<cParam_PersistentResult);

  if (bPersistent)
  {
    pMainComponent->ReleaseDataFlagOff();
    pMainComponent->ReleaseDataBeforeUpdateFlagOff();
  }
  else
  {
    pMainComponent->ReleaseDataFlagOn();
    pMainComponent->ReleaseDataBeforeUpdateFlagOn();
  }
};

template <class TControlledFilter>
typename ImageToImageFilterControllerBase<TControlledFilter>::GenericMediaPointer
ImageToImageFilterControllerBase<TControlledFilter>::
ComputeMedia(const MediaID& mediaID,ComponentType* pComponent, SessionComponentCache* pComponentCache, SessionInfo* pSessionInfo) const
{
  GenericMediaPointer smpMedia;

  if (mediaID == "output")
  {
    pComponent->Update();
    typename ComponentType::OutputImagePointer smpOutput = pComponent->GetOutput();

    //TODO Disconnect from Pipe. In the actual version of f.r.e.e. the controller should handle
    //the updating. Decide for upcoming version if itk propagating functionality schould be used
    //Right now it creates double computation, when e.g. a registration calls Update for the already
    //actualized inputs.
    smpOutput->DisconnectPipeline();
      
    smpMedia = smpOutput.GetPointer();
  }
  else throwCtrlExceptionMacro("", "Error. Only the computation of mediaID \"output\" is possible. Invalide mediaID: "<<mediaID);

  return smpMedia;
}

template <class TControlledFilter>
void
ImageToImageFilterControllerBase<TControlledFilter>::
SetMediaCasted(const MediaID& mediaID, GenericMediaType* pMedia, ComponentType* pComponent, SessionComponentCache* pComponentCache,
               SessionInfo* pSessionInfo) const
{
  if (mediaID == "input")
  {
    pComponent->SetInput(dynamic_cast<typename TControlledFilter::InputImageType*>(pMedia));
    this->ActualizeMediaValidityTag("input",pComponentCache);
  }
  else Superclass::SetMediaCasted(mediaID, pMedia, pComponent, pComponentCache, pSessionInfo);
}; 

} //end of namespace free

#endif

---