HyperRectDomain.h

 
#pragma once

 
#if defined(HyperRectDomain_RECURSES)
#error Recursive header files inclusion detected in HyperRectDomain.h
#else // defined(HyperRectDomain_RECURSES)
#define HyperRectDomain_RECURSES
 
#if !defined HyperRectDomain_h
#define HyperRectDomain_h

// Inclusions
#include <iostream>
#include <iterator>
 
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CSpace.h"
#include "DGtal/kernel/BasicPointPredicates.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/kernel/domains/HyperRectDomain_Iterator.h"
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/base/CConstBidirectionalRange.h"
 
namespace DGtal
{
  // class HyperRectDomain
  template<typename TSpace>
  class HyperRectDomain
  {
    BOOST_CONCEPT_ASSERT(( concepts::CSpace<TSpace> ));
 
    // ----------------------- Standard services ------------------------------
  public:
 
    typedef HyperRectDomain<TSpace> Self;
 
    // typedef TSpace DigitalSpace;
    // typedef TSpace Space;
    typedef TSpace Space;
 
    typedef HyperRectDomain<Space> Domain;
    typedef typename Space::Point Point;
    typedef typename Space::Integer Integer;
    typedef typename Space::Vector Vector;
    typedef typename Space::Dimension Dimension;
    typedef typename Space::Size Size;
    typedef typename Point::Coordinate Coordinate;
 
    BOOST_STATIC_CONSTANT(Dimension, dimension = Space::dimension);

    typedef HyperRectDomain_Iterator<Point> Iterator;
    typedef HyperRectDomain_ReverseIterator<Iterator> ReverseIterator;
    typedef Iterator ConstIterator;
    typedef ReverseIterator ConstReverseIterator;
 
    typedef functors::IsWithinPointPredicate<Point> Predicate;

    HyperRectDomain();

    HyperRectDomain ( const Point &lowerPoint, const Point &upperPoint );

    HyperRectDomain ( const typename Space::RealPoint &lowerPoint,
                      const typename Space::RealPoint &upperPoint );

    ~HyperRectDomain();

    HyperRectDomain ( const HyperRectDomain & other );
 

    HyperRectDomain & operator= ( const HyperRectDomain & other );

    const ConstIterator& begin() const
      {
        return myIteratorBegin;
      }
    const ConstIterator& begin() const {…}

    ConstIterator begin(const Point& aPoint) const
      {
        ASSERT_MSG(
            isInside(aPoint) || aPoint == myLowerBound || aPoint == myUpperBound,
            "The point must be inside the domain or be equal to one of his bound."
        );
 
        return ConstIterator(aPoint, myLowerBound, myUpperBound);
      }
    ConstIterator begin(const Point& aPoint) const {…}

    const ConstIterator& end() const
      {
        return myIteratorEnd;
      }
    const ConstIterator& end() const {…}

    ConstReverseIterator rbegin() const
      {
        return ConstReverseIterator(end());
      }
    ConstReverseIterator rbegin() const {…}

    ConstReverseIterator rbegin(const Point& aPoint) const
      {
        ASSERT_MSG(
            isInside(aPoint) || aPoint == myLowerBound || aPoint == myUpperBound,
            "The point must be inside the domain or be equal to one of his bound."
        );
 
        ConstIterator it(begin(aPoint)); ++it;
        return ConstReverseIterator(it);
      }
    ConstReverseIterator rbegin(const Point& aPoint) const {…}

    ConstReverseIterator rend() const
      {
        return ConstReverseIterator(begin());
      }
    ConstReverseIterator rend() const {…}

    struct ConstSubRange
    {
      typedef HyperRectDomain_subIterator<Point> ConstIterator;
      typedef HyperRectDomain_ReverseIterator<ConstIterator> ConstReverseIterator;

