---

boundingbox.h

Go to the documentation of this file.

#ifndef __BOUNDINGBOX_H__
#define __BOUNDINGBOX_H__

#include <iostream>
#include "aarectangle.h"
#include "genericalgs.h"


namespace Boundary {

  
template<class T=double, class Boolean=bool, class Float=double>
class BoundingBox {
  typedef BoundingBox<T,Boolean,Float> self;
  typedef BoundingBox<T,Boolean,Float> base;

public:
  typedef AARectangle<T,Boolean,Float> Rectangle;
  typedef T value_type;
  
  virtual Boolean inside(T x, T y) const =0;

  virtual base& scale(T xscale, T yscale) =0;

  virtual base& rotate(Float angle) =0;

  virtual base& translate(T xoffset, T yoffset) =0;

  virtual Rectangle aarectangle() const =0;
  
  virtual base* clone() const=0;

  virtual std::ostream& put(std::ostream &s) const {  return s;  };
};



template<class T,class Boolean,class Float>
std::ostream& operator<<(std::ostream &s, const BoundingBox<T,Boolean,Float>& b) {  return b.put(s);  }



template<class T=int,class Boolean=bool,class Float=double,
         class BoxType=AAArbitraryRectangle<T,Boolean,Float> >
class AARBoundingBox : public BoundingBox<T,Boolean,Float> {
private:
  typedef AARBoundingBox<T,Boolean,Float,BoxType> self;
  typedef BoundingBox<T,Boolean,Float> base;

public:
  AARBoundingBox() { }

  AARBoundingBox(T xlow, T ylow, T xhigh, T yhigh )
    : box(xlow,ylow,xhigh,yhigh) { }

  AARBoundingBox(T centerx, T centery, T radius )
    : box(centerx-radius,centery-radius,centerx+radius,centery+radius) { }
  
  virtual Boolean inside(T x, T y) const {  return box.inside(x,y);  }

  virtual self& set() {  box.set(); return *this;  }

  virtual self& set(T xlow, T ylow, T xhigh, T yhigh) 
    {  box=BoxType(xlow,ylow,xhigh,yhigh); return *this;  }

  virtual self& operator+=( const self& b )
    {  box += b.box;  return *this;  }
  
  virtual base& scale( T xscale, T yscale )
    {  box.scale(xscale,yscale);  return *this;  }
  
  virtual base& rotate( Float theta ) {  box.rotate(theta);  return *this;  }

  virtual base& translate( T xoffset, T yoffset )
    {  box.translate(xoffset,yoffset);  return *this;  }

  virtual typename base::Rectangle aarectangle() const
    {  return (box.isinfinite()? typename base::Rectangle() : box.aarectangle());  }
  
  virtual base* clone() const {  return new self(*this); };

  virtual std::ostream& put(std::ostream &s) const
    {  return box.put(s); }

  virtual Boolean empty() const
    {  return box.empty(); }

protected:  
  BoxType box;
};



template<class T=int,class Boolean=bool,class Float=double,
         class BoxType=AAArbitraryRectangle<T,Boolean,Float> >
class BoundingEllipse : public AARBoundingBox<T,Boolean,Float,BoxType> {
  typedef BoundingBox<T,Boolean,Float> base;
  typedef BoundingEllipse<T,Boolean,Float,BoxType> self;
  typedef AARBoundingBox<T,Boolean,Float> aarbase;
  
public:
  BoundingEllipse() : aarbase(), trimx(0), trimy(0) { }
  
  BoundingEllipse(T centerx, T centery, T radius, Float trim=0 )
    : aarbase(centerx-radius,centery-radius,centerx+radius,centery+radius),
    trimx(trim), trimy(trim) { }

  BoundingEllipse(T centerx, T centery, T radiusx, T radiusy, Float trimx_i=0, Float trimy_i=0)
    : aarbase(centerx-radiusx,centery-radiusy,centerx+radiusx,centery+radiusy),
    trimx(trimx_i), trimy(trimy_i) { }
  
  virtual Boolean inside(T x, T y) const {
    if (box.isinfinite()) return true;
    
    /* These could be cached */
    const Float radiusx         = (box.width())/2.0+trimx;
    const Float radiusy         = (box.height())/2.0+trimy;
    const Float div_radiusx_sq  = 1/(radiusx*radiusx);
    const Float div_radiusy_sq  = 1/(radiusy*radiusy);
    const T centerx             = box.corners().xl+T(radiusx);
    const T centery             = box.corners().yl+T(radiusy);
    
    const T xdistance           = x-centerx;
    const T ydistance           = y-centery;
    const T xdistance_sq        = xdistance*xdistance;
    const T ydistance_sq        = ydistance*ydistance;

    return (xdistance_sq*div_radiusx_sq + ydistance_sq*div_radiusy_sq < 1);
  }


