#include <DigitalSurface.h>

Collaboration diagram for DGtal::DigitalSurface< TDigitalSurfaceContainer >:

Data Structures
struct	Arc
struct	Edge
struct	Face
struct	SurfelMap
struct	VertexMap

Public Types
typedef TDigitalSurfaceContainer	DigitalSurfaceContainer
typedef DigitalSurface < DigitalSurfaceContainer >	Self
typedef DigitalSurfaceContainer::KSpace	KSpace
typedef DigitalSurfaceContainer::Cell	Cell
typedef DigitalSurfaceContainer::SCell	SCell
typedef DigitalSurfaceContainer::Surfel	Surfel
typedef DigitalSurfaceContainer::SurfelConstIterator	ConstIterator
typedef DigitalSurfaceContainer::DigitalSurfaceTracker	DigitalSurfaceTracker
typedef KSpace::Point	Point
typedef KSpace::SurfelSet	SurfelSet
typedef Surfel	Vertex
typedef KSpace::Size	Size
typedef KSpace::SurfelSet	VertexSet
typedef UmbrellaComputer < DigitalSurfaceTracker >	Umbrella
typedef Umbrella::State	UmbrellaState
typedef std::vector< Arc >	ArcRange
typedef std::vector< Face >	FaceRange
typedef std::vector< Vertex >	VertexRange
typedef std::set< Face >	FaceSet

Public Member Functions
	BOOST_CONCEPT_ASSERT ((CDigitalSurfaceContainer< DigitalSurfaceContainer >))
	~DigitalSurface ()
	DigitalSurface (const DigitalSurface &other)
	DigitalSurface (const DigitalSurfaceContainer &container)
	DigitalSurface (DigitalSurfaceContainer *containerPtr)
DigitalSurface &	operator= (const DigitalSurface &other)
const DigitalSurfaceContainer &	container () const
DigitalSurfaceContainer &	container ()
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
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	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
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 Member Functions
	DigitalSurface ()

Private Attributes
CountedPtr < DigitalSurfaceContainer >	myContainer
DigitalSurfaceTracker *	myTracker
UmbrellaComputer < DigitalSurfaceTracker >	myUmbrellaComputer

Detailed Description

template<typename TDigitalSurfaceContainer>
class DGtal::DigitalSurface< TDigitalSurfaceContainer >

Aim: Represents a set of n-1-cells in a nD space, together with adjacency relation between these cells. Therefore, a digital surface is a pure cubical complex (model of CCubicalComplex), made of k-cells, 0 <= k < n. This complex is generally not a manifold (i.e. a kind of surface), except when it has the property of being well-composed.

Description of template class 'DigitalSurface'

For geometric analysis or visualization, it is often interesting to look at the "dual" of the digital surface. n-1-cells form now vertices, n-2-cells are edges, n-3-cells are faces, and so on. A digital surface is thus a model of CUndirectedSimpleGraph, henceforth of CUndirectedSimpleLocalGraph. The n-1-cells are then seen as the vertices of the graph, while their adjacencies constitutes the edges of the graph.

Furthermore, starting from 3D, a digital surface is in some sense a model of combinatorial surface (closed or open). You may obtain arcs (which are oriented edges) and faces (which are sequences of oriented arcs turning around some pivot cell). In 3D, this dual digital surface is a combinatorial 2-manifold, open or not depending whether the digital surface is open or closed. For instance, arcs may have 0 or 1 incident face.

We construct this dual digital surface with umbrellas, which are sequences of adjacent n-1-cells turning around a n-3-cell, called the pivot of the umbrella. Faces or umbrellas are computed with UmbrellaComputer class.

Proxy class to a DigitalSurfaceContainer.

DigitalSurface is a model of the concept CUndirectedSimpleGraph, CUndirectedSimpleLocalGraph, CSinglePassConstRange, boost::CopyConstructible, boost::Assignable.

Todo:: Should be a model of CCubicalComplex

Template Parameters:

TDigitalSurfaceContainer any model of CDigitalSurfaceContainer: the concrete representation chosen for the digital surface.

Examples:: geometry/surfaces/greedy-plane-segmentation-ex2.cpp, geometry/surfaces/greedy-plane-segmentation.cpp, topology/frontierAndBoundary.cpp, and topology/volToOFF.cpp.

Definition at line 105 of file DigitalSurface.h.

Member Typedef Documentation

template<typename TDigitalSurfaceContainer>

typedef std::vector<Arc> DGtal::DigitalSurface< TDigitalSurfaceContainer >::ArcRange

The range of arcs is defined as a vector.

Definition at line 245 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef DigitalSurfaceContainer::Cell DGtal::DigitalSurface< TDigitalSurfaceContainer >::Cell

Definition at line 115 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef DigitalSurfaceContainer::SurfelConstIterator DGtal::DigitalSurface< TDigitalSurfaceContainer >::ConstIterator

Definition at line 118 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef TDigitalSurfaceContainer DGtal::DigitalSurface< TDigitalSurfaceContainer >::DigitalSurfaceContainer

Definition at line 108 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef DigitalSurfaceContainer::DigitalSurfaceTracker DGtal::DigitalSurface< TDigitalSurfaceContainer >::DigitalSurfaceTracker

Definition at line 119 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef std::vector<Face> DGtal::DigitalSurface< TDigitalSurfaceContainer >::FaceRange

