ImathBox.h

//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
 
//
// Axis-aligned bounding box
//
 
#ifndef INCLUDED_ATOMSMATHBOX_H
#define INCLUDED_ATOMSMATHBOX_H
 
#include <AtomsMath/ImathNamespace.h>
#include <AtomsMath/ImathVec.h>
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
template <class V> class Box
{
  public:
 
    
    V min;
 
    V max;
 
 
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box() noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box (const V& point) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box (const V& minV, const V& maxV) noexcept;
 
 
    
    ATOMSMATH_HOSTDEVICE constexpr bool operator== (const Box<V>& src) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr bool operator!= (const Box<V>& src) const noexcept;
 
 
 
    ATOMSMATH_HOSTDEVICE void makeEmpty() noexcept;
 
    ATOMSMATH_HOSTDEVICE void extendBy (const V& point) noexcept;
 
    ATOMSMATH_HOSTDEVICE void extendBy (const Box<V>& box) noexcept;
 
    ATOMSMATH_HOSTDEVICE void makeInfinite() noexcept;
 
 
    
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 V size() const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr V center() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersects (const V& point) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersects (const Box<V>& box) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 unsigned int majorAxis() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool isEmpty() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool hasVolume() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool isInfinite() const noexcept;
 
};
 
//--------------------
// Convenient typedefs
//--------------------
 
typedef Box<V2s> Box2s;
 
typedef Box<V2i> Box2i;
typedef Box<V2i64> Box2i64;
 
typedef Box<V2f> Box2f;
 
typedef Box<V2d> Box2d;
 
typedef Box<V3s> Box3s;
 
typedef Box<V3i> Box3i;
typedef Box<V3i64> Box3i64;
 
typedef Box<V3f> Box3f;
 
typedef Box<V3d> Box3d;
 
template <class V> ATOMSMATH_CONSTEXPR14 inline Box<V>::Box() noexcept
{
    makeEmpty();
}
 
template <class V> ATOMSMATH_CONSTEXPR14 inline Box<V>::Box (const V& point) noexcept
{
    min = point;
    max = point;
}
 
template <class V> ATOMSMATH_CONSTEXPR14 inline Box<V>::Box (const V& minV, const V& maxV) noexcept
{
    min = minV;
    max = maxV;
}
 
template <class V>
constexpr inline bool
Box<V>::operator== (const Box<V>& src) const noexcept
{
    return (min == src.min && max == src.max);
}
 
template <class V>
constexpr inline bool
Box<V>::operator!= (const Box<V>& src) const noexcept
{
    return (min != src.min || max != src.max);
}
 
template <class V>
inline void
Box<V>::makeEmpty() noexcept
{
    min = V (V::baseTypeMax());
    max = V (V::baseTypeLowest());
}
 
template <class V>
inline void
Box<V>::makeInfinite() noexcept
{
    min = V (V::baseTypeLowest());
    max = V (V::baseTypeMax());
}
 
template <class V>
inline void
Box<V>::extendBy (const V& point) noexcept
{
    for (unsigned int i = 0; i < min.dimensions(); i++)
    {
        if (point[i] < min[i])
            min[i] = point[i];
 
        if (point[i] > max[i])
            max[i] = point[i];
    }
}
 
template <class V>
inline void
Box<V>::extendBy (const Box<V>& box) noexcept
{
    for (unsigned int i = 0; i < min.dimensions(); i++)
    {
        if (box.min[i] < min[i])
            min[i] = box.min[i];
 
        if (box.max[i] > max[i])
            max[i] = box.max[i];
    }
}
 
template <class V>
ATOMSMATH_CONSTEXPR14 inline bool
Box<V>::intersects (const V& point) const noexcept
{
    for (unsigned int i = 0; i < min.dimensions(); i++)
    {
        if (point[i] < min[i] || point[i] > max[i])
            return false;
    }
 
    return true;
}
 
template <class V>
ATOMSMATH_CONSTEXPR14 inline bool
Box<V>::intersects (const Box<V>& box) const noexcept
{
    for (unsigned int i = 0; i < min.dimensions(); i++)
    {
        if (box.max[i] < min[i] || box.min[i] > max[i])
            return false;
    }
 
    return true;
}
 
