Object.ih

#include <cstdlib>
#include "DGtal/kernel/sets/DigitalSetDomain.h"
#include "DGtal/topology/DigitalTopology.h"
#include "DGtal/topology/MetricAdjacency.h"
#include "DGtal/topology/BreadthFirstVisitor.h"

// IMPLEMENTATION of inline methods.
#include "DGtal/topology/Object.h"

// ----------------------- Standard services ------------------------------

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::Object()
    : myTopo( 0 ), myPointSet( 0 ), myConnectedness( UNKNOWN )
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::Object
( const DigitalTopology & aTopology,
    const DigitalSet & aPointSet,
    Connectedness cxn )
    : myTopo( new DigitalTopology( aTopology ) ),
    myPointSet( new DigitalSet( aPointSet ) ),
    myConnectedness( cxn )
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::Object
( const CowPtr<DigitalTopology> & aTopology,
    const DigitalSet & aPointSet,
    Connectedness cxn )
    : myTopo( aTopology ),
    myPointSet( new DigitalSet( aPointSet ) ),
    myConnectedness( cxn )
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::Object
( const TDigitalTopology & aTopology,
    const CowPtr<DigitalSet> & aPointSet,
    Connectedness cxn )
    : myTopo( new DigitalTopology( aTopology ) ),
    myPointSet( aPointSet ),
    myConnectedness( cxn )
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::Object
( const TDigitalTopology & aTopology,
    DigitalSet* aPointSetPtr,
    Connectedness cxn )
    : myTopo( new DigitalTopology( aTopology ) ),
    myPointSet( pointSet ),
    myConnectedness( cxn )
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::Object
( const Object & other )
    : myTopo( other.myTopo ),
    myPointSet( other.myPointSet ),
    myConnectedness( other.myConnectedness )
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::Object
( const TDigitalTopology & aTopology,
    const Domain & aDomain )
    : myTopo( new DigitalTopology( aTopology ) ),
    myPointSet( new DigitalSet( aDomain ) ),
    myConnectedness( CONNECTED )
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::Object
( const CowPtr<DigitalTopology> & aTopology,
    const Domain & aDomain )
    : myTopo( aTopology ),
    myPointSet( new DigitalSet( aDomain ) ),
    myConnectedness( CONNECTED )
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>::~Object()
{
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet> &
DGtal::Object<TDigitalTopology, TDigitalSet>::operator=
( const Object & other )
{
  if ( this != &other )
  {
    myTopo = other.myTopo;
    myPointSet = other.myPointSet;
    myConnectedness = other.myConnectedness;
  }
  return *this;
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::Size
DGtal::Object<TDigitalTopology, TDigitalSet>::size() const
{
  return myPointSet->size();
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
const typename DGtal::Object<TDigitalTopology, TDigitalSet>::Domain &
DGtal::Object<TDigitalTopology, TDigitalSet>::domain() const
{
  return myPointSet->domain();
}


template <typename TDigitalTopology, typename TDigitalSet>
inline
const TDigitalSet &
DGtal::Object<TDigitalTopology, TDigitalSet>::pointSet() const
{
  return *myPointSet;
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
TDigitalSet &
DGtal::Object<TDigitalTopology, TDigitalSet>::pointSet()
{
  myConnectedness = UNKNOWN;
  return *myPointSet;
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
const TDigitalTopology &
DGtal::Object<TDigitalTopology, TDigitalSet>::topology() const
{
  return *myTopo;
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
const typename TDigitalTopology::ForegroundAdjacency &
DGtal::Object<TDigitalTopology, TDigitalSet>::adjacency() const
{
  return myTopo->kappa();
}


// ----------------------- Object services --------------------------------

template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::SmallObject
DGtal::Object<TDigitalTopology, TDigitalSet>::neighborhood
( const Point & p ) const
{
  typedef std::vector<Vertex> Container;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;

  // Intermediate container that is fast writable.
  Container tmp_local_points;
  std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
  adjacency().writeNeighbors( back_ins_it, p );
  tmp_local_points.push_back( p );

  // A neighborhood is small, so is defined the digital object.
  SmallObject neighA( myTopo, pointSet().domain() );
  const ContainerConstIterator it_end( tmp_local_points.end() );
  const DigitalSetConstIterator not_found( pointSet().end() );
  SmallSet & neighASet = neighA.pointSet();
  for ( ContainerConstIterator it = tmp_local_points.begin();
      it != it_end;
      ++it )
    if ( pointSet().find( *it ) != not_found )
      neighASet.insertNew( *it ); // insertNew is guaranteed by construction.
  return neighA;
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::Size
DGtal::Object<TDigitalTopology, TDigitalSet>
::neighborhoodSize( const Point & p ) const
{
  typedef std::vector<Vertex> Container;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;

  // Intermediate container that is fast writable.
  Container tmp_local_points;
  std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
  adjacency().writeNeighbors( back_ins_it, p );
  tmp_local_points.push_back( p );

  // A neighborhood is small, so is defined the digital object.
  const ContainerConstIterator it_end( tmp_local_points.end() );
  const DigitalSetConstIterator not_found( pointSet().end() );
  Size nb = 0;
  for ( ContainerConstIterator it = tmp_local_points.begin();
      it != it_end;
      ++it )
    if ( pointSet().find( *it ) != not_found )
      ++nb;
  return nb;
}


template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::SmallObject
DGtal::Object<TDigitalTopology, TDigitalSet>::properNeighborhood
( const Point & p ) const
{
  typedef std::vector<Vertex> Container;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;

  // Intermediate container that is fast writable.
  Container tmp_local_points;
  std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
  adjacency().writeNeighbors( back_ins_it, p );

  // A neighborhood is small, so is defined the digital object.
  SmallObject neighA( myTopo, pointSet().domain() );
  const ContainerConstIterator it_end( tmp_local_points.end() );
  const DigitalSetConstIterator not_found( pointSet().end() );
  SmallSet & neighASet = neighA.pointSet();
  for ( ContainerConstIterator it = tmp_local_points.begin();
      it != it_end;
      ++it )
    if ( pointSet().find( *it ) != not_found )
      neighASet.insertNew( *it ); // insertNew is guaranteed by construction.
  return neighA;
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::Size
DGtal::Object<TDigitalTopology, TDigitalSet>
::properNeighborhoodSize( const Point & p ) const
{
  typedef std::vector<Vertex> Container;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;

  // Intermediate container that is fast writable.
  Container tmp_local_points;

  std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
  adjacency().writeNeighbors( back_ins_it, p );

  // A neighborhood is small, so is defined the digital object.
  const ContainerConstIterator it_end( tmp_local_points.end() );
  const DigitalSetConstIterator not_found( pointSet().end() );
  Size nb = 0;
  for ( ContainerConstIterator it = tmp_local_points.begin();
      it != it_end;
      ++it )
    if ( pointSet().find( *it ) != not_found )
      ++nb;
  return nb;
}



template <typename TDigitalTopology, typename TDigitalSet>
inline
DGtal::Object<TDigitalTopology, TDigitalSet>
DGtal::Object<TDigitalTopology, TDigitalSet>::border() const
{
  typedef std::vector<Vertex> Container;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;
  //typedef typename Domain::Predicate Predicate;

  // Intermediate container that is fast writable.
  const DigitalSet & mySet = pointSet();
  Object<DigitalTopology, DigitalSet> output( topology(),
      domain() );
  DigitalSet & outputSet = output.pointSet();

  // Loop on all points of the set.
  Container tmp_local_points;
  const DigitalSetConstIterator it_end = mySet.end();
  for ( DigitalSetConstIterator it = mySet.begin();
      it != it_end;
      ++it )
  {
    std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
    // Computing neighborhood within domain.
    topology().lambda().writeNeighbors
    ( back_ins_it, *it, domain().predicate() );
    // Checks if any point is not in the object.
    const ContainerConstIterator itc_end( tmp_local_points.end() );
    for ( ContainerConstIterator itc = tmp_local_points.begin();
        itc != itc_end;
        ++itc )
      if ( pointSet().find( *itc ) == it_end )
      {
        outputSet.insertNew( *it );
        break;
      }
    tmp_local_points.clear();
  }
  return output;
}

template <typename TDigitalTopology, typename TDigitalSet>
template <typename OutputObjectIterator>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::Size
DGtal::Object<TDigitalTopology, TDigitalSet>
::writeComponents( OutputObjectIterator & it ) const
{
  Size nb_components = 0;
  if ( pointSet().empty() )
  {
    myConnectedness = CONNECTED;
    return nb_components;
  }
  else
    if ( connectedness() == CONNECTED )
    {
      *it++ = *this;
      return 1;
    }
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;
  DigitalSetConstIterator it_object = pointSet().begin();
  Point p( *it_object++ );

  // first component.
  BreadthFirstVisitor< Object, std::set<Vertex> > visitor( *this, p );
  while ( ! visitor.finished() ) visitor.expand();
  DigitalSet visited( domain() );
  visited.insertNew( visitor.markedVertices().begin(),
                     visitor.markedVertices().end() );
  *it++ = Object( myTopo, visited, CONNECTED );
  ++nb_components;
  while ( it_object != pointSet().end() )
  {
    p = *it_object++;
    if ( visited.find( p ) == visited.end() )
    {
      BreadthFirstVisitor< Object, std::set<Vertex> > visitor2( *this, p );
      while ( ! visitor2.finished() ) visitor2.expand();
      DigitalSet visited2( domain() );
      visited2.insertNew( visitor2.markedVertices().begin(),
                          visitor2.markedVertices().end() );
      *it++ = Object( myTopo, visited2, CONNECTED );
      ++nb_components;
      visited += visited2;
    }
  }
  // Expander<Object> expander( *this, p );
  // while ( expander.nextLayer() )
  //   ;
  // Object component( myTopo, expander.core(), CONNECTED );
  // *it++ = component;
  // ++nb_components;
  // DigitalSet visited( expander.core() );
  // while ( it_object != pointSet().end() )
  // {
  //   p = *it_object++;
  //   if ( visited.find( p ) == visited.end() )
  //   {
  //     Expander<Object> expander2( *this, p );
  //     while ( expander2.nextLayer() )
  //       ;
  //     Object component2( myTopo, expander2.core(), CONNECTED );
  //     *it++ = component2;
  //     ++nb_components;
  //     visited += expander2.core();
  //   }
  // }
  myConnectedness = nb_components == 1 ? CONNECTED : DISCONNECTED;
  return nb_components;
}

template <typename TDigitalTopology, typename TDigitalSet>
DGtal::Connectedness
DGtal::Object<TDigitalTopology, TDigitalSet>::connectedness() const
{
  return myConnectedness;
}

template <typename TDigitalTopology, typename TDigitalSet>
DGtal::Connectedness
DGtal::Object<TDigitalTopology, TDigitalSet>::computeConnectedness() const
{
  if ( myConnectedness == UNKNOWN )
  {
    if ( pointSet().empty() )
      myConnectedness = CONNECTED;
    else
    {
      // Take first point
      Vertex p = *( pointSet().begin() );
      BreadthFirstVisitor< Object, std::set<Vertex> > visitor( *this, p );
      while ( ! visitor.finished() )
       {
         visitor.expand();
       }
      myConnectedness = ( visitor.visitedVertices().size() == pointSet().size() )
        ? CONNECTED : DISCONNECTED;
      // JOL: 2012/11/16 There is apparently now a bug in expander !
      // Very weird considering this was working in 2012/05. Perhaps
      // this is related to some manipulations in predicates.
      //
      // Expander<Object> expander( *this, p );
      // // and expand.
      // while ( expander.nextLayer() )
      //   ;
      // myConnectedness = ( expander.core().size() == pointSet().size() )
      //     ? CONNECTED : DISCONNECTED;
    }
  }
  return myConnectedness;
}

// ----------------------- Graph services ------------------------------

template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::ConstIterator 
DGtal::Object<TDigitalTopology, TDigitalSet>::begin() const
{
  return myPointSet->begin();
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::ConstIterator 
DGtal::Object<TDigitalTopology, TDigitalSet>::end() const
{
  return myPointSet->end();
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::Size
DGtal::Object<TDigitalTopology, TDigitalSet>::degree
( const Vertex & v ) const
{
  return neighborhoodSize( v );
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::Size
DGtal::Object<TDigitalTopology, TDigitalSet>::bestCapacity() const
{
  return myTopo->kappa().bestCapacity();
}

template <typename TDigitalTopology, typename TDigitalSet>
template <typename OutputIterator>
inline
void
DGtal::Object<TDigitalTopology, TDigitalSet>::
writeNeighbors( OutputIterator & it,
                const Vertex & v ) const
{
  typedef std::vector<Vertex> Container;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;

  // Intermediate container that is fast writable.
  Container tmp_local_points;
  std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
  adjacency().writeNeighbors( back_ins_it, v );

  // A neighborhood is small, so is defined the digital object.
  const ContainerConstIterator it_end( tmp_local_points.end() );
  const DigitalSetConstIterator not_found( pointSet().end() );
  for ( ContainerConstIterator cit = tmp_local_points.begin();
      cit != it_end;
      ++cit )
    if ( pointSet().find( *cit ) != not_found )
      *it++ = *cit;
}

template <typename TDigitalTopology, typename TDigitalSet>
template <typename OutputIterator, typename VertexPredicate>
inline
void
DGtal::Object<TDigitalTopology, TDigitalSet>::
writeNeighbors( OutputIterator & it,
                const Vertex & v,
                const VertexPredicate & pred ) const
{
  typedef std::vector<Vertex> Container;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;

  // Intermediate container that is fast writable.
  Container tmp_local_points;
  std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
  adjacency().writeNeighbors( back_ins_it, v );

  // A neighborhood is small, so is defined the digital object.
  const ContainerConstIterator it_end( tmp_local_points.end() );
  const DigitalSetConstIterator not_found( pointSet().end() );
  for ( ContainerConstIterator cit = tmp_local_points.begin();
      cit != it_end;
      ++cit )
    if ( ( pointSet().find( *cit ) != not_found ) && pred(*cit) )
      *it++ = *cit;
}
// ----------------------- Simple points -------------------------------

template <typename TDigitalTopology, typename TDigitalSet>
template <typename TAdjacency>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::SmallObject
DGtal::Object<TDigitalTopology, TDigitalSet>
::geodesicNeighborhood
( const TAdjacency & adj, const Point & p, unsigned int k ) const
{
  // Local types.
  typedef std::vector<Vertex> Container;
  typedef MetricAdjacency<Space, Space::dimension> AlphaAdjacency;
  typedef MetricAdjacency<Space, 1> OmegaAdjacency;
  typedef DGtal::DigitalTopology<TAdjacency, OmegaAdjacency> LocalTopology;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;
  typedef Object<LocalTopology, SmallSet> LocalObject;
  typedef HyperRectDomain<Space> LocalDomain;

  DigitalSetDomain<DigitalSet> limitedX( *myPointSet );
  AlphaAdjacency alpha;
  OmegaAdjacency omega;
  // Intermediate container that is fast writable.
  Container tmp_local_points;
  std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
  alpha.writeNeighbors( back_ins_it, p, limitedX.predicate() );

  // Construct local domain.
  Point p1( p );
  for ( typename Point::Iterator it = p1.begin(); it != p1.end(); ++it )
    --(*it);
  Point p2( p );
  for ( typename Point::Iterator it = p2.begin(); it != p2.end(); ++it )
    ++(*it);
  LocalDomain aDomain( p1, p2 );

  // Construct local X.
  LocalTopology aTopology( adj, omega );
  LocalObject X( aTopology, aDomain );
  X.pointSet().insertNew( tmp_local_points.begin(), tmp_local_points.end() );

  // A neighborhood is small, so is defined the digital object.
  typename LocalObject::SmallObject neighAdj = X.properNeighborhood( p );

  BreadthFirstVisitor<LocalObject, std::set<Vertex> > visitor
    ( X, neighAdj.pointSet().begin(),
      neighAdj.pointSet().end() );
  while ( ! visitor.finished() )
    visitor.expand();
  SmallObject geodesicN( this->topology(), aDomain );
  geodesicN.pointSet().insertNew( visitor.markedVertices().begin(), 
                                  visitor.markedVertices().end()  );

  // JOL: 2012/11/16 There is apparently now a bug in expander !
  // Very weird considering this was working in 2012/05. Perhaps
  // this is related to some manipulations in predicates.
  // Expander<LocalObject> expander( X,
  //     neighAdj.pointSet().begin(),
  //     neighAdj.pointSet().end() );
  // for ( unsigned int i = 1; ( i < k ) && ( ! expander.finished() ); ++i )
  //   expander.nextLayer();
  // SmallObject geodesicN( this->topology(), expander.core() );
  return geodesicN;

}

template <typename TDigitalTopology, typename TDigitalSet>
template <typename TAdjacency>
inline
typename DGtal::Object<TDigitalTopology, TDigitalSet>::SmallComplementObject
DGtal::Object<TDigitalTopology, TDigitalSet>
::geodesicNeighborhoodInComplement
( const TAdjacency & adj, const Point & p, unsigned int k ) const
{
  // Local types.
  typedef std::vector<Vertex> Container;
  typedef MetricAdjacency<Space, Space::dimension> AlphaAdjacency;
  typedef MetricAdjacency<Space, 1> OmegaAdjacency;
  typedef DGtal::DigitalTopology<TAdjacency, OmegaAdjacency> LocalTopology;
  typedef typename Container::const_iterator ContainerConstIterator;
  typedef typename DigitalSet::ConstIterator DigitalSetConstIterator;
  typedef Object<LocalTopology, SmallSet> LocalObject;
  typedef HyperRectDomain<Space> LocalDomain;
  typedef typename DigitalSetDomain<DigitalSet>::Predicate PredicateIsInX;
  DigitalSetDomain<DigitalSet> limitedX( *myPointSet );
  AlphaAdjacency alpha;
  OmegaAdjacency omega;
  // Intermediate container that is fast writable.
  Container tmp_local_points;
  std::back_insert_iterator< Container > back_ins_it( tmp_local_points );
  NotPointPredicate<PredicateIsInX> not_pred_is_in_X( limitedX.predicate() );
  alpha.writeNeighbors( back_ins_it, p, not_pred_is_in_X );

  // Construct local domain.
  Point p1( p );
  for ( typename Point::Iterator it = p1.begin(); it != p1.end(); ++it )
    --(*it);
  Point p2( p );
  for ( typename Point::Iterator it = p2.begin(); it != p2.end(); ++it )
    ++(*it);
  LocalDomain aDomain( p1, p2 );

  // Construct local Xcomp.
  LocalTopology aTopology( adj, omega );
  LocalObject Xcomp( aTopology, aDomain );
  Xcomp.pointSet().insertNew( tmp_local_points.begin(), tmp_local_points.end() );

  // A neighborhood is small, so is defined the digital object.
  typename LocalObject::SmallObject neighAdj = Xcomp.properNeighborhood( p );

  BreadthFirstVisitor<LocalObject, std::set<Vertex> > visitor
    ( Xcomp, neighAdj.pointSet().begin(),
      neighAdj.pointSet().end() );
  while ( ! visitor.finished() )
    visitor.expand();
  SmallComplementObject geodesicN( this->topology().reverseTopology(),
                                   aDomain ); 
  geodesicN.pointSet().insertNew( visitor.markedVertices().begin(), 
                                  visitor.markedVertices().end()  );

  // JOL: 2012/11/16 There is apparently now a bug in expander !
  // Very weird considering this was working in 2012/05. Perhaps
  // this is related to some manipulations in predicates.
  // Expander<LocalObject> expander( Xcomp,
  //     neighAdj.pointSet().begin(),
  //     neighAdj.pointSet().end() );
  // for ( unsigned int i = 1; ( i < k ) && ( ! expander.finished() ); ++i )
  //   expander.nextLayer();
  // SmallComplementObject geodesicN( this->topology().reverseTopology(),
  //     expander.core() );
  return geodesicN;
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
bool
DGtal::Object<TDigitalTopology, TDigitalSet>
::isSimple( const Point & v ) const
{
  SmallObject Gkappa_X
  = geodesicNeighborhood( topology().kappa(),
      v, Space::dimension );
  if ( Gkappa_X.computeConnectedness() == CONNECTED )
  {
    if ( Gkappa_X.pointSet().empty() )
      return false;
    SmallComplementObject Glambda_compX
    = geodesicNeighborhoodInComplement( topology().lambda(),
        v, Space::dimension );
    return ( Glambda_compX.computeConnectedness()
             == CONNECTED )
      && ( ! Glambda_compX.pointSet().empty() );
  }
  return false;
}


// Interface - public :

template <typename TDigitalTopology, typename TDigitalSet>
inline
void
DGtal::Object<TDigitalTopology, TDigitalSet>
::selfDisplay ( std::ostream & out ) const
{
  out << "[Object"
  << " topology=" << myTopo
  << " counts=" << myPointSet.count()
  << " set=" << *myPointSet
  << " cxn=" << myConnectedness
  << "]";
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
bool
DGtal::Object<TDigitalTopology, TDigitalSet>::isValid() const
{
  return ( *myPointSet != 0 ) && (*myTopo != 0 );
}

template <typename TDigitalTopology, typename TDigitalSet>
inline
std::string
DGtal::Object<TDigitalTopology, TDigitalSet>::className() const
{
  return "Object";
}



// Implementation of inline functions                                        //

template <typename TDigitalTopology, typename TDigitalSet>
inline
std::ostream&
DGtal::operator<< ( std::ostream & out,
    const Object<TDigitalTopology, TDigitalSet> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //