---

aarectangle.h

Go to the documentation of this file.

#ifndef __AARECTANGLE_H__
#define __AARECTANGLE_H__

#include <iostream>
#include <algorithm>

#include "genericalgs.h"

namespace Boundary {
  
using std::min;
using std::max;


template<class T=int>
struct TwoOrderedPoints {
  T xl,yl,xh,yh;
  
  inline TwoOrderedPoints(const T& xlow=0, const T& ylow=0, 
                          const T& xhigh=0,const T& yhigh=0)
    : xl(xlow), yl(ylow), xh(xhigh), yh(yhigh)  {  }
};



template<class T=int,class Boolean=bool,class Float=double>
struct AARectangle {
private:
  typedef AARectangle<T,Boolean,Float> self;
  typedef TwoOrderedPoints<T> Points;
  
public:
  typedef T value_type;
  
  inline AARectangle(const T& xlow=0, const T& ylow=0, 
                     const T& xhigh=0,const T& yhigh=0)
    : p(xlow,ylow,xhigh,yhigh)  {  }
  
  inline Boolean inside(T x, T y) const
    {  return (x>=p.xl && y>=p.yl && x<=p.xh && y<=p.yh);  }
  
  inline Boolean upperexclusive_inside(T x, T y) const
    {  return (x>=p.xl && y>=p.yl && x<p.xh && y<p.yh);  }
  
  inline self& operator+=( const self& o ) {
    if (empty()) { p=o.p; }
    else         { p.xl=min(p.xl,o.p.xl); p.yl=min(p.yl,o.p.yl); p.xh=max(p.xh,o.p.xh); p.yh=max(p.yh,o.p.yh); }
    return *this;
  }
  
  inline self& scale( T xscale, T yscale ) {
    p.xl=p.xl*xscale; p.yl=p.yl*yscale; p.xh=p.xh*xscale; p.yh=p.yh*yscale;
    return *this;
  }
  
  self& rotate( Float theta ) {
    const Float cosmt  = cos(-theta);
    const Float sinmt  = sin(-theta);
    
    const T xlc = T(p.xl*cosmt);  const T xls = T(p.xl*sinmt);
    const T xhc = T(p.xh*cosmt);  const T xhs = T(p.xh*sinmt);
    const T ylc = T(p.yl*cosmt);  const T yls = T(p.yl*sinmt);
    const T yhc = T(p.yh*cosmt);  const T yhs = T(p.yh*sinmt);
    
    p.xl = min(min(min(xlc-yls,xlc-yhs),xhc-yls),xhc-yhs);
    p.xh = max(max(max(xlc-yls,xlc-yhs),xhc-yls),xhc-yhs);

    p.yl = min(min(min(xls+ylc,xls+yhc),xhs+ylc),xhs+yhc);
    p.yh = max(max(max(xls+ylc,xls+yhc),xhs+ylc),xhs+yhc);
    
    return *this;
  }
  
  inline self& translate( T xoffset, T yoffset ) {
    p.xl+=xoffset; p.yl+=yoffset; p.xh+=xoffset; p.yh+=yoffset;
    return *this;
  }
  
  inline self& set(T xlow, T ylow, T xhigh, T yhigh ) {
    p.xl=xlow; p.yl=ylow; p.xh=xhigh; p.yh=yhigh;
    return *this;
  }

  inline self& set (const Points& o) {  p=o;  }

  /* Returns a rectangle that is the intersection of the given box with this one */
  inline self intersection(const self& o) {
    return self(Generic::crop(o.p.xl,o.p.xh,p.xl),
                Generic::crop(o.p.yl,o.p.yh,p.yl),
                Generic::crop(o.p.xl,o.p.xh,p.xh),
                Generic::crop(o.p.yl,o.p.yh,p.yh));
  }
  
  inline T height() const {  return (std::abs(p.yh-p.yl));  }

  inline T width()  const {  return (std::abs(p.xh-p.xl));  }
  
  inline Points corners()  const {  return p;  }
  
  inline Boolean empty() const {  return (height()==0 || width()==0); }

  inline std::ostream& put(std::ostream &s) const
    {  return (s << "((" << p.xl << "," << p.yl << ") (" << p.xh << "," << p.yh << "))"); }

private:
  Points p;
};
  
  
  
template<class T=int,class Boolean=bool,class Float=double>
class AAArbitraryRectangle {
private:
  typedef AAArbitraryRectangle<T,Boolean,Float> self;
  typedef AARectangle<T,Boolean,Float> PlainRect;
  typedef TwoOrderedPoints<T> Points;
  
public:
  typedef T value_type;

  inline AAArbitraryRectangle() : infinite(true) { }
  
  inline AAArbitraryRectangle(T xlow, T ylow, T xhigh, T yhigh )
    : infinite(false), rect(xlow,ylow,xhigh,yhigh) { }
  
  inline Boolean isinfinite() const {  return infinite;  }
  
  inline Boolean inside(T x, T y) const
    {  return (infinite || rect.inside(x,y));  }
  
  inline Boolean upperexclusive_inside(T x, T y) const
    {  return (infinite || rect.upperexclusive_inside(x,y));  }
  
  inline self& set() {  infinite=true; return *this;  }

  inline self& set(T xlow, T ylow, T xhigh, T yhigh)
    {  infinite=false; rect.set(xlow,ylow,xhigh,yhigh); return *this;  }
  
  inline self& operator+=( const self& b ) {
    if (infinite || b.infinite) infinite=true;
    else rect+=b.rect;
    return *this;
  }
  
  inline self& scale( T xscale, T yscale )
    {  if (!infinite) rect.scale(xscale,yscale);  return *this;  }
  
  inline self& rotate( Float theta ) 
    {  if (!infinite) rect.rotate(theta);  return *this;  }
  
  inline self& translate( T xoffset, T yoffset ) 
    {  if (!infinite) rect.translate(xoffset,yoffset);  return *this;  }
  
  inline std::ostream& put(std::ostream &s) const
    {  return (infinite? s << "(Infinite)" : rect.put(s)); }

  /* Returns a rectangle that is the intersection of the given box with this one */
  inline self& intersection(const self& o) {
    return (o.isinfinite()? *this : 
            (isinfinite()?  o     :
             self(rect.intersection(o.rect))));
  }
  
  inline T height() const {  return (infinite? 0 : rect.height()); }

  inline T width()  const {  return (infinite? 0 : rect.width());  }
  
  inline PlainRect aarectangle()  const {  return (infinite? PlainRect() : rect);  }
  
  inline Points corners()  const {  return rect.corners();  }
  
  inline Boolean empty() const
    {  return (!infinite && rect.empty()); }
  
private:
  Boolean infinite;
  PlainRect rect;
};


} /* namespace Boundary */ 
#endif /* __AARECTANGLE_H__ */

---