axis_aligned_box.h

#pragma once
 
#include <cgv/type/standard_types.h>
#include <cgv/math/vec.h>
#include <cgv/math/fvec.h>
 
namespace cgv {
        namespace media {
 
template<typename T, cgv::type::uint32_type N>
class axis_aligned_box
{
public:
        typedef cgv::math::fvec<T,N> fpnt_type;
        typedef cgv::math::fvec<T,N> fvec_type;
        typedef cgv::math::vec<T> pnt_type;
        typedef cgv::math::vec<T> vec_type;
protected:
        fpnt_type minp;
        fpnt_type maxp;
public:
        axis_aligned_box() { invalidate(); }
        template <typename S>
        axis_aligned_box(const axis_aligned_box<S, N>& B) : 
                minp(T(B.get_min_pnt()(0)), T(B.get_min_pnt()(1)), T(B.get_min_pnt()(2))), 
                maxp(T(B.get_max_pnt()(0)), T(B.get_max_pnt()(1)), T(B.get_max_pnt()(2))) {}
        axis_aligned_box(const fpnt_type& _minp, const fpnt_type& _maxp) : minp(_minp), maxp(_maxp) {}
        axis_aligned_box(const pnt_type& _minp, const pnt_type& _maxp)
        {
                invalidate();
                unsigned i;
                for (i=0; i<_minp.size(); ++i) {
                        if (i == N)
                                break;
                        minp(i) = _minp(i);
                }
                for (i=0; i<_maxp.size(); ++i) {
                        if (i == N)
                                break;
                        maxp(i) = _maxp(i);
                }
        }
        void invalidate() {
                for (unsigned int c = 0; c<N; ++c) {
                        minp(c) = 1;
                        maxp(c) = 0;
                }
        }
        const fpnt_type& get_min_pnt() const { return minp; }
        const fpnt_type& get_max_pnt() const { return maxp; }
        fpnt_type& ref_min_pnt() { return minp; }
        fpnt_type& ref_max_pnt() { return maxp; }
        fpnt_type get_corner(int i) const
        {
                fpnt_type c = minp;
                int bit = 1;
                for (unsigned int dim=0; dim < N; ++dim, bit *= 2)
                        if (i & bit)
                                c(dim) = maxp(dim);
                return c;
        }
        fvec_type get_alpha(const fvec_type& p) const { return (p-minp) / (maxp-minp); }
        fvec_type get_extent() const { return maxp-minp; }
        fpnt_type get_center() const { return (minp+maxp)/2; }
        bool is_valid() const { return minp[0] <= maxp[0]; }
        bool inside(const fpnt_type& p) const {
                for (unsigned int c = 0; c<N; ++c) {
                        if (p(c) < minp(c)) return false;
                        if (p(c) >= maxp(c)) return false;
                }
                return true;
        }
        void add_point(const fpnt_type& p) {
                if (is_valid()) {
                        for (unsigned int c = 0; c<N; ++c) {
                                if (p(c) > maxp(c)) maxp(c) = p(c);
                                if (p(c) < minp(c)) minp(c) = p(c);
                        }
                }
                else
                        minp = maxp = p;
        }
        void add_point(const pnt_type& p) {
                if (is_valid()) {
                        for (unsigned int c = 0; p.size(); ++c) {
                                if (c == N)
                                        break;
                                if (p(c) > maxp(c)) maxp(c) = p(c);
                                if (p(c) < minp(c)) minp(c) = p(c);
                        }
                }
                else
                        *this = axis_aligned_box<T,N>(p,p);
        }
        void add_axis_aligned_box(const axis_aligned_box<T,N>& aab) {
                if (!aab.is_valid())
                        return;
                add_point(aab.minp);
                add_point(aab.maxp);
        }
        void scale(const T& f)
        {
                if (!is_valid())
                        return;
                for (unsigned int c = 0; c<N; ++c) {
                        maxp(c) *= f;
                        minp(c) *= f;
                }
        }
        void translate(const fpnt_type& v)
        {
                if (!is_valid())
                        return;
                ref_min_pnt() += v;
                ref_max_pnt() += v;
        }
        unsigned get_max_extent_coord_index() const
        {
                fvec_type e = get_extent();
                unsigned j = 0;
                for (unsigned i=1; i<N; ++i)
                        if (e(i) > e(j))
                                j = i;
                return j;
        }
};
 
template<typename T, cgv::type::uint32_type N>
std::ostream& operator<<(std::ostream& out, const axis_aligned_box<T, N>& box)
{
        return out << box.get_min_pnt() << "->" << box.get_max_pnt();
}
 
 
        }
}