freSetupOptimizationMetricMonitorBase.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: freSetupOptimizationMetricMonitorBase.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 __freSetupOptimizationMetricMonitorBase_h
#define __freSetupOptimizationMetricMonitorBase_h

#include "freExceptions.h"
#include "freStatistics.h"
#include "freGenericSetupToImageAdaptor.h"
#include "freControllerEvents.h"

#include "itkObject.h"
#include "itkMutexLock.h"

namespace FREE
{

class SetupOptimizationMetricResult
{
public:
  virtual void Reset() = 0;
  SetupOptimizationMetricResult() {};
};

template <typename TResultClass>
class ITK_EXPORT SetupOptimizationMetricMonitorBase : 
  public itk::Object
{
public:
  typedef SetupOptimizationMetricMonitorBase<TResultClass>   Self;
  typedef itk::Object                       Superclass;
        typedef itk::SmartPointer<Self>           Pointer;
  typedef itk::SmartPointer<const Self>     ConstPointer;

  typedef TResultClass   ResultType;

  typedef unsigned long ThreadIDType;
  typedef long AdaptationIDType;
  typedef long AdaptationCountType;
  typedef long ResultIndexType;

  typedef std::vector<AdaptationIDType> AdaptationIDListType;

  enum AdaptationStateType
  {
    ASPending = 0,       //*< Adaptation is pending in waiting for being processed
    ASProcessing = 1,    //*< Adaptation is right now in the state of being evaluated.
    ASFailed = 2,        //*< Adaptation has been processed and evaluation failed.
    ASEvaluated = 3,     //*< Adaptation has been processed and successfully evaluated.
  };

  itkTypeMacro( SetupOptimizationMetricMonitorBase, itk::Object );

  bool GetUnevaluatedAdaptedSetup(const ThreadIDType& threadID, AdaptationIDType& adaptID, Setup::Pointer& smpSetup);

  void NotifyFailedEvaluation(const ThreadIDType& threadID,const std::string& sError);

  void NotifyProgress(const ThreadIDType& threadID, const ProgressCtrlEventBase::StatusID status, const std::string& sComment);

  void EvaluationFinished(const ThreadIDType& threadID, const ResultType& results);

  void SetMetricStatistic(Statistics* pStatistic);
  Statistics* GetMetricStatistic();
  void ReleaseMetricStatistic();

  void SetGenericSetup(Setup* pSetup);
  void SetAdaptationList(Adaptation::AdaptationList* pAdaptations);

  bool GetAdaptationResults(const AdaptationIDType& adaptID, ResultType& results) const;
  
  AdaptationIDListType GetListOfPendingAdaptations() const;
  AdaptationIDListType GetListOfProcessedAdaptations() const;
  AdaptationIDListType GetListOfFailedAdaptations() const;
  AdaptationIDListType GetListOfEvaluatedAdaptations() const;
  AdaptationIDListType GetListOfAdaptationsByState(const AdaptationStateType& state) const;

  AdaptationStateType GetAdaptationState(const AdaptationIDType& adaptID) const;

  bool EvaluationIsFinished() const;

  bool IsInitialized() const;

  void Initialize();

  AdaptationCountType GetFailureCount() const;

  /*Pass through for events of the metric using the monitor*/
  ProgressEventBase::Pointer fnOnEvaluationProgress;
  ProgressEventBase::Pointer fnOnEvaluationDone;
  ProgressEventBase::Pointer fnOnNextAdaptation;
  ProgressEventBase::Pointer fnOnEvaluationFailed;

protected:

  SetupOptimizationMetricMonitorBase();

  virtual ~SetupOptimizationMetricMonitorBase();

  virtual void InsertEvaluationResults(const ResultType& results) = 0;

  virtual void CopyAdaptationResults(const ResultIndexType& index, ResultType& results) const = 0;

  virtual void EnlistResultsToStatistic(const ResultType& results, StatisticEntry& entry) = 0;

  virtual void EnlistDictionaryEntries(StatisticDictionary& dictionary) = 0;

  bool GetAdaptionProcessedByThread(const ThreadIDType& threadID, AdaptationIDType& adaptationID) const;

  bool ThreadIsProcessing(const ThreadIDType& threadID) const;

  void EnlistThreadAsProcessing(const ThreadIDType& threadID,const AdaptationIDType& adaptationID);

  void RemoveThreadFromProcessingList(const ThreadIDType& threadID);

  ResultIndexType GetResultIndexOfAdaptation(const AdaptationIDType& adaptationID) const;

  void SetAdaptationState(const AdaptationIDType& adaptID, const AdaptationStateType& state);

private:

  typedef std::vector<AdaptationStateType> AdaptationStateListType;
  AdaptationStateListType m_AdaptStates;
  mutable itk::SimpleMutexLock m_AdaptStatesMutex;

  AdaptationIDListType m_AdaptOrder;
  mutable itk::SimpleMutexLock m_AdaptOrderMutex;

  typedef std::map<ThreadIDType,AdaptationIDType> ThreadMapType;
  ThreadMapType m_AdaptThread;
  mutable itk::SimpleMutexLock m_AdaptThreadMutex;

  mutable itk::SimpleMutexLock m_ResultMutex;

  Statistics* m_pMetricStatistics;
  mutable itk::SimpleMutexLock m_StatisticMutex;

  Setup::Pointer m_smpGenericSetup;
  Adaptation::AdaptationList::Pointer m_smpAdaptations;
  GenericSetupToImageAdaptor m_Adaptor;
  mutable itk::SimpleMutexLock m_SetupMutex;

  mutable itk::SimpleMutexLock m_EventMutex;

  bool m_IsInitialized;

  SetupOptimizationMetricMonitorBase(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
};

} // end namespace FREE

#ifndef ITK_MANUAL_INSTANTIATION
#include "freSetupOptimizationMetricMonitorBase.txx"
#endif

#endif

---