lib/fpa/Base/Events.h

   1 #ifndef __FPA__BASE__EVENTS__H__
   2 #define __FPA__BASE__EVENTS__H__
   3
   4 #include <vector>
   5 #include <itkProcessObject.h>
   6
   7 namespace fpa
   8 {
   9   namespace Base
  10   {
  11     /**
  12      * Evolution event. An event is generated when a vertex changes its
  13      * state.
  14      */
  15     template< class N >
  16     class BaseEvent
  17       : public itk::AnyEvent
  18     {
  19     public:
  20       BaseEvent( )
  21         : itk::AnyEvent( )
  22         { }
  23       BaseEvent( const N& n )
  24         : itk::AnyEvent( ),
  25           Node( n )
  26         { }
  27       virtual ~BaseEvent( )
  28         { }
  29
  30       const char* GetEventName( ) const
  31         { return( "fpa::Base::BaseEvent" ); }
  32       bool CheckEvent( const itk::EventObject* e ) const
  33         { return( dynamic_cast< const BaseEvent< N >* >( e ) != NULL ); }
  34       itk::EventObject* MakeObject( ) const
  35         { return( new BaseEvent< N >( ) ); }
  36
  37     public:
  38       N Node;
  39     };
  40
  41     /**
  42      */
  43     template< class N >
  44     class FrontEvent
  45       : public BaseEvent< N >
  46     {
  47     public:
  48       FrontEvent( )
  49         : BaseEvent< N >( )
  50         { }
  51       FrontEvent( const N& n )
  52         : BaseEvent< N >( n )
  53         { }
  54       virtual ~FrontEvent( )
  55         { }
  56       const char* GetEventName( ) const
  57         { return( "fpa::Base::FrontEvent" ); }
  58       bool CheckEvent( const itk::EventObject* e ) const
  59         { return( dynamic_cast< const FrontEvent< N >* >( e ) != NULL ); }
  60       itk::EventObject* MakeObject( ) const
  61         { return( new FrontEvent< N >( ) ); }
  62     };
  63
  64     /**
  65      */
  66     template< class N >
  67     class MarkEvent
  68       : public BaseEvent< N >
  69     {
  70     public:
  71       MarkEvent( )
  72         : BaseEvent< N >( )
  73         { }
  74       MarkEvent( const N& n )
  75         : BaseEvent< N >( n )
  76         { }
  77       virtual ~MarkEvent( )
  78         { }
  79       const char* GetEventName( ) const
  80         { return( "fpa::Base::MarkEvent" ); }
  81       bool CheckEvent( const itk::EventObject* e ) const
  82         { return( dynamic_cast< const MarkEvent< N >* >( e ) != NULL ); }
  83       itk::EventObject* MakeObject( ) const
  84         { return( new MarkEvent< N >( ) ); }
  85     };
  86
  87     /**
  88      */
  89     template< class N >
  90     class CollisionEvent
  91       : public BaseEvent< N >
  92     {
  93     public:
  94       CollisionEvent( )
  95         : BaseEvent< N >( )
  96         { }
  97       CollisionEvent( const N& n )
  98         : BaseEvent< N >( n )
  99         { }
 100       virtual ~CollisionEvent( )
 101         { }
 102       const char* GetEventName( ) const
 103         { return( "fpa::Base::CollisionEvent" ); }
 104       bool CheckEvent( const itk::EventObject* e ) const
 105         { return( dynamic_cast< const CollisionEvent< N >* >( e ) != NULL ); }
 106       itk::EventObject* MakeObject( ) const
 107         { return( new CollisionEvent< N >( ) ); }
 108     };
 109
 110     /**
 111      */
 112     template< class N >
 113     class EndEvent
 114       : public BaseEvent< N >
 115     {
 116     public:
 117       EndEvent( )
 118         : BaseEvent< N >( )
 119         { }
 120       virtual ~EndEvent( )
 121         { }
 122       const char* GetEventName( ) const
 123         { return( "fpa::Base::EndEvent" ); }
 124       bool CheckEvent( const itk::EventObject* e ) const
 125         { return( dynamic_cast< const EndEvent< N >* >( e ) != NULL ); }
 126       itk::EventObject* MakeObject( ) const
 127         { return( new EndEvent< N >( ) ); }
 128     };
 129
 130     /**
 131      */
 132     template< class N >
 133     class BacktrackingEvent
 134       : public BaseEvent< N >
 135     {
 136     public:
 137       BacktrackingEvent( )
 138         : BaseEvent< N >( )
 139         { }
 140       BacktrackingEvent( const N& n, const unsigned long& id )
 141         : BaseEvent< N >( n ),
 142         BackId( id )
 143         { }
 144       virtual ~BacktrackingEvent( )
 145         { }
 146       const char* GetEventName( ) const
 147         { return( "fpa::Base::BacktrackingEvent" ); }
 148       bool CheckEvent( const itk::EventObject* e ) const
 149         {
 150           return(
 151             dynamic_cast< const BacktrackingEvent< N >* >( e ) != NULL
 152             );
 153         }
 154       itk::EventObject* MakeObject( ) const
 155         { return( new BacktrackingEvent< N >( ) ); }
 156
 157       unsigned long BackId;
 158     };
 159
 160     /**
 161      */
 162     template< class N >
 163     class EndBacktrackingEvent
 164       : public BaseEvent< N >
 165     {
 166     public:
 167       EndBacktrackingEvent( )
 168         : BaseEvent< N >( )
 169         { }
 170       EndBacktrackingEvent( const unsigned long& id )
 171         : BaseEvent< N >( ),
 172         BackId( id )
 173         { }
 174       virtual ~EndBacktrackingEvent( )
 175         { }
 176       const char* GetEventName( ) const
 177         { return( "fpa::Base::EndBacktrackingEvent" ); }
 178       bool CheckEvent( const itk::EventObject* e ) const
 179         {
 180           return(
 181             dynamic_cast< const EndBacktrackingEvent< N >* >( e ) != NULL
 182             );
 183         }
 184       itk::EventObject* MakeObject( ) const
 185         { return( new EndBacktrackingEvent< N >( ) ); }
 186
 187       unsigned long BackId;
 188     };
 189
 190   } // ecapseman
 191
 192 } // ecapseman
 193
 194 #endif // __FPA__BASE__EVENTS__H__
 195
 196 // eof - $RCSfile$