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
{
  namespace functions {

    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 )
        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 )
        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 )
        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 )
        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 )
        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 )
        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 )
        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 )
        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 ( ! 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 ( ! 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 ( ! 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 ( ! isSubset( S2.myCells[ i ], S1.myCells[ i ] ) )
          return false;
      return true;
    }

    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)