1 Clazz.declarePackage ("jssun.awt.geom");
\r
2 Clazz.load (null, "jssun.awt.geom.Curve", ["java.lang.Double", "$.InternalError", "java.awt.geom.IllegalPathStateException"], function () {
\r
3 c$ = Clazz.decorateAsClass (function () {
\r
5 Clazz.instantialize (this, arguments);
\r
6 }, jssun.awt.geom, "Curve");
\r
7 c$.insertMove = Clazz.defineMethod (c$, "insertMove",
\r
8 function (curves, x, y) {
\r
9 curves.add ( new jssun.awt.geom.Order0 (x, y));
\r
10 }, "java.util.Vector,~N,~N");
\r
11 c$.insertLine = Clazz.defineMethod (c$, "insertLine",
\r
12 function (curves, x0, y0, x1, y1) {
\r
14 curves.add ( new jssun.awt.geom.Order1 (x0, y0, x1, y1, 1));
\r
15 } else if (y0 > y1) {
\r
16 curves.add ( new jssun.awt.geom.Order1 (x1, y1, x0, y0, -1));
\r
18 }}, "java.util.Vector,~N,~N,~N,~N");
\r
19 c$.insertQuad = Clazz.defineMethod (c$, "insertQuad",
\r
20 function (curves, x0, y0, coords) {
\r
23 jssun.awt.geom.Order2.insert (curves, coords, coords[2], y1, coords[0], coords[1], x0, y0, -1);
\r
24 } else if (y0 == y1 && y0 == coords[1]) {
\r
27 jssun.awt.geom.Order2.insert (curves, coords, x0, y0, coords[0], coords[1], coords[2], y1, 1);
\r
28 }}, "java.util.Vector,~N,~N,~A");
\r
29 c$.insertCubic = Clazz.defineMethod (c$, "insertCubic",
\r
30 function (curves, x0, y0, coords) {
\r
33 jssun.awt.geom.Order3.insert (curves, coords, coords[4], y1, coords[2], coords[3], coords[0], coords[1], x0, y0, -1);
\r
34 } else if (y0 == y1 && y0 == coords[1] && y0 == coords[3]) {
\r
37 jssun.awt.geom.Order3.insert (curves, coords, x0, y0, coords[0], coords[1], coords[2], coords[3], coords[4], y1, 1);
\r
38 }}, "java.util.Vector,~N,~N,~A");
\r
39 c$.pointCrossingsForPath = Clazz.defineMethod (c$, "pointCrossingsForPath",
\r
40 function (pi, px, py) {
\r
43 }var coords = Clazz.newDoubleArray (6, 0);
\r
44 if (pi.currentSegment (coords) != 0) {
\r
45 throw new java.awt.geom.IllegalPathStateException ("missing initial moveto in path definition");
\r
47 var movx = coords[0];
\r
48 var movy = coords[1];
\r
54 while (!pi.isDone ()) {
\r
55 switch (pi.currentSegment (coords)) {
\r
58 crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);
\r
59 }movx = curx = coords[0];
\r
60 movy = cury = coords[1];
\r
65 crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, endx, endy);
\r
72 crossings += jssun.awt.geom.Curve.pointCrossingsForQuad (px, py, curx, cury, coords[0], coords[1], endx, endy, 0);
\r
79 crossings += jssun.awt.geom.Curve.pointCrossingsForCubic (px, py, curx, cury, coords[0], coords[1], coords[2], coords[3], endx, endy, 0);
\r
85 crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);
\r
93 crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);
\r
95 }, "java.awt.geom.PathIterator,~N,~N");
\r
96 c$.pointCrossingsForLine = Clazz.defineMethod (c$, "pointCrossingsForLine",
\r
97 function (px, py, x0, y0, x1, y1) {
\r
98 if (py < y0 && py < y1) return 0;
\r
99 if (py >= y0 && py >= y1) return 0;
\r
100 if (px >= x0 && px >= x1) return 0;
\r
101 if (px < x0 && px < x1) return (y0 < y1) ? 1 : -1;
\r
102 var xintercept = x0 + (py - y0) * (x1 - x0) / (y1 - y0);
\r
103 if (px >= xintercept) return 0;
\r
104 return (y0 < y1) ? 1 : -1;
\r
105 }, "~N,~N,~N,~N,~N,~N");
\r
106 c$.pointCrossingsForQuad = Clazz.defineMethod (c$, "pointCrossingsForQuad",
\r
107 function (px, py, x0, y0, xc, yc, x1, y1, level) {
\r
108 if (py < y0 && py < yc && py < y1) return 0;
\r
109 if (py >= y0 && py >= yc && py >= y1) return 0;
\r
110 if (px >= x0 && px >= xc && px >= x1) return 0;
\r
111 if (px < x0 && px < xc && px < x1) {
\r
113 if (py < y1) return 1;
\r
115 if (py >= y1) return -1;
\r
117 }if (level > 52) return jssun.awt.geom.Curve.pointCrossingsForLine (px, py, x0, y0, x1, y1);
\r
118 var x0c = (x0 + xc) / 2;
\r
119 var y0c = (y0 + yc) / 2;
\r
120 var xc1 = (xc + x1) / 2;
\r
121 var yc1 = (yc + y1) / 2;
\r
122 xc = (x0c + xc1) / 2;
\r
123 yc = (y0c + yc1) / 2;
\r
124 if (Double.isNaN (xc) || Double.isNaN (yc)) {
\r
126 }return (jssun.awt.geom.Curve.pointCrossingsForQuad (px, py, x0, y0, x0c, y0c, xc, yc, level + 1) + jssun.awt.geom.Curve.pointCrossingsForQuad (px, py, xc, yc, xc1, yc1, x1, y1, level + 1));
\r
127 }, "~N,~N,~N,~N,~N,~N,~N,~N,~N");
\r
128 c$.pointCrossingsForCubic = Clazz.defineMethod (c$, "pointCrossingsForCubic",
\r
129 function (px, py, x0, y0, xc0, yc0, xc1, yc1, x1, y1, level) {
\r
130 if (py < y0 && py < yc0 && py < yc1 && py < y1) return 0;
\r
131 if (py >= y0 && py >= yc0 && py >= yc1 && py >= y1) return 0;
\r
132 if (px >= x0 && px >= xc0 && px >= xc1 && px >= x1) return 0;
\r
133 if (px < x0 && px < xc0 && px < xc1 && px < x1) {
\r
135 if (py < y1) return 1;
\r
137 if (py >= y1) return -1;
\r
139 }if (level > 52) return jssun.awt.geom.Curve.pointCrossingsForLine (px, py, x0, y0, x1, y1);
\r
140 var xmid = (xc0 + xc1) / 2;
\r
141 var ymid = (yc0 + yc1) / 2;
\r
142 xc0 = (x0 + xc0) / 2;
\r
143 yc0 = (y0 + yc0) / 2;
\r
144 xc1 = (xc1 + x1) / 2;
\r
145 yc1 = (yc1 + y1) / 2;
\r
146 var xc0m = (xc0 + xmid) / 2;
\r
147 var yc0m = (yc0 + ymid) / 2;
\r
148 var xmc1 = (xmid + xc1) / 2;
\r
149 var ymc1 = (ymid + yc1) / 2;
\r
150 xmid = (xc0m + xmc1) / 2;
\r
151 ymid = (yc0m + ymc1) / 2;
\r
152 if (Double.isNaN (xmid) || Double.isNaN (ymid)) {
\r
154 }return (jssun.awt.geom.Curve.pointCrossingsForCubic (px, py, x0, y0, xc0, yc0, xc0m, yc0m, xmid, ymid, level + 1) + jssun.awt.geom.Curve.pointCrossingsForCubic (px, py, xmid, ymid, xmc1, ymc1, xc1, yc1, x1, y1, level + 1));
\r
155 }, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");
\r
156 c$.rectCrossingsForPath = Clazz.defineMethod (c$, "rectCrossingsForPath",
\r
157 function (pi, rxmin, rymin, rxmax, rymax) {
\r
158 if (rxmax <= rxmin || rymax <= rymin) {
\r
160 }if (pi.isDone ()) {
\r
162 }var coords = Clazz.newDoubleArray (6, 0);
\r
163 if (pi.currentSegment (coords) != 0) {
\r
164 throw new java.awt.geom.IllegalPathStateException ("missing initial moveto in path definition");
\r
172 curx = movx = coords[0];
\r
173 cury = movy = coords[1];
\r
175 while (crossings != -2147483648 && !pi.isDone ()) {
\r
176 switch (pi.currentSegment (coords)) {
\r
178 if (curx != movx || cury != movy) {
\r
179 crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);
\r
180 }movx = curx = coords[0];
\r
181 movy = cury = coords[1];
\r
186 crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, endx, endy);
\r
193 crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, curx, cury, coords[0], coords[1], endx, endy, 0);
\r
200 crossings = jssun.awt.geom.Curve.rectCrossingsForCubic (crossings, rxmin, rymin, rxmax, rymax, curx, cury, coords[0], coords[1], coords[2], coords[3], endx, endy, 0);
\r
205 if (curx != movx || cury != movy) {
\r
206 crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);
\r
213 if (crossings != -2147483648 && (curx != movx || cury != movy)) {
\r
214 crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);
\r
216 }, "java.awt.geom.PathIterator,~N,~N,~N,~N");
\r
217 c$.rectCrossingsForLine = Clazz.defineMethod (c$, "rectCrossingsForLine",
\r
218 function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1) {
\r
219 if (y0 >= rymax && y1 >= rymax) return crossings;
\r
220 if (y0 <= rymin && y1 <= rymin) return crossings;
\r
221 if (x0 <= rxmin && x1 <= rxmin) return crossings;
\r
222 if (x0 >= rxmax && x1 >= rxmax) {
\r
224 if (y0 <= rymin) crossings++;
\r
225 if (y1 >= rymax) crossings++;
\r
226 } else if (y1 < y0) {
\r
227 if (y1 <= rymin) crossings--;
\r
228 if (y0 >= rymax) crossings--;
\r
230 }if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) || (x1 > rxmin && x1 < rxmax && y1 > rymin && y1 < rymax)) {
\r
231 return -2147483648;
\r
234 xi0 += ((rymin - y0) * (x1 - x0) / (y1 - y0));
\r
235 } else if (y0 > rymax) {
\r
236 xi0 += ((rymax - y0) * (x1 - x0) / (y1 - y0));
\r
239 xi1 += ((rymin - y1) * (x0 - x1) / (y0 - y1));
\r
240 } else if (y1 > rymax) {
\r
241 xi1 += ((rymax - y1) * (x0 - x1) / (y0 - y1));
\r
242 }if (xi0 <= rxmin && xi1 <= rxmin) return crossings;
\r
243 if (xi0 >= rxmax && xi1 >= rxmax) {
\r
245 if (y0 <= rymin) crossings++;
\r
246 if (y1 >= rymax) crossings++;
\r
247 } else if (y1 < y0) {
\r
248 if (y1 <= rymin) crossings--;
\r
249 if (y0 >= rymax) crossings--;
\r
251 }return -2147483648;
\r
252 }, "~N,~N,~N,~N,~N,~N,~N,~N,~N");
\r
253 c$.rectCrossingsForQuad = Clazz.defineMethod (c$, "rectCrossingsForQuad",
\r
254 function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc, yc, x1, y1, level) {
\r
255 if (y0 >= rymax && yc >= rymax && y1 >= rymax) return crossings;
\r
256 if (y0 <= rymin && yc <= rymin && y1 <= rymin) return crossings;
\r
257 if (x0 <= rxmin && xc <= rxmin && x1 <= rxmin) return crossings;
\r
258 if (x0 >= rxmax && xc >= rxmax && x1 >= rxmax) {
\r
260 if (y0 <= rymin && y1 > rymin) crossings++;
\r
261 if (y0 < rymax && y1 >= rymax) crossings++;
\r
262 } else if (y1 < y0) {
\r
263 if (y1 <= rymin && y0 > rymin) crossings--;
\r
264 if (y1 < rymax && y0 >= rymax) crossings--;
\r
266 }if ((x0 < rxmax && x0 > rxmin && y0 < rymax && y0 > rymin) || (x1 < rxmax && x1 > rxmin && y1 < rymax && y1 > rymin)) {
\r
267 return -2147483648;
\r
269 return jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1);
\r
270 }var x0c = (x0 + xc) / 2;
\r
271 var y0c = (y0 + yc) / 2;
\r
272 var xc1 = (xc + x1) / 2;
\r
273 var yc1 = (yc + y1) / 2;
\r
274 xc = (x0c + xc1) / 2;
\r
275 yc = (y0c + yc1) / 2;
\r
276 if (Double.isNaN (xc) || Double.isNaN (yc)) {
\r
278 }crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x0c, y0c, xc, yc, level + 1);
\r
279 if (crossings != -2147483648) {
\r
280 crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, xc, yc, xc1, yc1, x1, y1, level + 1);
\r
282 }, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");
\r
283 c$.rectCrossingsForCubic = Clazz.defineMethod (c$, "rectCrossingsForCubic",
\r
284 function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc0, yc0, xc1, yc1, x1, y1, level) {
\r
285 if (y0 >= rymax && yc0 >= rymax && yc1 >= rymax && y1 >= rymax) {
\r
287 }if (y0 <= rymin && yc0 <= rymin && yc1 <= rymin && y1 <= rymin) {
\r
289 }if (x0 <= rxmin && xc0 <= rxmin && xc1 <= rxmin && x1 <= rxmin) {
\r
291 }if (x0 >= rxmax && xc0 >= rxmax && xc1 >= rxmax && x1 >= rxmax) {
\r
293 if (y0 <= rymin && y1 > rymin) crossings++;
\r
294 if (y0 < rymax && y1 >= rymax) crossings++;
\r
295 } else if (y1 < y0) {
\r
296 if (y1 <= rymin && y0 > rymin) crossings--;
\r
297 if (y1 < rymax && y0 >= rymax) crossings--;
\r
299 }if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) || (x1 > rxmin && x1 < rxmax && y1 > rymin && y1 < rymax)) {
\r
300 return -2147483648;
\r
302 return jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1);
\r
303 }var xmid = (xc0 + xc1) / 2;
\r
304 var ymid = (yc0 + yc1) / 2;
\r
305 xc0 = (x0 + xc0) / 2;
\r
306 yc0 = (y0 + yc0) / 2;
\r
307 xc1 = (xc1 + x1) / 2;
\r
308 yc1 = (yc1 + y1) / 2;
\r
309 var xc0m = (xc0 + xmid) / 2;
\r
310 var yc0m = (yc0 + ymid) / 2;
\r
311 var xmc1 = (xmid + xc1) / 2;
\r
312 var ymc1 = (ymid + yc1) / 2;
\r
313 xmid = (xc0m + xmc1) / 2;
\r
314 ymid = (yc0m + ymc1) / 2;
\r
315 if (Double.isNaN (xmid) || Double.isNaN (ymid)) {
\r
317 }crossings = jssun.awt.geom.Curve.rectCrossingsForCubic (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc0, yc0, xc0m, yc0m, xmid, ymid, level + 1);
\r
318 if (crossings != -2147483648) {
\r
319 crossings = jssun.awt.geom.Curve.rectCrossingsForCubic (crossings, rxmin, rymin, rxmax, rymax, xmid, ymid, xmc1, ymc1, xc1, yc1, x1, y1, level + 1);
\r
321 }, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");
\r
322 Clazz.makeConstructor (c$,
\r
323 function (direction) {
\r
324 this.direction = direction;
\r
326 Clazz.defineMethod (c$, "getDirection",
\r
328 return this.direction;
\r
330 Clazz.defineMethod (c$, "getWithDirection",
\r
331 function (direction) {
\r
332 return (this.direction == direction ? this : this.getReversedCurve ());
\r
334 c$.round = Clazz.defineMethod (c$, "round",
\r
338 c$.orderof = Clazz.defineMethod (c$, "orderof",
\r
339 function (x1, x2) {
\r
346 c$.signeddiffbits = Clazz.defineMethod (c$, "signeddiffbits",
\r
347 function (y1, y2) {
\r
348 return (Double.doubleToLongBits (y1) - Double.doubleToLongBits (y2));
\r
350 c$.diffbits = Clazz.defineMethod (c$, "diffbits",
\r
351 function (y1, y2) {
\r
352 return Math.abs (Double.doubleToLongBits (y1) - Double.doubleToLongBits (y2));
\r
354 c$.prev = Clazz.defineMethod (c$, "prev",
\r
356 return Double.longBitsToDouble (Double.doubleToLongBits (v) - 1);
\r
358 c$.next = Clazz.defineMethod (c$, "next",
\r
360 return Double.longBitsToDouble (Double.doubleToLongBits (v) + 1);
\r
362 Clazz.overrideMethod (c$, "toString",
\r
364 return ("Curve[" + this.getOrder () + ", " + ("(" + jssun.awt.geom.Curve.round (this.getX0 ()) + ", " + jssun.awt.geom.Curve.round (this.getY0 ()) + "), ") + this.controlPointString () + ("(" + jssun.awt.geom.Curve.round (this.getX1 ()) + ", " + jssun.awt.geom.Curve.round (this.getY1 ()) + "), ") + (this.direction == 1 ? "D" : "U") + "]");
\r
366 Clazz.defineMethod (c$, "controlPointString",
\r
370 Clazz.defineMethod (c$, "crossingsFor",
\r
372 if (y >= this.getYTop () && y < this.getYBot ()) {
\r
373 if (x < this.getXMax () && (x < this.getXMin () || x < this.XforY (y))) {
\r
377 Clazz.defineMethod (c$, "accumulateCrossings",
\r
379 var xhi = c.getXHi ();
\r
380 if (this.getXMin () >= xhi) {
\r
382 }var xlo = c.getXLo ();
\r
383 var ylo = c.getYLo ();
\r
384 var yhi = c.getYHi ();
\r
385 var y0 = this.getYTop ();
\r
386 var y1 = this.getYBot ();
\r
395 tstart = this.TforY (ylo);
\r
403 tend = this.TforY (yhi);
\r
407 }var hitLo = false;
\r
410 var x = this.XforT (tstart);
\r
412 if (hitHi || x > xlo) {
\r
419 }if (tstart >= tend) {
\r
421 }tstart = this.nextVertical (tstart, tend);
\r
424 c.record (ystart, yend, this.direction);
\r
426 }, "jssun.awt.geom.Crossings");
\r
427 Clazz.defineMethod (c$, "getSubCurve",
\r
428 function (ystart, yend) {
\r
429 return this.getSubCurve (ystart, yend, this.direction);
\r
431 Clazz.defineMethod (c$, "compareTo",
\r
432 function (that, yrange) {
\r
433 var y0 = yrange[0];
\r
434 var y1 = yrange[1];
\r
435 y1 = Math.min (Math.min (y1, this.getYBot ()), that.getYBot ());
\r
436 if (y1 <= yrange[0]) {
\r
437 System.err.println ("this == " + this);
\r
438 System.err.println ("that == " + that);
\r
439 System.out.println ("target range = " + yrange[0] + "=>" + yrange[1]);
\r
440 throw new InternalError ("backstepping from " + yrange[0] + " to " + y1);
\r
442 if (this.getXMax () <= that.getXMin ()) {
\r
443 if (this.getXMin () == that.getXMax ()) {
\r
446 }if (this.getXMin () >= that.getXMax ()) {
\r
448 }var s0 = this.TforY (y0);
\r
449 var ys0 = this.YforT (s0);
\r
451 s0 = this.refineTforY (s0, ys0, y0);
\r
452 ys0 = this.YforT (s0);
\r
453 }var s1 = this.TforY (y1);
\r
454 if (this.YforT (s1) < y0) {
\r
455 s1 = this.refineTforY (s1, this.YforT (s1), y0);
\r
456 }var t0 = that.TforY (y0);
\r
457 var yt0 = that.YforT (t0);
\r
459 t0 = that.refineTforY (t0, yt0, y0);
\r
460 yt0 = that.YforT (t0);
\r
461 }var t1 = that.TforY (y1);
\r
462 if (that.YforT (t1) < y0) {
\r
463 t1 = that.refineTforY (t1, that.YforT (t1), y0);
\r
464 }var xs0 = this.XforT (s0);
\r
465 var xt0 = that.XforT (t0);
\r
466 var scale = Math.max (Math.abs (y0), Math.abs (y1));
\r
467 var ymin = Math.max (scale * 1E-14, 1E-300);
\r
468 if (this.fairlyClose (xs0, xt0)) {
\r
470 var maxbump = Math.min (ymin * 1E13, (y1 - y0) * .1);
\r
473 if (this.fairlyClose (this.XforY (y), that.XforY (y))) {
\r
474 if ((bump *= 2) > maxbump) {
\r
480 var newy = y + bump;
\r
483 }if (this.fairlyClose (this.XforY (newy), that.XforY (newy))) {
\r
494 System.out.println ("ymin = " + ymin);
\r
495 }while (s0 < s1 && t0 < t1) {
\r
496 var sh = this.nextVertical (s0, s1);
\r
497 var xsh = this.XforT (sh);
\r
498 var ysh = this.YforT (sh);
\r
499 var th = that.nextVertical (t0, t1);
\r
500 var xth = that.XforT (th);
\r
501 var yth = that.YforT (th);
\r
503 if (this.findIntersect (that, yrange, ymin, 0, 0, s0, xs0, ys0, sh, xsh, ysh, t0, xt0, yt0, th, xth, yth)) {
\r
506 System.err.println ("Error: " + t);
\r
507 System.err.println ("y range was " + yrange[0] + "=>" + yrange[1]);
\r
508 System.err.println ("s y range is " + ys0 + "=>" + ysh);
\r
509 System.err.println ("t y range is " + yt0 + "=>" + yth);
\r
510 System.err.println ("ymin is " + ymin);
\r
514 if (ysh > yrange[0]) {
\r
515 if (ysh < yrange[1]) {
\r
522 if (yth > yrange[0]) {
\r
523 if (yth < yrange[1]) {
\r
530 var ymid = (yrange[0] + yrange[1]) / 2;
\r
531 return jssun.awt.geom.Curve.orderof (this.XforY (ymid), that.XforY (ymid));
\r
532 }, "jssun.awt.geom.Curve,~A");
\r
533 Clazz.defineMethod (c$, "findIntersect",
\r
534 function (that, yrange, ymin, slevel, tlevel, s0, xs0, ys0, s1, xs1, ys1, t0, xt0, yt0, t1, xt1, yt1) {
\r
535 if (ys0 > yt1 || yt0 > ys1) {
\r
537 }if (Math.min (xs0, xs1) > Math.max (xt0, xt1) || Math.max (xs0, xs1) < Math.min (xt0, xt1)) {
\r
539 }if (s1 - s0 > 0.001) {
\r
540 var s = (s0 + s1) / 2;
\r
541 var xs = this.XforT (s);
\r
542 var ys = this.YforT (s);
\r
543 if (s == s0 || s == s1) {
\r
544 System.out.println ("s0 = " + s0);
\r
545 System.out.println ("s1 = " + s1);
\r
546 throw new InternalError ("no s progress!");
\r
547 }if (t1 - t0 > 0.001) {
\r
548 var t = (t0 + t1) / 2;
\r
549 var xt = that.XforT (t);
\r
550 var yt = that.YforT (t);
\r
551 if (t == t0 || t == t1) {
\r
552 System.out.println ("t0 = " + t0);
\r
553 System.out.println ("t1 = " + t1);
\r
554 throw new InternalError ("no t progress!");
\r
555 }if (ys >= yt0 && yt >= ys0) {
\r
556 if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s0, xs0, ys0, s, xs, ys, t0, xt0, yt0, t, xt, yt)) {
\r
559 if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s0, xs0, ys0, s, xs, ys, t, xt, yt, t1, xt1, yt1)) {
\r
562 if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s, xs, ys, s1, xs1, ys1, t0, xt0, yt0, t, xt, yt)) {
\r
564 }}if (ys1 >= yt && yt1 >= ys) {
\r
565 if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s, xs, ys, s1, xs1, ys1, t, xt, yt, t1, xt1, yt1)) {
\r
569 if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel, s0, xs0, ys0, s, xs, ys, t0, xt0, yt0, t1, xt1, yt1)) {
\r
572 if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel, s, xs, ys, s1, xs1, ys1, t0, xt0, yt0, t1, xt1, yt1)) {
\r
574 }}}} else if (t1 - t0 > 0.001) {
\r
575 var t = (t0 + t1) / 2;
\r
576 var xt = that.XforT (t);
\r
577 var yt = that.YforT (t);
\r
578 if (t == t0 || t == t1) {
\r
579 System.out.println ("t0 = " + t0);
\r
580 System.out.println ("t1 = " + t1);
\r
581 throw new InternalError ("no t progress!");
\r
583 if (this.findIntersect (that, yrange, ymin, slevel, tlevel + 1, s0, xs0, ys0, s1, xs1, ys1, t0, xt0, yt0, t, xt, yt)) {
\r
586 if (this.findIntersect (that, yrange, ymin, slevel, tlevel + 1, s0, xs0, ys0, s1, xs1, ys1, t, xt, yt, t1, xt1, yt1)) {
\r
589 var xlk = xs1 - xs0;
\r
590 var ylk = ys1 - ys0;
\r
591 var xnm = xt1 - xt0;
\r
592 var ynm = yt1 - yt0;
\r
593 var xmk = xt0 - xs0;
\r
594 var ymk = yt0 - ys0;
\r
595 var det = xnm * ylk - ynm * xlk;
\r
597 var detinv = 1 / det;
\r
598 var s = (xnm * ymk - ynm * xmk) * detinv;
\r
599 var t = (xlk * ymk - ylk * xmk) * detinv;
\r
600 if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
\r
601 s = s0 + s * (s1 - s0);
\r
602 t = t0 + t * (t1 - t0);
\r
603 if (s < 0 || s > 1 || t < 0 || t > 1) {
\r
604 System.out.println ("Uh oh!");
\r
605 }var y = (this.YforT (s) + that.YforT (t)) / 2;
\r
606 if (y <= yrange[1] && y > yrange[0]) {
\r
610 }, "jssun.awt.geom.Curve,~A,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");
\r
611 Clazz.defineMethod (c$, "refineTforY",
\r
612 function (t0, yt0, y0) {
\r
615 var th = (t0 + t1) / 2;
\r
616 if (th == t0 || th == t1) {
\r
618 }var y = this.YforT (th);
\r
622 } else if (y > y0) {
\r
628 Clazz.defineMethod (c$, "fairlyClose",
\r
629 function (v1, v2) {
\r
630 return (Math.abs (v1 - v2) < Math.max (Math.abs (v1), Math.abs (v2)) * 1E-10);
\r
632 Clazz.defineStatics (c$,
\r
635 "RECT_INTERSECTS", 0x80000000,
\r