DigitalSurface.h

#pragma once

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

#define DigitalSurface_RECURSES

#if !defined DigitalSurface_h

#define DigitalSurface_h

// Inclusions
#include <iostream>
#include <vector>
#include <set>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/kernel/CWithGradientMap.h"
#include "DGtal/topology/CCellEmbedder.h"
#include "DGtal/topology/CSCellEmbedder.h"
#include "DGtal/topology/CDigitalSurfaceContainer.h"
#include "DGtal/topology/CDigitalSurfaceTracker.h"
#include "DGtal/topology/UmbrellaComputer.h"

namespace DGtal
{

  // template class DigitalSurface
  template <typename TDigitalSurfaceContainer>
  class DigitalSurface
  {
  public:
    typedef TDigitalSurfaceContainer DigitalSurfaceContainer;
    BOOST_CONCEPT_ASSERT(( CDigitalSurfaceContainer<DigitalSurfaceContainer> ));

    // ----------------------- types ------------------------------
  public:
    typedef DigitalSurface<DigitalSurfaceContainer> Self;
    typedef typename DigitalSurfaceContainer::KSpace KSpace;
    typedef typename DigitalSurfaceContainer::Cell Cell;
    typedef typename DigitalSurfaceContainer::SCell SCell;
    typedef typename DigitalSurfaceContainer::Surfel Surfel;
    typedef typename DigitalSurfaceContainer::SurfelConstIterator ConstIterator;
    typedef typename DigitalSurfaceContainer::DigitalSurfaceTracker DigitalSurfaceTracker; 
    typedef typename KSpace::Point Point;
    typedef typename KSpace::SurfelSet SurfelSet;
    template <typename Value> struct SurfelMap {
      typedef typename KSpace::template SurfelMap<Value>::Type Type;
    };

    // ----------------------- UndirectedSimpleGraph --------------------------
  public:
    typedef Surfel Vertex;
    typedef typename KSpace::Size Size;
    typedef typename KSpace::SurfelSet VertexSet;
    template <typename Value> struct VertexMap {
      typedef typename KSpace::template SurfelMap<Value>::Type Type;
    };
    struct Edge {
      Vertex vertices[ 2 ];
      Edge( const Vertex & v1, const Vertex & v2 )
      {
        if ( v1 <= v2 ) 
          {
            vertices[ 0 ] = v1;
            vertices[ 1 ] = v2;
          }
        else
          {
            vertices[ 0 ] = v2;
            vertices[ 1 ] = v1;
          }
      }
      bool operator==( const Edge & other ) const
      {
        return ( vertices[ 0 ] == other.vertices[ 0 ] )
          && ( vertices[ 1 ] == other.vertices[ 1 ] );
      }
      bool operator<( const Edge & other ) const
      {
        return ( vertices[ 0 ] < other.vertices[ 0 ] )
          || ( ( vertices[ 0 ] == other.vertices[ 0 ] )
               && ( vertices[ 1 ] < other.vertices[ 1 ] ) );
      }

    };

    // ----------------------- CombinatorialSurface --------------------------
  public:
    
    typedef UmbrellaComputer<DigitalSurfaceTracker> Umbrella;
    typedef typename Umbrella::State UmbrellaState;

    struct Arc {
      Vertex base;  
      Dimension k;  
      bool epsilon; 
      inline Arc( const Vertex & theTail, Dimension aK, bool aEpsilon )
        : base( theTail ), k( aK ), epsilon( aEpsilon ) {}
      inline bool operator==( const Arc & other ) const
      {
        return ( base == other.base ) 
          && ( k == other.k ) && ( epsilon == other.epsilon );
      }
      inline bool operator<( const Arc & other ) const
      {
        return ( base < other.base ) 
          || ( ( base == other.base ) 
               && ( ( k < other.k ) 
                    || ( ( k == other.k ) 
                         && ( epsilon < other.epsilon ) ) ) );
      }
    };

    struct Face {
      UmbrellaState state; 

