site/j2s/jssun/awt/geom/Curve.js

   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
   4 this.direction = 0;\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
  13 if (y0 < 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
  17 } else {\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
  21 var y1 = coords[3];\r
  22 if (y0 > y1) {\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
  25 return;\r
  26 } else {\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
  31 var y1 = coords[5];\r
  32 if (y0 > y1) {\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
  35 return;\r
  36 } else {\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
  41 if (pi.isDone ()) {\r
  42 return 0;\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
  46 }pi.next ();\r
  47 var movx = coords[0];\r
  48 var movy = coords[1];\r
  49 var curx = movx;\r
  50 var cury = movy;\r
  51 var endx;\r
  52 var endy;\r
  53 var crossings = 0;\r
  54 while (!pi.isDone ()) {\r
  55 switch (pi.currentSegment (coords)) {\r
  56 case 0:\r
  57 if (cury != movy) {\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
  61 break;\r
  62 case 1:\r
  63 endx = coords[0];\r
  64 endy = coords[1];\r
  65 crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, endx, endy);\r
  66 curx = endx;\r
  67 cury = endy;\r
  68 break;\r
  69 case 2:\r
  70 endx = coords[2];\r
  71 endy = coords[3];\r
  72 crossings += jssun.awt.geom.Curve.pointCrossingsForQuad (px, py, curx, cury, coords[0], coords[1], endx, endy, 0);\r
  73 curx = endx;\r
  74 cury = endy;\r
  75 break;\r
  76 case 3:\r
  77 endx = coords[4];\r
  78 endy = coords[5];\r
  79 crossings += jssun.awt.geom.Curve.pointCrossingsForCubic (px, py, curx, cury, coords[0], coords[1], coords[2], coords[3], endx, endy, 0);\r
  80 curx = endx;\r
  81 cury = endy;\r
  82 break;\r
  83 case 4:\r
  84 if (cury != movy) {\r
  85 crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);\r
  86 }curx = movx;\r
  87 cury = movy;\r
  88 break;\r
  89 }\r
  90 pi.next ();\r
  91 }\r
  92 if (cury != movy) {\r
  93 crossings += jssun.awt.geom.Curve.pointCrossingsForLine (px, py, curx, cury, movx, movy);\r
  94 }return crossings;\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
 112 if (py >= y0) {\r
 113 if (py < y1) return 1;\r
 114 } else {\r
 115 if (py >= y1) return -1;\r
 116 }return 0;\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
 125 return 0;\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
 134 if (py >= y0) {\r
 135 if (py < y1) return 1;\r
 136 } else {\r
 137 if (py >= y1) return -1;\r
 138 }return 0;\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
 153 return 0;\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
 159 return 0;\r
 160 }if (pi.isDone ()) {\r
 161 return 0;\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
 165 }pi.next ();\r
 166 var curx;\r
 167 var cury;\r
 168 var movx;\r
 169 var movy;\r
 170 var endx;\r
 171 var endy;\r
 172 curx = movx = coords[0];\r
 173 cury = movy = coords[1];\r
 174 var crossings = 0;\r
 175 while (crossings != -2147483648 && !pi.isDone ()) {\r
 176 switch (pi.currentSegment (coords)) {\r
 177 case 0:\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
 182 break;\r
 183 case 1:\r
 184 endx = coords[0];\r
 185 endy = coords[1];\r
 186 crossings = jssun.awt.geom.Curve.rectCrossingsForLine (crossings, rxmin, rymin, rxmax, rymax, curx, cury, endx, endy);\r
 187 curx = endx;\r
 188 cury = endy;\r
 189 break;\r
 190 case 2:\r
 191 endx = coords[2];\r
 192 endy = coords[3];\r
 193 crossings = jssun.awt.geom.Curve.rectCrossingsForQuad (crossings, rxmin, rymin, rxmax, rymax, curx, cury, coords[0], coords[1], endx, endy, 0);\r
 194 curx = endx;\r
 195 cury = endy;\r
 196 break;\r
 197 case 3:\r
 198 endx = coords[4];\r
 199 endy = coords[5];\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
 201 curx = endx;\r
 202 cury = endy;\r
 203 break;\r
 204 case 4:\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
 207 }curx = movx;\r
 208 cury = movy;\r
 209 break;\r
 210 }\r
 211 pi.next ();\r
 212 }\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
 215 }return crossings;\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
 223 if (y0 < y1) {\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
 229 }return 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
 232 }var xi0 = x0;\r
 233 if (y0 < rymin) {\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
 237 }var xi1 = x1;\r
 238 if (y1 < rymin) {\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
 244 if (y0 < y1) {\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
 250 }return 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
 259 if (y0 < y1) {\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
 265 }return 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
 268 }if (level > 52) {\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
 277 return 0;\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
 281 }return crossings;\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
 286 return crossings;\r
 287 }if (y0 <= rymin && yc0 <= rymin && yc1 <= rymin && y1 <= rymin) {\r
 288 return crossings;\r
 289 }if (x0 <= rxmin && xc0 <= rxmin && xc1 <= rxmin && x1 <= rxmin) {\r
 290 return crossings;\r
 291 }if (x0 >= rxmax && xc0 >= rxmax && xc1 >= rxmax && x1 >= rxmax) {\r
 292 if (y0 < y1) {\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
 298 }return 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
 301 }if (level > 52) {\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
 316 return 0;\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
 320 }return crossings;\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
 325 }, "~N");\r
 326 Clazz.defineMethod (c$, "getDirection", \r
 327 function () {\r
 328 return this.direction;\r
 329 });\r
 330 Clazz.defineMethod (c$, "getWithDirection", \r
 331 function (direction) {\r
 332 return (this.direction == direction ? this : this.getReversedCurve ());\r
 333 }, "~N");\r
 334 c$.round = Clazz.defineMethod (c$, "round", \r
 335 function (v) {\r
 336 return v;\r
 337 }, "~N");\r
 338 c$.orderof = Clazz.defineMethod (c$, "orderof", \r
 339 function (x1, x2) {\r
 340 if (x1 < x2) {\r
 341 return -1;\r
 342 }if (x1 > x2) {\r
 343 return 1;\r
 344 }return 0;\r
 345 }, "~N,~N");\r
 346 c$.signeddiffbits = Clazz.defineMethod (c$, "signeddiffbits", \r
 347 function (y1, y2) {\r
 348 return (Double.doubleToLongBits (y1) - Double.doubleToLongBits (y2));\r
 349 }, "~N,~N");\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
 353 }, "~N,~N");\r
 354 c$.prev = Clazz.defineMethod (c$, "prev", \r
 355 function (v) {\r
 356 return Double.longBitsToDouble (Double.doubleToLongBits (v) - 1);\r
 357 }, "~N");\r
 358 c$.next = Clazz.defineMethod (c$, "next", \r
 359 function (v) {\r
 360 return Double.longBitsToDouble (Double.doubleToLongBits (v) + 1);\r
 361 }, "~N");\r
 362 Clazz.overrideMethod (c$, "toString", \r
 363 function () {\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
 365 });\r
 366 Clazz.defineMethod (c$, "controlPointString", \r
 367 function () {\r
 368 return "";\r
 369 });\r
 370 Clazz.defineMethod (c$, "crossingsFor", \r
 371 function (x, y) {\r
 372 if (y >= this.getYTop () && y < this.getYBot ()) {\r
 373 if (x < this.getXMax () && (x < this.getXMin () || x < this.XforY (y))) {\r
 374 return 1;\r
 375 }}return 0;\r
 376 }, "~N,~N");\r
 377 Clazz.defineMethod (c$, "accumulateCrossings", \r
 378 function (c) {\r
 379 var xhi = c.getXHi ();\r
 380 if (this.getXMin () >= xhi) {\r
 381 return false;\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
 387 var tstart;\r
 388 var ystart;\r
 389 var tend;\r
 390 var yend;\r
 391 if (y0 < ylo) {\r
 392 if (y1 <= ylo) {\r
 393 return false;\r
 394 }ystart = ylo;\r
 395 tstart = this.TforY (ylo);\r
 396 } else {\r
 397 if (y0 >= yhi) {\r
 398 return false;\r
 399 }ystart = y0;\r
 400 tstart = 0;\r
 401 }if (y1 > yhi) {\r
 402 yend = yhi;\r
 403 tend = this.TforY (yhi);\r
 404 } else {\r
 405 yend = y1;\r
 406 tend = 1;\r
 407 }var hitLo = false;\r
 408 var hitHi = false;\r
 409 while (true) {\r
 410 var x = this.XforT (tstart);\r
 411 if (x < xhi) {\r
 412 if (hitHi || x > xlo) {\r
 413 return true;\r
 414 }hitLo = true;\r
 415 } else {\r
 416 if (hitLo) {\r
 417 return true;\r
 418 }hitHi = true;\r
 419 }if (tstart >= tend) {\r
 420 break;\r
 421 }tstart = this.nextVertical (tstart, tend);\r
 422 }\r
 423 if (hitLo) {\r
 424 c.record (ystart, yend, this.direction);\r
 425 }return false;\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
 430 }, "~N,~N");\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
 441 }yrange[1] = y1;\r
 442 if (this.getXMax () <= that.getXMin ()) {\r
 443 if (this.getXMin () == that.getXMax ()) {\r
 444 return 0;\r
 445 }return -1;\r
 446 }if (this.getXMin () >= that.getXMax ()) {\r
 447 return 1;\r
 448 }var s0 = this.TforY (y0);\r
 449 var ys0 = this.YforT (s0);\r
 450 if (ys0 < y0) {\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
 458 if (yt0 < y0) {\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
 469 var bump = ymin;\r
 470 var maxbump = Math.min (ymin * 1E13, (y1 - y0) * .1);\r
 471 var y = y0 + bump;\r
 472 while (y <= y1) {\r
 473 if (this.fairlyClose (this.XforY (y), that.XforY (y))) {\r
 474 if ((bump *= 2) > maxbump) {\r
 475 bump = maxbump;\r
 476 }} else {\r
 477 y -= bump;\r
 478 while (true) {\r
 479 bump /= 2;\r
 480 var newy = y + bump;\r
 481 if (newy <= y) {\r
 482 break;\r
 483 }if (this.fairlyClose (this.XforY (newy), that.XforY (newy))) {\r
 484 y = newy;\r
 485 }}\r
 486 break;\r
 487 }y += bump;\r
 488 }\r
 489 if (y > y0) {\r
 490 if (y < y1) {\r
 491 yrange[1] = y;\r
 492 }return 0;\r
 493 }}if (ymin <= 0) {\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
 502 try {\r
 503 if (this.findIntersect (that, yrange, ymin, 0, 0, s0, xs0, ys0, sh, xsh, ysh, t0, xt0, yt0, th, xth, yth)) {\r
 504 break;\r
 505 }} catch (t) {\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
 511 return 0;\r
 512 }\r
 513 if (ysh < yth) {\r
 514 if (ysh > yrange[0]) {\r
 515 if (ysh < yrange[1]) {\r
 516 yrange[1] = ysh;\r
 517 }break;\r
 518 }s0 = sh;\r
 519 xs0 = xsh;\r
 520 ys0 = ysh;\r
 521 } else {\r
 522 if (yth > yrange[0]) {\r
 523 if (yth < yrange[1]) {\r
 524 yrange[1] = yth;\r
 525 }break;\r
 526 }t0 = th;\r
 527 xt0 = xth;\r
 528 yt0 = yth;\r
 529 }}\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
 536 return false;\r
 537 }if (Math.min (xs0, xs1) > Math.max (xt0, xt1) || Math.max (xs0, xs1) < Math.min (xt0, xt1)) {\r
 538 return false;\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
 557 return true;\r
 558 }}if (ys >= 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
 560 return true;\r
 561 }}if (yt >= ys) {\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
 563 return true;\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
 566 return true;\r
 567 }}} else {\r
 568 if (ys >= yt0) {\r
 569 if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel, s0, xs0, ys0, s, xs, ys, t0, xt0, yt0, t1, xt1, yt1)) {\r
 570 return true;\r
 571 }}if (yt1 >= ys) {\r
 572 if (this.findIntersect (that, yrange, ymin, slevel + 1, tlevel, s, xs, ys, s1, xs1, ys1, t0, xt0, yt0, t1, xt1, yt1)) {\r
 573 return true;\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
 582 }if (yt >= ys0) {\r
 583 if (this.findIntersect (that, yrange, ymin, slevel, tlevel + 1, s0, xs0, ys0, s1, xs1, ys1, t0, xt0, yt0, t, xt, yt)) {\r
 584 return true;\r
 585 }}if (ys1 >= 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
 587 return true;\r
 588 }}} else {\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
 596 if (det != 0) {\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
 607 yrange[1] = y;\r
 608 return true;\r
 609 }}}}return false;\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
 613 var t1 = 1;\r
 614 while (true) {\r
 615 var th = (t0 + t1) / 2;\r
 616 if (th == t0 || th == t1) {\r
 617 return t1;\r
 618 }var y = this.YforT (th);\r
 619 if (y < y0) {\r
 620 t0 = th;\r
 621 yt0 = y;\r
 622 } else if (y > y0) {\r
 623 t1 = th;\r
 624 } else {\r
 625 return t1;\r
 626 }}\r
 627 }, "~N,~N,~N");\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
 631 }, "~N,~N");\r
 632 Clazz.defineStatics (c$,\r
 633 "INCREASING", 1,\r
 634 "DECREASING", -1,\r
 635 "RECT_INTERSECTS", 0x80000000,\r
 636 "TMIN", 1E-3);\r
 637 });\r