#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
{
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 ); }
- itk::EventObject* MakeObject( ) const
- { return( new BaseEvent< N >( ) ); }
-
- public:
- N Node;
- };
-
- /**
- */
- template< class N >
- class FrontEvent
- : public BaseEvent< N >
- {
- public:
- FrontEvent( )
- : BaseEvent< N >( )
- { }
- FrontEvent( const N& n )
- : BaseEvent< N >( n )
- { }
- virtual ~FrontEvent( )
- { }
- 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 ); }
+ { return( dynamic_cast< const BaseEvent* >( e ) != NULL ); }
itk::EventObject* MakeObject( ) const
- { return( new EndEvent< N >( ) ); }
+ { return( new BaseEvent( ) ); }
};
/**
*/
- template< class N >
- class BacktrackingEvent
- : public BaseEvent< N >
+ template< class V >
+ class BaseEventWithVertex
+ : public BaseEvent
{
public:
- BacktrackingEvent( )
- : BaseEvent< N >( )
+ BaseEventWithVertex( )
+ : BaseEvent( )
{ }
- BacktrackingEvent( const N& n, const unsigned long& id )
- : BaseEvent< N >( n ),
- BackId( id )
+ BaseEventWithVertex( const V& v, long fid )
+ : BaseEvent( ),
+ Vertex( v ),
+ FrontId( fid )
{ }
- virtual ~BacktrackingEvent( )
+ virtual ~BaseEventWithVertex( )
{ }
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< V >* >( e ) != NULL
);
}
itk::EventObject* MakeObject( ) const
- { return( new BacktrackingEvent< N >( ) ); }
-
- unsigned long BackId;
- };
+ { return( new BaseEventWithVertex< V >( ) ); }
- /**
- */
- template< class N >
- class EndBacktrackingEvent
- : public BaseEvent< N >
- {
public:
- EndBacktrackingEvent( )
- : BaseEvent< N >( )
- { }
- EndBacktrackingEvent( const unsigned long& id )
- : BaseEvent< N >( ),
- BackId( id )
- { }
- virtual ~EndBacktrackingEvent( )
- { }
- const char* GetEventName( ) const
- { return( "fpa::Base::EndBacktrackingEvent" ); }
- bool CheckEvent( const itk::EventObject* e ) const
- {
- return(
- dynamic_cast< const EndBacktrackingEvent< N >* >( e ) != NULL
- );
- }
- itk::EventObject* MakeObject( ) const
- { return( new EndBacktrackingEvent< N >( ) ); }
-
- unsigned long BackId;
+ V Vertex;
+ long FrontId;
};
} // ecapseman