ui/gfx/geometry/quad_f.cc

   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
   5 #include "ui/gfx/geometry/quad_f.h"
   6
   7 #include <limits>
   8
   9 #include "base/strings/stringprintf.h"
  10
  11 namespace gfx {
  12
  13 void QuadF::operator=(const RectF& rect) {
  14   p1_ = PointF(rect.x(), rect.y());
  15   p2_ = PointF(rect.right(), rect.y());
  16   p3_ = PointF(rect.right(), rect.bottom());
  17   p4_ = PointF(rect.x(), rect.bottom());
  18 }
  19
  20 std::string QuadF::ToString() const {
  21   return base::StringPrintf("%s;%s;%s;%s",
  22                             p1_.ToString().c_str(),
  23                             p2_.ToString().c_str(),
  24                             p3_.ToString().c_str(),
  25                             p4_.ToString().c_str());
  26 }
  27
  28 static inline bool WithinEpsilon(float a, float b) {
  29   return std::abs(a - b) < std::numeric_limits<float>::epsilon();
  30 }
  31
  32 bool QuadF::IsRectilinear() const {
  33   return
  34       (WithinEpsilon(p1_.x(), p2_.x()) && WithinEpsilon(p2_.y(), p3_.y()) &&
  35        WithinEpsilon(p3_.x(), p4_.x()) && WithinEpsilon(p4_.y(), p1_.y())) ||
  36       (WithinEpsilon(p1_.y(), p2_.y()) && WithinEpsilon(p2_.x(), p3_.x()) &&
  37        WithinEpsilon(p3_.y(), p4_.y()) && WithinEpsilon(p4_.x(), p1_.x()));
  38 }
  39
  40 bool QuadF::IsCounterClockwise() const {
  41   // This math computes the signed area of the quad. Positive area
  42   // indicates the quad is clockwise; negative area indicates the quad is
  43   // counter-clockwise. Note carefully: this is backwards from conventional
  44   // math because our geometric space uses screen coordiantes with y-axis
  45   // pointing downards.
  46   // Reference: http://mathworld.wolfram.com/PolygonArea.html.
  47   // The equation can be written:
  48   // Signed area = determinant1 + determinant2 + determinant3 + determinant4
  49   // In practise, Refactoring the computation of adding determinants so that
  50   // reducing the number of operations. The equation is:
  51   // Signed area = element1 + element2 - element3 - element4
  52
  53   float p24 = p2_.y() - p4_.y();
  54   float p31 = p3_.y() - p1_.y();
  55
  56   // Up-cast to double so this cannot overflow.
  57   double element1 = static_cast<double>(p1_.x()) * p24;
  58   double element2 = static_cast<double>(p2_.x()) * p31;
  59   double element3 = static_cast<double>(p3_.x()) * p24;
  60   double element4 = static_cast<double>(p4_.x()) * p31;
  61
  62   return element1 + element2 < element3 + element4;
  63 }
  64
  65 static inline bool PointIsInTriangle(const PointF& point,
  66                                      const PointF& r1,
  67                                      const PointF& r2,
  68                                      const PointF& r3) {
  69   // Compute the barycentric coordinates (u, v, w) of |point| relative to the
  70   // triangle (r1, r2, r3) by the solving the system of equations:
  71   //   1) point = u * r1 + v * r2 + w * r3
  72   //   2) u + v + w = 1
  73   // This algorithm comes from Christer Ericson's Real-Time Collision Detection.
  74
  75   Vector2dF r31 = r1 - r3;
  76   Vector2dF r32 = r2 - r3;
  77   Vector2dF r3p = point - r3;
  78
  79   float denom = r32.y() * r31.x() - r32.x() * r31.y();
  80   float u = (r32.y() * r3p.x() - r32.x() * r3p.y()) / denom;
  81   float v = (r31.x() * r3p.y() - r31.y() * r3p.x()) / denom;
  82   float w = 1.f - u - v;
  83
  84   // Use the barycentric coordinates to test if |point| is inside the
  85   // triangle (r1, r2, r2).
  86   return (u >= 0) && (v >= 0) && (w >= 0);
  87 }
  88
  89 bool QuadF::Contains(const PointF& point) const {
  90   return PointIsInTriangle(point, p1_, p2_, p3_)
  91       || PointIsInTriangle(point, p1_, p3_, p4_);
  92 }
  93
  94 void QuadF::Scale(float x_scale, float y_scale) {
  95   p1_.Scale(x_scale, y_scale);
  96   p2_.Scale(x_scale, y_scale);
  97   p3_.Scale(x_scale, y_scale);
  98   p4_.Scale(x_scale, y_scale);
  99 }
 100
 101 void QuadF::operator+=(const Vector2dF& rhs) {
 102   p1_ += rhs;
 103   p2_ += rhs;
 104   p3_ += rhs;
 105   p4_ += rhs;
 106 }
 107
 108 void QuadF::operator-=(const Vector2dF& rhs) {
 109   p1_ -= rhs;
 110   p2_ -= rhs;
 111   p3_ -= rhs;
 112   p4_ -= rhs;
 113 }
 114
 115 QuadF operator+(const QuadF& lhs, const Vector2dF& rhs) {
 116   QuadF result = lhs;
 117   result += rhs;
 118   return result;
 119 }
 120
 121 QuadF operator-(const QuadF& lhs, const Vector2dF& rhs) {
 122   QuadF result = lhs;
 123   result -= rhs;
 124   return result;
 125 }
 126
 127 }  // namespace gfx