Implement regression prevention for Ts_Segments

Specifically, add support to Ts_RegressionPreventerBatchAccess and
TsRegressionPreventer::_SegmentSolver. Overloads of the methods
IsSegmentRegressive and ProcessSegment now operate on a Ts_Segment.
ProcessSegment modifies the Ts_Segment in place.

In practice, these methods will only be called internally by eval,
sample, bake, and breakdown code to ensure that the segment they are
about to operate on is non-regressive. Currently this code only uses
the "keep ratio" anti-regression mode. In practice, splines are
de-regressed at authoring time so Ts_Segments should only be regressive
if the user has deliberately disabled anti-regression when authoring
and then wants to eval the spline.

Note: this functionality is only exercised by the test, but it is
proposed to be the basis for exec, breakdown, sample, and bake.

(Internal change: 2389416)

Author: o2b3d

pxr/base/ts/CMakeLists.txt

@@ -26,6 +26,7 @@ set(classes
     knotMap
     raii
     regressionPreventer
+    segment
     spline
     splineData
     tangentConversions
@@ -162,6 +163,16 @@ pxr_build_test(
         tf
 )
 
+pxr_build_test(
+    testTsRegressionPreventerCpp
+    CPPFILES
+        testenv/testTsRegressionPreventerCpp.cpp
+    LIBRARIES
+        gf
+        tf
+        ts
+)
+
 pxr_build_test(
     testTsSegmentIterator
     CPPFILES
@@ -304,6 +315,11 @@ pxr_register_test(
     COMMAND "${CMAKE_INSTALL_PREFIX}/tests/testTsThreadedCOW"
 )
 
+pxr_register_test(
+    testTsRegressionPreventerCpp
+    COMMAND "${CMAKE_INSTALL_PREFIX}/tests/testTsRegressionPreventerCpp"
+)
+
 pxr_register_test(
     testTsSegmentIterator
     COMMAND "${CMAKE_INSTALL_PREFIX}/tests/testTsSegmentIterator"

pxr/base/ts/iterator.cpp

@@ -20,31 +20,6 @@ constexpr double inf = std::numeric_limits<double>::infinity();
 constexpr bool OPEN = false;
 constexpr bool CLOSED = true;
 
-// Utility to convert a TsInterpMode value into a Ts_SegmentInterp. Because the
-// TsInterpMode just includes a generic "curve" interpolation, we also need the
-// spline's curve type to know if this segment is a bezier or hermite curve.
-Ts_SegmentInterp _ConvertInterpMode(TsInterpMode interpMode,
-                                    TsCurveType curveType)
-{
-    switch (interpMode)
-    {
-      case TsInterpValueBlock: return Ts_SegmentInterp::ValueBlock;
-      case TsInterpHeld: return Ts_SegmentInterp::Held;
-      case TsInterpLinear: return Ts_SegmentInterp::Linear;
-      case TsInterpCurve:
-        if (curveType == TsCurveTypeHermite) {
-            return Ts_SegmentInterp::Hermite;
-        } else {
-            return Ts_SegmentInterp::Bezier;
-        }
-    }
-    // Generate a nicer error message.
-    constexpr bool invalid_TsInterpMode_value = false;
-    TF_AXIOM(invalid_TsInterpMode_value);
-
-    return Ts_SegmentInterp::ValueBlock;
-}
-
 // Get a looped interval that's open on the right-hand end. The one returned by
 // TsLoopParams::GetLoopedInterval() is closed on the right and changing that
 // breaks a couple of existing tests.
@@ -59,100 +34,6 @@ GfInterval _GetOpenLoopedInterval(const TsLoopParams& lp)
 
 }  // end anonymous namespace
 
-////////////////////////////////////////////////////////////////
-// Ts_Segment
-
-// This computes a derivative, but only for u == 0 or u == 1 for curved
-// segments. Fortunately, this is all that's required for linear extrapolation.
-double
-Ts_Segment::_ComputeDerivative(double u) const
-{
-    u = std::clamp(u, 0.0, 1.0);
-
-    // It's possible to not have a derivative due to value blocks. But we're
-    // going to return 0.0 in that case just to keep things simple. The result
-    // will be a value block with slope of 0.0. :-)
-    switch (interp)
-    {
-      case Ts_SegmentInterp::ValueBlock:
-      case Ts_SegmentInterp::Held:
-        return 0.0;
-
-      case Ts_SegmentInterp::Linear:
-        return (p1[1] - p0[1]) / (p1[0] - p0[0]);
-
-      case Ts_SegmentInterp::PreExtrap:
-        return p0[1];
-
-      case Ts_SegmentInterp::PostExtrap:
-        return p1[1];
-
-      case Ts_SegmentInterp::Bezier:
-      case Ts_SegmentInterp::Hermite:
-        TF_VERIFY(u == 0.0 || u == 1.0,
-                  "Cannot yet compute derivatives at arbitrary values. u = %g",
-                  u);
-
-        // Not a generalized solution right now, but it works for 0 and 1
-        if (u <= 0.5) {
-            // slope is equal to first tangent direction.
-            GfVec2d tangent = t0 - p0;
-            return tangent[1] / tangent[0];
-        } else if (u > 0.5) {
-            // slope is equal to the last tangent direction. Note that
-            // this direction is measured from t1 to p1.
-            GfVec2d tangent = p1 - t1;
-            return tangent[1] / tangent[0];
-        }
-
-      default:
-        TF_CODING_ERROR("Invalid segment interp (%d) in _ComputeDerivative",
-                        int(interp));
-    }
-
-    return 0.0;
-}
-
-// Output operator for testing purposes.
-std::ostream& operator <<(std::ostream& out, const Ts_SegmentInterp interp)
-{
-    switch (interp)
-    {
-      case Ts_SegmentInterp::ValueBlock:
-        return out << "Ts_SegmentInterp::ValueBlock";
-
-      case Ts_SegmentInterp::Held:
-        return out << "Ts_SegmentInterp::Held";
-
-      case Ts_SegmentInterp::Linear:
-        return out << "Ts_SegmentInterp::Linear";
-
-      case Ts_SegmentInterp::Bezier:
-        return out << "Ts_SegmentInterp::Bezier";
-
-      case Ts_SegmentInterp::Hermite:
-        return out << "Ts_SegmentInterp::Hermite";
-
-      case Ts_SegmentInterp::PreExtrap:
-        return out << "Ts_SegmentInterp::PreExtrap";
-
-      case Ts_SegmentInterp::PostExtrap:
-        return out << "Ts_SegmentInterp::PostExtrap";
-    }
-
-    return out << "Ts_SegmentInterp(" << int(interp) << ")";
-}
-
-// Output operators for testing purposes.
-std::ostream& operator <<(std::ostream& out, const Ts_Segment& seg)
-{
-    return out << "Ts_Segment{"
-               << "{" << seg.p0[0] << ", " << seg.p0[1] << "}, "
-               << "{" << seg.t0[0] << ", " << seg.t0[1] << "}, "
-               << "{" << seg.t1[0] << ", " << seg.t1[1] << "}, "
-               << "{" << seg.p1[0] << ", " << seg.p1[1] << "}, "
-               << seg.interp << "}";
-}
 
 ////////////////////////////////////////////////////////////////
 // Ts_SegmentPrototypeIterator
@@ -256,7 +137,7 @@ Ts_SegmentPrototypeIterator::_UpdateSegment()
     _segment.t1 = _segment.p1 +
                   GfVec2d(-nextKnot.preTanWidth,
                           nextKnot.GetPreTanHeight());
-    _segment.interp = _ConvertInterpMode(prevKnot.nextInterp, _data->curveType);
+    _segment.SetInterp(prevKnot.nextInterp, _data->curveType);
 }
 
 Ts_Segment Ts_SegmentPrototypeIterator::operator *() const
@@ -634,7 +515,7 @@ Ts_SegmentKnotIterator::_UpdateSegment()
     _segment.t1 = _segment.p1 -
                   GfVec2d(nextKnot.preTanWidth,
                           nextKnot.preTanWidth * nextKnot.preTanSlope);
-    _segment.interp = _ConvertInterpMode(prevKnot.nextInterp, _data->curveType);
+    _segment.SetInterp(prevKnot.nextInterp, _data->curveType);
 }
 
 Ts_Segment

