VoxelComplexFunctions.h

 
#pragma once
 
#if defined(VoxelComplexFunctions_RECURSES)
#error Recursive header files inclusion detected in VoxelComplexFunctions.h
#else // defined(VoxelComplexFunctions_RECURSES)
#define VoxelComplexFunctions_RECURSES
 
#if !defined VoxelComplexFunctions_h
#define VoxelComplexFunctions_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/topology/VoxelComplex.h"
namespace DGtal
{
  namespace functions {
 
    template < typename TComplex >
    TComplex
    asymetricThinningScheme(
       TComplex & vc ,
       std::function<
       std::pair<typename TComplex::Cell, typename TComplex::Data> (
         const typename TComplex::Clique &)
       > Select ,
       std::function<
       bool(
         const TComplex & ,
         const typename TComplex::Cell & )
       > Skel,
       bool verbose = false
    );
 
    template < typename TComplex >
    TComplex
    persistenceAsymetricThinningScheme(
       TComplex & vc ,
       std::function<
       std::pair<typename TComplex::Cell, typename TComplex::Data> (
         const typename TComplex::Clique &)
       > Select ,
       std::function<
       bool(
         const TComplex & ,
         const typename TComplex::Cell & )
       > Skel,
       uint32_t persistence,
       bool verbose = false
    );
// Select Functions
    template < typename TComplex >
    std::pair<typename TComplex::Cell, typename TComplex::Data>
    selectFirst(
      const typename TComplex::Clique & clique);
 
    template < typename TComplex >
    std::pair<typename TComplex::Cell, typename TComplex::Data>
    selectRandom(
      const typename TComplex::Clique & clique);
 
    template < typename TComplex, typename TRandomGenerator >
    std::pair<typename TComplex::Cell, typename TComplex::Data>
    selectRandom(
      const typename TComplex::Clique & clique,
      TRandomGenerator & gen);
 
    template < typename TDistanceTransform, typename TComplex >
    std::pair<typename TComplex::Cell, typename TComplex::Data>
    selectMaxValue(
      const TDistanceTransform & dist_map,
      const typename TComplex::Clique & clique);
// Skeleton Functions
    template < typename TComplex >
    bool
    skelUltimate(
      const TComplex & vc,
      const typename TComplex::Cell & cell);
 
    template < typename TComplex >
    bool
    skelEnd(
      const TComplex & vc,
      const typename TComplex::Cell & cell);
 
    template < typename TComplex >
    bool
    skelSimple(
      const TComplex & vc,
      const typename TComplex::Cell & cell);
 
    template < typename TComplex >
    bool
    skelIsthmus(
      const TComplex & vc,
      const typename TComplex::Cell & cell);
 
    template < typename TComplex >
    bool
    oneIsthmus(
      const TComplex & vc,
      const typename TComplex::Cell & cell);
 
    template < typename TComplex >
    bool
    twoIsthmus(
      const TComplex & vc,
      const typename TComplex::Cell & cell);
 
    template < typename TComplex >
    bool
    skelWithTable(
      const boost::dynamic_bitset<> & table,
      const std::unordered_map<typename TComplex::Point, unsigned int> & pointToMaskMap,
      const TComplex & vc,
      const typename TComplex::Cell & cell);
// Helpers for Objects
    template < typename TObject >
    bool
    isZeroSurface(const TObject & small_obj) ;
 
    template < typename TObject >
    bool
    isOneSurface(const TObject & small_obj) ;
 
    template <typename TObject >
    std::vector< TObject >
    connectedComponents(const TObject & input_obj, bool verbose);
  } // namespace functions
 
  //Operators between VoxelComplexes//
 
  template <typename TKSpace, typename TCellContainer>
    inline VoxelComplex< TKSpace, TCellContainer >&
    operator-=( VoxelComplex< TKSpace, TCellContainer >& S1,
        const VoxelComplex< TKSpace, TCellContainer >& S2 )
    {
      typedef VoxelComplex< TKSpace, TCellContainer > VC;
      for ( Dimension i = 0; i <= VC::dimension; ++i )
        functions::setops::operator-=( S1.myCells[ i ],S2.myCells[ i ] );
      return S1;
    }
 
  template <typename TKSpace, typename TCellContainer>
    inline VoxelComplex< TKSpace, TCellContainer >
    operator-( const VoxelComplex< TKSpace, TCellContainer >& S1,
        const VoxelComplex< TKSpace, TCellContainer >& S2 )
    {
      typedef VoxelComplex< TKSpace, TCellContainer > VC;
      VC S(S1);
      for ( Dimension i = 0; i <= VC::dimension; ++i )
        functions::setops::operator-=( S.myCells[ i ],S2.myCells[ i ] );
      return S;
    }
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/topology/VoxelComplexFunctions.ih"
 
//                                                                           //
 
#endif // !defined VoxelComplexFunctions_h
 
#undef VoxelComplexFunctions_RECURSES
#endif // else defined(VoxelComplexFunctions_RECURSES)