  virtual base& rotate( Float theta ) {
    (void)theta;
    /* This routine should be straightforward to implement, since it would
       just need to rotate each corner about the center.   However, it would
       be tedious to do, and the inside() routine would need to be modified
       to match.  So it is left undone since this routine is not
       currently needed.
    */
    abort();
    return *this;
  }

  virtual base* clone() const {  return new self(*this); }

private:
  Float trimx,trimy;
};


template<class T=int,class Boolean=bool,class Float=double,
         class BBA=BoundingEllipse<T,Boolean,Float>,
         class BBB=AARBoundingBox<T,Boolean,Float> >
class Intersection : public BoundingBox<T,Boolean,Float> {
  typedef BoundingBox<T,Boolean,Float> base;
  typedef Intersection<T,Boolean,Float,BBA,BBB> self;
  typedef AARBoundingBox<T,Boolean,Float> aarbase;
  
public:
  Intersection(const BBA& bb_a=BBA(), const BBB& bb_b=BBB())
    : a(bb_a), b(bb_b) { }
  
  virtual Boolean inside(T x, T y) const 
    {  return (a.inside(x,y) && b.inside(x,y));  }

  virtual base& scale(T xscale, T yscale)
    {  a.scale(xscale,yscale); b.scale(xscale,yscale);  return *this;  }

  virtual base& rotate(Float angle)
    {  a.rotate(angle); b.rotate(angle);  return *this;  }

  virtual base& translate(T xoffset, T yoffset)
    {  a.translate(xoffset,yoffset); b.translate(xoffset,yoffset);  return *this;  }
  
  virtual typename base::Rectangle aarectangle() const {  return a.aarectangle().intersection(b.aarectangle());  }

  virtual base* clone() const {  return new self(*this); };

  virtual std::ostream& put(std::ostream &s) const
    {  s<<"(";  a.put(s);  s<<" && ";  b.put(s);  s<<")";  return s;  };
  
private:
  BBA a;
  BBB b;
};



template<class T=int,class Boolean=bool,class Float=double>
class BoundingCircle : public BoundingBox<T,Boolean,Float> {
private:
  typedef BoundingCircle<T,Boolean,Float> self;
  typedef BoundingBox<T,Boolean,Float> base;

public:
  BoundingCircle(): infinite(true) { }

  BoundingCircle(T centerx_, T centery_, Float radius_ )
    : infinite(false), centerx(centerx_), centery(centery_), radius(radius_)
    {  freshencache();  }

  inline Boolean isinfinite() const {  return infinite;  }
  
  virtual Boolean inside(T x, T y) const {
    if (isinfinite()) return true;
    
    const T xdistance           = x-centerx;
    const T ydistance           = y-centery;
    const T xdistance_sq        = xdistance*xdistance;
    const T ydistance_sq        = ydistance*ydistance;

    return (xdistance_sq + ydistance_sq <= radius_sq);
  }

  virtual base& scale( T xscale, T yscale )
    {  radius*=xscale; (void)yscale; assert(xscale==yscale);  freshencache();  return *this;  }
  
  virtual base& rotate( Float ) {  return *this;  }

  virtual base& translate( T xoffset, T yoffset )
    {  centerx+=xoffset;  centery+=yoffset;  freshencache();  return *this;  }

  virtual typename base::Rectangle aarectangle() const {
    return (isinfinite()?
            typename base::Rectangle() :
            typename base::Rectangle(T(centerx)-T(radius),T(centery)-T(radius),
                                     T(centerx)+T(radius),T(centery)+T(radius)));
  }
  
  virtual base* clone() const {  return new self(*this); };

  virtual std::ostream& put(std::ostream &s) const
    {  return (s << "((" << centerx << "," << centery << ") radius " << radius << ")");  }

private:
  Boolean infinite;

  T centerx;
  T centery;
  Float radius;

  /* \name Cached values computed from radius,radiusy and centerx,centery */
  Float radius_sq;
  void freshencache() {  radius_sq = radius*radius;  }
};




} /* namespace Boundary */

// For temporary backwards compatibility
using namespace Boundary;

#endif /* __BOUNDINGBOX_H__ */

---