#ifndef __FPA__IMAGE__ALGORITHM__H__
#define __FPA__IMAGE__ALGORITHM__H__

#include <itkImage.h>

namespace fpa
{
  namespace Image
  {
    /**
     * A generic front propagation algorithm were vertices are image pixels.
     *
     * @param I Input image type
     * @param O Output image type
     * @param A Base algorithm (RegionGrow, Dijkstra or FastMarching)
     */
    template< class I, class O, class A >
    class Algorithm
      : public A
    {
    public:
      /// Standard class typdedefs
      typedef Algorithm                       Self;
      typedef A                               Superclass;
      typedef itk::SmartPointer< Self >       Pointer;
      typedef itk::SmartPointer< const Self > ConstPointer;

      /// Template input values
      typedef I TInputImage;
      typedef O TOutputImage;

      typedef typename Superclass::TVertex        TVertex;
      typedef typename Superclass::TValue         TValue;
      typedef typename Superclass::TResult        TResult;
      typedef typename Superclass::TSpace         TSpace;
      typedef typename Superclass::TVertexCompare TVertexCompare;

    protected:
      typedef typename Superclass::_TVertices      _TVertices;
      typedef typename Superclass::_TCollision     _TCollision;
      typedef typename Superclass::_TCollisionsRow _TCollisionsRow;
      typedef typename Superclass::_TCollisions    _TCollisions;
      typedef typename Superclass::_TNode          _TNode;
      typedef typename Superclass::_TNodes         _TNodes;

    public:
      itkTypeMacro( Algorithm, TAlgorithm );

      /// Set/Get
      itkGetConstMacro( NeighborhoodOrder, unsigned int );
      itkSetMacro( NeighborhoodOrder, unsigned int );

    protected:
      Algorithm( );
      virtual ~Algorithm( );

      virtual void _BeforeGenerateData( ) ITK_OVERRIDE;

      // Graph-related abstract methods
      virtual unsigned long _NumberOfVertices( ) const ITK_OVERRIDE;
      virtual const TValue& _VertexValue( const TVertex& v ) const ITK_OVERRIDE;
      virtual double _Distance(
        const TVertex& a, const TVertex& b
        ) const ITK_OVERRIDE;
      virtual bool _HasEdge( const TVertex& a, const TVertex& b ) const ITK_OVERRIDE;
      virtual void _Neighborhood(
        _TVertices& neighborhood, const TVertex& v
        ) const ITK_OVERRIDE;

      // Results-related abstract methods
      virtual void _InitResults( ) ITK_OVERRIDE;
      virtual const TResult& _Result( const TVertex& v ) const ITK_OVERRIDE;
      virtual void _SetResult( const TVertex& v, const _TNode& n ) ITK_OVERRIDE;

    private:
      // Purposely not implemented
      Algorithm( const Self& other );
      Self& operator=( const Self& other );

    protected:
      unsigned int m_NeighborhoodOrder;
    };

  } // ecapseman

} // ecapseman

#ifndef ITK_MANUAL_INSTANTIATION
#include <fpa/Image/Algorithm.hxx>
#endif // ITK_MANUAL_INSTANTIATION

#endif // __FPA__IMAGE__ALGORITHM__H__

// eof - $RCSfile$