      unsigned int nbVertices; 
      bool closed;         
      inline Face( const UmbrellaState & aState, 
                   unsigned int nb, bool aIsClosed )
        : state( aState ), nbVertices( nb ), closed( aIsClosed )
      {}
      inline bool isClosed() const 
      { return closed; }
      inline bool operator==( const Face & other ) const
      {
        return state == other.state;
      }
      inline bool operator<( const Face & other ) const
      {
        return state < other.state;
      }
 
    };
    
    typedef std::vector<Arc> ArcRange;
    typedef std::vector<Face> FaceRange;
    typedef std::vector<Vertex> VertexRange;
    typedef std::set<Face> FaceSet;


    // ----------------------- Standard services ------------------------------
  public:
    
    ~DigitalSurface();

    DigitalSurface ( const DigitalSurface & other );

    DigitalSurface( const DigitalSurfaceContainer & container );

    DigitalSurface( DigitalSurfaceContainer* containerPtr );

    DigitalSurface & operator= ( const DigitalSurface & other );

    // ----------------------- Services --------------------------------------
  public:

    const DigitalSurfaceContainer & container() const;

    DigitalSurfaceContainer & container();

    // ----------------- UndirectedSimpleGraph realization --------------------
  public:
    
    ConstIterator begin() const;

    ConstIterator end() const;

    Size size() const;

    Size degree( const Vertex & v ) const;

    Size bestCapacity() const;

    template <typename OutputIterator>
    void writeNeighbors( OutputIterator & it,
                         const Vertex & v ) const;

    template <typename OutputIterator, typename VertexPredicate>
    void writeNeighbors( OutputIterator & it,
                         const Vertex & v,
                         const VertexPredicate & pred ) const;


    // ----------------------- CombinatorialSurface --------------------------
  public:

    ArcRange outArcs( const Vertex & v ) const;

    ArcRange inArcs( const Vertex & v ) const;

    FaceRange facesAroundVertex( const Vertex & v ) const;

    /*
      @param a any arc (s,t)
      @return the vertex t
    */
    Vertex head( const Arc & a ) const;

    /*
      @param a any arc (s,t)
      @return the vertex s
    */
    Vertex tail( const Arc & a ) const;

    Arc opposite( const Arc & a ) const;

    Arc arc( const Vertex & tail, const Vertex & head ) const;

    FaceRange facesAroundArc( const Arc & a ) const;

    VertexRange verticesAroundFace( const Face & f ) const;

    FaceSet allFaces() const;

    FaceSet allClosedFaces() const;

    FaceSet allOpenFaces() const;

    Face computeFace( UmbrellaState state ) const;

    SCell separator( const Arc & a ) const;

    SCell pivot( const Face & f ) const;


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

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

    bool isValid() const;

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

    template <typename CellEmbedder>
    void exportEmbeddedSurfaceAs3DOFF ( std::ostream & out,
                                        const CellEmbedder & cembedder ) const;

    template <typename CellEmbedder>
    void exportEmbeddedSurfaceAs3DNOFF ( std::ostream & out,
                                        const CellEmbedder & cembedder ) const;

    template <typename SCellEmbedderWithGradientMap>
    void exportAs3DNOFF( std::ostream & out,
                         const SCellEmbedderWithGradientMap & scembedder ) const;
 
    template <typename CellEmbedder>
    void exportEmbeddedIteratedSurfaceAs3DNOFF ( std::ostream & out,
                                                 const CellEmbedder & cembedder ) const;

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

    CountedPtr<DigitalSurfaceContainer> myContainer;
    mutable DigitalSurfaceTracker* myTracker;
    mutable UmbrellaComputer<DigitalSurfaceTracker> myUmbrellaComputer;

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

    DigitalSurface();

  private:


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

  }; // end of class DigitalSurface


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

} // namespace DGtal


// Includes inline functions.
#include "DGtal/topology/DigitalSurface.ih"

//                                                                           //

#endif // !defined DigitalSurface_h

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