src/pathops/SkDCubicIntersection.cpp - Issue 1037573004: cumulative pathops patch

Side by Side Diff: src/pathops/SkDCubicIntersection.cpp

Issue 1037573004: cumulative pathops patch (Closed) Base URL: https://skia.googlesource.com/skia.git@master

Patch Set: fix pathopsinverse gm Created 5 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /*

2 * Copyright 2012 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

8 #include "SkIntersections.h"

9 #include "SkPathOpsCubic.h"

10 #include "SkPathOpsLine.h"

11 #include "SkPathOpsPoint.h"

12 #include "SkPathOpsQuad.h"

13 #include "SkPathOpsRect.h"

14 #include "SkReduceOrder.h"

15 #include "SkTSort.h"

16

17 #if ONE_OFF_DEBUG

18 static const double tLimits1[2][2] = {{0.3, 0.4}, {0.8, 0.9}};

19 static const double tLimits2[2][2] = {{-0.8, -0.9}, {-0.8, -0.9}};

20 #endif

21

22 #define DEBUG_QUAD_PART ONE_OFF_DEBUG && 1

23 #define DEBUG_QUAD_PART_SHOW_SIMPLE DEBUG_QUAD_PART && 0

24 #define SWAP_TOP_DEBUG 0

25

26 static const int kCubicToQuadSubdivisionDepth = 8; // slots reserved for cubic t o quads subdivision

27

28 static int quadPart(const SkDCubic& cubic, double tStart, double tEnd, SkReduceO rder* reducer) {

29 SkDCubic part = cubic.subDivide(tStart, tEnd);

30 SkDQuad quad = part.toQuad();

31 // FIXME: should reduceOrder be looser in this use case if quartic is going to blow up on an

32 // extremely shallow quadratic?

33 int order = reducer->reduce(quad);

34 #if DEBUG_QUAD_PART

35 SkDebugf("%s cubic=(%1.9g,%1.9g %1.9g,%1.9g %1.9g,%1.9g %1.9g,%1.9g)"

36 " t=(%1.9g,%1.9g)\n", __FUNCTION__, cubic[0].fX, cubic[0].fY,

37 cubic[1].fX, cubic[1].fY, cubic[2].fX, cubic[2].fY,

38 cubic[3].fX, cubic[3].fY, tStart, tEnd);

39 SkDebugf(" {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n"

40 " {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n",

41 part[0].fX, part[0].fY, part[1].fX, part[1].fY, part[2].fX, part[2]. fY,

42 part[3].fX, part[3].fY, quad[0].fX, quad[0].fY,

43 quad[1].fX, quad[1].fY, quad[2].fX, quad[2].fY);

44 #if DEBUG_QUAD_PART_SHOW_SIMPLE

45 SkDebugf("%s simple=(%1.9g,%1.9g", __FUNCTION__, reducer->fQuad[0].fX, reduc er->fQuad[0].fY);

46 if (order > 1) {

47 SkDebugf(" %1.9g,%1.9g", reducer->fQuad[1].fX, reducer->fQuad[1].fY);

48 }

49 if (order > 2) {

50 SkDebugf(" %1.9g,%1.9g", reducer->fQuad[2].fX, reducer->fQuad[2].fY);

51 }

52 SkDebugf(")\n");

53 SkASSERT(order < 4 && order > 0);

54 #endif

55 #endif

56 return order;

57 }

58

59 static void intersectWithOrder(const SkDQuad& simple1, int order1, const SkDQuad & simple2,

60 int order2, SkIntersections& i) {

61 if (order1 == 3 && order2 == 3) {

62 i.intersect(simple1, simple2);

63 } else if (order1 <= 2 && order2 <= 2) {

64 i.intersect((const SkDLine&) simple1, (const SkDLine&) simple2);

65 } else if (order1 == 3 && order2 <= 2) {

66 i.intersect(simple1, (const SkDLine&) simple2);

67 } else {

68 SkASSERT(order1 <= 2 && order2 == 3);

69 i.intersect(simple2, (const SkDLine&) simple1);

70 i.swapPts();

71 }

72 }

73

74 // this flavor centers potential intersections recursively. In contrast, '2' may inadvertently

75 // chase intersections near quadratic ends, requiring odd hacks to find them.

76 static void intersect(const SkDCubic& cubic1, double t1s, double t1e, const SkDC ubic& cubic2,

77 double t2s, double t2e, double precisionScale, SkIntersections& i) {

78 i.upDepth();

79 SkDCubic c1 = cubic1.subDivide(t1s, t1e);

80 SkDCubic c2 = cubic2.subDivide(t2s, t2e);

81 SkSTArray<kCubicToQuadSubdivisionDepth, double, true> ts1;

82 // OPTIMIZE: if c1 == c2, call once (happens when detecting self-intersectio n)

83 c1.toQuadraticTs(c1.calcPrecision() * precisionScale, &ts1);

84 SkSTArray<kCubicToQuadSubdivisionDepth, double, true> ts2;

85 c2.toQuadraticTs(c2.calcPrecision() * precisionScale, &ts2);

86 double t1Start = t1s;

87 int ts1Count = ts1.count();

88 for (int i1 = 0; i1 <= ts1Count; ++i1) {

89 const double tEnd1 = i1 < ts1Count ? ts1[i1] : 1;

90 const double t1 = t1s + (t1e - t1s) * tEnd1;

91 SkReduceOrder s1;

92 int o1 = quadPart(cubic1, t1Start, t1, &s1);

93 double t2Start = t2s;

94 int ts2Count = ts2.count();

95 for (int i2 = 0; i2 <= ts2Count; ++i2) {

96 const double tEnd2 = i2 < ts2Count ? ts2[i2] : 1;

97 const double t2 = t2s + (t2e - t2s) * tEnd2;

98 if (&cubic1 == &cubic2 && t1Start >= t2Start) {

99 t2Start = t2;

100 continue;

101 }

102 SkReduceOrder s2;

103 int o2 = quadPart(cubic2, t2Start, t2, &s2);

104 #if ONE_OFF_DEBUG

105 char tab[] = " ";

106 if (tLimits1[0][0] >= t1Start && tLimits1[0][1] <= t1

107 && tLimits1[1][0] >= t2Start && tLimits1[1][1] <= t2) {

108 SkDebugf("%.s %s t1=(%1.9g,%1.9g) t2=(%1.9g,%1.9g)", i.depth() 2, tab,

109 __FUNCTION__, t1Start, t1, t2Start, t2);

110 SkIntersections xlocals;

111 xlocals.allowNear(false);

112 xlocals.allowFlatMeasure(true);

113 intersectWithOrder(s1.fQuad, o1, s2.fQuad, o2, xlocals);

114 SkDebugf(" xlocals.fUsed=%d\n", xlocals.used());

115 }

116 #endif

117 SkIntersections locals;

118 locals.allowNear(false);

119 locals.allowFlatMeasure(true);

120 intersectWithOrder(s1.fQuad, o1, s2.fQuad, o2, locals);

121 int tCount = locals.used();

122 for (int tIdx = 0; tIdx < tCount; ++tIdx) {

123 double to1 = t1Start + (t1 - t1Start) * locals[0][tIdx];

124 double to2 = t2Start + (t2 - t2Start) * locals[1][tIdx];

125 // if the computed t is not sufficiently precise, iterate

126 SkDPoint p1 = cubic1.ptAtT(to1);

127 SkDPoint p2 = cubic2.ptAtT(to2);

128 if (p1.approximatelyEqual(p2)) {

129 // FIXME: local edge may be coincident -- experiment with not propagating co incidence to caller

130 // SkASSERT(!locals.isCoincident(tIdx));

131 if (&cubic1 != &cubic2 \|\| !approximately_equal(to1, to2)) {

132 if (i.swapped()) { // FIXME: insert should respect swa p

133 i.insert(to2, to1, p1);

134 } else {

135 i.insert(to1, to2, p1);

136 }

137 }

138 } else {

139 /*for random cubics, 16 below catches 99.997% of the intersections. To test for the remaining 0.003%

140 look for nearly coincident curves. and check each 1/16th section.

141 */

