#ifndef __FPA__BASE__REGIONGROW__H__
#define __FPA__BASE__REGIONGROW__H__

#include <queue>
#include <vector>
#include <fpa/Base/Algorithm.h>

namespace fpa
{
  namespace Base
  {
    /**
     */
    template< class V, class R, class VV, class VC >
    class RegionGrowTraits
    {
    public:
      typedef R  TResult;
      typedef V  TVertex;
      typedef VV TVertexValue;
      typedef VC TVertexCmp;

      typedef bool TCost;
      typedef long TFrontId;

      class TNode
      {
      public:
        TNode( )
          { }
        TNode( const TVertex& v, const TFrontId& f )
          : Vertex( v ),
            Parent( v ),
            FrontId( f )
          { }
        TNode( const TVertex& v, const TResult& r, const TFrontId& f )
          : Vertex( v ),
            Parent( v ),
            Result( r ),
            FrontId( f )
          { }
        virtual ~TNode( )
          { }

        TVertex Vertex;
        TVertex Parent;
        TResult Result;
        TFrontId FrontId;
      };

      typedef std::vector< TNode > TNodes;
    };

    /**
     * Region grow is a front propagation with no costs.
     */
    template< class V, class R, class VV, class VC, class B >
    class RegionGrow
      : public Algorithm< RegionGrowTraits< V, R, VV, VC >, B >
    {
    public:
      typedef V  TVertex;
      typedef R  TResult;
      typedef VV TVertexValue;
      typedef B  TBaseFilter;

      /// Standard class typdedefs
      typedef RegionGrowTraits< V, R, VV, VC > TTraits;
      typedef RegionGrow                       Self;
      typedef Algorithm< TTraits, B >          Superclass;
      typedef itk::SmartPointer< Self >        Pointer;
      typedef itk::SmartPointer< const Self >  ConstPointer;

      typedef typename TTraits::TCost TCost;

    protected:
      typedef typename TTraits::TFrontId  _TFrontId;
      typedef typename TTraits::TNode     _TNode;
      typedef typename TTraits::TNodes    _TNodes;

    private:
      typedef std::queue< _TNode > _TQueue;

    public:
      itkTypeMacro( RegionGrow, Base );

    protected:
      RegionGrow( );
      virtual ~RegionGrow( );

      virtual   bool _UpdateResult    ( _TNode& n );
      virtual   void _InitializeQueue ( );
      virtual   bool _IsQueueEmpty    ( ) const;
      virtual   void _QueuePush       ( const _TNode& n );
      virtual _TNode _QueuePop        ( );
      virtual   void _QueueClear      ( );
      virtual   bool _UpdateNeigh     ( _TNode& nn, const _TNode& n );

      virtual bool _CheckMembership( const _TNode& n ) const = 0;

    private:
      RegionGrow( const Self& );     // Not impl.
      void operator=( const Self& ); // Not impl.

    private:
      _TQueue m_Queue;
    };

  } // ecapseman

} // ecapseman

#include <fpa/Base/RegionGrow.hxx>

#endif // __FPA__BASE__REGIONGROW__H__

// eof - $RCSfile$