skia / skia / 8e712021de51eadb887c4aa6b18ceb4bf3f78f07 / . / experimental / Intersection / thingsToDo.txt

/* | |

* Copyright 2012 Google Inc. | |

* | |

* Use of this source code is governed by a BSD-style license that can be | |

* found in the LICENSE file. | |

*/ | |

add unit test for quadratic horizontal intersection | |

add unit test for cubic horizontal intersection with left/right | |

add unit test for ActiveEdge::calcLeft (can currently loop forever) | |

does ActiveEdge::isCoincidentWith need to support quad, cubic? | |

figure out why variation in ActiveEdge::tooCloseToCall isn't better | |

why does 'lastPtr - 2' in addIntersectingTs break testSimplifyTriangle22? | |

add code to promote quad to cubic, or add quad/cubic intersection | |

figure out why testSimplifySkinnyTriangle13 fails | |

for quadratics and cubics, once various T values are added, see if consecutive | |

Ts have ys that go up instead of down. If so, the edge needs to be broken. | |

when splitting curves at inflection pts, should I retain the original curve | |

data and note that the first/last T are no longer 0/1 ? | |

I need to figure this out before I can proceed | |

would it make sense to leave the InEdge alone, and add multiple copies of | |

ActiveEdge, pointing to the same InEdge, where the copy has only the subset | |

of Ts that need to be walked in reverse order? | |

-- A Digression Which Shows Why Resolving Coincidence Does Not Make Sense -- | |

Consider the following fine ASCII art: | |

+------>-------+ +------>-------+ | |

| | | | | |

^ V ^ V | |

| | | | | |

+------<-------+ +------<-------+ | |

+------>-------+ +------<-------+ | |

| | | | | |

^ V V ^ | |

| | | | | |

+------<-------+ +------>-------+ | |

(assume the bottom and top of the stacked rectangles are coincident) | |

Simplifying said rectangles, regardless of rectangle direction, and regardless | |

of winding or even/odd, eliminates the coincident edge, i.e., the result is | |

always: | |

+------>-------+ | |

| | | |

| | | |

| | | |

^ V | |

| | | |

| | | |

| | | |

+------<-------+ | |

But when the rectangles are enclosed in a larger rectangle: | |

+-------->---------+ +-------->---------+ | |

| +------>-------+ | | +------>-------+ | | |

| | | | | | | | | |

| ^ V | | ^ V | | |

| | | | | | | | | |

| +------<-------+ | | +------<-------+ | | |

| +------>-------+ | | +------<-------+ | | |

| | | | | | | | | |

| ^ V | | V ^ | | |

| | | | | | | | | |

| +------<-------+ | | +------>-------+ | | |

+--------<---------+ +--------<---------+ | |

Simplifying them gives different results depending on the winding setting: | |

winding: | |

+-------->---------+ +-------->---------+ | |

| | | | | |

| | | | | |

| | | | | |

| | | | | |

| | | +------<-------+ | | |

| | | | | | | |

| | | V ^ | | |

| | | | | | | |

| | | +------>-------+ | | |

+--------<---------+ +--------<---------+ | |

even odd: | |

+-------->---------+ +-------->---------+ | |

| +------<-------+ | | +------<-------+ | | |

| | | | | | | | | |

| | | | | | | | | |

| | | | | | | | | |

| | | | | | | | | |

| V ^ | | V ^ | | |

| | | | | | | | | |

| | | | | | | | | |

| | | | | | | | | |

| +------>-------+ | | +------>-------+ | | |

+--------<---------+ +--------<---------+ | |

So, given the inner rectangles alone (e.g., given coincident pairs in some local | |

context), we can't know whether to keep the coincident edges or not. | |

-- Thoughts About Sortless Ops -- | |

I can't come up with anything truly sortless. It seems that the crossings need | |

to be sorted to know which segment is next on the outside, although sometimes | |

we can use that it is not coincident just to follow the direction. | |

If it is coincident or if there's more than two crossing segments, sorting | |

seems inevitable. | |

Likewise, to resolve whether one contour is inside another, it seems that | |

sorting is required. Given a pair of segments on different contours, to know | |

if one is inside of the other, I need to know for each which side of the edge | |

is the inside/filled side. When the outer contour is walked, it seems like I | |

could record the inside info. I guess when the inner contour is found, its | |

inside sense is reversed (inside is above the top). But how do I know if the | |

next contour is inside another? Maybe shoot out a line and brute-force | |

intersect it with all the segments in all the other contours? If every contour | |

has an extra segment when the intersections are computed, this may not be as | |

crazy as it seems. | |

Suppose each contour has one extra segment shooting straight up from the top | |

(or straight up from any point on the segment). This ray is not intersected | |

with the home contour, but is intersected with all other contours as part of | |

the normal intersection engine. If it is possible to get from the T values to | |

