Box.h

Go to the documentation of this file.

/** Routines for handling vectors of intervals.
 * @file Box.h 
 * @author John Hart
 * @author Terry Fleury
 * @date 3 July 2001
 */

#ifndef BOX_H
#define BOX_H

#include "Interval.h"
#include "RandomStream.h"

/** 
 * @class Box 
 * An interval vector class.
 * A box is an axis aligned region of space represented by a vector of
 * intervals.  A generalized Box can be of any dimension.  Specialized
 * classes exist for 3D and 4D regions.
 */
template <class Float>
class Box : public TNT::Vector< Interval<Float> > // Note space between >'s
{
  private:
    RandomStream rs;   ///< A stream of random numbers

  public:
    /// Constructors
    Box();
    Box(int n);
    Box(int n, Float x);
    Box(TNT::Vector<Float> x);

    /// Math operators
    Box<Float>& operator *=(const Interval<Float> &c);
    Box<Float>& operator /=(const Interval<Float> &c);
    Box<Float>& operator +=(const Interval<Float> &c);

    /// Size operators
    Float width(int &dim);  ///< Also returns which side was longest
    Float width();
    Interval<Float> length();
    Interval<Float> lengthSquared();
    Box<Float> normalize();

    /// Parts of Boxes
    Box<Float> unionWith(Box<Float> &b);
    void subdivide(Box<Float> &IX1, Box<Float> &IX2);
    TNT::Vector<Float> center();

    /// Basic output
    void print();
};  // End of class definition




/// Explicit instantiation of Box<double>
template class Box<double>;

/// Multiply a box and an interval.
template <class Float>
Box<Float> operator *(const Box<Float> &x, const Interval<Float> &y)
{
  Box<Float> z = x;
  return (z *= y);
}

/// Multiply an interval and a box.
template <class Float>
Box<Float> operator *(const Interval<Float> &x, const Box<Float> &y)
{
  Box<Float> z = y;
  return (z *= x);
}

/// Divide a box and an interval.
template <class Float>
Box<Float> operator /(const Box<Float> &x, const Interval<Float> &y)
{
  Box<Float> z = x;
  return (z /= y);
}

/// Add a box and an interval.
template <class Float>
Box<Float> operator +(const Box<Float> &x, const Interval<Float> &y)
{
  Box<Float> z = x;
  return (z += y);
}

/// Add an interval and a box.
template <class Float>
Box<Float> operator +(const Interval<Float> &x, const Box<Float> &y)
{
  Box<Float> z = y;
  return (z += x);
}

/// 'Dot' product of two boxes - loose definition of dot product here.
template <class Float>
Interval<Float> dot(const Box<Float> &x, const Box<Float> &y)
{
  Interval<Float> sum = 0.0;
  for (int i = 0; i < x.size(); i++)
    sum += x[i] * y[i];

  return sum;
}

/// Standard output stream to print out the coords of the box.
template<class Float>
std::ostream& operator<<(std::ostream& os, const Box<Float>& x)
{
  os << "[ ";
  for (int i = 0; i < x.size(); i++)
    {
      os << x[i];
      if (i < (x.size()-1))
        os << ", ";
    }
  return os << " ]";
}




/**
 * This is the 3D / double specific version of a Box.  Use this most often
 * so you don't have to declare the size of your Boxes all the time.
 */
class Box3d : public Box<double>
{
  public:
    /// Constructors
    Box3d();
    Box3d(TNT::Vector< Interval<double> > A);
    Box3d(gmVector3 mincorner, gmVector3 maxcorner);
    Box3d(gmVector3 x);
    Box3d(Interval<double> x, Interval<double> y, Interval<double> z);
    Box3d(Interval<double> v);
    Box3d(double d);
    Box3d(Box<double> x);

    /// 'Corner' operators
    gmVector3 low();
    gmVector3 high();
};




/**
 * This is the 4D / double specific version of a Box.  Use this when you
 * need a 4D box (ie, x,y,z,t) for finding 4D critical points (through time).
 */
class Box4d : public Box<double>
{
  public:
    /// Constructors
    Box4d();
    Box4d(TNT::Vector< Interval<double> >);
    Box4d(gmVector4 mincorner, gmVector4 maxcorner);
    Box4d(gmVector4 x);
    Box4d(Interval<double>,Interval<double>,Interval<double>,Interval<double>);
    Box4d(Interval<double>);
    Box4d(double d);
    Box4d(Box<double>);
   
    /// 'Corner' operators
    gmVector4 low();
    gmVector4 high();
};

#endif

---