#ifndef __FPA__BASE__ALGORITHM__H__
#define __FPA__BASE__ALGORITHM__H__
-#include <map>
-#include <vector>
#include <utility>
+#include <vector>
#include <fpa/Base/Events.h>
namespace fpa
* vertex could be marked as "visited", "in the front", "not yet there"
* or "freezed".
*
- * @param T Traits used for this algorithm
+ * @param V Vertex type.
+ * @param C Vertex value type.
+ * @param R Result value type.
+ * @param B Base class for this algorithm. It should be any itk-based
+ * filter (itk::ProcessObject).
+ *
*/
- template< class T, class B >
+ template< class V, class C, class R, class B >
class Algorithm
: public B
{
public:
- // Standard class typdedefs
typedef Algorithm Self;
typedef B Superclass;
typedef itk::SmartPointer< Self > Pointer;
typedef itk::SmartPointer< const Self > ConstPointer;
- /// Templated types
- typedef T TTraits;
- typedef B TBaseFilter;
- typedef typename T::TCost TCost;
- typedef typename T::TResult TResult;
- typedef typename T::TVertex TVertex;
- typedef typename T::TVertexValue TVertexValue;
-
- protected:
- typedef typename T::TFrontId _TFrontId;
- typedef typename T::TNode _TNode;
- typedef typename T::TNodes _TNodes;
- typedef typename T::TVertexCmp _TVertexCmp;
-
- typedef std::map< TVertex, _TNode, _TVertexCmp > _TMarks;
+ typedef V TVertex;
+ typedef C TValue;
+ typedef R TResult;
- typedef std::pair< TVertex, bool > _TCollision;
- typedef std::vector< _TCollision > _TCollisionSitesRow;
- typedef std::vector< _TCollisionSitesRow > _TCollisionSites;
+ fpa_Base_NewEvent( TStartEvent );
+ fpa_Base_NewEvent( TStartLoopEvent );
+ fpa_Base_NewEvent( TEndEvent );
+ fpa_Base_NewEvent( TEndLoopEvent );
+ fpa_Base_NewEventWithVertex( TAliveEvent, TVertex );
+ fpa_Base_NewEventWithVertex( TFrontEvent, TVertex );
+ fpa_Base_NewEventWithVertex( TFreezeEvent, TVertex );
- public:
- typedef BaseEvent< _TNode > TEvent;
- typedef FrontEvent< _TNode > TFrontEvent;
- typedef MarkEvent< _TNode > TMarkEvent;
- typedef CollisionEvent< _TNode > TCollisionEvent;
- typedef EndEvent< _TNode > TEndEvent;
- typedef BacktrackingEvent< TVertex > TBacktrackingEvent;
- typedef EndBacktrackingEvent< TVertex > TEndBacktrackingEvent;
+ protected:
+ typedef std::vector< TVertex > _TVertices;
+ typedef std::pair< TVertex, bool > _TCollision;
+ typedef std::vector< _TCollision > _TCollisionsRow;
+ typedef std::vector< _TCollisionsRow > _TCollisions;
+
+ /**
+ */
+ enum _TNodeLabel
+ {
+ FarLabel = 0,
+ FrontLabel,
+ AliveLabel
+ };
+
+ /**
+ */
+ class _TNode
+ {
+ public:
+ _TNode( );
+ virtual ~_TNode( );
+
+ public:
+ TVertex Vertex;
+ TVertex Parent;
+ TResult Result;
+ long FrontId;
+ _TNodeLabel Label;
+ };
+ typedef std::vector< _TNode > _TNodes;
public:
- itkTypeMacro( Algorithm, itkProcessObject );
+ itkTypeMacro( Algorithm, B );
- itkBooleanMacro( StopAtOneFront );
itkBooleanMacro( ThrowEvents );
+ itkBooleanMacro( StopAtOneFront );
- itkGetConstMacro( StopAtOneFront, bool );
itkGetConstMacro( ThrowEvents, bool );
+ itkGetConstMacro( StopAtOneFront, bool );
- itkSetMacro( StopAtOneFront, bool );
itkSetMacro( ThrowEvents, bool );
+ itkSetMacro( StopAtOneFront, bool );
public:
virtual void InvokeEvent( const itk::EventObject& e );
virtual void InvokeEvent( const itk::EventObject& e ) const;
- /// Seeds manipulation
- void AddSeed( const TVertex& s, const TResult& v );
- const TVertex& GetSeed( const unsigned long& i ) const;
+ void AddSeed( const TVertex& s, const TResult& r );
+ const TVertex& GetSeed( const unsigned int& id ) const;
void ClearSeeds( );
unsigned long GetNumberOfSeeds( ) const;
Algorithm( );
virtual ~Algorithm( );
- /// itk::ProcessObject
+ // Connection with itk's pipeline
virtual void GenerateData( );
- /// Base interface
- virtual void _BeforeMainLoop ( );
- virtual void _AfterMainLoop ( );
- virtual void _BeforeLoop ( );
- virtual void _AfterLoop ( );
- virtual void _Loop ( );
- virtual bool _CheckCollisions ( const _TNode& a, const _TNode& b );
- virtual bool _CheckStopCondition ( );
- virtual bool _UpdateResult ( _TNode& n );
-
- /// Marks management
- virtual void _InitializeMarks ( );
- virtual bool _IsMarked ( const TVertex& v ) const;
- virtual _TFrontId _FrontId ( const TVertex& v ) const;
- virtual TVertex _Parent ( const TVertex& v ) const;
- virtual void _Mark ( const _TNode& n );
-
- /// Pure virtual interface: vertices
- virtual unsigned long _NumberOfVertices ( ) const = 0;
- virtual TVertexValue _Value ( const TVertex& v ) const = 0;
- virtual TResult _Result ( const TVertex& v ) const = 0;
-
- /// Pure virtual interface: edges
- virtual double _Norm ( const TVertex& a, const TVertex& b ) const = 0;
- virtual bool _Edge ( const TVertex& a, const TVertex& b ) const = 0;
- virtual TCost _Cost ( const TVertex& a, const TVertex& b ) const = 0;
-
- /// Pure virtual interface: neighborhood
- virtual void _Neighs ( const _TNode& n, _TNodes& N ) const = 0;
- virtual bool _UpdateNeigh ( _TNode& nn, const _TNode& n ) = 0;
- virtual void _NeighsInDim ( const _TNode& n,
- const unsigned int& d,
- _TNodes& N ) = 0;
-
- /// Pure virtual interface: queue
- virtual void _InitializeQueue ( ) = 0;
- virtual bool _IsQueueEmpty ( ) const = 0;
- virtual void _QueuePush ( const _TNode& n ) = 0;
- virtual _TNode _QueuePop ( ) = 0;
- virtual void _QueueClear ( ) = 0;
-
- /// Pure virtual interface: results
- virtual void _InitializeResults ( ) = 0;
+ // Main loop algorithm
+ virtual void _Loop( );
+
+ // Supporting methods for loop
+ virtual void _BeforeGenerateData( );
+ virtual void _AfterGenerateData( );
+ virtual void _BeforeLoop( );
+ virtual void _AfterLoop( );
+
+ // Methods to control forced stops
+ virtual bool _UpdateCollisions( const TVertex& a, const TVertex& b );
+ virtual bool _NeedToStop( ) const;
+
+ // Graph-related abstract methods
+ virtual unsigned long _NumberOfVertices( ) const = 0;
+ virtual const TValue& _VertexValue( const TVertex& v ) const = 0;
+ virtual double _Distance(
+ const TVertex& a, const TVertex& b
+ ) const = 0;
+ virtual bool _HasEdge( const TVertex& a, const TVertex& b ) const = 0;
+ virtual void _Neighborhood(
+ _TVertices& neighborhood, const TVertex& v
+ ) const = 0;
+
+ // Results-related abstract methods
+ virtual bool _ComputeNeighborResult(
+ TResult& result, const TVertex& neighbor, const TVertex& parent
+ ) const = 0;
+ virtual void _InitResults( ) = 0;
+ virtual const TResult& _Result( const TVertex& v ) const = 0;
+ virtual void _SetResult( const TVertex& v, const TResult& r ) = 0;
+
+ // Marks-related abstract methods
+ virtual const _TNode& _Node( const TVertex& v ) const = 0;
+ virtual void _InitMarks( ) = 0;
+ virtual void _Mark( const _TNode& node ) = 0;
+
+ // Queue-related abstract methods
+ virtual void _InitQueue( );
+ virtual bool _IsQueueEmpty( ) const = 0;
+ virtual void _QueuePush( const _TNode& n ) = 0;
+ virtual _TNode _QueuePop( ) = 0;
+ virtual void _QueueClear( ) = 0;
private:
// Purposely not implemented
- Algorithm( const Self& );
- void operator=( const Self& );
+ Algorithm( const Self& other );
+ Self& operator=( const Self& other );
protected:
- bool m_StopAtOneFront;
- bool m_ThrowEvents;
-
- _TNodes m_Seeds;
- _TMarks m_Marks;
-
- _TCollisionSites m_CollisionSites;
+ bool m_ThrowEvents;
+ bool m_StopAtOneFront;
+ _TNodes m_Seeds;
+ _TCollisions m_Collisions;
};
} // ecapseman
git://git.creatis.insa-lyon.fr / FrontAlgorithms.git / blobdiff