142 double offset = precisionScale / 16; // FIXME: const is arb itrary: test, refine

143 double c1Bottom = tIdx == 0 ? 0 :

144 (t1Start + (t1 - t1Start) * locals[0][tIdx - 1] + to 1) / 2;

145 double c1Min = SkTMax(c1Bottom, to1 - offset);

146 double c1Top = tIdx == tCount - 1 ? 1 :

147 (t1Start + (t1 - t1Start) * locals[0][tIdx + 1] + to 1) / 2;

148 double c1Max = SkTMin(c1Top, to1 + offset);

149 double c2Min = SkTMax(0., to2 - offset);

150 double c2Max = SkTMin(1., to2 + offset);

151 #if ONE_OFF_DEBUG

152 SkDebugf("%.s %s 1 contains1=%d/%d contains2=%d/%d\n", i.de pth()2, tab,

153 __FUNCTION__,

154 c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max

155 && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max,

156 to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset

157 && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset,

158 c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max

159 && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max,

160 to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset

161 && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset);

162 SkDebugf("%.*s %s 1 c1Bottom=%1.9g c1Top=%1.9g c2Bottom=%1.9 g c2Top=%1.9g"

163 " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset=%1. 9g\n",

164 i.depth()*2, tab, __FUNCTION__, c1Bottom, c1Top, 0., 1.,

165 to1 - offset, to1 + offset, to2 - offset, to2 + offs et, offset);

