...

[FrontAlgorithms.git] / lib / fpa / Base / Events.h

diff --git a/lib/fpa/Base/Events.h b/lib/fpa/Base/Events.h
index ad662abdf65d90886ba730d0d3e4dee81e7c3bb3..17c55649cece70841cfaa2558b4be6528e604956 100644 (file)
--- a/lib/fpa/Base/Events.h
+++ b/lib/fpa/Base/Events.h
@@ -1,18 +1,46 @@
-#ifndef __FPA__BASE__EVENTS__H__
-#define __FPA__BASE__EVENTS__H__
+#ifndef __fpa__Base__Events__h__
+#define __fpa__Base__Events__h__
 
-#include <vector>
-#include <itkProcessObject.h>
+// -------------------------------------------------------------------------
+#define fpa_Base_NewEvent( name )                               \
+  class name                                                    \
+    : public BaseEvent                                          \
+  {                                                             \
+  public:                                                       \
+    name( ) : BaseEvent( ) { }                                  \
+    virtual ~name( ) { }                                        \
+    const char* GetEventName( ) const                           \
+    { return( "fpa::Base::##name" ); }                          \
+    bool CheckEvent( const itk::EventObject* e ) const          \
+    { return( dynamic_cast< const name* >( e ) != NULL ); }     \
+    itk::EventObject* MakeObject( ) const                       \
+    { return( new name( ) ); }                                  \
+  };
+
+// -------------------------------------------------------------------------
+#define fpa_Base_NewEventWithVertex( name, type )               \
+  class name                                                    \
+    : public BaseEventWithVertex< type >                        \
+  {                                                             \
+  public:                                                       \
+    name( ) : BaseEventWithVertex< type >( ) { }                \
+    name( const type& v, long fid )                             \
+        : BaseEventWithVertex< type >( v, fid ) { }             \
+    virtual ~name( ) { }                                        \
+    const char* GetEventName( ) const                           \
+    { return( "fpa::Base::##name" ); }                          \
+    bool CheckEvent( const itk::EventObject* e ) const          \
+    { return( dynamic_cast< const name* >( e ) != NULL ); }     \
+    itk::EventObject* MakeObject( ) const                       \
+    { return( new name( ) ); }                                  \
+  };
 
 namespace fpa
 {
   namespace Base
   {
     /**
-     * Evolution event. An event is generated when a vertex changes its
-     * state.
      */
-    template< class N >
     class BaseEvent
       : public itk::AnyEvent
     {
@@ -20,147 +48,53 @@ namespace fpa
       BaseEvent( )
         : itk::AnyEvent( )
         { }
-      BaseEvent( const N& n )
-        : itk::AnyEvent( ),
-          Node( n )
-        { }
       virtual ~BaseEvent( )
         { }
-
       const char* GetEventName( ) const
         { return( "fpa::Base::BaseEvent" ); }
       bool CheckEvent( const itk::EventObject* e ) const
-        { return( dynamic_cast< const BaseEvent< N >* >( e ) != NULL ); }
+        { return( dynamic_cast< const BaseEvent* >( e ) != NULL ); }
       itk::EventObject* MakeObject( ) const
-        { return( new BaseEvent< N >( ) ); }
-
-    public:
-      N Node;
+        { return( new BaseEvent( ) ); }
     };
 
     /**
      */
-    template< class N >
-    class FrontEvent
-      : public BaseEvent< N >
+    template< class _TVertex >
+    class BaseEventWithVertex
+      : public BaseEvent
     {
     public:
-      FrontEvent( )
-        : BaseEvent< N >( )
+      BaseEventWithVertex( )
+        : BaseEvent( )
         { }
-      FrontEvent( const N& n )
-        : BaseEvent< N >( n )
+      BaseEventWithVertex( const _TVertex& v, long fid )
+        : BaseEvent( ),
+          Vertex( v ),
+          FrontId( fid )
         { }
-      virtual ~FrontEvent( )
+      virtual ~BaseEventWithVertex( )
         { }
       const char* GetEventName( ) const
-        { return( "fpa::Base::FrontEvent" ); }
-      bool CheckEvent( const itk::EventObject* e ) const
-        { return( dynamic_cast< const FrontEvent< N >* >( e ) != NULL ); }
-      itk::EventObject* MakeObject( ) const
-        { return( new FrontEvent< N >( ) ); }
-    };
-
-    /**
-     */
-    template< class N >
-    class MarkEvent
-      : public BaseEvent< N >
-    {
-    public:
-      MarkEvent( )
-        : BaseEvent< N >( )
-        { }
-      MarkEvent( const N& n )
-        : BaseEvent< N >( n )
-        { }
-      virtual ~MarkEvent( )
-        { }
-      const char* GetEventName( ) const
-        { return( "fpa::Base::MarkEvent" ); }
-      bool CheckEvent( const itk::EventObject* e ) const
-        { return( dynamic_cast< const MarkEvent< N >* >( e ) != NULL ); }
-      itk::EventObject* MakeObject( ) const
-        { return( new MarkEvent< N >( ) ); }
-    };
-
-    /**
-     */
-    template< class N >
-    class CollisionEvent
-      : public BaseEvent< N >
-    {
-    public:
-      CollisionEvent( )
-        : BaseEvent< N >( )
-        { }
-      CollisionEvent( const N& n )
-        : BaseEvent< N >( n )
-        { }
-      virtual ~CollisionEvent( )
-        { }
-      const char* GetEventName( ) const
-        { return( "fpa::Base::CollisionEvent" ); }
-      bool CheckEvent( const itk::EventObject* e ) const
-        { return( dynamic_cast< const CollisionEvent< N >* >( e ) != NULL ); }
-      itk::EventObject* MakeObject( ) const
-        { return( new CollisionEvent< N >( ) ); }
-    };
-
-    /**
-     */
-    template< class N >
-    class EndEvent
-      : public BaseEvent< N >
-    {
-    public:
-      EndEvent( )
-        : BaseEvent< N >( )
-        { }
-      virtual ~EndEvent( )
-        { }
-      const char* GetEventName( ) const
-        { return( "fpa::Base::EndEvent" ); }
-      bool CheckEvent( const itk::EventObject* e ) const
-        { return( dynamic_cast< const EndEvent< N >* >( e ) != NULL ); }
-      itk::EventObject* MakeObject( ) const
-        { return( new EndEvent< N >( ) ); }
-    };
-
-    /**
-     */
-    template< class N >
-    class BacktrackingEvent
-      : public BaseEvent< N >
-    {
-    public:
-      BacktrackingEvent( )
-        : BaseEvent< N >( )
-        { }
-      BacktrackingEvent( const N& n, const unsigned long& id )
-        : BaseEvent< N >( n ),
-          BackId( id )
-        { }
-      virtual ~BacktrackingEvent( )
-        { }
-      const char* GetEventName( ) const
-        { return( "fpa::Base::BacktrackingEvent" ); }
+        { return( "fpa::Base::BaseEventWithVertex" ); }
       bool CheckEvent( const itk::EventObject* e ) const
         {
           return(
-            dynamic_cast< const BacktrackingEvent< N >* >( e ) != NULL
+            dynamic_cast< const BaseEventWithVertex< _TVertex >* >( e ) != NULL
             );
         }
       itk::EventObject* MakeObject( ) const
-        { return( new BacktrackingEvent< N >( ) ); }
+        { return( new BaseEventWithVertex< _TVertex >( ) ); }
 
-      unsigned long BackId;
+    public:
+      _TVertex Vertex;
+      long     FrontId;
     };
 
   } // ecapseman
 
 } // ecapseman
 
-#endif // __FPA__BASE__EVENTS__H__
+#endif // __fpa__Base__Events__h__
 
 // eof - $RCSfile$