bbox.h

/*
    This file is part of Nori, a simple educational ray tracer
 
    Copyright (c) 2015 by Wenzel Jakob
 
    Nori 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.
 
    Nori 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/>.
*/
 
#if !defined(__NORI_BBOX_H)
#define __NORI_BBOX_H
 
#include <nori/ray.h>
 
NORI_NAMESPACE_BEGIN
 
template <typename _PointType> struct TBoundingBox {
    enum {
        Dimension = _PointType::Dimension
    };
 
    typedef _PointType                             PointType;
    typedef typename PointType::Scalar             Scalar;
    typedef typename PointType::VectorType         VectorType;
 
    TBoundingBox() {
        reset();
    }
 
    TBoundingBox(const PointType &p) 
        : min(p), max(p) { }
 
    TBoundingBox(const PointType &min, const PointType &max)
        : min(min), max(max) {
    }
 
    bool operator==(const TBoundingBox &bbox) const {
        return min == bbox.min && max == bbox.max;
    }
 
    bool operator!=(const TBoundingBox &bbox) const {
        return min != bbox.min || max != bbox.max;
    }
 
    Scalar getVolume() const {
        return (max - min).prod();
    }
 
    float getSurfaceArea() const {
        VectorType d = max - min;
        float result = 0.0f;
        for (int i=0; i<Dimension; ++i) {
            float term = 1.0f;
            for (int j=0; j<Dimension; ++j) {
                if (i == j)
                    continue;
                term *= d[j];
            }
            result += term;
        }
        return 2.0f * result;
    }
 
    PointType getCenter() const {
        return (max + min) * (Scalar) 0.5f;
    }
 
    bool contains(const PointType &p, bool strict = false) const {
        if (strict) {
            return (p.array() > min.array()).all() 
                && (p.array() < max.array()).all();
        } else {
            return (p.array() >= min.array()).all() 
                && (p.array() <= max.array()).all();
        }
    }
 
    bool contains(const TBoundingBox &bbox, bool strict = false) const {
        if (strict) {
            return (bbox.min.array() > min.array()).all() 
                && (bbox.max.array() < max.array()).all();
        } else {
            return (bbox.min.array() >= min.array()).all() 
                && (bbox.max.array() <= max.array()).all();
        }
    }
 
    bool overlaps(const TBoundingBox &bbox, bool strict = false) const {
        if (strict) {
            return (bbox.min.array() < max.array()).all() 
                && (bbox.max.array() > min.array()).all();
        } else {
            return (bbox.min.array() <= max.array()).all() 
                && (bbox.max.array() >= min.array()).all();
        }
    }
 
    Scalar squaredDistanceTo(const PointType &p) const {
        Scalar result = 0;
 
        for (int i=0; i<Dimension; ++i) {
            Scalar value = 0;
            if (p[i] < min[i])
                value = min[i] - p[i];
            else if (p[i] > max[i])
                value = p[i] - max[i];
            result += value*value;
        }
 
        return result;
    }
 
    Scalar distanceTo(const PointType &p) const {
        return std::sqrt(squaredDistanceTo(p));
    }
 
    Scalar squaredDistanceTo(const TBoundingBox &bbox) const {
        Scalar result = 0;
 
        for (int i=0; i<Dimension; ++i) {
            Scalar value = 0;
            if (bbox.max[i] < min[i])
                value = min[i] - bbox.max[i];
            else if (bbox.min[i] > max[i])
                value = bbox.min[i] - max[i];
            result += value*value;
        }
 
        return result;
    }
 
    Scalar distanceTo(const TBoundingBox &bbox) const {
        return std::sqrt(squaredDistanceTo(bbox));
    }
 
    bool isValid() const {
        return (max.array() >= min.array()).all();
    }
 
    bool isPoint() const {
        return (max.array() == min.array()).all();
    }
 
    bool hasVolume() const {
        return (max.array() > min.array()).all();
    }
 
    int getMajorAxis() const {
        VectorType d = max - min;
        int largest = 0;
        for (int i=1; i<Dimension; ++i)
            if (d[i] > d[largest])
                largest = i;
        return largest;
    }
 
    int getMinorAxis() const {
        VectorType d = max - min;
        int shortest = 0;
        for (int i=1; i<Dimension; ++i)
            if (d[i] < d[shortest])
                shortest = i;
        return shortest;
    }
 
    VectorType getExtents() const {
        return max - min;
    }
 
    void clip(const TBoundingBox &bbox) {
        min = min.cwiseMax(bbox.min);
        max = max.cwiseMin(bbox.max);
    }
 
    void reset() {
        min.setConstant( std::numeric_limits<Scalar>::infinity());
        max.setConstant(-std::numeric_limits<Scalar>::infinity());
    }
 
    void expandBy(const PointType &p) {
        min = min.cwiseMin(p);
        max = max.cwiseMax(p);
    }
 
    void expandBy(const TBoundingBox &bbox) {
        min = min.cwiseMin(bbox.min);
        max = max.cwiseMax(bbox.max);
    }
 
    static TBoundingBox merge(const TBoundingBox &bbox1, const TBoundingBox &bbox2) {
        return TBoundingBox(
            bbox1.min.cwiseMin(bbox2.min),
            bbox1.max.cwiseMax(bbox2.max)
        );
    }
 
    int getLargestAxis() const {
        VectorType extents = max-min;
 
        if (extents[0] >= extents[1] && extents[0] >= extents[2])
            return 0;
        else if (extents[1] >= extents[0] && extents[1] >= extents[2])
            return 1;
        else
            return 2;
    }
 
    PointType getCorner(int index) const {
        PointType result;
        for (int i=0; i<Dimension; ++i)
            result[i] = (index & (1 << i)) ? max[i] : min[i];
        return result;
    }
 
    std::string toString() const {
        if (!isValid())
            return "BoundingBox[invalid]";
        else
            return tfm::format("BoundingBox[min=%s, max=%s]", min.toString(), max.toString());
    }
 
    bool rayIntersect(const Ray3f &ray) const {
        float nearT = -std::numeric_limits<float>::infinity();
        float farT = std::numeric_limits<float>::infinity();
 
        for (int i=0; i<3; i++) {
            float origin = ray.o[i];
            float minVal = min[i], maxVal = max[i];
 
            if (ray.d[i] == 0) {
                if (origin < minVal || origin > maxVal)
                    return false;
            } else {
                float t1 = (minVal - origin) * ray.dRcp[i];
                float t2 = (maxVal - origin) * ray.dRcp[i];
 
                if (t1 > t2)
                    std::swap(t1, t2);
 
                nearT = std::max(t1, nearT);
                farT = std::min(t2, farT);
 
                if (!(nearT <= farT))
                    return false;
            }
        }
 
        return ray.mint <= farT && nearT <= ray.maxt;
    }
 
    bool rayIntersect(const Ray3f &ray, float &nearT, float &farT) const {
        nearT = -std::numeric_limits<float>::infinity();
        farT = std::numeric_limits<float>::infinity();
 
        for (int i=0; i<3; i++) {
            float origin = ray.o[i];
            float minVal = min[i], maxVal = max[i];
 
            if (ray.d[i] == 0) {
                if (origin < minVal || origin > maxVal)
                    return false;
            } else {
                float t1 = (minVal - origin) * ray.dRcp[i];
                float t2 = (maxVal - origin) * ray.dRcp[i];
 
                if (t1 > t2)
                    std::swap(t1, t2);
 
                nearT = std::max(t1, nearT);
                farT = std::min(t2, farT);
 
                if (!(nearT <= farT))
                    return false;
            }
        }
 
        return true;
    }
 
    PointType min; 
    PointType max; 
};
 
 
NORI_NAMESPACE_END
 
#endif /* __NORI_BBOX_H */