166 SkDebugf("%.*s %s 1 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Max=%1 .9g c2Min=%1.9g"

167 " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__, to 1, to2, c1Min,

168 c1Max, c2Min, c2Max);

169 #endif

170 intersect(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset , i);

171 #if ONE_OFF_DEBUG

172 SkDebugf("%.s %s 1 i.used=%d t=%1.9g\n", i.depth()2, tab, __FUNCTION__,

173 i.used(), i.used() > 0 ? i[0][i.used() - 1] : -1);

174 #endif

175 if (tCount > 1) {

176 c1Min = SkTMax(0., to1 - offset);

177 c1Max = SkTMin(1., to1 + offset);

178 double c2Bottom = tIdx == 0 ? to2 :

179 (t2Start + (t2 - t2Start) * locals[1][tIdx - 1] + to2) / 2;

180 double c2Top = tIdx == tCount - 1 ? to2 :

181 (t2Start + (t2 - t2Start) * locals[1][tIdx + 1] + to2) / 2;

182 if (c2Bottom > c2Top) {

183 SkTSwap(c2Bottom, c2Top);

184 }

185 if (c2Bottom == to2) {

186 c2Bottom = 0;

187 }

188 if (c2Top == to2) {

189 c2Top = 1;

190 }

191 c2Min = SkTMax(c2Bottom, to2 - offset);

192 c2Max = SkTMin(c2Top, to2 + offset);

193 #if ONE_OFF_DEBUG

194 SkDebugf("%.s %s 2 contains1=%d/%d contains2=%d/%d\n", i.depth()2, tab,

195 __FUNCTION__,

196 c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max

197 && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max,

198 to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset

199 && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset,

200 c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max

201 && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max,

202 to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset

203 && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset);

204 SkDebugf("%.*s %s 2 c1Bottom=%1.9g c1Top=%1.9g c2Bottom= %1.9g c2Top=%1.9g"

205 " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset =%1.9g\n",

206 i.depth()*2, tab, __FUNCTION__, 0., 1., c2Bottom , c2Top,

207 to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset);

208 SkDebugf("%.*s %s 2 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Ma x=%1.9g c2Min=%1.9g"

209 " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__ , to1, to2, c1Min,

210 c1Max, c2Min, c2Max);

211 #endif

212 intersect(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, of fset, i);

213 #if ONE_OFF_DEBUG

214 SkDebugf("%.s %s 2 i.used=%d t=%1.9g\n", i.depth()2, tab, __FUNCTION__,

215 i.used(), i.used() > 0 ? i[0][i.used() - 1] : -1);

216 #endif

217 c1Min = SkTMax(c1Bottom, to1 - offset);

218 c1Max = SkTMin(c1Top, to1 + offset);

219 #if ONE_OFF_DEBUG

220 SkDebugf("%.s %s 3 contains1=%d/%d contains2=%d/%d\n", i.depth()2, tab,

221 __FUNCTION__,

222 c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max

223 && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max,

224 to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset

225 && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset,

226 c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max

227 && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max,

228 to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset

229 && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset);

230 SkDebugf("%.*s %s 3 c1Bottom=%1.9g c1Top=%1.9g c2Bottom= %1.9g c2Top=%1.9g"

231 " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset =%1.9g\n",

232 i.depth()*2, tab, __FUNCTION__, 0., 1., c2Bottom , c2Top,

233 to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset);

234 SkDebugf("%.*s %s 3 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Ma x=%1.9g c2Min=%1.9g"

235 " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__ , to1, to2, c1Min,

236 c1Max, c2Min, c2Max);

237 #endif

238 intersect(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, of fset, i);

239 #if ONE_OFF_DEBUG

240 SkDebugf("%.s %s 3 i.used=%d t=%1.9g\n", i.depth()2, tab, __FUNCTION__,

241 i.used(), i.used() > 0 ? i[0][i.used() - 1] : -1);

242 #endif

243 }

