engine/kagecd.js

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