engine/kagecd.js

   1 function cdDrawCurveU(kage, polygons, x1, y1, sx1, sy1, sx2, sy2, x2, y2, a1, a2){\r
   2   var rad, t;\r
   3   var x, y, v;\r
   4   var ix, iy, ia, ib, ir;\r
   5   var tt;\r
   6   var delta;\r
   7   var deltad;\r
   8   var XX, XY, YX, YY;\r
   9   var poly, poly2;\r
  10   var hosomi;\r
  11   \r
  12   if(kage.kShotai == kage.kMincho){ // mincho\r
  13     switch(a1 % 100){\r
  14     case 0:\r
  15     case 7:\r
  16       delta = -1 * kage.kMinWidthY * 0.5;\r
  17       break;\r
  18     case 1:\r
  19     case 2: // ... must be 32\r
  20     case 6:\r
  21     case 22:\r
  22     case 32: // changed\r
  23       delta = 0;\r
  24       break;\r
  25     case 12:\r
  26     //case 32:\r
  27       delta = kage.kMinWidthY;\r
  28       break;\r
  29     default:\r
  30       break;\r
  31     }\r
  32     \r
  33     if(x1 == sx1){\r
  34       if(y1 < sy1){ y1 = y1 - delta; }\r
  35       else{ y1 = y1 + delta; }\r
  36     }\r
  37     else if(y1 == sy1){\r
  38       if(x1 < sx1){ x1 = x1 - delta; }\r
  39       else{ x1 = x1 + delta; }\r
  40     }\r
  41     else{\r
  42       rad = Math.atan((sy1 - y1) / (sx1 - x1));\r
  43       if(x1 < sx1){ v = 1; } else{ v = -1; }\r
  44       x1 = x1 - delta * Math.cos(rad) * v;\r
  45       y1 = y1 - delta * Math.sin(rad) * v;\r
  46     }\r
  47     \r
  48     switch(a2 % 100){\r
  49     case 0:\r
  50     case 1:\r
  51     case 7:\r
  52     case 9:\r
  53     case 15: // it can change to 15->5\r
  54     case 14: // it can change to 14->4\r
  55     case 17: // no need\r
  56     case 5:\r
  57       delta = 0;\r
  58       break;\r
  59     case 8: // get shorten for tail's circle\r
  60       delta = -1 * kage.kMinWidthT * 0.5;\r
  61       break;\r
  62     default:\r
  63       break;\r
  64     }\r
  65     \r
  66     if(sx2 == x2){\r
  67       if(sy2 < y2){ y2 = y2 + delta; }\r
  68       else{ y2 = y2 - delta; }\r
  69     }\r
  70     else if(sy2 == y2){\r
  71       if(sx2 < x2){ x2 = x2 + delta; }\r
  72       else{ x2 = x2 - delta; }\r
  73     }\r
  74     else{\r
  75       rad = Math.atan((y2 - sy2) / (x2 - sx2));\r
  76       if(sx2 < x2){ v = 1; } else{ v = -1; }\r
  77       x2 = x2 + delta * Math.cos(rad) * v;\r
  78       y2 = y2 + delta * Math.sin(rad) * v;\r
  79     }\r
  80     \r
  81     hosomi = 0.5;\r
  82     if(Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) < 50){\r
  83       hosomi += 0.4 * (1 - Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) / 50);\r
  84     }\r
  85     \r
  86     //---------------------------------------------------------------\r
  87     \r
  88     poly = new Polygon();\r
  89     poly2 = new Polygon();\r
  90     \r
  91     if(sx1 == sx2 && sy1 == sy2){ // Spline\r
  92       if(kage.kUseCurve){\r
  93         // generating fatten curve -- begin\r
  94         var kage2 = new Kage();\r
  95         kage2.kRate = 10;\r
  96         \r
  97         var curve = new Array(2); // L and R\r
  98         get_candidate(kage2, curve, a1, a2, x1, y1, sx1, sy1, x2, y2);\r
  99         \r
 100         var dcl12_34 = new Array(2);\r
 101         var dcr12_34 = new Array(2);\r
 102         var dpl12_34 = new Array(2);\r
 103         var dpr12_34 = new Array(2);\r
 104         divide_curve(kage2, x1, y1, sx1, sy1, x2, y2, curve[0], dcl12_34, dpl12_34);\r
 105         divide_curve(kage2, x1, y1, sx1, sy1, x2, y2, curve[1], dcr12_34, dpr12_34);\r
 106         \r
 107         var ncl1 = new Array(7);\r
 108         var ncl2 = new Array(7);\r
 109         find_offcurve(kage2, dcl12_34[0], dpl12_34[0][2], dpl12_34[0][3], ncl1);\r
 110         find_offcurve(kage2, dcl12_34[1], dpl12_34[1][2], dpl12_34[1][3], ncl2);\r
 111         \r
 112         poly.push(ncl1[0], ncl1[1]);\r
 113         poly.push(ncl1[2], ncl1[3], 1);\r
 114         poly.push(ncl1[4], ncl1[5]);\r
 115         poly.push(ncl2[2], ncl2[3], 1);\r
 116         poly.push(ncl2[4], ncl2[5]);\r
 117         \r
 118         poly2.push(dcr12_34[0][0][0], dcr12_34[0][0][1]);\r
 119         poly2.push(dpr12_34[0][2] - (ncl1[2] - dpl12_34[0][2]), dpl12_34[0][3] - (ncl1[3] - dpl12_34[0][3]), 1);\r
 120         poly2.push(dcr12_34[0][dcr12_34[0].length - 1][0], dcr12_34[0][dcr12_34[0].length - 1][1]);\r
 121         poly2.push(dpr12_34[1][2] - (ncl2[2] - dpl12_34[1][2]), dpl12_34[1][3] - (ncl2[3] - dpl12_34[1][3]), 1);\r
 122         poly2.push(dcr12_34[1][dcr12_34[1].length - 1][0], dcr12_34[1][dcr12_34[1].length - 1][1]);\r
 123         \r
 124         poly2.reverse();\r
 125         poly.concat(poly2);\r
 126         polygons.push(poly);\r
 127         // generating fatten curve -- end\r
 128       } else {\r
 129         for(tt = 0; tt <= 1000; tt = tt + kage.kRate){\r
 130           t = tt / 1000;\r
 131           \r
 132           // calculate a dot\r
 133           x = ((1.0 - t) * (1.0 - t) * x1 + 2.0 * t * (1.0 - t) * sx1 + t * t * x2);\r
 134           y = ((1.0 - t) * (1.0 - t) * y1 + 2.0 * t * (1.0 - t) * sy1 + t * t * y2);\r
 135           \r
 136           // KATAMUKI of vector by BIBUN\r
 137           ix = (x1 - 2.0 * sx1 + x2) * 2.0 * t + (-2.0 * x1 + 2.0 * sx1);\r
 138           iy = (y1 - 2.0 * sy1 + y2) * 2.0 * t + (-2.0 * y1 + 2.0 * sy1);\r
 139           \r
 140           // line SUICHOKU by vector\r
 141           if(ix != 0 && iy != 0){\r
 142             ir = Math.atan(iy / ix * -1);\r
 143             ia = Math.sin(ir) * (kage.kMinWidthT);\r
 144             ib = Math.cos(ir) * (kage.kMinWidthT);\r
 145           }\r
 146           else if(ix == 0){\r
 147             ia = kage.kMinWidthT;\r
 148             ib = 0;\r
 149           }\r
 150           else{\r
 151             ia = 0;\r
 152             ib = kage.kMinWidthT;\r
 153           }\r
 154           \r
 155           if(a1 == 7 && a2 == 0){ // L2RD: fatten\r
 156             deltad = Math.pow(t, hosomi) * kage.kL2RDfatten;\r
 157           }\r
 158           else if(a1 == 7){\r
 159             deltad = Math.pow(t, hosomi);\r
 160           }\r
 161           else if(a2 == 7){\r
 162             deltad = Math.pow(1.0 - t, hosomi);\r
 163           }\r
 164           else{ deltad = 1; }\r
 165           \r
 166           if(deltad < 0.15){\r
 167             deltad = 0.15;\r
 168           }\r
 169           ia = ia * deltad;\r
 170           ib = ib * deltad;\r
 171           \r
 172           //reverse if vector is going 2nd/3rd quadrants\r
 173           if(ix <= 0){\r
 174             ia = ia * -1;\r
 175             ib = ib * -1;\r
 176           }\r
 177           \r
 178           //copy to polygon structure\r
 179           poly.push(x - ia, y - ib);\r
 180           poly2.push(x + ia, y + ib);\r
 181         }\r
 182         \r
 183         // suiheisen ni setsuzoku\r
 184         if(a1 == 132){\r
 185           var index = 0;\r
 186           while(true){\r
 187             if(poly2.array[index].y <= y1 && y1 <= poly2.array[index + 1].y){\r
 188               break;\r
 189             }\r
 190             index++;\r
 191           }\r
 192           newx1 = poly2.array[index + 1].x + (poly2.array[index].x - poly2.array[index + 1].x) *\r
 193             (poly2.array[index + 1].y - y1) / (poly2.array[index + 1].y - poly2.array[index].y);\r
 194           newy1 = y1;\r
 195           newx2 = poly.array[0].x + (poly.array[0].x - poly.array[1].x) * (poly.array[0].y - y1) /\r
 196             (poly.array[1].y - poly.array[0].y);\r
 197           newy2 = y1;\r
 198           \r
 199           for(var i = 0; i < index; i++){\r
 200             poly2.shift();\r
 201           }\r
 202           poly2.set(0, newx1, newy1);\r
 203           poly.unshift(newx2, newy2);\r
 204         }\r
 205         \r
 206         poly2.reverse();\r
 207         poly.concat(poly2);\r
 208         polygons.push(poly);\r
 209       }\r
 210     } else { // Bezier\r
 211       for(tt = 0; tt <= 1000; tt = tt + kage.kRate){\r
 212         t = tt / 1000;\r
 213         \r
 214         // calculate a dot\r
 215         x = (1.0 - t) * (1.0 - t) * (1.0 - t) * x1 + 3.0 * t * (1.0 - t) * (1.0 - t) * sx1 + 3 * t * t * (1.0 - t) * sx2 + t * t * t * x2;\r
 216         y = (1.0 - t) * (1.0 - t) * (1.0 - t) * y1 + 3.0 * t * (1.0 - t) * (1.0 - t) * sy1 + 3 * t * t * (1.0 - t) * sy2 + t * t * t * y2;\r
 217         // KATAMUKI of vector by BIBUN\r
 218         ix = t * t * (-3 * x1 + 9 * sx1 + -9 * sx2 + 3 * x2) + t * (6 * x1 + -12 * sx1 + 6 * sx2) + -3 * x1 + 3 * sx1;\r
 219         iy = t * t * (-3 * y1 + 9 * sy1 + -9 * sy2 + 3 * y2) + t * (6 * y1 + -12 * sy1 + 6 * sy2) + -3 * y1 + 3 * sy1;\r
 220         \r
 221         // line SUICHOKU by vector\r
 222         if(ix != 0 && iy != 0){\r
 223           ir = Math.atan(iy / ix * -1);\r
 224           ia = Math.sin(ir) * (kage.kMinWidthT);\r
 225           ib = Math.cos(ir) * (kage.kMinWidthT);\r
 226         }\r
 227         else if(ix == 0){\r
 228           ia = kage.kMinWidthT;\r
 229           ib = 0;\r
 230         }\r
 231         else{\r
 232           ia = 0;\r
 233           ib = kage.kMinWidthT;\r
 234         }\r
 235         \r
 236         if(a1 == 7 && a2 == 0){ // L2RD: fatten\r
 237           deltad = Math.pow(t, hosomi) * kage.kL2RDfatten;\r
 238         }\r
 239         else if(a1 == 7){\r
 240           deltad = Math.pow(t, hosomi);\r
 241         }\r
 242         else if(a2 == 7){\r
 243           deltad = Math.pow(1.0 - t, hosomi);\r
 244         }\r
 245         else{ deltad = 1; }\r
 246         \r
 247         if(deltad < 0.15){\r
 248           deltad = 0.15;\r
 249         }\r
 250         ia = ia * deltad;\r
 251         ib = ib * deltad;\r
 252         \r
 253         //reverse if vector is going 2nd/3rd quadrants\r
 254         if(ix <= 0){\r
 255           ia = ia * -1;\r
 256           ib = ib * -1;\r
 257         }\r
 258         \r
 259         //copy to polygon structure\r
 260         poly.push(x - ia, y - ib);\r
 261         poly2.push(x + ia, y + ib);\r
 262       }\r
 263       \r
 264       // suiheisen ni setsuzoku\r
 265       if(a1 == 132){\r
 266         var index = 0;\r
 267         while(true){\r
 268           if(poly2.array[index].y <= y1 && y1 <= poly2.array[index + 1].y){\r
 269             break;\r
 270           }\r
 271           index++;\r
 272         }\r
 273         newx1 = poly2.array[index + 1].x + (poly2.array[index].x - poly2.array[index + 1].x) *\r
 274           (poly2.array[index + 1].y - y1) / (poly2.array[index + 1].y - poly2.array[index].y);\r
 275         newy1 = y1;\r
 276         newx2 = poly.array[0].x + (poly.array[0].x - poly.array[1].x) * (poly.array[0].y - y1) /\r
 277           (poly.array[1].y - poly.array[0].y);\r
 278         newy2 = y1;\r
 279         \r
 280         for(var i = 0; i < index; i++){\r
 281           poly2.shift();\r
 282         }\r
 283         poly2.set(0, newx1, newy1);\r
 284         poly.unshift(newx2, newy2);\r
 285       }\r
 286       \r
 287       poly2.reverse();\r
 288       poly.concat(poly2);\r
 289       polygons.push(poly);\r
 290     }\r
 291     \r
 292     //process for head of stroke\r
 293     rad = Math.atan((sy1 - y1) / (sx1 - x1));\r
 294     if(x1 < sx1){ v = 1; } else{ v = -1; }\r
 295     XX = Math.sin(rad) * v;\r
 296     XY = Math.cos(rad) * v * -1;\r
 297     YX = Math.cos(rad) * v;\r
 298     YY = Math.sin(rad) * v;\r
 299     \r
 300     if(a1 == 12){\r
 301       if(x1 == x2){\r
 302         poly= new Polygon();\r
 303         poly.push(x1 - kage.kMinWidthT, y1);\r
 304         poly.push(x1 + kage.kMinWidthT, y1);\r
 305         poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthT);\r
 306         polygons.push(poly);\r
 307       }\r
 308       else{\r
 309         poly = new Polygon();\r
 310         poly.push(x1 - kage.kMinWidthT * XX, y1 - kage.kMinWidthT * XY);\r
 311         poly.push(x1 + kage.kMinWidthT * XX, y1 + kage.kMinWidthT * XY);\r
 312         poly.push(x1 - kage.kMinWidthT * XX - kage.kMinWidthT * YX, y1 - kage.kMinWidthT * XY - kage.kMinWidthT * YY);\r
 313         polygons.push(poly);\r
 314       }\r
 315     }\r
 316     \r
 317     var type;\r
 318     var pm = 0;\r
 319     if(a1 == 0){\r
 320       if(y1 <= y2){ //from up to bottom\r
 321         type = (Math.atan2(Math.abs(y1 - sy1), Math.abs(x1 - sx1)) / Math.PI * 2 - 0.4);\r
 322         if(type > 0){\r
 323           type = type * 2;\r
 324         } else {\r
 325           type = type * 16;\r
 326         }\r
 327         if(type < 0){\r
 328           pm = -1;\r
 329         } else {\r
 330           pm = 1;\r
 331         }\r
 332         if(x1 == sx1){\r
 333           poly = new Polygon();\r
 334           poly.push(x1 - kage.kMinWidthT, y1);\r
 335           poly.push(x1 + kage.kMinWidthT, y1);\r
 336           poly.push(x1 - kage.kMinWidthT * pm, y1 - kage.kMinWidthY * type * pm);\r
 337           polygons.push(poly);\r
 338         }\r
 339         else{\r
 340           poly = new Polygon();\r
 341           poly.push(x1 - kage.kMinWidthT * XX, y1 - kage.kMinWidthT * XY);\r
 342           poly.push(x1 + kage.kMinWidthT * XX, y1 + kage.kMinWidthT * XY);\r
 343           poly.push(x1 - kage.kMinWidthT * pm * XX - kage.kMinWidthY * type * pm * YX, y1 - kage.kMinWidthT * pm * XY - kage.kMinWidthY * type * pm * YY);\r
 344           polygons.push(poly);\r
 345         }\r
 346       }\r
 347       else{ //bottom to up\r
 348         if(x1 == sx1){\r
 349           poly = new Polygon();\r
 350           poly.push(x1 - kage.kMinWidthT, y1);\r
 351           poly.push(x1 + kage.kMinWidthT, y1);\r
 352           poly.push(x1 + kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 353           polygons.push(poly);\r
 354         }\r
 355         else{\r
 356           poly = new Polygon();\r
 357           poly.push(x1 - kage.kMinWidthT * XX, y1 - kage.kMinWidthT * XY);\r
 358           poly.push(x1 + kage.kMinWidthT * XX, y1 + kage.kMinWidthT * XY);\r
 359           poly.push(x1 + kage.kMinWidthT * XX - kage.kMinWidthY * YX, y1 + kage.kMinWidthT * XY - kage.kMinWidthY * YY);\r
 360           polygons.push(poly);\r
 361         }\r
 362       }\r
 363     }\r
 364     \r
 365     if(a1 == 22){ //box's up-right corner, any time same degree\r
 366       poly = new Polygon();\r
 367       poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 368       poly.push(x1, y1 - kage.kMinWidthY - kage.kWidth);\r
 369       poly.push(x1 + kage.kMinWidthT + kage.kWidth, y1 + kage.kMinWidthY);\r
 370       poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthT);\r
 371       poly.push(x1, y1 + kage.kMinWidthT);\r
 372       polygons.push(poly);\r
 373     }\r
 374     \r
 375     if(a1 == 0){ //beginning of the stroke\r
 376       if(y1 <= y2){ //from up to bottom\r
 377         if(pm > 0){\r
 378           type = 0;\r
 379         }\r
 380         var move = kage.kMinWidthY * type * pm;\r
 381         if(x1 == sx1){\r
 382           poly = new Polygon();\r
 383           poly.push(x1 + kage.kMinWidthT, y1 - move);\r
 384           poly.push(x1 + kage.kMinWidthT * 1.5, y1 + kage.kMinWidthY - move);\r
 385           poly.push(x1 + kage.kMinWidthT * 0.5, y1 + kage.kMinWidthY * 3 - move / 2);\r
 386           polygons.push(poly);\r
 387         }\r
 388         else{\r
 389           poly = new Polygon();\r
 390           poly.push(x1 + kage.kMinWidthT * XX - move * YX,\r
 391                     y1 + kage.kMinWidthT * XY - move * YY);\r
 392           poly.push(x1 + kage.kMinWidthT * 1.5 * XX + (kage.kMinWidthY - move * 1.2) * YX,\r
 393                     y1 + kage.kMinWidthT * 1.5 * XY + (kage.kMinWidthY - move * 1.2) * YY);\r
 394           poly.push(x1 + kage.kMinWidthT * 0.5 * XX + (kage.kMinWidthY * 3 - move * 0.8) * YX,\r
 395                     y1 + kage.kMinWidthT * 0.5 * XY + (kage.kMinWidthY * 3 - move * 0.8) * YY);\r
 396           polygons.push(poly);\r
 397         }\r
 398       }\r
 399       else{ //from bottom to up\r
 400         if(x1 == sx1){\r
 401           poly = new Polygon();\r
 402           poly.push(x1 - kage.kMinWidthT, y1);\r
 403           poly.push(x1 - kage.kMinWidthT * 1.5, y1 + kage.kMinWidthY);\r
 404           poly.push(x1 - kage.kMinWidthT * 0.5, y1 + kage.kMinWidthY * 3);\r
 405           polygons.push(poly);\r
 406         }\r
 407         else{\r
 408           poly = new Polygon();\r
 409           poly.push(x1 - kage.kMinWidthT * XX, y1 - kage.kMinWidthT * XY);\r
 410           poly.push(x1 - kage.kMinWidthT * 1.5 * XX + kage.kMinWidthY * YX, y1 + kage.kMinWidthY * YY - kage.kMinWidthT * 1.5 * XY);\r
 411           poly.push(x1 - kage.kMinWidthT * 0.5 * XX + kage.kMinWidthY * 3 * YX, y1 + kage.kMinWidthY * 3 * YY - kage.kMinWidthT * 0.5 * XY);\r
 412           polygons.push(poly);\r
 413         }\r
 414       }\r
 415     }\r
 416     \r
 417     //process for tail\r
 418     rad = Math.atan((y2 - sy2) / (x2 - sx2));\r
 419     if(sx2 < x2){ v = 1; } else{ v = -1; }\r
 420     YX = Math.sin(rad) * v * -1;\r
 421     YY = Math.cos(rad) * v;\r
 422     XX = Math.cos(rad) * v;\r
 423     XY = Math.sin(rad) * v;\r
 424     \r
 425     if(a2 == 1 || a2 == 8 || a2 == 15){ //the last filled circle ... it can change 15->5\r
 426       if(sx2 == x2){\r
 427         poly = new Polygon();\r
 428         if(kage.kUseCurve){\r
 429           // by curve path\r
 430           poly.push(x2 - kage.kMinWidthT, y2);\r
 431           poly.push(x2 - kage.kMinWidthT, y2 + kage.kMinWidthT, 1);\r
 432           poly.push(x2, y2 + kage.kMinWidthT);\r
 433           poly.push(x2 + kage.kMinWidthT, y2 + kage.kMinWidthT, 1);\r
 434           poly.push(x2 + kage.kMinWidthT, y2);\r
 435         } else {\r
 436           // by polygon\r
 437           poly.push(x2 - kage.kMinWidthT, y2);\r
 438           poly.push(x2 - kage.kMinWidthT * 0.7, y2 + kage.kMinWidthT * 0.7);\r
 439           poly.push(x2, y2 + kage.kMinWidthT);\r
 440           poly.push(x2 + kage.kMinWidthT * 0.7, y2 + kage.kMinWidthT * 0.7);\r
 441           poly.push(x2 + kage.kMinWidthT, y2);\r
 442         }\r
 443         polygons.push(poly);\r
 444       }\r
 445       else if(sy2 == y2){\r
 446         poly = new Polygon();\r
 447         if(kage.kUseCurve){\r
 448           // by curve path\r
 449           poly.push(x2 - kage.kMinWidthT, y2);\r
 450           poly.push(x2 - kage.kMinWidthT, y2 + kage.kMinWidthT, 1);\r
 451           poly.push(x2, y2 + kage.kMinWidthT);\r
 452           poly.push(x2 + kage.kMinWidthT, y2 + kage.kMinWidthT, 1);\r
 453           poly.push(x2 + kage.kMinWidthT, y2);\r
 454         } else {\r
 455           // by polygon\r
 456           poly.push(x2, y2 - kage.kMinWidthT);\r
 457           poly.push(x2 + kage.kMinWidthT * 0.7, y2 - kage.kMinWidthT * 0.7);\r
 458           poly.push(x2 + kage.kMinWidthT, y2);\r
 459           poly.push(x2 + kage.kMinWidthT * 0.7, y2 + kage.kMinWidthT * 0.7);\r
 460           poly.push(x2, y2 + kage.kMinWidthT);\r
 461         }\r
 462         polygons.push(poly);\r
 463       }\r
 464       else{\r
 465         poly = new Polygon();\r
 466         if(kage.kUseCurve){\r
 467           poly.push(x2 + Math.sin(rad) * kage.kMinWidthT * v, y2 - Math.cos(rad) * kage.kMinWidthT * v);\r
 468           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * 0.9 * v + Math.sin(rad) * kage.kMinWidthT * 0.9 * v,\r
 469                     y2 + Math.sin(rad) * kage.kMinWidthT * 0.9 * v - Math.cos(rad) * kage.kMinWidthT * 0.9 * v, 1);\r
 470           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * v, y2 + Math.sin(rad) * kage.kMinWidthT * v);\r
 471           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * 0.9 * v - Math.sin(rad) * kage.kMinWidthT * 0.9 * v,\r
 472                     y2 + Math.sin(rad) * kage.kMinWidthT * 0.9 * v + Math.cos(rad) * kage.kMinWidthT * 0.9 * v, 1);\r
 473           poly.push(x2 - Math.sin(rad) * kage.kMinWidthT * v, y2 + Math.cos(rad) * kage.kMinWidthT * v);\r
 474         } else {\r
 475           poly.push(x2 + Math.sin(rad) * kage.kMinWidthT * v, y2 - Math.cos(rad) * kage.kMinWidthT * v);\r
 476           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * 0.7 * v + Math.sin(rad) * kage.kMinWidthT * 0.7 * v,\r
 477                     y2 + Math.sin(rad) * kage.kMinWidthT * 0.7 * v - Math.cos(rad) * kage.kMinWidthT * 0.7 * v);\r
 478           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * v, y2 + Math.sin(rad) * kage.kMinWidthT * v);\r
 479           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * 0.7 * v - Math.sin(rad) * kage.kMinWidthT * 0.7 * v,\r
 480                     y2 + Math.sin(rad) * kage.kMinWidthT * 0.7 * v + Math.cos(rad) * kage.kMinWidthT * 0.7 * v);\r
 481           poly.push(x2 - Math.sin(rad) * kage.kMinWidthT * v, y2 + Math.cos(rad) * kage.kMinWidthT * v);\r
 482         }\r
 483         polygons.push(poly);\r
 484       }\r
 485     }\r
 486     \r
 487     if(a2 == 9 || (a1 == 7 && a2 == 0)){ // Math.sinnyu & L2RD Harai ... no need for a2=9\r
 488       var type = (Math.atan2(Math.abs(y2 - sy2), Math.abs(x2 - sx2)) / Math.PI * 2 - 0.6);\r
 489       if(type > 0){\r
 490         type = type * 8;\r
 491       } else {\r
 492         type = type * 3;\r
 493       }\r
 494       var pm = 0;\r
 495       if(type < 0){\r
 496         pm = -1;\r
 497       } else {\r
 498         pm = 1;\r
 499       }\r
 500       if(sy2 == y2){\r
 501         poly = new Polygon();\r
 502         poly.push(x2, y2 + kage.kMinWidthT * kage.kL2RDfatten);\r
 503         poly.push(x2, y2 - kage.kMinWidthT * kage.kL2RDfatten);\r
 504         poly.push(x2 + kage.kMinWidthT * kage.kL2RDfatten * Math.abs(type), y2 + kage.kMinWidthT * kage.kL2RDfatten * pm);\r
 505         polygons.push(poly);\r
 506       }\r
 507       else{\r
 508         poly = new Polygon();\r
 509         poly.push(x2 + kage.kMinWidthT * kage.kL2RDfatten * YX, y2 + kage.kMinWidthT * kage.kL2RDfatten * YY);\r
 510         poly.push(x2 - kage.kMinWidthT * kage.kL2RDfatten * YX, y2 - kage.kMinWidthT * kage.kL2RDfatten * YY);\r
 511         poly.push(x2 + kage.kMinWidthT * kage.kL2RDfatten * Math.abs(type) * XX + kage.kMinWidthT * kage.kL2RDfatten * pm * YX,\r
 512                   y2 + kage.kMinWidthT * kage.kL2RDfatten * Math.abs(type) * XY + kage.kMinWidthT * kage.kL2RDfatten * pm * YY);\r
 513         polygons.push(poly);\r
 514       }\r
 515     }\r
 516     \r
 517     if(a2 == 15){ //jump up ... it can change 15->5\r
 518       if(sy2 == y2){\r
 519         poly = new Polygon();\r
 520         poly.push(x2, y2 - kage.kMinWidthT + 1);\r
 521         poly.push(x2 + 2, y2 - kage.kMinWidthT - kage.kWidth * 5);\r
 522         poly.push(x2, y2 - kage.kMinWidthT - kage.kWidth * 5);\r
 523         poly.push(x2 - kage.kMinWidthT, y2 - kage.kMinWidthT + 1);\r
 524         polygons.push(poly);\r
 525       }\r
 526       else{\r
 527         poly = new Polygon();\r
 528         poly.push(x2 + (kage.kMinWidthT - 1) * Math.sin(rad) * v, y2 - (kage.kMinWidthT - 1) * Math.cos(rad) * v);\r
 529         poly.push(x2 + 2 * Math.cos(rad) * v + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
 530                   y2 + 2 * Math.sin(rad) * v - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
 531         poly.push(x2 + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
 532                   y2 - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
 533         poly.push(x2 + (kage.kMinWidthT - 1) * Math.sin(rad) * v - kage.kMinWidthT * Math.cos(rad) * v,\r
 534                   y2 - (kage.kMinWidthT - 1) * Math.cos(rad) * v - kage.kMinWidthT * Math.sin(rad) * v);\r
 535         polygons.push(poly);\r
 536       }\r
 537     }\r
 538     \r
 539     if(a2 == 14){ //jump to left, allways go left ... it can change 14->4\r
 540       poly = new Polygon();\r
 541       poly.push(x2, y2);\r
 542       poly.push(x2, y2 - kage.kMinWidthT);\r
 543       poly.push(x2 - kage.kWidth * 4, y2 - kage.kMinWidthT);\r
 544       poly.push(x2 - kage.kWidth * 4, y2 - kage.kMinWidthT * 0.5);\r
 545       polygons.push(poly);\r
 546     }\r
 547   }\r
 548   else{ //gothic\r
 549     if(a1 % 10 == 2){\r
 550       if(x1 == sx1){\r
 551         if(y1 < sy1){ y1 = y1 - kage.kWidth; } else{ y1 = y1 + kage.kWidth; }\r
 552       }\r
 553       else if(y1 == sy1){\r
 554         if(x1 < sx1){ x1 = x1 - kage.kWidth; } else{ x1 = x1 + kage.kWidth; }\r
 555       }\r
 556       else{\r
 557         rad = Math.atan((sy1 - y1) / (sx1 - x1));\r
 558         if(x1 < sx1){ v = 1; } else{ v = -1; }\r
 559         x1 = x1 - kage.kWidth * Math.cos(rad) * v;\r
 560         y1 = y1 - kage.kWidth * Math.sin(rad) * v;\r
 561       }\r
 562     }\r
 563     \r
 564     if(a1 % 10 == 3){\r
 565       if(x1 == sx1){\r
 566         if(y1 < sy1){\r
 567           y1 = y1 - kage.kWidth * kage.kKakato;\r
 568         }\r
 569         else{\r
 570           y1 = y1 + kage.kWidth * kage.kKakato;\r
 571         }\r
 572       }\r
 573       else if(y1 == sy1){\r
 574         if(x1 < sx1){\r
 575           x1 = x1 - kage.kWidth * kage.kKakato;\r
 576         }\r
 577         else{\r
 578           x1 = x1 + kage.kWidth * kage.kKakato;\r
 579         }\r
 580       }\r
 581       else{\r
 582         rad = Math.atan((sy1 - y1) / (sx1 - x1));\r
 583         if(x1 < sx1){ v = 1; } else{ v = -1; }\r
 584         x1 = x1 - kage.kWidth * Math.cos(rad) * v * kage.kKakato;\r
 585         y1 = y1 - kage.kWidth * Math.sin(rad) * v * kage.kKakato;\r
 586       }\r
 587     }\r
 588     if(a2 % 10 == 2){\r
 589       if(sx2 == x2){\r
 590         if(sy2 < y2){ y2 = y2 + kage.kWidth; } else{ y2 = y2 - kage.kWidth; }\r
 591       }\r
 592       else if(sy2 == y2){\r
 593         if(sx2 < x2){ x2 = x2 + kage.kWidth; } else{ x2 = x2 - kage.kWidth; }\r
 594       }\r
 595       else{\r
 596         rad = Math.atan((y2 - sy2) / (x2 - sx2));\r
 597         if(sx2 < x2){ v = 1; } else{ v = -1; }\r
 598         x2 = x2 + kage.kWidth * Math.cos(rad) * v;\r
 599         y2 = y2 + kage.kWidth * Math.sin(rad) * v;\r
 600       }\r
 601     }\r
 602     \r
 603     if(a2 % 10 == 3){\r
 604       if(sx2 == x2){\r
 605         if(sy2 < y2){\r
 606           y2 = y2 + kage.kWidth * kage.kKakato;\r
 607         }\r
 608         else{\r
 609           y2 = y2 - kage.kWidth * kage.kKakato;\r
 610         }\r
 611       }\r
 612       else if(sy2 == y2){\r
 613         if(sx2 < x2){\r
 614           x2 = x2 + kage.kWidth * kage.kKakato;\r
 615         }\r
 616         else{\r
 617           x2 = x2 - kage.kWidth * kage.kKakato;\r
 618         }\r
 619       }\r
 620       else{\r
 621         rad = Math.atan((y2 - sy2) / (x2 - sx2));\r
 622         if(sx2 < x2){ v = 1; } else{ v = -1; }\r
 623         x2 = x2 + kage.kWidth * Math.cos(rad) * v * kage.kKakato;\r
 624         y2 = y2 + kage.kWidth * Math.sin(rad) * v * kage.kKakato;\r
 625       }\r
 626     }\r
 627     \r
 628     poly = new Polygon();\r
 629     poly2 = new Polygon();\r
 630     \r
 631     for(tt = 0; tt <= 1000; tt = tt + kage.kRate){\r
 632       t = tt / 1000;\r
 633       \r
 634       if(sx1 == sx2 && sy1 == sy2){\r
 635         //calculating each point\r
 636         x = ((1.0 - t) * (1.0 - t) * x1 + 2.0 * t * (1.0 - t) * sx1 + t * t * x2);\r
 637         y = ((1.0 - t) * (1.0 - t) * y1 + 2.0 * t * (1.0 - t) * sy1 + t * t * y2);\r
 638         \r
 639         //SESSEN NO KATAMUKI NO KEISAN(BIBUN)\r
 640         ix = (x1 - 2.0 * sx1 + x2) * 2.0 * t + (-2.0 * x1 + 2.0 * sx1);\r
 641         iy = (y1 - 2.0 * sy1 + y2) * 2.0 * t + (-2.0 * y1 + 2.0 * sy1);\r
 642       } else {\r
 643       }\r
 644       //SESSEN NI SUICHOKU NA CHOKUSEN NO KEISAN\r
 645       if(kage.kShotai == kage.kMincho){ //always false ?\r
 646         if(ix != 0 && iy != 0){\r
 647           ir = Math.atan(iy / ix * -1.0);\r
 648           ia = Math.sin(ir) * kage.kMinWidthT;\r
 649           ib = Math.cos(ir) * kage.kMinWidthT;\r
 650         }\r
 651         else if(ix == 0){\r
 652           ia = kage.kMinWidthT;\r
 653           ib = 0;\r
 654         }\r
 655         else{\r
 656           ia = 0;\r
 657           ib = kage.kMinWidthT;\r
 658         }\r
 659         ia = ia * Math.sqrt(1.0 - t);\r
 660         ib = ib * Math.sqrt(1.0 - t);\r
 661       }\r
 662       else{\r
 663         if(ix != 0 && iy != 0){\r
 664           ir = Math.atan(iy / ix * -1.0);\r
 665           ia = Math.sin(ir) * kage.kWidth;\r
 666           ib = Math.cos(ir) * kage.kWidth;\r
 667         }\r
 668         else if(ix == 0){\r
 669           ia = kage.kWidth;\r
 670           ib = 0;\r
 671         }\r
 672         else{\r
 673           ia = 0;\r
 674           ib = kage.kWidth;\r
 675         }\r
 676       }\r
 677       \r
 678       //reverse if vector is going 2nd/3rd quadrants\r
 679       if(ix <= 0){\r
 680         ia = ia * -1;\r
 681         ib = ib * -1;\r
 682       }\r
 683       \r
 684       //save to polygon\r
 685       poly.push(x - ia, y - ib);\r
 686       poly2.push(x + ia, y + ib);\r
 687     }\r
 688     \r
 689     poly2.reverse();\r
 690     poly.concat(poly2);\r
 691     polygons.push(poly);\r
 692   }\r
 693 }\r
 694 \r
 695 function cdDrawBezier(kage, polygons, x1, y1, x2, y2, x3, y3, x4, y4, a1, a2){\r
 696   cdDrawCurveU(kage, polygons, x1, y1, x2, y2, x3, y3, x4, y4, a1, a2);\r
 697 }\r
 698 \r
 699 function cdDrawCurve(kage, polygons, x1, y1, x2, y2, x3, y3, a1, a2){\r
 700   cdDrawCurveU(kage, polygons, x1, y1, x2, y2, x2, y2, x3, y3, a1, a2);\r
 701 }\r
 702 \r
 703 function cdDrawLine(kage, polygons, tx1, ty1, tx2, ty2, ta1, ta2){\r
 704   var rad;\r
 705   var v, x1, y1, x2, y2;\r
 706   var a1, a2, opt1, opt2;\r
 707   var XX, XY, YX, YY;\r
 708   var poly;\r
 709   \r
 710   if(kage.kShotai == kage.kMincho){ //mincho\r
 711     x1 = tx1;\r
 712     y1 = ty1;\r
 713     x2 = tx2;\r
 714     y2 = ty2;\r
 715     a1 = ta1 % 100;\r
 716     a2 = ta2 % 100;\r
 717     opt1 = Math.floor(ta1 / 100);\r
 718     opt2 = Math.floor(ta2 / 100);\r
 719     \r
 720     if(x1 == x2){ //if TATE stroke, use y-axis\r
 721       poly = new Polygon(4);\r
 722       switch(a1){\r
 723       case 0:\r
 724         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY / 2);\r
 725         poly.set(0, x1 + kage.kMinWidthT, y1 + kage.kMinWidthY / 2);\r
 726         break;\r
 727       case 1:\r
 728       case 6: //... no need\r
 729       case 22:\r
 730         poly.set(3, x1 - kage.kMinWidthT, y1);\r
 731         poly.set(0, x1 + kage.kMinWidthT, y1);\r
 732         break;\r
 733       case 12:\r
 734         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY - kage.kMinWidthT);\r
 735         poly.set(0, x1 + kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 736         break;\r
 737       case 32:\r
 738         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 739         poly.set(0, x1 + kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 740         break;\r
 741       }\r
 742       \r
 743       switch(a2){\r
 744       case 0:\r
 745         if(a1 == 6){ //KAGI's tail ... no need\r
 746           poly.set(2, x2 - kage.kMinWidthT, y2);\r
 747           poly.set(1, x2 + kage.kMinWidthT, y2);\r
 748         }\r
 749         else{\r
 750           poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kMinWidthT / 2);\r
 751           poly.set(1, x2 + kage.kMinWidthT, y2 - kage.kMinWidthT / 2);\r
 752         }\r
 753         break;\r
 754       case 1:\r
 755         poly.set(2, x2 - kage.kMinWidthT, y2);\r
 756         poly.set(1, x2 + kage.kMinWidthT, y2);\r
 757         break;\r
 758       case 13:\r
 759         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kAdjustKakatoL[opt2] + kage.kMinWidthT);\r
 760         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kAdjustKakatoL[opt2]);\r
 761         break;\r
 762       case 23:\r
 763         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kAdjustKakatoR[opt2] + kage.kMinWidthT);\r
 764         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kAdjustKakatoR[opt2]);\r
 765         break;\r
 766       case 32:\r
 767         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kMinWidthY);\r
 768         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kMinWidthY);\r
 769         break;\r
 770       }\r
 771       \r
 772       polygons.push(poly);\r
 773       \r
 774       if(a1 == 22){ //box's right top corner\r
 775         poly = new Polygon();\r
 776         poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 777         poly.push(x1, y1 - kage.kMinWidthY - kage.kWidth);\r
 778         poly.push(x1 + kage.kMinWidthT + kage.kWidth, y1 + kage.kMinWidthY);\r
 779         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthT);\r
 780         poly.push(x1 - kage.kMinWidthT, y1);\r
 781         polygons.push(poly);\r
 782       }\r
 783       \r
 784       if(a1 == 0){ //beginning of the stroke\r
 785         poly = new Polygon();\r
 786         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthY * 0.5);\r
 787         poly.push(x1 + kage.kMinWidthT + kage.kMinWidthT * 0.5, y1 + kage.kMinWidthY * 0.5 + kage.kMinWidthY);\r
 788         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthY * 0.5 + kage.kMinWidthY * 2);\r
 789         polygons.push(poly);\r
 790       }\r
 791       \r
 792       if((a1 == 6 && a2 == 0) || a2 == 1){ //KAGI NO YOKO BOU NO SAIGO NO MARU ... no need only used at 1st=yoko\r
 793         poly = new Polygon();\r
 794         poly.push(x2 - kage.kMinWidthT, y2);\r
 795         poly.push(x2 - kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
 796         poly.push(x2, y2 + kage.kMinWidthT);\r
 797         poly.push(x2 + kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
 798         poly.push(x2 + kage.kMinWidthT, y2);\r
 799         poly.reverse(); // for fill-rule\r
 800         polygons.push(poly);\r
 801       }\r
 802     }\r
 803     else if(y1 == y2){ //if it is YOKO stroke, use x-axis\r
 804       if(a1 == 6){ //if it is KAGI's YOKO stroke, get bold\r
 805         poly = new Polygon();\r
 806         poly.push(x1, y1 - kage.kMinWidthT);\r
 807         poly.push(x2, y2 - kage.kMinWidthT);\r
 808         poly.push(x2, y2 + kage.kMinWidthT);\r
 809         poly.push(x1, y1 + kage.kMinWidthT);\r
 810         polygons.push(poly);\r
 811         \r
 812         if(a2 == 1 || a2 == 0 || a2 == 5){ // no need a2=1\r
 813           //KAGI NO YOKO BOU NO SAIGO NO MARU\r
 814           poly = new Polygon();\r
 815           poly.push(x2, y2 - kage.kMinWidthT);\r
 816           poly.push(x2 + kage.kMinWidthT * 0.6, y2 - kage.kMinWidthT * 0.6);\r
 817           poly.push(x2 + kage.kMinWidthT, y2);\r
 818           poly.push(x2 + kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
 819           poly.push(x2, y2 + kage.kMinWidthT);\r
 820           polygons.push(poly);\r
 821         }\r
 822         \r
 823         if(a2 == 5){\r
 824           //KAGI NO YOKO BOU NO HANE\r
 825           poly = new Polygon();\r
 826           poly.push(x2, y2 - kage.kMinWidthT + 1);\r
 827           poly.push(x2 + 2, y2 - kage.kMinWidthT - kage.kWidth * 5);\r
 828           poly.push(x2, y2 - kage.kMinWidthT - kage.kWidth * 5);\r
 829           poly.push(x2 - kage.kMinWidthT, y2 - kage.kMinWidthT + 1);\r
 830           poly.reverse(); // for fill-rule\r
 831           polygons.push(poly);\r
 832         }\r
 833       }\r
 834       else{\r
 835         //always same\r
 836         poly = new Polygon(4);\r
 837         poly.set(0, x1, y1 - kage.kMinWidthY);\r
 838         poly.set(1, x2, y2 - kage.kMinWidthY);\r
 839         poly.set(2, x2, y2 + kage.kMinWidthY);\r
 840         poly.set(3, x1, y1 + kage.kMinWidthY);\r
 841         polygons.push(poly);\r
 842         \r
 843         //UROKO\r
 844         if(a2 == 0){\r
 845           poly = new Polygon();\r
 846           poly.push(x2, y2 - kage.kMinWidthY);\r
 847           poly.push(x2 - kage.kAdjustUrokoX[opt2], y2);\r
 848           poly.push(x2 - kage.kAdjustUrokoX[opt2] / 2, y2 - kage.kAdjustUrokoY[opt2]);\r
 849           polygons.push(poly);\r
 850         }\r
 851       }\r
 852     }\r
 853     else{ //for others, use x-axis\r
 854       rad = Math.atan((y2 - y1) / (x2 - x1));\r
 855       if((Math.abs(y2 - y1) < Math.abs(x2 - x1)) && (a1 != 6) && (a2 != 6) && !(x1 > x2)){ //ASAI KAUDO\r
 856         //always same\r
 857         poly = new Polygon(4);\r
 858         poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthY, y1 - Math.cos(rad) * kage.kMinWidthY);\r
 859         poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthY, y2 - Math.cos(rad) * kage.kMinWidthY);\r
 860         poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthY, y2 + Math.cos(rad) * kage.kMinWidthY);\r
 861         poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthY, y1 + Math.cos(rad) * kage.kMinWidthY);\r
 862         polygons.push(poly);\r
 863         \r
 864         //UROKO\r
 865         if(a2 == 0){\r
 866           poly = new Polygon();\r
 867           poly.push(x2 + Math.sin(rad) * kage.kMinWidthY, y2 - Math.cos(rad) * kage.kMinWidthY);\r
 868           poly.push(x2 - Math.cos(rad) * kage.kAdjustUrokoX[opt2], y2 - Math.sin(rad) * kage.kAdjustUrokoX[opt2]);\r
 869           poly.push(x2 - Math.cos(rad) * kage.kAdjustUrokoX[opt2] / 2 + Math.sin(rad) * kage.kAdjustUrokoX[opt2] / 2, y2 - Math.sin(rad) * kage.kAdjustUrokoY[opt2] - Math.cos(rad) * kage.kAdjustUrokoY[opt2]);\r
 870           polygons.push(poly);\r
 871         }\r
 872       }\r
 873       \r
 874       else{ //KAKUDO GA FUKAI or KAGI NO YOKO BOU\r
 875         if(x1 > x2){ v = -1; } else{ v = 1; }\r
 876         poly = new Polygon(4);\r
 877         switch(a1){\r
 878         case 0:\r
 879           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.cos(rad) * 0.5 * v,\r
 880                    y1 - Math.cos(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.sin(rad) * 0.5 * v);\r
 881           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.cos(rad) * 0.5 * v,\r
 882                    y1 + Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.sin(rad) * 0.5 * v);\r
 883           break;\r
 884         case 1:\r
 885         case 6:\r
 886         case 22:\r
 887           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthT * v, y1 - Math.cos(rad) * kage.kMinWidthT * v);\r
 888           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthT * v, y1 + Math.cos(rad) * kage.kMinWidthT * v);\r
 889           break;\r
 890         case 12:\r
 891           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.cos(rad) * v,\r
 892                    y1 - Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.sin(rad) * v);\r
 893           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthT * v - (kage.kMinWidthT + kage.kMinWidthY) * Math.cos(rad) * v,\r
 894                    y1 + Math.cos(rad) * kage.kMinWidthT * v - (kage.kMinWidthT + kage.kMinWidthY) * Math.sin(rad) * v);\r
 895           break;\r
 896         case 32:\r
 897           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.cos(rad) * v,\r
 898                    y1 - Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.sin(rad) * v);\r
 899           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.cos(rad) * v,\r
 900                    y1 + Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.sin(rad) * v);\r
 901           break;\r
 902         }\r
 903         \r
 904         switch(a2){\r
 905         case 0:\r
 906           if(a1 == 6){\r
 907             poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v, y2 - Math.cos(rad) * kage.kMinWidthT * v);\r
 908             poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v, y2 + Math.cos(rad) * kage.kMinWidthT * v);\r
 909           }\r
 910           else{\r
 911             poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthT * 0.5 * Math.cos(rad) * v,\r
 912                      y2 - Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthT * 0.5 * Math.sin(rad) * v);\r
 913             poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v + kage.kMinWidthT * 0.5 * Math.cos(rad) * v,\r
 914                      y2 + Math.cos(rad) * kage.kMinWidthT * v + kage.kMinWidthT * 0.5 * Math.sin(rad) * v);\r
 915           }\r
 916           break;\r
 917         case 1: // is needed?\r
 918         case 5:\r
 919           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v, y2 - Math.cos(rad) * kage.kMinWidthT * v);\r
 920           poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v, y2 + Math.cos(rad) * kage.kMinWidthT * v);\r
 921           break;\r
 922         case 13:\r
 923           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v + kage.kAdjustKakatoL[opt2] * Math.cos(rad) * v,\r
 924                    y2 - Math.cos(rad) * kage.kMinWidthT * v + kage.kAdjustKakatoL[opt2] * Math.sin(rad) * v);\r
 925           poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v + (kage.kAdjustKakatoL[opt2] + kage.kMinWidthT) * Math.cos(rad) * v,\r
 926                    y2 + Math.cos(rad) * kage.kMinWidthT * v + (kage.kAdjustKakatoL[opt2] + kage.kMinWidthT) * Math.sin(rad) * v);\r
 927           break;\r
 928         case 23:\r
 929           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v + kage.kAdjustKakatoR[opt2] * Math.cos(rad) * v,\r
 930                    y2 - Math.cos(rad) * kage.kMinWidthT * v + kage.kAdjustKakatoR[opt2] * Math.sin(rad) * v);\r
 931           poly.set(2,\r
 932                    x2 - Math.sin(rad) * kage.kMinWidthT * v + (kage.kAdjustKakatoR[opt2] + kage.kMinWidthT) * Math.cos(rad) * v,\r
 933                    y2 + Math.cos(rad) * kage.kMinWidthT * v + (kage.kAdjustKakatoR[opt2] + kage.kMinWidthT) * Math.sin(rad) * v);\r
 934           break;\r
 935         case 32:\r
 936           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.cos(rad) * v,\r
 937                    y2 - Math.cos(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.sin(rad) * v);\r
 938           poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.cos(rad) * v,\r
 939                    y2 + Math.cos(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.sin(rad) * v);\r
 940           break;\r
 941         }\r
 942         \r
 943         polygons.push(poly);\r
 944         \r
 945         if((a1 == 6) && (a2 == 0 || a2 == 5)){ //KAGI NO YOKO BOU NO SAIGO NO MARU\r
 946           poly = new Polygon();\r
 947           poly.push(x2 + Math.sin(rad) * kage.kMinWidthT * v, y2 - Math.cos(rad) * kage.kMinWidthT * v);\r
 948           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * 0.8 * v + Math.sin(rad) * kage.kMinWidthT * 0.6 * v,\r
 949                     y2 + Math.sin(rad) * kage.kMinWidthT * 0.8 * v - Math.cos(rad) * kage.kMinWidthT * 0.6 * v);\r
 950           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * v, y2 + Math.sin(rad) * kage.kMinWidthT * v);\r
 951           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * 0.8 * v - Math.sin(rad) * kage.kMinWidthT * 0.6 * v,\r
 952                     y2 + Math.sin(rad) * kage.kMinWidthT * 0.8 * v + Math.cos(rad) * kage.kMinWidthT * 0.6 * v);\r
 953           poly.push(x2 - Math.sin(rad) * kage.kMinWidthT * v, y2 + Math.cos(rad) * kage.kMinWidthT * v);\r
 954           polygons.push(poly);\r
 955         }\r
 956         \r
 957         if(a1 == 6 && a2 == 5){\r
 958           //KAGI NO YOKO BOU NO HANE\r
 959           poly = new Polygon();\r
 960           poly.push(x2 + (kage.kMinWidthT - 1) * Math.sin(rad) * v, y2 - (kage.kMinWidthT - 1) * Math.cos(rad) * v);\r
 961           poly.push(x2 + 2 * Math.cos(rad) * v + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
 962                     y2 + 2 * Math.sin(rad) * v - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
 963           poly.push(x2 + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
 964                     y2 - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
 965           poly.push(x2 + (kage.kMinWidthT - 1) * Math.sin(rad) * v - kage.kMinWidthT * Math.cos(rad) * v,\r
 966                     y2 - (kage.kMinWidthT - 1) * Math.cos(rad) * v - kage.kMinWidthT * Math.sin(rad) * v);\r
 967           polygons.push(poly);\r
 968         }\r
 969         \r
 970         if(a1 == 22){ //SHIKAKU MIGIUE UROKO NANAME DEMO MASSUGU MUKI\r
 971           poly = new Polygon();\r
 972           poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 973           poly.push(x1, y1 - kage.kMinWidthY - kage.kWidth);\r
 974           poly.push(x1 + kage.kMinWidthT + kage.kWidth, y1 + kage.kMinWidthY);\r
 975           poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthT);\r
 976           poly.push(x1 - kage.kMinWidthT, y1);\r
 977           polygons.push(poly);\r
 978         }\r
 979         \r
 980         XX = Math.sin(rad) * v;\r
 981         XY = Math.cos(rad) * v * -1;\r
 982         YX = Math.cos(rad) * v;\r
 983         YY = Math.sin(rad) * v;\r
 984         \r
 985         if(a1 == 0){ //beginning of the storke\r
 986           poly = new Polygon();\r
 987           poly.push(x1 + kage.kMinWidthT * XX + (kage.kMinWidthY * 0.5) * YX,\r
 988                     y1 + kage.kMinWidthT * XY + (kage.kMinWidthY * 0.5) * YY);\r
 989           poly.push(x1 + (kage.kMinWidthT + kage.kMinWidthT * 0.5) * XX + (kage.kMinWidthY * 0.5 + kage.kMinWidthY) * YX,\r
 990                     y1 + (kage.kMinWidthT + kage.kMinWidthT * 0.5) * XY + (kage.kMinWidthY * 0.5 + kage.kMinWidthY) * YY);\r
 991           poly.push(x1 + kage.kMinWidthT * XX + (kage.kMinWidthY * 0.5 + kage.kMinWidthY * 2) * YX,\r
 992                     y1 + kage.kMinWidthT * XY + (kage.kMinWidthY * 0.5 + kage.kMinWidthY * 2) * YY);\r
 993           polygons.push(poly);\r
 994         }\r
 995       }\r
 996     }\r
 997   }\r
 998   else{ //gothic\r
 999     if(tx1 == tx2){ //if TATE stroke, use y-axis\r
1000       if(ty1 > ty2){\r
1001         x1 = tx2;\r
1002         y1 = ty2;\r
1003         x2 = tx1;\r
1004         y2 = ty1;\r
1005         a1 = ta2;\r
1006         a2 = ta1;\r
1007       }\r
1008       else{\r
1009         x1 = tx1;\r
1010         y1 = ty1;\r
1011         x2 = tx2;\r
1012         y2 = ty2;\r
1013         a1 = ta1;\r
1014         a2 = ta2;\r
1015       }\r
1016       \r
1017       if(a1 % 10 == 2){ y1 = y1 - kage.kWidth; }\r
1018       if(a2 % 10 == 2){ y2 = y2 + kage.kWidth; }\r
1019       if(a1 % 10 == 3){ y1 = y1 - kage.kWidth * kage.kKakato; }\r
1020       if(a2 % 10 == 3){ y2 = y2 + kage.kWidth * kage.kKakato; }\r
1021       \r
1022       poly = new Polygon();\r
1023       poly.push(x1 - kage.kWidth, y1);\r
1024       poly.push(x2 - kage.kWidth, y2);\r
1025       poly.push(x2 + kage.kWidth, y2);\r
1026       poly.push(x1 + kage.kWidth, y1);\r
1027       poly.reverse(); // for fill-rule\r
1028       \r
1029       polygons.push(poly);\r
1030     }\r
1031     else if(ty1 == ty2){ //if YOKO stroke, use x-axis\r
1032       if(tx1 > tx2){\r
1033         x1 = tx2;\r
1034         y1 = ty2;\r
1035         x2 = tx1;\r
1036         y2 = ty1;\r
1037         a1 = ta2;\r
1038         a2 = ta1;\r
1039       }\r
1040       else{\r
1041         x1 = tx1;\r
1042         y1 = ty1;\r
1043         x2 = tx2;\r
1044         y2 = ty2;\r
1045         a1 = ta1;\r
1046         a2 = ta2;\r
1047       }\r
1048       if(a1 % 10 == 2){ x1 = x1 - kage.kWidth; }\r
1049       if(a2 % 10 == 2){ x2 = x2 + kage.kWidth; }\r
1050       if(a1 % 10 == 3){ x1 = x1 - kage.kWidth * kage.kKakato; }\r
1051       if(a2 % 10 == 3){ x2 = x2 + kage.kWidth * kage.kKakato; }\r
1052       \r
1053       poly = new Polygon();\r
1054       poly.push(x1, y1 - kage.kWidth);\r
1055       poly.push(x2, y2 - kage.kWidth);\r
1056       poly.push(x2, y2 + kage.kWidth);\r
1057       poly.push(x1, y1 + kage.kWidth);\r
1058       \r
1059       polygons.push(poly);\r
1060     }\r
1061     else{ //for others, use x-axis\r
1062       if(tx1 > tx2){\r
1063         x1 = tx2;\r
1064         y1 = ty2;\r
1065         x2 = tx1;\r
1066         y2 = ty1;\r
1067         a1 = ta2;\r
1068         a2 = ta1;\r
1069       }\r
1070       else{\r
1071         x1 = tx1;\r
1072         y1 = ty1;\r
1073         x2 = tx2;\r
1074         y2 = ty2;\r
1075         a1 = ta1;\r
1076         a2 = ta2;\r
1077       }\r
1078       rad = Math.atan((y2 - y1) / (x2 - x1));\r
1079       if(a1 % 10 == 2){\r
1080         x1 = x1 - kage.kWidth * Math.cos(rad);\r
1081         y1 = y1 - kage.kWidth * Math.sin(rad);\r
1082       }\r
1083       if(a2 % 10 == 2){\r
1084         x2 = x2 + kage.kWidth * Math.cos(rad);\r
1085         y2 = y2 + kage.kWidth * Math.sin(rad);\r
1086       }\r
1087       if(a1 % 10 == 3){\r
1088         x1 = x1 - kage.kWidth * Math.cos(rad) * kage.kKakato;\r
1089         y1 = y1 - kage.kWidth * Math.sin(rad) * kage.kKakato;\r
1090       }\r
1091       if(a2 % 10 == 3){\r
1092         x2 = x2 + kage.kWidth * Math.cos(rad) * kage.kKakato;\r
1093         y2 = y2 + kage.kWidth * Math.sin(rad) * kage.kKakato;\r
1094       }\r
1095       \r
1096       //SUICHOKU NO ICHI ZURASHI HA Math.sin TO Math.cos NO IREKAE + x-axis MAINASU KA\r
1097       poly = new Polygon();\r
1098       poly.push(x1 + Math.sin(rad) * kage.kWidth, y1 - Math.cos(rad) * kage.kWidth);\r
1099       poly.push(x2 + Math.sin(rad) * kage.kWidth, y2 - Math.cos(rad) * kage.kWidth);\r
1100       poly.push(x2 - Math.sin(rad) * kage.kWidth, y2 + Math.cos(rad) * kage.kWidth);\r
1101       poly.push(x1 - Math.sin(rad) * kage.kWidth, y1 + Math.cos(rad) * kage.kWidth);\r
1102       \r
1103       polygons.push(poly);\r
1104     }\r
1105   }\r
1106 }\r