The range of faces is defined as a vector.

Definition at line 247 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef std::set<Face> DGtal::DigitalSurface< TDigitalSurfaceContainer >::FaceSet

The set of faces is defined as set.

Definition at line 251 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef DigitalSurfaceContainer::KSpace DGtal::DigitalSurface< TDigitalSurfaceContainer >::KSpace

Definition at line 114 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef KSpace::Point DGtal::DigitalSurface< TDigitalSurfaceContainer >::Point

Definition at line 120 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef DigitalSurfaceContainer::SCell DGtal::DigitalSurface< TDigitalSurfaceContainer >::SCell

Definition at line 116 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef DigitalSurface<DigitalSurfaceContainer> DGtal::DigitalSurface< TDigitalSurfaceContainer >::Self

Definition at line 113 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef KSpace::Size DGtal::DigitalSurface< TDigitalSurfaceContainer >::Size

Defines how to represent a size (unsigned integral type).

Definition at line 133 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef DigitalSurfaceContainer::Surfel DGtal::DigitalSurface< TDigitalSurfaceContainer >::Surfel

Definition at line 117 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef KSpace::SurfelSet DGtal::DigitalSurface< TDigitalSurfaceContainer >::SurfelSet

Definition at line 121 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef UmbrellaComputer<DigitalSurfaceTracker> DGtal::DigitalSurface< TDigitalSurfaceContainer >::Umbrella

This define a utility class for computing umbrellas.

Definition at line 185 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef Umbrella::State DGtal::DigitalSurface< TDigitalSurfaceContainer >::UmbrellaState

The state of an umbrella is a triplet (surfel, separator, pivot). Given a state, the whole umbrella can be computed.

Definition at line 188 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef Surfel DGtal::DigitalSurface< TDigitalSurfaceContainer >::Vertex

Defines the type for a vertex.

Definition at line 131 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef std::vector<Vertex> DGtal::DigitalSurface< TDigitalSurfaceContainer >::VertexRange

The range of vertices is defined as a vector.

Definition at line 249 of file DigitalSurface.h.

template<typename TDigitalSurfaceContainer>

typedef KSpace::SurfelSet DGtal::DigitalSurface< TDigitalSurfaceContainer >::VertexSet

Defines how to represent a set of vertex.

Definition at line 135 of file DigitalSurface.h.

Constructor & Destructor Documentation

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::~DigitalSurface ( )

inline

Destructor.

Definition at line 46 of file DigitalSurface.ih.

