Biomechanical Joint Model  Author: Anderson Maciel

---

bbox.h

Go to the documentation of this file.

/*@#---------------------------------------------------------------------------
 PROJECT            : PHD THESIS
 MODULE             : PHYSICALLY-BASED DEFORMATION

 FILE               : bbox.h
 CREATION DATE      : Thu Dec  2 13:49:39 MET 1999
 CREATION AUTHOR(S) : aubel 
 ------------------------------------------------------------------------------
 KEYWORD(S)         : bounding box
 DEFINED TYPE(S)    : 
 RELATED TYPE(S)    : 

 FUNCTIONALITY      : Bounding Box class to avoid relying on Inventor's bboxes
 ------------------------------------------------------------------------------
 LANGAGE            : Ansi C++
 SYSTEM             : UNIX V 6.x / SGI
 GRAPHIC LIBRARY    : SGI  
 ------------------------------------------------------------------------------
 PROJECT DIRECTOR   : D. THALMANN
 LAB                : EPFL- LIG
 --------------------------------------------------------------------------#@*/
#ifndef BBOX_H
#define BBOX_H

#include <LinAlg/linalg.h>
#include "ray.h"
#include <vector>

//using namespace std;

// a bounding box class that works both in 2D and in 3D (default=3D, see ctor)
class BBox 
{
public:
   BBox(int ndim = dimspace) : n_(ndim), LL(ndim), UR(ndim) , empty(true) { assert(n_<4); };
   BBox(const BBox &bb) : LL(bb.LL), UR(bb.UR), n_(bb.n_), empty(bb.empty) { assert(n_<4);};

   BBox(const VEC &LowerLeft, const VEC &UpperRight): LL(LowerLeft), UR(UpperRight), 
      n_(LowerLeft.dim()), empty( VEC(UR-LL).norm2() < epsilon ) {};

   void extendBy(const VEC &X);
   void extendBy(const VECArray &X) { for (int i=0; i<X.size(); i++) extendBy(X[i]); };
   void extendBy(const BBox &bb);

   VEC getMin() const { return LL; };
   VEC getMax() const { return UR; };
   VEC getDim() const { return (UR - LL); };
   VEC getCenter() const { return 0.5*(LL+UR); };

   void makeEmpty() { empty=true; };
   bool isEmpty() const { return empty; };

   void scale(REAL factor);
   bool contains(const VEC &X) const { return (X >= LL && X <= UR); };
   bool strictlyContains(const VEC &X) const { return (X > LL && X < UR); };

   bool intersectedBy(const BBox &bb) const;
   bool intersectedBy(Ray &ray) const;
   bool intersectedBy(const VEC &V0, const VEC &V1, const VEC &V2) const;

private:
   VEC LL, UR;
   int n_;
   bool empty;
};

class BBoxHierarchy
{   
public:
   BBoxHierarchy(const BBox &bbox, int recursion_level=0) : 
      bb(bbox), bboxlist(), triangles(), level(recursion_level) {};

   BBoxHierarchy(const VEC &LL, const VEC &UR, int recursion_level=0) : 
      bb(LL, UR), bboxlist(), triangles(), level(recursion_level) {};

   BBoxHierarchy(const BBoxHierarchy &bb_h) : 
      bb(bb_h.bb), bboxlist(bb_h.bboxlist), triangles(bb_h.triangles), level(bb_h.level) {};

   ~BBoxHierarchy();

   // tris = list of triangles (ONLY!) with no separator between 2 consecutive triangles
   void createHierarchy(const VECArray &coords, const vector<int> &tris, int num_tris_max,
                        int level=0);

   // return list (without duplicates) of triangles that might be hit by ray
   // trilist = indices (premultiplied by 3 = # vertices) into the triangles list 
   void getPotentialTriangles(Ray &ray, vector<int> &trilist) const;

   // read-only
   const BBox& getBBox() const { return bb; };
   int getNumTriangles() const { return triangles.size(); };
   const vector<int> &getTriangles() const { return triangles; };

   // return lowest-level  bounding box that contains X and at least m triangles
   // return NULL if it doesn't exist
   const BBoxHierarchy* getSmallestBBox(const VEC &X, int m=1) const; 
private:
   BBox bb;
   vector<BBoxHierarchy*> bboxlist;
   vector<int> triangles;  // list of indices of triangles
   int level;
};

#endif

---