Provide approximate type functions for SkMatrix44.

cc/base/math_util.cc

 // Copyright 2012 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 "cc/base/math_util.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
 #include "base/values.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/rect_f.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d_f.h"
 
 namespace cc {
+namespace {
+
+inline bool ApproximatelyZero(SkMScalar x, SkMScalar tolerance) {
+  DCHECK_GE(tolerance, 0);
+  return std::abs(x) <= tolerance;
+}
+
+inline bool ApproximatelyOne(SkMScalar x, SkMScalar tolerance) {
+  DCHECK_GE(tolerance, 0);
+  return std::abs(x-SkDoubleToMScalar(1.0)) <= tolerance;

[danakj, 2013/10/16 19:04:14]

spaces around -

+}
+
+}  // namespace
 
 const double MathUtil::kPiDouble = 3.14159265358979323846;
 const float MathUtil::kPiFloat = 3.14159265358979323846f;
 
 static HomogeneousCoordinate ProjectHomogeneousPoint(
     const gfx::Transform& transform,
     gfx::PointF p) {
   // In this case, the layer we are trying to project onto is perpendicular to
   // ray (point p and z-axis direction) that we are trying to project. This
   // happens when the layer is rotated so that it is infinitesimally thin, or
@@ skipping 556 matching lines @@
 scoped_ptr<base::Value> MathUtil::AsValueSafely(double value) {
   return scoped_ptr<base::Value>(base::Value::CreateDoubleValue(
       std::min(value, std::numeric_limits<double>::max())));
 }
 
 scoped_ptr<base::Value> MathUtil::AsValueSafely(float value) {
   return scoped_ptr<base::Value>(base::Value::CreateDoubleValue(
       std::min(value, std::numeric_limits<float>::max())));
 }
 
+bool MathUtil::IsApproximatelyPureTranslation(
+    const gfx::Transform& transform, SkMScalar tolerance) {
+  return IsMatrixApproximatelyPureTranslation(transform.matrix(), tolerance);
+}
+
+bool MathUtil::IsMatrixApproximatelyPureTranslation(const SkMatrix44& matrix,
+                                                    SkMScalar tolerance) {
+  return
+      ApproximatelyOne(matrix.get(0, 0), tolerance) &&
+      ApproximatelyZero(matrix.get(1, 0), tolerance) &&
+      ApproximatelyZero(matrix.get(2, 0), tolerance) &&
+      matrix.get(3, 0) == 0 &&
+      ApproximatelyZero(matrix.get(0, 1), tolerance) &&
+      ApproximatelyOne(matrix.get(1, 1), tolerance) &&
+      ApproximatelyZero(matrix.get(2, 1), tolerance) &&
+      matrix.get(3, 1) == 0 &&
+      ApproximatelyZero(matrix.get(0, 2), tolerance) &&
+      ApproximatelyZero(matrix.get(1, 2), tolerance) &&
+      ApproximatelyOne(matrix.get(2, 2), tolerance) &&
+      matrix.get(3, 2) == 0 &&
+      matrix.get(3, 3) == 1;
+}
+
 }  // namespace cc