Consolidate Ink's linear interpolation implementations

We had multiple different naive floating-point lerp implementations sprinkled throughout our code.  In some places, we used `a + (b - a) * t`, which gives incorrect results if `b - a` overflows, and can be inexact for `t = 1`.  In other places, we used `a * (1 - t) + b * t`, which is better, but apparently has monotonicity issues [1] and also gives incorrect results when `t` is infinite and `a` or `b` is zero.  Better to have one _carefully tested_ definition and use it everywhere, which is what this CL does.

The good news is that C++20 (which we can finally now use in all our build environments) provides a `std::lerp` function that handles these edge cases.  The bad news is that (at least in some of our build environments), it seems to have a bug (b/457491215) where its behavior does not match the standard!  So for now our `float Lerp` definition in this CL has an extra branch to work around that before deferring to `std::lerp`.

[1] https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0811r3.html

PiperOrigin-RevId: 826613841

Author: Ink Open Source

ink/geometry/BUILD.bazel

@@ -264,6 +264,7 @@ cc_library(
     deps = [
         ":point",
         ":vec",
+        "//ink/geometry/internal:lerp",
         "@com_google_absl//absl/strings",
     ],
 )

ink/geometry/internal/BUILD.bazel

@@ -25,9 +25,7 @@ cc_library(
     hdrs = ["algorithms.h"],
     deps = [
         ":intersects_internal",
-        "//ink/color",
         "//ink/geometry:affine_transform",
-        "//ink/geometry:angle",
         "//ink/geometry:envelope",
         "//ink/geometry:mesh",
         "//ink/geometry:mutable_mesh",
@@ -46,8 +44,6 @@ cc_test(
     srcs = ["algorithms_test.cc"],
     deps = [
         ":algorithms",
-        "//ink/color",
-        "//ink/color:type_matchers",
         "//ink/geometry:affine_transform",
         "//ink/geometry:angle",
         "//ink/geometry:envelope",
@@ -136,6 +132,37 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "lerp",
+    srcs = ["lerp.cc"],
+    hdrs = ["lerp.h"],
+    deps = [
+        "//ink/color",
+        "//ink/geometry:angle",
+        "//ink/geometry:point",
+        "//ink/geometry:vec",
+        "//ink/types:duration",
+    ],
+)
+
+cc_test(
+    name = "lerp_test",
+    srcs = ["lerp_test.cc"],
+    deps = [
+        ":lerp",
+        "//ink/color",
+        "//ink/color:type_matchers",
+        "//ink/geometry:angle",
+        "//ink/geometry:point",
+        "//ink/geometry:type_matchers",
+        "//ink/geometry:vec",
+        "//ink/types:duration",
+        "//ink/types:type_matchers",
+        "@com_google_fuzztest//fuzztest",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "modulo",
     srcs = ["modulo.cc"],

ink/geometry/internal/algorithms.cc

@@ -23,9 +23,7 @@
 
 #include "absl/log/absl_check.h"
 #include "absl/types/span.h"
-#include "ink/color/color.h"
 #include "ink/geometry/affine_transform.h"
-#include "ink/geometry/angle.h"
 #include "ink/geometry/envelope.h"
 #include "ink/geometry/internal/intersects_internal.h"
 #include "ink/geometry/mesh.h"
@@ -90,44 +88,6 @@ std::optional<Vec> VectorFromPointToSegmentProjection(Point point,
          base_vector.Orthogonal();
 }
 
-float Lerp(float a, float b, float t) { return a + (b - a) * t; }
-
-Point Lerp(Point a, Point b, float t) {
-  return Segment{.start = a, .end = b}.Lerp(t);
-}
-
-Color::RgbaFloat Lerp(const Color::RgbaFloat& a, const Color::RgbaFloat& b,
-                      float t) {
-  return {.r = a.r * (1 - t) + b.r * t,
-          .g = a.g * (1 - t) + b.g * t,
-          .b = a.b * (1 - t) + b.b * t,
-          .a = a.a * (1 - t) + b.a * t};
-}
-
-Angle Lerp(Angle a, Angle b, float t) { return (1 - t) * a + t * b; }
-Angle NormalizedAngleLerp(Angle a, Angle b, float t) {
-  return (a + Lerp(Angle(), (b - a).NormalizedAboutZero(), t)).Normalized();
-}
-
-Vec Lerp(Vec a, Vec b, float t) {
-  return Vec{Lerp(a.x, b.x, t), Lerp(a.y, b.y, t)};
-}
-
-float InverseLerp(float a, float b, float value) {
-  // If the interval between `a` and `b` is 0, there is no way to get to `t`
-  // because in the other direction the value of `t` won't impact the result.
-  if (b - a == 0.f) {
-    return 0.f;
-  }
-  return (value - a) / (b - a);
-}
-
-float LinearMap(float input_value, std::pair<float, float> input_range,
-                std::pair<float, float> output_range) {
-  return Lerp(output_range.first, output_range.second,
-              InverseLerp(input_range.first, input_range.second, input_value));
-}
-
 std::optional<std::pair<float, float>> SegmentIntersectionRatio(
     const Segment& a, const Segment& b) {
   if (a == b) return std::pair{0.f, 0.f};

ink/geometry/internal/algorithms.h

@@ -20,9 +20,7 @@
 #include <utility>
 
 #include "absl/types/span.h"
-#include "ink/color/color.h"
 #include "ink/geometry/affine_transform.h"
-#include "ink/geometry/angle.h"
 #include "ink/geometry/envelope.h"
 #include "ink/geometry/mesh.h"
 #include "ink/geometry/mutable_mesh.h"
@@ -62,43 +60,6 @@ Envelope CalculateEnvelope(const MutableMesh& mesh);
 std::optional<Vec> VectorFromPointToSegmentProjection(Point point,
                                                       const Segment& segment);
 
-// Linearly interpolates between `a` and `b`. Extrapolates when `t` is not in
-// [0, 1].
-//
-// In the case where `a` == `b` the function will return `a` for any value of
-// `t`.
-//
-// Note that the `Angle` overload simply interpolates the value of the `Angle`;
-// it does not have any special case logic for congruent angles. I.e., for
-// `Angle`s that differ by more than 2π, this will interpolate through one (or
-// more) full rotations, and for `Angle`s that differ by less than 2π, this
-// may interpolate the "long way" around the unit circle. If you require that
-// behavior, you can achieve it by normalizing the `Angle`s w.r.t. a reference
-// `Angle` (see also `Angle::Normalized` and `Angle::NormalizedAboutZero`).
-float Lerp(float a, float b, float t);
-Point Lerp(Point a, Point b, float t);
-Color::RgbaFloat Lerp(const Color::RgbaFloat& a, const Color::RgbaFloat& b,
-                      float t);
-Angle Lerp(Angle a, Angle b, float t);
-Vec Lerp(Vec a, Vec b, float t);
-
-// Linearly interpolates between `a` and `b` in the shorter direction between
-// the two angles and returns a value in range [0, 2pi).
-Angle NormalizedAngleLerp(Angle a, Angle b, float t);
-
-// Linearly rescales `t` relative to `a` and `b`, such that `a` maps to 0, and
-// `b` maps to 1. If `value` is between `a` and `b`, the result will lie in the
-// interval [0, 1].
-//
-// If `a` == `b` this function will return 0, for any `value`.
-float InverseLerp(float a, float b, float value);
-
-// Linearly maps an `input_value` from an `input_range` to an`output_range` such
-// that `input_range.first` maps to `output_range.first` and
-// `input_range.second` maps to `output_range.second`.
-float LinearMap(float input_value, std::pair<float, float> input_range,
-                std::pair<float, float> output_range);
-
 // Returns the ratio along `a` (per `Segment::Lerp`) at which it intersects `b`,
 // and along `b' (per `Segment::Lerp`) at which it intersects `a` or
 // `std::nullopt` if they do not intersect. If `a` and `b` are overlapping

ink/geometry/internal/algorithms_test.cc

@@ -24,8 +24,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/span.h"
-#include "ink/color/color.h"
-#include "ink/color/type_matchers.h"
 #include "ink/geometry/affine_transform.h"
 #include "ink/geometry/angle.h"
 #include "ink/geometry/envelope.h"
@@ -165,183 +163,6 @@ TEST(VectorFromPointToSegmentProjectionTest,
       Optional(VecNear(segment.Lerp(*segment.Project(point)) - point, 0.0001)));
 }
 
-TEST(LerpFloatTest, AmountBetweenZeroAndOne) {
-  EXPECT_FLOAT_EQ(Lerp(100.0, 200.0, 0.1), 110.0);
-}
-
-TEST(LerpFloatTest, AmountGreaterThanOne) {
-  EXPECT_FLOAT_EQ(Lerp(100.0, 200.0, 1.1), 210.0);
-}
-
-TEST(LerpFloatTest, AmountLessThanZero) {
-  EXPECT_FLOAT_EQ(Lerp(100.0, 200.0, -0.1), 90.0);
-}
-
-TEST(InverseLerpFloatTest, InverseLerp) {
-  EXPECT_FLOAT_EQ(InverseLerp(100.0, 200.0, 140.0), 0.4);
-}
-
-TEST(InverseLerpFloatTest, InverseLerpOnZeroWidthInterval) {
-  EXPECT_FLOAT_EQ(InverseLerp(100.0, 100.0, 140.0), 0.f);
-}
-
-TEST(InverseLerpFloatTest, InverseLerpIsInverseOfLerp) {
-  EXPECT_FLOAT_EQ(InverseLerp(100.0, 200, Lerp(100, 200, 0.1)), 0.1);
-  EXPECT_FLOAT_EQ(InverseLerp(100.0, 200, Lerp(100, 200, 1.1)), 1.1);
-  EXPECT_FLOAT_EQ(InverseLerp(100.0, 200, Lerp(100, 200, -0.1)), -0.1);
-
-  // For a zero-width interval Lerp cannot be be inversed because the original
-  // `t` doesn't impact the result of the Lerp function.
-  EXPECT_FLOAT_EQ(InverseLerp(100.0, 100, Lerp(100, 100, 0.1)), 0.0f);
-  EXPECT_FLOAT_EQ(InverseLerp(100.0, 100, Lerp(100, 100, 1.1)), 0.0f);
-  EXPECT_FLOAT_EQ(InverseLerp(100.0, 100, Lerp(100, 100, -0.1)), 0.0f);
-}
-
-TEST(LinearMapTest, LinearMap) {
-  EXPECT_FLOAT_EQ(LinearMap(10, {0, 100}, {0, 200}), 20);
-  EXPECT_FLOAT_EQ(LinearMap(10, {0, 100}, {100, 150}), 105);
-  EXPECT_FLOAT_EQ(LinearMap(10, {0, 100}, {0, -100}), -10);
-}
-
-TEST(LinearMapTest, LinearMapOnZeroWidthInputInterval) {
-  EXPECT_FLOAT_EQ(LinearMap(0, {0, 0}, {0, 100}), 0);
-  EXPECT_FLOAT_EQ(LinearMap(150, {150, 150}, {0, 100}), 0);
-}
-
-TEST(LinearMapTest, LinearMapOnZeroWidthTargetInterval) {
-  EXPECT_FLOAT_EQ(LinearMap(0, {0, 100}, {100, 100}), 100);
-  EXPECT_FLOAT_EQ(LinearMap(50, {0, 100}, {100, 100}), 100);
-}
-
-TEST(LinearMapTest, LinearMapWithValueOutsideRange) {
-  EXPECT_FLOAT_EQ(LinearMap(-10, {0, 100}, {0, 200}), -20);
-}
-
-TEST(LinearMapTest, LinearMapLinearMapofLinearMapIsOriginalValue) {
-  EXPECT_FLOAT_EQ(
-      LinearMap(LinearMap(10, {0, 100}, {0, 200}), {0, 200}, {0, 100}), 10);
-}
-
-TEST(LerpPointTest, AmountBetweenZeroAndOne) {
-  EXPECT_THAT(Lerp(Point({100.0, 100.0}), Point({200.0, 200.0}), 0.1),
-              PointEq(Point({110.0, 110.0})));
-}
-
-TEST(LerpPointTest, AmountGreaterThanOne) {
-  EXPECT_THAT(Lerp(Point({100.0, 100.0}), Point({200.0, 200.0}), 1.1),
-              PointEq(Point({210.0, 210.0})));
-}
-
-TEST(LerpPointTest, AmountLessThanZero) {
-  EXPECT_THAT(Lerp(Point({100.0, 100.0}), Point({200.0, 200.0}), -0.1),
-              PointEq(Point({90.0, 90.0})));
-}
-
-TEST(LerpColorRgbaFloatTest, AmountBetweenZeroAndOne) {
-  EXPECT_THAT(Lerp(Color::RgbaFloat({100.0, 100.0, 100.0, 100.0}),
-                   Color::RgbaFloat({200.0, 200.0, 200.0, 200.0}), 0.1),
-              ChannelStructEqFloats({110.0, 110.0, 110.0, 110.0}));
-}
-
-TEST(LerpColorRgbaFloatTest, AmountGreaterThanOne) {
-  EXPECT_THAT(Lerp(Color::RgbaFloat({100.0, 100.0, 100.0, 100.0}),
-                   Color::RgbaFloat({200.0, 200.0, 200.0, 200.0}), 1.1),
-              ChannelStructEqFloats({210.0, 210.0, 210.0, 210.0}));
-}
-
-TEST(LerpColorRgbaFloatTest, AmountLessThanZero) {
-  EXPECT_THAT(Lerp(Color::RgbaFloat({100.0, 100.0, 100.0, 100.0}),
-                   Color::RgbaFloat({200.0, 200.0, 200.0, 200.0}), -0.1),
-              ChannelStructEqFloats({90.0, 90.0, 90.0, 90.0}));
-}
-
-TEST(LerpAngleTest, AmountBetweenZeroAndOne) {
-  EXPECT_THAT(Lerp(Angle::Radians(1), Angle::Radians(2), 0.3),
-              AngleEq(Angle::Radians(1.3)));
-}
-
-TEST(LerpAngleTest, AmountLessThanZero) {
-  EXPECT_THAT(Lerp(Angle::Radians(0.5), Angle::Radians(1.5), -2),
-              AngleEq(Angle::Radians(-1.5)));
-}
-
-TEST(LerpAngleTest, AmountGreaterThanOne) {
-  EXPECT_THAT(Lerp(Angle::Radians(-0.3), Angle::Radians(0.7), 5),
-              AngleEq(Angle::Radians(4.7)));
-}
-
-TEST(LerpAngleTest, DifferenceGreaterThanTwoPi) {
-  EXPECT_THAT(Lerp(Angle::Radians(-6), Angle::Radians(4), 0.7),
-              AngleEq(Angle::Radians(1)));
-}
-
-TEST(NormalizedAngleLerpTest, DifferenceSmallerThanPiWithBGreaterA) {
-  EXPECT_THAT(NormalizedAngleLerp(Angle::Radians(1), Angle::Radians(2), 0.3),
-              AngleEq(Angle::Radians(1.3)));
-}
-
-TEST(NormalizedAngleLerpTest, DifferenceGreaterThanPiWithBGreaterA) {
-  EXPECT_THAT(
-      NormalizedAngleLerp(Angle::Radians(0.5), Angle::Radians(5.5), 0.3),
-      AngleNear(Angle::Radians(0.116), 0.01));
-}
-
-TEST(NormalizedAngleLerpTest, DifferenceSmallerThanPiWithAGreaterB) {
-  EXPECT_THAT(
-      NormalizedAngleLerp(Angle::Radians(5.5), Angle::Radians(0.5), 0.3),
-      AngleNear(Angle::Radians(5.884), 0.01));
-}
-
-TEST(NormalizedAngleLerpTest, DifferenceGreaterThanPiWithAGreaterB) {
-  EXPECT_THAT(
-      NormalizedAngleLerp(Angle::Radians(5.5), Angle::Radians(4.5), 0.3),
-      AngleEq(Angle::Radians(5.2)));
-}
-
-TEST(LerpTest, NonZeroInputVectorsWithDifferentDirections) {
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, 5}, -5), VecEq({24, -25}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, 5}, -4), VecEq({20, -20}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, 5}, -1), VecEq({8, -5}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, 5}, 0), VecEq({4, 0}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, 5}, 0.5), VecEq({2, 2.5}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, 5}, 1), VecEq({0, 5}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, 5}, 3), VecEq({-8, 15}));
-
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, -3}, -1), VecEq({8, 3}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, -3}, 0), VecEq({4, 0}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, -3}, 0.5), VecEq({2, -1.5}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, -3}, 1), VecEq({0, -3}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, -3}, 4), VecEq({-12, -12}));
-  EXPECT_THAT(Lerp(Vec{4, 0}, Vec{0, -3}, 5), VecEq({-16, -15}));
-}
-
-TEST(LerpTest, NonZeroInputVectorsWithSameDirection) {
-  EXPECT_THAT(Lerp(Vec{1, 1}, Vec{3, 3}, -1), VecNear({-1, -1}, 0.001));
-  EXPECT_THAT(Lerp(Vec{1, 1}, Vec{3, 3}, 0), VecEq({1, 1}));
-  EXPECT_THAT(Lerp(Vec{1, 1}, Vec{3, 3}, 0.5), VecEq({2, 2}));
-  EXPECT_THAT(Lerp(Vec{1, 1}, Vec{3, 3}, 1), VecEq({3, 3}));
-  EXPECT_THAT(Lerp(Vec{1, 1}, Vec{3, 3}, 2), VecEq({5, 5}));
-}
-
-TEST(LerpTest, ZeroInputVectors) {
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 2}, -1), VecEq({0, -2}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 2}, 0), VecEq({0, 0}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 2}, 0.75), VecEq({0, 1.5}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 2}, 1), VecEq({0, 2}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 2}, 2), VecEq({0, 4}));
-
-  EXPECT_THAT(Lerp(Vec{-3, 0}, Vec{0, 0}, -1), VecEq({-6, 0}));
-  EXPECT_THAT(Lerp(Vec{-3, 0}, Vec{0, 0}, 0), VecEq({-3, 0}));
-  EXPECT_THAT(Lerp(Vec{-3, 0}, Vec{0, 0}, 0.5), VecEq({-1.5, 0}));
-  EXPECT_THAT(Lerp(Vec{-3, 0}, Vec{0, 0}, 1), VecEq({0, 0}));
-  EXPECT_THAT(Lerp(Vec{-3, 0}, Vec{0, 0}, 2), VecEq({3, 0}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 0}, -1), VecEq({0, 0}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 0}, 0), VecEq({0, 0}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 0}, 0.2), VecEq({0, 0}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 0}, 1), VecEq({0, 0}));
-  EXPECT_THAT(Lerp(Vec{0, 0}, Vec{0, 0}, 2), VecEq({0, 0}));
-}
-
 TEST(SegmentIntersectionRatioTest, NoIntersection) {
   // These segments cover all three non-intersection cases: skew but not
   // touching, parallel but offset, and parallel on the same line but