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::Vector      Vector;
    typedef typename KSpace::Cell        Cell;
    typedef typename KSpace::SCell       SCell;
    typedef typename KSpace::Surfel      Surfel;
    typedef typename KSpace::DirIterator DirIterator;
    typedef std::vector<Cell>            CellRange;
    
    // ----------------------- 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 );
 
    
    static
    CellRange getPrimalVertices( const KSpace& K, const SCell& s );
    
    static
    CellRange getPrimalVertices( const KSpace& K, const Surfel& s, bool ccw );
    
 
    // ----------------------- 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)