u3d_box.hpp

/* u3d_box.hpp */
/* $Id: u3d_box.hpp,v 1.13 2008/03/31 07:58:19 guser1 Exp $ */
#ifndef __u3d_box_hpp
#define __u3d_box_hpp

#include "u3d_point.hpp"
#include "u3d_triangle.hpp"


class U3dPoint;

enum U3D_BOX_STATE  {
  INVALID = 0, 
  ACCEPTABLE
};

enum BOX_TRI_INT  {
  NO_INTERSECT,
  INTERSECT, 
  INSIDE
};

class U3dBox
{
public:
  
  U3dBox();
  
  U3dBox (double x_size, double y_size, double z_size);
  
  U3dBox (const U3dPoint& p1, const U3dPoint& p2);
  
  U3dBox (const U3dPoint& p, double x_size, double y_size, double z_size);
  
  U3dBox (const U3dBox& box);
  
  U3D_BOX_STATE validate(double xmin,
             double xmax,
             double ymin,
             double ymax,
             double zmin,
             double zmax) const;
    
  bool checkOverlay(const U3dBox& box) const;
  
  BOX_TRI_INT intersectWithTriangle(const U3dTriangle& triangle, const U3dPoint& p1, 
                    const U3dPoint& p2, const U3dPoint& p3);
  
  bool intersectWithSegment(U3dPoint pA, U3dPoint pB);
  
  /* Returns array of intersection points of triangle with box */
  //int getIntersectWithTriangle(U3dPoint p1, U3dPoint p2, U3dPoint p3, U3dVertexAr* isectAr);
    
  bool  checkInside (const U3dPoint& p) const;
  bool  checkDefinitelyInside (const U3dPoint& p) const;
  bool  checkInsideEps (const U3dPoint& p) const;
  
  
  double        getXMin () const;
    
  double    getXMax () const;
  
  double    getYMin () const;
  
  double    getYMax () const;
  
  double    getZMin () const;
  
  double    getZMax () const;
  
  void setCoords(const double& xmin,
         const double& xmax,
         const double& ymin,
         const double& ymax,
         const double& zmin,
         const double& zmax);
    
  int   setXMin (double);
  
  int   setXMax (double);
  
  int   setYMin (double);
  
  int   setYMax (double);
  
  int   setZMin (double);
  
  int   setZMax (double);
  
  double    getXSize () const;
  
  double    getYSize () const;
  
  double    getZSize () const;
  
  double        getDiag() const;
  
  U3dPoint getCenter();
  
  U3dPoint getInitPoint();
  
  U3dPoint getLimitPoint();
  
  /* Get coordinates of center of  the box */   
  //U3dVertex getCenter();
  
  int operator== (const U3dBox& rbox) const;
  
  int operator!= (const U3dBox& rbox) const {return !operator==(rbox); };
   
protected:

    double  fXRange[2];
    
    double  fYRange[2];
    
    double  fZRange[2];
    
private:
  int triBoxOverlap(U3dPoint boxcenter, double boxhalfsize[3], U3dPoint triverts[3]);
  int planeBoxOverlap(U3dPoint normal,double d, double maxbox[3]);
};

/* INLINE implementation */

inline double
U3dBox::getXMin () const
{
  return fXRange[0];
}

inline double
U3dBox::getXMax () const
{
  return fXRange[1];
}

inline double
U3dBox::getYMin () const
{
  return fYRange[0];
}

inline double
U3dBox::getYMax () const
{
  return fYRange[1];
}

inline double
U3dBox::getZMin () const
{
  return fZRange[0];
}

inline double
U3dBox::getZMax () const
{
  return fZRange[1];
}

inline  void 
U3dBox::setCoords(const double& xmin,
                                    const double& xmax,
                                    const double& ymin,
                                    const double& ymax,
                                    const double& zmin,
                                    const double& zmax)
{
    fXRange[0] = xmin;
    fXRange[1] = xmax;
    fYRange[0] = ymin;
    fYRange[1] = ymax;
    fZRange[0] = zmin;
    fZRange[1] = zmax;
}

inline int  U3dBox::setXMin (double xMin)
{                         
    if (xMin >= fXRange[1])
        return false;
    fXRange[0] = xMin;
    return true;
}
    
inline int  U3dBox::setXMax (double xMax)
{
    if (xMax <= fXRange[0])
        return false;
    fXRange[1] = xMax;
    return true;
}
    
inline int  U3dBox::setYMin (double yMin)
{
    if (yMin >= fYRange[1])
        return false;
    fYRange[0] = yMin;
    return true;
}
    
inline int  U3dBox::setYMax (double yMax)
{
    if (yMax <= fYRange[0])
        return false;
    fYRange[1] = yMax;
    return true;
}
        
inline int  U3dBox::setZMin (double zMin)
{
    if (zMin >= fZRange[1])
        return false;
    fZRange[0] = zMin;
    return true;
}
    
inline int  U3dBox::setZMax (double zMax)
{
    if (zMax <= fZRange[0])
        return false;
    fZRange[1] = zMax;
    return true;
}
    

inline double
U3dBox::getXSize () const
{
  return fXRange[1] - fXRange[0];
}

inline double
U3dBox::getYSize () const
{
  return fYRange[1] - fYRange[0];
}

inline double
U3dBox::getZSize () const
{
  return fZRange[1] - fZRange[0];
}


U3dBox combineBox(U3dBox box1, U3dBox box2);

#endif /* u3d_box.hpp */