244 // intersect(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offs et, i);

245 // FIXME: if no intersection is found, either quadratics int ersected where

246 // cubics did not, or the intersection was missed. In the fo rmer case, expect

247 // the quadratics to be nearly parallel at the point of inte rsection, and check

248 // for that.

249 }

250 }

251 t2Start = t2;

252 }

253 t1Start = t1;

254 }

255 i.downDepth();

256 }

257

258 // if two ends intersect, check middle for coincidence

259 bool SkIntersections::cubicCheckCoincidence(const SkDCubic& c1, const SkDCubic& c2) {

260 if (fUsed < 2) {

261 return false;

262 }

263 int last = fUsed - 1;

264 double tRange1 = fT[0][last] - fT[0][0];

265 double tRange2 = fT[1][last] - fT[1][0];

266 for (int index = 1; index < 5; ++index) {

267 double testT1 = fT[0][0] + tRange1 * index / 5;

268 double testT2 = fT[1][0] + tRange2 * index / 5;

269 SkDPoint testPt1 = c1.ptAtT(testT1);

270 SkDPoint testPt2 = c2.ptAtT(testT2);

271 if (!testPt1.approximatelyEqual(testPt2)) {

272 return false;

273 }

274 }

275 if (fUsed > 2) {

276 fPt[1] = fPt[last];

277 fT[0][1] = fT[0][last];

278 fT[1][1] = fT[1][last];

279 fUsed = 2;

280 }

281 fIsCoincident[0] = fIsCoincident[1] = 0x03;

282 return true;

283 }

284

285 #define LINE_FRACTION 0.1

286

287 // intersect the end of the cubic with the other. Try lines from the end to cont rol and opposite

288 // end to determine range of t on opposite cubic.

289 bool SkIntersections::cubicExactEnd(const SkDCubic& cubic1, bool start, const Sk DCubic& cubic2) {

290 int t1Index = start ? 0 : 3;

291 double testT = (double) !start;

292 bool swap = swapped();

293 // quad/quad at this point checks to see if exact matches have already been found

294 // cubic/cubic can't reject so easily since cubics can intersect same point more than once

295 SkDLine tmpLine;

296 tmpLine[0] = tmpLine[1] = cubic2[t1Index];

297 tmpLine[1].fX += cubic2[2 - start].fY - cubic2[t1Index].fY;

298 tmpLine[1].fY -= cubic2[2 - start].fX - cubic2[t1Index].fX;

299 SkIntersections impTs;

300 impTs.allowNear(false);

301 impTs.allowFlatMeasure(true);

302 impTs.intersectRay(cubic1, tmpLine);

303 for (int index = 0; index < impTs.used(); ++index) {

304 SkDPoint realPt = impTs.pt(index);

305 if (!tmpLine[0].approximatelyEqual(realPt)) {

306 continue;

307 }

308 if (swap) {

309 cubicInsert(testT, impTs[0][index], tmpLine[0], cubic2, cubic1);

310 } else {

311 cubicInsert(impTs[0][index], testT, tmpLine[0], cubic1, cubic2);

312 }

313 return true;

314 }

315 return false;

316 }

317

318

319 void SkIntersections::cubicInsert(double one, double two, const SkDPoint& pt,

320 const SkDCubic& cubic1, const SkDCubic& cubic2) {

321 for (int index = 0; index < fUsed; ++index) {

322 if (fT[0][index] == one) {

323 double oldTwo = fT[1][index];

324 if (oldTwo == two) {

325 return;

326 }

327 SkDPoint mid = cubic2.ptAtT((oldTwo + two) / 2);

328 if (mid.approximatelyEqual(fPt[index])) {

329 return;

330 }

331 }

332 if (fT[1][index] == two) {

333 SkDPoint mid = cubic1.ptAtT((fT[0][index] + two) / 2);

334 if (mid.approximatelyEqual(fPt[index])) {

335 return;

336 }

337 }

338 }

339 insert(one, two, pt);

340 }

341

342 void SkIntersections::cubicNearEnd(const SkDCubic& cubic1, bool start, const SkD Cubic& cubic2,

343 const SkDRect& bounds2) {

344 SkDLine line;

345 int t1Index = start ? 0 : 3;

346 double testT = (double) !start;

347 // don't bother if the two cubics are connnected

348 static const int kPointsInCubic = 4; // FIXME: move to DCubic, replace '4' w ith this

349 static const int kMaxLineCubicIntersections = 3;

350 SkSTArray<(kMaxLineCubicIntersections - 1) * kMaxLineCubicIntersections, dou ble, true> tVals;

351 line[0] = cubic1[t1Index];

352 // this variant looks for intersections with the end point and lines paralle l to other points

353 for (int index = 0; index < kPointsInCubic; ++index) {

354 if (index == t1Index) {

355 continue;

356 }

357 SkDVector dxy1 = cubic1[index] - line[0];

358 dxy1 /= SkDCubic::gPrecisionUnit;

359 line[1] = line[0] + dxy1;

360 SkDRect lineBounds;

361 lineBounds.setBounds(line);

362 if (!bounds2.intersects(&lineBounds)) {

363 continue;

364 }

365 SkIntersections local;

366 if (!local.intersect(cubic2, line)) {

367 continue;

368 }

369 for (int idx2 = 0; idx2 < local.used(); ++idx2) {

370 double foundT = local[0][idx2];

371 if (approximately_less_than_zero(foundT)

372 \|\| approximately_greater_than_one(foundT)) {

373 continue;

374 }

375 if (local.pt(idx2).approximatelyEqual(line[0])) {

376 if (swapped()) { // FIXME: insert should respect swap

377 insert(foundT, testT, line[0]);

378 } else {

379 insert(testT, foundT, line[0]);

380 }

381 } else {

382 tVals.push_back(foundT);

383 }

384 }

385 }

386 if (tVals.count() == 0) {

387 return;

388 }

389 SkTQSort<double>(tVals.begin(), tVals.end() - 1);

390 double tMin1 = start ? 0 : 1 - LINE_FRACTION;

391 double tMax1 = start ? LINE_FRACTION : 1;

392 int tIdx = 0;

393 do {

394 int tLast = tIdx;

395 while (tLast + 1 < tVals.count() && roughly_equal(tVals[tLast + 1], tVal s[tIdx])) {

396 ++tLast;

397 }

398 double tMin2 = SkTMax(tVals[tIdx] - LINE_FRACTION, 0.0);

399 double tMax2 = SkTMin(tVals[tLast] + LINE_FRACTION, 1.0);

400 int lastUsed = used();

401 if (start ? tMax1 < tMin2 : tMax2 < tMin1) {

402 ::intersect(cubic1, tMin1, tMax1, cubic2, tMin2, tMax2, 1, *this);

403 }

404 if (lastUsed == used()) {

405 tMin2 = SkTMax(tVals[tIdx] - (1.0 / SkDCubic::gPrecisionUnit), 0.0);

406 tMax2 = SkTMin(tVals[tLast] + (1.0 / SkDCubic::gPrecisionUnit), 1.0) ;

407 if (start ? tMax1 < tMin2 : tMax2 < tMin1) {

408 ::intersect(cubic1, tMin1, tMax1, cubic2, tMin2, tMax2, 1, *this );

409 }

410 }

411 tIdx = tLast + 1;

412 } while (tIdx < tVals.count());

413 return;

414 }

415

416 const double CLOSE_ENOUGH = 0.001;

417

418 static bool closeStart(const SkDCubic& cubic, int cubicIndex, SkIntersections& i , SkDPoint& pt) {

419 if (i[cubicIndex][0] != 0 \|\| i[cubicIndex][1] > CLOSE_ENOUGH) {

420 return false;

421 }

422 pt = cubic.ptAtT((i[cubicIndex][0] + i[cubicIndex][1]) / 2);

423 return true;

424 }

425

426 static bool closeEnd(const SkDCubic& cubic, int cubicIndex, SkIntersections& i, SkDPoint& pt) {

427 int last = i.used() - 1;

428 if (i[cubicIndex][last] != 1 \|\| i[cubicIndex][last - 1] < 1 - CLOSE_ENOUGH) {

429 return false;

430 }

431 pt = cubic.ptAtT((i[cubicIndex][last] + i[cubicIndex][last - 1]) / 2);

432 return true;

433 }

434

435 static bool only_end_pts_in_common(const SkDCubic& c1, const SkDCubic& c2) {

436 // the idea here is to see at minimum do a quick reject by rotating all points

437 // to either side of the line formed by connecting the endpoints

438 // if the opposite curves points are on the line or on the other side, the

439 // curves at most intersect at the endpoints

440 for (int oddMan = 0; oddMan < 4; ++oddMan) {

441 const SkDPoint* endPt[3];

442 for (int opp = 1; opp < 4; ++opp) {

443 int end = oddMan ^ opp; // choose a value not equal to oddMan

444 endPt[opp - 1] = &c1[end];

445 }

446 for (int triTest = 0; triTest < 3; ++triTest) {

447 double origX = endPt[triTest]->fX;

448 double origY = endPt[triTest]->fY;

449 int oppTest = triTest + 1;

450 if (3 == oppTest) {

451 oppTest = 0;

452 }

453 double adj = endPt[oppTest]->fX - origX;

454 double opp = endPt[oppTest]->fY - origY;

455 if (adj == 0 && opp == 0) { // if the other point equals the test p oint, ignore it

456 continue;

457 }

458 double sign = (c1[oddMan].fY - origY) * adj - (c1[oddMan].fX - origX ) * opp;

459 if (approximately_zero(sign)) {

460 goto tryNextHalfPlane;

461 }

462 for (int n = 0; n < 4; ++n) {

463 double test = (c2[n].fY - origY) * adj - (c2[n].fX - origX) * op p;

464 if (test * sign > 0 && !precisely_zero(test)) {

465 goto tryNextHalfPlane;

466 }

467 }

468 }

469 return true;

470 tryNextHalfPlane:

471 ;

472 }

473 return false;

474 }

475

