#ifndef __FPA__BASE__FASTMARCHING__H__
#define __FPA__BASE__FASTMARCHING__H__

#include <fpa/Base/Dijkstra.h>

namespace fpa
{
  namespace Base
  {
    /**
     */
    template< class V, class C, class VV, class VC, class B >
    class FastMarching
      : public Dijkstra< V, C, VV, VC, B >
    {
    public:
      // Templated types
      typedef V  TVertex;
      typedef C  TCost;
      typedef VV TVertexValue;
      typedef B  TBaseFilter;

      // Standard class typdedefs
      typedef FastMarching                    Self;
      typedef Dijkstra< V, C, VV, VC, B >     Superclass;
      typedef itk::SmartPointer< Self >       Pointer;
      typedef itk::SmartPointer< const Self > ConstPointer;

      typedef typename Superclass::TResult TResult;
      typedef typename Superclass::TTraits TTraits;

    protected:
      typedef typename Superclass::_TFrontId _TFrontId;
      typedef typename Superclass::_TNode    _TNode;
      typedef typename Superclass::_TNodes   _TNodes;
      struct _TNodeEikonalSort
      {
        bool operator()( const _TNode& a, const _TNode& b ) const
          { return( a.Result < b.Result ); }
      };

    public:
      itkTypeMacro( FastMarching, Dijkstra );

    protected:
      FastMarching( );
      virtual ~FastMarching( );

      virtual bool _UpdateNeigh( _TNode& nn, const _TNode& n );

      /**
       * Eikonal solution method
       *
       * This method returns the computed time and a flag indicating if the
       * determinant was valid.
       */
      bool _SolveEikonal( double& re, const _TNode& n, const double& F );

    private:
      // Purposely not implemented
      FastMarching( const Self& );
      void operator=( const Self& );

    protected:
      static const double LargestValue;
    };

  } // ecapseman

} // ecapseman

#ifndef ITK_MANUAL_INSTANTIATION
#include <fpa/Base/FastMarching.hxx>
#endif // ITK_MANUAL_INSTANTIATION

#endif // __FPA__BASE__FASTMARCHING__H__

// eof - $RCSfile$