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 data -----------------------------------
    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)