segment.h

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_BASE_TS_SEGMENT_H
#define PXR_BASE_TS_SEGMENT_H
 
#include "pxr/pxr.h"
 
#include "pxr/base/ts/api.h"
#include "pxr/base/ts/types.h"
 
#include "pxr/base/gf/vec2d.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
//
enum class Ts_SegmentInterp
{
    ValueBlock,                 //< This segment explicitly has no value
    Held,                       //< The value is always the starting value
    Linear,                     //< Interpolate linearly from start to end
    Bezier,                     //< The segment uses Bezier interpolation
    Hermite,                    //< The segment uses Hermite interpolation
    PreExtrap,                  //< Linear extrapolation from -infinity to
                                //< the end value with a fixed slope
    PostExtrap                  //< Linear extrapolation to +infinity from
                                //< the start value with a fixed slope
};
 
struct Ts_Segment
{
    GfVec2d p0 = GfVec2d(0);
    GfVec2d t0 = GfVec2d(0);
    GfVec2d t1 = GfVec2d(0);
    GfVec2d p1 = GfVec2d(0);
    Ts_SegmentInterp interp = Ts_SegmentInterp::ValueBlock;
 
    void SetInterp(TsInterpMode interpMode, TsCurveType curveType);
 
    TsInterpMode GetInterpMode() const;
 
    Ts_Segment& operator +=(const GfVec2d& delta)
    {
        p0 += delta;
        t0 += delta;
        t1 += delta;
        p1 += delta;
 
        return *this;
    }
 
    Ts_Segment& operator +=(const double timeDelta)
    {
        p0[0] += timeDelta;
        t0[0] += timeDelta;
        t1[0] += timeDelta;
        p1[0] += timeDelta;
 
        return *this;
    }
 
    Ts_Segment& operator -=(const GfVec2d& delta)
    {
        p0 -= delta;
        t0 -= delta;
        t1 -= delta;
        p1 -= delta;
 
        return *this;
    }
 
    Ts_Segment& operator -=(const double timeDelta)
    {
        p0[0] -= timeDelta;
        t0[0] -= timeDelta;
        t1[0] -= timeDelta;
        p1[0] -= timeDelta;
 
        return *this;
    }
 
    template <typename T>
    Ts_Segment operator +(const T& delta) const
    {
        Ts_Segment result = *this;
        result += delta;
        return result;
    }
 
    // Subtraction operator
    template <typename T>
    Ts_Segment operator -(const T& delta) const
    {
        Ts_Segment result = *this;
        result -= delta;
        return result;
    }
 
    // Unary negation operator - negates the times, not the values.
    Ts_Segment operator -() const
    {
        Ts_Segment result = *this;
        result.p0[0] = -result.p0[0];
        result.t0[0] = -result.t0[0];
        result.t1[0] = -result.t1[0];
        result.p1[0] = -result.p1[0];
 
        // Now swap the points back into the correct order (p0 always has the
        // smallest time value).
        using std::swap;
        swap(result.p0, result.p1);
        swap(result.t0, result.t1);
 
        return result;
    }
 
    bool operator ==(const Ts_Segment& rhs) const
    {
        return (p0 == rhs.p0 &&
                t0 == rhs.t0 &&
                t1 == rhs.t1 &&
                p1 == rhs.p1 &&
                interp == rhs.interp);
    }
 
    bool operator !=(const Ts_Segment& rhs) const
    {
        return !(*this == rhs);
    }
 
    bool IsClose(const Ts_Segment& other, const double tolerance) const
    {
        return (interp == other.interp &&
                GfIsClose(p0, other.p0, tolerance) &&
                GfIsClose(t0, other.t0, tolerance) &&
                GfIsClose(t1, other.t1, tolerance) &&
                GfIsClose(p1, other.p1, tolerance));
    }
 
    TS_API
    double _ComputeDerivative(double u) const;
};
 
// For testing purposes.
TS_API
std::ostream& operator <<(std::ostream&, const Ts_SegmentInterp);
TS_API
std::ostream& operator <<(std::ostream&, const Ts_Segment&);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif