#ifndef __FPA__IMAGE__MINIMUMSPANNINGTREE__H__
#define __FPA__IMAGE__MINIMUMSPANNINGTREE__H__

#include <vector>
#include <itkImage.h>
#include <fpa/Base/MinimumSpanningTree.h>

namespace fpa
{
  namespace Image
  {
    template< unsigned int _NDim >
    struct MinimumSpanningTreeData
    {
      typedef itk::Offset< _NDim > TOffset;
      TOffset Parent;
      short   FrontId;
      double  GlobalCost;
    };

    /**
     */
    template< unsigned int _NDim >
    class MinimumSpanningTree
      : public fpa::Base::MinimumSpanningTree< itk::Image< MinimumSpanningTreeData< _NDim >, _NDim >, itk::Index< _NDim > >
    {
    public:
      typedef MinimumSpanningTreeData< _NDim >                 TInfo;
      typedef itk::Image< TInfo, _NDim >                       TBase;
      typedef itk::Index< _NDim >                              TVertex;
      typedef fpa::Base::MinimumSpanningTree< TBase, TVertex > Superclass;
      typedef MinimumSpanningTree                              Self;
      typedef itk::SmartPointer< Self >                        Pointer;
      typedef itk::SmartPointer< const Self >                  ConstPointer;

      typedef typename Superclass::TVertices TVertices;
      typedef typename Superclass::TPoint    TPoint;
      typedef typename Superclass::TPoints   TPoints;
      itkStaticConstMacro( Dimension, unsigned int, _NDim );

    public:
      itkNewMacro( Self );
      itkTypeMacro( MinimumSpanningTree, _TSuperclass );

    public:
      void CopyMetaData( itk::ImageBase< _NDim >* infoImage );
      virtual void SetNode(
        const TVertex& v,
        const TVertex& p,
        const short& fid,
        const double& cost
        ) override;
      virtual void Clear( ) override;

      virtual TPoints GetEuclideanPath( const TVertex& a ) const override;
      virtual TPoints GetEuclideanPath(
        const TVertex& a, const TVertex& b
        ) const override;
      virtual bool IsDefinedInEuclideanSpace( ) const override;

    protected:
      MinimumSpanningTree( );
      virtual ~MinimumSpanningTree( );

      virtual bool _HasVertex( const TVertex& a ) const override;
      virtual short _FrontId( const TVertex& a ) const override;
      virtual void _Path( TVertices& path, const TVertex& a ) const override;

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

  } // ecapseman

} // ecapseman

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

#endif // __FPA__IMAGE__MINIMUMSPANNINGTREE__H__

// eof - $RCSfile$