PolygonalSurface.h

 
#pragma once
 
#if defined(PolygonalSurface_RECURSES)
#error Recursive header files inclusion detected in PolygonalSurface.h
#else // defined(PolygonalSurface_RECURSES)
#define PolygonalSurface_RECURSES
 
#if !defined PolygonalSurface_h
#define PolygonalSurface_h
 
// Inclusions
#include <iostream>
#include <set>
#include <map>
#include "DGtal/base/Common.h"
#include "DGtal/base/Clone.h"
#include "DGtal/base/OwningOrAliasingPtr.h"
#include "DGtal/base/IntegerSequenceIterator.h"
#include "DGtal/topology/HalfEdgeDataStructure.h"
 
namespace DGtal
{
 
  // template class PolygonalSurface
  template <typename TPoint>
  class PolygonalSurface
  {
  public:
    typedef TPoint                               Point;
    typedef PolygonalSurface<TPoint>             Self;
    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<Point>                   PositionsStorage;
    typedef std::vector<PolygonalFace>           PolygonalFacesStorage;
 
    // 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< Point >          PositionsMap;
 
  protected:
    typedef HalfEdgeDataStructure::HalfEdge      HalfEdge;
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~PolygonalSurface() {}
 
    PolygonalSurface() : isHEDSValid( false ) {}
 
    PolygonalSurface( Clone<HalfEdgeDataStructure> aHeds,
                      Clone<PositionsStorage>      pos );
 
    void clear();
 
    bool build();
 
    VertexIndex addVertex( const Point& vdata );
 
    FaceIndex addTriangle( VertexIndex v0, VertexIndex v1, VertexIndex v2 );
 
    FaceIndex addQuadrangle( VertexIndex v0, VertexIndex v1, VertexIndex v2, VertexIndex v3 );
 
    FaceIndex addPolygonalFace( const PolygonalFace& f );
 
    HalfEdgeDataStructure& heds() { return myHEDS; }
    
    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 );
    }
 
    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 );
    }
 
    Point& position( Vertex v );
    const Point& position( Vertex v ) const;
 
    // ----------------------- 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;
 
    ArcRange arcsAroundFace( 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;
    PositionsStorage      myPositions;
    PolygonalFacesStorage myPolygonalFaces;
 
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
  private:
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class PolygonalSurface
 
 
  template <typename TPoint>
  std::ostream&
  operator<< ( std::ostream & out, const PolygonalSurface<TPoint> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/shapes/PolygonalSurface.ih"
 
//                                                                           //
 
#endif // !defined PolygonalSurface_h
 
#undef PolygonalSurface_RECURSES
#endif // else defined(PolygonalSurface_RECURSES)