-Clazz.declarePackage ("jssun.awt.geom");\r
-Clazz.load (null, "jssun.awt.geom.Curve", ["java.lang.Double", "$.InternalError", "java.awt.geom.IllegalPathStateException"], function () {\r
-c$ = Clazz.decorateAsClass (function () {\r
-this.direction = 0;\r
-Clazz.instantialize (this, arguments);\r
-}, jssun.awt.geom, "Curve");\r
-c$.insertMove = Clazz.defineMethod (c$, "insertMove", \r
-function (curves, x, y) {\r
-curves.add ( new jssun.awt.geom.Order0 (x, y));\r
-}, "java.util.Vector,~N,~N");\r
-c$.insertLine = Clazz.defineMethod (c$, "insertLine", \r
-function (curves, x0, y0, x1, y1) {\r
-if (y0 < y1) {\r
-curves.add ( new jssun.awt.geom.Order1 (x0, y0, x1, y1, 1));\r
-} else if (y0 > y1) {\r
-curves.add ( new jssun.awt.geom.Order1 (x1, y1, x0, y0, -1));\r
-} else {\r
-}}, "java.util.Vector,~N,~N,~N,~N");\r
-c$.insertQuad = Clazz.defineMethod (c$, "insertQuad", \r
-function (curves, x0, y0, coords) {\r
-var y1 = coords[3];\r
-if (y0 > y1) {\r
-jssun.awt.geom.Order2.insert (curves, coords, coords[2], y1, coords[0], coords[1], x0, y0, -1);\r
-} else if (y0 == y1 && y0 == coords[1]) {\r
-return;\r
-} else {\r
-jssun.awt.geom.Order2.insert (curves, coords, x0, y0, coords[0], coords[1], coords[2], y1, 1);\r
-}}, "java.util.Vector,~N,~N,~A");\r
-c$.insertCubic = Clazz.defineMethod (c$, "insertCubic", \r
-function (curves, x0, y0, coords) {\r
-var y1 = coords[5];\r
-if (y0 > y1) {\r
-jssun.awt.geom.Order3.insert (curves, coords, coords[4], y1, coords[2], coords[3], coords[0], coords[1], x0, y0, -1);\r
-} else if (y0 == y1 && y0 == coords[1] && y0 == coords[3]) {\r
-return;\r
-} else {\r
-jssun.awt.geom.Order3.insert (curves, coords, x0, y0, coords[0], coords[1], coords[2], coords[3], coords[4], y1, 1);\r
-}}, "java.util.Vector,~N,~N,~A");\r
-c$.pointCrossingsForPath = Clazz.defineMethod (c$, "pointCrossingsForPath", \r
-function (pi, px, py) {\r
-if (pi.isDone ()) {\r
-return 0;\r
-}var coords = Clazz.newDoubleArray (6, 0);\r
-if (pi.currentSegment (coords) != 0) {\r
-throw new java.awt.geom.IllegalPathStateException ("missing initial moveto in path definition");\r
-}pi.next ();\r
-var movx = coords[0];\r
-var movy = coords[1];\r
-var curx = movx;\r
-var cury = movy;\r
-var endx;\r
-var endy;\r
-var crossings = 0;\r
-while (!pi.isDone ()) {\r
-switch (pi.currentSegment (coords)) {\r
-case 0:\r
-if (cury != movy) {\r
-crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);\r
-}movx = curx = coords[0];\r
-movy = cury = coords[1];\r
-break;\r
-case 1:\r
-endx = coords[0];\r
-endy = coords[1];\r
-crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, endx, endy);\r
-curx = endx;\r
-cury = endy;\r
-break;\r
-case 2:\r
-endx = coords[2];\r
-endy = coords[3];\r
-crossings += jssun.awt.geom.Curve.pointCrossingsForQuad (px, py, curx, cury, coords[0], coords[1], endx, endy, 0);\r
-curx = endx;\r
-cury = endy;\r
-break;\r
-case 3:\r
-endx = coords[4];\r
-endy = coords[5];\r
-crossings += jssun.awt.geom.Curve.pointCrossingsForCubic (px, py, curx, cury, coords[0], coords[1], coords[2], coords[3], endx, endy, 0);\r
-curx = endx;\r
-cury = endy;\r
-break;\r
-case 4:\r
-if (cury != movy) {\r
-crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);\r
-}curx = movx;\r
-cury = movy;\r
-break;\r
-}\r
-pi.next ();\r
-}\r
-if (cury != movy) {\r
-crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);\r
-}return crossings;\r
-}, "java.awt.geom.PathIterator,~N,~N");\r
-c$.pointCrossingsForLine = Clazz.defineMethod (c$, "pointCrossingsForLine", \r
-function (px, py, x0, y0, x1, y1) {\r
-if (py < y0 && py < y1) return 0;\r
-if (py >= y0 && py >= y1) return 0;\r
-if (px >= x0 && px >= x1) return 0;\r
-if (px < x0 && px < x1) return (y0 < y1) ? 1 : -1;\r
-var xintercept = x0 + (py - y0) * (x1 - x0) / (y1 - y0);\r
-if (px >= xintercept) return 0;\r
-return (y0 < y1) ? 1 : -1;\r
-}, "~N,~N,~N,~N,~N,~N");\r
-c$.pointCrossingsForQuad = Clazz.defineMethod (c$, "pointCrossingsForQuad", \r
-function (px, py, x0, y0, xc, yc, x1, y1, level) {\r
-if (py < y0 && py < yc && py < y1) return 0;\r
-if (py >= y0 && py >= yc && py >= y1) return 0;\r
-if (px >= x0 && px >= xc && px >= x1) return 0;\r
-if (px < x0 && px < xc && px < x1) {\r
-if (py >= y0) {\r
-if (py < y1) return 1;\r
-} else {\r
-if (py >= y1) return -1;\r
-}return 0;\r
-}if (level > 52) return jssun.awt.geom.Curve.pointCrossingsForLine (px, py, x0, y0, x1, y1);\r
-var x0c = (x0 + xc) / 2;\r
-var y0c = (y0 + yc) / 2;\r
-var xc1 = (xc + x1) / 2;\r
-var yc1 = (yc + y1) / 2;\r
-xc = (x0c + xc1) / 2;\r
-yc = (y0c + yc1) / 2;\r
-if (Double.isNaN (xc) || Double.isNaN (yc)) {\r
-return 0;\r
-}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
-}, "~N,~N,~N,~N,~N,~N,~N,~N,~N");\r
-c$.pointCrossingsForCubic = Clazz.defineMethod (c$, "pointCrossingsForCubic", \r
-function (px, py, x0, y0, xc0, yc0, xc1, yc1, x1, y1, level) {\r
-if (py < y0 && py < yc0 && py < yc1 && py < y1) return 0;\r
-if (py >= y0 && py >= yc0 && py >= yc1 && py >= y1) return 0;\r
-if (px >= x0 && px >= xc0 && px >= xc1 && px >= x1) return 0;\r
-if (px < x0 && px < xc0 && px < xc1 && px < x1) {\r
-if (py >= y0) {\r
-if (py < y1) return 1;\r
-} else {\r
-if (py >= y1) return -1;\r
-}return 0;\r
-}if (level > 52) return jssun.awt.geom.Curve.pointCrossingsForLine (px, py, x0, y0, x1, y1);\r
-var xmid = (xc0 + xc1) / 2;\r
-var ymid = (yc0 + yc1) / 2;\r
-xc0 = (x0 + xc0) / 2;\r
-yc0 = (y0 + yc0) / 2;\r
-xc1 = (xc1 + x1) / 2;\r
-yc1 = (yc1 + y1) / 2;\r
-var xc0m = (xc0 + xmid) / 2;\r
-var yc0m = (yc0 + ymid) / 2;\r
-var xmc1 = (xmid + xc1) / 2;\r
-var ymc1 = (ymid + yc1) / 2;\r
-xmid = (xc0m + xmc1) / 2;\r
-ymid = (yc0m + ymc1) / 2;\r
-if (Double.isNaN (xmid) || Double.isNaN (ymid)) {\r
-return 0;\r
-}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
-}, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");\r
-c$.rectCrossingsForPath = Clazz.defineMethod (c$, "rectCrossingsForPath", \r
-function (pi, rxmin, rymin, rxmax, rymax) {\r
-if (rxmax <= rxmin || rymax <= rymin) {\r
-return 0;\r
-}if (pi.isDone ()) {\r
-return 0;\r
-}var coords = Clazz.newDoubleArray (6, 0);\r
-if (pi.currentSegment (coords) != 0) {\r
-throw new java.awt.geom.IllegalPathStateException ("missing initial moveto in path definition");\r
-}pi.next ();\r
-var curx;\r
-var cury;\r
-var movx;\r
-var movy;\r
-var endx;\r
-var endy;\r
-curx = movx = coords[0];\r
-cury = movy = coords[1];\r
-var crossings = 0;\r
-while (crossings != -2147483648 && !pi.isDone ()) {\r
-switch (pi.currentSegment (coords)) {\r
-case 0:\r
-if (curx != movx || cury != movy) {\r
-crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);\r
-}movx = curx = coords[0];\r
-movy = cury = coords[1];\r
-break;\r
-case 1:\r
-endx = coords[0];\r
-endy = coords[1];\r
-crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, endx, endy);\r
-curx = endx;\r
-cury = endy;\r
-break;\r
-case 2:\r
-endx = coords[2];\r
-endy = coords[3];\r
-crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, curx, cury, coords[0], coords[1], endx, endy, 0);\r
-curx = endx;\r
-cury = endy;\r
-break;\r
-case 3:\r
-endx = coords[4];\r
-endy = coords[5];\r
-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
-curx = endx;\r
-cury = endy;\r
-break;\r
-case 4:\r
-if (curx != movx || cury != movy) {\r
-crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);\r
-}curx = movx;\r
-cury = movy;\r
-break;\r
-}\r
-pi.next ();\r
-}\r
-if (crossings != -2147483648 && (curx != movx || cury != movy)) {\r
-crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);\r
-}return crossings;\r
-}, "java.awt.geom.PathIterator,~N,~N,~N,~N");\r
-c$.rectCrossingsForLine = Clazz.defineMethod (c$, "rectCrossingsForLine", \r
-function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1) {\r
-if (y0 >= rymax && y1 >= rymax) return crossings;\r
-if (y0 <= rymin && y1 <= rymin) return crossings;\r
-if (x0 <= rxmin && x1 <= rxmin) return crossings;\r
-if (x0 >= rxmax && x1 >= rxmax) {\r
-if (y0 < y1) {\r
-if (y0 <= rymin) crossings++;\r
-if (y1 >= rymax) crossings++;\r
-} else if (y1 < y0) {\r
-if (y1 <= rymin) crossings--;\r
-if (y0 >= rymax) crossings--;\r
-}return crossings;\r
-}if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) || (x1 > rxmin && x1 < rxmax && y1 > rymin && y1 < rymax)) {\r
-return -2147483648;\r
-}var xi0 = x0;\r
-if (y0 < rymin) {\r
-xi0 += ((rymin - y0) * (x1 - x0) / (y1 - y0));\r
-} else if (y0 > rymax) {\r
-xi0 += ((rymax - y0) * (x1 - x0) / (y1 - y0));\r
-}var xi1 = x1;\r
-if (y1 < rymin) {\r
-xi1 += ((rymin - y1) * (x0 - x1) / (y0 - y1));\r
-} else if (y1 > rymax) {\r
-xi1 += ((rymax - y1) * (x0 - x1) / (y0 - y1));\r
-}if (xi0 <= rxmin && xi1 <= rxmin) return crossings;\r
-if (xi0 >= rxmax && xi1 >= rxmax) {\r
-if (y0 < y1) {\r
-if (y0 <= rymin) crossings++;\r
-if (y1 >= rymax) crossings++;\r
-} else if (y1 < y0) {\r
-if (y1 <= rymin) crossings--;\r
-if (y0 >= rymax) crossings--;\r
-}return crossings;\r
-}return -2147483648;\r
-}, "~N,~N,~N,~N,~N,~N,~N,~N,~N");\r
-c$.rectCrossingsForQuad = Clazz.defineMethod (c$, "rectCrossingsForQuad", \r
-function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc, yc, x1, y1, level) {\r
-if (y0 >= rymax && yc >= rymax && y1 >= rymax) return crossings;\r
-if (y0 <= rymin && yc <= rymin && y1 <= rymin) return crossings;\r
-if (x0 <= rxmin && xc <= rxmin && x1 <= rxmin) return crossings;\r
-if (x0 >= rxmax && xc >= rxmax && x1 >= rxmax) {\r
-if (y0 < y1) {\r
-if (y0 <= rymin && y1 > rymin) crossings++;\r
-if (y0 < rymax && y1 >= rymax) crossings++;\r
-} else if (y1 < y0) {\r
-if (y1 <= rymin && y0 > rymin) crossings--;\r
-if (y1 < rymax && y0 >= rymax) crossings--;\r
-}return crossings;\r
-}if ((x0 < rxmax && x0 > rxmin && y0 < rymax && y0 > rymin) || (x1 < rxmax && x1 > rxmin && y1 < rymax && y1 > rymin)) {\r
-return -2147483648;\r
-}if (level > 52) {\r
-return jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1);\r
-}var x0c = (x0 + xc) / 2;\r
-var y0c = (y0 + yc) / 2;\r
-var xc1 = (xc + x1) / 2;\r
-var yc1 = (yc + y1) / 2;\r
-xc = (x0c + xc1) / 2;\r
-yc = (y0c + yc1) / 2;\r
-if (Double.isNaN (xc) || Double.isNaN (yc)) {\r
-return 0;\r
-}crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x0c, y0c, xc, yc, level + 1);\r
-if (crossings != -2147483648) {\r
-crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, xc, yc, xc1, yc1, x1, y1, level + 1);\r
-}return crossings;\r
-}, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");\r
-c$.rectCrossingsForCubic = Clazz.defineMethod (c$, "rectCrossingsForCubic", \r
-function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc0, yc0, xc1, yc1, x1, y1, level) {\r
-if (y0 >= rymax && yc0 >= rymax && yc1 >= rymax && y1 >= rymax) {\r
-return crossings;\r
-}if (y0 <= rymin && yc0 <= rymin && yc1 <= rymin && y1 <= rymin) {\r
-return crossings;\r
-}if (x0 <= rxmin && xc0 <= rxmin && xc1 <= rxmin && x1 <= rxmin) {\r
-return crossings;\r
-}if (x0 >= rxmax && xc0 >= rxmax && xc1 >= rxmax && x1 >= rxmax) {\r
-if (y0 < y1) {\r
-if (y0 <= rymin && y1 > rymin) crossings++;\r
-if (y0 < rymax && y1 >= rymax) crossings++;\r
-} else if (y1 < y0) {\r
-if (y1 <= rymin && y0 > rymin) crossings--;\r
-if (y1 < rymax && y0 >= rymax) crossings--;\r
-}return crossings;\r
-}if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) || (x1 > rxmin && x1 < rxmax && y1 > rymin && y1 < rymax)) {\r
-return -2147483648;\r
-}if (level > 52) {\r
-return jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1);\r
-}var xmid = (xc0 + xc1) / 2;\r
-var ymid = (yc0 + yc1) / 2;\r
-xc0 = (x0 + xc0) / 2;\r
-yc0 = (y0 + yc0) / 2;\r
-xc1 = (xc1 + x1) / 2;\r
-yc1 = (yc1 + y1) / 2;\r
-var xc0m = (xc0 + xmid) / 2;\r
-var yc0m = (yc0 + ymid) / 2;\r
-var xmc1 = (xmid + xc1) / 2;\r
-var ymc1 = (ymid + yc1) / 2;\r
-xmid = (xc0m + xmc1) / 2;\r
-ymid = (yc0m + ymc1) / 2;\r
-if (Double.isNaN (xmid) || Double.isNaN (ymid)) {\r
-return 0;\r
-}crossings = jssun.awt.geom.Curve.rectCrossingsForCubic (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc0, yc0, xc0m, yc0m, xmid, ymid, level + 1);\r
-if (crossings != -2147483648) {\r
-crossings = jssun.awt.geom.Curve.rectCrossingsForCubic (crossings, rxmin, rymin, rxmax, rymax, xmid, ymid, xmc1, ymc1, xc1, yc1, x1, y1, level + 1);\r
-}return crossings;\r
-}, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");\r
-Clazz.makeConstructor (c$, \r
-function (direction) {\r
-this.direction = direction;\r
-}, "~N");\r
-Clazz.defineMethod (c$, "getDirection", \r
-function () {\r
-return this.direction;\r
-});\r
-Clazz.defineMethod (c$, "getWithDirection", \r
-function (direction) {\r
-return (this.direction == direction ? this : this.getReversedCurve ());\r
-}, "~N");\r
-c$.round = Clazz.defineMethod (c$, "round", \r
-function (v) {\r
-return v;\r
-}, "~N");\r
-c$.orderof = Clazz.defineMethod (c$, "orderof", \r
-function (x1, x2) {\r
-if (x1 < x2) {\r
-return -1;\r
-}if (x1 > x2) {\r
-return 1;\r
-}return 0;\r
-}, "~N,~N");\r
-c$.signeddiffbits = Clazz.defineMethod (c$, "signeddiffbits", \r
-function (y1, y2) {\r
-return (Double.doubleToLongBits (y1) - Double.doubleToLongBits (y2));\r
-}, "~N,~N");\r
-c$.diffbits = Clazz.defineMethod (c$, "diffbits", \r
-function (y1, y2) {\r
-return Math.abs (Double.doubleToLongBits (y1) - Double.doubleToLongBits (y2));\r
-}, "~N,~N");\r
-c$.prev = Clazz.defineMethod (c$, "prev", \r
-function (v) {\r
-return Double.longBitsToDouble (Double.doubleToLongBits (v) - 1);\r
-}, "~N");\r
-c$.next = Clazz.defineMethod (c$, "next", \r
-function (v) {\r
-return Double.longBitsToDouble (Double.doubleToLongBits (v) + 1);\r
-}, "~N");\r
-Clazz.overrideMethod (c$, "toString", \r
-function () {\r
-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
-});\r
-Clazz.defineMethod (c$, "controlPointString", \r
-function () {\r
-return "";\r
-});\r
-Clazz.defineMethod (c$, "crossingsFor", \r
-function (x, y) {\r
-if (y >= this.getYTop () && y < this.getYBot ()) {\r
-if (x < this.getXMax () && (x < this.getXMin () || x < this.XforY (y))) {\r
-return 1;\r
-}}return 0;\r
-}, "~N,~N");\r
-Clazz.defineMethod (c$, "accumulateCrossings", \r
-function (c) {\r
-var xhi = c.getXHi ();\r
-if (this.getXMin () >= xhi) {\r
-return false;\r
-}var xlo = c.getXLo ();\r
-var ylo = c.getYLo ();\r
-var yhi = c.getYHi ();\r
-var y0 = this.getYTop ();\r
-var y1 = this.getYBot ();\r
-var tstart;\r
-var ystart;\r
-var tend;\r
-var yend;\r
-if (y0 < ylo) {\r
-if (y1 <= ylo) {\r
-return false;\r
-}ystart = ylo;\r
-tstart = this.TforY (ylo);\r
-} else {\r
-if (y0 >= yhi) {\r
-return false;\r
-}ystart = y0;\r
-tstart = 0;\r
-}if (y1 > yhi) {\r
-yend = yhi;\r
-tend = this.TforY (yhi);\r
-} else {\r
-yend = y1;\r
-tend = 1;\r
-}var hitLo = false;\r
-var hitHi = false;\r
-while (true) {\r
-var x = this.XforT (tstart);\r
-if (x < xhi) {\r
-if (hitHi || x > xlo) {\r
-return true;\r
-}hitLo = true;\r
-} else {\r
-if (hitLo) {\r
-return true;\r
-}hitHi = true;\r
-}if (tstart >= tend) {\r
-break;\r
-}tstart = this.nextVertical (tstart, tend);\r
-}\r
-if (hitLo) {\r
-c.record (ystart, yend, this.direction);\r
-}return false;\r
-}, "jssun.awt.geom.Crossings");\r
-Clazz.defineMethod (c$, "getSubCurve", \r
-function (ystart, yend) {\r
-return this.getSubCurve (ystart, yend, this.direction);\r
-}, "~N,~N");\r
-Clazz.defineMethod (c$, "compareTo", \r
-function (that, yrange) {\r
-var y0 = yrange[0];\r
-var y1 = yrange[1];\r
-y1 = Math.min (Math.min (y1, this.getYBot ()), that.getYBot ());\r
-if (y1 <= yrange[0]) {\r
-System.err.println ("this == " + this);\r
-System.err.println ("that == " + that);\r
-System.out.println ("target range = " + yrange[0] + "=>" + yrange[1]);\r
-throw new InternalError ("backstepping from " + yrange[0] + " to " + y1);\r
-}yrange[1] = y1;\r
-if (this.getXMax () <= that.getXMin ()) {\r
-if (this.getXMin () == that.getXMax ()) {\r
-return 0;\r
-}return -1;\r
-}if (this.getXMin () >= that.getXMax ()) {\r
-return 1;\r
-}var s0 = this.TforY (y0);\r
-var ys0 = this.YforT (s0);\r
-if (ys0 < y0) {\r
-s0 = this.refineTforY (s0, ys0, y0);\r
-ys0 = this.YforT (s0);\r
-}var s1 = this.TforY (y1);\r
-if (this.YforT (s1) < y0) {\r
-s1 = this.refineTforY (s1, this.YforT (s1), y0);\r
-}var t0 = that.TforY (y0);\r
-var yt0 = that.YforT (t0);\r
-if (yt0 < y0) {\r
-t0 = that.refineTforY (t0, yt0, y0);\r
-yt0 = that.YforT (t0);\r
-}var t1 = that.TforY (y1);\r
-if (that.YforT (t1) < y0) {\r
-t1 = that.refineTforY (t1, that.YforT (t1), y0);\r
-}var xs0 = this.XforT (s0);\r
-var xt0 = that.XforT (t0);\r
-var scale = Math.max (Math.abs (y0), Math.abs (y1));\r
-var ymin = Math.max (scale * 1E-14, 1E-300);\r
-if (this.fairlyClose (xs0, xt0)) {\r
-var bump = ymin;\r
-var maxbump = Math.min (ymin * 1E13, (y1 - y0) * .1);\r
-var y = y0 + bump;\r
-while (y <= y1) {\r
-if (this.fairlyClose (this.XforY (y), that.XforY (y))) {\r
-if ((bump *= 2) > maxbump) {\r
-bump = maxbump;\r
-}} else {\r
-y -= bump;\r
-while (true) {\r
-bump /= 2;\r
-var newy = y + bump;\r
-if (newy <= y) {\r
-break;\r
-}if (this.fairlyClose (this.XforY (newy), that.XforY (newy))) {\r
-y = newy;\r
-}}\r
-break;\r
-}y += bump;\r
-}\r
-if (y > y0) {\r
-if (y < y1) {\r
-yrange[1] = y;\r
-}return 0;\r
-}}if (ymin <= 0) {\r
-System.out.println ("ymin = " + ymin);\r
-}while (s0 < s1 && t0 < t1) {\r
-var sh = this.nextVertical (s0, s1);\r
-var xsh = this.XforT (sh);\r
-var ysh = this.YforT (sh);\r
-var th = that.nextVertical (t0, t1);\r
-var xth = that.XforT (th);\r
-var yth = that.YforT (th);\r
-try {\r
-if (this.findIntersect (that, yrange, ymin, 0, 0, s0, xs0, ys0, sh, xsh, ysh, t0, xt0, yt0, th, xth, yth)) {\r
-break;\r
-}} catch (t) {\r
-System.err.println ("Error: " + t);\r
-System.err.println ("y range was " + yrange[0] + "=>" + yrange[1]);\r
-System.err.println ("s y range is " + ys0 + "=>" + ysh);\r
-System.err.println ("t y range is " + yt0 + "=>" + yth);\r
-System.err.println ("ymin is " + ymin);\r
-return 0;\r
-}\r
-if (ysh < yth) {\r
-if (ysh > yrange[0]) {\r
-if (ysh < yrange[1]) {\r
-yrange[1] = ysh;\r
-}break;\r
-}s0 = sh;\r
-xs0 = xsh;\r
-ys0 = ysh;\r
-} else {\r
-if (yth > yrange[0]) {\r
-if (yth < yrange[1]) {\r
-yrange[1] = yth;\r
-}break;\r
-}t0 = th;\r
-xt0 = xth;\r
-yt0 = yth;\r
-}}\r
-var ymid = (yrange[0] + yrange[1]) / 2;\r
-return jssun.awt.geom.Curve.orderof (this.XforY (ymid), that.XforY (ymid));\r
-}, "jssun.awt.geom.Curve,~A");\r
-Clazz.defineMethod (c$, "findIntersect", \r
-function (that, yrange, ymin, slevel, tlevel, s0, xs0, ys0, s1, xs1, ys1, t0, xt0, yt0, t1, xt1, yt1) {\r
-if (ys0 > yt1 || yt0 > ys1) {\r
-return false;\r
-}if (Math.min (xs0, xs1) > Math.max (xt0, xt1) || Math.max (xs0, xs1) < Math.min (xt0, xt1)) {\r
-return false;\r
-}if (s1 - s0 > 0.001) {\r
-var s = (s0 + s1) / 2;\r
-var xs = this.XforT (s);\r
-var ys = this.YforT (s);\r
-if (s == s0 || s == s1) {\r
-System.out.println ("s0 = " + s0);\r
-System.out.println ("s1 = " + s1);\r
-throw new InternalError ("no s progress!");\r
-}if (t1 - t0 > 0.001) {\r
-var t = (t0 + t1) / 2;\r
-var xt = that.XforT (t);\r
-var yt = that.YforT (t);\r
-if (t == t0 || t == t1) {\r
-System.out.println ("t0 = " + t0);\r
-System.out.println ("t1 = " + t1);\r
-throw new InternalError ("no t progress!");\r
-}if (ys >= yt0 && yt >= ys0) {\r
-if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s0, xs0, ys0, s, xs, ys, t0, xt0, yt0, t, xt, yt)) {\r
-return true;\r
-}}if (ys >= yt) {\r
-if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s0, xs0, ys0, s, xs, ys, t, xt, yt, t1, xt1, yt1)) {\r
-return true;\r
-}}if (yt >= ys) {\r
-if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s, xs, ys, s1, xs1, ys1, t0, xt0, yt0, t, xt, yt)) {\r
-return true;\r
-}}if (ys1 >= yt && yt1 >= ys) {\r
-if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s, xs, ys, s1, xs1, ys1, t, xt, yt, t1, xt1, yt1)) {\r
-return true;\r
-}}} else {\r
-if (ys >= yt0) {\r
-if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel, s0, xs0, ys0, s, xs, ys, t0, xt0, yt0, t1, xt1, yt1)) {\r
-return true;\r
-}}if (yt1 >= ys) {\r
-if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel, s, xs, ys, s1, xs1, ys1, t0, xt0, yt0, t1, xt1, yt1)) {\r
-return true;\r
-}}}} else if (t1 - t0 > 0.001) {\r
-var t = (t0 + t1) / 2;\r
-var xt = that.XforT (t);\r
-var yt = that.YforT (t);\r
-if (t == t0 || t == t1) {\r
-System.out.println ("t0 = " + t0);\r
-System.out.println ("t1 = " + t1);\r
-throw new InternalError ("no t progress!");\r
-}if (yt >= ys0) {\r
-if (this.findIntersect (that, yrange, ymin, slevel, tlevel + 1, s0, xs0, ys0, s1, xs1, ys1, t0, xt0, yt0, t, xt, yt)) {\r
-return true;\r
-}}if (ys1 >= yt) {\r
-if (this.findIntersect (that, yrange, ymin, slevel, tlevel + 1, s0, xs0, ys0, s1, xs1, ys1, t, xt, yt, t1, xt1, yt1)) {\r
-return true;\r
-}}} else {\r
-var xlk = xs1 - xs0;\r
-var ylk = ys1 - ys0;\r
-var xnm = xt1 - xt0;\r
-var ynm = yt1 - yt0;\r
-var xmk = xt0 - xs0;\r
-var ymk = yt0 - ys0;\r
-var det = xnm * ylk - ynm * xlk;\r
-if (det != 0) {\r
-var detinv = 1 / det;\r
-var s = (xnm * ymk - ynm * xmk) * detinv;\r
-var t = (xlk * ymk - ylk * xmk) * detinv;\r
-if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {\r
-s = s0 + s * (s1 - s0);\r
-t = t0 + t * (t1 - t0);\r
-if (s < 0 || s > 1 || t < 0 || t > 1) {\r
-System.out.println ("Uh oh!");\r
-}var y = (this.YforT (s) + that.YforT (t)) / 2;\r
-if (y <= yrange[1] && y > yrange[0]) {\r
-yrange[1] = y;\r
-return true;\r
-}}}}return false;\r
-}, "jssun.awt.geom.Curve,~A,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");\r
-Clazz.defineMethod (c$, "refineTforY", \r
-function (t0, yt0, y0) {\r
-var t1 = 1;\r
-while (true) {\r
-var th = (t0 + t1) / 2;\r
-if (th == t0 || th == t1) {\r
-return t1;\r
-}var y = this.YforT (th);\r
-if (y < y0) {\r
-t0 = th;\r
-yt0 = y;\r
-} else if (y > y0) {\r
-t1 = th;\r
-} else {\r
-return t1;\r
-}}\r
-}, "~N,~N,~N");\r
-Clazz.defineMethod (c$, "fairlyClose", \r
-function (v1, v2) {\r
-return (Math.abs (v1 - v2) < Math.max (Math.abs (v1), Math.abs (v2)) * 1E-10);\r
-}, "~N,~N");\r
-Clazz.defineStatics (c$,\r
-"INCREASING", 1,\r
-"DECREASING", -1,\r
-"RECT_INTERSECTS", 0x80000000,\r
-"TMIN", 1E-3);\r
-});\r
+Clazz.declarePackage ("jssun.awt.geom");
+Clazz.load (null, "jssun.awt.geom.Curve", ["java.lang.Double", "$.InternalError", "java.awt.geom.IllegalPathStateException"], function () {
+c$ = Clazz.decorateAsClass (function () {
+this.direction = 0;
+Clazz.instantialize (this, arguments);
+}, jssun.awt.geom, "Curve");
+c$.insertMove = Clazz.defineMethod (c$, "insertMove",
+function (curves, x, y) {
+curves.add ( new jssun.awt.geom.Order0 (x, y));
+}, "java.util.Vector,~N,~N");
+c$.insertLine = Clazz.defineMethod (c$, "insertLine",
+function (curves, x0, y0, x1, y1) {
+if (y0 < y1) {
+curves.add ( new jssun.awt.geom.Order1 (x0, y0, x1, y1, 1));
+} else if (y0 > y1) {
+curves.add ( new jssun.awt.geom.Order1 (x1, y1, x0, y0, -1));
+} else {
+}}, "java.util.Vector,~N,~N,~N,~N");
+c$.insertQuad = Clazz.defineMethod (c$, "insertQuad",
+function (curves, x0, y0, coords) {
+var y1 = coords[3];
+if (y0 > y1) {
+jssun.awt.geom.Order2.insert (curves, coords, coords[2], y1, coords[0], coords[1], x0, y0, -1);
+} else if (y0 == y1 && y0 == coords[1]) {
+return;
+} else {
+jssun.awt.geom.Order2.insert (curves, coords, x0, y0, coords[0], coords[1], coords[2], y1, 1);
+}}, "java.util.Vector,~N,~N,~A");
+c$.insertCubic = Clazz.defineMethod (c$, "insertCubic",
+function (curves, x0, y0, coords) {
+var y1 = coords[5];
+if (y0 > y1) {
+jssun.awt.geom.Order3.insert (curves, coords, coords[4], y1, coords[2], coords[3], coords[0], coords[1], x0, y0, -1);
+} else if (y0 == y1 && y0 == coords[1] && y0 == coords[3]) {
+return;
+} else {
+jssun.awt.geom.Order3.insert (curves, coords, x0, y0, coords[0], coords[1], coords[2], coords[3], coords[4], y1, 1);
+}}, "java.util.Vector,~N,~N,~A");
+c$.pointCrossingsForPath = Clazz.defineMethod (c$, "pointCrossingsForPath",
+function (pi, px, py) {
+if (pi.isDone ()) {
+return 0;
+}var coords = Clazz.newDoubleArray (6, 0);
+if (pi.currentSegment (coords) != 0) {
+throw new java.awt.geom.IllegalPathStateException ("missing initial moveto in path definition");
+}pi.next ();
+var movx = coords[0];
+var movy = coords[1];
+var curx = movx;
+var cury = movy;
+var endx;
+var endy;
+var crossings = 0;
+while (!pi.isDone ()) {
+switch (pi.currentSegment (coords)) {
+case 0:
+if (cury != movy) {
+crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);
+}movx = curx = coords[0];
+movy = cury = coords[1];
+break;
+case 1:
+endx = coords[0];
+endy = coords[1];
+crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, endx, endy);
+curx = endx;
+cury = endy;
+break;
+case 2:
+endx = coords[2];
+endy = coords[3];
+crossings += jssun.awt.geom.Curve.pointCrossingsForQuad (px, py, curx, cury, coords[0], coords[1], endx, endy, 0);
+curx = endx;
+cury = endy;
+break;
+case 3:
+endx = coords[4];
+endy = coords[5];
+crossings += jssun.awt.geom.Curve.pointCrossingsForCubic (px, py, curx, cury, coords[0], coords[1], coords[2], coords[3], endx, endy, 0);
+curx = endx;
+cury = endy;
+break;
+case 4:
+if (cury != movy) {
+crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);
+}curx = movx;
+cury = movy;
+break;
+}
+pi.next ();
+}
+if (cury != movy) {
+crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);
+}return crossings;
+}, "java.awt.geom.PathIterator,~N,~N");
+c$.pointCrossingsForLine = Clazz.defineMethod (c$, "pointCrossingsForLine",
+function (px, py, x0, y0, x1, y1) {
+if (py < y0 && py < y1) return 0;
+if (py >= y0 && py >= y1) return 0;
+if (px >= x0 && px >= x1) return 0;
+if (px < x0 && px < x1) return (y0 < y1) ? 1 : -1;
+var xintercept = x0 + (py - y0) * (x1 - x0) / (y1 - y0);
+if (px >= xintercept) return 0;
+return (y0 < y1) ? 1 : -1;
+}, "~N,~N,~N,~N,~N,~N");
+c$.pointCrossingsForQuad = Clazz.defineMethod (c$, "pointCrossingsForQuad",
+function (px, py, x0, y0, xc, yc, x1, y1, level) {
+if (py < y0 && py < yc && py < y1) return 0;
+if (py >= y0 && py >= yc && py >= y1) return 0;
+if (px >= x0 && px >= xc && px >= x1) return 0;
+if (px < x0 && px < xc && px < x1) {
+if (py >= y0) {
+if (py < y1) return 1;
+} else {
+if (py >= y1) return -1;
+}return 0;
+}if (level > 52) return jssun.awt.geom.Curve.pointCrossingsForLine (px, py, x0, y0, x1, y1);
+var x0c = (x0 + xc) / 2;
+var y0c = (y0 + yc) / 2;
+var xc1 = (xc + x1) / 2;
+var yc1 = (yc + y1) / 2;
+xc = (x0c + xc1) / 2;
+yc = (y0c + yc1) / 2;
+if (Double.isNaN (xc) || Double.isNaN (yc)) {
+return 0;
+}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));
+}, "~N,~N,~N,~N,~N,~N,~N,~N,~N");
+c$.pointCrossingsForCubic = Clazz.defineMethod (c$, "pointCrossingsForCubic",
+function (px, py, x0, y0, xc0, yc0, xc1, yc1, x1, y1, level) {
+if (py < y0 && py < yc0 && py < yc1 && py < y1) return 0;
+if (py >= y0 && py >= yc0 && py >= yc1 && py >= y1) return 0;
+if (px >= x0 && px >= xc0 && px >= xc1 && px >= x1) return 0;
+if (px < x0 && px < xc0 && px < xc1 && px < x1) {
+if (py >= y0) {
+if (py < y1) return 1;
+} else {
+if (py >= y1) return -1;
+}return 0;
+}if (level > 52) return jssun.awt.geom.Curve.pointCrossingsForLine (px, py, x0, y0, x1, y1);
+var xmid = (xc0 + xc1) / 2;
+var ymid = (yc0 + yc1) / 2;
+xc0 = (x0 + xc0) / 2;
+yc0 = (y0 + yc0) / 2;
+xc1 = (xc1 + x1) / 2;
+yc1 = (yc1 + y1) / 2;
+var xc0m = (xc0 + xmid) / 2;
+var yc0m = (yc0 + ymid) / 2;
+var xmc1 = (xmid + xc1) / 2;
+var ymc1 = (ymid + yc1) / 2;
+xmid = (xc0m + xmc1) / 2;
+ymid = (yc0m + ymc1) / 2;
+if (Double.isNaN (xmid) || Double.isNaN (ymid)) {
+return 0;
+}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));
+}, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");
+c$.rectCrossingsForPath = Clazz.defineMethod (c$, "rectCrossingsForPath",
+function (pi, rxmin, rymin, rxmax, rymax) {
+if (rxmax <= rxmin || rymax <= rymin) {
+return 0;
+}if (pi.isDone ()) {
+return 0;
+}var coords = Clazz.newDoubleArray (6, 0);
+if (pi.currentSegment (coords) != 0) {
+throw new java.awt.geom.IllegalPathStateException ("missing initial moveto in path definition");
+}pi.next ();
+var curx;
+var cury;
+var movx;
+var movy;
+var endx;
+var endy;
+curx = movx = coords[0];
+cury = movy = coords[1];
+var crossings = 0;
+while (crossings != -2147483648 && !pi.isDone ()) {
+switch (pi.currentSegment (coords)) {
+case 0:
+if (curx != movx || cury != movy) {
+crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);
+}movx = curx = coords[0];
+movy = cury = coords[1];
+break;
+case 1:
+endx = coords[0];
+endy = coords[1];
+crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, endx, endy);
+curx = endx;
+cury = endy;
+break;
+case 2:
+endx = coords[2];
+endy = coords[3];
+crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, curx, cury, coords[0], coords[1], endx, endy, 0);
+curx = endx;
+cury = endy;
+break;
+case 3:
+endx = coords[4];
+endy = coords[5];
+crossings = jssun.awt.geom.Curve.rectCrossingsForCubic (crossings, rxmin, rymin, rxmax, rymax, curx, cury, coords[0], coords[1], coords[2], coords[3], endx, endy, 0);
+curx = endx;
+cury = endy;
+break;
+case 4:
+if (curx != movx || cury != movy) {
+crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);
+}curx = movx;
+cury = movy;
+break;
+}
+pi.next ();
+}
+if (crossings != -2147483648 && (curx != movx || cury != movy)) {
+crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, movx, movy);
+}return crossings;
+}, "java.awt.geom.PathIterator,~N,~N,~N,~N");
+c$.rectCrossingsForLine = Clazz.defineMethod (c$, "rectCrossingsForLine",
+function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1) {
+if (y0 >= rymax && y1 >= rymax) return crossings;
+if (y0 <= rymin && y1 <= rymin) return crossings;
+if (x0 <= rxmin && x1 <= rxmin) return crossings;
+if (x0 >= rxmax && x1 >= rxmax) {
+if (y0 < y1) {
+if (y0 <= rymin) crossings++;
+if (y1 >= rymax) crossings++;
+} else if (y1 < y0) {
+if (y1 <= rymin) crossings--;
+if (y0 >= rymax) crossings--;
+}return crossings;
+}if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) || (x1 > rxmin && x1 < rxmax && y1 > rymin && y1 < rymax)) {
+return -2147483648;
+}var xi0 = x0;
+if (y0 < rymin) {
+xi0 += ((rymin - y0) * (x1 - x0) / (y1 - y0));
+} else if (y0 > rymax) {
+xi0 += ((rymax - y0) * (x1 - x0) / (y1 - y0));
+}var xi1 = x1;
+if (y1 < rymin) {
+xi1 += ((rymin - y1) * (x0 - x1) / (y0 - y1));
+} else if (y1 > rymax) {
+xi1 += ((rymax - y1) * (x0 - x1) / (y0 - y1));
+}if (xi0 <= rxmin && xi1 <= rxmin) return crossings;
+if (xi0 >= rxmax && xi1 >= rxmax) {
+if (y0 < y1) {
+if (y0 <= rymin) crossings++;
+if (y1 >= rymax) crossings++;
+} else if (y1 < y0) {
+if (y1 <= rymin) crossings--;
+if (y0 >= rymax) crossings--;
+}return crossings;
+}return -2147483648;
+}, "~N,~N,~N,~N,~N,~N,~N,~N,~N");
+c$.rectCrossingsForQuad = Clazz.defineMethod (c$, "rectCrossingsForQuad",
+function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc, yc, x1, y1, level) {
+if (y0 >= rymax && yc >= rymax && y1 >= rymax) return crossings;
+if (y0 <= rymin && yc <= rymin && y1 <= rymin) return crossings;
+if (x0 <= rxmin && xc <= rxmin && x1 <= rxmin) return crossings;
+if (x0 >= rxmax && xc >= rxmax && x1 >= rxmax) {
+if (y0 < y1) {
+if (y0 <= rymin && y1 > rymin) crossings++;
+if (y0 < rymax && y1 >= rymax) crossings++;
+} else if (y1 < y0) {
+if (y1 <= rymin && y0 > rymin) crossings--;
+if (y1 < rymax && y0 >= rymax) crossings--;
+}return crossings;
+}if ((x0 < rxmax && x0 > rxmin && y0 < rymax && y0 > rymin) || (x1 < rxmax && x1 > rxmin && y1 < rymax && y1 > rymin)) {
+return -2147483648;
+}if (level > 52) {
+return jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1);
+}var x0c = (x0 + xc) / 2;
+var y0c = (y0 + yc) / 2;
+var xc1 = (xc + x1) / 2;
+var yc1 = (yc + y1) / 2;
+xc = (x0c + xc1) / 2;
+yc = (y0c + yc1) / 2;
+if (Double.isNaN (xc) || Double.isNaN (yc)) {
+return 0;
+}crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x0c, y0c, xc, yc, level + 1);
+if (crossings != -2147483648) {
+crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, xc, yc, xc1, yc1, x1, y1, level + 1);
+}return crossings;
+}, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");
+c$.rectCrossingsForCubic = Clazz.defineMethod (c$, "rectCrossingsForCubic",
+function (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc0, yc0, xc1, yc1, x1, y1, level) {
+if (y0 >= rymax && yc0 >= rymax && yc1 >= rymax && y1 >= rymax) {
+return crossings;
+}if (y0 <= rymin && yc0 <= rymin && yc1 <= rymin && y1 <= rymin) {
+return crossings;
+}if (x0 <= rxmin && xc0 <= rxmin && xc1 <= rxmin && x1 <= rxmin) {
+return crossings;
+}if (x0 >= rxmax && xc0 >= rxmax && xc1 >= rxmax && x1 >= rxmax) {
+if (y0 < y1) {
+if (y0 <= rymin && y1 > rymin) crossings++;
+if (y0 < rymax && y1 >= rymax) crossings++;
+} else if (y1 < y0) {
+if (y1 <= rymin && y0 > rymin) crossings--;
+if (y1 < rymax && y0 >= rymax) crossings--;
+}return crossings;
+}if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) || (x1 > rxmin && x1 < rxmax && y1 > rymin && y1 < rymax)) {
+return -2147483648;
+}if (level > 52) {
+return jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, x0, y0, x1, y1);
+}var xmid = (xc0 + xc1) / 2;
+var ymid = (yc0 + yc1) / 2;
+xc0 = (x0 + xc0) / 2;
+yc0 = (y0 + yc0) / 2;
+xc1 = (xc1 + x1) / 2;
+yc1 = (yc1 + y1) / 2;
+var xc0m = (xc0 + xmid) / 2;
+var yc0m = (yc0 + ymid) / 2;
+var xmc1 = (xmid + xc1) / 2;
+var ymc1 = (ymid + yc1) / 2;
+xmid = (xc0m + xmc1) / 2;
+ymid = (yc0m + ymc1) / 2;
+if (Double.isNaN (xmid) || Double.isNaN (ymid)) {
+return 0;
+}crossings = jssun.awt.geom.Curve.rectCrossingsForCubic (crossings, rxmin, rymin, rxmax, rymax, x0, y0, xc0, yc0, xc0m, yc0m, xmid, ymid, level + 1);
+if (crossings != -2147483648) {
+crossings = jssun.awt.geom.Curve.rectCrossingsForCubic (crossings, rxmin, rymin, rxmax, rymax, xmid, ymid, xmc1, ymc1, xc1, yc1, x1, y1, level + 1);
+}return crossings;
+}, "~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");
+Clazz.makeConstructor (c$,
+function (direction) {
+this.direction = direction;
+}, "~N");
+Clazz.defineMethod (c$, "getDirection",
+function () {
+return this.direction;
+});
+Clazz.defineMethod (c$, "getWithDirection",
+function (direction) {
+return (this.direction == direction ? this : this.getReversedCurve ());
+}, "~N");
+c$.round = Clazz.defineMethod (c$, "round",
+function (v) {
+return v;
+}, "~N");
+c$.orderof = Clazz.defineMethod (c$, "orderof",
+function (x1, x2) {
+if (x1 < x2) {
+return -1;
+}if (x1 > x2) {
+return 1;
+}return 0;
+}, "~N,~N");
+c$.signeddiffbits = Clazz.defineMethod (c$, "signeddiffbits",
+function (y1, y2) {
+return (Double.doubleToLongBits (y1) - Double.doubleToLongBits (y2));
+}, "~N,~N");
+c$.diffbits = Clazz.defineMethod (c$, "diffbits",
+function (y1, y2) {
+return Math.abs (Double.doubleToLongBits (y1) - Double.doubleToLongBits (y2));
+}, "~N,~N");
+c$.prev = Clazz.defineMethod (c$, "prev",
+function (v) {
+return Double.longBitsToDouble (Double.doubleToLongBits (v) - 1);
+}, "~N");
+c$.next = Clazz.defineMethod (c$, "next",
+function (v) {
+return Double.longBitsToDouble (Double.doubleToLongBits (v) + 1);
+}, "~N");
+Clazz.overrideMethod (c$, "toString",
+function () {
+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") + "]");
+});
+Clazz.defineMethod (c$, "controlPointString",
+function () {
+return "";
+});
+Clazz.defineMethod (c$, "crossingsFor",
+function (x, y) {
+if (y >= this.getYTop () && y < this.getYBot ()) {
+if (x < this.getXMax () && (x < this.getXMin () || x < this.XforY (y))) {
+return 1;
+}}return 0;
+}, "~N,~N");
+Clazz.defineMethod (c$, "accumulateCrossings",
+function (c) {
+var xhi = c.getXHi ();
+if (this.getXMin () >= xhi) {
+return false;
+}var xlo = c.getXLo ();
+var ylo = c.getYLo ();
+var yhi = c.getYHi ();
+var y0 = this.getYTop ();
+var y1 = this.getYBot ();
+var tstart;
+var ystart;
+var tend;
+var yend;
+if (y0 < ylo) {
+if (y1 <= ylo) {
+return false;
+}ystart = ylo;
+tstart = this.TforY (ylo);
+} else {
+if (y0 >= yhi) {
+return false;
+}ystart = y0;
+tstart = 0;
+}if (y1 > yhi) {
+yend = yhi;
+tend = this.TforY (yhi);
+} else {
+yend = y1;
+tend = 1;
+}var hitLo = false;
+var hitHi = false;
+while (true) {
+var x = this.XforT (tstart);
+if (x < xhi) {
+if (hitHi || x > xlo) {
+return true;
+}hitLo = true;
+} else {
+if (hitLo) {
+return true;
+}hitHi = true;
+}if (tstart >= tend) {
+break;
+}tstart = this.nextVertical (tstart, tend);
+}
+if (hitLo) {
+c.record (ystart, yend, this.direction);
+}return false;
+}, "jssun.awt.geom.Crossings");
+Clazz.defineMethod (c$, "getSubCurve",
+function (ystart, yend) {
+return this.getSubCurve (ystart, yend, this.direction);
+}, "~N,~N");
+Clazz.defineMethod (c$, "compareTo",
+function (that, yrange) {
+var y0 = yrange[0];
+var y1 = yrange[1];
+y1 = Math.min (Math.min (y1, this.getYBot ()), that.getYBot ());
+if (y1 <= yrange[0]) {
+System.err.println ("this == " + this);
+System.err.println ("that == " + that);
+System.out.println ("target range = " + yrange[0] + "=>" + yrange[1]);
+throw new InternalError ("backstepping from " + yrange[0] + " to " + y1);
+}yrange[1] = y1;
+if (this.getXMax () <= that.getXMin ()) {
+if (this.getXMin () == that.getXMax ()) {
+return 0;
+}return -1;
+}if (this.getXMin () >= that.getXMax ()) {
+return 1;
+}var s0 = this.TforY (y0);
+var ys0 = this.YforT (s0);
+if (ys0 < y0) {
+s0 = this.refineTforY (s0, ys0, y0);
+ys0 = this.YforT (s0);
+}var s1 = this.TforY (y1);
+if (this.YforT (s1) < y0) {
+s1 = this.refineTforY (s1, this.YforT (s1), y0);
+}var t0 = that.TforY (y0);
+var yt0 = that.YforT (t0);
+if (yt0 < y0) {
+t0 = that.refineTforY (t0, yt0, y0);
+yt0 = that.YforT (t0);
+}var t1 = that.TforY (y1);
+if (that.YforT (t1) < y0) {
+t1 = that.refineTforY (t1, that.YforT (t1), y0);
+}var xs0 = this.XforT (s0);
+var xt0 = that.XforT (t0);
+var scale = Math.max (Math.abs (y0), Math.abs (y1));
+var ymin = Math.max (scale * 1E-14, 1E-300);
+if (this.fairlyClose (xs0, xt0)) {
+var bump = ymin;
+var maxbump = Math.min (ymin * 1E13, (y1 - y0) * .1);
+var y = y0 + bump;
+while (y <= y1) {
+if (this.fairlyClose (this.XforY (y), that.XforY (y))) {
+if ((bump *= 2) > maxbump) {
+bump = maxbump;
+}} else {
+y -= bump;
+while (true) {
+bump /= 2;
+var newy = y + bump;
+if (newy <= y) {
+break;
+}if (this.fairlyClose (this.XforY (newy), that.XforY (newy))) {
+y = newy;
+}}
+break;
+}y += bump;
+}
+if (y > y0) {
+if (y < y1) {
+yrange[1] = y;
+}return 0;
+}}if (ymin <= 0) {
+System.out.println ("ymin = " + ymin);
+}while (s0 < s1 && t0 < t1) {
+var sh = this.nextVertical (s0, s1);
+var xsh = this.XforT (sh);
+var ysh = this.YforT (sh);
+var th = that.nextVertical (t0, t1);
+var xth = that.XforT (th);
+var yth = that.YforT (th);
+try {
+if (this.findIntersect (that, yrange, ymin, 0, 0, s0, xs0, ys0, sh, xsh, ysh, t0, xt0, yt0, th, xth, yth)) {
+break;
+}} catch (t) {
+System.err.println ("Error: " + t);
+System.err.println ("y range was " + yrange[0] + "=>" + yrange[1]);
+System.err.println ("s y range is " + ys0 + "=>" + ysh);
+System.err.println ("t y range is " + yt0 + "=>" + yth);
+System.err.println ("ymin is " + ymin);
+return 0;
+}
+if (ysh < yth) {
+if (ysh > yrange[0]) {
+if (ysh < yrange[1]) {
+yrange[1] = ysh;
+}break;
+}s0 = sh;
+xs0 = xsh;
+ys0 = ysh;
+} else {
+if (yth > yrange[0]) {
+if (yth < yrange[1]) {
+yrange[1] = yth;
+}break;
+}t0 = th;
+xt0 = xth;
+yt0 = yth;
+}}
+var ymid = (yrange[0] + yrange[1]) / 2;
+return jssun.awt.geom.Curve.orderof (this.XforY (ymid), that.XforY (ymid));
+}, "jssun.awt.geom.Curve,~A");
+Clazz.defineMethod (c$, "findIntersect",
+function (that, yrange, ymin, slevel, tlevel, s0, xs0, ys0, s1, xs1, ys1, t0, xt0, yt0, t1, xt1, yt1) {
+if (ys0 > yt1 || yt0 > ys1) {
+return false;
+}if (Math.min (xs0, xs1) > Math.max (xt0, xt1) || Math.max (xs0, xs1) < Math.min (xt0, xt1)) {
+return false;
+}if (s1 - s0 > 0.001) {
+var s = (s0 + s1) / 2;
+var xs = this.XforT (s);
+var ys = this.YforT (s);
+if (s == s0 || s == s1) {
+System.out.println ("s0 = " + s0);
+System.out.println ("s1 = " + s1);
+throw new InternalError ("no s progress!");
+}if (t1 - t0 > 0.001) {
+var t = (t0 + t1) / 2;
+var xt = that.XforT (t);
+var yt = that.YforT (t);
+if (t == t0 || t == t1) {
+System.out.println ("t0 = " + t0);
+System.out.println ("t1 = " + t1);
+throw new InternalError ("no t progress!");
+}if (ys >= yt0 && yt >= ys0) {
+if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s0, xs0, ys0, s, xs, ys, t0, xt0, yt0, t, xt, yt)) {
+return true;
+}}if (ys >= yt) {
+if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s0, xs0, ys0, s, xs, ys, t, xt, yt, t1, xt1, yt1)) {
+return true;
+}}if (yt >= ys) {
+if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s, xs, ys, s1, xs1, ys1, t0, xt0, yt0, t, xt, yt)) {
+return true;
+}}if (ys1 >= yt && yt1 >= ys) {
+if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel + 1, s, xs, ys, s1, xs1, ys1, t, xt, yt, t1, xt1, yt1)) {
+return true;
+}}} else {
+if (ys >= yt0) {
+if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel, s0, xs0, ys0, s, xs, ys, t0, xt0, yt0, t1, xt1, yt1)) {
+return true;
+}}if (yt1 >= ys) {
+if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel, s, xs, ys, s1, xs1, ys1, t0, xt0, yt0, t1, xt1, yt1)) {
+return true;
+}}}} else if (t1 - t0 > 0.001) {
+var t = (t0 + t1) / 2;
+var xt = that.XforT (t);
+var yt = that.YforT (t);
+if (t == t0 || t == t1) {
+System.out.println ("t0 = " + t0);
+System.out.println ("t1 = " + t1);
+throw new InternalError ("no t progress!");
+}if (yt >= ys0) {
+if (this.findIntersect (that, yrange, ymin, slevel, tlevel + 1, s0, xs0, ys0, s1, xs1, ys1, t0, xt0, yt0, t, xt, yt)) {
+return true;
+}}if (ys1 >= yt) {
+if (this.findIntersect (that, yrange, ymin, slevel, tlevel + 1, s0, xs0, ys0, s1, xs1, ys1, t, xt, yt, t1, xt1, yt1)) {
+return true;
+}}} else {
+var xlk = xs1 - xs0;
+var ylk = ys1 - ys0;
+var xnm = xt1 - xt0;
+var ynm = yt1 - yt0;
+var xmk = xt0 - xs0;
+var ymk = yt0 - ys0;
+var det = xnm * ylk - ynm * xlk;
+if (det != 0) {
+var detinv = 1 / det;
+var s = (xnm * ymk - ynm * xmk) * detinv;
+var t = (xlk * ymk - ylk * xmk) * detinv;
+if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
+s = s0 + s * (s1 - s0);
+t = t0 + t * (t1 - t0);
+if (s < 0 || s > 1 || t < 0 || t > 1) {
+System.out.println ("Uh oh!");
+}var y = (this.YforT (s) + that.YforT (t)) / 2;
+if (y <= yrange[1] && y > yrange[0]) {
+yrange[1] = y;
+return true;
+}}}}return false;
+}, "jssun.awt.geom.Curve,~A,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N,~N");
+Clazz.defineMethod (c$, "refineTforY",
+function (t0, yt0, y0) {
+var t1 = 1;
+while (true) {
+var th = (t0 + t1) / 2;
+if (th == t0 || th == t1) {
+return t1;
+}var y = this.YforT (th);
+if (y < y0) {
+t0 = th;
+yt0 = y;
+} else if (y > y0) {
+t1 = th;
+} else {
+return t1;
+}}
+}, "~N,~N,~N");
+Clazz.defineMethod (c$, "fairlyClose",
+function (v1, v2) {
+return (Math.abs (v1 - v2) < Math.max (Math.abs (v1), Math.abs (v2)) * 1E-10);
+}, "~N,~N");
+Clazz.defineStatics (c$,
+"INCREASING", 1,
+"DECREASING", -1,
+"RECT_INTERSECTS", 0x80000000,
+"TMIN", 1E-3);
+});
git://source.jalview.org / jalviewjs.git / blobdiff