Common/Geom/BoundingBox.h

Go to the documentation of this file.

//-------------------------------------------------------------------
// Copyright (c) 2007 Celeritive Technologies, Inc.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//-------------------------------------------------------------------
#pragma once
#ifndef VOLUMILL_BOUNDINGBOX_H
#define VOLUMILL_BOUNDINGBOX_H

#include <Geom/Points.h>

namespace geom
{

inline int maxBoxCoord (int) { return 0x7fffffff; }
inline double maxBoxCoord (double) { return 1e30; }

template<class P>
class BoundingBox
{
public:
   typedef P Point;
   BoundingBox ()
   {
      for (int ii=0; ii < Point::Dim; ++ii)
      {
         m_min[ii] = maxBoxCoord (typename Point::Coord());
         m_max[ii] = -maxBoxCoord (typename Point::Coord());
      }
   }
   bool isValid () const { return m_min[0] <= m_max[0]; }
   void addPoint (const Point& pt)
   {
      for (int ii=0; ii < Point::Dim; ++ii)
      {
         if (m_min[ii] > pt[ii])
            m_min[ii] = pt[ii];
         if (m_max[ii] < pt[ii])
            m_max[ii] = pt[ii];
      }
   }
   const Point& getMin () const { return m_min; }
   const Point& getMax () const { return m_max; }
private:
   Point m_min, m_max;
};

template<class B, class P>
inline bool isPointInBox (const B& box, const P& pt)
{
   bool inBox = true;
   for (int ii=0; ii < P::Dim; ++ii)
   {
      inBox &= (box.getMin()[ii] < pt[ii]+util::doubleEps && box.getMax()[ii] > pt[ii]-util::doubleEps);
   }
   return inBox;
}

template<class B>
inline bool boxesIntersect (const B& b1, const B& b2)
{
   bool intersect = true;
   for (int ii=0; ii < B::Point::Dim && intersect; ++ii)
   {
      typename B::Point::Coord lo = std::max (b1.getMin()[ii], b2.getMin()[ii]);
      typename B::Point::Coord hi = std::min (b1.getMax()[ii], b2.getMax()[ii]);
      intersect &= (lo < hi + util::doubleEps);
   }
   return intersect;
}

template<class B, class P>
inline void getBoundingBox (const P& pt, B* pBox)
{
   pBox->addPoint (pt);
}

template<class B>
inline void expandBoundingBox (double eps, B* pBox)
{
   typedef typename B::Point P;
   P lo (pBox->getMin()), hi (pBox->getMax());
   for (int ii=0; ii < P::Dim; ++ii)
   {
      lo[ii] -= eps;
      hi[ii] += eps;
   }
   pBox->addPoint (lo);
   pBox->addPoint (hi);
}

typedef BoundingBox<Point2d> BoundingBox2d;
typedef BoundingBox<Point3d> BoundingBox3d;

}

#endif

---