BoundingBoxImpl.hpp

#include <geom/Point.hpp>

namespace jafar {
  namespace geom {

    template<int dimension>
    BoundingBox<dimension>::BoundingBox() : m_corner1(0), m_corner2(0), m_defined(false)
    {
    }

    template<int dimension>
    BoundingBox<dimension>::BoundingBox(const BoundingBox<dimension>::HomogenousVec& corner1, const BoundingBox<dimension>::HomogenousVec& corner2)
      : m_corner1(corner1), m_corner2(corner2), m_defined(true)
    {
      normalize();
    }

    template<int dimension>
    BoundingBox<dimension>::BoundingBox(const BoundingBox<dimension>& ref)
      : m_corner1(ref.corner1()), m_corner2(ref.corner2()), m_defined(true)
    {
      //      normalize();
    }

    template<int dimension>
    bool BoundingBox<dimension>::operator==( const BoundingBox& _rhs ) const
    {
      for( int i = 0; i < dimension; ++i)
      {
        if(  _rhs.m_corner1(i) != m_corner1(i) or _rhs.m_corner2(i) != m_corner2(i) )
        {
          return false;
        }
      }
      return true;
    }

    template<int dimension>
    inline const typename BoundingBox<dimension>::HomogenousVec& BoundingBox<dimension>::corner1() const
    {
      return m_corner1;
    }

    template<int dimension>
    inline const typename BoundingBox<dimension>::HomogenousVec& BoundingBox<dimension>::corner2() const
    {
      return m_corner2;
    }

    template<int dimension>
    inline void BoundingBox<dimension>::extend(double size)
    {
      HomogenousVec extensionVec = jblas::scalar_vec( dimension+1, size );
      extensionVec( dimension ) = 0.0;
      m_corner1 -= extensionVec;
      m_corner2 += extensionVec;
    }

    template<int dimension>
    inline void BoundingBox<dimension>::normalize()
    {
      for(int i = 0; i < dimension; i++)
      {
        if( m_corner1(i) > m_corner2(i) )
        {
          double v = m_corner1(i);
          m_corner1(i) = m_corner2(i);
          m_corner2(i) = v;
        }
      }
    }

    template<int dimension>
    inline bool BoundingBox<dimension>::isDefined() const
    {
      return m_defined;
    }

    template<int dimension>
    inline bool BoundingBox<dimension>::contains( const typename BoundingBox<dimension>::HomogenousVec& _point) const
    {
      for( int i = 0; i < dimension; i++)
      {
        if( _point(i) > m_corner2(i) or _point(i) < m_corner1(i) )
        {
          return false;
        }
      }
      return true;
    }

    template<int dimension>
    inline bool BoundingBox<dimension>::strictContains( const typename BoundingBox<dimension>::HomogenousVec& _point) const
    {
      for( int i = 0; i < dimension; i++)
      {
        if( _point(i) >= m_corner2(i) or _point(i) <= m_corner1(i) )
        {
          return false;
        }
      }
      return true;
    }

    template<int _dimension_>
    inline bool BoundingBox<_dimension_>::overlap( const BoundingBox<_dimension_>& _bb) const
    {
      if( *this == _bb ) return true;
      for( int i = 0; i < _dimension_; i++)
      { // If both coordinate from corner1 and corner2 are out of the range, then it's over
        if( (_bb.corner1()(i) > m_corner2(i) or _bb.corner1()(i) < m_corner1(i) ) and
            (_bb.corner2()(i) > m_corner2(i) or _bb.corner2()(i) < m_corner1(i) ) and
            (_bb.corner2()(i) < m_corner2(i) or _bb.corner1()(i) > m_corner2(i) ) and
            (_bb.corner2()(i) < m_corner1(i) or _bb.corner1()(i) > m_corner1(i) ) )
        {
          return false;
        }
      }
      return true;
    }

    template<int _dimension_>
    inline bool BoundingBox<_dimension_>::strictOverlap( const BoundingBox<_dimension_>& _bb) const
    {
      if( *this == _bb ) return true; // Special case
      for( int i = 0; i < _dimension_; i++)
      { // If both coordinate from corner1 and corner2 are out of the range, then it's over
        if( (_bb.corner1()(i) >= m_corner2(i) or _bb.corner1()(i) <= m_corner1(i) ) and
            (_bb.corner2()(i) >= m_corner2(i) or _bb.corner2()(i) <= m_corner1(i) ) and
            (_bb.corner2()(i) <= m_corner2(i) or _bb.corner1()(i) >= m_corner2(i) ) and
            (_bb.corner2()(i) <= m_corner1(i) or _bb.corner1()(i) >= m_corner1(i) ) )
        {
          return false;
        }
      }
      return true;
    }

    template<int _dimension_>
    inline std::ostream& operator<<(std::ostream& _s, const BoundingBox<_dimension_>& _bb)
    {
      _s << _bb.corner1() << " " << _bb.corner2();
      return _s;
    }

  }
}