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