u3d_box.hpp

/* u3d_box.hpp */
/* $Id: u3d_box.hpp,v 1.3 2008/05/23 07:25:27 sasha 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    m_x_range[2];
  
  double    m_y_range[2];
  
  double    m_z_range[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 m_x_range[0];
}

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

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

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

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

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

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

inline int U3dBox::setXMin (double xMin)
{                         
  if (xMin >= m_x_range[1])
    return false;
  m_x_range[0] = xMin;
  return true;
}

inline int U3dBox::setXMax (double xMax)
{
  if (xMax <= m_x_range[0])
    return false;
  m_x_range[1] = xMax;
  return true;
}

inline int U3dBox::setYMin (double yMin)
{
  if (yMin >= m_y_range[1])
    return false;
  m_y_range[0] = yMin;
  return true;
}

inline int U3dBox::setYMax (double yMax)
{
  if (yMax <= m_y_range[0])
    return false;
  m_y_range[1] = yMax;
  return true;
}

inline int U3dBox::setZMin (double zMin)
{
  if (zMin >= m_z_range[1])
    return false;
  m_z_range[0] = zMin;
  return true;
}

inline int U3dBox::setZMax (double zMax)
{
  if (zMax <= m_z_range[0])
    return false;
  m_z_range[1] = zMax;
  return true;
}
    

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

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

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


U3dBox combineBox(U3dBox box1, U3dBox box2);

#endif /* u3d_box.hpp */