476 int SkIntersections::intersect(const SkDCubic& c1, const SkDCubic& c2) {

477 if (fMax == 0) {

478 fMax = 9;

479 }

480 bool selfIntersect = &c1 == &c2;

481 if (selfIntersect) {

482 if (c1[0].approximatelyEqual(c1[3])) {

483 insert(0, 1, c1[0]);

484 return fUsed;

485 }

486 } else {

487 // OPTIMIZATION: set exact end bits here to avoid cubic exact end later

488 for (int i1 = 0; i1 < 4; i1 += 3) {

489 for (int i2 = 0; i2 < 4; i2 += 3) {

490 if (c1[i1].approximatelyEqual(c2[i2])) {

491 insert(i1 >> 1, i2 >> 1, c1[i1]);

492 }

493 }

494 }

495 }

496 SkASSERT(fUsed < 4);

497 if (!selfIntersect) {

498 if (only_end_pts_in_common(c1, c2)) {

499 return fUsed;

500 }

501 if (only_end_pts_in_common(c2, c1)) {

502 return fUsed;

503 }

504 }

505 // quad/quad does linear test here -- cubic does not

506 // cubics which are really lines should have been detected in reduce step ea rlier

507 int exactEndBits = 0;

508 if (selfIntersect) {

509 if (fUsed) {

510 return fUsed;

511 }

512 } else {

513 exactEndBits \|= cubicExactEnd(c1, false, c2) << 0;

514 exactEndBits \|= cubicExactEnd(c1, true, c2) << 1;

515 swap();

516 exactEndBits \|= cubicExactEnd(c2, false, c1) << 2;

517 exactEndBits \|= cubicExactEnd(c2, true, c1) << 3;

518 swap();

519 }

520 if (cubicCheckCoincidence(c1, c2)) {

521 SkASSERT(!selfIntersect);

522 return fUsed;

523 }

524 // FIXME: pass in cached bounds from caller

525 SkDRect c2Bounds;

526 c2Bounds.setBounds(c2);

527 if (!(exactEndBits & 4)) {

528 cubicNearEnd(c1, false, c2, c2Bounds);

529 }

530 if (!(exactEndBits & 8)) {

531 if (selfIntersect && fUsed) {

532 return fUsed;

533 }

534 cubicNearEnd(c1, true, c2, c2Bounds);

535 if (selfIntersect && fUsed && ((approximately_less_than_zero(fT[0][0])

536 && approximately_less_than_zero(fT[1][0]))

537 \|\| (approximately_greater_than_one(fT[0][0])

538 && approximately_greater_than_one(fT[1][0])))) {

539 SkASSERT(fUsed == 1);

540 fUsed = 0;

541 return fUsed;

542 }

543 }

544 if (!selfIntersect) {

545 SkDRect c1Bounds;

546 c1Bounds.setBounds(c1); // OPTIMIZE use setRawBounds ?

547 swap();

548 if (!(exactEndBits & 1)) {

549 cubicNearEnd(c2, false, c1, c1Bounds);

550 }

551 if (!(exactEndBits & 2)) {

552 cubicNearEnd(c2, true, c1, c1Bounds);

553 }

554 swap();

555 }

556 if (cubicCheckCoincidence(c1, c2)) {

557 SkASSERT(!selfIntersect);

558 return fUsed;

559 }

560 SkIntersections i;

561 i.fAllowNear = false;

562 i.fFlatMeasure = true;

563 i.fMax = 9;

564 ::intersect(c1, 0, 1, c2, 0, 1, 1, i);

565 int compCount = i.used();

566 if (compCount) {

567 int exactCount = used();

568 if (exactCount == 0) {

569 *this = i;

570 } else {

571 // at least one is exact or near, and at least one was computed. Eli minate duplicates

572 for (int exIdx = 0; exIdx < exactCount; ++exIdx) {

573 for (int cpIdx = 0; cpIdx < compCount; ) {

574 if (fT[0][0] == i[0][0] && fT[1][0] == i[1][0]) {

575 i.removeOne(cpIdx);

576 --compCount;

577 continue;

578 }

579 double tAvg = (fT[0][exIdx] + i[0][cpIdx]) / 2;

580 SkDPoint pt = c1.ptAtT(tAvg);

581 if (!pt.approximatelyEqual(fPt[exIdx])) {

582 ++cpIdx;

583 continue;

584 }

585 tAvg = (fT[1][exIdx] + i[1][cpIdx]) / 2;

586 pt = c2.ptAtT(tAvg);

587 if (!pt.approximatelyEqual(fPt[exIdx])) {

588 ++cpIdx;

589 continue;

590 }

591 i.removeOne(cpIdx);

592 --compCount;

593 }

594 }

595 // if mid t evaluates to nearly the same point, skip the t

596 for (int cpIdx = 0; cpIdx < compCount - 1; ) {

597 double tAvg = (fT[0][cpIdx] + i[0][cpIdx + 1]) / 2;

598 SkDPoint pt = c1.ptAtT(tAvg);

599 if (!pt.approximatelyEqual(fPt[cpIdx])) {

600 ++cpIdx;

601 continue;

602 }

603 tAvg = (fT[1][cpIdx] + i[1][cpIdx + 1]) / 2;

604 pt = c2.ptAtT(tAvg);

605 if (!pt.approximatelyEqual(fPt[cpIdx])) {

606 ++cpIdx;

607 continue;

608 }

609 i.removeOne(cpIdx);

610 --compCount;

611 }

612 // in addition to adding below missing function, think about how to say

613 append(i);

614 }

615 }

616 // If an end point and a second point very close to the end is returned, the second

617 // point may have been detected because the approximate quads

618 // intersected at the end and close to it. Verify that the second point is v alid.

619 if (fUsed <= 1) {

620 return fUsed;

621 }

622 SkDPoint pt[2];

623 if (closeStart(c1, 0, this, pt[0]) && closeStart(c2, 1, this, pt[1])

624 && pt[0].approximatelyEqual(pt[1])) {

625 removeOne(1);

626 }

627 if (closeEnd(c1, 0, this, pt[0]) && closeEnd(c2, 1, this, pt[1])

628 && pt[0].approximatelyEqual(pt[1])) {

629 removeOne(used() - 2);

630 }

631 // vet the pairs of t values to see if the mid value is also on the curve. I f so, mark

632 // the span as coincident

633 if (fUsed >= 2 && !coincidentUsed()) {

634 int last = fUsed - 1;

635 int match = 0;

636 for (int index = 0; index < last; ++index) {

637 double mid1 = (fT[0][index] + fT[0][index + 1]) / 2;

638 double mid2 = (fT[1][index] + fT[1][index + 1]) / 2;

639 pt[0] = c1.ptAtT(mid1);

640 pt[1] = c2.ptAtT(mid2);

641 if (pt[0].approximatelyEqual(pt[1])) {

642 match \|= 1 << index;

643 }

644 }

645 if (match) {

646 #if DEBUG_CONCIDENT

647 if (((match + 1) & match) != 0) {

648 SkDebugf("%s coincident hole\n", __FUNCTION__);

649 }

650 #endif

651 // for now, assume that everything from start to finish is coinciden t

652 if (fUsed > 2) {

653 fPt[1] = fPt[last];

654 fT[0][1] = fT[0][last];

655 fT[1][1] = fT[1][last];

656 fIsCoincident[0] = 0x03;

657 fIsCoincident[1] = 0x03;

658 fUsed = 2;

659 }

660 }

661 }

662 return fUsed;

663 }