{
  if ( myTracker != 0 ) delete myTracker;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::DigitalSurface ( const DigitalSurface< TDigitalSurfaceContainer > & other )

inline

Copy constructor.

Parameters:

other the object to clone.

Definition at line 54 of file DigitalSurface.ih.

  : myContainer( other.myContainer ),
    myTracker( new DigitalSurfaceTracker( *other.myTracker ) ),
    myUmbrellaComputer( other.myUmbrellaComputer )
{
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::DigitalSurface ( const DigitalSurfaceContainer & container )

inline

Copy constructor from container.

Parameters:

container the container to copy.

Definition at line 64 of file DigitalSurface.ih.

  : myContainer( new DigitalSurfaceContainer( aContainer ) )
{
  if ( ! myContainer->empty() )
    {
      Surfel s = *( myContainer->begin() );
      myTracker = myContainer->newTracker( s ); 
      myUmbrellaComputer.init( *myTracker, 0, false, 1 );
    }
  else 
    myTracker = 0;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::DigitalSurface ( DigitalSurfaceContainer * containerPtr )

inline

Constructor from pointer on a dynamically allocated container.

Parameters:

containerPtr the pointer to acquire.

Definition at line 80 of file DigitalSurface.ih.

  : myContainer( containerPtr )
{
  if ( ! myContainer->empty() )
    {
      Surfel s = *( myContainer->begin() );
      myTracker = myContainer->newTracker( s );
      myUmbrellaComputer.init( *myTracker, 0, false, 1 );
    }
  else 
    myTracker = 0;
}

template<typename TDigitalSurfaceContainer>

DGtal::DigitalSurface< TDigitalSurfaceContainer >::DigitalSurface ( )

protected

Constructor. Forbidden by default (protected to avoid g++ warnings).

Member Function Documentation

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::FaceSet DGtal::DigitalSurface< TDigitalSurfaceContainer >::allClosedFaces ( ) const

inline

This set of faces is sufficient for displaying the surface.

Returns:: the set of all closed faces of the digital surface.

Definition at line 409 of file DigitalSurface.ih.

{
  FaceSet all_faces;
  for ( ConstIterator it = begin(), it_end = end(); it != it_end; ++it )
    {
      FaceRange local_faces = facesAroundVertex( *it );
      for ( typename FaceRange::const_iterator lit = local_faces.begin(),
              lit_end = local_faces.end(); lit != lit_end; ++lit )
        if ( lit->isClosed() )
          all_faces.insert( *lit );
    }
  return all_faces;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::FaceSet DGtal::DigitalSurface< TDigitalSurfaceContainer >::allFaces ( ) const

inline

Returns:: the set of all faces of the digital surface (open and closed faces).

Definition at line 394 of file DigitalSurface.ih.

{
  FaceSet all_faces;
  for ( ConstIterator it = begin(), it_end = end(); it != it_end; ++it )
    {
      FaceRange local_faces = facesAroundVertex( *it );
      all_faces.insert( local_faces.begin(), local_faces.end() );
    }
  return all_faces;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::FaceSet DGtal::DigitalSurface< TDigitalSurfaceContainer >::allOpenFaces ( ) const

inline

This set of faces is sufficient for displaying the boundary of the surface.

Returns:: the set of all closed faces of the digital surface.

Definition at line 427 of file DigitalSurface.ih.

{
  FaceSet all_faces;
  for ( ConstIterator it = begin(), it_end = end(); it != it_end; ++it )
    {
      FaceRange local_faces = facesAroundVertex( *it );
      for ( typename FaceRange::const_iterator lit = local_faces.begin(),
              lit_end = local_faces.end(); lit != lit_end; ++lit )
        if ( ! lit->isClosed() )
          all_faces.insert( *lit );
    }
  return all_faces;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc DGtal::DigitalSurface< TDigitalSurfaceContainer >::arc	(	const Vertex &	tail,
		const Vertex &	head
	)		const

inline

[tail] and [head] should be adjacent surfel.

Parameters:

tail	the vertex at the tail of the arc.
head	the vertex at the head of the arc.

Returns:: the arc (tail, head)

Definition at line 337 of file DigitalSurface.ih.

{
  const KSpace & K = container().space();
  Point p1 = K.sKCoords( t );
  Point p2 = K.sKCoords( h );
  p2 -= p1;
  for ( typename KSpace::DirIterator q = K.sDirs( h );
        q != 0; ++q )
    {
      Dimension i = *q;
      if ( p1[ i ] != 0 ) return Arc( t, i, p1[ i ] > 0 );
    }
  ASSERT( false && "DGtal::DigitalSurface<TDigitalSurfaceContainer>::arc( tail, head ): tail and head are not adjacent." );
  return Arc( t, 0, true );
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::ConstIterator DGtal::DigitalSurface< TDigitalSurfaceContainer >::begin ( ) const

inline

Returns:: a ConstIterator on the first surfel in the container.

Definition at line 128 of file DigitalSurface.ih.

{
  return myContainer->begin();
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::Size DGtal::DigitalSurface< TDigitalSurfaceContainer >::bestCapacity ( ) const

inline

Should return a reasonable estimation of the number of neighbors for all vertices. For instance a planar triangulation should return 6-8, a quad-mesh should return 4, digital surface is 2*(K::dimension-1).

Returns:: 2*(K::dimension-1)

Definition at line 152 of file DigitalSurface.ih.

{
  return KSpace::dimension*2 - 2;
}

template<typename TDigitalSurfaceContainer>

DGtal::DigitalSurface< TDigitalSurfaceContainer >::BOOST_CONCEPT_ASSERT ( (CDigitalSurfaceContainer< DigitalSurfaceContainer >) )

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::Face DGtal::DigitalSurface< TDigitalSurfaceContainer >::computeFace ( UmbrellaState state ) const

inline

Parameters:

state any valid state (i.e. some pivot cell) on the surface.

Returns:: the face that contains the given [state].

Definition at line 446 of file DigitalSurface.ih.

References DGtal::false, and DGtal::DigitalSurface< TDigitalSurfaceContainer >::Face::state.

{
  myUmbrellaComputer.setState( state );
  Surfel start = state.surfel;
  unsigned int nb = 0;
  unsigned int code;
  do
    {
      // std::cerr << "       + s/surf " 
      //           << myUmbrellaComputer.state().surfel<< std::endl;
      ++nb;
      code = myUmbrellaComputer.previous();
      if ( code == 0 ) break; // face is open
      if ( myUmbrellaComputer.state() < state ) 
        state = myUmbrellaComputer.state();
    }
  while ( myUmbrellaComputer.surfel() != start );
  if ( code == 0 ) // open face
    { // Going back to count the number of incident vertices.
      nb = 0;
      do 
        {
          // std::cerr << "       + c/surf "
          //           << myUmbrellaComputer.state().surfel<< std::endl;
          ++nb;
          code = myUmbrellaComputer.next();
        }
      while ( code != 0 );
      return Face( myUmbrellaComputer.state(), nb, false );
    }
  else             // closed face
    return Face( state, nb, true );
}

template<typename TDigitalSurfaceContainer >

const TDigitalSurfaceContainer & DGtal::DigitalSurface< TDigitalSurfaceContainer >::container ( ) const

inline

Returns:: a const reference to the stored container.

Definition at line 112 of file DigitalSurface.ih.

{
  return *myContainer;
}

template<typename TDigitalSurfaceContainer >

TDigitalSurfaceContainer & DGtal::DigitalSurface< TDigitalSurfaceContainer >::container ( )

inline

Returns:: a reference to the container (may be duplicated if several DigitalSurface points on the same).

Definition at line 120 of file DigitalSurface.ih.

{
  return *myContainer;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::Size DGtal::DigitalSurface< TDigitalSurfaceContainer >::degree ( const Vertex & v ) const

inline

Parameters:

v	any vertex of this graph

Returns:: the number of neighbors of this Vertex/Surfel.a

Precondition:: container().isInside( v )

Definition at line 161 of file DigitalSurface.ih.

{
  Size d = 0;
  Vertex s;
  myTracker->move( v );
  for ( typename KSpace::DirIterator q = container().space().sDirs( v );
        q != 0; ++q )
    {
      if ( myTracker->adjacent( s, *q, true ) )
        ++d;
      if ( myTracker->adjacent( s, *q, false ) )
        ++d;
    }
  return d;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::ConstIterator DGtal::DigitalSurface< TDigitalSurfaceContainer >::end ( ) const

inline

Returns:: a ConstIterator after the last surfel in the container.

Definition at line 136 of file DigitalSurface.ih.

{
  return myContainer->end();
}

template<typename TDigitalSurfaceContainer >

template<typename SCellEmbedderWithGradientMap >

void DGtal::DigitalSurface< TDigitalSurfaceContainer >::exportAs3DNOFF	(	std::ostream &	out,
		const SCellEmbedderWithGradientMap &	scembedder
	)		const

Writes/Displays the object on an output stream in NOFF file format. Cells are embedded by [scembedder]. Normals are also computed by the embedder.

Parameters:

out	the output stream where the object is written.
scembedder	any embedder of signed cellular grid elements.

Template Parameters:

SCellEmbedderWithGradientMap any model of CSCellEmbedder and CWithGradientMap.

Definition at line 756 of file DigitalSurface.ih.

{
  BOOST_CONCEPT_ASSERT(( CSCellEmbedder< SCellEmbedderWithGradientMap > ));
  BOOST_CONCEPT_ASSERT(( CWithGradientMap< SCellEmbedderWithGradientMap > ));
  typedef typename SCellEmbedderWithGradientMap::GradientMap GradientMap;
  typedef typename SCellEmbedderWithGradientMap::SCell MySCell;
  typedef typename SCellEmbedderWithGradientMap::RealPoint RealPoint;
  typedef typename SCellEmbedderWithGradientMap::RealVector RealVector;
  typedef DGtal::uint64_t Number;
  // Gets the gradient map.
  GradientMap gradMap = scembedder.gradientMap();
  // Numbers all vertices.
  std::map<Vertex, Number> index;
  Number nbv = 0;
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    index[ *it ] = nbv++;
  // Get faces
  // std::cerr << "- " << nbv << " vertices." << std::endl;
  FaceSet faces = allClosedFaces();
  // Compute the number of edges and faces.
  Number nbe = 0;
  Number nbf = 0;
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        { nbe += itf->nbVertices; ++nbf; }
      else
        { nbe += itf->nbVertices - 1; }
    }
  // std::cerr << "- " << nbf << " faces." << std::endl;
  // Outputs OFF header.
  out << "NOFF" << std::endl
      << "# Generated by DGtal::DigitalSurface." << std::endl
      << nbv << " " << nbf << " " << ( nbe / 2 ) << std::endl;
  // Outputs vertex coordinates (the 3 first ones).
  RealPoint p;
  RealVector v;
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    {
      MySCell c = *it;
      p = scembedder( c );
      v = gradMap( c );
      //cembedder.embedSCell( *it, p, v );
      double norm = v.norm();
      if ( norm != 0.0 ) v /= norm;
      out << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << " "
          << v[ 0 ] << " " << v[ 1 ] << " " << v[ 2 ] << std::endl;
      // double areaD = NumberTraits<Coordinate>::castToDouble(area)*2.0; 
    }
  // Outputs closed faces.
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        {
          out << itf->nbVertices;
          VertexRange vtcs = verticesAroundFace( *itf );
          for ( typename VertexRange::const_iterator
                  itv = vtcs.begin(), itv_end = vtcs.end();
                itv != itv_end; ++itv )
            out << " " << index[ *itv ];
          out << std::endl;
        }
    }
}

template<typename TDigitalSurfaceContainer >

template<typename CellEmbedder >

void DGtal::DigitalSurface< TDigitalSurfaceContainer >::exportEmbeddedIteratedSurfaceAs3DNOFF	(	std::ostream &	out,
		const CellEmbedder &	cembedder
	)		const

Writes/Displays the object on an output stream in NOFF file format. Surface spels are embedded by [cembedder]. Normals are also computed by the embedder.

Parameters:

out	the output stream where the object is written.
cembedder	any embedder of digital surface spels.

Definition at line 836 of file DigitalSurface.ih.

References DGtal::PointVector< dim, TEuclideanRing >::norm().

{
  typedef DGtal::uint64_t Number;
  // Numbers all vertices.
  std::map<Vertex, Number> index;
  Number nbv = 0;
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    index[ *it ] = nbv++;
  // Get faces
  // std::cerr << "- " << nbv << " vertices." << std::endl;
  FaceSet faces = allClosedFaces();
  // Compute the number of edges and faces.
  Number nbe = 0;
  Number nbf = 0;
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        { nbe += itf->nbVertices; ++nbf; }
      else
        { nbe += itf->nbVertices - 1; }
    }
  // std::cerr << "- " << nbf << " faces." << std::endl;
  // Outputs OFF header.
  out << "NOFF" << std::endl
      << "# Generated by DGtal::DigitalSurface." << std::endl
      << nbv << " " << nbf << " " << ( nbe / 2 ) << std::endl;
  // Outputs vertex coordinates (the 3 first ones).
  typedef typename CellEmbedder::RealPoint RealPoint;
  typedef typename CellEmbedder::RealVector RealVector;
  const KSpace & K = container().space();
  RealPoint p;
  RealVector v;
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    {
      cembedder.embedSurfel( it, p, v );
      double norm = v.norm();
      if ( norm != 0.0 ) v /= norm;
      out << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << " "
          << v[ 0 ] << " " << v[ 1 ] << " " << v[ 2 ] << std::endl;
      // double areaD = NumberTraits<Coordinate>::castToDouble(area)*2.0; 
    }
  // Outputs closed faces.
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        {
          out << itf->nbVertices;
          VertexRange vtcs = verticesAroundFace( *itf );
          for ( typename VertexRange::const_iterator
                  itv = vtcs.begin(), itv_end = vtcs.end();
                itv != itv_end; ++itv )
            out << " " << index[ *itv ];
          out << std::endl;
        }
    }
}

template<typename TDigitalSurfaceContainer >

template<typename CellEmbedder >

void DGtal::DigitalSurface< TDigitalSurfaceContainer >::exportEmbeddedSurfaceAs3DNOFF	(	std::ostream &	out,
		const CellEmbedder &	cembedder
	)		const

Writes/Displays the object on an output stream in NOFF file format. Cells are embedded by [cembedder]. Normals are also computed by the embedder.

Parameters:

out	the output stream where the object is written.
cembedder	any embedder of cellular grid elements.

Template Parameters:

CellEmbedder any model of CCellEmbedder and CWithGradientMap.

Definition at line 675 of file DigitalSurface.ih.

{
  BOOST_CONCEPT_ASSERT(( CCellEmbedder< CellEmbedder > ));
  BOOST_CONCEPT_ASSERT(( CWithGradientMap< CellEmbedder > ));
  typedef typename CellEmbedder::GradientMap GradientMap;
  typedef typename CellEmbedder::Cell MyCell;
  typedef typename CellEmbedder::RealPoint RealPoint;
  typedef typename CellEmbedder::RealVector RealVector;
  typedef DGtal::uint64_t Number;
  // Gets the gradient map.
  GradientMap gradMap = cembedder.gradientMap();
  // Numbers all vertices.
  std::map<Vertex, Number> index;
  Number nbv = 0;
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    index[ *it ] = nbv++;
  // Get faces
  // std::cerr << "- " << nbv << " vertices." << std::endl;
  FaceSet faces = allClosedFaces();
  // Compute the number of edges and faces.
  Number nbe = 0;
  Number nbf = 0;
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        { nbe += itf->nbVertices; ++nbf; }
      else
        { nbe += itf->nbVertices - 1; }
    }
  // std::cerr << "- " << nbf << " faces." << std::endl;
  // Outputs OFF header.
  out << "NOFF" << std::endl
      << "# Generated by DGtal::DigitalSurface." << std::endl
      << nbv << " " << nbf << " " << ( nbe / 2 ) << std::endl;
  // Outputs vertex coordinates (the 3 first ones).
  const KSpace & K = container().space();
  RealPoint p;
  RealVector v;
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    {
      MyCell c = K.unsigns( *it );
      p = cembedder( c );
      v = gradMap( c );
      //cembedder.embedSCell( *it, p, v );
      double norm = v.norm();
      if ( norm != 0.0 ) v /= norm;
      out << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << " "
          << v[ 0 ] << " " << v[ 1 ] << " " << v[ 2 ] << std::endl;
      // double areaD = NumberTraits<Coordinate>::castToDouble(area)*2.0; 
    }
  // Outputs closed faces.
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        {
          out << itf->nbVertices;
          VertexRange vtcs = verticesAroundFace( *itf );
          for ( typename VertexRange::const_iterator
                  itv = vtcs.begin(), itv_end = vtcs.end();
                itv != itv_end; ++itv )
            out << " " << index[ *itv ];
          out << std::endl;
        }
    }
}

template<typename TDigitalSurfaceContainer >

template<typename CellEmbedder >

void DGtal::DigitalSurface< TDigitalSurfaceContainer >::exportEmbeddedSurfaceAs3DOFF	(	std::ostream &	out,
		const CellEmbedder &	cembedder
	)		const

Writes/Displays the object on an output stream in OFF file format. Cells are embedded by [cembedder]. Normals are not computed.

Parameters:

out	the output stream where the object is written.
cembedder	any embedder of cellular grid elements.

Template Parameters:

CellEmbedder any model of CCellEmbedder.

Definition at line 609 of file DigitalSurface.ih.

{
  BOOST_CONCEPT_ASSERT(( CCellEmbedder< CellEmbedder > ));
  typedef DGtal::uint64_t Number;
  // Numbers all vertices.
  std::map<Vertex, Number> index;
  Number nbv = 0;
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    index[ *it ] = nbv++;
  // Get faces
  // std::cerr << "- " << nbv << " vertices." << std::endl;
  FaceSet faces = allClosedFaces();
  // Compute the number of edges and faces.
  Number nbe = 0;
  Number nbf = 0;
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        { nbe += itf->nbVertices; ++nbf; }
      else
        { nbe += itf->nbVertices - 1; }
    }
  // std::cerr << "- " << nbf << " faces." << std::endl;
  // Outputs OFF header.
  out << "OFF" << std::endl
      << "# Generated by DGtal::DigitalSurface." << std::endl
      << nbv << " " << nbf << " " << ( nbe / 2 ) << std::endl;
  // Outputs vertex coordinates (the 3 first ones).
  typedef typename CellEmbedder::RealPoint RealPoint;
  const KSpace & K = container().space();
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    {
      RealPoint p( cembedder( K.unsigns( *it ) ) );
      out << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << std::endl;
      // double areaD = NumberTraits<Coordinate>::castToDouble(area)*2.0; 
    }
  // Outputs closed faces.
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        {
          out << itf->nbVertices;
          VertexRange vtcs = verticesAroundFace( *itf );
          for ( typename VertexRange::const_iterator
                  itv = vtcs.begin(), itv_end = vtcs.end();
                itv != itv_end; ++itv )
            out << " " << index[ *itv ];
          out << std::endl;
        }
    }
}

template<typename TDigitalSurfaceContainer >

void DGtal::DigitalSurface< TDigitalSurfaceContainer >::exportSurfaceAs3DOFF ( std::ostream & out ) const

Writes/Displays the object on an output stream in OFF file format. Cells are embbeded onto their default centroid.

Parameters:

out	the output stream where the object is written.

Writes/Displays the object on an output stream.

Parameters:

out	the output stream where the object is written.

Definition at line 547 of file DigitalSurface.ih.

{
  typedef DGtal::uint64_t Number;
  // Numbers all vertices.
  std::map<Vertex, Number> index;
  Number nbv = 0;
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    index[ *it ] = nbv++;
  // Get faces
  // std::cerr << "- " << nbv << " vertices." << std::endl;
  FaceSet faces = allClosedFaces();
  // Compute the number of edges and faces.
  Number nbe = 0;
  Number nbf = 0;
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        { nbe += itf->nbVertices; ++nbf; }
      else
        { nbe += itf->nbVertices - 1; }
    }
  // std::cerr << "- " << nbf << " faces." << std::endl;
  // Outputs OFF header.
  out << "OFF" << std::endl
      << "# Generated by DGtal::DigitalSurface." << std::endl
      << nbv << " " << nbf << " " << ( nbe / 2 ) << std::endl;
  // Outputs vertex coordinates (the 3 first ones).
  const KSpace & K = container().space();
  for ( ConstIterator it = begin(), it_end = end();
        it != it_end; ++it )
    {
      Point p = K.sKCoords( *it );
      out << p[ 0 ] << " " << p[ 1 ] << " " << p[ 2 ] << std::endl;
      // double areaD = NumberTraits<Coordinate>::castToDouble(area)*2.0; 
    }
  // Outputs closed faces.
  for ( typename FaceSet::const_iterator
          itf = faces.begin(), itf_end = faces.end();
        itf != itf_end; ++itf )
    {
      if ( itf->isClosed() ) 
        {
          out << itf->nbVertices;
          VertexRange vtcs = verticesAroundFace( *itf );
          for ( typename VertexRange::const_iterator
                  itv = vtcs.begin(), itv_end = vtcs.end();
                itv != itv_end; ++itv )
            out << " " << index[ *itv ];
          out << std::endl;
        }
    }
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::FaceRange DGtal::DigitalSurface< TDigitalSurfaceContainer >::facesAroundArc ( const Arc & a ) const

inline

Computes the faces incident to a given arc. Empty in 2D. 1 face in 3D, 2 in 4D and so one, n-2 in nD. Returned faces may be open.

Parameters:

a	any arc on the surface.

Returns:: a vector containing the faces incident to this arc.

Definition at line 357 of file DigitalSurface.ih.

References DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::base, DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::epsilon, and DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::k.

{
  FaceRange faces;
  UmbrellaState state( a.base, a.k, a.epsilon, 0 );
  myUmbrellaComputer.setState( state );
  SCell sep = myUmbrellaComputer.separator();
  // Faces are to be found along direction spanned by the separator.
  for ( typename KSpace::DirIterator q = container().space().sDirs( sep );
        q != 0; ++q )
    {
      state.j = *q;
      faces.push_back( computeFace( state ) );
    }
  return faces;
  
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::FaceRange DGtal::DigitalSurface< TDigitalSurfaceContainer >::facesAroundVertex ( const Vertex & v ) const

inline

Parameters:

v	any vertex (surfel) of the surface.

Returns:: the faces containing this vertex [v]: 0 in 2D, 4 in 3D, 12 in 4D, 2(n-1)(n-2) in nD.

Definition at line 271 of file DigitalSurface.ih.

{
  typedef typename ArcRange::const_iterator ArcRangeConstIterator;
  // std::cerr << "  - facesAroundVertex(" << v << ")" << std::endl;
  ArcRange arcs = outArcs( v );
  FaceRange faces;
  std::back_insert_iterator<FaceRange> output_it = std::back_inserter( faces );
  for ( ArcRangeConstIterator it = arcs.begin(), it_end = arcs.end();
        it != it_end; ++it )
    {
      // std::cerr << "     + arc " << tail( *it )
      //           << " -> " << head( *it ) << std::endl;
      FaceRange faces_of_arc = facesAroundArc( *it );
      output_it = 
        std::copy( faces_of_arc.begin(), faces_of_arc.end(), output_it );
    }
  return faces;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::Vertex DGtal::DigitalSurface< TDigitalSurfaceContainer >::head ( const Arc & a ) const

inline

Definition at line 294 of file DigitalSurface.ih.

References DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::base, DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::epsilon, and DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::k.

{
  Vertex s;
  myTracker->move( a.base );
  uint8_t code = myTracker->adjacent( s, a.k, a.epsilon );
  ASSERT( code != 0 );
  return s;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::ArcRange DGtal::DigitalSurface< TDigitalSurfaceContainer >::inArcs ( const Vertex & v ) const

inline

Parameters:

v	any vertex (surfel) of the surface.

Returns:: the ingoing arcs to [v]

Definition at line 249 of file DigitalSurface.ih.

{
  ArcRange arcs;
  Vertex s;
  myTracker->move( v );
  for ( typename KSpace::DirIterator q = container().space().sDirs( v );
        q != 0; ++q )
    {
      Dimension i = *q;
      if ( myTracker->adjacent( s, i, true ) )
        arcs.push_back( opposite( Arc( v, i, true ) ) );
      if ( myTracker->adjacent( s, i, false ) )
        arcs.push_back( opposite( Arc( v, i, false ) ) );
    }
  return arcs;
}

template<typename TDigitalSurfaceContainer >

bool DGtal::DigitalSurface< TDigitalSurfaceContainer >::isValid ( ) const

inline

Checks the validity/consistency of the object.

Returns:: 'true' if the object is valid, 'false' otherwise.

Definition at line 534 of file DigitalSurface.ih.

{
  return myTracker != 0;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer > & DGtal::DigitalSurface< TDigitalSurfaceContainer >::operator= ( const DigitalSurface< TDigitalSurfaceContainer > & other )

inline

Assignment.

Parameters:

other the object to copy.

Returns:: a reference on 'this'.

Definition at line 97 of file DigitalSurface.ih.

References DGtal::DigitalSurface< TDigitalSurfaceContainer >::myContainer, DGtal::DigitalSurface< TDigitalSurfaceContainer >::myTracker, and DGtal::DigitalSurface< TDigitalSurfaceContainer >::myUmbrellaComputer.

{
  if ( this != &other )
    {
      myContainer = other.myContainer;
      if ( myTracker != 0 ) delete myTracker;
      myTracker = new DigitalSurfaceTracker( *other.myTracker );
      myUmbrellaComputer = other.myUmbrellaComputer;
    }
  return *this;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc DGtal::DigitalSurface< TDigitalSurfaceContainer >::opposite ( const Arc & a ) const

inline

Parameters:

a	any arc (s,t)

Returns:: the arc (t,s)

Definition at line 316 of file DigitalSurface.ih.

References DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::base, DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::epsilon, and DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::k.

{
  Vertex s;
  myTracker->move( a.base );
  uint8_t code = myTracker->adjacent( s, a.k, a.epsilon );
  ASSERT( code != 0 );
  if ( code == 2 ) return Arc( s, a.k, ! a.epsilon );
  else 
    {
      bool orientation = container().space().sDirect( a.base, a.k );
      unsigned int i = myTracker->orthDir();
      return Arc( s, i, 
                  ( orientation == a.epsilon )
                  == container().space().sDirect( s, i ) );
    } 
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::ArcRange DGtal::DigitalSurface< TDigitalSurfaceContainer >::outArcs ( const Vertex & v ) const

inline

Parameters:

v	any vertex (surfel) of the surface.

Returns:: the outgoing arcs from [v]

Definition at line 228 of file DigitalSurface.ih.

{
  ArcRange arcs;
  Vertex s;
  myTracker->move( v );
  for ( typename KSpace::DirIterator q = container().space().sDirs( v );
        q != 0; ++q )
    {
      Dimension i = *q;
      if ( myTracker->adjacent( s, i, true ) )
        arcs.push_back( Arc( v, i, true ) );
      if ( myTracker->adjacent( s, i, false ) )
        arcs.push_back( Arc( v, i, false ) );
    }
  return arcs;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::SCell DGtal::DigitalSurface< TDigitalSurfaceContainer >::pivot ( const Face & f ) const

inline

NB: there may be different faces with the same pivot (except on the boundary of well-composed pictures).

Parameters:

f any face.

Returns:: the positively oriented n-3-cell that is the pivot of the face.

Definition at line 503 of file DigitalSurface.ih.

References DGtal::DigitalSurface< TDigitalSurfaceContainer >::Face::state.

{
  SCell sep = container().space().sIncident( f.state.surfel, f.state.k, 
                                             f.state.epsilon );
  return container().space().sDirectIncident( sep, f.state.j );
}

template<typename TDigitalSurfaceContainer >

void DGtal::DigitalSurface< TDigitalSurfaceContainer >::selfDisplay ( std::ostream & out ) const

inline

Writes/Displays the object on an output stream.

Parameters:

out	the output stream where the object is written.

Definition at line 522 of file DigitalSurface.ih.

{
  out << "[DigitalSurface]";
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::SCell DGtal::DigitalSurface< TDigitalSurfaceContainer >::separator ( const Arc & a ) const

inline

NB: there may be two arcs with the same separator.

Parameters:

a any arc.

Returns:: the n-2-cell between the two surfels forming the arc.

Definition at line 484 of file DigitalSurface.ih.

References DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::base, DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::epsilon, and DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::k.

{
  return container().space().sIncident( a.base, a.k, a.epsilon );
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::Size DGtal::DigitalSurface< TDigitalSurfaceContainer >::size ( ) const

inline

Returns:: the number of vertices of the graph.

Definition at line 144 of file DigitalSurface.ih.

{
  return myContainer->nbSurfels();
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::Vertex DGtal::DigitalSurface< TDigitalSurfaceContainer >::tail ( const Arc & a ) const

inline

Definition at line 307 of file DigitalSurface.ih.

References DGtal::DigitalSurface< TDigitalSurfaceContainer >::Arc::base.

{
  return a.base;
}

template<typename TDigitalSurfaceContainer >

DGtal::DigitalSurface< TDigitalSurfaceContainer >::VertexRange DGtal::DigitalSurface< TDigitalSurfaceContainer >::verticesAroundFace ( const Face & f ) const

inline

If f is incident to the arcs (s,t) and (t,u) (say), then (s,t,u) is a subsequence of the returned sequence.

Parameters:

f	any valid face on the digital surface (open or closed ).

Returns:: the sequence of vertices that touches this face. The order follows the order of incident arcs

Definition at line 378 of file DigitalSurface.ih.

References DGtal::DigitalSurface< TDigitalSurfaceContainer >::Face::nbVertices, and DGtal::DigitalSurface< TDigitalSurfaceContainer >::Face::state.

{
  VertexRange vertices;
  myUmbrellaComputer.setState( f.state );
  for ( unsigned int i = 0; i < f.nbVertices; ++i )
    {
      vertices.push_back( myUmbrellaComputer.surfel() );
      myUmbrellaComputer.previous();
    }
  return vertices;
}

template<typename TDigitalSurfaceContainer >

template<typename OutputIterator >

void DGtal::DigitalSurface< TDigitalSurfaceContainer >::writeNeighbors	(	OutputIterator &	it,
		const Vertex &	v
	)		const

inline

Writes the neighbors of [v] in the output iterator [it]. Neighbors are given in no specific order.

Template Parameters:

OutputIterator the type for the output iterator (e.g. back_insert_iterator<std::vector<Vertex> >).

Parameters:

[in,out]	it	any output iterator on Vertex (*it++ should be allowed), which specifies where neighbors are written.
[in]	v	any vertex of this graph

Precondition:: container().isInside( v )

Definition at line 182 of file DigitalSurface.ih.

{
  Vertex s;
  myTracker->move( v );
  for ( typename KSpace::DirIterator q = container().space().sDirs( v );
        q != 0; ++q )
    {
      if ( myTracker->adjacent( s, *q, true ) )
        *it++ = s;
      if ( myTracker->adjacent( s, *q, false ) )
        *it++ = s;
    }
}

template<typename TDigitalSurfaceContainer >

template<typename OutputIterator , typename VertexPredicate >

void DGtal::DigitalSurface< TDigitalSurfaceContainer >::writeNeighbors	(	OutputIterator &	it,
		const Vertex &	v,
		const VertexPredicate &	pred
	)		const

inline

Writes the neighbors of [v], verifying the predicate [pred] in the output iterator [it]. Neighbors are given in no specific order.

Template Parameters:

OutputIterator	the type for the output iterator (e.g. back_insert_iterator<std::vector<Vertex> >).
VertexPredicate	any type of predicate taking a Vertex as input.

Parameters:

[in,out]	it	any output iterator on Vertex (*it++ should be allowed), which specifies where neighbors are written.
[in]	v	any vertex of this graph
[in]	pred	the predicate for selecting neighbors.

Precondition:: container().isInside( v )

Definition at line 202 of file DigitalSurface.ih.

{
  BOOST_CONCEPT_ASSERT(( CVertexPredicate< VertexPredicate > ));
  Vertex s;
  myTracker->move( v );
  for ( typename KSpace::DirIterator q = container().space().sDirs( v );
        q != 0; ++q )
    {
      if ( myTracker->adjacent( s, *q, true ) )
        {
          if ( pred( s ) ) *it++ = s;
        }
      if ( myTracker->adjacent( s, *q, false ) )
        {
          if ( pred( s ) ) *it++ = s;
        }
    }
}

Field Documentation

template<typename TDigitalSurfaceContainer>

CountedPtr<DigitalSurfaceContainer> DGtal::DigitalSurface< TDigitalSurfaceContainer >::myContainer

private

a smart pointer on the container.

Definition at line 572 of file DigitalSurface.h.

Referenced by DGtal::DigitalSurface< TDigitalSurfaceContainer >::operator=().

template<typename TDigitalSurfaceContainer>

DigitalSurfaceTracker* DGtal::DigitalSurface< TDigitalSurfaceContainer >::myTracker

mutableprivate

a pointer on a tracker.

Definition at line 574 of file DigitalSurface.h.

Referenced by DGtal::DigitalSurface< TDigitalSurfaceContainer >::operator=().

template<typename TDigitalSurfaceContainer>

UmbrellaComputer<DigitalSurfaceTracker> DGtal::DigitalSurface< TDigitalSurfaceContainer >::myUmbrellaComputer

mutableprivate

This object is used to compute umbrellas over the surface.

Definition at line 576 of file DigitalSurface.h.

Referenced by DGtal::DigitalSurface< TDigitalSurfaceContainer >::operator=().

The documentation for this class was generated from the following files:

Data Structures

Public Types

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

template<typename TDigitalSurfaceContainer> class DGtal::DigitalSurface< TDigitalSurfaceContainer >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation

template<typename TDigitalSurfaceContainer>
class DGtal::DigitalSurface< TDigitalSurfaceContainer >