Flutter Engine
The Flutter Engine
PathOpsConicIntersectionTest.cpp
Go to the documentation of this file.
1/*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7#include "include/core/SkPoint.h"
8#include "include/core/SkScalar.h"
9#include "include/core/SkTypes.h"
10#include "src/core/SkGeometry.h"
11#include "src/pathops/SkIntersections.h"
12#include "src/pathops/SkPathOpsConic.h"
13#include "src/pathops/SkPathOpsPoint.h"
14#include "src/pathops/SkPathOpsQuad.h"
15#include "src/pathops/SkPathOpsTypes.h"
16#include "tests/PathOpsTestCommon.h"
17#include "tests/Test.h"
18
19#include <array>
20
21/*
22manually compute the intersection of a pair of circles and see if the conic intersection matches
23 given two circles
24 construct a line connecting their centers
25
26 */
27
28static const ConicPts testSet[] = {
29 {{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
30 {{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
31
32 {{{{5.1114602088928223, 628.77813720703125},
33 {10.834027290344238, 988.964111328125},
34 {163.40835571289062, 988.964111328125}}}, 0.72944212f},
35 {{{{163.40835571289062, 988.964111328125},
36 {5, 988.964111328125},
37 {5, 614.7423095703125}}}, 0.707106769f},
38
39 {{{{11.17222976684570312, -8.103978157043457031},
40 {22.91432571411132812, -10.37866020202636719},
41 {23.7764129638671875, -7.725424289703369141}}}, 1.00862849f},
42 {{{{-1.545085430145263672, -4.755282402038574219},
43 {22.23132705688476562, -12.48070907592773438},
44 {23.7764129638671875, -7.725427150726318359}}}, 0.707106769f},
45
46 {{{{-4,1}, {-4,5}, {0,5}}}, 0.707106769f},
47 {{{{-3,4}, {-3,1}, {0,1}}}, 0.707106769f},
48
49 {{{{0, 0}, {0, 1}, {1, 1}}}, 0.5f},
50 {{{{1, 0}, {0, 0}, {0, 1}}}, 0.5f},
51
52};
53
54const int testSetCount = (int) std::size(testSet);
55
56static void chopCompare(const SkConic chopped[2], const SkDConic dChopped[2]) {
57 SkASSERT(roughly_equal(chopped[0].fW, dChopped[0].fWeight));
58 SkASSERT(roughly_equal(chopped[1].fW, dChopped[1].fWeight));
59 for (int cIndex = 0; cIndex < 2; ++cIndex) {
60 for (int pIndex = 0; pIndex < 3; ++pIndex) {
61 SkDPoint up;
62 up.set(chopped[cIndex].fPts[pIndex]);
63 SkASSERT(dChopped[cIndex].fPts[pIndex].approximatelyEqual(up));
64 }
65 }
66#if DEBUG_VISUALIZE_CONICS
67 dChopped[0].dump();
68 dChopped[1].dump();
69#endif
70}
71
72#define DEBUG_VISUALIZE_CONICS 0
73
74#if DEBUG_VISUALIZE_CONICS
75#include "include/core/SkBitmap.h"
76#include "include/core/SkCanvas.h"
77#include "include/core/SkPaint.h"
78#include "include/core/SkString.h"
79#include "src/pathops/SkPathOpsRect.h"
80
81static void writePng(const SkConic& c, const SkConic ch[2], const char* name) {
82 const int scale = 10;
83 SkConic conic, chopped[2];
84 for (int index = 0; index < 3; ++index) {
85 conic.fPts[index].fX = c.fPts[index].fX * scale;
86 conic.fPts[index].fY = c.fPts[index].fY * scale;
87 for (int chIndex = 0; chIndex < 2; ++chIndex) {
88 chopped[chIndex].fPts[index].fX = ch[chIndex].fPts[index].fX * scale;
89 chopped[chIndex].fPts[index].fY = ch[chIndex].fPts[index].fY * scale;
90 }
91 }
92 conic.fW = c.fW;
93 chopped[0].fW = ch[0].fW;
94 chopped[1].fW = ch[1].fW;
95 SkBitmap bitmap;
96 SkRect bounds;
97 conic.computeTightBounds(&bounds);
98 bounds.outset(10, 10);
99 bitmap.tryAllocPixels(SkImageInfo::MakeN32Premul(
100 SkScalarRoundToInt(bounds.width()), SkScalarRoundToInt(bounds.height())));
101 SkCanvas canvas(bitmap);
102 SkPaint paint;
103 paint.setAntiAlias(true);
104 paint.setStyle(SkPaint::kStroke_Style);
105 canvas.translate(-bounds.fLeft, -bounds.fTop);
106 canvas.drawColor(SK_ColorWHITE);
107 SkPath path;
108 path.moveTo(conic.fPts[0]);
109 path.conicTo(conic.fPts[1], conic.fPts[2], conic.fW);
110 paint.setARGB(0x80, 0xFF, 0, 0);
111 canvas.drawPath(path, paint);
112 path.reset();
113 path.moveTo(chopped[0].fPts[0]);
114 path.conicTo(chopped[0].fPts[1], chopped[0].fPts[2], chopped[0].fW);
115 path.moveTo(chopped[1].fPts[0]);
116 path.conicTo(chopped[1].fPts[1], chopped[1].fPts[2], chopped[1].fW);
117 paint.setARGB(0x80, 0, 0, 0xFF);
118 canvas.drawPath(path, paint);
119 SkString filename("c:\\Users\\caryclark\\Documents\\");
120 filename.appendf("%s.png", name);
121 ToolUtils::EncodeImageToPngFile(filename.c_str(), bitmap);
122}
123
124static void writeDPng(const SkDConic& dC, const char* name) {
125 const int scale = 5;
126 SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
127 {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
128 {dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
129 SkBitmap bitmap;
130 SkDRect bounds;
131 bounds.setBounds(dConic);
132 bounds.fLeft -= 10;
133 bounds.fTop -= 10;
134 bounds.fRight += 10;
135 bounds.fBottom += 10;
136 bitmap.tryAllocPixels(SkImageInfo::MakeN32Premul(
137 SkScalarRoundToInt(SkDoubleToScalar(bounds.width())),
138 SkScalarRoundToInt(SkDoubleToScalar(bounds.height()))));
139 SkCanvas canvas(bitmap);
140 SkPaint paint;
141 paint.setAntiAlias(true);
142 paint.setStyle(SkPaint::kStroke_Style);
143 canvas.translate(SkDoubleToScalar(-bounds.fLeft), SkDoubleToScalar(-bounds.fTop));
144 canvas.drawColor(SK_ColorWHITE);
145 SkPath path;
146 path.moveTo(dConic.fPts[0].asSkPoint());
147 path.conicTo(dConic.fPts[1].asSkPoint(), dConic.fPts[2].asSkPoint(), dConic.fWeight);
148 paint.setARGB(0x80, 0xFF, 0, 0);
149 canvas.drawPath(path, paint);
150 path.reset();
151 const int chops = 2;
152 for (int tIndex = 0; tIndex < chops; ++tIndex) {
153 SkDConic chopped = dConic.subDivide(tIndex / (double) chops,
154 (tIndex + 1) / (double) chops);
155 path.moveTo(chopped.fPts[0].asSkPoint());
156 path.conicTo(chopped.fPts[1].asSkPoint(), chopped.fPts[2].asSkPoint(), chopped.fWeight);
157 }
158 paint.setARGB(0x80, 0, 0, 0xFF);
159 canvas.drawPath(path, paint);
160 SkString filename("c:\\Users\\caryclark\\Documents\\");
161 filename.appendf("%s.png", name);
162 ToolUtils::EncodeImageToPngFile(filename.c_str(), bitmap);
163}
164#endif
165
166static void chopBothWays(const SkDConic& dConic, double t, const char* name) {
167 SkConic conic;
168 for (int index = 0; index < 3; ++index) {
169 conic.fPts[index] = dConic.fPts[index].asSkPoint();
170 }
171 conic.fW = dConic.fWeight;
172 SkConic chopped[2];
173 SkDConic dChopped[2];
174 if (!conic.chopAt(SkDoubleToScalar(t), chopped)) {
175 return;
176 }
177 dChopped[0] = dConic.subDivide(0, t);
178 dChopped[1] = dConic.subDivide(t, 1);
179#if DEBUG_VISUALIZE_CONICS
180 dConic.dump();
181#endif
182 chopCompare(chopped, dChopped);
183#if DEBUG_VISUALIZE_CONICS
184 writePng(conic, chopped, name);
185#endif
186}
187
188#if DEBUG_VISUALIZE_CONICS
189const SkDConic frame0[] = {
190{{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
191{{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
192};
193
194const SkDConic frame1[] = {
195{{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
196{{{{306.58801299999999, -227.983994}, {212.46499600000001, -262.24200400000001}, {95.551200899999998, 58.976398500000002}}}, 0.707107008f},
197{{{{377.21899400000001, -141.98100299999999}, {237.77799285476553, -166.56830755921084}, {134.08399674208422, -155.06258330544892}}}, 0.788580656f},
198{{{{134.08399674208422, -155.06258330544892}, {30.390000629402859, -143.55685905168704}, {23.185499199999999, -102.697998}}}, 0.923879623f},
199};
200
201const SkDConic frame2[] = {
202{{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
203{{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
204{{{{205.78973252799028, -158.12538713371103}, {143.97848953841861, -74.076645245042371}, {95.551200899999998, 58.976398500000002}}}, 0.923879623f},
205{{{{377.21899400000001, -141.98100299999999}, {237.77799285476553, -166.56830755921084}, {134.08399674208422, -155.06258330544892}}}, 0.788580656f},
206};
207
208const SkDConic frame3[] = {
209{{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
210{{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
211{{{{205.78973252799028, -158.12538713371103}, {143.97848953841861, -74.076645245042371}, {95.551200899999998, 58.976398500000002}}}, 0.923879623f},
212{{{{252.08225670812539, -156.90491625851064}, {185.93099479842493, -160.81544543232982}, {134.08399674208422, -155.06258330544892}}}, 0.835816324f},
213};
214
215const SkDConic frame4[] = {
216{{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
217{{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
218{{{{205.78973252799028, -158.12538713371103}, {174.88411103320448, -116.10101618937664}, {145.19509369736275, -56.857102571363754}}}, 0.871667147f},
219{{{{252.08225670812539, -156.90491625851064}, {185.93099479842493, -160.81544543232982}, {134.08399674208422, -155.06258330544892}}}, 0.835816324f},
220};
221
222const SkDConic frame5[] = {
223{{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
224{{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
225{{{{205.78973252799028, -158.12538713371103}, {174.88411103320448, -116.10101618937664}, {145.19509369736275, -56.857102571363754}}}, 0.871667147f},
226{{{{252.08225670812539, -156.90491625851064}, {219.70109133058406, -158.81912754088933}, {190.17095392508796, -158.38373974664466}}}, 0.858306944f},
227};
228
229const SkDConic frame6[] = {
230{{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
231{{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
232{{{{205.78973252799028, -158.12538713371103}, {190.33692178059735, -137.11320166154385}, {174.87004877564593, -111.2132534799228}}}, 0.858117759f},
233{{{{252.08225670812539, -156.90491625851064}, {219.70109133058406, -158.81912754088933}, {190.17095392508796, -158.38373974664466}}}, 0.858306944f},
234};
235
236const SkDConic* frames[] = {
237 frame0, frame1, frame2, frame3, frame4, frame5, frame6
238};
239
240const int frameSizes[] = { (int) std::size(frame0), (int) std::size(frame1),
241 (int) std::size(frame2), (int) std::size(frame3),
242 (int) std::size(frame4), (int) std::size(frame5),
243 (int) std::size(frame6),
244};
245
246static void writeFrames() {
247 const int scale = 5;
248
249 for (int index = 0; index < (int) std::size(frameSizes); ++index) {
250 SkDRect bounds;
251 bool boundsSet = false;
252 int frameSize = frameSizes[index];
253 for (int fIndex = 0; fIndex < frameSize; ++fIndex) {
254 const SkDConic& dC = frames[index][fIndex];
255 SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
256 {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
257 {dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
258 SkDRect dBounds;
259 dBounds.setBounds(dConic);
260 if (!boundsSet) {
261 bounds = dBounds;
262 boundsSet = true;
263 } else {
264 bounds.add((SkDPoint&) dBounds.fLeft);
265 bounds.add((SkDPoint&) dBounds.fRight);
266 }
267 }
268 bounds.fLeft -= 10;
269 bounds.fTop -= 10;
270 bounds.fRight += 10;
271 bounds.fBottom += 10;
272 SkBitmap bitmap;
273 bitmap.tryAllocPixels(SkImageInfo::MakeN32Premul(
274 SkScalarRoundToInt(SkDoubleToScalar(bounds.width())),
275 SkScalarRoundToInt(SkDoubleToScalar(bounds.height()))));
276 SkCanvas canvas(bitmap);
277 SkPaint paint;
278 paint.setAntiAlias(true);
279 paint.setStyle(SkPaint::kStroke_Style);
280 canvas.translate(SkDoubleToScalar(-bounds.fLeft), SkDoubleToScalar(-bounds.fTop));
281 canvas.drawColor(SK_ColorWHITE);
282 for (int fIndex = 0; fIndex < frameSize; ++fIndex) {
283 const SkDConic& dC = frames[index][fIndex];
284 SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
285 {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
286 {dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
287 SkPath path;
288 path.moveTo(dConic.fPts[0].asSkPoint());
289 path.conicTo(dConic.fPts[1].asSkPoint(), dConic.fPts[2].asSkPoint(), dConic.fWeight);
290 if (fIndex < 2) {
291 paint.setARGB(0x80, 0xFF, 0, 0);
292 } else {
293 paint.setARGB(0x80, 0, 0, 0xFF);
294 }
295 canvas.drawPath(path, paint);
296 }
297 SkString filename("c:\\Users\\caryclark\\Documents\\");
298 filename.appendf("f%d.png", index);
299 ToolUtils::EncodeImageToPngFile(filename.c_str(), bitmap);
300 }
301}
302#endif
303
304static void oneOff(skiatest::Reporter* reporter, const ConicPts& conic1, const ConicPts& conic2,
305 bool coin) {
306#if DEBUG_VISUALIZE_CONICS
307 writeFrames();
308#endif
309 SkDConic c1, c2;
310 c1.debugSet(conic1.fPts.fPts, conic1.fWeight);
311 c2.debugSet(conic2.fPts.fPts, conic2.fWeight);
312 chopBothWays(c1, 0.5, "c1");
313 chopBothWays(c2, 0.5, "c2");
314#if DEBUG_VISUALIZE_CONICS
315 writeDPng(c1, "d1");
316 writeDPng(c2, "d2");
317#endif
318 SkASSERT(ValidConic(c1));
319 SkASSERT(ValidConic(c2));
320 SkIntersections intersections;
321 intersections.intersect(c1, c2);
322 REPORTER_ASSERT(reporter, !coin || intersections.used() == 2);
323 double tt1, tt2;
324 SkDPoint xy1, xy2;
325 for (int pt3 = 0; pt3 < intersections.used(); ++pt3) {
326 tt1 = intersections[0][pt3];
327 xy1 = c1.ptAtT(tt1);
328 tt2 = intersections[1][pt3];
329 xy2 = c2.ptAtT(tt2);
330 const SkDPoint& iPt = intersections.pt(pt3);
331 REPORTER_ASSERT(reporter, xy1.approximatelyEqual(iPt));
332 REPORTER_ASSERT(reporter, xy2.approximatelyEqual(iPt));
333 REPORTER_ASSERT(reporter, xy1.approximatelyEqual(xy2));
334 }
335 reporter->bumpTestCount();
336}
337
338static void oneOff(skiatest::Reporter* reporter, int outer, int inner) {
339 const ConicPts& c1 = testSet[outer];
340 const ConicPts& c2 = testSet[inner];
341 oneOff(reporter, c1, c2, false);
342}
343
344static void oneOffTests(skiatest::Reporter* reporter) {
345 for (int outer = 0; outer < testSetCount - 1; ++outer) {
346 for (int inner = outer + 1; inner < testSetCount; ++inner) {
347 oneOff(reporter, outer, inner);
348 }
349 }
350}
351
352DEF_TEST(PathOpsConicIntersectionOneOff, reporter) {
353 oneOff(reporter, 0, 1);
354}
355
356DEF_TEST(PathOpsConicIntersection, reporter) {
357 oneOffTests(reporter);
358}
fPts
SkPoint fPts[2]
Definition: AAConvexPathRenderer.cpp:50
reporter
reporter
Definition: FontMgrTest.cpp:39
chopBothWays
static void chopBothWays(const SkDConic &dConic, double t, const char *name)
Definition: PathOpsConicIntersectionTest.cpp:166
testSet
static const ConicPts testSet[]
Definition: PathOpsConicIntersectionTest.cpp:28
oneOff
static void oneOff(skiatest::Reporter *reporter, const ConicPts &conic1, const ConicPts &conic2, bool coin)
Definition: PathOpsConicIntersectionTest.cpp:304
oneOffTests
static void oneOffTests(skiatest::Reporter *reporter)
Definition: PathOpsConicIntersectionTest.cpp:344
DEF_TEST
DEF_TEST(PathOpsConicIntersectionOneOff, reporter)
Definition: PathOpsConicIntersectionTest.cpp:352
chopCompare
static void chopCompare(const SkConic chopped[2], const SkDConic dChopped[2])
Definition: PathOpsConicIntersectionTest.cpp:56
testSetCount
const int testSetCount
Definition: PathOpsConicIntersectionTest.cpp:54
ValidConic
bool ValidConic(const SkDConic &conic)
Definition: PathOpsTestCommon.cpp:274
SkASSERT
#define SkASSERT(cond)
Definition: SkAssert.h:116
SK_ColorWHITE
constexpr SkColor SK_ColorWHITE
Definition: SkColor.h:122
roughly_equal
bool roughly_equal(double x, double y)
Definition: SkPathOpsTypes.h:536
SkScalarRoundToInt
#define SkScalarRoundToInt(x)
Definition: SkScalar.h:37
SkDoubleToScalar
#define SkDoubleToScalar(x)
Definition: SkScalar.h:64
REPORTER_ASSERT
#define REPORTER_ASSERT(r, cond,...)
Definition: Test.h:286
SkCanvas::translate
void translate(SkScalar dx, SkScalar dy)
Definition: SkCanvas.cpp:1278
SkCanvas::drawColor
void drawColor(SkColor color, SkBlendMode mode=SkBlendMode::kSrcOver)
Definition: SkCanvas.h:1182
SkCanvas::drawPath
void drawPath(const SkPath &path, const SkPaint &paint)
Definition: SkCanvas.cpp:1747
SkIntersections::intersect
int intersect(const SkDLine &, const SkDLine &)
Definition: SkDLineIntersection.cpp:87
SkIntersections::pt
const SkDPoint & pt(int index) const
Definition: SkIntersections.h:173
SkIntersections::used
int used() const
Definition: SkIntersections.h:228
SkPaint::kStroke_Style
@ kStroke_Style
set to stroke geometry
Definition: SkPaint.h:194
SkPath
Definition: SkPath.h:59
SkString::c_str
const char * c_str() const
Definition: SkString.h:133
SkString::appendf
void void void appendf(const char format[],...) SK_PRINTF_LIKE(2
Definition: SkString.cpp:550
paint
const Paint & paint
Definition: color_source.cc:38
SkRecords::bounds
Optional< SkRect > bounds
Definition: SkRecords.h:189
ToolUtils::EncodeImageToPngFile
bool EncodeImageToPngFile(const char *path, const SkBitmap &src)
Definition: EncodeUtils.cpp:60
bitmap
Definition: bitmap.py:1
flutter::path
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir path
Definition: switches.h:57
flutter::name
DEF_SWITCHES_START aot vmservice shared library name
Definition: switches.h:32
flutter::size
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Definition: switches.h:259
skgpu::wangs_formula::conic
AI float conic(float tolerance, const SkPoint pts[], float w, const VectorXform &vectorXform=VectorXform())
Definition: WangsFormula.h:287
scale
const Scalar scale
Definition: stroke_path_geometry.cc:308
ConicPts::fWeight
SkScalar fWeight
Definition: PathOpsTestCommon.h:29
ConicPts::fPts
QuadPts fPts
Definition: PathOpsTestCommon.h:28
QuadPts::fPts
SkDPoint fPts[kPointCount]
Definition: PathOpsTestCommon.h:24
SkConic::fW
SkScalar fW
Definition: SkGeometry.h:337
SkConic::fPts
SkPoint fPts[3]
Definition: SkGeometry.h:336
SkDConic::ptAtT
SkDPoint ptAtT(double t) const
Definition: SkPathOpsConic.cpp:95
SkDConic::dump
void dump() const
Definition: PathOpsDebug.cpp:88
SkDConic::fPts
SkDQuad fPts
Definition: SkPathOpsConic.h:31
SkDConic::subDivide
SkDConic subDivide(double t1, double t2) const
Definition: SkPathOpsConic.cpp:131
SkDConic::debugSet
void debugSet(const SkDPoint *pts, SkScalar weight)
Definition: SkPathOpsDebug.cpp:717
SkDConic::fWeight
SkScalar fWeight
Definition: SkPathOpsConic.h:32
SkDPoint::set
void set(const SkPoint &pt)
Definition: SkPathOpsPoint.h:106
SkDPoint::approximatelyEqual
bool approximatelyEqual(const SkDPoint &a) const
Definition: SkPathOpsPoint.h:177
SkDRect::fRight
double fRight
Definition: SkPathOpsRect.h:22
SkDRect::setBounds
void setBounds(const SkDConic &curve)
Definition: SkPathOpsRect.h:59
SkDRect::fLeft
double fLeft
Definition: SkPathOpsRect.h:22
SkImageInfo::MakeN32Premul
static SkImageInfo MakeN32Premul(int width, int height)
Definition: SkImageInfo.cpp:157
SkPoint::fX
float fX
x-axis value
Definition: SkPoint_impl.h:164
SkPoint::fY
float fY
y-axis value
Definition: SkPoint_impl.h:165
Generated on Sun Jun 23 2024 21:56:42 for Flutter Engine by doxygen 1.9.4