pxr/base/ts/iterator.h

@@ -11,6 +11,7 @@
 #include "pxr/pxr.h"
 
 #include "pxr/base/ts/api.h"
+#include "pxr/base/ts/segment.h"
 #include "pxr/base/ts/splineData.h"
 
 #include "pxr/base/gf/interval.h"
@@ -81,151 +82,6 @@
 
 PXR_NAMESPACE_OPEN_SCOPE
 
-/// Ts_SegmentInterp declares the type of interpolation that should be used
-/// between the end-points of a segment.
-//
-/// It is a scoped enum so the use of the Ts_SegmentInterp:: prefix is required.
-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
-};
-
-/// Ts_Segment represents one section of a spline. It generally contains the
-/// "post" side values of one knot (time, value, tangent, and interpolation) and
-/// the "pre" side of the next knot (preValue and tangent). There are special
-/// case interpolation types for pre- and post-extrapolation and the curve
-/// interpolation of \c TsKnot has been split into separate Bezier and Hermite
-/// values.
-///
-/// The data is stored as 4 GfVec2d values that represent (time, value) points
-/// that are the knot points and the tangent end points. Note that the tangents
-/// are stored as their end points rather than as width and slope as they are in
-/// the knots. Also note that held interpolation segments still store the value
-/// of the post-side knot even though that value is not used for segment
-/// interpolation. This allows the knots to be reconstructed from the segment
-/// data.
-///
-/// If the interpolation is PreExtrap or PostExtrap then the starting or ending
-/// point (respectively) contains (+/- infinity, slope) rather than (time,
-/// value). The straight line is extrapolated to infinity from the other end
-/// point of the segment with the given 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;
-
-    /// Add the (timeDelta, valueDelta) contained in the \c GfVec2d argument to
-    /// the segment's time and value.
-    Ts_Segment& operator +=(const GfVec2d& delta) {
-        p0 += delta;
-        t0 += delta;
-        t1 += delta;
-        p1 += delta;
-
-        return *this;
-    }
-
-    /// Add the timeDelta argument to the segment's time
-    Ts_Segment& operator +=(const double timeDelta) {
-        p0[0] += timeDelta;
-        t0[0] += timeDelta;
-        t1[0] += timeDelta;
-        p1[0] += timeDelta;
-
-        return *this;
-    }
-
-    /// Subtract the (timeDelta, valueDelta) contained in the \c GfVec2d
-    /// argument from the segment's time and value.
-    Ts_Segment& operator -=(const GfVec2d& delta) {
-        p0 -= delta;
-        t0 -= delta;
-        t1 -= delta;
-        p1 -= delta;
-
-        return *this;
-    }
-
-    /// Subtract the timeDelta argument from the segment's time
-    Ts_Segment& operator -=(const double timeDelta) {
-        p0[0] -= timeDelta;
-        t0[0] -= timeDelta;
-        t1[0] -= timeDelta;
-        p1[0] -= timeDelta;
-
-        return *this;
-    }
-
-    /// Addition operator.
-    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;
-    }
-
-    /// Compare for equivalence
-    bool operator ==(const Ts_Segment& rhs) const {
-        return (p0 == rhs.p0 &&
-                t0 == rhs.t0 &&
-                t1 == rhs.t1 &&
-                p1 == rhs.p1 &&
-                interp == rhs.interp);
-    }
-
-    /// Not equivalent
-    bool operator !=(const Ts_Segment& rhs) const {
-        return !(*this == rhs);
-    }
-
-    /// Compute dv/dt at the value u in the interval [0..1].
-    /// Note: This currently only supports u == 0.0 or u == 1.0.
-    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&);
-
 /// \brief Iterate over the segments in an inner loop prototype that intersect
 /// the input time interval.
 ///