range3d.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
// This file is generated by a script.  Do not edit directly.  Edit the
// range.template.h file to make changes.
 
#ifndef PXR_BASE_GF_RANGE3D_H
#define PXR_BASE_GF_RANGE3D_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/base/gf/api.h"
#include "pxr/base/gf/vec3d.h"
#include "pxr/base/gf/vec3f.h"
#include "pxr/base/gf/traits.h"
#include "pxr/base/tf/hash.h"
 
#include <cfloat>
#include <cstddef>
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class GfRange3d;
class GfRange3f;
 
template <>
struct GfIsGfRange<class GfRange3d> { static const bool value = true; };
 
class GfRange3d
{
public:
 
    typedef GfVec3d MinMaxType;
 
    static const size_t dimension = GfVec3d::dimension;
    typedef GfVec3d::ScalarType ScalarType;
 
    // TODO check whether this can be deprecated.
    void inline SetEmpty() {
        _min[0] = _min[1] = _min[2] =  FLT_MAX;
        _max[0] = _max[1] = _max[2] = -FLT_MAX;
    }
 
    GfRange3d() {
        SetEmpty();
    }
 
    GfRange3d(const GfVec3d &min, const GfVec3d &max)
        : _min(min), _max(max)
    {
    }
 
 
    GF_API
    GfRange3d(class GfRange3f const &other);
 
    const GfVec3d &GetMin() const { return _min; }
 
    const GfVec3d &GetMax() const { return _max; }
 
    GfVec3d GetSize() const { return _max - _min; }
 
    GfVec3d GetMidpoint() const {
        return static_cast<ScalarType>(0.5) * _min
               + static_cast<ScalarType>(0.5) * _max;
    }
 
    void SetMin(const GfVec3d &min) { _min = min; }
 
    void SetMax(const GfVec3d &max) { _max = max; }
 
    bool IsEmpty() const {
        return _min[0] > _max[0] || _min[1] > _max[1] || _min[2] > _max[2];
    }
 
    void ExtendBy(const GfVec3d &point) { UnionWith(point); }
 
    void ExtendBy(const GfRange3d &range) { UnionWith(range); }
 
    bool Contains(const GfVec3d &point) const {
        return (point[0] >= _min[0] && point[0] <= _max[0]
             && point[1] >= _min[1] && point[1] <= _max[1]
             && point[2] >= _min[2] && point[2] <= _max[2]);
    }
 
    bool Contains(const GfRange3d &range) const {
        return Contains(range._min) && Contains(range._max);
    }
 
    bool IsInside(const GfVec3d &point) const {
        return Contains(point);
    }
 
    bool IsInside(const GfRange3d &range) const {
        return Contains(range);
    }
 
    bool IsOutside(const GfRange3d &range) const {
        return ((range._max[0] < _min[0] || range._min[0] > _max[0])
             || (range._max[1] < _min[1] || range._min[1] > _max[1])
             || (range._max[2] < _min[2] || range._min[2] > _max[2]));
    }
 
    static GfRange3d GetUnion(const GfRange3d &a, const GfRange3d &b) {
        GfRange3d res = a;
        _FindMin(res._min,b._min);
        _FindMax(res._max,b._max);
        return res;
    }
 
    const GfRange3d &UnionWith(const GfRange3d &b) {
        _FindMin(_min,b._min);
        _FindMax(_max,b._max);
        return *this;
    }
 
    const GfRange3d &UnionWith(const GfVec3d &b) {
        _FindMin(_min,b);
        _FindMax(_max,b);
        return *this;
    }
 
    static GfRange3d Union(const GfRange3d &a, const GfRange3d &b) {
        return GetUnion(a, b);
    }
 
    const GfRange3d &Union(const GfRange3d &b) {
        return UnionWith(b);
    }
 
    const GfRange3d &Union(const GfVec3d &b) {
        return UnionWith(b);
    }
 