664

665 // Up promote the quad to a cubic.

666 // OPTIMIZATION If this is a common use case, optimize by duplicating

667 // the intersect 3 loop to avoid the promotion / demotion code

668 int SkIntersections::intersect(const SkDCubic& cubic, const SkDQuad& quad) {

669 fMax = 7;

670 SkDCubic up = quad.toCubic();

671 (void) intersect(cubic, up);

672 return used();

673 }

674

675 /* http://www.ag.jku.at/compass/compasssample.pdf

676 ( Self-Intersection Problems and Approximate Implicitization by Jan B. Thomassen

677 Centre of Mathematics for Applications, University of Oslo http://www.cma.uio.no janbth@math.uio.no

678 SINTEF Applied Mathematics http://www.sintef.no )

679 describes a method to find the self intersection of a cubic by taking the gradie nt of the implicit

680 form dotted with the normal, and solving for the roots. My math foo is too poor to implement this.*/

681

682 int SkIntersections::intersect(const SkDCubic& c) {

683 fMax = 1;

684 // check to see if x or y end points are the extrema. Are other quick reject s possible?

685 if (c.endsAreExtremaInXOrY()) {

686 return false;

687 }

688 // OPTIMIZATION: could quick reject if neither end point tangent ray interse cted the line

689 // segment formed by the opposite end point to the control point

690 (void) intersect(c, c);

691 if (used() > 1) {

692 fUsed = 0;

693 } else if (used() > 0) {

694 if (approximately_equal_double(fT[0][0], fT[1][0])) {

695 fUsed = 0;

696 } else {

697 SkASSERT(used() == 1);

698 if (fT[0][0] > fT[1][0]) {

699 swapPts();

700 }

701 }

702 }

703 return used();

704 }

OLD	NEW

« no previous file with comments | « src/pathops/SkAddIntersections.cpp ('k') | src/pathops/SkDCubicLineIntersection.cpp » ('j') | no next file with comments »