Remove unused geometry_internal::SpiralLerp function

PiperOrigin-RevId: 827593574

Author: Ink Open Source

ink/geometry/internal/algorithms.cc

@@ -51,17 +51,6 @@ std::optional<std::array<float, 3>> GetBarycentricCoordinates(
   return std::array<float, 3>({b0, b1, 1 - b0 - b1});
 }
 
-Vec SpiralLerp(Vec a, Vec b, float t) {
-  if (t == 0) return a;
-  if (t == 1) return b;
-
-  Angle direction = a.Direction() + t * Vec::SignedAngleBetween(a, b);
-  // Note that magnitude can lerp to a negative value, which evaluates to the
-  // desired reflection through the origin.
-  float magnitude = (1 - t) * a.Magnitude() + t * b.Magnitude();
-  return Vec::FromDirectionAndMagnitude(direction, magnitude);
-}
-
 Envelope CalculateEnvelope(const MutableMesh& mesh) {
   Envelope envelope;
   for (uint32_t i = 0; i < mesh.VertexCount(); ++i) {

ink/geometry/internal/algorithms.h

@@ -42,19 +42,6 @@ namespace ink::geometry_internal {
 std::optional<std::array<float, 3>> GetBarycentricCoordinates(
     const Triangle& triangle, Point position);
 
-// Interpolates from `a` to `b` by separately interpolating or extrapolating
-// the direction and magnitude based on the parameter `t`.
-//
-//   * When `a` and `b` have different magnitudes and directions, this produces
-//     points on an Archimedean spiral containing `a`, `b`, and the origin.
-//   * When `a` and `b` have the same direction, this is equivalent to a regular
-//     linear interpolation or extrapolation. This is a degenerate spiral with
-//     infinite radial separation between loops.
-//   * When `a` and `b` have the same magnitude, this is equivalent to the 2D
-//     case of spherical interpolation (https://en.wikipedia.org/wiki/Slerp).
-//     This is a degenerate spiral with zero radial separation between loops.
-Vec SpiralLerp(Vec a, Vec b, float t);
-
 // Returns the `Envelope` of `mesh` positions.
 //
 // Vertex positions contribute to the envelope by just being in the `mesh` and

ink/geometry/internal/algorithms_test.cc

@@ -108,60 +108,6 @@ TEST(GetBarycentricCoordinatesTest, DegenerateTriangle) {
               Eq(std::nullopt));
 }
 
-TEST(SpiralLerpTest, NonZeroInputVectorsWithDifferentDirections) {
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, 5}, -5), VecNear({0, 1}, 0.001));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, 5}, -4), VecNear({0, 0}, 0.001));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, 5}, -1), VecNear({0, -3}, 0.001));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, 5}, 0), VecEq({4, 0}));
-  EXPECT_THAT(
-      SpiralLerp({4, 0}, {0, 5}, 0.5),
-      VecNear(Vec::FromDirectionAndMagnitude(kFullTurn / 8, 4.5), 0.001));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, 5}, 1), VecEq({0, 5}));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, 5}, 3), VecNear({0, -7}, 0.001));
-
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, -3}, -1), VecNear({0, 5}, 0.001));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, -3}, 0), VecEq({4, 0}));
-  EXPECT_THAT(
-      SpiralLerp({4, 0}, {0, -3}, 0.5),
-      VecNear(Vec::FromDirectionAndMagnitude(-kFullTurn / 8, 3.5), 0.001));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, -3}, 1), VecEq({0, -3}));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, -3}, 4), VecNear({0, 0}, 0.001));
-  EXPECT_THAT(SpiralLerp({4, 0}, {0, -3}, 5), VecNear({0, 1}, 0.001));
-}
-
-TEST(SpiralLerpTest, NonZeroInputVectorsWithSameDirection) {
-  EXPECT_THAT(SpiralLerp({1, 1}, {3, 3}, -1), VecNear({-1, -1}, 0.001));
-  EXPECT_THAT(SpiralLerp({1, 1}, {3, 3}, 0), VecEq({1, 1}));
-  EXPECT_THAT(SpiralLerp({1, 1}, {3, 3}, 0.5), VecNear({2, 2}, 0.001));
-  EXPECT_THAT(SpiralLerp({1, 1}, {3, 3}, 1), VecEq({3, 3}));
-  EXPECT_THAT(SpiralLerp({1, 1}, {3, 3}, 2), VecNear({5, 5}, 0.001));
-}
-
-TEST(SpiralLerpTest, ZeroInputVectors) {
-  // Note that the "direction" of (0, 0) is toward the positive x-axis as given
-  // by IEEE atan2.
-
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 2}, -1), VecNear({0, 2}, 0.001));
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 2}, 0), VecEq({0, 0}));
-  EXPECT_THAT(
-      SpiralLerp({0, 0}, {0, 2}, 0.75),
-      VecNear(Vec::FromDirectionAndMagnitude(3 * kFullTurn / 16, 1.5), 0.001));
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 2}, 1), VecEq({0, 2}));
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 2}, 2), VecNear({-4, 0}, 0.001));
-
-  EXPECT_THAT(SpiralLerp({-3, 0}, {0, 0}, -1), VecNear({6, 0}, 0.001));
-  EXPECT_THAT(SpiralLerp({-3, 0}, {0, 0}, 0), VecEq({-3, 0}));
-  EXPECT_THAT(SpiralLerp({-3, 0}, {0, 0}, 0.5), VecNear({0, -1.5}, 0.001));
-  EXPECT_THAT(SpiralLerp({-3, 0}, {0, 0}, 1), VecEq({0, 0}));
-  EXPECT_THAT(SpiralLerp({-3, 0}, {0, 0}, 2), VecNear({3, 0}, 0.001));
-
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 0}, -1), VecEq({0, 0}));
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 0}, 0), VecEq({0, 0}));
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 0}, 0.2), VecEq({0, 0}));
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 0}, 1), VecEq({0, 0}));
-  EXPECT_THAT(SpiralLerp({0, 0}, {0, 0}, 2), VecEq({0, 0}));
-}
-
 TEST(CalculateEnvelopeTest, EmptyMesh) {
   MutableMesh mesh;
   EXPECT_TRUE(CalculateEnvelope(mesh).IsEmpty());