range1f.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache 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_RANGE1F_H
#define PXR_BASE_GF_RANGE1F_H


#include "pxr/pxr.h"

#include "pxr/base/gf/api.h"
#include "pxr/base/gf/traits.h"

#include <boost/functional/hash.hpp>

#include <cfloat>
#include <cstddef>
#include <iosfwd>

PXR_NAMESPACE_OPEN_SCOPE

class GfRange1d;
class GfRange1f;

template <>
struct GfIsGfRange<class GfRange1f> { static const bool value = true; };

class GfRange1f
{
public:

    typedef float MinMaxType;

    static const size_t dimension = 1;
    typedef MinMaxType ScalarType;

    // TODO check whether this can be deprecated.
    void inline SetEmpty() {
        _min =  FLT_MAX;
        _max = -FLT_MAX;
    }

    GfRange1f() {
        SetEmpty();
    }

    GfRange1f(float min, float max)
        : _min(min), _max(max)
    {
    }

    float GetMin() const { return _min; }

    float GetMax() const { return _max; }

    float GetSize() const { return _max - _min; }

    float GetMidpoint() const {
        return static_cast<ScalarType>(0.5) * _min
               + static_cast<ScalarType>(0.5) * _max;
    }

    void SetMin(float min) { _min = min; }

    void SetMax(float max) { _max = max; }

    bool IsEmpty() const {
        return _min > _max;
    }

    void ExtendBy(float point) { UnionWith(point); }

    void ExtendBy(const GfRange1f &range) { UnionWith(range); }

    bool Contains(float point) const {
        return (point >= _min && point <= _max);
    }

    bool Contains(const GfRange1f &range) const {
        return Contains(range._min) && Contains(range._max);
    }

    bool IsInside(float point) const {
        return Contains(point);
    }

    bool IsInside(const GfRange1f &range) const {
        return Contains(range);
    }

    bool IsOutside(const GfRange1f &range) const {
        return (range._max < _min || range._min > _max);
    }

    static GfRange1f GetUnion(const GfRange1f &a, const GfRange1f &b) {
        GfRange1f res = a;
        _FindMin(res._min,b._min);
        _FindMax(res._max,b._max);
        return res;
    }

    const GfRange1f &UnionWith(const GfRange1f &b) {
        _FindMin(_min,b._min);
        _FindMax(_max,b._max);
        return *this;
    }

    const GfRange1f &UnionWith(float b) {
        _FindMin(_min,b);
        _FindMax(_max,b);
        return *this;
    }

    static GfRange1f Union(const GfRange1f &a, const GfRange1f &b) {
        return GetUnion(a, b);
    }

    const GfRange1f &Union(const GfRange1f &b) {
        return UnionWith(b);
    }

    const GfRange1f &Union(float b) {
        return UnionWith(b);
    }

    static GfRange1f GetIntersection(const GfRange1f &a, const GfRange1f &b) {
        GfRange1f res = a;
        _FindMax(res._min,b._min);
        _FindMin(res._max,b._max);
        return res;
    }

    static GfRange1f Intersection(const GfRange1f &a, const GfRange1f &b) {
        return GetIntersection(a, b);
    }

    const GfRange1f &IntersectWith(const GfRange1f &b) {
        _FindMax(_min,b._min);
        _FindMin(_max,b._max);
        return *this;
    }

    const GfRange1f &Intersection(const GfRange1f &b) {
        return IntersectWith(b);
    }

    GfRange1f operator +=(const GfRange1f &b) {
        _min += b._min;
        _max += b._max;
        return *this;
    }

    GfRange1f operator -=(const GfRange1f &b) {
        _min -= b._max;
        _max -= b._min;
        return *this;
    }

    GfRange1f operator *=(double m) {
        if (m > 0) {
            _min *= m;
            _max *= m;
        } else {
            float tmp = _min;
            _min = _max * m;
            _max = tmp * m;
        }
        return *this;
    }

    GfRange1f operator /=(double m) {
        return *this *= (1.0 / m);
    }

    GfRange1f operator +(const GfRange1f &b) const {
        return GfRange1f(_min + b._min, _max + b._max);
    }


    GfRange1f operator -(const GfRange1f &b) const {
        return GfRange1f(_min - b._max, _max - b._min);
    }

    friend GfRange1f operator *(double m, const GfRange1f &r) {
        return (m > 0 ? 
            GfRange1f(r._min*m, r._max*m) : 
            GfRange1f(r._max*m, r._min*m));
    }

    friend GfRange1f operator *(const GfRange1f &r, double m) {
        return (m > 0 ? 
            GfRange1f(r._min*m, r._max*m) : 
            GfRange1f(r._max*m, r._min*m));
    }

    friend GfRange1f operator /(const GfRange1f &r, double m) {
        return r * (1.0 / m);
    }

    friend inline size_t hash_value(const GfRange1f &r) {
        size_t h = 0;
        boost::hash_combine(h, r._min);
        boost::hash_combine(h, r._max);
        return h;
    }

    bool operator ==(const GfRange1f &b) const {
        return (_min == b._min && _max == b._max);
    }

    bool operator !=(const GfRange1f &b) const {
        return !(*this == b);
    }

    GF_API inline bool operator ==(const GfRange1d& other) const;
    GF_API inline bool operator !=(const GfRange1d& other) const;

    GF_API
    double GetDistanceSquared(float p) const;


  private:
    float _min, _max;

    static void _FindMin(float &dest, float point) {
        if (point < dest) dest = point;
    }

    static void _FindMax(float &dest, float point) {
        if (point > dest) dest = point;
    }
};

GF_API std::ostream& operator<<(std::ostream &, GfRange1f const &);

PXR_NAMESPACE_CLOSE_SCOPE
#include "pxr/base/gf/range1d.h"
PXR_NAMESPACE_OPEN_SCOPE

inline bool
GfRange1f::operator ==(const GfRange1d& other) const {
    return _min == float(other.GetMin()) &&
           _max == float(other.GetMax());
}

inline bool
GfRange1f::operator !=(const GfRange1d& other) const {
    return !(*this == other);
}


PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_BASE_GF_RANGE1F_H