#ifndef __FPA__BASE__REGIONGROWWITHMULTIPLECRITERIA__H__
#define __FPA__BASE__REGIONGROWWITHMULTIPLECRITERIA__H__

#include <vector>
#include <itkFunctionBase.h>
#include <fpa/Base/RegionGrow.h>

namespace fpa
{
  namespace Base
  {
    /**
     * Region grow is a front propagation with no costs.
     */
    template< class V, class R, class VV, class VC, class B >
    class RegionGrowWithMultipleCriteria
      : public RegionGrow< V, R, VV, VC, B >
    {
    public:
      typedef V  TVertex;
      typedef R  TResult;
      typedef VV TVertexValue;
      typedef B  TBaseFilter;

      /// Standard class typdedefs
      typedef RegionGrowWithMultipleCriteria  Self;
      typedef RegionGrow< V, R, VV, VC, B >   Superclass;
      typedef itk::SmartPointer< Self >       Pointer;
      typedef itk::SmartPointer< const Self > ConstPointer;

      typedef typename Superclass::TTraits  TTraits;
      typedef typename Superclass::TCost    TCost;
      typedef itk::FunctionBase< V, TCost > TMembershipFunction;
      typedef
      typename TMembershipFunction::Pointer
      TMembershipFunctionPointer;
      typedef std::vector< TMembershipFunctionPointer > TFunctions;

    protected:
      typedef typename Superclass::_TFrontId  _TFrontId;
      typedef typename Superclass::_TNode     _TNode;
      typedef typename Superclass::_TNodes    _TNodes;
      typedef typename Superclass::_TQueue    _TQueue;
      typedef typename Superclass::_TMarks    _TMarks;

    public:
      itkTypeMacro( RegionGrowWithMultipleCriteria, RegionGrow );

    public:
      unsigned int GetNumberOfMembershipFunctions( ) const;
      void ClearMembershipFunctions( );
      void AddMembershipFunction( TMembershipFunction* function );

    protected:
      RegionGrowWithMultipleCriteria( );
      virtual ~RegionGrowWithMultipleCriteria( );

      virtual void _BeforeMainLoop( );
      virtual void _AfterLoop( );
      virtual void _Loop( );
      virtual bool _CheckMembership( const _TNode& n ) const;

    private:
      RegionGrowWithMultipleCriteria( const Self& ); // Not impl.
      void operator=( const Self& );                 // Not impl.

    protected:
      mutable _TQueue m_AuxiliaryQueue;
      TFunctions m_Functions;
      typename TFunctions::iterator m_ActualFunction;
    };

  } // ecapseman

} // ecapseman

#include <fpa/Base/RegionGrowWithMultipleCriteria.hxx>

#endif // __FPA__BASE__REGIONGROWWITHMULTIPLECRITERIA__H__

// eof - $RCSfile$