Interval.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_Interval_h__)
#define __geom_Interval_h__

// If we are debugging the whole geom package.
#if defined(DEBUG_geom) && !defined(DEBUG_Interval)
#define DEBUG_Interval
#endif

#ifdef DEBUG_Interval
// Debug the FixedArray class as well.
#ifndef DEBUG_FixedArray
#define DEBUG_FixedArray
#endif
#endif

#include "../defs.h"

#include "../../ads/array/FixedArray.h"
  
#include <iosfwd>

BEGIN_NAMESPACE_GEOM


template<int N, typename T = double>
class Interval {
public:

  //
  // Public types
  //

  typedef T Number;
  typedef ads::FixedArray<N,T> Point;

private:

  //
  // Data
  //

  // The lower and upper corners of the interval.
  Point _min, _max;
  
public:

  //--------------------------------------------------------------------------
  // @{
  
  Interval() :
    _min(),
    _max()
  {}

  Interval(const Point& min, const Point& max) :
    _min(min),
    _max(max)
  {}
    
  Interval(const Number xmin, const Number xmax) :
    _min(xmin),
    _max(xmax) {
    LOKI_STATIC_CHECK(N == 1, DimensionMustBe1);
  }
    
  Interval(const Number xmin, const Number ymin, 
           const Number xmax, const Number ymax) :
    _min(xmin, ymin),
    _max(xmax, ymax) {
    LOKI_STATIC_CHECK(N == 2, DimensionMustBe2);
  }
    
  Interval(const Number xmin, const Number ymin, const Number zmin,
           const Number xmax, const Number ymax, const Number zmax) :
    _min(xmin, ymin, zmin),
    _max(xmax, ymax, zmax) {
    LOKI_STATIC_CHECK(N == 3, DimensionMustBe3);
  }
    

  Interval(const Number* coordinates) :
    _min(coordinates),
    _max(coordinates + N)
  {}
    
  Interval(const Interval& other) :
    _min(other._min),
    _max(other._max)
  {}

  Interval& 
  operator=(const Interval& other);

  void 
  add(const Point& p);

  ~Interval()
  {}

  // @}
  //--------------------------------------------------------------------------
  // @{

  void 
  add(const Interval& x);

  template<class InputIterator>
  void 
  bound(InputIterator first, InputIterator last);

  void 
  bound(const Point& p);

  void 
  bound(const Point& p, const Point& q);

  void 
  bound(const Point& p, const Point& q, const Point& r);

  // @}
  //--------------------------------------------------------------------------
  // @{
    
  const Point& 
  getLowerCorner() const { 
    return _min; 
  }

  const Point& 
  getUpperCorner() const { 
    return _max; 
  }

  Number
  computeContent() const {
    Number x = 1;
    for (int n = 0; n != N; ++n) {
      x *= _max[n] - _min[n];
    }
    return x;
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  void
  setLowerCorner(const Point& lowerCorner) { 
    _min = lowerCorner; 
  }

  void
  setUpperCorner(const Point& upperCorner) { 
    _max = upperCorner; 
  }

  void
  setCorners(const Point& lowerCorner, const Point& upperCorner) { 
    _min = lowerCorner; 
    _max = upperCorner; 
  }

  void
  setLowerCoordinate(const int index, const Number value) { 
    _min[index] = value; 
  }

  void
  setUpperCoordinate(const int index, const Number value) { 
    _max[index] = value; 
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  static
  int 
  getDimension() { 
    return N; 
  }

  // @}
};


//
// File I/O.
//

  

template<int N, typename T>
void
printFormatted(std::ostream& out, const Interval<N,T>& x);



template<int N, typename T>
inline
std::istream& 
operator>>(std::istream& in, Interval<N,T>& x) {
  typename Interval<N,T>::Point point;
  in >> point;
  x.setLowerCorner(point);
  in >> point;
  x.setUpperCorner(point);
  return in;
}



template<int N, typename T>
inline
std::ostream& 
operator<<(std::ostream& out, const Interval<N,T>& x) {
  return out << x.getLowerCorner() << " " << x.getUpperCorner();
}


//
// Equality Operators.
//

  

template<int N, typename T>
inline
bool 
operator==(const Interval<N,T>& a, const Interval<N,T>& b) {
  return (a.getLowerCorner() == b.getLowerCorner() && 
          a.getUpperCorner() == b.getUpperCorner());
}



template<int N, typename T>
inline
bool 
operator!=(const Interval<N,T>& a, const Interval<N,T>& b) {
  return !(a == b);
}


//
// Mathematical Functions.
//



template<int N, typename T>
bool 
doOverlap(const Interval<N,T>& a, const Interval<N,T>& b);



template<int N, typename T>
Interval<N,T>
computeIntersection(const Interval<N,T>& a, const Interval<N,T>& b);



template<int N, typename T>
void
computeIntersection(const Interval<N,T>& a, const Interval<N,T>& b,
                    Interval<N,T>* x);


END_NAMESPACE_GEOM

#define __geom_Interval_ipp__
#include "Interval.ipp"
#undef __geom_Interval_ipp__

#endif

---