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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
/*
* 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;
double fY;
void set(const SkVector& pt) {
fX = pt.fX;
fY = pt.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;
}
// similar to cross, this bastardization considers nearly coincident to be zero
double crossCheck(const SkDVector& a) const {
double xy = fX * a.fY;
double yx = fY * a.fX;
return AlmostEqualUlps(xy, yx) ? 0 : xy - yx;
}
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 into account
bool approximatelyEqual(const SkDPoint& a) const {
if (approximately_equal(fX, a.fX) && approximately_equal(fY, a.fY)) {
return true;
}
if (!RoughlyEqualUlps(fX, a.fX) || !RoughlyEqualUlps(fY, a.fY)) {
return false;
}
double dist = distance(a); // OPTIMIZATION: can we compare against distSq instead ?
double tiniest = SkTMin(SkTMin(SkTMin(fX, a.fX), fY), a.fY);
double largest = SkTMax(SkTMax(SkTMax(fX, a.fX), fY), a.fY);
largest = SkTMax(largest, -tiniest);
return AlmostBequalUlps(largest, largest + dist); // is the dist within ULPS tolerance?
}
bool approximatelyEqual(const SkPoint& a) const {
SkDPoint dA;
dA.set(a);
return approximatelyEqual(dA);
}
static bool ApproximatelyEqual(const SkPoint& a, const SkPoint& b) {
if (approximately_equal(a.fX, b.fX) && approximately_equal(a.fY, b.fY)) {
return true;
}
if (!RoughlyEqualUlps(a.fX, b.fX) || !RoughlyEqualUlps(a.fY, b.fY)) {
return false;
}
SkDPoint dA, dB;
dA.set(a);
dB.set(b);
double dist = dA.distance(dB); // OPTIMIZATION: can we compare against distSq instead ?
float tiniest = SkTMin(SkTMin(SkTMin(a.fX, b.fX), a.fY), b.fY);
float largest = SkTMax(SkTMax(SkTMax(a.fX, b.fX), a.fY), b.fY);
largest = SkTMax(largest, -tiniest);
return AlmostBequalUlps((double) largest, largest + dist); // is dist within ULPS tolerance?
}
static bool RoughlyEqual(const SkPoint& a, const SkPoint& b) {
if (approximately_equal(a.fX, b.fX) && approximately_equal(a.fY, b.fY)) {
return true;
}
return RoughlyEqualUlps(a.fX, b.fX) && RoughlyEqualUlps(a.fY, b.fY);
}
bool approximatelyPEqual(const SkDPoint& a) const {
if (approximately_equal(fX, a.fX) && approximately_equal(fY, a.fY)) {
return true;
}
if (!RoughlyEqualUlps(fX, a.fX) || !RoughlyEqualUlps(fY, a.fY)) {
return false;
}
double dist = distance(a); // OPTIMIZATION: can we compare against distSq instead ?
double tiniest = SkTMin(SkTMin(SkTMin(fX, a.fX), fY), a.fY);
double largest = SkTMax(SkTMax(SkTMax(fX, a.fX), fY), a.fY);
largest = SkTMax(largest, -tiniest);
return AlmostPequalUlps(largest, largest + dist); // is the dist within ULPS tolerance?
}
bool approximatelyDEqual(const SkDPoint& a) const {
if (approximately_equal(fX, a.fX) && approximately_equal(fY, a.fY)) {
return true;
}
if (!RoughlyEqualUlps(fX, a.fX) || !RoughlyEqualUlps(fY, a.fY)) {
return false;
}
double dist = distance(a); // OPTIMIZATION: can we compare against distSq instead ?
double tiniest = SkTMin(SkTMin(SkTMin(fX, a.fX), fY), a.fY);
double largest = SkTMax(SkTMax(SkTMax(fX, a.fX), fY), a.fY);
largest = SkTMax(largest, -tiniest);
return AlmostDequalUlps(largest, largest + dist); // is the dist within ULPS tolerance?
}
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();
}
static SkDPoint Mid(const SkDPoint& a, const SkDPoint& b) {
SkDPoint result;
result.fX = (a.fX + b.fX) / 2;
result.fY = (a.fY + b.fY) / 2;
return result;
}
bool moreRoughlyEqual(const SkDPoint& a) const {
if (roughly_equal(fX, a.fX) && roughly_equal(fY, a.fY)) {
return true;
}
double dist = distance(a); // OPTIMIZATION: can we compare against distSq instead ?
double tiniest = SkTMin(SkTMin(SkTMin(fX, a.fX), fY), a.fY);
double largest = SkTMax(SkTMax(SkTMax(fX, a.fX), fY), a.fY);
largest = SkTMax(largest, -tiniest);
return RoughlyEqualUlps(largest, largest + dist); // is the dist within ULPS tolerance?
}
bool roughlyEqual(const SkDPoint& a) const {
return roughly_equal(a.fY, fY) && roughly_equal(a.fX, fX);
}
// utilities callable by the user from the debugger when the implementation code is linked in
void dump() const;
static void Dump(const SkPoint& pt);
static void DumpHex(const SkPoint& pt);
};
#endif
|