the other segments to the other contours, it would be straightforward to | |

count the contour crossings and determine if the home contour is in another | |

contour or not (if the count is even, not, if odd, is inside). By itself that | |

doesn't tell us about winding, but it's a start. | |

Since intersecting these rays is unrelated to computing other intersections, | |

it can be lazily done once the contour is found. | |

So | |

repeat the following | |

find the top segment of all contours | |

trace the outside, marking touching first and last segments as inside | |

continue tracing the touched segments with reversed outside/inside sense | |

once the edges are exhausted, remaining must be disjoint contours | |

send a ray from a disjoint point through all other contours | |

count the crossings, determine if disjoint is inside or outside, then continue | |

=== | |

On Quadratic (and Cubic) Intersections | |

Currently, if only the end points touch, QuadracticIntersections does a lot of | |

work to figure that out. Can I test for that up front, then short circuit the | |

recursive search for the end points? | |

Or, is there something defective in the current approach that makes the end | |

point recursion go so deep? I'm seeing 56 stack frames (about 28 divides, but | |

thankfully, no splits) to find one matching endpoint. | |

Bezier curve focus may allow more quickly determining that end points with | |

identical tangents are practically coicident for some range of T, but I don't | |

understand the math yet to know. | |

Another approach is to determine how flat the curve is to make good guesses | |

about how far to move away in T before doing the intersection for the remainder | |

and/or to determine whether one curve is to the inside or outside of another. | |

According to Mike/Rob, the flatness for quadratics increases by 4 for each | |

subdivision, and a crude guess of the curvature can be had by comparing P1 to | |

(P0+P2)/2. By looking at the ULPS of the numbers, I can guess what value of | |

T may be far enough that the curves diverge but don't cross. | |

==== | |

Code I May Not Need Any More | |

static bool CoincidentCandidate(const Angle* current) { | |

const Segment* segment = current->segment(); | |

int min = SkMin32(current->start(), current->end()); | |

do { | |

const Span& span = segment->fTs[min]; | |

if (span.fCoincident == Span::kStart_Coincidence) { | |

return true; | |

} | |

} while (--min >= 0); | |

return false; | |

} | |

static bool CoincidentHalf(const Angle* current, const Angle* next) { | |

const Segment* other = next->segment(); | |

const Segment* segment = current->segment(); | |

int min = SkMin32(current->start(), current->end()); | |

const Span& minSpan = segment->fTs[min]; | |

if (minSpan.fOther == other) { | |

return minSpan.fCoincident == Span::kStart_Coincidence; | |

} | |

int index = min; | |

int spanCount = segment->fTs.count(); | |

while (++index < spanCount) { | |

const Span& span = segment->fTs[index]; | |

if (minSpan.fT != span.fT) { | |

break; | |

} | |

if (span.fOther != other) { | |

continue; | |

} | |

return span.fCoincident == Span::kStart_Coincidence; | |

} | |

index = min; | |

while (--index >= 0) { | |

const Span& span = segment->fTs[index]; | |

if (span.fOther != other) { | |

continue; | |

} | |

return span.fCoincident == Span::kStart_Coincidence; | |

} | |

return false; | |

} | |

static bool Coincident(const Angle* current, const Angle* next) { | |

return CoincidentHalf(current, next) && | |

CoincidentHalf(next, current); | |

} | |

// If three lines cancel in a - b - c order, a - b may or may not | |

// eliminate the edge that describes the b - c cancellation. Check done to | |

// determine this. | |

static bool CoincidentCancels(const Angle* current, const Angle* next) { | |

int curMin = SkMin32(current->start(), current->end()); | |

if (current->segment()->fTs[curMin].fDone) { | |

return false; | |

} | |

int nextMin = SkMin32(next->start(), next->end()); | |

if (next->segment()->fTs[nextMin].fDone) { | |

return false; | |

} | |

return SkSign32(current->start() - current->end()) | |

!= SkSign32(next->start() - next->end()); | |

} | |

// FIXME: at this point, just have two functions for the different steps | |

int coincidentEnd(int from, int step) const { | |

double fromT = fTs[from].fT; | |

int count = fTs.count(); | |

int to = from; | |

while (step > 0 ? ++to < count : --to >= 0) { | |

const Span& span = fTs[to]; | |

if ((step > 0 ? span.fT - fromT : fromT - span.fT) >= FLT_EPSILON ) { | |

// FIXME: we assume that if the T changes, we don't care about | |

// coincident -- but in nextSpan, we require that both the T | |

// and actual loc change to represent a span. This asymettry may | |

// be OK or may be trouble -- if trouble, probably will need to | |

// detect coincidence earlier or sort differently | |

break; | |

} | |

#if 01 | |

if (span.fCoincident == (step < 0 ? Span::kStart_Coincidence : | |

Span::kEnd_Coincidence)) { | |

from = to; | |

} | |

#else | |

from = to; | |

#endif | |

} | |

return from; | |

} | |

