range3f.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_RANGE3F_H
#define PXR_BASE_GF_RANGE3F_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 GfRange3f> { static const bool value = true; };
 
class GfRange3f
{
public:
 
    typedef GfVec3f MinMaxType;
 
    static const size_t dimension = GfVec3f::dimension;
    typedef GfVec3f::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;
    }
 
    GfRange3f() {
        SetEmpty();
    }
 
    GfRange3f(const GfVec3f &min, const GfVec3f &max)
        : _min(min), _max(max)
    {
    }
 
 
    GF_API
    explicit GfRange3f(class GfRange3d const &other);
 
    const GfVec3f &GetMin() const { return _min; }
 
    const GfVec3f &GetMax() const { return _max; }
 
    GfVec3f GetSize() const { return _max - _min; }
 
    GfVec3f GetMidpoint() const {
        return static_cast<ScalarType>(0.5) * _min
               + static_cast<ScalarType>(0.5) * _max;
    }
 
    void SetMin(const GfVec3f &min) { _min = min; }
 
    void SetMax(const GfVec3f &max) { _max = max; }
 
    bool IsEmpty() const {
        return _min[0] > _max[0] || _min[1] > _max[1] || _min[2] > _max[2];
    }
 
    void ExtendBy(const GfVec3f &point) { UnionWith(point); }
 
    void ExtendBy(const GfRange3f &range) { UnionWith(range); }
 
    bool Contains(const GfVec3f &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 GfRange3f &range) const {
        return Contains(range._min) && Contains(range._max);
    }
 
    bool IsInside(const GfVec3f &point) const {
        return Contains(point);
    }
 
    bool IsInside(const GfRange3f &range) const {
        return Contains(range);
    }
 
    bool IsOutside(const GfRange3f &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 GfRange3f GetUnion(const GfRange3f &a, const GfRange3f &b) {
        GfRange3f res = a;
        _FindMin(res._min,b._min);
        _FindMax(res._max,b._max);
        return res;
    }
 
    const GfRange3f &UnionWith(const GfRange3f &b) {
        _FindMin(_min,b._min);
        _FindMax(_max,b._max);
        return *this;
    }
 
    const GfRange3f &UnionWith(const GfVec3f &b) {
        _FindMin(_min,b);
        _FindMax(_max,b);
        return *this;
    }
 
    static GfRange3f Union(const GfRange3f &a, const GfRange3f &b) {
        return GetUnion(a, b);
    }
 
    const GfRange3f &Union(const GfRange3f &b) {
        return UnionWith(b);
    }
 
    const GfRange3f &Union(const GfVec3f &b) {
        return UnionWith(b);
    }
 
    static GfRange3f GetIntersection(const GfRange3f &a, const GfRange3f &b) {
        GfRange3f res = a;
        _FindMax(res._min,b._min);
        _FindMin(res._max,b._max);
        return res;
    }
 
    static GfRange3f Intersection(const