BoundedLatticePolytopeCounter.h

 
#pragma once
 
#if defined(BoundedLatticePolytopeCounter_RECURSES)
#error Recursive header files inclusion detected in BoundedLatticePolytopeCounter.h
#else // defined(BoundedLatticePolytopeCounter_RECURSES)
#define BoundedLatticePolytopeCounter_RECURSES
 
 
#if !defined BoundedLatticePolytopeCounter_h
#define BoundedLatticePolytopeCounter_h
 
// Inclusions
#include <iostream>
#include <map>
#include "DGtal/kernel/IntegralIntervals.h"
#include "DGtal/geometry/volumes/BoundedLatticePolytope.h"
 
namespace DGtal
{
 
  // template class BoundedLatticePolytopeCounter
  template < typename TSpace >
  class BoundedLatticePolytopeCounter 
  {
    BOOST_CONCEPT_ASSERT(( concepts::CSpace< TSpace > ));
  public:
    typedef BoundedLatticePolytopeCounter<TSpace>  Self;
    typedef TSpace                                 Space;
    typedef BoundedLatticePolytope<TSpace>         Polytope;
    using Integer          = typename Polytope::Integer;
    using Point            = typename Polytope::Point;
    using Vector           = typename Polytope::Vector;
    using InequalityMatrix = typename Polytope::InequalityMatrix;
    using InequalityVector = typename Polytope::InequalityVector;
    using Domain           = typename Polytope::Domain;
    using HalfSpace        = typename Polytope::HalfSpace;
    using BigInteger       = typename Polytope::BigInteger;
    using Intervals        = IntegralIntervals< Integer >;
    using Interval         = typename Intervals::Interval;
    using PointRange       = std::vector< Point >;
    static const Dimension dimension = Space::dimension;
 
    using LatticeSetByInterval  = std::map< Point, Interval >;
 
    using LatticeSetByIntervals = std::map< Point, Intervals >;
    
    BoundedLatticePolytopeCounter() = default;
    
    BoundedLatticePolytopeCounter( const Polytope& P );
    
    void init( const Polytope* ptrP );
 
    Interval intersectionIntervalAlongAxis( Point p, Dimension a ) const;
 
    Interval interiorIntersectionIntervalAlongAxis( Point p, Dimension a ) const;
 
    Integer countAlongAxis( Dimension a ) const;
    
    Integer countInteriorAlongAxis( Dimension a ) const;
 
    void getPointsAlongAxis( PointRange& pts, Dimension a ) const;
 
    void getInteriorPointsAlongAxis( PointRange& pts, Dimension a ) const;
 
    LatticeSetByInterval getLatticeSet( Dimension a ) const;
 
    LatticeSetByInterval getLatticeCells( Dimension a ) const;
 
    Dimension longestAxis() const;
 
    Point lowerBound() const { return myLower; }
    Point upperBound() const { return myUpper; }
 
    
    // --------------------------- protected datas -----------------------------------
    const Polytope* myPolytope;
    Point myLower;
    Point myUpper;
  };
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "BoundedLatticePolytopeCounter.ih"
 
//                                                                           //
 
#endif // !defined BoundedLatticePolytopeCounter_h
 
#undef BoundedLatticePolytopeCounter_RECURSES
#endif // else defined(BoundedLatticePolytopeCounter_RECURSES)