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
operator =(const RectF & rect)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
ToString() const20 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
WithinEpsilon(float a,float b)28 static inline bool WithinEpsilon(float a, float b) {
29 return std::abs(a - b) < std::numeric_limits<float>::epsilon();
30 }
31
IsRectilinear() const32 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
IsCounterClockwise() const40 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
PointIsInTriangle(const PointF & point,const PointF & r1,const PointF & r2,const PointF & r3)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 // Promote to doubles so all the math below is done with doubles, because
80 // otherwise it gets incorrect results on arm64.
81 double r31x = r31.x();
82 double r31y = r31.y();
83 double r32x = r32.x();
84 double r32y = r32.y();
85
86 double denom = r32y * r31x - r32x * r31y;
87 double u = (r32y * r3p.x() - r32x * r3p.y()) / denom;
88 double v = (r31x * r3p.y() - r31y * r3p.x()) / denom;
89 double w = 1.0 - u - v;
90
91 // Use the barycentric coordinates to test if |point| is inside the
92 // triangle (r1, r2, r2).
93 return (u >= 0) && (v >= 0) && (w >= 0);
94 }
95
Contains(const PointF & point) const96 bool QuadF::Contains(const PointF& point) const {
97 return PointIsInTriangle(point, p1_, p2_, p3_)
98 || PointIsInTriangle(point, p1_, p3_, p4_);
99 }
100
Scale(float x_scale,float y_scale)101 void QuadF::Scale(float x_scale, float y_scale) {
102 p1_.Scale(x_scale, y_scale);
103 p2_.Scale(x_scale, y_scale);
104 p3_.Scale(x_scale, y_scale);
105 p4_.Scale(x_scale, y_scale);
106 }
107
operator +=(const Vector2dF & rhs)108 void QuadF::operator+=(const Vector2dF& rhs) {
109 p1_ += rhs;
110 p2_ += rhs;
111 p3_ += rhs;
112 p4_ += rhs;
113 }
114
operator -=(const Vector2dF & rhs)115 void QuadF::operator-=(const Vector2dF& rhs) {
116 p1_ -= rhs;
117 p2_ -= rhs;
118 p3_ -= rhs;
119 p4_ -= rhs;
120 }
121
operator +(const QuadF & lhs,const Vector2dF & rhs)122 QuadF operator+(const QuadF& lhs, const Vector2dF& rhs) {
123 QuadF result = lhs;
124 result += rhs;
125 return result;
126 }
127
operator -(const QuadF & lhs,const Vector2dF & rhs)128 QuadF operator-(const QuadF& lhs, const Vector2dF& rhs) {
129 QuadF result = lhs;
130 result -= rhs;
131 return result;
132 }
133
134 } // namespace gfx
135