      ConstSubRange(const HyperRectDomain<TSpace>& domain,
          const std::vector<Dimension> & permutation,
          const Point & startingPoint)
        : myLowerBound(domain.myLowerBound),
          myUpperBound(domain.myUpperBound),
          myStartingPoint(startingPoint)
        {
          ASSERT_MSG(
              domain.isInside(startingPoint) || startingPoint == myLowerBound || startingPoint == myUpperBound,
              "The point must be inside the given domain or be equal to one of his bound."
          );
 
          myPermutation.reserve( permutation.size() );
          std::copy(permutation.begin(), permutation.end(), std::back_inserter(myPermutation));
          myLowerBound.partialCopyInv(myStartingPoint, myPermutation);
          myUpperBound.partialCopyInv(myStartingPoint, myPermutation);
        }
      ConstSubRange(const HyperRectDomain<TSpace>& domain, {…}

      ConstSubRange(const HyperRectDomain<TSpace>& domain,
          std::initializer_list<Dimension> permutation,
          const Point & startingPoint)
        : myLowerBound(domain.myLowerBound),
          myUpperBound(domain.myUpperBound),
          myStartingPoint(startingPoint)
        {
          ASSERT_MSG(
              domain.isInside(startingPoint) || startingPoint == myLowerBound || startingPoint == myUpperBound,
              "The point must be inside the given domain or be equal to one of his bound."
          );
 
          myPermutation.reserve( permutation.size() );
          for ( const unsigned int *c = permutation.begin(); c != permutation.end(); ++c )
            {
              myPermutation.push_back( *c );
            }
          myLowerBound.partialCopyInv(myStartingPoint, myPermutation);
          myUpperBound.partialCopyInv(myStartingPoint, myPermutation);
        }
      ConstSubRange(const HyperRectDomain<TSpace>& domain, {…}

      ConstSubRange(const HyperRectDomain<TSpace>& domain,
          Dimension adim,
          const Point & startingPoint)
        : myLowerBound(domain.myLowerBound),
          myUpperBound(domain.myUpperBound),
          myStartingPoint(startingPoint)
        {
          ASSERT_MSG(
              domain.isInside(startingPoint) || startingPoint == myLowerBound || startingPoint == myUpperBound,
              "The point must be inside the given domain or be equal to one of his bound."
          );
 
          myPermutation.push_back( adim );
          myLowerBound.partialCopyInv(myStartingPoint, myPermutation);
          myUpperBound.partialCopyInv(myStartingPoint, myPermutation);
        }
      ConstSubRange(const HyperRectDomain<TSpace>& domain, {…}

      ConstSubRange(const HyperRectDomain<TSpace>& domain,
          Dimension adim1, Dimension adim2,
          const Point & startingPoint)
        : myLowerBound(domain.myLowerBound),
          myUpperBound(domain.myUpperBound),
          myStartingPoint(startingPoint)
        {
          ASSERT_MSG(
              domain.isInside(startingPoint) || startingPoint == myLowerBound || startingPoint == myUpperBound,
              "The point must be inside the given domain or be equal to one of his bound."
          );
 
          myPermutation.push_back( adim1 );
          myPermutation.push_back( adim2 );
          myLowerBound.partialCopyInv(myStartingPoint, myPermutation);
          myUpperBound.partialCopyInv(myStartingPoint, myPermutation);
        }
      ConstSubRange(const HyperRectDomain<TSpace>& domain, {…}

      ConstSubRange(const HyperRectDomain<TSpace>& domain,
          Dimension adim1, Dimension adim2, Dimension adim3,
          const Point & startingPoint)
        : myLowerBound(domain.myLowerBound),
          myUpperBound(domain.myUpperBound),
          myStartingPoint(startingPoint)
        {
          ASSERT_MSG(
              domain.isInside(startingPoint) || startingPoint == myLowerBound || startingPoint == myUpperBound,
              "The point must be inside the given domain or be equal to one of his bound."
          );
 
          myPermutation.push_back( adim1 );
          myPermutation.push_back( adim2 );
          myPermutation.push_back( adim3 );
          myLowerBound.partialCopyInv(myStartingPoint, myPermutation);
          myUpperBound.partialCopyInv(myStartingPoint, myPermutation);
        }
      ConstSubRange(const HyperRectDomain<TSpace>& domain, {…}

      ConstIterator begin() const
        {
          return ConstIterator(myLowerBound, myLowerBound, myUpperBound, myPermutation);
        }
      ConstIterator begin() const {…}

      ConstIterator begin(const Point& aPoint) const
        {
          ASSERT(aPoint.partialEqualInv(myLowerBound, myPermutation) );
          ASSERT_MSG(
            ( myLowerBound.isLower(aPoint) && aPoint.isLower(myUpperBound) ) || aPoint == myLowerBound || aPoint == myUpperBound,
            "The point must be inside the given domain or be equal to one of his bound."
          );
 
          return ConstIterator(aPoint, myLowerBound, myUpperBound, myPermutation);
        }
      ConstIterator begin(const Point& aPoint) const {…}

      ConstIterator end() const
        {
          ConstIterator it = ConstIterator(myUpperBound, myLowerBound, myUpperBound, myPermutation);
          ++it;
          return it;
        }
      ConstIterator end() const {…}

      ConstReverseIterator rbegin() const
        {
          return ConstReverseIterator(end());
        }
      ConstReverseIterator rbegin() const {…}

      ConstReverseIterator rbegin(const Point& aPoint) const
        {
          ConstIterator it(begin(aPoint));
          ++it;
          return ConstReverseIterator(it);
        }
      ConstReverseIterator rbegin(const Point& aPoint) const {…}

      ConstReverseIterator rend() const
        {
          return ConstReverseIterator(begin());
        }
      ConstReverseIterator rend() const {…}
 
    private:
      Point                  myLowerBound;
      Point                  myUpperBound;
      Point                  myStartingPoint;
      std::vector<Dimension> myPermutation;
    }; // ConstSubRange
    struct ConstSubRange {…};

    ConstSubRange subRange(const std::vector<Dimension> & permutation) const
      {
        return ConstSubRange(*this, permutation, myLowerBound);
      }
    ConstSubRange subRange(const std::vector<Dimension> & permutation) const {…}

    ConstSubRange subRange(const std::vector<Dimension> & permutation,
        const Point & startingPoint) const
      {
        return ConstSubRange(*this, permutation, startingPoint);
      }
    ConstSubRange subRange(const std::vector<Dimension> & permutation, {…}

    ConstSubRange subRange(Dimension adim,
        const Point & startingPoint) const
      {
        return ConstSubRange(*this, adim, startingPoint);
      }
    ConstSubRange subRange(Dimension adim, {…}

    ConstSubRange subRange(Dimension adim1, Dimension adim2,
        const Point & startingPoint) const
      {
        return ConstSubRange(*this, adim1, adim2, startingPoint);
      }
    ConstSubRange subRange(Dimension adim1, Dimension adim2, {…}

    ConstSubRange subRange(Dimension adim1, Dimension adim2, Dimension adim3,
        const Point & startingPoint) const
      {
        return ConstSubRange(*this, adim1, adim2, adim3, startingPoint);
      }
    ConstSubRange subRange(Dimension adim1, Dimension adim2, Dimension adim3, {…}

    ConstSubRange subRange(std::initializer_list<Dimension> permutation)
      {
        return ConstSubRange(*this, permutation, myLowerBound);
      }
    ConstSubRange subRange(std::initializer_list<Dimension> permutation) {…}

    ConstSubRange subRange(std::initializer_list<Dimension> permutation,
        const Point & startingPoint)
      {
        return ConstSubRange(*this, permutation, startingPoint);
      }
    ConstSubRange subRange(std::initializer_list<Dimension> permutation, {…}
 
    // ----------------------- Interface --------------------------------------
  public:

    Size size() const
      {
        Size res = 1;
        for(Dimension i=0; i < Space::dimension; ++i)
          res *= static_cast<Size>(NumberTraits<Coordinate>::castToUInt64_t(myUpperBound[i] - myLowerBound[i] + 1));
        return res;
      }
    Size size() const {…}

    const Point &lowerBound() const;

    const Point &upperBound() const ;

    bool isInside( const Point & p ) const;

    bool isEmpty() const;

    const Predicate & predicate() const;
 
    // ------------------------- Private Datas --------------------------------
  private:
 
 
 
    // --------------- CDrawableWithBoard2D realization --------------------
  public:

    //DrawableWithBoard2D* defaultStyle( std::string mode = "" ) const;

    std::string className() const;
 

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;
 
 
 
    // ------------------------- Hidden services ------------------------------
  //private:
    Point myLowerBound;
    Point myUpperBound;
 
  private:

    Predicate myPredicate;

    ConstIterator myIteratorBegin;
    ConstIterator myIteratorEnd;
  }; // end of class HyperRectDomain
  class HyperRectDomain {…};
 

  template<typename TSpace>
  std::ostream&
  operator<< ( std::ostream& out, const HyperRectDomain<TSpace> & object );
 
 
} // namespace DGtal
 

// Includes inline functions.
#include "DGtal/kernel/domains/HyperRectDomain.ih"
 
//                                                                           //
 
#endif // !defined HyperRectDomain_h
 
#undef HyperRectDomain_RECURSES
#endif // else defined(HyperRectDomain_RECURSES)