#ifndef __FPA__IMAGE__DIJKSTRAWITHENDPOINTDETECTION__H__
#define __FPA__IMAGE__DIJKSTRAWITHENDPOINTDETECTION__H__

#include <map>
#include <itkImage.h>
#include <fpa/Image/Dijkstra.h>
#include <fpa/Base/MatrixValuesContainer.h>
#include <fpa/Base/UniqueValuesContainer.h>

namespace fpa
{
  namespace Image
  {
    /**
     * @param I Input image type
     * @param O Output image type
     */
    template< class I, class O >
    class DijkstraWithEndPointDetection
      : public Dijkstra< I, O >
    {
    public:
      typedef DijkstraWithEndPointDetection   Self;
      typedef Dijkstra< I, O >                Superclass;
      typedef itk::SmartPointer< Self >       Pointer;
      typedef itk::SmartPointer< const Self > ConstPointer;

      typedef typename Superclass::TInputImage          TInputImage;
      typedef typename Superclass::TOutputImage         TOutputImage;
      typedef typename Superclass::TVertex              TVertex;
      typedef typename Superclass::TVertexCompare       TVertexCompare;
      typedef typename Superclass::TValue               TValue;
      typedef typename Superclass::TResult              TResult;
      typedef typename Superclass::TSpace               TSpace;
      typedef typename Superclass::TMinimumSpanningTree TMinimumSpanningTree;
      typedef typename Superclass::TCostFunction        TCostFunction;
      typedef typename Superclass::TConversionFunction  TConversionFunction;
      typedef typename Superclass::_TVertices           TVertices;

      typedef typename Superclass::TStartEvent     TStartEvent;
      typedef typename Superclass::TStartLoopEvent TStartLoopEvent;
      typedef typename Superclass::TEndEvent       TEndEvent;
      typedef typename Superclass::TEndLoopEvent   TEndLoopEvent;
      typedef typename Superclass::TAliveEvent     TAliveEvent;
      typedef typename Superclass::TFrontEvent     TFrontEvent;
      typedef typename Superclass::TFreezeEvent    TFreezeEvent;

      typedef typename
      Superclass::TStartBacktrackingEvent TStartBacktrackingEvent;
      typedef typename
      Superclass::TEndBacktrackingEvent TEndBacktrackingEvent;
      typedef typename
      Superclass::TBacktrackingEvent TBacktrackingEvent;

      typedef unsigned short                          TLabel;
      typedef itk::Image< TLabel, I::ImageDimension > TLabelImage;

      typedef fpa::Base::
      UniqueValuesContainer< TVertex, TVertexCompare > TUniqueVertices;
      typedef fpa::Base::
      MatrixValuesContainer< TVertex, TLabel, TVertexCompare > TBranches;

    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;

      typedef typename I::PixelType  _TPixel;
      typedef typename I::RegionType _TRegion;
      typedef typename I::SizeType   _TSize;

      typedef std::pair< TResult, TVertex >     _TCandidate;
      typedef std::multimap< TResult, TVertex > _TCandidates;

    public:
      itkNewMacro( Self );
      itkTypeMacro( DijkstraWithEndPointDetection, Dijkstra );

      itkBooleanMacro( CorrectSeeds );
      itkBooleanMacro( CorrectEndPoints );

      itkGetConstMacro( CorrectSeeds, bool );
      itkGetConstMacro( CorrectEndPoints, bool );
      itkGetConstMacro( SafetyNeighborhoodSize, unsigned int );

      itkGetConstMacro( NumberOfBranches, unsigned long );

      itkSetMacro( CorrectSeeds, bool );
      itkSetMacro( CorrectEndPoints, bool );
      itkSetMacro( SafetyNeighborhoodSize, unsigned int );

    public:
      TLabelImage* GetLabelImage( );
      const TLabelImage* GetLabelImage( ) const;
      void GraftLabelImage( itk::DataObject* obj );

      TUniqueVertices* GetEndPoints( );
      const TUniqueVertices* GetEndPoints( ) const;
      void GraftEndPoints( itk::DataObject* obj );

      TUniqueVertices* GetBifurcations( );
      const TUniqueVertices* GetBifurcations( ) const;
      void GraftBifurcations( itk::DataObject* obj );

      TBranches* GetBranches( );
      const TBranches* GetBranches( ) const;
      void GraftBranches( itk::DataObject* obj );

    protected:
      DijkstraWithEndPointDetection( );
      virtual ~DijkstraWithEndPointDetection( );

      virtual void _BeforeGenerateData( );
      virtual void _AfterGenerateData( );
      virtual void _SetResult( const TVertex& v, const _TNode& n );

      void _EndPointsAndBifurcations( );
      void _FindBranches( );
      void _LabelAll( );

      _TRegion _Region( const TVertex& c, const double& r );

      template< class _T >
      TVertex _MaxInRegion(
        const _T* image, const TVertex& v, const double& r
        );

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

    protected:
      unsigned int m_LabelImageIndex;
      unsigned int m_BifurcationsIndex;
      unsigned int m_EndPointsIndex;
      unsigned int m_BranchesIndex;

      bool m_CorrectSeeds;
      bool m_CorrectEndPoints;
      unsigned int m_SafetyNeighborhoodSize;

      _TCandidates  m_Candidates;
      unsigned long m_NumberOfBranches;
    };

  } // ecapseman

} // ecapseman

#include <fpa/Image/DijkstraWithEndPointDetection.hxx>

#endif // __FPA__IMAGE__DIJKSTRAWITHENDPOINTDETECTION__H__

// eof - $RCSfile$