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 Object = typename TVoxelComplex::Object;
      using DigitalSet = typename Object::DigitalSet ;
      using Point = typename Object::Point ;
      using Domain = typename DigitalSet::Domain ;
      using DomainConstIterator = typename Domain::ConstIterator ;
      using KSpace = typename TVoxelComplex::KSpace;
      using DigitalTopology = typename Object::DigitalTopology;
      using ForegroundAdjacency = typename Object::ForegroundAdjacency;
      using BackgroundAdjacency = typename Object::BackgroundAdjacency;
      ForegroundAdjacency adjF;
      BackgroundAdjacency adjB;
      DigitalTopology dt( adjF, adjB,
          DigitalTopologyProperties::JORDAN_DT);

      Point p1 = Point::diagonal( -1 );
      Point p2 = Point::diagonal(  1 );
      Point c = Point::diagonal( 0 );
      Domain domain( p1, p2 );
      DigitalSet shapeSet( domain );
      Object shape( dt, shapeSet );
      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(shape.domain().lowerBound() + Point::diagonal( -1 ) ,
          shape.domain().upperBound() + Point::diagonal( 1 ),
          true);
      TVoxelComplex vc(ks);
      vc.construct(shape);
      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)