BBox.H

Go to the documentation of this file.

#ifndef BBOX_H
#define BBOX_H

// Gluebase includes
#define OUTSIDE_GLUE_CORE
#include <mlib/points.H>

#include "glwrap.H"

#include <math.h>


class BBox
{
 public:

  BBox() {
    _empty = 1;
    _minPt = Wpt(0,0,0);
    _maxPt = Wpt(0,0,0);
  };

  BBox(const BBox& bb){
    _empty=bb._empty;
    _minPt=bb._minPt;
    _maxPt=bb._maxPt;
  } 

  BBox(BBox* bb){
    _empty=bb->_empty;
    _minPt=bb->_minPt;
    _maxPt=bb->_maxPt;
  }

  virtual ~BBox() {};

  inline void addPt(const Wpt p) {
    if (_empty) {
      _minPt = p;
      _maxPt = p;
    }
    else {
      // min
      if (p[0] < _minPt[0]) _minPt[0] = p[0];
      if (p[1] < _minPt[1]) _minPt[1] = p[1];
      if (p[2] < _minPt[2]) _minPt[2] = p[2];
      // max
      if (p[0] > _maxPt[0]) _maxPt[0] = p[0];
      if (p[1] > _maxPt[1]) _maxPt[1] = p[1];
      if (p[2] > _maxPt[2]) _maxPt[2] = p[2];
    }
    _empty = 0;
  }

  inline void addBBox(const BBox b2) {
    if (_empty) {
      _minPt = b2.minPt();
      _maxPt = b2.maxPt();
    }
    else {
      // min
      if (b2.minPt()[0] < _minPt[0]) _minPt[0] = b2.minPt()[0];
      if (b2.minPt()[1] < _minPt[1]) _minPt[1] = b2.minPt()[1];
      if (b2.minPt()[2] < _minPt[2]) _minPt[2] = b2.minPt()[2];
      // max
      if (b2.maxPt()[0] > _maxPt[0]) _maxPt[0] = b2.maxPt()[0];
      if (b2.maxPt()[1] > _maxPt[1]) _maxPt[1] = b2.maxPt()[1];
      if (b2.maxPt()[2] > _maxPt[2]) _maxPt[2] = b2.maxPt()[2];
    }
    _empty = 0;
  }
  
  inline void addBBox(BBox* const b2) {
    if (_empty) {
      _minPt = b2->minPt();
      _maxPt = b2->maxPt();
    }
    else {
      // min
      if (b2->minPt()[0] < _minPt[0]) _minPt[0] = b2->minPt()[0];
      if (b2->minPt()[1] < _minPt[1]) _minPt[1] = b2->minPt()[1];
      if (b2->minPt()[2] < _minPt[2]) _minPt[2] = b2->minPt()[2];
      // max
      if (b2->maxPt()[0] > _maxPt[0]) _maxPt[0] = b2->maxPt()[0];
      if (b2->maxPt()[1] > _maxPt[1]) _maxPt[1] = b2->maxPt()[1];
      if (b2->maxPt()[2] > _maxPt[2]) _maxPt[2] = b2->maxPt()[2];
    }
    _empty = 0;
  }
  void reset() {
    _minPt = Wpt(0,0,0);
    _maxPt = Wpt(0,0,0);
    _empty = 1;
  }


  Wpt minPt()  const  { return _minPt; }
  Wpt maxPt()  const  { return _maxPt; }
  Wpt center() const  { return Wpt((_minPt[0] + _maxPt[0]) / 2.0,
                   (_minPt[1] + _maxPt[1]) / 2.0,
                   (_minPt[2] + _maxPt[2]) / 2.0); }
  double volume() {
    double x = fabs(_maxPt[0] - _minPt[0]);
    double y = fabs(_maxPt[1] - _minPt[1]);
    double z = fabs(_maxPt[2] - _minPt[2]);
    // if the box lies in a plane, return the area rather than the volume
    if (x==0.0) x=1.0;
    if (y==0.0) y=1.0;
    if (z==0.0) z=1.0;
    return x*y*z;
  }

  double volume(const Wtransf m) {
    Wpt max = m * _maxPt;
    Wpt min = m * _minPt;

    double x = fabs(max[0] - min[0]);
    double y = fabs(max[1] - min[1]);
    double z = fabs(max[2] - min[2]);
    // if the box lies in a plane, return the area rather than the volume
    if (x==0.0) x=1.0;
    if (y==0.0) y=1.0;
    if (z==0.0) z=1.0;
    return x*y*z;
  }


  int contains(const Wpt pt) {
    if (_empty) 
      return 0;
    return !(pt[0] < _minPt[0] || pt[1] < _minPt[1] || pt[2] < _minPt[2] ||
         pt[0] > _maxPt[0] || pt[1] > _maxPt[1] || pt[2] > _maxPt[2]); 
  }


  int contains(const Wpt pt, const Wtransf xform) {
    if (_empty) 
      return 0;
    Wpt min = xform*_minPt;
    Wpt max = xform*_maxPt;

    double tmp;
    if (max[0] < min[0]) { tmp = min[0]; min[0] = max[0]; max[0] = tmp; }
    if (max[1] < min[1]) { tmp = min[1]; min[1] = max[1]; max[1] = tmp; }
    if (max[2] < min[2]) { tmp = min[2]; min[2] = max[2]; max[2] = tmp; }

    return !(pt[0] < min[0] || pt[1] < min[1] || pt[2] < min[2] ||
         pt[0] > max[0] || pt[1] > max[1] || pt[2] > max[2]); 
  }


  void transformBox(const Wtransf transform){
    Wpt tmpmin=transform*_minPt;
    Wpt tmpmax=transform*_maxPt;
    
    reset();
    addPt(tmpmin);
    addPt(tmpmax);
  }

  // drawing routines..

  void drawBox (const GLfloat x1,const GLfloat y1,const GLfloat z1, 
        const GLfloat x2,const GLfloat y2,const GLfloat z2) {
    glColor3f (1.0, 1.0, 1.0);
    glBegin (GL_LINE_LOOP);
    glVertex3f (x1, y1, z1);
    glVertex3f (x2, y1, z1);
    glVertex3f (x2, y2, z1);
    glVertex3f (x1, y2, z1);
    glEnd ();
    
    glBegin (GL_LINE_LOOP);
    glVertex3f (x1, y1, z2);
    glVertex3f (x2, y1, z2);
    glVertex3f (x2, y2, z2);
    glVertex3f (x1, y2, z2);
    glEnd ();
    
    glBegin (GL_LINES);  /*  4 lines     */
    glVertex3f (x1, y1, z1);
    glVertex3f (x1, y1, z2);
    glVertex3f (x1, y2, z1);
    glVertex3f (x1, y2, z2);
    glVertex3f (x2, y1, z1);
    glVertex3f (x2, y1, z2);
    glVertex3f (x2, y2, z1);
    glVertex3f (x2, y2, z2);
    glEnd ();
  }
  

  void draw() {
    glPushAttrib(GL_ALL_ATTRIB_BITS);

    glDisable(GL_LIGHTING);
    glDisable(GL_COLOR_MATERIAL);
    glDisable(GL_BLEND);
    
    drawBox(_minPt[0],_minPt[1],_minPt[2],
        _maxPt[0],_maxPt[1],_maxPt[2]);

    glPopAttrib();
  }

  void print(){
    cout << "BBOX:MinPt is " << _minPt << endl 
     << "BBOX:MaxPt is " << _maxPt << endl; 
  }
  
 protected:

  Wpt _minPt;
  Wpt _maxPt;
  int _empty;

};


#endif

---