interpolated_transform_unittest.cc 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ui/gfx/interpolated_transform.h"
  5. #include "testing/gtest/include/gtest/gtest.h"
  6. #include "ui/gfx/geometry/rect.h"
  7. namespace {
  8. void CheckApproximatelyEqual(const gfx::Transform& lhs,
  9. const gfx::Transform& rhs) {
  10. for (int i = 0; i < 4; ++i) {
  11. for (int j = 0; j < 4; ++j) {
  12. EXPECT_FLOAT_EQ(lhs.matrix().rc(i, j), rhs.matrix().rc(i, j));
  13. }
  14. }
  15. }
  16. } // namespace
  17. TEST(InterpolatedTransformTest, InterpolatedRotation) {
  18. ui::InterpolatedRotation interpolated_rotation(0, 100);
  19. ui::InterpolatedRotation interpolated_rotation_diff_start_end(
  20. 0, 100, 100, 200);
  21. for (int i = 0; i <= 100; ++i) {
  22. gfx::Transform rotation;
  23. rotation.Rotate(i);
  24. gfx::Transform interpolated = interpolated_rotation.Interpolate(i / 100.0f);
  25. CheckApproximatelyEqual(rotation, interpolated);
  26. interpolated = interpolated_rotation_diff_start_end.Interpolate(i + 100);
  27. CheckApproximatelyEqual(rotation, interpolated);
  28. }
  29. }
  30. TEST(InterpolatedTransformTest, InterpolatedScale) {
  31. ui::InterpolatedScale interpolated_scale(gfx::Point3F(0, 0, 0),
  32. gfx::Point3F(100, 100, 100));
  33. ui::InterpolatedScale interpolated_scale_diff_start_end(
  34. gfx::Point3F(0, 0, 0), gfx::Point3F(100, 100, 100), 100, 200);
  35. for (int i = 0; i <= 100; ++i) {
  36. gfx::Transform scale;
  37. scale.Scale3d(i, i, i);
  38. gfx::Transform interpolated = interpolated_scale.Interpolate(i / 100.0f);
  39. CheckApproximatelyEqual(scale, interpolated);
  40. interpolated = interpolated_scale_diff_start_end.Interpolate(i + 100);
  41. CheckApproximatelyEqual(scale, interpolated);
  42. }
  43. }
  44. TEST(InterpolatedTransformTest, InterpolatedTranslate) {
  45. ui::InterpolatedTranslation interpolated_xform(gfx::PointF(),
  46. gfx::PointF(100.f, 100.f));
  47. ui::InterpolatedTranslation interpolated_xform_diff_start_end(
  48. gfx::PointF(), gfx::PointF(100.f, 100.f), 100, 200);
  49. for (int i = 0; i <= 100; ++i) {
  50. gfx::Transform xform;
  51. xform.Translate(i, i);
  52. gfx::Transform interpolated = interpolated_xform.Interpolate(i / 100.0f);
  53. CheckApproximatelyEqual(xform, interpolated);
  54. interpolated = interpolated_xform_diff_start_end.Interpolate(i + 100);
  55. CheckApproximatelyEqual(xform, interpolated);
  56. }
  57. }
  58. TEST(InterpolatedTransformTest, InterpolatedTranslate3d) {
  59. ui::InterpolatedTranslation interpolated_xform(gfx::Point3F(0, 0, 0),
  60. gfx::Point3F(100, 100, 100));
  61. ui::InterpolatedTranslation interpolated_xform_diff_start_end(
  62. gfx::Point3F(0, 0, 0), gfx::Point3F(100, 100, 100), 100, 200);
  63. for (int i = 0; i <= 100; ++i) {
  64. gfx::Transform xform;
  65. xform.Translate3d(i, i, i);
  66. gfx::Transform interpolated = interpolated_xform.Interpolate(i / 100.0f);
  67. CheckApproximatelyEqual(xform, interpolated);
  68. interpolated = interpolated_xform_diff_start_end.Interpolate(i + 100);
  69. CheckApproximatelyEqual(xform, interpolated);
  70. }
  71. }
  72. TEST(InterpolatedTransformTest, InterpolatedRotationAboutPivot) {
  73. gfx::Point pivot(100, 100);
  74. gfx::Point above_pivot(100, 200);
  75. ui::InterpolatedRotation rot(0, 90);
  76. ui::InterpolatedTransformAboutPivot interpolated_xform(
  77. pivot, std::make_unique<ui::InterpolatedRotation>(0, 90));
  78. gfx::Transform result = interpolated_xform.Interpolate(0.0f);
  79. CheckApproximatelyEqual(gfx::Transform(), result);
  80. result = interpolated_xform.Interpolate(1.0f);
  81. gfx::Point expected_result = pivot;
  82. result.TransformPoint(&pivot);
  83. EXPECT_EQ(expected_result, pivot);
  84. expected_result = gfx::Point(0, 100);
  85. result.TransformPoint(&above_pivot);
  86. EXPECT_EQ(expected_result, above_pivot);
  87. }
  88. TEST(InterpolatedTransformTest, InterpolatedScaleAboutPivot) {
  89. gfx::Point pivot(100, 100);
  90. gfx::Point above_pivot(100, 200);
  91. ui::InterpolatedTransformAboutPivot interpolated_xform(
  92. pivot, std::make_unique<ui::InterpolatedScale>(gfx::Point3F(1, 1, 1),
  93. gfx::Point3F(2, 2, 2)));
  94. gfx::Transform result = interpolated_xform.Interpolate(0.0f);
  95. CheckApproximatelyEqual(gfx::Transform(), result);
  96. result = interpolated_xform.Interpolate(1.0f);
  97. gfx::Point expected_result = pivot;
  98. result.TransformPoint(&pivot);
  99. EXPECT_EQ(expected_result, pivot);
  100. expected_result = gfx::Point(100, 300);
  101. result.TransformPoint(&above_pivot);
  102. EXPECT_EQ(expected_result, above_pivot);
  103. }
  104. ui::InterpolatedTransform* GetScreenRotation(int degrees, bool reversed) {
  105. gfx::Point old_pivot;
  106. gfx::Point new_pivot;
  107. int width = 1920;
  108. int height = 180;
  109. switch (degrees) {
  110. case 90:
  111. new_pivot = gfx::Point(width, 0);
  112. break;
  113. case -90:
  114. new_pivot = gfx::Point(0, height);
  115. break;
  116. case 180:
  117. case 360:
  118. new_pivot = old_pivot = gfx::Point(width / 2, height / 2);
  119. break;
  120. }
  121. std::unique_ptr<ui::InterpolatedTransform> rotation =
  122. std::make_unique<ui::InterpolatedTransformAboutPivot>(
  123. old_pivot, std::make_unique<ui::InterpolatedRotation>(
  124. reversed ? degrees : 0, reversed ? 0 : degrees));
  125. std::unique_ptr<ui::InterpolatedTransform> translation =
  126. std::make_unique<ui::InterpolatedTranslation>(
  127. gfx::PointF(), gfx::PointF(new_pivot.x() - old_pivot.x(),
  128. new_pivot.y() - old_pivot.y()));
  129. float scale_factor = 0.9f;
  130. std::unique_ptr<ui::InterpolatedTransform> scale_down =
  131. std::make_unique<ui::InterpolatedScale>(1.0f, scale_factor, 0.0f, 0.5f);
  132. std::unique_ptr<ui::InterpolatedTransform> scale_up =
  133. std::make_unique<ui::InterpolatedScale>(1.0f, 1.0f / scale_factor, 0.5f,
  134. 1.0f);
  135. std::unique_ptr<ui::InterpolatedTransform> to_return =
  136. std::make_unique<ui::InterpolatedConstantTransform>(gfx::Transform());
  137. scale_up->SetChild(std::move(scale_down));
  138. translation->SetChild(std::move(scale_up));
  139. rotation->SetChild(std::move(translation));
  140. to_return->SetChild(std::move(rotation));
  141. to_return->SetReversed(reversed);
  142. return to_return.release();
  143. }
  144. TEST(InterpolatedTransformTest, ScreenRotationEndsCleanly) {
  145. for (int i = 0; i < 2; ++i) {
  146. for (int degrees = -360; degrees <= 360; degrees += 90) {
  147. const bool reversed = i == 1;
  148. std::unique_ptr<ui::InterpolatedTransform> screen_rotation(
  149. GetScreenRotation(degrees, reversed));
  150. gfx::Transform interpolated = screen_rotation->Interpolate(1.0f);
  151. // Upper-left 3x3 matrix should all be 0, 1 or -1.
  152. for (int row = 0; row < 3; ++row) {
  153. for (int col = 0; col < 3; ++col) {
  154. float entry = interpolated.matrix().rc(row, col);
  155. EXPECT_TRUE(entry == 0 || entry == 1 || entry == -1);
  156. }
  157. }
  158. }
  159. }
  160. }
  161. ui::InterpolatedTransform* GetMaximize() {
  162. gfx::Rect target_bounds(0, 0, 1920, 1080);
  163. gfx::Rect initial_bounds(30, 1000, 192, 108);
  164. float scale_x = static_cast<float>(
  165. target_bounds.height()) / initial_bounds.width();
  166. float scale_y = static_cast<float>(
  167. target_bounds.width()) / initial_bounds.height();
  168. std::unique_ptr<ui::InterpolatedTransform> scale =
  169. std::make_unique<ui::InterpolatedScale>(
  170. gfx::Point3F(1, 1, 1), gfx::Point3F(scale_x, scale_y, 1));
  171. std::unique_ptr<ui::InterpolatedTransform> translation =
  172. std::make_unique<ui::InterpolatedTranslation>(
  173. gfx::PointF(), gfx::PointF(target_bounds.x() - initial_bounds.x(),
  174. target_bounds.y() - initial_bounds.y()));
  175. std::unique_ptr<ui::InterpolatedTransform> rotation =
  176. std::make_unique<ui::InterpolatedRotation>(0, 4.0f);
  177. std::unique_ptr<ui::InterpolatedTransform> rotation_about_pivot(
  178. std::make_unique<ui::InterpolatedTransformAboutPivot>(
  179. gfx::Point(initial_bounds.width() * 0.5,
  180. initial_bounds.height() * 0.5),
  181. std::move(rotation)));
  182. scale->SetChild(std::move(translation));
  183. rotation_about_pivot->SetChild(std::move(scale));
  184. rotation_about_pivot->SetReversed(true);
  185. return rotation_about_pivot.release();
  186. }
  187. TEST(InterpolatedTransformTest, MaximizeEndsCleanly) {
  188. std::unique_ptr<ui::InterpolatedTransform> maximize(GetMaximize());
  189. gfx::Transform interpolated = maximize->Interpolate(1.0f);
  190. // Upper-left 3x3 matrix should all be 0, 1 or -1.
  191. for (int row = 0; row < 3; ++row) {
  192. for (int col = 0; col < 3; ++col) {
  193. float entry = interpolated.matrix().rc(row, col);
  194. EXPECT_TRUE(entry == 0 || entry == 1 || entry == -1);
  195. }
  196. }
  197. }