Box3.h

Go to the documentation of this file.

 
//
// Copyright 2020 Arvind Singh
//
// 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, see <http://www.gnu.org/licenses/>.
 
 
#ifndef _TGX_BOX3_H_
#define _TGX_BOX3_H_
 
// only C++, no plain C
#ifdef __cplusplus
 
#include "Misc.h"
#include "Vec3.h"
 
#include <type_traits>
#include <stdint.h>
 
namespace tgx
{
 
 
    // Forward declaration
 
    template<typename T> struct Box3;
 
 
    // Specializations
 
    typedef Box3<int> iBox3; 
 
    typedef Box3<float> fBox3; 
 
    typedef Box3<double> dBox3; 
 
 
    template<typename T> struct Box3
    {
        
        // mtools extension (if available).   
        #if (MTOOLS_TGX_EXTENSIONS)
        #include <mtools/extensions/tgx/tgx_ext_Box3.inl>
        #endif        
 
        // box dimension: [minX, maxX] x [minY, maxY] x [minZ, maxZ]
 
        T minX; 
        T maxX; 
        T minY; 
        T maxY; 
        T minZ; 
        T maxZ; 
 
 
        constexpr Box3()
            {
            }
 
 
        constexpr Box3(const T minx, const T maxx, const T miny, const T maxy, const T minz, const T maxz) : minX(minx), maxX(maxx), minY(miny), maxY(maxy), minZ(minz), maxZ(maxz)
            {
            }
 
 
        constexpr Box3(const Vec3<T>& v) : minX(v.x), maxX(v.x), minY(v.y), maxY(v.y), minZ(v.z), maxZ(v.z)
            {
            }
 
 
        Box3(const Box3<T>& B) = default;
 
 
        Box3<T>& operator=(const Box3<T>& B) = default;
 
 
        template<typename U>
        explicit operator Box3<U>() { return Box3<U>((U)minX, (U)maxX, (U)minY, (U)maxY, (U)minZ, (U)maxZ); }
 
 
        operator Box3<typename DefaultFPType<T>::fptype>() { return Box3<typename DefaultFPType<T>::fptype>((typename DefaultFPType<T>::fptype)minX, (typename DefaultFPType<T>::fptype)maxX, (typename DefaultFPType<T>::fptype)minY, (typename DefaultFPType<T>::fptype)maxY, (typename DefaultFPType<T>::fptype)minZ, (typename DefaultFPType<T>::fptype)maxZ); }
 
 
        constexpr inline bool isEmpty() const { return ((maxX < minX) || (maxY < minY) || (maxZ < minZ)); }
 
 
        void empty()
            {
            minX = (T)1; 
            maxX = (T)0;
            minY = (T)1;
            maxY = (T)0;
            minZ = (T)1;
            maxZ = (T)0;
            }
 
 
        inline T lx() const
            {
            if (std::is_integral<T>::value) // compiler optimize this away. 
                {
                return (maxX - minX + 1); // for integer, return the number of points
                }
            else    
                {
                return (maxX - minX); // for floating point type, return maxX - minX. 
                }                   
            }
 
 
        inline T ly() const
            {
            if (std::is_integral<T>::value) // compiler optimize this away. 
                {
                return (maxY - minY + 1); // for integer, return the number of points
                }
            else    
                {
                return (maxY - minY); // for floating point type, return maxX - minX. 
                }                   
            }
 
 
        inline T lz() const
            {
            if (std::is_integral<T>::value) // compiler optimize this away. 
                {
                return (maxZ - minZ + 1); // for integer, return the number of points
                }
            else    
                {
                return (maxZ - minZ); // for floating point type, return maxX - minX. 
                }                   
            }
 
 
        inline bool equals(const Box3<T>& B) const
            {
            if (isEmpty()) { return B.isEmpty(); }
            return ((minX == B.minX) && (maxX == B.maxX) && (minY == B.minY) && (maxY == B.maxY) && (minZ == B.minZ) && (maxZ == B.maxZ));
            }
 
 
        inline bool operator==(const Box3<T>& B) const
            {
            return equals(B);
            }
 
 
        inline bool contains(const Vec3<T>& v) const
            {
            return(((minX <= v.x) && (v.x <= maxX)) && ((minY <= v.y) && (v.y <= maxY)) && ((minZ <= v.z) && (v.z <= maxZ)));
            }
 
 
        inline bool contains(const Box3<T>& B) const
            {
            if (isEmpty()) return false;
            if (B.isEmpty()) return true;
            return ((minX <= B.minX) && (maxX >= B.maxX) && (minY <= B.minY) && (maxY >= B.maxY) && (minZ <= B.minZ) && (maxZ >= B.maxZ));
            }
 
 
        inline bool operator>=(const Box3<T>& B) const
            {
            return contains(B);
            }
 
 
        inline bool operator<=(const Box3<T>& B) const
            {
            return B.contains(*this);
            }
 
 
        inline bool operator>(const Box3<T>& B) const
            {
            return ((contains(B)) && (!equals(B)));
            }
 
 
        inline bool operator<(const Box3<T>& B) const
            {
            return ((B.contains(*this)) && (!B.equals(*this)));
            }
 
 
        inline Box3<T> operator&(const Box3<T>& B) const
            {
            Box3<T> R;
            if (isEmpty()) 
                {
                R = *this;
                }
            else if (B.isEmpty())
                {
                R = B;
                }
            else
                {
                R.minX = max(minX, B.minX);
                R.maxX = min(maxX, B.maxX);
                R.minY = max(minY, B.minY);
                R.maxY = min(maxY, B.maxY);
                R.minZ = max(minZ, B.minZ);
                R.maxZ = min(maxZ, B.maxZ);
                }
            return R;
            }
 
 
        inline void operator&=(const Box3<T>& B)
            {
            (*this) = ((*this) & B);
            }
 
 
        inline Box3<T> operator|(const Box3<T>& B) const
            {
            Box3<T> R;
            if (isEmpty())
                {
                R = B;
                }
            else if (B.isEmpty())
                {
                R = (*this);
                }
            else
                {
                R.minX = min(minX, B.minX);
                R.maxX = max(maxX, B.maxX);
                R.minY = min(minY, B.minY);
                R.maxY = max(maxY, B.maxY);
                R.minZ = min(minZ, B.minZ);
                R.maxZ = max(maxZ, B.maxZ);
                }
            return R;
            }
 
 
        inline void operator|=(const Box3<T>& B)
            {
            *this = (*this) | B;
            }
 
 
        inline Box3<T> operator|(const Vec3<T>& v) const
            {
            Box3<T> R;
            if (isEmpty())
                {
                R.minX = R.maxX = v.x;
                R.minY = R.maxY = v.y;
                R.minZ = R.maxZ = v.z;
                }
            else
                {
                R.minX = min(minX, v.x);
                R.maxX = max(maxX, v.x);
                R.minY = min(minY, v.y);
                R.maxY = max(maxY, v.y);
                R.minZ = min(minZ, v.z);
                R.maxZ = max(maxZ, v.z);
                }
            return R;
            }
 
 
        inline void operator|=(const Vec3<T>& v)
            {
            (*this) = (*this) | v;
            }
 
 
        inline void operator+=(const Vec3<T> & V)
            {
            minX += V.x;
            maxX += V.x;
            minY += V.y;
            maxY += V.y;
            minZ += V.z;
            maxZ += V.z;
            }
 
 
        inline Box3<T> operator+(const Vec3<T> & V) const
            {
            return Box3<T>(minX + V.x, maxX + V.x, minY + V.y, maxY + V.y, minZ + V.z, maxZ + V.z);
            }
 
 
        inline void operator-=(const Vec3<T> & V)
            {
            minX -= V.x;
            maxX -= V.x;
            minY -= V.y;
            maxY -= V.y;
            minZ -= V.z;
            maxZ -= V.z;
            }
 
 
        inline Box3<T> operator-(const Vec3<T> & V) const
            {
            return Box3<T>(minX - V.x, maxX - V.x, minY - V.y, maxY - V.y, minZ - V.z, maxZ - V.z);
            }
 
 
        Vec3<T> center() const
            {
            return Vec3<T>((minX + maxX) / 2, (minY + maxY) / 2, (minZ + maxZ) / 2);
            }
 
 
        void zoomOut()
            {
            const T u = lx() / 10;
            minX -= u;
            maxX += u;
            const T v = ly() / 10;
            minY -= v;
            maxY += v;
            const T w = lz() / 10;
            minZ -= w;
            maxZ += w;
            }
 
 
        void zoomIn()
            {
            const T u = lx() / 8;
            minX += u;
            maxX -= u;
            const T v = ly() / 8;
            minY += v;
            maxY -= v;
            const T w = lz() / 8;
            minZ += w;
            maxZ -= w;
            }
 
 
        void left()
            {
            const T u = lx() / 10;
            minX -= u;
            maxX -= u;
            }
 
 
        void right()
            {
            const T u = lx() / 10;
            minX += u;
            maxX += u;
            }
 
 
        void up()
            {
            const T v = ly() / 10;
            minY -= v;
            maxY -= v;
            }
 
 
        void down()
            {
            const T v = ly() / 10;
            minY += v;
            maxY += v;
            }
 
 
        void front()
            {
            const T v = lz() / 10;
            minZ -= v;
            maxZ -= v;
            }
 
 
        void back()
            {
            const T v = lz() / 10;
            minZ += v;
            maxZ += v;
            }
 
 
    };
 
 
 
 
}
 
#endif
 
#endif