1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkPathOpsPoint_DEFINED
#define SkPathOpsPoint_DEFINED
#include "SkPathOpsTypes.h"
#include "SkPoint.h"
inline bool AlmostEqualUlps(const SkPoint& pt1, const SkPoint& pt2) {
return AlmostEqualUlps(pt1.fX, pt2.fX) && AlmostEqualUlps(pt1.fY, pt2.fY);
}
struct SkDVector {
double fX, fY;
friend SkDPoint operator+(const SkDPoint& a, const SkDVector& b);
void operator+=(const SkDVector& v) {
fX += v.fX;
fY += v.fY;
}
void operator-=(const SkDVector& v) {
fX -= v.fX;
fY -= v.fY;
}
void operator/=(const double s) {
fX /= s;
fY /= s;
}
void operator*=(const double s) {
fX *= s;
fY *= s;
}
SkVector asSkVector() const {
SkVector v = {SkDoubleToScalar(fX), SkDoubleToScalar(fY)};
return v;
}
double cross(const SkDVector& a) const {
return fX * a.fY - fY * a.fX;
}
double dot(const SkDVector& a) const {
return fX * a.fX + fY * a.fY;
}
double length() const {
return sqrt(lengthSquared());
}
double lengthSquared() const {
return fX * fX + fY * fY;
}
};
struct SkDPoint {
double fX;
double fY;
void set(const SkPoint& pt) {
fX = pt.fX;
fY = pt.fY;
}
friend SkDVector operator-(const SkDPoint& a, const SkDPoint& b);
friend bool operator==(const SkDPoint& a, const SkDPoint& b) {
return a.fX == b.fX && a.fY == b.fY;
}
friend bool operator!=(const SkDPoint& a, const SkDPoint& b) {
return a.fX != b.fX || a.fY != b.fY;
}
void operator=(const SkPoint& pt) {
fX = pt.fX;
fY = pt.fY;
}
void operator+=(const SkDVector& v) {
fX += v.fX;
fY += v.fY;
}
void operator-=(const SkDVector& v) {
fX -= v.fX;
fY -= v.fY;
}
// note: this can not be implemented with
// return approximately_equal(a.fY, fY) && approximately_equal(a.fX, fX);
// because that will not take the magnitude of the values
bool approximatelyEqual(const SkDPoint& a) const {
double denom = SkTMax(fabs(fX), SkTMax(fabs(fY),
SkTMax(fabs(a.fX), fabs(a.fY))));
if (denom == 0) {
return true;
}
double inv = 1 / denom;
return approximately_equal(fX * inv, a.fX * inv)
&& approximately_equal(fY * inv, a.fY * inv);
}
bool approximatelyEqual(const SkPoint& a) const {
double denom = SkTMax(fabs(fX), SkTMax(fabs(fY),
SkScalarToDouble(SkTMax(fabsf(a.fX), fabsf(a.fY)))));
if (denom == 0) {
return true;
}
double inv = 1 / denom;
return approximately_equal(fX * inv, a.fX * inv)
&& approximately_equal(fY * inv, a.fY * inv);
}
bool approximatelyEqualHalf(const SkDPoint& a) const {
double denom = SkTMax(fabs(fX), SkTMax(fabs(fY),
SkTMax(fabs(a.fX), fabs(a.fY))));
if (denom == 0) {
return true;
}
double inv = 1 / denom;
return approximately_equal_half(fX * inv, a.fX * inv)
&& approximately_equal_half(fY * inv, a.fY * inv);
}
bool approximatelyZero() const {
return approximately_zero(fX) && approximately_zero(fY);
}
SkPoint asSkPoint() const {
SkPoint pt = {SkDoubleToScalar(fX), SkDoubleToScalar(fY)};
return pt;
}
double distance(const SkDPoint& a) const {
SkDVector temp = *this - a;
return temp.length();
}
double distanceSquared(const SkDPoint& a) const {
SkDVector temp = *this - a;
return temp.lengthSquared();
}
double moreRoughlyEqual(const SkDPoint& a) const {
return more_roughly_equal(a.fY, fY) && more_roughly_equal(a.fX, fX);
}
double roughlyEqual(const SkDPoint& a) const {
return roughly_equal(a.fY, fY) && roughly_equal(a.fX, fX);
}
};
#endif
|
