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; // TODO REVOIR LES NOMS.... RECUPERER DANS SPACE
 
    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;
      }
 
    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);
      }
 
    const ConstIterator& end() const
      {
        return myIteratorEnd;
      }
 
    ConstReverseIterator rbegin() const
      {
        return ConstReverseIterator(end());
      }
 
    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 rend() const
      {
        return ConstReverseIterator(begin());
      }
 
    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,
          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,
          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,
          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,
          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);
        }
 
      ConstIterator begin() const
        {
          return ConstIterator(myLowerBound, myLowerBound, myUpperBound, myPermutation);
        }
 
      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 end() const
        {
          ConstIterator it = ConstIterator(myUpperBound, myLowerBound, myUpperBound, myPermutation);
          ++it;
          return it;
        }
 
      ConstReverseIterator rbegin() const
        {
          return ConstReverseIterator(end());
        }
 
      ConstReverseIterator rbegin(const Point& aPoint) const
        {
          ConstIterator it(begin(aPoint));
          ++it;
          return ConstReverseIterator(it);
        }
 
      ConstReverseIterator rend() const
        {
          return ConstReverseIterator(begin());
        }
 
    private:
      Point                  myLowerBound;
      Point                  myUpperBound;
      Point                  myStartingPoint;
      std::vector<Dimension> myPermutation;
    }; // ConstSubRange
 
    ConstSubRange subRange(const std::vector<Dimension> & permutation) const
      {
        return ConstSubRange(*this, permutation, myLowerBound);
      }
 
    ConstSubRange subRange(const std::vector<Dimension> & permutation,
        const Point & startingPoint) const
      {
        return ConstSubRange(*this, permutation, startingPoint);
      }
 
    ConstSubRange subRange(Dimension adim,
        const Point & startingPoint) const
      {
        return ConstSubRange(*this, adim, startingPoint);
      }
 
    ConstSubRange subRange(Dimension adim1, Dimension adim2,
        const Point & startingPoint) const
      {
        return ConstSubRange(*this, adim1, adim2, startingPoint);
      }
 
    ConstSubRange subRange(Dimension adim1, Dimension adim2, Dimension adim3,
        const Point & startingPoint) const
      {
        return ConstSubRange(*this, adim1, adim2, adim3, startingPoint);
      }
 
    ConstSubRange subRange(std::initializer_list<Dimension> permutation)
      {
        return ConstSubRange(*this, permutation, myLowerBound);
      }
 
    ConstSubRange subRange(std::initializer_list<Dimension> permutation,
        const Point & startingPoint)
      {
        return ConstSubRange(*this, permutation, startingPoint);
      }
 
    // ----------------------- Interface --------------------------------------
  public:
 
    Size size() const
      {
        Size res = 1;
        Point p = Point::diagonal(1);
        Vector e =  (myUpperBound - myLowerBound) + p;
        typename Vector::ConstIterator it, itEnd;
        for ( it = e.begin(), itEnd = e.end(); it != itEnd; ++it)
          {
            res *= *it;
          }
        return res;
      }
 
    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
 
 
  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)