Don't add duplicate points when clipping

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>
 #ifdef __SSE__
@@ skipping 137 matching lines @@
                                               float* xmax,
                                               float* ymin,
                                               float* ymax,
                                               const gfx::PointF& p) {
   *xmin = std::min(p.x(), *xmin);
   *xmax = std::max(p.x(), *xmax);
   *ymin = std::min(p.y(), *ymin);
   *ymax = std::max(p.y(), *ymax);
 }
 
+static inline bool approx(const float f, const float g) {

[flackr, 2016/12/08 23:31:06]

Maybe approximatelyEqual to be verbose?

[Peter Mayo, 2016/12/14 23:13:11]

I think nearlyTheSame covers all of the overloaded functions more consistently.
One of the advantages of the abbreviation was that it fit many readings of the
conditions for the different types.

+  static const float epsilon_scale = 0.00001;

[flackr, 2016/12/08 23:31:06]

nit: 0.00001f

[Peter Mayo, 2016/12/14 23:13:11]

Acknowledged.

+  return std::abs(f - g) <

[flackr, 2016/12/08 23:31:06]

nit: I think <= might be safer in case of precision errors.

[Peter Mayo, 2016/12/14 23:13:11]

I worry that it would worsely cover over inappropriately close tolerances.
It seems that if you are sensitive to the last possible mantissa value you have
missed the point of using the function.

Having < without the = highlighted the problems around zero earlier, rather than
later.  I think it would be better to dodge that sort of pitfall earlier in the
future too.

+         epsilon_scale *
+             std::max(std::max(std::abs(f), std::abs(g)), epsilon_scale);
+}
+
+static inline bool approx(const gfx::PointF& lhs, const gfx::PointF& rhs) {
+  return approx(lhs.x(), rhs.x()) && approx(lhs.y(), rhs.y());
+}
+
+static inline bool approx(const gfx::Point3F& lhs, const gfx::Point3F& rhs) {
+  return approx(lhs.x(), rhs.x()) && approx(lhs.y(), rhs.y()) &&
+         approx(lhs.z(), rhs.z());
+}
+
 static inline void AddVertexToClippedQuad(const gfx::PointF& new_vertex,
                                           gfx::PointF clipped_quad[8],
                                           int* num_vertices_in_clipped_quad) {
+  if (*num_vertices_in_clipped_quad > 0) {
+    if (approx(clipped_quad[*num_vertices_in_clipped_quad - 1], new_vertex))
+      return;
+    if (approx(clipped_quad[0], new_vertex))
+      return;
+  }
   clipped_quad[*num_vertices_in_clipped_quad] = new_vertex;
   (*num_vertices_in_clipped_quad)++;
 }
 
 static inline void AddVertexToClippedQuad3d(const gfx::Point3F& new_vertex,
                                             gfx::Point3F clipped_quad[8],
                                             int* num_vertices_in_clipped_quad) {
+  if (*num_vertices_in_clipped_quad > 0) {
+    if (approx(clipped_quad[*num_vertices_in_clipped_quad - 1], new_vertex))
+      return;
+    if (approx(clipped_quad[0], new_vertex))
+      return;
+  }
   clipped_quad[*num_vertices_in_clipped_quad] = new_vertex;
   (*num_vertices_in_clipped_quad)++;
 }
 
 gfx::Rect MathUtil::MapEnclosingClippedRect(const gfx::Transform& transform,
                                             const gfx::Rect& src_rect) {
   if (transform.IsIdentityOrIntegerTranslation()) {
     gfx::Vector2d offset(static_cast<int>(transform.matrix().getFloat(0, 3)),
                          static_cast<int>(transform.matrix().getFloat(1, 3)));
     return src_rect + offset;
@@ skipping 750 matching lines @@
   _mm_setcsr(orig_state_ | 0x8040);
 #endif
 }
 
 ScopedSubnormalFloatDisabler::~ScopedSubnormalFloatDisabler() {
 #ifdef __SSE__
   _mm_setcsr(orig_state_);
 #endif
 }
 
+bool IsApproximatelyForUnitTesting(const float left, const float right) {
+  return approx(left, right);
+}
+
+bool IsApproximatelyForUnitTesting(const gfx::PointF& left,
+                                   const gfx::PointF& right) {
+  return approx(left, right);
+}
+
+bool IsApproximatelyForUnitTesting(const gfx::Point3F& left,
+                                   const gfx::Point3F& right) {
+  return approx(left, right);
+}
+
 }  // namespace cc