CubicalComplexFunctions.h

 
#pragma once
 
#if defined(CubicalComplexFunctions_RECURSES)
#error Recursive header files inclusion detected in CubicalComplexFunctions.h
#else // defined(CubicalComplexFunctions_RECURSES)
#define CubicalComplexFunctions_RECURSES
 
#if !defined CubicalComplexFunctions_h
#define CubicalComplexFunctions_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/topology/CubicalComplex.h"
#include <DGtal/topology/helpers/NeighborhoodConfigurationsHelper.h>
 
namespace DGtal
{
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >
  operator~( const CubicalComplex< TKSpace, TCellContainer >& S1 )
  {
    CubicalComplex< TKSpace, TCellContainer > S( S1 );
    S.close();
    return S;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >
  operator*( const CubicalComplex< TKSpace, TCellContainer >& S1 )
  {
    CubicalComplex< TKSpace, TCellContainer > S( S1 );
    S.open();
    return S;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >&
  operator-=( CubicalComplex< TKSpace, TCellContainer >& S1,
              const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      functions::setops::operator-=( S1.myCells[ i ],S2.myCells[ i ] );
    return S1;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >
  operator-( const CubicalComplex< TKSpace, TCellContainer >& S1,
             const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    CC S( S1 );
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      functions::setops::operator-=( S.myCells[ i ],S2.myCells[ i ] );
    return S;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >
  operator|( const CubicalComplex< TKSpace, TCellContainer >& S1,
             const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    CC S( S1 );
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      functions::setops::operator|=( S.myCells[ i ],S2.myCells[ i ] );
    return S;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >&
  operator|=( CubicalComplex< TKSpace, TCellContainer >& S1,
              const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      functions::setops::operator|=( S1.myCells[ i ], S2.myCells[ i ] );
    return S1;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >
  operator&( const CubicalComplex< TKSpace, TCellContainer >& S1,
             const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    CC S( S1 );
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      functions::setops::operator&=( S.myCells[ i ], S2.myCells[ i ] );
    return S;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >&
  operator&=( CubicalComplex< TKSpace, TCellContainer >& S1,
              const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      functions::setops::operator&=( S1.myCells[ i ], S2.myCells[ i ] );
    return S1;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >
  operator^( const CubicalComplex< TKSpace, TCellContainer >& S1,
             const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    CC S( S1 );
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      functions::setops::operator^=( S.myCells[ i ], S2.myCells[ i ] );
    return S;
  }
 
  template <typename TKSpace, typename TCellContainer>
  inline CubicalComplex< TKSpace, TCellContainer >&
  operator^=( CubicalComplex< TKSpace, TCellContainer >& S1,
              const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      functions::setops::operator^=( S1.myCells[ i ], S2.myCells[ i ] );
    return S1;
  }
 
 
  template <typename TKSpace, typename TCellContainer>
  bool
  operator==( const CubicalComplex< TKSpace, TCellContainer >& S1,
              const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    ASSERT( &(S1.space()) == &(S2.space()) );
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      if ( ! functions::isEqual( S1.myCells[ i ], S2.myCells[ i ] ) )
        return false;
    return true;
  }
 
 
  template <typename TKSpace, typename TCellContainer>
  bool
  operator!=( const CubicalComplex< TKSpace, TCellContainer >& S1,
              const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    ASSERT( &(S1.space()) == &(S2.space()) );
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      if ( ! functions::isEqual( S1.myCells[ i ], S2.myCells[ i ] ) )
        return true;
    return false;
  }
 
 
  template <typename TKSpace, typename TCellContainer>
  bool
  operator<=( const CubicalComplex< TKSpace, TCellContainer >& S1,
              const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    ASSERT( &(S1.space()) == &(S2.space()) );
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      if ( ! functions::isSubset( S1.myCells[ i ], S2.myCells[ i ] ) )
        return false;
    return true;
  }
 
  template <typename TKSpace, typename TCellContainer>
  bool
  operator>=( const CubicalComplex< TKSpace, TCellContainer >& S1,
              const CubicalComplex< TKSpace, TCellContainer >& S2 )
  {
    typedef CubicalComplex< TKSpace, TCellContainer > CC;
    ASSERT( &(S1.space()) == &(S2.space()) );
    for ( Dimension i = 0; i <= CC::dimension; ++i )
      if ( ! functions::isSubset( S2.myCells[ i ], S1.myCells[ i ] ) )
        return false;
    return true;
  }
 
  namespace functions {
    
    template <typename TKSpace, typename TCellContainer,
              typename CellConstIterator,
              typename CellMapIteratorPriority >
    uint64_t collapse( CubicalComplex< TKSpace, TCellContainer > & K,
                       CellConstIterator S_itB, CellConstIterator S_itE,
                       const CellMapIteratorPriority& priority,
                       bool hintIsSClosed = false, bool hintIsKClosed = false,
                       bool verbose = false );
 
    template <typename TKSpace, typename TCellContainer,
              typename BdryCellOutputIterator,
              typename InnerCellOutputIterator>
    void
    filterCellsWithinBounds( const CubicalComplex< TKSpace, TCellContainer > & K,
                             const typename TKSpace::Point& kLow,
                             const typename TKSpace::Point& kUp,
                             BdryCellOutputIterator itBdry,
                             InnerCellOutputIterator itInner );
 
    template < typename TObject, typename TKSpace, typename TCellContainer>
      std::unique_ptr<TObject>
      objectFromSpels(const CubicalComplex< TKSpace, TCellContainer > & C);
 
  template<typename TComplex>
  NeighborhoodConfiguration
  getSpelNeighborhoodConfigurationOccupancy(
      const          TComplex        & input_complex,
      const typename TComplex::Point & center,
      const std::unordered_map<
              typename TComplex::Point, NeighborhoodConfiguration> & mapPointToMask);
  } // namespace functions
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/topology/CubicalComplexFunctions.ih"
 
//                                                                           //
 
#endif // !defined CubicalComplexFunctions_h
 
#undef CubicalComplexFunctions_RECURSES
#endif // else defined(CubicalComplexFunctions_RECURSES)