// once past current span, if step>0, look for coicident==1 | |

// if step<0, look for coincident==-1 | |

int nextSpanEnd(int from, int step) const { | |

int result = nextSpan(from, step); | |

if (result < 0) { | |

return result; | |

} | |

return coincidentEnd(result, step); | |

} | |

void adjustFirst(const SkTDArray<Angle*>& sorted, int& first, int& winding, | |

bool outside) { | |

int firstIndex = first; | |

int angleCount = sorted.count(); | |

if (true || outside) { | |

const Angle* angle = sorted[firstIndex]; | |

int prior = firstIndex; | |

do { | |

if (--prior < 0) { | |

prior = angleCount - 1; | |

} | |

if (prior == firstIndex) { // all are coincident with each other | |

return; | |

} | |

if (!Coincident(sorted[prior], sorted[first])) { | |

return; | |

} | |

winding += angle->sign(); | |

first = prior; | |

angle = sorted[prior]; | |

winding -= angle->sign(); | |

} while (true); | |

} | |

do { | |

int next = first + 1; | |

if (next == angleCount) { | |

next = 0; | |

} | |

if (next == firstIndex) { // all are coincident with each other | |

return; | |

} | |

if (!Coincident(sorted[first], sorted[next])) { | |

return; | |

} | |

first = next; | |

} while (true); | |

} | |

bool nextIsCoincident = CoincidentCandidate(nextAngle); | |

bool finalOrNoCoincident = true; | |

bool pairCoincides = false; | |

bool pairCancels = false; | |

if (nextIsCoincident) { | |

int followIndex = nextIndex + 1; | |

if (followIndex == angleCount) { | |

followIndex = 0; | |

} | |

const Angle* followAngle = sorted[followIndex]; | |

finalOrNoCoincident = !Coincident(nextAngle, followAngle); | |

if ((pairCoincides = Coincident(angle, nextAngle))) { | |

pairCancels = CoincidentCancels(angle, nextAngle); | |

} | |

} | |

if (pairCancels && !foundAngle && !nextSegment->done()) { | |

Segment* aSeg = angle->segment(); | |

// alreadyMarked |= aSeg == sorted[firstIndex]->segment(); | |

aSeg->markAndChaseCoincident(angle->start(), angle->end(), | |

nextSegment); | |

if (firstEdge) { | |

return NULL; | |

} | |

} | |

if (pairCoincides) { | |

if (pairCancels) { | |

goto doNext; | |

} | |

int minT = SkMin32(nextAngle->start(), nextAngle->end()); | |

bool markNext = abs(maxWinding) < abs(winding); | |

if (markNext) { | |

nextSegment->markDone(minT, winding); | |

} | |

int oldMinT = SkMin32(angle->start(), angle->end()); | |

if (true || !foundAngle) { | |

// SkASSERT(0); // do we ever get here? | |

Segment* aSeg = angle->segment(); | |

// alreadyMarked |= aSeg == sorted[firstIndex]->segment(); | |

aSeg->markDone(oldMinT, maxWinding); | |

} | |

} | |

// OPTIMIZATION: uses tail recursion. Unwise? | |

