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>
// JOL (2013/02/01): required to define internal tags (boost/graph/copy.hpp, l. 251 error ?).
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>
#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 boost
{
  struct DigitalSurface_graph_traversal_category 
    : public virtual adjacency_graph_tag,
      public virtual vertex_list_graph_tag,
      public virtual incidence_graph_tag,
      public virtual edge_list_graph_tag { };
}
 
namespace DGtal
{
 
  // template class DigitalSurface
  template <typename TDigitalSurfaceContainer>
  class DigitalSurface
  {
  public:
    typedef TDigitalSurfaceContainer DigitalSurfaceContainer;
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSurfaceContainer<DigitalSurfaceContainer> ));
 
    // ----------------------- boost graph tags ------------------------------
    // JOL (2013/02/01): required to define internal tags (boost/graph/copy.hpp, l. 251 error ?).
  public:
    typedef boost::undirected_tag directed_category;
    typedef boost::DigitalSurface_graph_traversal_category traversal_category;
    typedef boost::disallow_parallel_edge_tag edge_parallel_category;
 
 
    // ----------------------- 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::Vector    Vector;
    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()
        : base(), k( 0 ), epsilon( false ) {}
      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 ) ) ) );
      }
      inline bool operator!=( const Arc & other ) const
      {
        return ( base != other.base ) 
          || ( 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,
                                 bool order_ccw_in_3d = false ) const;
    
    Vertex head( const Arc & a ) const;
 
    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)