VoxelComplex.h

 
#pragma once
 
#if defined(VoxelComplex_RECURSES)
#error Recursive header files inclusion detected in VoxelComplex.h
#else // defined(VoxelComplex_RECURSES)
 
#define VoxelComplex_RECURSES
 
#if !defined VoxelComplex_h
 
#define VoxelComplex_h
 
// Inclusions
#include "boost/dynamic_bitset.hpp"
#include <DGtal/kernel/sets/DigitalSetBySTLSet.h>
#include <DGtal/topology/CubicalComplex.h>
#include <DGtal/topology/DigitalTopology.h>
#include <DGtal/topology/Object.h>
 
namespace DGtal {
 
// Forward definitions.
template <typename TKSpace, typename TCellContainer>
class VoxelComplex;
 
template <typename TKSpace, typename TCellContainer>
VoxelComplex<TKSpace, TCellContainer> &
operator-=(VoxelComplex<TKSpace, TCellContainer> &,
           const VoxelComplex<TKSpace, TCellContainer> &);
template <typename TKSpace, typename TCellContainer>
VoxelComplex<TKSpace, TCellContainer>
operator-(const VoxelComplex<TKSpace, TCellContainer> &,
          const VoxelComplex<TKSpace, TCellContainer> &);
 
  // template class VoxelComplex
template <typename TKSpace,
          typename TCellContainer = typename TKSpace::template CellMap< CubicalCellData >::Type >
class VoxelComplex : public CubicalComplex<TKSpace, TCellContainer> {
  public:
    using Self = VoxelComplex<TKSpace, TCellContainer>;
 
    friend Self &DGtal::operator-=<>(Self &, const Self &);
    friend Self DGtal::operator-<>(const Self &, const Self &);
    // ----------------------- associated types ------------------------------
    using Parent = CubicalComplex<TKSpace, TCellContainer>;
    using KSpace = TKSpace;
    using CellContainer = TCellContainer;
    using Data = typename CellContainer::mapped_type;
 
    static const Dimension dimension = KSpace::dimension;
 
    using Integer = typename KSpace::Integer;
    using Cell = typename KSpace::Cell;
    using PreCell = typename Cell::PreCell;
    using Cells = typename KSpace::Cells;
    using Space = typename KSpace::Space;
    using Size = typename KSpace::Size;
    using Point = typename KSpace::Point;
    using DirIterator = typename KSpace::DirIterator;
    using CellMap = CellContainer;
    using CellMapConstIterator = typename CellMap::const_iterator;
    using CellMapIterator = typename CellMap::iterator;
 
    // Clique alias
    using Clique = Parent;
    using CliqueContainer = std::vector<Clique>;
 
    // Tables
    using ConfigMap = boost::dynamic_bitset<>;
    using PointToMaskMap = std::unordered_map<Point, unsigned int>;
 
  protected:
    VoxelComplex();
  public:
    using CubicalComplex<KSpace, CellContainer>::CubicalComplex;
 
    VoxelComplex( const VoxelComplex & other );
 
    Self &operator=(const Self &other);
 
    template < typename TDigitalSet >
    void construct(const TDigitalSet &input_set);
 
    template < typename TDigitalSet >
    void construct(const TDigitalSet &input_set,
                   const Alias<ConfigMap> input_table);
 
    void setSimplicityTable(const Alias<ConfigMap> input_table);
 
    void copySimplicityTable(const Self & other);
 
    const ConfigMap &table() const;
 
    const bool &isTableLoaded() const;
 
    void voxelClose(const Cell &kcell);
 
    void cellsClose(Dimension k_d, const Cells &cells);
 
    void insertVoxelCell(const Cell &kcell, const bool &close_it = true,
                         const Data &data = Data());
 
    void insertVoxelCell(const std::pair<Cell, Data> &data_pair,
                         const bool &close_it = true) {
        insertVoxelCell(data_pair.first, close_it, data_pair.second);
    }
 
    void insertVoxelPoint(const Point &dig_point, const bool &close_it = true,
                          const Data &data = Data());
 
