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 "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(( CSpace<TSpace> ));

    // ----------------------- Standard services ------------------------------
  public:

    typedef HyperRectDomain<TSpace> Self;
    
    // typedef TSpace DigitalSpace;
    // typedef TSpace Space;
    typedef TSpace Space;

    // static constants
    static const typename Space::Dimension dimension = Space::dimension;

    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

    typedef HyperRectDomain_Iterator<Point> Iterator;
    typedef myreverse_iterator<Iterator> ReverseIterator;
    typedef Iterator ConstIterator;
    typedef ReverseIterator ConstReverseIterator;
    
    typedef IsWithinPointPredicate<Point> Predicate;

    HyperRectDomain();

    HyperRectDomain ( const Point &aPointA, const Point &aPointB );


    ~HyperRectDomain();

    HyperRectDomain ( const HyperRectDomain & other );


    HyperRectDomain & operator= ( const HyperRectDomain & other );

    /*
     * begin method.
     * @return ConstIterator on the beginning of the range.
     */
    const ConstIterator& begin() const
    { return myIteratorBegin; }
    
    /*
     * begin method from a given point.
     * @param aPoint the initial point.
     * @return a ConstIterator initialized to aPoint.
     * @pre aPoint must belong to the range.
     */
    ConstIterator begin(const Point& aPoint) const
    { ASSERT(isInside(aPoint));
      return ConstIterator(aPoint, 
                           myLowerBound, myUpperBound); }
    
    /*
     * end method.
     * @return ConstIterator on the end of the range.
     */
    const ConstIterator& end() const
    { return myIteratorEnd; }
    
    /*
     * reverse begin method.
     * @return ConstIterator on the beginning of the reverse range.
     */
    ConstReverseIterator rbegin() const
    { return ConstReverseIterator(end()); }
    
    /*
     * reverse begin method from a given point.
     * @param aPoint the initial point.
     * @return a ConstIterator initialized to aPoint.
     * @pre aPoint must belong to the range.
     */
    ConstReverseIterator rbegin(const Point& aPoint) const
    {  ASSERT(isInside(aPoint));
      ConstIterator it(begin(aPoint)); ++it;
      return ConstReverseIterator(it); }
    
    /*
     * reverse end method.
     * @return ConstIterator on the end of the reverse range.
     */
    ConstReverseIterator rend() const
    { return ConstReverseIterator(begin()); }
    
    struct ConstSubRange 
    {
      typedef HyperRectDomain_subIterator<Point> ConstIterator;
      typedef myreverse_iterator<ConstIterator> ConstReverseIterator;

      ConstSubRange(const HyperRectDomain<TSpace>& domain,
                    const std::vector<Dimension> & permutation,
                    const Point & startingPoint)
        : myLowerBound(domain.myLowerBound),
          myUpperBound(domain.myUpperBound),
          myStartingPoint(startingPoint)
      {
        myPermutation.reserve( permutation.size() );
        std::copy(permutation.begin(),permutation.end(),
                  std::back_inserter(myPermutation));
        myLowerBound.partialCopyInv(myStartingPoint, myPermutation);
        myUpperBound.partialCopyInv(myStartingPoint, myPermutation);
      }

#ifdef CPP11_INITIALIZER_LIST

      ConstSubRange(const HyperRectDomain<TSpace>& domain,
                    std::initializer_list<Dimension> permutation,
                    const Point & startingPoint)
        : myLowerBound(domain.myLowerBound),
          myUpperBound(domain.myUpperBound),
          myStartingPoint(startingPoint)
      {
        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);
      }
#endif

      ConstSubRange(const HyperRectDomain<TSpace>& domain,
                    Dimension adim,
                    const Point & startingPoint)
        : myLowerBound(domain.myLowerBound),
          myUpperBound(domain.myUpperBound),
          myStartingPoint(startingPoint)
      {
        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)
      {
        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)
      {
        myPermutation.push_back( adim1 );
        myPermutation.push_back( adim2 );
        myPermutation.push_back( adim3 );
        myLowerBound.partialCopyInv(myStartingPoint, myPermutation);
        myUpperBound.partialCopyInv(myStartingPoint, myPermutation);
      }
      
      /*
       * begin method.
       * @return ConstIterator on the beginning of the range.
       */
      ConstIterator begin() const
      {  return ConstIterator(myLowerBound, myLowerBound,
                              myUpperBound, myPermutation); }
      
      /*
       * begin method from a given point.
       * @param aPoint the initial point.
       * @return a ConstIterator initialized to aPoint.
       * @pre aPoint must belong to the range.
       */
      ConstIterator begin(const Point& aPoint) const
      { 
        ASSERT(aPoint.partialEqualInv(myLowerBound, myPermutation) );
        ASSERT(myLowerBound<=aPoint && aPoint<=myUpperBound);
        return ConstIterator(aPoint, myLowerBound,
                             myUpperBound, myPermutation);
      }

      /*
       * end method.
       * @return ConstIterator on the end of the range.
       */
      ConstIterator end() const
      {
        ConstIterator it = ConstIterator(myUpperBound, myLowerBound,
                                         myUpperBound, myPermutation);
        ++it;
        return it;
      }

      /*
       * reverse begin method.
       * @return ConstIterator on the beginning of the reverse range.
       */
      ConstReverseIterator rbegin() const
      { return ConstReverseIterator(end()); }

      /*
       * reverse begin method from a given point.
       * @param aPoint the initial point.
       * @return a ConstIterator initialized to aPoint.
       * @pre aPoint must belong to the range.
       */
      ConstReverseIterator rbegin(const Point& aPoint) const
      { ConstIterator it(begin(aPoint)); ++it;
        return ConstReverseIterator(it); }

      /*
       * reverse end method.
       * @return ConstIterator on the end of the reverse range.
       */
      ConstReverseIterator rend() const
      { return ConstReverseIterator(begin()); }

    private:
      Point                  myLowerBound;
      Point                  myUpperBound;
      Point                  myStartingPoint;
      std::vector<Dimension> myPermutation;
    };

    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); }
    
#ifdef CPP11_INITIALIZER_LIST

    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); }
#endif
    
    // ----------------------- Interface --------------------------------------
  public:
    Vector extent() const
    {
      Point p = Point::diagonal(1);
      return (myUpperBound - myLowerBound) + p;
    }

    Size size() const
    {
      Size res = 1;
      Vector e = this->extent();
      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;

    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)