Allow the computation of inflated bounds for non matrix transform operations.

cc/animation/transform_operations_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_vector.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/box_f.h"
+#include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/vector3d_f.h"
 
 namespace cc {
 namespace {
 
 TEST(TransformOperationTest, TransformTypesAreUnique) {
   ScopedVector<TransformOperations> transforms;
 
   TransformOperations* to_add = new TransformOperations();
   to_add->AppendTranslate(1, 0, 0);
@@ skipping 855 matching lines @@
 
   float min = -1.f / 3.f;
   float max = 1.f;
   float size = max - min;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, 0.f, 1.f, &bounds));
   EXPECT_EQ(gfx::BoxF(min, min, min, size, size, size).ToString(),
             bounds.ToString());
 }
 
+TEST(TransformOperationTest, BlendedBoundsForRotationDifferentAxes) {
+  // We can handle rotations about a single axis. If the axes are different,
+  // we revert to matrix interpolation for which inflated bounds cannot be
+  // computed.
+  TransformOperations operations_from;
+  operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
+  TransformOperations operations_to_same;
+  operations_to_same.AppendRotate(1.f, 1.f, 1.f, 390.f);
+  TransformOperations operations_to_opposite;
+  operations_to_opposite.AppendRotate(-1.f, -1.f, -1.f, 390.f);
+  TransformOperations operations_to_different;
+  operations_to_different.AppendRotate(1.f, 3.f, 1.f, 390.f);
+
+  gfx::BoxF box(1.f, 0.f, 0.f, 0.f, 0.f, 0.f);
+  gfx::BoxF bounds;
+
+  EXPECT_TRUE(operations_to_same.BlendedBoundsForBox(
+      box, operations_from, 0.f, 1.f, &bounds));
+  EXPECT_TRUE(operations_to_opposite.BlendedBoundsForBox(
+      box, operations_from, 0.f, 1.f, &bounds));
+  EXPECT_FALSE(operations_to_different.BlendedBoundsForBox(
+      box, operations_from, 0.f, 1.f, &bounds));
+}
+
 TEST(TransformOperationTest, BlendedBoundsForRotationPointOnAxis) {
   // Checks that if the point to rotate is sitting on the axis of rotation, that
   // it does not get affected.
   TransformOperations operations_from;
   operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
   TransformOperations operations_to;
   operations_to.AppendRotate(1.f, 1.f, 1.f, 390.f);
 
   gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
   gfx::BoxF bounds;
@@ skipping 62 matching lines @@
 struct TestAngles {
   float theta_from;
   float theta_to;
 };
 
 struct TestProgress {
   float min_progress;
   float max_progress;
 };
 
-TEST(TransformOperationsTest, BlendedBoundsForRotationEmpiricalTests) {
+static void ExpectBoxesApproximatelyEqual(const gfx::BoxF& lhs,
+                                          const gfx::BoxF& rhs,
+                                          float tolerance) {
+  EXPECT_NEAR(lhs.x(), rhs.x(), tolerance);
+  EXPECT_NEAR(lhs.y(), rhs.y(), tolerance);
+  EXPECT_NEAR(lhs.z(), rhs.z(), tolerance);
+  EXPECT_NEAR(lhs.width(), rhs.width(), tolerance);
+  EXPECT_NEAR(lhs.height(), rhs.height(), tolerance);
+  EXPECT_NEAR(lhs.depth(), rhs.depth(), tolerance);
+}
+
+static void EmpiricallyTestBounds(const TransformOperations& from,
+                                  const TransformOperations& to,
+                                  SkMScalar min_progress,
+                                  SkMScalar max_progress,
+                                  bool test_containment_only) {
+  gfx::BoxF box(200.f, 500.f, 100.f, 100.f, 300.f, 200.f);
+  gfx::BoxF bounds;
+  EXPECT_TRUE(
+      to.BlendedBoundsForBox(box, from, min_progress, max_progress, &bounds));
+
+  bool first_time = true;
+  gfx::BoxF empirical_bounds;
+  static const size_t kNumSteps = 10;
+  for (size_t step = 0; step < kNumSteps; ++step) {
+    float t = step / (kNumSteps - 1.f);
+    t = gfx::Tween::FloatValueBetween(t, min_progress, max_progress);
+    gfx::Transform partial_transform = to.Blend(from, t);
+    gfx::BoxF transformed = box;
+    partial_transform.TransformBox(&transformed);
+
+    if (first_time) {
+      empirical_bounds = transformed;
+      first_time = false;
+    } else {
+      empirical_bounds.Union(transformed);
+    }
+  }
+
+  if (test_containment_only) {
+    gfx::BoxF unified_bounds = bounds;
+    unified_bounds.Union(empirical_bounds);
+    // Convert to the screen space rects these boxes represent.
+    gfx::Rect bounds_rect = ToEnclosingRect(
+        gfx::RectF(bounds.x(), bounds.y(), bounds.width(), bounds.height()));
+    gfx::Rect unified_bounds_rect =
+        ToEnclosingRect(gfx::RectF(unified_bounds.x(),
+                                   unified_bounds.y(),
+                                   unified_bounds.width(),
+                                   unified_bounds.height()));
+    EXPECT_EQ(bounds_rect.ToString(), unified_bounds_rect.ToString());
+  } else {
+    // Our empirical estimate will be a little rough since we're only doing
+    // 100 samples.
+    static const float kTolerance = 1e-2f;
+    ExpectBoxesApproximatelyEqual(empirical_bounds, bounds, kTolerance);
+  }
+}
+
+static void EmpiricallyTestBoundsEquality(const TransformOperations& from,
+                                          const TransformOperations& to,
+                                          SkMScalar min_progress,
+                                          SkMScalar max_progress) {
+  EmpiricallyTestBounds(from, to, min_progress, max_progress, false);
+}
+
+static void EmpiricallyTestBoundsContainment(const TransformOperations& from,
+                                             const TransformOperations& to,
+                                             SkMScalar min_progress,
+                                             SkMScalar max_progress) {
+  EmpiricallyTestBounds(from, to, min_progress, max_progress, true);
+}
+
+TEST(TransformOperationTest, BlendedBoundsForRotationEmpiricalTests) {
   // Sets up various axis angle combinations, computes the bounding box and
   // empirically tests that the transformed bounds are indeed contained by the
   // computed bounding box.
 
   TestAxis axes[] = {
     { 1.f, 1.f, 1.f },
     { -1.f, -1.f, -1.f },
     { -1.f, 2.f, 3.f },
     { 1.f, -2.f, 3.f },
     { 1.f, 2.f, -3.f },
@@ skipping 23 matching lines @@
   };
 
   // We can go beyond the range [0, 1] (the bezier might slide out of this range
   // at either end), but since the first and last knots are at (0, 0) and (1, 1)
   // we will never go within it, so these tests are sufficient.
   TestProgress progress[] = {
     { 0.f, 1.f },
     { -.25f, 1.25f },
   };
 
-  size_t num_steps = 150;
   for (size_t i = 0; i < arraysize(axes); ++i) {
     for (size_t j = 0; j < arraysize(angles); ++j) {
       for (size_t k = 0; k < arraysize(progress); ++k) {
         float x = axes[i].x;
         float y = axes[i].y;
         float z = axes[i].z;
         TransformOperations operations_from;
         operations_from.AppendRotate(x, y, z, angles[j].theta_from);
         TransformOperations operations_to;
         operations_to.AppendRotate(x, y, z, angles[j].theta_to);
-
-        gfx::BoxF box(2.f, 5.f, 6.f, 1.f, 3.f, 2.f);
-        gfx::BoxF bounds;
-
-        EXPECT_TRUE(operations_to.BlendedBoundsForBox(box,
-                                                      operations_from,
-                                                      progress[k].min_progress,
-                                                      progress[k].max_progress,
-                                                      &bounds));
-        bool first_point = true;
-        gfx::BoxF empirical_bounds;
-        for (size_t step = 0; step < num_steps; ++step) {
-          float t = step / (num_steps - 1.f);
-          t = gfx::Tween::FloatValueBetween(
-              t, progress[k].min_progress, progress[k].max_progress);
-          gfx::Transform partial_rotation =
-              operations_to.Blend(operations_from, t);
-
-          for (int corner = 0; corner < 8; ++corner) {
-            gfx::Point3F point = box.origin();
-            point += gfx::Vector3dF(corner & 1 ? box.width() : 0.f,
-                                    corner & 2 ? box.height() : 0.f,
-                                    corner & 4 ? box.depth() : 0.f);
-            partial_rotation.TransformPoint(&point);
-            if (first_point) {
-              empirical_bounds.set_origin(point);
-              first_point = false;
-            } else {
-              empirical_bounds.ExpandTo(point);
-            }
-          }
-        }
-
-        // Our empirical estimate will be a little rough since we're only doing
-        // 100 samples.
-        static const float kTolerance = 1e-2f;
-        EXPECT_NEAR(empirical_bounds.x(), bounds.x(), kTolerance);
-        EXPECT_NEAR(empirical_bounds.y(), bounds.y(), kTolerance);
-        EXPECT_NEAR(empirical_bounds.z(), bounds.z(), kTolerance);
-        EXPECT_NEAR(empirical_bounds.width(), bounds.width(), kTolerance);
-        EXPECT_NEAR(empirical_bounds.height(), bounds.height(), kTolerance);
-        EXPECT_NEAR(empirical_bounds.depth(), bounds.depth(), kTolerance);
+        EmpiricallyTestBoundsContainment(operations_from,
+                                         operations_to,
+                                         progress[k].min_progress,
+                                         progress[k].max_progress);
       }
     }
   }
 }
 
 TEST(TransformOperationTest, PerspectiveMatrixAndTransformBlendingEquivalency) {
     TransformOperations from_operations;
     from_operations.AppendPerspective(200);
 
     TransformOperations to_operations;
@@ skipping 12 matching lines @@
       gfx::Transform blended_matrix = to_transform;
       EXPECT_TRUE(blended_matrix.Blend(from_transform, progress));
 
       gfx::Transform blended_transform =
           to_operations.Blend(from_operations, progress);
 
       EXPECT_TRANSFORMATION_MATRIX_EQ(blended_matrix, blended_transform);
     }
 }
 
+struct TestPerspectiveDepths {
+  float from_depth;
+  float to_depth;
+};
+
+TEST(TransformOperationTest, BlendedBoundsForPerspective) {
+  TestPerspectiveDepths perspective_depths[] = {
+    { 600.f, 400.f },
+    { 800.f, 1000.f },
+    { 800.f, std::numeric_limits<float>::infinity() },
+  };
+
+  TestProgress progress[] = {
+    { 0.f, 1.f },
+    { -0.1f, 1.1f },
+  };
+
+  for (size_t i = 0; i < arraysize(perspective_depths); ++i) {
+    for (size_t j = 0; j < arraysize(progress); ++j) {
+      TransformOperations operations_from;
+      operations_from.AppendPerspective(perspective_depths[i].from_depth);
+      TransformOperations operations_to;
+      operations_to.AppendPerspective(perspective_depths[i].to_depth);
+      EmpiricallyTestBoundsEquality(operations_from,
+                                    operations_to,
+                                    progress[j].min_progress,
+                                    progress[j].max_progress);
+    }
+  }
+}
+
+struct TestSkews {
+  float from_x;
+  float from_y;
+  float to_x;
+  float to_y;
+};
+
+TEST(TransformOperationTest, BlendedBoundsForSkew) {
+  TestSkews skews[] = {
+    { 1.f, 0.5f, 0.5f, 1.f },
+    { 2.f, 1.f, 0.5f, 0.5f },
+  };
+
+  TestProgress progress[] = {
+    { 0.f, 1.f },
+    { -0.1f, 1.1f },
+  };
+
+  for (size_t i = 0; i < arraysize(skews); ++i) {
+    for (size_t j = 0; j < arraysize(progress); ++j) {
+      TransformOperations operations_from;
+      operations_from.AppendSkew(skews[i].from_x, skews[i].from_y);
+      TransformOperations operations_to;
+      operations_to.AppendSkew(skews[i].to_x, skews[i].to_y);
+      EmpiricallyTestBoundsEquality(operations_from,
+                                    operations_to,
+                                    progress[j].min_progress,
+                                    progress[j].max_progress);
+    }
+  }
+}
+
 TEST(TransformOperationTest, BlendedBoundsForSequence) {
   TransformOperations operations_from;
   operations_from.AppendTranslate(2.0, 4.0, -1.0);
   operations_from.AppendScale(-1.0, 2.0, 3.0);
   operations_from.AppendTranslate(1.0, -5.0, 1.0);
   TransformOperations operations_to;
   operations_to.AppendTranslate(6.0, -2.0, 3.0);
   operations_to.AppendScale(-3.0, -2.0, 5.0);
   operations_to.AppendTranslate(13.0, -1.0, 5.0);
 
@@ skipping 21 matching lines @@
             bounds.ToString());
 
   EXPECT_TRUE(identity.BlendedBoundsForBox(
         box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(-7.f, -3.f, 2.f, 15.f, 23.f, 20.f).ToString(),
             bounds.ToString());
 }
 
 }  // namespace
 }  // namespace cc