    template<typename TDigitalSet>
    void dumpVoxels(TDigitalSet & in_out_set);
 
    void clear();
 
    void clear( Dimension d );
 
    void erase( typename Parent::Iterator position );
 
    Size erase( const Cell& aCell );
 
    void erase( typename Parent::Iterator first, typename Parent::Iterator last );
 
    //------ Spels ------//
    void pointelsFromCell(std::set<Cell> &pointels_out,
                          const Cell &input_cell) const;
    void spelsFromCell(std::set<Cell> &spels_out, const Cell &input_cell) const;
 
    std::set<Cell> neighborhoodVoxels(const Cell &input_cell) const;
 
    std::set<Cell> properNeighborhoodVoxels(const Cell &input_cell) const;
 
    Clique Kneighborhood(const Cell &input_cell) const;
 
    bool isSimpleByThinning(const Cell &input_spel) const;
    bool isSimple(const Cell &input_spel) const;
 
    //------ Cliques ------//
    // Cliques, union of adjacent spels.
    // The intersection of all spels of the clique define the type.
    // 0-clique, 1-clique, 2-clique. 3-clique are isolated spels.
  public:
    std::pair<bool, Clique>
    criticalCliquePair(const Dimension d,
                       const CellMapConstIterator &cellMapIterator) const;
 
    std::array<CliqueContainer, dimension + 1>
    criticalCliques(const Parent &cubical, bool verbose = false) const {
        ASSERT((dimension + 1) == 4);
        std::array<CliqueContainer, dimension + 1> criticals;
        if (verbose) {
            trace.beginBlock("criticalCliques of CubicalComplex");
            trace.info() << cubical << std::endl;
        }
        for (size_t d = 0; d != dimension + 1; ++d)
            criticals[d] = criticalCliquesForD(d, cubical, verbose);
 
        if (verbose) {
            trace.info() << std::endl;
            trace.endBlock();
        }
        return criticals;
    }
    std::array<CliqueContainer, dimension + 1>
    criticalCliques(bool verbose = false) const {
        return criticalCliques(*this, verbose);
    }
 
    CliqueContainer criticalCliquesForD(const Dimension d,
                                        const Parent &cubical,
                                        bool verbose = false) const;
 
    std::pair<bool, Clique> K_2(const Cell &A, const Cell &B,
                                bool verbose = false) const;
    std::pair<bool, Clique> K_2(const typename KSpace::Point &A,
                                const typename KSpace::Point &B,
                                bool verbose = false) const;
 
    std::pair<bool, Clique> K_2(const Cell &face2, bool verbose = false) const;
 
    std::pair<bool, Clique> K_1(const Cell &face1, bool verbose = false) const;
 
    std::pair<bool, Clique> K_0(const Cell &face0, bool verbose = false) const;
 
    std::pair<bool, Clique> K_3(const Cell &input_spel,
                                bool verbose = false) const;
    bool isSpel(const Cell &c) const;
 
    Cell surfelBetweenAdjacentSpels(const Cell &A, const Cell &B) const;
 
    /*------------- Data --------------*/
  protected:
    CountedPtrOrPtr<ConfigMap> myTablePtr;
    CountedPtrOrPtr<PointToMaskMap> myPointToMaskPtr;
    bool myIsTableLoaded{false}; 
 
    /*------------- Internal Methods --------------*/
    const PointToMaskMap &pointToMask() const;
 
    // ----------------------- Interface --------------------------------------
  public:
    void selfDisplay(std::ostream &out) const;
 
    bool isValid() const;
 
    // --------------- CDrawableWithBoard2D realization ------------------
  public:
    std::string className() const;
 
}; // end of class CubicalComplex
 
template <typename TKSpace, typename TCellContainer>
std::ostream &
operator<<(std::ostream &out,
           const VoxelComplex<TKSpace, TCellContainer> &object);
 
} // namespace DGtal
 
// Includes inline functions.
#include "DGtal/topology/VoxelComplex.ih"
 
//                                                                           //
 
#endif // !defined VoxelComplex_h
 
#undef VoxelComplex_RECURSES
#endif // else defined(VoxelComplex_RECURSES)