template <class V>
ATOMSMATH_CONSTEXPR14 inline V
Box<V>::size() const noexcept
{
    if (isEmpty())
        return V (0);
 
    return max - min;
}
 
template <class V>
constexpr inline V
Box<V>::center() const noexcept
{
    return (max + min) / 2;
}
 
template <class V>
ATOMSMATH_CONSTEXPR14 inline bool
Box<V>::isEmpty() const noexcept
{
    for (unsigned int i = 0; i < min.dimensions(); i++)
    {
        if (max[i] < min[i])
            return true;
    }
 
    return false;
}
 
template <class V>
ATOMSMATH_CONSTEXPR14 inline bool
Box<V>::isInfinite() const noexcept
{
    for (unsigned int i = 0; i < min.dimensions(); i++)
    {
        if (min[i] != V::baseTypeLowest() || max[i] != V::baseTypeMax())
            return false;
    }
 
    return true;
}
 
template <class V>
ATOMSMATH_CONSTEXPR14 inline bool
Box<V>::hasVolume() const noexcept
{
    for (unsigned int i = 0; i < min.dimensions(); i++)
    {
        if (max[i] <= min[i])
            return false;
    }
 
    return true;
}
 
template <class V>
ATOMSMATH_CONSTEXPR14 inline unsigned int
Box<V>::majorAxis() const noexcept
{
    unsigned int major = 0;
    V s                = size();
 
    for (unsigned int i = 1; i < min.dimensions(); i++)
    {
        if (s[i] > s[major])
            major = i;
    }
 
    return major;
}
 
//-------------------------------------------------------------------
//
//  Partial class specializations for Imath::Vec2<T> and Imath::Vec3<T>
//
//-------------------------------------------------------------------
 
template <typename V> class Box;
 
 
template <class T> class Box<Vec2<T>>
{
  public:
 
    
    Vec2<T> min;
 
    Vec2<T> max;
 
    
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box() noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box (const Vec2<T>& point) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box (const Vec2<T>& minT, const Vec2<T>& maxT) noexcept;
 
 
    
    ATOMSMATH_HOSTDEVICE constexpr bool operator== (const Box<Vec2<T>>& src) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr bool operator!= (const Box<Vec2<T>>& src) const noexcept;
 
 
 
    ATOMSMATH_HOSTDEVICE void makeEmpty() noexcept;
 
    ATOMSMATH_HOSTDEVICE void extendBy (const Vec2<T>& point) noexcept;
 
    ATOMSMATH_HOSTDEVICE void extendBy (const Box<Vec2<T>>& box) noexcept;
 
    ATOMSMATH_HOSTDEVICE void makeInfinite() noexcept;
 
 
    
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Vec2<T> size() const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Vec2<T> center() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersects (const Vec2<T>& point) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersects (const Box<Vec2<T>>& box) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 unsigned int majorAxis() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool isEmpty() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool hasVolume() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool isInfinite() const noexcept;
 
};
 
