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       var type = (Math.atan2(Math.abs(y3 - y2), Math.abs(x3 - x2)) / Math.PI * 2 - 0.6);\r
 802       if(type > 0){\r
 803         type = type * 8;\r
 804       } else {\r
 805         type = type * 3;\r
 806       }\r
 807       var pm;\r
 808       if(type < 0){\r
 809         pm = -1;\r
 810       } else {\r
 811         pm = 1;\r
 812       }\r
 813       if(y2 == y3){\r
 814         poly = new Polygon();\r
 815         poly.push(x3, y3 + kage.kMinWidthT * kage.kL2RDfatten);\r
 816         poly.push(x3, y3 - kage.kMinWidthT * kage.kL2RDfatten);\r
 817         poly.push(x3 + kage.kMinWidthT * kage.kL2RDfatten * Math.abs(type), y3 + kage.kMinWidthT * kage.kL2RDfatten * pm);\r
 818         polygons.push(poly);\r
 819       }\r
 820       else{\r
 821         poly = new Polygon();\r
 822         poly.push(x3 + kage.kMinWidthT * kage.kL2RDfatten * YX, y3 + kage.kMinWidthT * kage.kL2RDfatten * YY);\r
 823         poly.push(x3 - kage.kMinWidthT * kage.kL2RDfatten * YX, y3 - kage.kMinWidthT * kage.kL2RDfatten * YY);\r
 824         poly.push(x3 + kage.kMinWidthT * kage.kL2RDfatten * Math.abs(type) * XX + kage.kMinWidthT * kage.kL2RDfatten * pm * YX,\r
 825                   y3 + kage.kMinWidthT * kage.kL2RDfatten * Math.abs(type) * XY + kage.kMinWidthT * kage.kL2RDfatten * pm * YY);\r
 826         polygons.push(poly);\r
 827       }\r
 828     }\r
 829     \r
 830     if(a2 == 15){ //jump up ... it can change 15->5\r
 831       if(y2 == y3){\r
 832         poly = new Polygon();\r
 833         poly.push(x3, y3 - kage.kMinWidthT + 1);\r
 834         poly.push(x3 + 2, y3 - kage.kMinWidthT - kage.kWidth * 5);\r
 835         poly.push(x3, y3 - kage.kMinWidthT - kage.kWidth * 5);\r
 836         poly.push(x3 - kage.kMinWidthT, y3 - kage.kMinWidthT + 1);\r
 837         polygons.push(poly);\r
 838       }\r
 839       else{\r
 840         poly = new Polygon();\r
 841         poly.push(x3 + (kage.kMinWidthT - 1) * Math.sin(rad) * v, y3 - (kage.kMinWidthT - 1) * Math.cos(rad) * v);\r
 842         poly.push(x3 + 2 * Math.cos(rad) * v + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
 843                   y3 + 2 * Math.sin(rad) * v - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
 844         poly.push(x3 + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
 845                   y3 - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
 846         poly.push(x3 + (kage.kMinWidthT - 1) * Math.sin(rad) * v - kage.kMinWidthT * Math.cos(rad) * v,\r
 847                   y3 - (kage.kMinWidthT - 1) * Math.cos(rad) * v - kage.kMinWidthT * Math.sin(rad) * v);\r
 848         polygons.push(poly);\r
 849       }\r
 850     }\r
 851     \r
 852     if(a2 == 14){ //jump to left, allways go left ... it can change 14->4\r
 853       poly = new Polygon();\r
 854       poly.push(x3, y3);\r
 855       poly.push(x3, y3 - kage.kMinWidthT);\r
 856       poly.push(x3 - kage.kWidth * 4, y3 - kage.kMinWidthT);\r
 857       poly.push(x3 - kage.kWidth * 4, y3 - kage.kMinWidthT * 0.5);\r
 858       polygons.push(poly);\r
 859     }\r
 860   }\r
 861   else{ //gothic\r
 862     if(a1 % 10 == 2){\r
 863       if(x1 == x2){\r
 864         if(y1 < y2){ y1 = y1 - kage.kWidth; } else{ y1 = y1 + kage.kWidth; }\r
 865       }\r
 866       else if(y1 == y2){\r
 867         if(x1 < x2){ x1 = x1 - kage.kWidth; } else{ x1 = x1 + kage.kWidth; }\r
 868       }\r
 869       else{\r
 870         rad = Math.atan((y2 - y1) / (x2 - x1));\r
 871         if(x1 < x2){ v = 1; } else{ v = -1; }\r
 872         x1 = x1 - kage.kWidth * Math.cos(rad) * v;\r
 873         y1 = y1 - kage.kWidth * Math.sin(rad) * v;\r
 874       }\r
 875     }\r
 876     \r
 877     if(a1 % 10 == 3){\r
 878       if(x1 == x2){\r
 879         if(y1 < y2){\r
 880           y1 = y1 - kage.kWidth * kage.kKakato;\r
 881         }\r
 882         else{\r
 883           y1 = y1 + kage.kWidth * kage.kKakato;\r
 884         }\r
 885       }\r
 886       else if(y1 == y2){\r
 887         if(x1 < x2){\r
 888           x1 = x1 - kage.kWidth * kage.kKakato;\r
 889         }\r
 890         else{\r
 891           x1 = x1 + kage.kWidth * kage.kKakato;\r
 892         }\r
 893       }\r
 894       else{\r
 895         rad = Math.atan((y2 - y1) / (x2 - x1));\r
 896         if(x1 < x2){ v = 1; } else{ v = -1; }\r
 897         x1 = x1 - kage.kWidth * Math.cos(rad) * v * kage.kKakato;\r
 898         y1 = y1 - kage.kWidth * Math.sin(rad) * v * kage.kKakato;\r
 899       }\r
 900     }\r
 901     if(a2 % 10 == 2){\r
 902       if(x2 == x3){\r
 903         if(y2 < y3){ y3 = y3 + kage.kWidth; } else{ y3 = y3 - kage.kWidth; }\r
 904       }\r
 905       else if(y2 == y3){\r
 906         if(x2 < x3){ x3 = x3 + kage.kWidth; } else{ x3 = x3 - kage.kWidth; }\r
 907       }\r
 908       else{\r
 909         rad = Math.atan((y3 - y2) / (x3 - x2));\r
 910         if(x2 < x3){ v = 1; } else{ v = -1; }\r
 911         x3 = x3 + kage.kWidth * Math.cos(rad) * v;\r
 912         y3 = y3 + kage.kWidth * Math.sin(rad) * v;\r
 913       }\r
 914     }\r
 915     \r
 916     if(a2 % 10 == 3){\r
 917       if(x2 == x3){\r
 918         if(y2 < y3){\r
 919           y3 = y3 + kage.kWidth * kage.kKakato;\r
 920         }\r
 921         else{\r
 922           y3 = y3 - kage.kWidth * kage.kKakato;\r
 923         }\r
 924       }\r
 925       else if(y2 == y3){\r
 926         if(x2 < x3){\r
 927           x3 = x3 + kage.kWidth * kage.kKakato;\r
 928         }\r
 929         else{\r
 930           x3 = x3 - kage.kWidth * kage.kKakato;\r
 931         }\r
 932       }\r
 933       else{\r
 934         rad = Math.atan((y3 - y2) / (x3 - x2));\r
 935         if(x2 < x3){ v = 1; } else{ v = -1; }\r
 936         x3 = x3 + kage.kWidth * Math.cos(rad) * v * kage.kKakato;\r
 937         y3 = y3 + kage.kWidth * Math.sin(rad) * v * kage.kKakato;\r
 938       }\r
 939     }\r
 940     \r
 941     poly = new Polygon();\r
 942     poly2 = new Polygon();\r
 943     \r
 944     for(tt = 0; tt <= 1000; tt = tt + kage.kRate){\r
 945       t = tt / 1000;\r
 946       \r
 947       //calculating each point\r
 948       x = ((1.0 - t) * (1.0 - t) * x1 + 2.0 * t * (1.0 - t) * x2 + t * t * x3);\r
 949       y = ((1.0 - t) * (1.0 - t) * y1 + 2.0 * t * (1.0 - t) * y2 + t * t * y3);\r
 950       \r
 951       //SESSEN NO KATAMUKI NO KEISAN(BIBUN)\r
 952       ix = (x1 - 2.0 * x2 + x3) * 2.0 * t + (-2.0 * x1 + 2.0 * x2);\r
 953       iy = (y1 - 2.0 * y2 + y3) * 2.0 * t + (-2.0 * y1 + 2.0 * y2);\r
 954       \r
 955       //SESSEN NI SUICHOKU NA CHOKUSEN NO KEISAN\r
 956       if(kage.kShotai == kage.kMincho){ //always false ?\r
 957         if(ix != 0 && iy != 0){\r
 958           ir = Math.atan(iy / ix * -1.0);\r
 959           ia = Math.sin(ir) * kage.kMinWidthT;\r
 960           ib = Math.cos(ir) * kage.kMinWidthT;\r
 961         }\r
 962         else if(ix == 0){\r
 963           ia = kage.kMinWidthT;\r
 964           ib = 0;\r
 965         }\r
 966         else{\r
 967           ia = 0;\r
 968           ib = kage.kMinWidthT;\r
 969         }\r
 970         ia = ia * Math.sqrt(1.0 - t);\r
 971         ib = ib * Math.sqrt(1.0 - t);\r
 972       }\r
 973       else{\r
 974         if(ix != 0 && iy != 0){\r
 975           ir = Math.atan(iy / ix * -1.0);\r
 976           ia = Math.sin(ir) * kage.kWidth;\r
 977           ib = Math.cos(ir) * kage.kWidth;\r
 978         }\r
 979         else if(ix == 0){\r
 980           ia = kage.kWidth;\r
 981           ib = 0;\r
 982         }\r
 983         else{\r
 984           ia = 0;\r
 985           ib = kage.kWidth;\r
 986         }\r
 987       }\r
 988       \r
 989       //reverse if vector is going 2nd/3rd quadrants\r
 990       if(ix <= 0){\r
 991         ia = ia * -1;\r
 992         ib = ib * -1;\r
 993       }\r
 994       \r
 995       //save to polygon\r
 996       poly.push(x - ia, y - ib);\r
 997       poly2.push(x + ia, y + ib);\r
 998     }\r
 999     \r
1000     poly2.reverse();\r
1001     poly.concat(poly2);\r
1002     polygons.push(poly);\r
1003   }\r
1004 }\r
1005 \r
1006 function cdDrawLine(kage, polygons, tx1, ty1, tx2, ty2, ta1, ta2){\r
1007   var rad;\r
1008   var v, x1, y1, x2, y2;\r
1009   var a1, a2, opt1, opt2;\r
1010   var XX, XY, YX, YY;\r
1011   var poly;\r
1012   \r
1013   if(kage.kShotai == kage.kMincho){ //mincho\r
1014     x1 = tx1;\r
1015     y1 = ty1;\r
1016     x2 = tx2;\r
1017     y2 = ty2;\r
1018     a1 = ta1 % 100;\r
1019     a2 = ta2 % 100;\r
1020     opt1 = Math.floor(ta1 / 100);\r
1021     opt2 = Math.floor(ta2 / 100);\r
1022     \r
1023     if(x1 == x2){ //if TATE stroke, use y-axis\r
1024       poly = new Polygon(4);\r
1025       switch(a1){\r
1026       case 0:\r
1027         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY / 2);\r
1028         poly.set(0, x1 + kage.kMinWidthT, y1 + kage.kMinWidthY / 2);\r
1029         break;\r
1030       case 1:\r
1031       case 6: //... no need\r
1032       case 22:\r
1033         poly.set(3, x1 - kage.kMinWidthT, y1);\r
1034         poly.set(0, x1 + kage.kMinWidthT, y1);\r
1035         break;\r
1036       case 12:\r
1037         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY - kage.kMinWidthT);\r
1038         poly.set(0, x1 + kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1039         break;\r
1040       case 32:\r
1041         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1042         poly.set(0, x1 + kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1043         break;\r
1044       }\r
1045       \r
1046       switch(a2){\r
1047       case 0:\r
1048         if(a1 == 6){ //KAGI's tail ... no need\r
1049           poly.set(2, x2 - kage.kMinWidthT, y2);\r
1050           poly.set(1, x2 + kage.kMinWidthT, y2);\r
1051         }\r
1052         else{\r
1053           poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kMinWidthT / 2);\r
1054           poly.set(1, x2 + kage.kMinWidthT, y2 - kage.kMinWidthT / 2);\r
1055         }\r
1056         break;\r
1057       case 1:\r
1058         poly.set(2, x2 - kage.kMinWidthT, y2);\r
1059         poly.set(1, x2 + kage.kMinWidthT, y2);\r
1060         break;\r
1061       case 13:\r
1062         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kAdjustKakatoL[opt2] + kage.kMinWidthT);\r
1063         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kAdjustKakatoL[opt2]);\r
1064         break;\r
1065       case 23:\r
1066         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kAdjustKakatoR[opt2] + kage.kMinWidthT);\r
1067         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kAdjustKakatoR[opt2]);\r
1068         break;\r
1069       case 32:\r
1070         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kMinWidthY);\r
1071         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kMinWidthY);\r
1072         break;\r
1073       }\r
1074       \r
1075       polygons.push(poly);\r
1076       \r
1077       if(a1 == 22){ //box's right top corner\r
1078         poly = new Polygon();\r
1079         poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1080         poly.push(x1, y1 - kage.kMinWidthY - kage.kWidth);\r
1081         poly.push(x1 + kage.kMinWidthT + kage.kWidth, y1 + kage.kMinWidthY);\r
1082         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthT);\r
1083         poly.push(x1 - kage.kMinWidthT, y1);\r
1084         polygons.push(poly);\r
1085       }\r
1086       \r
1087       if(a1 == 0){ //beginning of the stroke\r
1088         poly = new Polygon();\r
1089         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthY * 0.5);\r
1090         poly.push(x1 + kage.kMinWidthT + kage.kMinWidthT * 0.5, y1 + kage.kMinWidthY * 0.5 + kage.kMinWidthY);\r
1091         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthY * 0.5 + kage.kMinWidthY * 2);\r
1092         polygons.push(poly);\r
1093       }\r
1094       \r
1095       if((a1 == 6 && a2 == 0) || a2 == 1){ //KAGI NO YOKO BOU NO SAIGO NO MARU ... no need only used at 1st=yoko\r
1096         poly = new Polygon();\r
1097         poly.push(x2 - kage.kMinWidthT, y2);\r
1098         poly.push(x2 - kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
1099         poly.push(x2, y2 + kage.kMinWidthT);\r
1100         poly.push(x2 + kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
1101         poly.push(x2 + kage.kMinWidthT, y2);\r
1102         poly.reverse(); // for fill-rule\r
1103         polygons.push(poly);\r
1104       }\r
1105     }\r
1106     else if(y1 == y2){ //if it is YOKO stroke, use x-axis\r
1107       if(a1 == 6){ //if it is KAGI's YOKO stroke, get bold\r
1108         poly = new Polygon();\r
1109         poly.push(x1, y1 - kage.kMinWidthT);\r
1110         poly.push(x2, y2 - kage.kMinWidthT);\r
1111         poly.push(x2, y2 + kage.kMinWidthT);\r
1112         poly.push(x1, y1 + kage.kMinWidthT);\r
1113         polygons.push(poly);\r
1114         \r
1115         if(a2 == 1 || a2 == 0 || a2 == 5){ // no need a2=1\r
1116           //KAGI NO YOKO BOU NO SAIGO NO MARU\r
1117           poly = new Polygon();\r
1118           poly.push(x2, y2 - kage.kMinWidthT);\r
1119           poly.push(x2 + kage.kMinWidthT * 0.6, y2 - kage.kMinWidthT * 0.6);\r
1120           poly.push(x2 + kage.kMinWidthT, y2);\r
1121           poly.push(x2 + kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
1122           poly.push(x2, y2 + kage.kMinWidthT);\r
1123           polygons.push(poly);\r
1124         }\r
1125         \r
1126         if(a2 == 5){\r
1127           //KAGI NO YOKO BOU NO HANE\r
1128           poly = new Polygon();\r
1129           poly.push(x2, y2 - kage.kMinWidthT + 1);\r
1130           poly.push(x2 + 2, y2 - kage.kMinWidthT - kage.kWidth * 5);\r
1131           poly.push(x2, y2 - kage.kMinWidthT - kage.kWidth * 5);\r
1132           poly.push(x2 - kage.kMinWidthT, y2 - kage.kMinWidthT + 1);\r
1133           poly.reverse(); // for fill-rule\r
1134           polygons.push(poly);\r
1135         }\r
1136       }\r
1137       else{\r
1138         //always same\r
1139         poly = new Polygon(4);\r
1140         poly.set(0, x1, y1 - kage.kMinWidthY);\r
1141         poly.set(1, x2, y2 - kage.kMinWidthY);\r
1142         poly.set(2, x2, y2 + kage.kMinWidthY);\r
1143         poly.set(3, x1, y1 + kage.kMinWidthY);\r
1144         polygons.push(poly);\r
1145         \r
1146         //UROKO\r
1147         if(a2 == 0){\r
1148           poly = new Polygon();\r
1149           poly.push(x2, y2 - kage.kMinWidthY);\r
1150           poly.push(x2 - kage.kAdjustUrokoX[opt2], y2);\r
1151           poly.push(x2 - kage.kAdjustUrokoX[opt2] / 2, y2 - kage.kAdjustUrokoY[opt2]);\r
1152           polygons.push(poly);\r
1153         }\r
1154       }\r
1155     }\r
1156     else{ //for others, use x-axis\r
1157       rad = Math.atan((y2 - y1) / (x2 - x1));\r
1158       if((Math.abs(y2 - y1) < Math.abs(x2 - x1)) && (a1 != 6) && (a2 != 6) && !(x1 > x2)){ //ASAI KAUDO\r
1159         //always same\r
1160         poly = new Polygon(4);\r
1161         poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthY, y1 - Math.cos(rad) * kage.kMinWidthY);\r
1162         poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthY, y2 - Math.cos(rad) * kage.kMinWidthY);\r
1163         poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthY, y2 + Math.cos(rad) * kage.kMinWidthY);\r
1164         poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthY, y1 + Math.cos(rad) * kage.kMinWidthY);\r
1165         polygons.push(poly);\r
1166         \r
1167         //UROKO\r
1168         if(a2 == 0){\r
1169           poly = new Polygon();\r
1170           poly.push(x2 + Math.sin(rad) * kage.kMinWidthY, y2 - Math.cos(rad) * kage.kMinWidthY);\r
1171           poly.push(x2 - Math.cos(rad) * kage.kAdjustUrokoX[opt2], y2 - Math.sin(rad) * kage.kAdjustUrokoX[opt2]);\r
1172           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
1173           polygons.push(poly);\r
1174         }\r
1175       }\r
1176       \r
1177       else{ //KAKUDO GA FUKAI or KAGI NO YOKO BOU\r
1178         if(x1 > x2){ v = -1; } else{ v = 1; }\r
1179         poly = new Polygon(4);\r
1180         switch(a1){\r
1181         case 0:\r
1182           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.cos(rad) * 0.5 * v,\r
1183                    y1 - Math.cos(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.sin(rad) * 0.5 * v);\r
1184           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.cos(rad) * 0.5 * v,\r
1185                    y1 + Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.sin(rad) * 0.5 * v);\r
1186           break;\r
1187         case 1:\r
1188         case 6:\r
1189         case 22:\r
1190           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthT * v, y1 - Math.cos(rad) * kage.kMinWidthT * v);\r
1191           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthT * v, y1 + Math.cos(rad) * kage.kMinWidthT * v);\r
1192           break;\r
1193         case 12:\r
1194           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.cos(rad) * v,\r
1195                    y1 - Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.sin(rad) * v);\r
1196           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthT * v - (kage.kMinWidthT + kage.kMinWidthY) * Math.cos(rad) * v,\r
1197                    y1 + Math.cos(rad) * kage.kMinWidthT * v - (kage.kMinWidthT + kage.kMinWidthY) * Math.sin(rad) * v);\r
1198           break;\r
1199         case 32:\r
1200           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.cos(rad) * v,\r
1201                    y1 - Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.sin(rad) * v);\r
1202           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.cos(rad) * v,\r
1203                    y1 + Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthY * Math.sin(rad) * v);\r
1204           break;\r
1205         }\r
1206         \r
1207         switch(a2){\r
1208         case 0:\r
1209           if(a1 == 6){\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           }\r
1213           else{\r
1214             poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v - kage.kMinWidthT * 0.5 * Math.cos(rad) * v,\r
1215                      y2 - Math.cos(rad) * kage.kMinWidthT * v - kage.kMinWidthT * 0.5 * Math.sin(rad) * v);\r
1216             poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v + kage.kMinWidthT * 0.5 * Math.cos(rad) * v,\r
1217                      y2 + Math.cos(rad) * kage.kMinWidthT * v + kage.kMinWidthT * 0.5 * Math.sin(rad) * v);\r
1218           }\r
1219           break;\r
1220         case 1: // is needed?\r
1221         case 5:\r
1222           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v, y2 - Math.cos(rad) * kage.kMinWidthT * v);\r
1223           poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v, y2 + Math.cos(rad) * kage.kMinWidthT * v);\r
1224           break;\r
1225         case 13:\r
1226           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v + kage.kAdjustKakatoL[opt2] * Math.cos(rad) * v,\r
1227                    y2 - Math.cos(rad) * kage.kMinWidthT * v + kage.kAdjustKakatoL[opt2] * Math.sin(rad) * v);\r
1228           poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v + (kage.kAdjustKakatoL[opt2] + kage.kMinWidthT) * Math.cos(rad) * v,\r
1229                    y2 + Math.cos(rad) * kage.kMinWidthT * v + (kage.kAdjustKakatoL[opt2] + kage.kMinWidthT) * Math.sin(rad) * v);\r
1230           break;\r
1231         case 23:\r
1232           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v + kage.kAdjustKakatoR[opt2] * Math.cos(rad) * v,\r
1233                    y2 - Math.cos(rad) * kage.kMinWidthT * v + kage.kAdjustKakatoR[opt2] * Math.sin(rad) * v);\r
1234           poly.set(2,\r
1235                    x2 - Math.sin(rad) * kage.kMinWidthT * v + (kage.kAdjustKakatoR[opt2] + kage.kMinWidthT) * Math.cos(rad) * v,\r
1236                    y2 + Math.cos(rad) * kage.kMinWidthT * v + (kage.kAdjustKakatoR[opt2] + kage.kMinWidthT) * Math.sin(rad) * v);\r
1237           break;\r
1238         case 32:\r
1239           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.cos(rad) * v,\r
1240                    y2 - Math.cos(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.sin(rad) * v);\r
1241           poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.cos(rad) * v,\r
1242                    y2 + Math.cos(rad) * kage.kMinWidthT * v + kage.kMinWidthY * Math.sin(rad) * v);\r
1243           break;\r
1244         }\r
1245         \r
1246         polygons.push(poly);\r
1247         \r
1248         if((a1 == 6) && (a2 == 0 || a2 == 5)){ //KAGI NO YOKO BOU NO SAIGO NO MARU\r
1249           poly = new Polygon();\r
1250           poly.push(x2 + Math.sin(rad) * kage.kMinWidthT * v, y2 - Math.cos(rad) * kage.kMinWidthT * v);\r
1251           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * 0.8 * v + Math.sin(rad) * kage.kMinWidthT * 0.6 * v,\r
1252                     y2 + Math.sin(rad) * kage.kMinWidthT * 0.8 * v - Math.cos(rad) * kage.kMinWidthT * 0.6 * v);\r
1253           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * v, y2 + Math.sin(rad) * kage.kMinWidthT * v);\r
1254           poly.push(x2 + Math.cos(rad) * kage.kMinWidthT * 0.8 * v - Math.sin(rad) * kage.kMinWidthT * 0.6 * v,\r
1255                     y2 + Math.sin(rad) * kage.kMinWidthT * 0.8 * v + Math.cos(rad) * kage.kMinWidthT * 0.6 * v);\r
1256           poly.push(x2 - Math.sin(rad) * kage.kMinWidthT * v, y2 + Math.cos(rad) * kage.kMinWidthT * v);\r
1257           polygons.push(poly);\r
1258         }\r
1259         \r
1260         if(a1 == 6 && a2 == 5){\r
1261           //KAGI NO YOKO BOU NO HANE\r
1262           poly = new Polygon();\r
1263           poly.push(x2 + (kage.kMinWidthT - 1) * Math.sin(rad) * v, y2 - (kage.kMinWidthT - 1) * Math.cos(rad) * v);\r
1264           poly.push(x2 + 2 * Math.cos(rad) * v + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
1265                     y2 + 2 * Math.sin(rad) * v - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
1266           poly.push(x2 + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
1267                     y2 - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
1268           poly.push(x2 + (kage.kMinWidthT - 1) * Math.sin(rad) * v - kage.kMinWidthT * Math.cos(rad) * v,\r
1269                     y2 - (kage.kMinWidthT - 1) * Math.cos(rad) * v - kage.kMinWidthT * Math.sin(rad) * v);\r
1270           polygons.push(poly);\r
1271         }\r
1272         \r
1273         if(a1 == 22){ //SHIKAKU MIGIUE UROKO NANAME DEMO MASSUGU MUKI\r
1274           poly = new Polygon();\r
1275           poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1276           poly.push(x1, y1 - kage.kMinWidthY - kage.kWidth);\r
1277           poly.push(x1 + kage.kMinWidthT + kage.kWidth, y1 + kage.kMinWidthY);\r
1278           poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthT);\r
1279           poly.push(x1 - kage.kMinWidthT, y1);\r
1280           polygons.push(poly);\r
1281         }\r
1282         \r
1283         XX = Math.sin(rad) * v;\r
1284         XY = Math.cos(rad) * v * -1;\r
1285         YX = Math.cos(rad) * v;\r
1286         YY = Math.sin(rad) * v;\r
1287         \r
1288         if(a1 == 0){ //beginning of the storke\r
1289           poly = new Polygon();\r
1290           poly.push(x1 + kage.kMinWidthT * XX + (kage.kMinWidthY * 0.5) * YX,\r
1291                     y1 + kage.kMinWidthT * XY + (kage.kMinWidthY * 0.5) * YY);\r
1292           poly.push(x1 + (kage.kMinWidthT + kage.kMinWidthT * 0.5) * XX + (kage.kMinWidthY * 0.5 + kage.kMinWidthY) * YX,\r
1293                     y1 + (kage.kMinWidthT + kage.kMinWidthT * 0.5) * XY + (kage.kMinWidthY * 0.5 + kage.kMinWidthY) * YY);\r
1294           poly.push(x1 + kage.kMinWidthT * XX + (kage.kMinWidthY * 0.5 + kage.kMinWidthY * 2) * YX,\r
1295                     y1 + kage.kMinWidthT * XY + (kage.kMinWidthY * 0.5 + kage.kMinWidthY * 2) * YY);\r
1296           polygons.push(poly);\r
1297         }\r
1298       }\r
1299     }\r
1300   }\r
1301   else{ //gothic\r
1302     if(tx1 == tx2){ //if TATE stroke, use y-axis\r
1303       if(ty1 > ty2){\r
1304         x1 = tx2;\r
1305         y1 = ty2;\r
1306         x2 = tx1;\r
1307         y2 = ty1;\r
1308         a1 = ta2;\r
1309         a2 = ta1;\r
1310       }\r
1311       else{\r
1312         x1 = tx1;\r
1313         y1 = ty1;\r
1314         x2 = tx2;\r
1315         y2 = ty2;\r
1316         a1 = ta1;\r
1317         a2 = ta2;\r
1318       }\r
1319       \r
1320       if(a1 % 10 == 2){ y1 = y1 - kage.kWidth; }\r
1321       if(a2 % 10 == 2){ y2 = y2 + kage.kWidth; }\r
1322       if(a1 % 10 == 3){ y1 = y1 - kage.kWidth * kage.kKakato; }\r
1323       if(a2 % 10 == 3){ y2 = y2 + kage.kWidth * kage.kKakato; }\r
1324       \r
1325       poly = new Polygon();\r
1326       poly.push(x1 - kage.kWidth, y1);\r
1327       poly.push(x2 - kage.kWidth, y2);\r
1328       poly.push(x2 + kage.kWidth, y2);\r
1329       poly.push(x1 + kage.kWidth, y1);\r
1330       poly.reverse(); // for fill-rule\r
1331       \r
1332       polygons.push(poly);\r
1333     }\r
1334     else if(ty1 == ty2){ //if YOKO stroke, use x-axis\r
1335       if(tx1 > tx2){\r
1336         x1 = tx2;\r
1337         y1 = ty2;\r
1338         x2 = tx1;\r
1339         y2 = ty1;\r
1340         a1 = ta2;\r
1341         a2 = ta1;\r
1342       }\r
1343       else{\r
1344         x1 = tx1;\r
1345         y1 = ty1;\r
1346         x2 = tx2;\r
1347         y2 = ty2;\r
1348         a1 = ta1;\r
1349         a2 = ta2;\r
1350       }\r
1351       if(a1 % 10 == 2){ x1 = x1 - kage.kWidth; }\r
1352       if(a2 % 10 == 2){ x2 = x2 + kage.kWidth; }\r
1353       if(a1 % 10 == 3){ x1 = x1 - kage.kWidth * kage.kKakato; }\r
1354       if(a2 % 10 == 3){ x2 = x2 + kage.kWidth * kage.kKakato; }\r
1355       \r
1356       poly = new Polygon();\r
1357       poly.push(x1, y1 - kage.kWidth);\r
1358       poly.push(x2, y2 - kage.kWidth);\r
1359       poly.push(x2, y2 + kage.kWidth);\r
1360       poly.push(x1, y1 + kage.kWidth);\r
1361       \r
1362       polygons.push(poly);\r
1363     }\r
1364     else{ //for others, use x-axis\r
1365       if(tx1 > tx2){\r
1366         x1 = tx2;\r
1367         y1 = ty2;\r
1368         x2 = tx1;\r
1369         y2 = ty1;\r
1370         a1 = ta2;\r
1371         a2 = ta1;\r
1372       }\r
1373       else{\r
1374         x1 = tx1;\r
1375         y1 = ty1;\r
1376         x2 = tx2;\r
1377         y2 = ty2;\r
1378         a1 = ta1;\r
1379         a2 = ta2;\r
1380       }\r
1381       rad = Math.atan((y2 - y1) / (x2 - x1));\r
1382       if(a1 % 10 == 2){\r
1383         x1 = x1 - kage.kWidth * Math.cos(rad);\r
1384         y1 = y1 - kage.kWidth * Math.sin(rad);\r
1385       }\r
1386       if(a2 % 10 == 2){\r
1387         x2 = x2 + kage.kWidth * Math.cos(rad);\r
1388         y2 = y2 + kage.kWidth * Math.sin(rad);\r
1389       }\r
1390       if(a1 % 10 == 3){\r
1391         x1 = x1 - kage.kWidth * Math.cos(rad) * kage.kKakato;\r
1392         y1 = y1 - kage.kWidth * Math.sin(rad) * kage.kKakato;\r
1393       }\r
1394       if(a2 % 10 == 3){\r
1395         x2 = x2 + kage.kWidth * Math.cos(rad) * kage.kKakato;\r
1396         y2 = y2 + kage.kWidth * Math.sin(rad) * kage.kKakato;\r
1397       }\r
1398       \r
1399       //SUICHOKU NO ICHI ZURASHI HA Math.sin TO Math.cos NO IREKAE + x-axis MAINASU KA\r
1400       poly = new Polygon();\r
1401       poly.push(x1 + Math.sin(rad) * kage.kWidth, y1 - Math.cos(rad) * kage.kWidth);\r
1402       poly.push(x2 + Math.sin(rad) * kage.kWidth, y2 - Math.cos(rad) * kage.kWidth);\r
1403       poly.push(x2 - Math.sin(rad) * kage.kWidth, y2 + Math.cos(rad) * kage.kWidth);\r
1404       poly.push(x1 - Math.sin(rad) * kage.kWidth, y1 + Math.cos(rad) * kage.kWidth);\r
1405       \r
1406       polygons.push(poly);\r
1407     }\r
1408   }\r
1409 }\r