Object.h

 
#pragma once
 
#if defined(Object_RECURSES)
#error Recursive header files inclusion detected in Object.h
#else // defined(Object_RECURSES)
#define Object_RECURSES
 
#if !defined Object_h
#define Object_h
 
// Inclusions
#include <iostream>
#include <string>
#include <map>
#include "DGtal/base/Common.h"
#include "DGtal/base/CowPtr.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/base/Clone.h"
#include "DGtal/base/Alias.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/kernel/sets/CDigitalSet.h"
#include "DGtal/kernel/sets/DigitalSetSelector.h"
#include "DGtal/topology/Topology.h"
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>
#include <boost/dynamic_bitset.hpp>
#include <unordered_map>
#include <DGtal/topology/helpers/NeighborhoodConfigurationsHelper.h>
 
namespace boost
{
  struct Object_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 Object
  template <typename TDigitalTopology, typename TDigitalSet>
  class Object
  {
    // ----------------------- Standard services ------------------------------
  public:
    typedef TDigitalSet DigitalSet;
 
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSet< TDigitalSet > ));
 
    // ----------------------- boost graph tags ------------------------------
    // JOL (2013/02/01): required to define internal tags (boost/graph/copy.hpp, l. 251 error ?).
    // PHC(2016/02/01): copied from digital surface to use connected_components
  public:
    typedef boost::undirected_tag directed_category;
    typedef boost::Object_graph_traversal_category traversal_category;
    typedef boost::disallow_parallel_edge_tag edge_parallel_category;
 
    typedef TDigitalTopology DigitalTopology;
    typedef typename DigitalTopology::ReverseTopology ReverseTopology;
    typedef typename DigitalSet::Size Size;
    typedef typename DigitalSet::Point Point;
    // should be the same as Point.
    typedef typename DigitalTopology::Point DTPoint;
 
    typedef typename DigitalSet::Domain Domain;
    typedef typename Domain::Space Space;
    typedef
      typename DigitalSetSelector < Domain,
               SMALL_DS + HIGH_ITER_DS >::Type SmallSet;
    typedef typename DigitalTopology::ForegroundAdjacency ForegroundAdjacency;
    typedef typename DigitalTopology::BackgroundAdjacency BackgroundAdjacency;
    typedef Object<ReverseTopology, DigitalSet> ComplementObject;
    typedef Object<DigitalTopology, SmallSet> SmallObject;
    typedef Object<ReverseTopology, SmallSet> SmallComplementObject;
 
    // Required by CUndirectedSimpleLocalGraph
    typedef typename DigitalSet::Point Vertex;
    typedef TDigitalSet VertexSet;
    template <typename Value> struct VertexMap {
      typedef typename std::map<Vertex, Value> Type;
    };
    typedef typename DigitalSet::ConstIterator ConstIterator;
 
    // Required by CUndirectedSimpleGraph
    struct Edge
    {
      Vertex vertices [2];
 
      inline Edge(){}
 
      Edge( const Vertex & v1, const Vertex & v2, const bool )
      {
        vertices[ 0 ] = v1;
        vertices[ 1 ] = v2;
      }
      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[ 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 ] ) );
      }
    };
    // ... End added
 
    typedef std::vector<Edge> EdgeRange;
 
    Object();
 
    Object( Clone<DigitalTopology> aTopology,
        Clone<DigitalSet> aPointSet,
        Connectedness cxn = UNKNOWN );
 
 
    Object( Clone<DigitalTopology> aTopology,
        Clone<Domain> domain );
 
    Object ( const Object & other );
 
    ~Object();
 
    Object & operator= ( const Object & other );
 
    void setTable(Alias<boost::dynamic_bitset<> >inputTable);
 
    NeighborhoodConfiguration getNeighborhoodConfigurationOccupancy(
        const Point & center,
        const std::unordered_map< Point,
        NeighborhoodConfiguration> & mapZeroNeighborhoodToMask) const;
    Size size() const;
 
    const Domain & domain() const;
 
    CowPtr<Domain> domainPointer() const;
 
    const DigitalSet & pointSet() const;
 
    DigitalSet & pointSet();
 
    const DigitalTopology & topology() const;
 
    const ForegroundAdjacency & adjacency() const;
 
    // ----------------------- Object services --------------------------------
  public:
 
    SmallObject neighborhood( const Point & p ) const;
 
    Size neighborhoodSize( const Point & p ) const;
 
    SmallObject properNeighborhood( const Point & p ) const;
 
    Size properNeighborhoodSize( const Point & p ) const;
 
 
    // ----------------------- border services -------------------------------
  public:
 
 
    Object border() const;
 
 
    // ----------------------- Connectedness services -------------------------
  public:
 
    template <typename OutputObjectIterator>
      Size writeComponents( OutputObjectIterator & it ) const;
 
    Connectedness connectedness() const;
 
    Connectedness computeConnectedness() const;
 
    // ----------------------- Graph services ------------------------------
  public:
 
    ConstIterator begin() const;
 
 
    ConstIterator end() 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;
 
    EdgeRange outEdges( const Vertex & v) const;
 
    Edge opposite(const Edge & e) const;
 
    Vertex head( const Edge & e) const;
    Vertex tail( const Edge & e) const;
 
    // ----------------------- Simple points -------------------------------
  public:
 
    template <typename TAdjacency>
      SmallObject
      geodesicNeighborhood( const TAdjacency & adj,
          const Point & p, unsigned int k ) const;
 
    template <typename TAdjacency>
      SmallComplementObject
      geodesicNeighborhoodInComplement( const TAdjacency & adj,
          const Point & p, unsigned int k ) const;
 
 
    bool isSimple( const Point & v ) const;
 
    inline bool isSimpleFromTable(
        const Point & v,
        const boost::dynamic_bitset<> & input_table,
        const std::unordered_map< Point,
          NeighborhoodConfiguration > & mapZeroNeighborhoodToMask) const;
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
 
    CowPtr<DigitalTopology> myTopo;
 
    CowPtr<DigitalSet> myPointSet;
 
    mutable Connectedness myConnectedness;
 
    CountedPtrOrPtr<boost::dynamic_bitset<> > myTable;
 
    CountedPtrOrPtr<std::unordered_map<Point,unsigned int> > myNeighborConfigurationMap;
 
    bool myTableIsLoaded;
 
    // --------------- CDrawableWithBoard2D realization ------------------
  public:
    std::string className() const;
 
 
  }; // end of class Object
 
 
  template <typename TDigitalTopology, typename TDigitalSet>
    std::ostream&
    operator<< ( std::ostream & out,
        const Object<TDigitalTopology, TDigitalSet> & object );
 
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/topology/Object.ih"
 
//                                                                           //
 
#endif // !defined Object_h
 
#undef Object_RECURSES
#endif // else defined(Object_RECURSES)