#ifndef __FPA__BASE__EXTRACTENDPOINTSANDBIFURCATIONSFROMMINIMUMSPANNINGTREE__H__
#define __FPA__BASE__EXTRACTENDPOINTSANDBIFURCATIONSFROMMINIMUMSPANNINGTREE__H__

#include <vector>
#include <itkProcessObject.h>
#include <cpExtensions/DataStructures/ImageIndexesContainer.h>

namespace fpa
{
  namespace Base
  {
    /**
     */
    template< class _TMST >
    class ExtractEndPointsAndBifurcationsFromMinimumSpanningTree
      : public itk::ProcessObject
    {
    public:
      typedef ExtractEndPointsAndBifurcationsFromMinimumSpanningTree Self;
      typedef itk::ProcessObject                                     Superclass;
      typedef itk::SmartPointer< Self >                              Pointer;
      typedef itk::SmartPointer< const Self >                        ConstPointer;

      typedef _TMST  TMinimumSpanningTree;
      typedef typename _TMST::TVertex TVertex;

      typedef
      cpExtensions::DataStructures::ImageIndexesContainer< TVertex::Dimension >
      TVertices;

    public:
      itkTypeMacro(
        ExtractEndPointsAndBifurcationsFromMinimumSpanningTree,
        itk::ProcessObject
        );

    public:
      const TMinimumSpanningTree* GetMinimumSpanningTree( );
      void SetMinimumSpanningTree( TMinimumSpanningTree* mst );

      TVertices* GetEndPoints( );
      TVertices* GetBifurcations( );
      TVertices* GetCollisions( );

      virtual void Update( ) ITK_OVERRIDE
        {
          this->GenerateData( );
        }

    protected:
      ExtractEndPointsAndBifurcationsFromMinimumSpanningTree( );
      virtual ~ExtractEndPointsAndBifurcationsFromMinimumSpanningTree( );

      virtual void GenerateData( ) ITK_OVERRIDE;

      virtual void _MarkSkeleton(
        const TVertex& v, const unsigned long& l
        ) = 0;
      virtual void _MarkSphere(
        const TVertex& v,
        const double& r,
        const unsigned long& l
        ) = 0;
      virtual unsigned long _Mark( const TVertex& v ) = 0;
      virtual unsigned long _SkeletonMark( const TVertex& v ) = 0;
      virtual double _Radius( const TVertex& v ) = 0;

      virtual void _Tmp( ) = 0;

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

  } // ecapseman

} // ecapseman

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

#endif // __FPA__BASE__EXTRACTENDPOINTSANDBIFURCATIONSFROMMINIMUMSPANNINGTREE__H__

// eof - $RCSfile$