//----------------
//  Implementation
//----------------
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Box<Vec2<T>>::Box() noexcept
{
    makeEmpty();
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Box<Vec2<T>>::Box (const Vec2<T>& point) noexcept
{
    min = point;
    max = point;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline Box<Vec2<T>>::Box (const Vec2<T>& minT, const Vec2<T>& maxT) noexcept
{
    min = minT;
    max = maxT;
}
 
template <class T>
constexpr inline bool
Box<Vec2<T>>::operator== (const Box<Vec2<T>>& src) const noexcept
{
    return (min == src.min && max == src.max);
}
 
template <class T>
constexpr inline bool
Box<Vec2<T>>::operator!= (const Box<Vec2<T>>& src) const noexcept
{
    return (min != src.min || max != src.max);
}
 
template <class T>
inline void
Box<Vec2<T>>::makeEmpty() noexcept
{
    min = Vec2<T> (Vec2<T>::baseTypeMax());
    max = Vec2<T> (Vec2<T>::baseTypeLowest());
}
 
template <class T>
inline void
Box<Vec2<T>>::makeInfinite() noexcept
{
    min = Vec2<T> (Vec2<T>::baseTypeLowest());
    max = Vec2<T> (Vec2<T>::baseTypeMax());
}
 
template <class T>
inline void
Box<Vec2<T>>::extendBy (const Vec2<T>& point) noexcept
{
    if (point[0] < min[0])
        min[0] = point[0];
 
    if (point[0] > max[0])
        max[0] = point[0];
 
    if (point[1] < min[1])
        min[1] = point[1];
 
    if (point[1] > max[1])
        max[1] = point[1];
}
 
template <class T>
inline void
Box<Vec2<T>>::extendBy (const Box<Vec2<T>>& box) noexcept
{
    if (box.min[0] < min[0])
        min[0] = box.min[0];
 
    if (box.max[0] > max[0])
        max[0] = box.max[0];
 
    if (box.min[1] < min[1])
        min[1] = box.min[1];
 
    if (box.max[1] > max[1])
        max[1] = box.max[1];
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec2<T>>::intersects (const Vec2<T>& point) const noexcept
{
    if (point[0] < min[0] || point[0] > max[0] || point[1] < min[1] || point[1] > max[1])
        return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec2<T>>::intersects (const Box<Vec2<T>>& box) const noexcept
{
    if (box.max[0] < min[0] || box.min[0] > max[0] || box.max[1] < min[1] || box.min[1] > max[1])
        return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline Vec2<T>
Box<Vec2<T>>::size() const noexcept
{
    if (isEmpty())
        return Vec2<T> (0);
 
    return max - min;
}
 
template <class T>
constexpr inline Vec2<T>
Box<Vec2<T>>::center() const noexcept
{
    return (max + min) / 2;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec2<T>>::isEmpty() const noexcept
{
    if (max[0] < min[0] || max[1] < min[1])
        return true;
 
    return false;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec2<T>>::isInfinite() const noexcept
{
    if (min[0] != std::numeric_limits<T>::lowest() ||
        max[0] != std::numeric_limits<T>::max() ||
        min[1] != std::numeric_limits<T>::lowest() ||
        max[1] != std::numeric_limits<T>::max())
        return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec2<T>>::hasVolume() const noexcept
{
    if (max[0] <= min[0] || max[1] <= min[1])
        return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline unsigned int
Box<Vec2<T>>::majorAxis() const noexcept
{
    unsigned int major = 0;
    Vec2<T> s          = size();
 
    if (s[1] > s[major])
        major = 1;
 
    return major;
}
 
template <class T> class Box<Vec3<T>>
{
  public:
 
    
    Vec3<T> min;
 
    Vec3<T> max;
 
 
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box() noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box (const Vec3<T>& point) noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Box (const Vec3<T>& minT, const Vec3<T>& maxT) noexcept;
 
 
    ATOMSMATH_HOSTDEVICE constexpr bool operator== (const Box<Vec3<T>>& src) const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr bool operator!= (const Box<Vec3<T>>& src) const noexcept;
 
    ATOMSMATH_HOSTDEVICE void makeEmpty() noexcept;
 
    ATOMSMATH_HOSTDEVICE void extendBy (const Vec3<T>& point) noexcept;
 
    ATOMSMATH_HOSTDEVICE void extendBy (const Box<Vec3<T>>& box) noexcept;
 
    ATOMSMATH_HOSTDEVICE void makeInfinite() noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 Vec3<T> size() const noexcept;
 
    ATOMSMATH_HOSTDEVICE constexpr Vec3<T> center() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersects (const Vec3<T>& point) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool intersects (const Box<Vec3<T>>& box) const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 unsigned int majorAxis() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool isEmpty() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool hasVolume() const noexcept;
 
    ATOMSMATH_HOSTDEVICE ATOMSMATH_CONSTEXPR14 bool isInfinite() const noexcept;
};
 
//----------------
//  Implementation
//----------------
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Box<Vec3<T>>::Box() noexcept
{
    makeEmpty();
}
 
template <class T> ATOMSMATH_CONSTEXPR14 inline Box<Vec3<T>>::Box (const Vec3<T>& point) noexcept
{
    min = point;
    max = point;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline Box<Vec3<T>>::Box (const Vec3<T>& minT, const Vec3<T>& maxT) noexcept
{
    min = minT;
    max = maxT;
}
 
template <class T>
constexpr inline bool
Box<Vec3<T>>::operator== (const Box<Vec3<T>>& src) const noexcept
{
    return (min == src.min && max == src.max);
}
 
template <class T>
constexpr inline bool
Box<Vec3<T>>::operator!= (const Box<Vec3<T>>& src) const noexcept
{
    return (min != src.min || max != src.max);
}
 
template <class T>
inline void
Box<Vec3<T>>::makeEmpty() noexcept
{
    min = Vec3<T> (Vec3<T>::baseTypeMax());
    max = Vec3<T> (Vec3<T>::baseTypeLowest());
}
 
template <class T>
inline void
Box<Vec3<T>>::makeInfinite() noexcept
{
    min = Vec3<T> (Vec3<T>::baseTypeLowest());
    max = Vec3<T> (Vec3<T>::baseTypeMax());
}
 
template <class T>
inline void
Box<Vec3<T>>::extendBy (const Vec3<T>& point) noexcept
{
    if (point[0] < min[0])
        min[0] = point[0];
 
    if (point[0] > max[0])
        max[0] = point[0];
 
    if (point[1] < min[1])
        min[1] = point[1];
 
    if (point[1] > max[1])
        max[1] = point[1];
 
    if (point[2] < min[2])
        min[2] = point[2];
 
    if (point[2] > max[2])
        max[2] = point[2];
}
 
template <class T>
inline void
Box<Vec3<T>>::extendBy (const Box<Vec3<T>>& box) noexcept
{
    if (box.min[0] < min[0])
        min[0] = box.min[0];
 
    if (box.max[0] > max[0])
        max[0] = box.max[0];
 
    if (box.min[1] < min[1])
        min[1] = box.min[1];
 
    if (box.max[1] > max[1])
        max[1] = box.max[1];
 
    if (box.min[2] < min[2])
        min[2] = box.min[2];
 
    if (box.max[2] > max[2])
        max[2] = box.max[2];
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec3<T>>::intersects (const Vec3<T>& point) const noexcept
{
    if (point[0] < min[0] || point[0] > max[0] || point[1] < min[1] || point[1] > max[1] ||
        point[2] < min[2] || point[2] > max[2])
        return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec3<T>>::intersects (const Box<Vec3<T>>& box) const noexcept
{
    if (box.max[0] < min[0] || box.min[0] > max[0] || box.max[1] < min[1] || box.min[1] > max[1] ||
        box.max[2] < min[2] || box.min[2] > max[2])
        return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline Vec3<T>
Box<Vec3<T>>::size() const noexcept
{
    if (isEmpty())
        return Vec3<T> (0);
 
    return max - min;
}
 
template <class T>
constexpr inline Vec3<T>
Box<Vec3<T>>::center() const noexcept
{
    return (max + min) / 2;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec3<T>>::isEmpty() const noexcept
{
    if (max[0] < min[0] || max[1] < min[1] || max[2] < min[2])
        return true;
 
    return false;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec3<T>>::isInfinite() const noexcept
{
    if (min[0] != std::numeric_limits<T>::lowest() ||
        max[0] != std::numeric_limits<T>::max() ||
        min[1] != std::numeric_limits<T>::lowest() ||
        max[1] != std::numeric_limits<T>::max() ||
        min[2] != std::numeric_limits<T>::lowest() ||
        max[2] != std::numeric_limits<T>::max())
        return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline bool
Box<Vec3<T>>::hasVolume() const noexcept
{
    if (max[0] <= min[0] || max[1] <= min[1] || max[2] <= min[2])
        return false;
 
    return true;
}
 
template <class T>
ATOMSMATH_CONSTEXPR14 inline unsigned int
Box<Vec3<T>>::majorAxis() const noexcept
{
    unsigned int major = 0;
    Vec3<T> s          = size();
 
    if (s[1] > s[major])
        major = 1;
 
    if (s[2] > s[major])
        major = 2;
 
    return major;
}
 
ATOMSMATH_INTERNAL_NAMESPACE_HEADER_EXIT
 
#endif // INCLUDED_ATOMSMATHBOX_H