box.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program 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              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_SPACE_CORE_BOX_H
#define VCL_SPACE_CORE_BOX_H
 
#include "point.h"
 
namespace vcl {
 
template<PointConcept PointT>
class Box
{
    PointT mMin;
    PointT mMax;
 
public:
    using PointType = PointT;
 
    static const uint DIM = PointT::DIM;
 
    Box() { setNull(); }
 
    Box(const PointT& p) : mMin(p), mMax(p) {}
 
    Box(const PointT& min, const PointT& max) : mMin(min), mMax(max) {}
 
    PointT& min() { return mMin; }
 
    const PointT& min() const { return mMin; }
 
    PointT& max() { return mMax; }
 
    const PointT& max() const { return mMax; }
 
    template<typename Scalar>
    auto cast() const
    {
        if constexpr (std::is_same_v<typename PointT::ScalarType, Scalar>) {
            return *this;
        }
        else {
            return Box<Point<Scalar, PointT::DIM>>(
                mMin.template cast<Scalar>(), mMax.template cast<Scalar>());
        }
    }
 
    bool isNull() const
    {
        for (uint i = 0; i < PointT::DIM; ++i) {
            if (mMin[i] > mMax[i])
                return true;
        }
        return false;
    }
 
    bool isEmpty() const { return mMin == mMax; }
 
    bool isInside(const PointT& p) const
    {
        for (uint i = 0; i < PointT::DIM; ++i) {
            if (p[i] < mMin[i] || p[i] > mMax[i])
                return false;
        }
        return true;
    }
 
    bool isInsideStrict(const PointT& p) const
    {
        for (uint i = 0; i < PointT::DIM; ++i) {
            if (p[i] <= mMin[i] || p[i] >= mMax[i])
                return false;
        }
        return true;
    }
 
    bool isInsideOpenBox(const PointT& p) const
    {
        for (uint i = 0; i < PointT::DIM; ++i) {
            if (p[i] < mMin[i] || p[i] >= mMax[i])
                return false;
        }
        return true;
    }
 
    bool overlap(const Box<PointT>& b) const
    {
        // Check if any dimension of the boxes does not overlap.
        for (uint i = 0; i < PointT::DIM; ++i) {
            if (b.mMin[i] >= mMax[i] || b.mMax[i] <= mMin[i])
                return false;
        }
        // All dimensions overlap, the boxes collide.
        return true;
    }
 
    bool collide(const Box<PointT>& b) const { return overlap(b); }
 
    bool intersects(const Box<PointT>& b) const { return overlap(b); }
 
    auto diagonal() const { return mMin.dist(mMax); }
 
    auto squaredDiagonal() const { return mMin.squaredDist(mMax); }
 
    PointT center() const { return (mMax + mMin) / 2; }
 
    PointT size() const { return mMax - mMin; }
 
    auto volume() const
    {
        // Initialize volume as the width of the first dimension.
        auto vol = mMax[0] - mMin[0];
        // Multiply by the width of each dimension.
        for (uint i = 1; i < PointT::DIM; ++i) {
            vol *= mMax[i] - mMin[i];
        }
        return vol;
    }
 
    auto dim(uint i) const
    {
        assert(i < PointT::DIM);
        return mMax[i] - mMin[i];
    }
 
    auto minDim() const
    {
        auto m = mMax[0] - mMin[0];
        for (uint i = 1; i < PointT::DIM; ++i) {
            if (mMax[i] - mMin[i] < m)
                m = mMax[i] - mMin[i];
        }
        return m;
    }
 
    auto maxDim() const
    {
        auto m = mMax[0] - mMin[0];
        for (uint i = 1; i < PointT::DIM; ++i) {
            if (mMax[i] - mMin[i] > m)
                m = mMax[i] - mMin[i];
        }
        return m;
    }
 
    Box<PointT> intersection(const Box<PointT>& b) const
    {
        Box<PointT> res = *this;
        for (uint i = 0; i < PointT::DIM; ++i) {
            if (mMin[i] < b.mMin[i]) {
                // set the minimum point to the larger value
                res.mMin[i] = b.mMin[i];
            }
            if (mMax[i] > b.mMax[i]) {
                // set the maximum point to the smaller value
                res.mMax[i] = b.mMax[i];
            }
            if (res.mMin[i] > res.mMax[i]) {
                // if the minimum point is larger than the maximum point, the
                // box is null
                res.setNull();
                return res;
            }
        }
        return res;
    }
 
    void setNull()
    {
        mMin.setConstant(
            std::numeric_limits<typename PointT::ScalarType>::max());
        mMax.setConstant(
            std::numeric_limits<typename PointT::ScalarType>::lowest());
    }
 
    void add(const PointT& p)
    {
        if (isNull()) {
            // If the box was null, set both the minimum and maximum points to
            // the given point
            *this = Box(p);
        }
        else {
            // Expand the current box to include the added point
            mMin = vcl::min(mMin, p);
            mMax = vcl::max(mMax, p);
        }
    }
 
    template<typename Scalar>
    void add(const PointT& p, Scalar radius)
    {
        if (isNull()) {
            // If the box was null, initialize it with the minimum and maximum
            // points obtained by subtracting and adding the radius to the given
            // point
            *this = Box(p - radius, p + radius);
        }
        else {
            // Expand the current box to include the added point and all points
            // within the radius around it
            mMin = vcl::min(mMin, p - radius);
            mMax = vcl::max(mMax, p + radius);
        }
    }
 
    void add(const Box<PointT>& b)
    {
        // Adding a null box should do nothing
        if (!b.isNull()) {
            if (isNull()) {
                *this = b; // if the current box is null, set it equal to b
            }
            else {
                // expand this box to contain the minimum and maximum point of b
                add(b.mMin);
                add(b.mMax);
            }
        }
    }
 
    void translate(const PointT& p)
    {
        mMin += p; // translate the minimum point by p
        mMax += p; // translate the maximum point by p
    }
 
    void serialize(std::ostream& os) const
    {
        mMin.serialize(os);
        mMax.serialize(os);
    }
 
    void deserialize(std::istream& is)
    {
        mMin.deserialize(is);
        mMax.deserialize(is);
    }
 
    bool operator==(const Box<PointT>& b) const
    {
        return mMin == b.mMin && mMax == b.mMax;
    }
 
    bool operator!=(const Box<PointT>& b) const { return !(*this == b); }
};
 
/* Specialization Aliases */
 
template<typename S>
using Box2 = Box<Point2<S>>;
 
using Box2i = Box<Point2i>;
using Box2f = Box<Point2f>;
using Box2d = Box<Point2d>;
 
template<typename S>
using Box3 = Box<Point3<S>>;
 
using Box3i = Box<Point3i>;
using Box3f = Box<Point3f>;
using Box3d = Box<Point3d>;
 
/* Concepts */
 
template<typename T>
concept BoxConcept = std::derived_from< // same type or derived type
    std::remove_cvref_t<T>,
    Box<typename RemoveRef<T>::PointType>>;
 
template<typename T>
concept Box2Concept = BoxConcept<T> && RemoveRef<T>::DIM == 2;
 
template<typename T>
concept Box3Concept = BoxConcept<T> && RemoveRef<T>::DIM == 3;
 
} // namespace vcl
 
#endif // VCL_SPACE_CORE_BOX_H