TriangulatedSurface.h

 
#pragma once
 
#if defined(TriangulatedSurface_RECURSES)
#error Recursive header files inclusion detected in TriangulatedSurface.h
#else // defined(TriangulatedSurface_RECURSES)
#define TriangulatedSurface_RECURSES
 
#if !defined TriangulatedSurface_h
#define TriangulatedSurface_h
 
// Inclusions
#include <iostream>
#include <set>
#include <map>
#include "DGtal/base/Common.h"
#include "DGtal/base/OwningOrAliasingPtr.h"
#include "DGtal/base/IntegerSequenceIterator.h"
#include "DGtal/topology/HalfEdgeDataStructure.h"
 
namespace DGtal
{
 
  // template class TriangulatedSurface
  template <typename TPoint>
  class TriangulatedSurface
  {
  public:
    typedef TPoint                             Point;
    typedef TriangulatedSurface<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 std::vector<Point>                 PositionsStorage;
    typedef std::vector<Triangle>              TriangleStorage;
 
    // 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:
 
    ~TriangulatedSurface() {}
 
    TriangulatedSurface() : isHEDSValid( false ) {}
 
    void clear();
 
    bool build();
 
    VertexIndex addVertex( const Point& vdata );
 
    FaceIndex addTriangle( VertexIndex v0, VertexIndex v1, VertexIndex v2 );
 
    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;
 
    VertexRange verticesOfFacesAroundArc( const Arc a ) const;
      
    // ----------------------- Other services ---------------------------------
  public:
 
    bool isFlippable( const Arc a ) const;
 
    void flip( const Arc a );
 
    Vertex split( const Arc a, const Point& data );
 
    bool isMergeable( const Arc a ) const;
 
    Vertex merge( const Arc a, const Point& data );
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
    bool isHEDSValid;
    HalfEdgeDataStructure myHEDS;
    PositionsStorage myPositions;
    TriangleStorage myTriangles;
 
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
  private:
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class TriangulatedSurface
 
 
  template <typename TPoint>
  std::ostream&
  operator<< ( std::ostream & out, const TriangulatedSurface<TPoint> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/shapes/TriangulatedSurface.ih"
 
//                                                                           //
 
#endif // !defined TriangulatedSurface_h
 
#undef TriangulatedSurface_RECURSES
#endif // else defined(TriangulatedSurface_RECURSES)