box.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#ifndef EASY3D_CORE_GENERIC_BOX_H
#define EASY3D_CORE_GENERIC_BOX_H
 
#include <cassert>
#include <limits>
 
#include <easy3d/core/vec.h>
 
 
namespace easy3d {

    template<int DIM, typename FT>
    class GenericBox {
    public:
        typedef Vec<DIM, FT> Point;            
        typedef Vec<DIM, FT> Vector;           
        typedef GenericBox<DIM, FT> thisclass; 
 
    public:
        GenericBox()
                : min_(std::numeric_limits<FT>::max())   // is_valid to an invalid value
                , max_(-std::numeric_limits<FT>::max()) {
        }

        GenericBox(const Point &pmin, const Point &pmax) {
            grow(pmin);
            grow(pmax);
        }

        GenericBox(const Point &c, FT r) {
            Vector dir(1.0);
            dir.normalize();
            min_ = c - dir * r;
            max_ = c + dir * r;
        }

        bool is_valid() const {
            for (int i = 0; i < DIM; ++i) {
                if (max_[i] >= min_[i] - std::numeric_limits<FT>::epsilon())
                    return true;
            }
            return false;
        }

        void clear() {
            min_ = Point(std::numeric_limits<FT>::max());
            max_ = Point(-std::numeric_limits<FT>::max());
        }

        const Point& min_point() const { return min_; }
        Point& min_point() { return min_; }

        const Point& max_point() const { return max_; }
        Point& max_point() { return max_; }

        FT min_coord(unsigned int axis) const {
            assert(axis >= 0 && axis < DIM);
            if (is_valid())
                return min_[axis];
            return FT(0.0);
        }

        FT max_coord(unsigned int axis) const {
            assert(axis >= 0 && axis < DIM);
            if (is_valid())
                return max_[axis];
            return FT(0.0);
        }

        FT range(unsigned int axis) const {
            assert(axis >= 0 && axis < DIM);
            if (is_valid())
                return max_[axis] - min_[axis];
            return FT(0.0);
        }

        FT max_range() const {
            FT max_value = max_[0] - min_[0];
            for (int i = 1; i < DIM; ++i)
                max_value = std::max(max_value, max_[i] - min_[i]);
            return max_value;
        }

        FT min_range() const {
            FT min_value = max_[0] - min_[0];
            for (int i = 1; i < DIM; ++i)
                min_value = std::min(min_value, max_[i] - min_[i]);
            return min_value;
        }

        unsigned int max_range_axis() const {
            unsigned int axis = 0;
            FT max_value = max_[0] - min_[0];
            for (int i = 1; i < DIM; ++i) {
                FT range = max_[i] - min_[i];
                if (range > max_value) {
                    axis = i;
                    max_value = range;
                }
            }
            return axis;
        }

        unsigned int min_range_axis() const {
            unsigned int axis = 0;
            FT min_value = max_[0] - min_[0];
            for (int i = 1; i < DIM; ++i) {
                FT range = max_[i] - min_[i];
                if (range < min_value) {
                    axis = i;
                    min_value = range;
                }
            }
            return axis;
        }

        Point center() const {
            if (is_valid())
                return FT(0.5) * (min_ + max_);
            return Point(0.0);
        }

        Vector diagonal_vector() const { return max_ - min_; }

        FT diagonal_length() const {
            if (is_valid()) {
                FT sqr_len(0.0);
                for (int i = 0; i < DIM; ++i) {
                    FT d = max_[i] - min_[i];
                    sqr_len += d * d;
                }
                return std::sqrt(sqr_len);
            }
            return FT(0.0);
        }

        FT radius() const {
            return diagonal_length() * FT(0.5);
        }

        FT surface_area() const {
            Vector ext = max_ - min_;
            if (DIM == 3)
                return FT(2.0) * (ext[0] * ext[1] + ext[0] * ext[2] + ext[1] * ext[2]);
            else if (DIM == 2)
                return ext[0] * ext[1];
            else {
                std::cerr << "surface_area() is for 2D and 3D boxes" << std::endl;
                return FT(0);
            }
        }

        void grow(const Point &p) {
            if (is_valid()) {
                for (int i = 0; i < DIM; ++i) {
                    min_[i] = std::min(min_[i], p[i]);
                    max_[i] = std::max(max_[i], p[i]);
                }
            } else {
                min_ = p;
                max_ = p;
            }
        }

        void grow(const thisclass &b) {
            if (b.is_valid()) {
                grow(b.min_point());
                grow(b.max_point());
            }
        }

        thisclass operator+(const thisclass &b) const {
            thisclass result = *this;
            if (b.is_valid())
                result += b;
            return result;
        }

        thisclass &operator+=(const thisclass &b) {
            if (b.is_valid()) {
                grow(b.min_point());
                grow(b.max_point());
            }
            return *this;
        }

        bool contains(Point const& p) const {
            for (int i = 0; i < DIM; ++i) {
                if (p[i] <= min_[i] || p[i] >= max_[i])
                    return false;
            }
            return true;
        }

        bool contains(thisclass const& b) const {
            return contains(b.min_point()) && contains(b.max_point());
        }

        bool intersects(thisclass const& b) const {
            for (int i = 0; i < DIM; ++i) {
                if (b.min_coord(i) > max_[i] || b.max_coord(i) < min_[i])
                    return false;
            }
            return true;
        }
 
    private:
        Point min_;
        Point max_;
    };
 

    template<int DIM, typename FT>
    bool has_nan(const GenericBox<DIM, FT> &box) {
        return has_nan(box.min_point()) || has_nan(box.max_point());
    }
 
 
    namespace geom {
 
#if 1
        template<int DIM, typename FT>
        GenericBox<DIM, FT> box_union(GenericBox<DIM, FT> const& a, GenericBox<DIM, FT> const& b) {
            return GenericBox<DIM, FT>(comp_min(a.min_point(), b.min_point()), comp_max(a.max_point(), b.max_point()));
        }

        template<int DIM, typename FT>
        GenericBox<DIM, FT> box_intersection(GenericBox<DIM, FT> const& a, GenericBox<DIM, FT> const& b)
        {
            return GenericBox<DIM, FT>(comp_max(a.min_point(), b.min_point()), comp_min(a.max_point(), b.max_point()));
        }
#else
        template<int DIM, typename FT>
        GenericBox<DIM, FT> box_union(GenericBox<DIM, FT> const& a, GenericBox<DIM, FT> const& b) { return a + b; }
 
        template<int DIM, typename FT>
        GenericBox<DIM, FT> box_intersection(GenericBox<DIM, FT> const& a, GenericBox<DIM, FT> const& b) {
            if (a.intersects(b))
                return GenericBox<DIM, FT>(comp_max(a.min_point(), b.min_point()), comp_min(a.max_point(), b.max_point()));
            else
                return GenericBox<DIM, FT>();
        }
#endif
 
    }
 
} // namespace easy3d
 
 
#endif  // EASY3D_CORE_GENERIC_BOX_H