freRegistrationEvents.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: freRegistrationEvents.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 __freRegistrationEvents_h
#define __freRegistrationEvents_h

#include "freEvents.h"
#include "freStatistics.h"

namespace FREE
{
class IterationEventBase: public NotificationEventBase
{
public:
  typedef void (*NextIterationEvent)(const long& IterationStep, Statistics* pStatistic, void* pSender, long threadID);

         typedef itk::SmartPointer<IterationEventBase> Pointer;

         freNewEventBaseMacro(IterationEventBase,NextIterationEvent);
         itkTypeMacro(IterationEventBase,NotificationEventBase);

private:
   NextIterationEvent m_IterationEvent;

protected:
  IterationEventBase();
  IterationEventBase(NextIterationEvent pNIE);

public:
  virtual void Execute(const long IterationStep, Statistics* pStatistic, void* pSender, long threadID = 0);
};

class LevelEventBase: public NotificationEventBase
{
public:
  typedef void (*NextLevelEvent)(const unsigned int iID, void* pSender, long threadID);

  typedef itk::SmartPointer<LevelEventBase> Pointer;

        freNewEventBaseMacro(LevelEventBase,NextLevelEvent);
        itkTypeMacro(LevelEventBase,NotificationEventBase);

private:
   NextLevelEvent m_LevelEvent;

protected:
  LevelEventBase(); 
  LevelEventBase(NextLevelEvent pNLE);
  
public:
  virtual void Execute(const unsigned int iID, void* pSender, long threadID = 0);
};

template <typename T>
class IterationEvent : public IterationEventBase
{
public:
  typedef void (T::*NextIterationEvent)(const long lIteration, Statistics* pStatistic, void* pSender, long threadID);

  typedef itk::SmartPointer<IterationEvent<T> > Pointer;

  freNewEventMacro(IterationEvent, T, NextIterationEvent);
        itkTypeMacro(IterationEvent,IterationEventBase);

private:
   T* m_Object;
   NextIterationEvent m_IterationEvent;

protected:
   IterationEvent(T* pObject, NextIterationEvent pNIE)
   {
         m_Object = pObject;
         m_IterationEvent = pNIE;
   };
   
public:
  virtual void Execute(const long lIteration, Statistics* pStatistic, void* pSender, long threadID = 0)
   { (m_Object->*m_IterationEvent)(lIteration, pStatistic, pSender, threadID); };
};

template <typename T>
class LevelEvent : public LevelEventBase
{
public:
  typedef void (T::*NextLevelEvent)(const unsigned int iID, void* pSender, long threadID);

  typedef itk::SmartPointer<LevelEvent<T> > Pointer;

  freNewEventMacro(LevelEvent, T, NextLevelEvent);
        itkTypeMacro(LevelEvent,LevelEventBase);

private:
   T* m_Object;
   NextLevelEvent m_LevelEvent;

protected:
   LevelEvent(T* pObject, NextLevelEvent pNLE)
       : m_Object(pObject), m_LevelEvent(pNLE)
   {};

public:
   
  virtual void Execute(const unsigned int iID, void* pSender, long threadID = 0)
  { (m_Object->*m_LevelEvent)(iID, pSender, threadID); };
};

class RegistrationProgressEventBase: public NotificationEventBase
{
public:
   typedef void (*ProgEvent)(const RegistrationStatusType status,
                                                                       const std::string  sComment,
                             void* pSender,
                             long threadID);

  typedef itk::SmartPointer<RegistrationProgressEventBase> Pointer;

        freNewEventBaseMacro(RegistrationProgressEventBase,ProgEvent);
        itkTypeMacro(RegistrationProgressEventBase,NotificationEventBase);

private:
   ProgEvent m_ProgressEvent;

protected:
   RegistrationProgressEventBase();
   RegistrationProgressEventBase(ProgEvent pPE);

public:
   virtual void Execute(const RegistrationStatusType status,
                                                                                                const std::string  sComment,
                        void* pSender,
                        long threadID = 0);
};

template <typename T>
class RegistrationProgressEvent: public RegistrationProgressEventBase
{
public:
   typedef void (T::*ProgEvent)(const RegistrationStatusType status,
                                                                                const std::string  sComment,
                                void* pSender,
                                long threadID);

  typedef itk::SmartPointer<RegistrationProgressEvent<T> > Pointer;

  freNewEventMacro(RegistrationProgressEvent, T, ProgEvent);
        itkTypeMacro(RegistrationProgressEvent,RegistrationProgressEventBase);

private:
   T* m_Object;
   ProgEvent m_ProgressEvent;

protected:
   RegistrationProgressEvent(T* pObject, ProgEvent pPE)
   {
          m_Object = pObject;
          m_ProgressEvent = pPE;
   };
   
public:
   virtual void Execute(const RegistrationStatusType status,
                                                            const std::string  sComment,
                        void* pSender,
                        long threadID = 0)
   { (m_Object->*m_ProgressEvent)(status, sComment, pSender, threadID); };
};

} //end of namespace free
#endif

---