void innerCoincidentChase(int step, Segment* other) { | |

// find other at index | |

// SkASSERT(!done()); | |

const Span* start = NULL; | |

const Span* end = NULL; | |

int index, startIndex, endIndex; | |

int count = fTs.count(); | |

for (index = 0; index < count; ++index) { | |

const Span& span = fTs[index]; | |

if (!span.fCoincident || span.fOther != other) { | |

continue; | |

} | |

if (!start) { | |

startIndex = index; | |

start = &span; | |

} else { | |

SkASSERT(!end); | |

endIndex = index; | |

end = &span; | |

} | |

} | |

if (!end) { | |

return; | |

} | |

bool thisDone = fTs[SkMin32(startIndex, endIndex)].fDone; | |

bool otherDone = other->fTs[SkMin32(start->fOtherIndex, | |

end->fOtherIndex)].fDone; | |

if (thisDone && otherDone) { | |

return; | |

} | |

Segment* next; | |

Segment* nextOther; | |

if (step < 0) { | |

next = start->fT == 0 ? NULL : this; | |

nextOther = other->fTs[start->fOtherIndex].fT > 1 - FLT_EPSILON ? NULL : other; | |

} else { | |

next = end->fT == 1 ? NULL : this; | |

nextOther = other->fTs[end->fOtherIndex].fT < FLT_EPSILON ? NULL : other; | |

} | |

SkASSERT(!next || !nextOther); | |

for (index = 0; index < count; ++index) { | |

const Span& span = fTs[index]; | |

if (span.fCoincident || span.fOther == other) { | |

continue; | |

} | |

bool checkNext = !next && (step < 0 ? span.fT < FLT_EPSILON | |

&& span.fOtherT > 1 - FLT_EPSILON : span.fT > 1 - FLT_EPSILON | |

&& span.fOtherT < FLT_EPSILON); | |

bool checkOther = !nextOther && (step < 0 ? fabs(span.fT - start->fT) < FLT_EPSILON | |

&& span.fOtherT < FLT_EPSILON : fabs(span.fT - end->fT) < FLT_EPSILON | |

&& span.fOtherT > 1 - FLT_EPSILON); | |

if (!checkNext && !checkOther) { | |

continue; | |

} | |

Segment* oSegment = span.fOther; | |

if (oSegment->done()) { | |

continue; | |

} | |

int oCount = oSegment->fTs.count(); | |

for (int oIndex = 0; oIndex < oCount; ++oIndex) { | |

const Span& oSpan = oSegment->fTs[oIndex]; | |

if (oSpan.fT >= FLT_EPSILON && oSpan.fT <= 1 - FLT_EPSILON) { | |

continue; | |

} | |

if (!oSpan.fCoincident) { | |

continue; | |

} | |

if (checkNext && (oSpan.fT < FLT_EPSILON ^ step < 0)) { | |

next = oSegment; | |

checkNext = false; | |

} | |

if (checkOther && (oSpan.fT > 1 - FLT_EPSILON ^ step < 0)) { | |

nextOther = oSegment; | |

checkOther = false; | |

} | |

} | |

} | |

// this needs to walk both spans in lock step, skipping edges that | |

// are already marked done on one or the other | |

markCanceled(startIndex, endIndex); | |

if (next && nextOther) { | |

next->innerCoincidentChase(step, nextOther); | |

} | |

} | |

// cancel coincident edges in lock step | |

void markCanceled(int start, int end) { | |

if (done()) { | |

return; | |

} | |

Segment* other = fTs[start].fOther; | |

if (other->done()) { | |

return; | |

} | |

if (start > end) { | |

SkTSwap<int>(start, end); | |

} | |

double maxT = fTs[end].fT - FLT_EPSILON; | |

int spanCount = fTs.count(); | |

// since these cancel, this walks up and other walks down | |

int oStart = fTs[start].fOtherIndex; | |

double oStartT = other->fTs[oStart].fT; | |

while (oStartT - other->fTs[--oStart].fT < FLT_EPSILON) | |

; | |

double startT = fTs[start].fT; | |

while (start > 0 && startT - fTs[start - 1].fT < FLT_EPSILON) { | |

--start; | |

} | |

do { | |

Span* span = &fTs[start]; | |

Span* oSpan = &other->fTs[oStart]; | |

// find start of each, and see if both are not done | |

bool markDone = !span->fDone && !oSpan->fDone; | |

double spanT = span->fT; | |

do { | |

if (markDone) { | |

span->fCanceled = true; | |

#if DEBUG_MARK_DONE | |

const SkPoint& pt = xyAtT(span); | |

SkDebugf("%s segment=%d index=%d t=%1.9g pt=(%1.9g,%1.9g)\n", | |

__FUNCTION__, fID, start, span->fT, pt.fX, pt.fY); | |

#endif | |

SkASSERT(!span->fDone); | |

span->fDone = true; | |

span->fWinding = 0; | |

fDoneSpans++; | |

} | |

if (++start == spanCount) { | |

break; | |

} | |

span = &fTs[start]; | |

} while (span->fT - spanT < FLT_EPSILON); | |

double oSpanT = oSpan->fT; | |

do { | |

if (markDone) { | |

oSpan->fCanceled = true; | |

#if DEBUG_MARK_DONE | |

const SkPoint& oPt = xyAtT(oSpan); | |

SkDebugf("%s segment=%d index=%d t=%1.9g pt=(%1.9g,%1.9g)\n", | |

__FUNCTION__, other->fID, oStart, oSpan->fT, | |

oPt.fX, oPt.fY); | |

#endif | |

SkASSERT(!oSpan->fDone); | |

oSpan->fDone = true; | |

oSpan->fWinding = 0; | |

other->fDoneSpans++; | |

} | |

if (--oStart < 0) { | |

break; | |

} | |

oSpan = &other->fTs[oStart]; | |

} while (oSpanT - oSpan->fT < FLT_EPSILON); | |

} while (fTs[start].fT <= maxT); | |

} | |

bool canceled(int start, int end) const { | |

int min = SkMin32(start, end); | |

return fTs[min].fCanceled; | |

} | |

void markAndChaseCoincident(int index, int endIndex, Segment* other) { | |

int step = SkSign32(endIndex - index); | |

innerCoincidentChase(step, other); | |

} | |