    static GfRange3d GetIntersection(const GfRange3d &a, const GfRange3d &b) {
        GfRange3d res = a;
        _FindMax(res._min,b._min);
        _FindMin(res._max,b._max);
        return res;
    }
 
    static GfRange3d Intersection(const GfRange3d &a, const GfRange3d &b) {
        return GetIntersection(a, b);
    }
 
    const GfRange3d &IntersectWith(const GfRange3d &b) {
        _FindMax(_min,b._min);
        _FindMin(_max,b._max);
        return *this;
    }
 
    const GfRange3d &Intersection(const GfRange3d &b) {
        return IntersectWith(b);
    }
 
    GfRange3d &operator +=(const GfRange3d &b) {
        _min += b._min;
        _max += b._max;
        return *this;
    }
 
    GfRange3d &operator -=(const GfRange3d &b) {
        _min -= b._max;
        _max -= b._min;
        return *this;
    }
 
    GfRange3d &operator *=(double m) {
        if (m > 0) {
            _min *= m;
            _max *= m;
        } else {
            GfVec3d tmp = _min;
            _min = _max * m;
            _max = tmp * m;
        }
        return *this;
    }
 
    GfRange3d &operator /=(double m) {
        return *this *= (1.0 / m);
    }
 
    GfRange3d operator +(const GfRange3d &b) const {
        return GfRange3d(_min + b._min, _max + b._max);
    }
 
 
    GfRange3d operator -(const GfRange3d &b) const {
        return GfRange3d(_min - b._max, _max - b._min);
    }
 
    friend GfRange3d operator *(double m, const GfRange3d &r) {
        return (m > 0 ? 
            GfRange3d(r._min*m, r._max*m) : 
            GfRange3d(r._max*m, r._min*m));
    }
 
    friend GfRange3d operator *(const GfRange3d &r, double m) {
        return (m > 0 ? 
            GfRange3d(r._min*m, r._max*m) : 
            GfRange3d(r._max*m, r._min*m));
    }
 
    friend GfRange3d operator /(const GfRange3d &r, double m) {
        return r * (1.0 / m);
    }
 
    friend inline size_t hash_value(const GfRange3d &r) {
        return TfHash::Combine(r._min, r._max);
    }
 
    bool operator ==(const GfRange3d &b) const {
        return (_min == b._min && _max == b._max);
    }
 
    bool operator !=(const GfRange3d &b) const {
        return !(*this == b);
    }
 
    GF_API inline bool operator ==(const GfRange3f& other) const;
    GF_API inline bool operator !=(const GfRange3f& other) const;
 
    GF_API
    double GetDistanceSquared(const GfVec3d &p) const;
 
    GF_API
    GfVec3d GetCorner(size_t i) const;
 
    GF_API
    GfRange3d GetOctant(size_t i) const;
 
    GF_API
    static const GfRange3d UnitCube;
 
  private:
    GfVec3d _min, _max;
 
    static void _FindMin(GfVec3d &dest, const GfVec3d &point) {
        if (point[0] < dest[0]) dest[0] = point[0];
        if (point[1] < dest[1]) dest[1] = point[1];
        if (point[2] < dest[2]) dest[2] = point[2];
    }
 
    static void _FindMax(GfVec3d &dest, const GfVec3d &point) {
        if (point[0] > dest[0]) dest[0] = point[0];
        if (point[1] > dest[1]) dest[1] = point[1];
        if (point[2] > dest[2]) dest[2] = point[2];
    }
};
 
GF_API std::ostream& operator<<(std::ostream &, GfRange3d const &);
 
PXR_NAMESPACE_CLOSE_SCOPE
#include "pxr/base/gf/range3f.h"
PXR_NAMESPACE_OPEN_SCOPE
 
inline bool
GfRange3d::operator ==(const GfRange3f& other) const {
    return _min == GfVec3d(other.GetMin()) &&
           _max == GfVec3d(other.GetMax());
}
 
inline bool
GfRange3d::operator !=(const GfRange3f& other) const {
    return !(*this == other);
}
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_RANGE3D_H