NeighborhoodTablesGenerators.h

 
#if defined(NeighborhoodConfigurationsGenerators_RECURSES)
#error Recursive header files inclusion detected in NeighborhoodConfigurationsGenerators.h
#else // defined(NeighborhoodConfigurationsGenerators_RECURSES)
#define NeighborhoodConfigurationsGenerators_RECURSES
 
#if !defined NeighborhoodConfigurationsGenerators_h
#define NeighborhoodConfigurationsGenerators_h
// Inclusions
#include <iostream>
#include <bitset>
#include <memory>
#include "DGtal/topology/Object.h"
#include "DGtal/helpers/StdDefs.h"
#include <unordered_map>
#include "boost/dynamic_bitset.hpp"
#include <DGtal/topology/helpers/NeighborhoodConfigurationsHelper.h>
#include "DGtal/topology/VoxelComplexFunctions.h"
 
namespace DGtal {
  namespace functions {
 
  template <typename TObject, typename TMap>
  void
  generateSimplicityTable(
      const typename TObject::DigitalTopology & dt,
      TMap & map )
  {
    typedef typename TObject::DigitalSet DigitalSet;
    typedef typename TObject::Point Point;
    typedef typename DigitalSet::Domain Domain;
    typedef typename Domain::ConstIterator DomainConstIterator;
 
    Point p1 = Point::diagonal( -1 );
    Point p2 = Point::diagonal(  1 );
    Point c = Point::diagonal( 0 );
    Domain domain( p1, p2 );
    DigitalSet shapeSet( domain );
    TObject shape( dt, shapeSet );
    unsigned int k = 0;
    for ( DomainConstIterator it = domain.begin(); it != domain.end(); ++it )
      if ( *it != c ) ++k;
    ASSERT( ( k < 32 )
        && "[generateSimplicityTable] number of configurations is too high." );
    unsigned int nbCfg = 1 << k;
    for ( NeighborhoodConfiguration cfg = 0; cfg < nbCfg; ++cfg )
    {
      if ( ( cfg % 1000 ) == 0 )
      {
        trace.progressBar( (double) cfg, (double) nbCfg );
      }
      shape.pointSet().clear();
      shape.pointSet().insert( c );
      NeighborhoodConfiguration mask = 1;
      for ( DomainConstIterator it = domain.begin(); it != domain.end(); ++it )
      {
        if ( *it != c )
        {
          if ( cfg & mask ) shape.pointSet().insert( *it );
          mask <<= 1;
        }
      }
      bool simple = shape.isSimple( c );
      map[ cfg ] = simple;
    }
  }
 
  template <typename TVoxelComplex, typename TMap>
    void
    generateVoxelComplexTable(
        TMap & map,
        std::function< bool(
          const TVoxelComplex & ,
          const typename TVoxelComplex::Cell & )
        > skelFunction
        )
    {
      using Domain = DGtal::Z3i::Domain;
      using Point = typename Domain::Point ;
      using DigitalSet = DigitalSetByAssociativeContainer<
        Domain, std::unordered_set< Point > >;
      using DomainConstIterator = typename Domain::ConstIterator ;
      using KSpace = typename TVoxelComplex::KSpace;
 
      Point p1 = Point::diagonal( -1 );
      Point p2 = Point::diagonal(  1 );
      Point c = Point::diagonal( 0 );
      Domain domain( p1, p2 );
      DigitalSet shapeSet( domain );
      unsigned int k = 0;
      for ( DomainConstIterator it = domain.begin(); it != domain.end(); ++it )
        if ( *it != c ) ++k;
      ASSERT( ( k < 32 )
          && "[generateVoxelComplexTable] number of configurations is too high." );
      unsigned int nbCfg = 1 << k;
 
      KSpace ks;
      // Pad KSpace domain.
      ks.init(domain.lowerBound() + Point::diagonal( -1 ) ,
          domain.upperBound() + Point::diagonal( 1 ),
          true);
      TVoxelComplex vc(ks);
      vc.construct(shapeSet);
      for ( unsigned int cfg = 0; cfg < nbCfg; ++cfg ){
        if ( ( cfg % 1000 ) == 0 )
          trace.progressBar( (double) cfg, (double) nbCfg );
        vc.clear();
        vc.insertVoxelPoint(c);
        unsigned int mask = 1;
        for ( DomainConstIterator it = domain.begin(); it != domain.end(); ++it ){
          if ( *it != c ) {
            if ( cfg & mask ) vc.insertVoxelPoint( *it );
            mask <<= 1;
          }
        }
        const auto &kcell = vc.space().uSpel(c);
        bool predicate_output = skelFunction(vc, kcell);
        map[ cfg ] = predicate_output;
      }
    }
  }// namespace functions
}// namespace DGtal
 
#endif // !defined NeighborhoodConfigurationsGenerators_h
 
#undef NeighborhoodConfigurationsGenerators_RECURSES
#endif // else defined(NeighborhoodConfigurationsGenerators_RECURSES)