Surfaces.h

#pragma once

#if defined(Surfaces_RECURSES)
#error Recursive header files inclusion detected in Surfaces.h
#else // defined(Surfaces_RECURSES)

#define Surfaces_RECURSES

#if !defined Surfaces_h

#define Surfaces_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/Exceptions.h"
#include "DGtal/topology/SurfelAdjacency.h"
#include "DGtal/topology/SurfelNeighborhood.h"


#ifdef _MSC_VER
#pragma warning(disable : 4290)
#endif

namespace DGtal
{

  // template class Surfaces
  template <typename TKSpace>
  class Surfaces
  {
    // ----------------------- Types ------------------------------
  public:
    typedef TKSpace KSpace;
    typedef typename KSpace::Integer Integer;
    typedef typename KSpace::Point Point;
    typedef typename KSpace::Cell Cell;
    typedef typename KSpace::SCell SCell;
    typedef typename KSpace::DirIterator DirIterator;

    // ----------------------- Static services ------------------------------
  public:

    template <typename PointPredicate>
    static
    SCell findABel( const KSpace & K,
        const PointPredicate & pp,
        unsigned int nbtries = 1000 );

    template <typename PointPredicate>
    static
    SCell findABel( const KSpace & K,
                    const PointPredicate & pp,
                    Point x1, Point x2 );

    template <typename SCellSet, typename PointPredicate >
    static 
    void trackBoundary( SCellSet & surface,
      const KSpace & K,
      const SurfelAdjacency<KSpace::dimension> & surfel_adj,
      const PointPredicate & pp,
      const SCell & start_surfel );

    template <typename SCellSet, typename PointPredicate >
    static 
    void trackClosedBoundary( SCellSet & surface,
            const KSpace & K,
            const SurfelAdjacency<KSpace::dimension> & surfel_adj,
            const PointPredicate & pp,
            const SCell & start_surfel );


    template <typename SCellSet, typename SurfelPredicate >
    static 
    void trackSurface( SCellSet & surface,
                       const KSpace & K,
                       const SurfelAdjacency<KSpace::dimension> & surfel_adj,
                       const SurfelPredicate & pp,
                       const SCell & start_surfel );

    template <typename SCellSet, typename SurfelPredicate >
    static 
    void trackClosedSurface( SCellSet & surface,
                             const KSpace & K,
                             const SurfelAdjacency<KSpace::dimension> & surfel_adj,
                             const SurfelPredicate & pp,
                             const SCell & start_surfel );


    template <typename PointPredicate >
    static 
    void track2DBoundary( std::vector<SCell> & aSCellContour2D,
        const KSpace & K,
        const SurfelAdjacency<KSpace::dimension> & surfel_adj,
        const PointPredicate & pp,
        const SCell & start_surfel );



    template <typename PointPredicate>
    static 
    void track2DSliceBoundary( std::vector<SCell> & aSCellContour2D,
                               const KSpace & K, 
                               const Dimension & trackDir,
                               const SurfelAdjacency<KSpace::dimension> & surfel_adj,
                               const PointPredicate & pp,
                               const SCell & start_surfel );


    template <typename SurfelPredicate >
    static 
    void track2DSurface( std::vector<SCell> & aSCellContour,
                         const KSpace & K,
                         const SurfelAdjacency<KSpace::dimension> & surfel_adj,
                         const SurfelPredicate & sp,
                         const SCell & start_surfel );



    template <typename SurfelPredicate>
    static 
    void track2DSliceSurface( std::vector<SCell> & aSCellContour,
                               const KSpace & K, 
                               const Dimension & trackDir,
                               const SurfelAdjacency<KSpace::dimension> & surfel_adj,
                               const SurfelPredicate & sp,
                               const SCell & start_surfel );



    template <typename PointPredicate>
    static
    void 
    track2DBoundaryPoints( std::vector<Point> & aVectorOfPoints,
         const KSpace & K, 
         const SurfelAdjacency<KSpace::dimension> & surfel_adj,
         const PointPredicate & pp,
         const SCell & start_surfel );


    template <typename PointPredicate>
    static 
    void extractAllPointContours4C
    ( std::vector< std::vector< Point > > & aVectPointContour2D,
      const KSpace & aKSpace,
      const PointPredicate & pp,
      const SurfelAdjacency<2> &aSAdj );

    

    template <typename PointPredicate>
    static 
    void extractAll2DSCellContours
    ( std::vector< std::vector<SCell> > & aVectSCellContour2D,
      const KSpace & aKSpace,
      const SurfelAdjacency<KSpace::dimension> & aSurfelAdj,
      const PointPredicate & pp );
    

    template <typename PointPredicate >
    static 
    void extractAllConnectedSCell
    ( std::vector< std::vector<SCell> > & aVectConnectedSCell,
      const KSpace & aKSpace,
      const SurfelAdjacency<KSpace::dimension> & aSurfelAdj,
      const PointPredicate & pp,
      bool forceOrientCellExterior=false );

    
    

    template <typename PointPredicate>
    static 
    void orientSCellExterior(std::vector<SCell> & aVectOfSCell,  
           const KSpace & aKSpace, 
           const PointPredicate & pp  );

    

    
    
    
    template <typename CellSet, typename PointPredicate >
    static 
    void uMakeBoundary( CellSet & aBoundary,
                        const KSpace & aKSpace,
                        const PointPredicate & pp,
                        const Point & aLowerBound, 
                        const Point & aUpperBound  );
    
    template <typename SCellSet, typename PointPredicate >
    static 
    void sMakeBoundary( SCellSet & aBoundary,
                        const KSpace & aKSpace,
                        const PointPredicate & pp,
                        const Point & aLowerBound, 
                        const Point & aUpperBound  );

    template <typename OutputIterator, typename PointPredicate >
    static 
    void uWriteBoundary( OutputIterator & out_it,
                         const KSpace & aKSpace,
                         const PointPredicate & pp,
                         const Point & aLowerBound, 
                         const Point & aUpperBound  );
    
    template <typename OutputIterator, typename PointPredicate >
    static 
    void sWriteBoundary( OutputIterator & out_it,
                         const KSpace & aKSpace,
                         const PointPredicate & pp,
                         const Point & aLowerBound, 
                         const Point & aUpperBound  );
    

    


    template < typename TSurfelPredicate, typename TImageContainer> 
    unsigned int
    static
    uFillInterior( const KSpace & aKSpace, 
                   const TSurfelPredicate & aSurfPred,
                   TImageContainer & anImage,
                   const typename TImageContainer::Value & aValue,
                   bool empty_is_inside=false,
                   bool incrementMode=true );


    template < typename SurfelPredicate, typename TImageContainer> 
    unsigned int
    static
    uFillExterior( const KSpace & aKSpace, 
                   const SurfelPredicate & aSurfPred,
                   TImageContainer & anImage,
                   const typename TImageContainer::Value & aValue,
                   bool empty_is_outside=true,
                   bool incrementMode=true );

    
    

    // ----------------------- Standard services ------------------------------
  public:

    ~Surfaces();

    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:

    // ------------------------- Hidden services ------------------------------
  protected:

    Surfaces();

  private:

    Surfaces ( const Surfaces & other );

    Surfaces & operator= ( const Surfaces & other );

    // ------------------------- Internals ------------------------------------
  private:

  }; // end of class Surfaces


  template <typename TKSpace>
  std::ostream&
  operator<< ( std::ostream & out, const Surfaces<TKSpace> & object );

} // namespace DGtal


// Includes inline functions.
#include "DGtal/topology/helpers/Surfaces.ih"

//                                                                           //

#endif // !defined Surfaces_h

#undef Surfaces_RECURSES
#endif // else defined(Surfaces_RECURSES)