Box.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/Array.h"
#include "objects/geometry/Indices.h"
#include "objects/geometry/Vector.h"
 
NAMESPACE_SPH_BEGIN
 
class Box {
private:
    Vector minBound = Vector(LARGE);
    Vector maxBound = Vector(-LARGE);
 
public:
    INLINE Box() = default;
 
    INLINE Box(const Vector& minBound, const Vector& maxBound)
        : minBound(minBound)
        , maxBound(maxBound) {
        SPH_ASSERT(isValid());
    }
 
    static Box EMPTY() {
        return Box();
    }
 
    INLINE void extend(const Vector& v) {
        maxBound = max(maxBound, v);
        minBound = min(minBound, v);
    }
 
    INLINE void extend(const Box& other) {
        maxBound = max(maxBound, other.maxBound);
        minBound = min(minBound, other.minBound);
    }
 
    INLINE bool contains(const Vector& v) const {
        for (int i = 0; i < 3; ++i) {
            if (v[i] < minBound[i] || v[i] > maxBound[i]) {
                return false;
            }
        }
        return true;
    }
 
    INLINE Vector clamp(const Vector& v) const {
        SPH_ASSERT(isValid());
        return Sph::clamp(v, minBound, maxBound);
    }
 
    INLINE const Vector& lower() const {
        SPH_ASSERT(isValid());
        return minBound;
    }
 
    INLINE Vector& lower() {
        SPH_ASSERT(isValid());
        return minBound;
    }
 
    INLINE const Vector& upper() const {
        SPH_ASSERT(isValid());
        return maxBound;
    }
 
    INLINE Vector& upper() {
        SPH_ASSERT(isValid());
        return maxBound;
    }
 
    INLINE Vector size() const {
        SPH_ASSERT(isValid());
        return maxBound - minBound;
    }
 
    INLINE Vector center() const {
        SPH_ASSERT(isValid());
        return 0.5_f * (minBound + maxBound);
    }
 
    INLINE Float volume() const {
        const Vector s = size();
        return s[X] * s[Y] * s[Z];
    }
 
    INLINE bool operator==(const Box& other) const {
        return minBound == other.minBound && maxBound == other.maxBound;
    }
 
    INLINE bool operator!=(const Box& other) const {
        return minBound != other.minBound || maxBound != other.maxBound;
    }
 
    INLINE Box translate(const Vector& offset) const {
        return Box(minBound + offset, maxBound + offset);
    }
 
    INLINE Pair<Box> split(const Size dim, const Float x) const {
        SPH_ASSERT(isValid());
        SPH_ASSERT(dim < 3);
        SPH_ASSERT(x >= minBound[dim] && x <= maxBound[dim]);
        Box b1 = *this, b2 = *this;
        b1.maxBound[dim] = x;
        b2.minBound[dim] = x;
        return { b1, b2 };
    }
 
    INLINE Box intersect(const Box& other) const {
        Box is;
        is.minBound = max(minBound, other.minBound);
        is.maxBound = min(maxBound, other.maxBound);
        if (is.isValid()) {
            return is;
        } else {
            return Box::EMPTY();
        }
    }
 
    template <typename TFunctor>
    void iterate(const Vector& step, TFunctor&& functor) const {
        SPH_ASSERT(isValid());
        for (Float x = minBound[X]; x <= maxBound[X]; x += step[X]) {
            for (Float y = minBound[Y]; y <= maxBound[Y]; y += step[Y]) {
                for (Float z = minBound[Z]; z <= maxBound[Z]; z += step[Z]) {
                    functor(Vector(x, y, z));
                }
            }
        }
    }
 
    template <typename TFunctor>
    void iterateWithIndices(const Vector& step, TFunctor&& functor) const {
        SPH_ASSERT(isValid());
        Size i = 0, j = 0, k = 0;
        for (Float z = minBound[Z]; z <= maxBound[Z]; z += step[Z], k++) {
            i = 0;
            j = 0;
            for (Float y = minBound[Y]; y <= maxBound[Y]; y += step[Y], j++) {
                i = 0;
                for (Float x = minBound[X]; x <= maxBound[X]; x += step[X], i++) {
                    functor(Indices(i, j, k), Vector(x, y, z));
                }
            }
        }
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const Box& box) {
        if (box == Box::EMPTY()) {
            stream << "EMPTY";
        } else {
            stream << box.lower() << box.upper();
        }
        return stream;
    }
 
private:
    bool isValid() const {
        return minElement(maxBound - minBound) >= 0._f;
    }
};
 
 
NAMESPACE_SPH_END