IndexedDigitalSurface.h

 
#pragma once
 
#if defined(IndexedDigitalSurface_RECURSES)
#error Recursive header files inclusion detected in IndexedDigitalSurface.h
#else // defined(IndexedDigitalSurface_RECURSES)
 
#define IndexedDigitalSurface_RECURSES
 
#if !defined IndexedDigitalSurface_h
 
#define IndexedDigitalSurface_h
 
// Inclusions
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/base/OwningOrAliasingPtr.h"
#include "DGtal/base/IntegerSequenceIterator.h"
#include "DGtal/topology/HalfEdgeDataStructure.h"
#include "DGtal/topology/CDigitalSurfaceContainer.h"
 
namespace DGtal
{
 
  // template class IndexedDigitalSurface
  template <typename TDigitalSurfaceContainer>
  class IndexedDigitalSurface
  {
  public:
    typedef IndexedDigitalSurface<TDigitalSurfaceContainer> Self;
    typedef TDigitalSurfaceContainer             DigitalSurfaceContainer;
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSurfaceContainer< DigitalSurfaceContainer > ));
 
    typedef typename DigitalSurfaceContainer::KSpace KSpace;
    typedef typename KSpace::Space                   Space;
    typedef typename KSpace::Surfel                  Surfel;
    typedef typename KSpace::SCell                   SCell;
    typedef typename KSpace::Cell                    Cell;
    typedef typename Space::RealPoint                RealPoint;
    typedef HalfEdgeDataStructure::Size              Size;
    typedef HalfEdgeDataStructure::Index             Index;
    typedef HalfEdgeDataStructure::VertexIndex       VertexIndex;
    typedef HalfEdgeDataStructure::EdgeIndex         EdgeIndex;
    typedef HalfEdgeDataStructure::FaceIndex         FaceIndex;
    typedef HalfEdgeDataStructure::Triangle          Triangle;
    typedef HalfEdgeDataStructure::PolygonalFace     PolygonalFace;
    typedef std::vector<RealPoint>                   PositionsStorage;
    typedef std::vector<PolygonalFace>               PolygonalFacesStorage;
    typedef std::vector<SCell>                       SCellStorage;
 
    // Required by CUndirectedSimpleLocalGraph
    typedef VertexIndex                              Vertex;
    typedef std::set<Vertex>                         VertexSet;
    template <typename Value> struct                 VertexMap {
      typedef typename std::map<Vertex, Value>       Type;
    };
 
    // Required by CUndirectedSimpleGraph
    typedef EdgeIndex                                Edge;
    typedef IntegerSequenceIterator<VertexIndex>     ConstIterator;
 
    // Required for CCombinatorialSurface
    typedef HalfEdgeDataStructure::HalfEdgeIndex     Arc;
    typedef HalfEdgeDataStructure::FaceIndex         Face;
    typedef std::vector<Arc>                         ArcRange;
    typedef std::vector<Face>                        FaceRange;
    typedef std::vector<Vertex>                      VertexRange;
 
    BOOST_STATIC_CONSTANT( Face, INVALID_FACE = HALF_EDGE_INVALID_INDEX );
 
    template <typename TData>
    struct IndexedPropertyMap {
      typedef Index             Argument;
      typedef TData             Data;
      typedef std::vector<Data> Storage;
 
      IndexedPropertyMap() : mySurface( 0 ), myData( 0 ) {}
 
      IndexedPropertyMap( const Self& aSurface, Size s, Data def_data = Data() )
        : mySurface( &aSurface ),
          myData( Storage( s, def_data ) )
      {}
 
      IndexedPropertyMap( const Self& aSurface,
                          Storage& aStorage )
        : mySurface( &aSurface ),
          myData( &aStorage, false )
      {}
 
      const Self& surface() const
      {
        ASSERT( isValid() );
        return *mySurface;
      }
 
      const Data& operator()( Argument v ) const
      {
        ASSERT( isValid() && v < myData->size() );
        return (*myData)[ v ];
      }
 
      const Data& operator[]( Argument v ) const
      {
        ASSERT( isValid() && v < myData->size() );
        return (*myData)[ v ];
      }
 
      Data& operator[]( Argument v )
      {
        ASSERT( isValid() && v < myData->size() );
        return (*myData)[ v ];
      }
 
      bool isValid() const { return mySurface != 0; }
 
      Size size() const { return myData->size(); }
 
      Storage& storage() { return *myData; }
 
      const Storage& storage() const { return *myData; }
 
    private:
      const Self* mySurface;
      OwningOrAliasingPtr<Storage> myData;
    };
 
    typedef IndexedPropertyMap< RealPoint >          PositionsMap;
 
  protected:
    typedef HalfEdgeDataStructure::HalfEdge      HalfEdge;
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~IndexedDigitalSurface() {}
 
    IndexedDigitalSurface() : isHEDSValid( false ), myContainer( 0 ) {}
 
    IndexedDigitalSurface( ConstAlias< DigitalSurfaceContainer > surfContainer )
      : isHEDSValid( false ), myContainer( 0 )
    {
      build( surfContainer );
    }
    
    void clear();
 
    bool build( ConstAlias< DigitalSurfaceContainer > surfContainer );
 
    const DigitalSurfaceContainer & container() const
    { return *myContainer; }
 
    const KSpace& space() const
    { return myContainer->space(); }
 
    const HalfEdgeDataStructure& heds() const
    { return myHEDS; }
 
    // ------------------------- standard services ------------------------------
  public:
    Size nbArcs() const { return myHEDS.nbHalfEdges(); }
 
    Size nbVertices() const { return myHEDS.nbVertices(); }
 
    Size nbEdges() const { return myHEDS.nbEdges(); }
 
    Size nbFaces() const { return myHEDS.nbFaces(); }
 
    long Euler() const { return myHEDS.Euler(); }
 
    PositionsMap positions()
    {
      return PositionsMap( *this, myPositions );
    }
 
    IndexedPropertyMap< SCell > surfels()
    {
      return IndexedPropertyMap< SCell >( *this, myVertexIndex2Surfel );
    }
 
    IndexedPropertyMap< SCell > linels()
    {
      return IndexedPropertyMap< SCell >( *this, myArc2Linel );
    }
 
    IndexedPropertyMap< SCell > pointels()
    {
      return IndexedPropertyMap< SCell >( *this, myFaceIndex2Pointel );
    }
 
    template <typename AnyData>
    IndexedPropertyMap< AnyData > makeVertexMap() const
    {
      return IndexedPropertyMap< AnyData >( *this, nbVertices() );
    }
 
    template <typename AnyData>
    IndexedPropertyMap< AnyData > makeVertexMap( AnyData value ) const
    {
      return IndexedPropertyMap< AnyData >( *this, nbVertices(), value );
    }
 
    template <typename AnyData>
    IndexedPropertyMap< AnyData > makeEdgeMap() const
    {
      return IndexedPropertyMap< AnyData >( *this, nbEdges() );
    }
 
    template <typename AnyData>
    IndexedPropertyMap< AnyData > makeEdgeMap( AnyData value ) const
    {
      return IndexedPropertyMap< AnyData >( *this, nbEdges(), value );
    }
 
    template <typename AnyData>
    IndexedPropertyMap< AnyData > makeFaceMap() const
    {
      return IndexedPropertyMap< AnyData >( *this, nbFaces() );
    }
 
    template <typename AnyData>
    IndexedPropertyMap< AnyData > makeFaceMap( AnyData value ) const
    {
      return IndexedPropertyMap< AnyData >( *this, nbFaces(), value );
    }
 
    RealPoint& position( Vertex v );
    const RealPoint& position( Vertex v ) const;
 
    const SCell& surfel( Vertex v ) const
    {
      ASSERT( v < nbVertices() );
      return myVertexIndex2Surfel[ v ];
    }
 
    const SCell& linel( Arc a ) const
    {
      ASSERT( a < nbArcs() );
      return myArc2Linel[ a ];
    }
 
    const SCell& pointel( Face f ) const
    {
      ASSERT( f < nbFaces() );
      return myFaceIndex2Pointel[ f ];
    }
    
    Vertex getVertex( const SCell& aSurfel ) const
    {
      auto it = mySurfel2VertexIndex.find( aSurfel );
      return it != mySurfel2VertexIndex.end() ? it->second : INVALID_FACE;
    }
 
    Arc getArc( const SCell& aLinel ) const
    {
      auto it = myLinel2Arc.find( aLinel );
      return it != myLinel2Arc.end() ? it->second : INVALID_FACE;
    }
 
    Face getFace( const SCell& aPointel ) const
    {
      auto it = myPointel2FaceIndex.find( aPointel );
      return it != myPointel2FaceIndex.end() ? it->second : INVALID_FACE;
    }
    
    // ----------------------- Undirected simple graph services -------------------------
  public:
    Size size() const;
 
    Size bestCapacity() const;
 
    Size degree( const Vertex & v ) 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;
 
    ConstIterator begin() const
    { return ConstIterator( 0 ); }
 
    ConstIterator end() const
    { return ConstIterator( nbVertices() ); }
 
    // ----------------------- CombinatorialSurface --------------------------
  public:
 
    ArcRange outArcs( const Vertex & v ) const;
 
    ArcRange inArcs( const Vertex & v ) const;
 
    FaceRange facesAroundVertex( const Vertex & v ) const;
 
    Vertex head( const Arc & a ) const;
 
    Vertex tail( const Arc & a ) const;
 
    Arc opposite( const Arc & a ) const;
 
    Arc next( const Arc & a ) const;
 
    Arc arc( const Vertex & t, const Vertex & h ) const;
 
    Face faceAroundArc( const Arc & a ) const;
 
    FaceRange facesAroundArc( const Arc & a ) const;
 
    VertexRange verticesAroundFace( const Face & f ) const;
 
    bool isVertexBoundary( const Vertex& v ) const;
 
    bool isArcBoundary( const Arc& v ) const;
 
    FaceRange allFaces() const;
    ArcRange allArcs() const;
    VertexRange allVertices() const;
 
    ArcRange allBoundaryArcs() const;
 
    VertexRange allBoundaryVertices() const;
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
    bool                  isHEDSValid;
    HalfEdgeDataStructure myHEDS;
    CountedConstPtrOrConstPtr< DigitalSurfaceContainer > myContainer;
 
    PositionsStorage      myPositions;
    PolygonalFacesStorage myPolygonalFaces;
    std::map< SCell, VertexIndex > mySurfel2VertexIndex;
    std::map< SCell, Arc >         myLinel2Arc;
    std::map< SCell, FaceIndex >   myPointel2FaceIndex;
    SCellStorage          myVertexIndex2Surfel;
    SCellStorage          myArc2Linel;
    SCellStorage          myFaceIndex2Pointel;
 
    
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
  private:
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class IndexedDigitalSurface
 
 
  template <typename TDigitalSurfaceContainer>
  std::ostream&
  operator<< ( std::ostream & out,
               const IndexedDigitalSurface<TDigitalSurfaceContainer> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/topology/IndexedDigitalSurface.ih"
 
//                                                                           //
 
#endif // !defined IndexedDigitalSurface_h
 
#undef IndexedDigitalSurface_RECURSES
#endif // else defined(IndexedDigitalSurface_RECURSES)