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){\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       delta = 0;\r
 505       break;\r
 506     case 12:\r
 507     case 32:\r
 508       delta = kage.kMinWidthY;\r
 509       break;\r
 510     default:\r
 511       break;\r
 512     }\r
 513     \r
 514     if(x1 == x2){\r
 515       if(y1 < y2){ y1 = y1 - delta; }\r
 516       else{ y1 = y1 + delta; }\r
 517     }\r
 518     else if(y1 == y2){\r
 519       if(x1 < x2){ x1 = x1 - delta; }\r
 520       else{ x1 = x1 + delta; }\r
 521     }\r
 522     else{\r
 523       rad = Math.atan((y2 - y1) / (x2 - x1));\r
 524       if(x1 < x2){ v = 1; } else{ v = -1; }\r
 525       x1 = x1 - delta * Math.cos(rad) * v;\r
 526       y1 = y1 - delta * Math.sin(rad) * v;\r
 527     }\r
 528     \r
 529     switch(a2){\r
 530     case 0:\r
 531     case 1:\r
 532     case 7:\r
 533     case 9:\r
 534     case 15: // it can change to 15->5\r
 535     case 14: // it can change to 14->4\r
 536     case 17: // no need\r
 537     case 5:\r
 538       delta = 0;\r
 539       break;\r
 540     case 8: // get shorten for tail's circle\r
 541       delta = -1 * kage.kMinWidthT * 0.5;\r
 542       break;\r
 543     default:\r
 544       break;\r
 545     }\r
 546     \r
 547     if(x2 == x3){\r
 548       if(y2 < y3){ y3 = y3 + delta; }\r
 549       else{ y3 = y3 - delta; }\r
 550     }\r
 551     else if(y2 == y3){\r
 552       if(x2 < x3){ x3 = x3 + delta; }\r
 553       else{ x3 = x3 - delta; }\r
 554     }\r
 555     else{\r
 556       rad = Math.atan((y3 - y2) / (x3 - x2));\r
 557       if(x2 < x3){ v = 1; } else{ v = -1; }\r
 558       x3 = x3 + delta * Math.cos(rad) * v;\r
 559       y3 = y3 + delta * Math.sin(rad) * v;\r
 560     }\r
 561 \r
 562                 hosomi = 0.5;\r
 563                 if(Math.sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1)) < 50){\r
 564                         hosomi += 0.4 * (1 - Math.sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1)) / 50);\r
 565                 }\r
 566     \r
 567     poly = new Polygon();\r
 568     poly2 = new Polygon();\r
 569     \r
 570     for(tt = 0; tt <= 1000; tt = tt + kage.kRate){\r
 571       t = tt / 1000;\r
 572       \r
 573       //calculate a dot\r
 574       x = ((1.0 - t) * (1.0 - t) * x1 + 2.0 * t * (1.0 - t) * x2 + t * t * x3);\r
 575       y = ((1.0 - t) * (1.0 - t) * y1 + 2.0 * t * (1.0 - t) * y2 + t * t * y3);\r
 576       \r
 577       //KATAMUKI of vector by BIBUN\r
 578       ix = (x1 - 2.0 * x2 + x3) * 2.0 * t + (-2.0 * x1 + 2.0 * x2);\r
 579       iy = (y1 - 2.0 * y2 + y3) * 2.0 * t + (-2.0 * y1 + 2.0 * y2);\r
 580       \r
 581       //line SUICHOKU by vector\r
 582       if(ix != 0 && iy != 0){\r
 583         ir = Math.atan(iy / ix * -1);\r
 584         ia = Math.sin(ir) * (kage.kMinWidthT);\r
 585         ib = Math.cos(ir) * (kage.kMinWidthT);\r
 586       }\r
 587       else if(ix == 0){\r
 588         ia = kage.kMinWidthT;\r
 589         ib = 0;\r
 590       }\r
 591       else{\r
 592         ia = 0;\r
 593         ib = kage.kMinWidthT;\r
 594       }\r
 595       \r
 596       if(a1 == 7 && a2 == 0){ // L2RD: fatten\r
 597                                         deltad = Math.pow(t, hosomi) * kage.kL2RDfatten;\r
 598                         }\r
 599       else if(a1 == 7){\r
 600                                 deltad = Math.pow(t, hosomi);\r
 601                         }\r
 602                         else if(a2 == 7){\r
 603                                 deltad = Math.pow(1.0 - t, hosomi);\r
 604                         }\r
 605       else{ deltad = 1; }\r
 606 \r
 607                         if(deltad < 0.15){\r
 608                                 deltad = 0.15;\r
 609                         }\r
 610       ia = ia * deltad;\r
 611       ib = ib * deltad;\r
 612       \r
 613       //reverse if vector is going 2nd/3rd quadrants\r
 614       if(ix <= 0){\r
 615         ia = ia * -1;\r
 616         ib = ib * -1;\r
 617       }\r
 618       \r
 619       //copy to polygon structure\r
 620       poly.push(x - ia, y - ib);\r
 621       poly2.push(x + ia, y + ib);\r
 622     }\r
 623     \r
 624     poly2.reverse();\r
 625     poly.concat(poly2);\r
 626     polygons.push(poly);\r
 627     \r
 628     //process for head of stroke\r
 629     rad = Math.atan((y2 - y1) / (x2 - x1));\r
 630     if(x1 < x2){ v = 1; } else{ v = -1; }\r
 631     XX = Math.sin(rad) * v;\r
 632     XY = Math.cos(rad) * v * -1;\r
 633     YX = Math.cos(rad) * v;\r
 634     YY = Math.sin(rad) * v;\r
 635     \r
 636     if(a1 == 12){\r
 637       if(x1 == x2){\r
 638         poly= new Polygon();\r
 639         poly.push(x1 - kage.kMinWidthT, y1);\r
 640         poly.push(x1 + kage.kMinWidthT, y1);\r
 641         poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthT);\r
 642         polygons.push(poly);\r
 643       }\r
 644       else{\r
 645         poly = new Polygon();\r
 646         poly.push(x1 - kage.kMinWidthT * XX, y1 - kage.kMinWidthT * XY);\r
 647         poly.push(x1 + kage.kMinWidthT * XX, y1 + kage.kMinWidthT * XY);\r
 648         poly.push(x1 - kage.kMinWidthT * XX - kage.kMinWidthT * YX, y1 - kage.kMinWidthT * XY - kage.kMinWidthT * YY);\r
 649         polygons.push(poly);\r
 650       }\r
 651     }\r
 652     \r
 653     if(a1 == 0){\r
 654       if(y1 <= y3){ //from up to bottom\r
 655         if(x1 == x2){\r
 656           poly = new Polygon();\r
 657           poly.push(x1 - kage.kMinWidthT, y1);\r
 658           poly.push(x1 + kage.kMinWidthT, y1);\r
 659           poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 660           polygons.push(poly);\r
 661         }\r
 662         else{\r
 663           poly = new Polygon();\r
 664           poly.push(x1 - kage.kMinWidthT * XX, y1 - kage.kMinWidthT * XY);\r
 665           poly.push(x1 + kage.kMinWidthT * XX, y1 + kage.kMinWidthT * XY);\r
 666           poly.push(x1 - kage.kMinWidthT * XX - kage.kMinWidthY * YX, y1 - kage.kMinWidthT * XY - kage.kMinWidthY * YY);\r
 667           polygons.push(poly);\r
 668         }\r
 669       }\r
 670       else{ //bottom to up\r
 671         if(x1 == x2){\r
 672           poly = new Polygon();\r
 673           poly.push(x1 - kage.kMinWidthT, y1);\r
 674           poly.push(x1 + kage.kMinWidthT, y1);\r
 675           poly.push(x1 + kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 676           polygons.push(poly);\r
 677         }\r
 678         else{\r
 679           poly = new Polygon();\r
 680           poly.push(x1 - kage.kMinWidthT * XX, y1 - kage.kMinWidthT * XY);\r
 681           poly.push(x1 + kage.kMinWidthT * XX, y1 + kage.kMinWidthT * XY);\r
 682           poly.push(x1 + kage.kMinWidthT * XX - kage.kMinWidthY * YX, y1 + kage.kMinWidthT * XY - kage.kMinWidthY * YY);\r
 683           polygons.push(poly);\r
 684         }\r
 685       }\r
 686     }\r
 687     \r
 688     if(a1 == 22){ //box's up-right corner, any time same degree\r
 689       poly = new Polygon();\r
 690       poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
 691       poly.push(x1, y1 - kage.kMinWidthY - kage.kWidth);\r
 692       poly.push(x1 + kage.kMinWidthT + kage.kWidth, y1 + kage.kMinWidthY);\r
 693       poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthT);\r
 694       poly.push(x1, y1 + kage.kMinWidthT);\r
 695       polygons.push(poly);\r
 696     }\r
 697     \r
 698     if(a1 == 0){ //beginning of the stroke\r
 699       if(y1 <= y3){ //from up to bottom\r
 700         if(x1 == x2){\r
 701           poly = new Polygon();\r
 702           poly.push(x1 + kage.kMinWidthT, y1);\r
 703           poly.push(x1 + kage.kMinWidthT * 1.5, y1 + kage.kMinWidthY);\r
 704           poly.push(x1 + kage.kMinWidthT * 0.5, y1 + kage.kMinWidthY * 3);\r
 705           polygons.push(poly);\r
 706         }\r
 707         else{\r
 708           poly = new Polygon();\r
 709           poly.push(x1 + kage.kMinWidthT * XX,\r
 710                     y1 + kage.kMinWidthT * XY);\r
 711           poly.push(x1 + kage.kMinWidthT * 1.5 * XX + kage.kMinWidthY * YX,\r
 712                     y1 + kage.kMinWidthT * 1.5 * XY + kage.kMinWidthY * YY);\r
 713           poly.push(x1 + kage.kMinWidthT * 0.5 * XX + kage.kMinWidthY * 3 * YX,\r
 714                     y1 + kage.kMinWidthT * 0.5 * XY + kage.kMinWidthY * 3 * YY);\r
 715           polygons.push(poly);\r
 716         }\r
 717       }\r
 718       else{ //from bottom to up\r
 719         if(x1 == x2){\r
 720           poly = new Polygon();\r
 721           poly.push(x1 - kage.kMinWidthT, y1);\r
 722           poly.push(x1 - kage.kMinWidthT * 1.5, y1 + kage.kMinWidthY);\r
 723           poly.push(x1 - kage.kMinWidthT * 0.5, y1 + kage.kMinWidthY * 3);\r
 724           polygons.push(poly);\r
 725         }\r
 726         else{\r
 727           poly = new Polygon();\r
 728           poly.push(x1 - kage.kMinWidthT * XX, y1 - kage.kMinWidthT * XY);\r
 729           poly.push(x1 - kage.kMinWidthT * 1.5 * XX + kage.kMinWidthY * YX, y1 + kage.kMinWidthY * YY - kage.kMinWidthT * 1.5 * XY);\r
 730           poly.push(x1 - kage.kMinWidthT * 0.5 * XX + kage.kMinWidthY * 3 * YX, y1 + kage.kMinWidthY * 3 * YY - kage.kMinWidthT * 0.5 * XY);\r
 731           polygons.push(poly);\r
 732         }\r
 733       }\r
 734     }\r
 735     \r
 736     //process for tail\r
 737     rad = Math.atan((y3 - y2) / (x3 - x2));\r
 738     if(x2 < x3){ v = 1; } else{ v = -1; }\r
 739     YX = Math.sin(rad) * v * -1;\r
 740     YY = Math.cos(rad) * v;\r
 741     XX = Math.cos(rad) * v;\r
 742     XY = Math.sin(rad) * v;\r
 743     \r
 744     if(a2 == 1 || a2 == 8 || a2 == 15){ //the last filled circle ... it can change 15->5\r
 745       if(x2 == x3){\r
 746         poly = new Polygon();\r
 747         poly.push(x3 - kage.kMinWidthT, y3);\r
 748         poly.push(x3 - kage.kMinWidthT * 0.7, y3 + kage.kMinWidthT * 0.7);\r
 749         poly.push(x3, y3 + kage.kMinWidthT);\r
 750         poly.push(x3 + kage.kMinWidthT * 0.7, y3 + kage.kMinWidthT * 0.7);\r
 751         poly.push(x3 + kage.kMinWidthT, y3);\r
 752         polygons.push(poly);\r
 753       }\r
 754       else if(y2 == y3){\r
 755         poly = new Polygon();\r
 756         poly.push(x3, y3 - kage.kMinWidthT);\r
 757         poly.push(x3 + kage.kMinWidthT * 0.7, y3 - kage.kMinWidthT * 0.7);\r
 758         poly.push(x3 + kage.kMinWidthT, y3);\r
 759         poly.push(x3 + kage.kMinWidthT * 0.7, y3 + kage.kMinWidthT * 0.7);\r
 760         poly.push(x3, y3 + kage.kMinWidthT);\r
 761         polygons.push(poly);\r
 762       }\r
 763       else{\r
 764         poly = new Polygon();\r
 765         poly.push(x3 + Math.sin(rad) * kage.kMinWidthT * v, y3 - Math.cos(rad) * kage.kMinWidthT * v);\r
 766         poly.push(x3 + Math.cos(rad) * kage.kMinWidthT * 0.7 * v + Math.sin(rad) * kage.kMinWidthT * 0.7 * v,\r
 767                   y3 + Math.sin(rad) * kage.kMinWidthT * 0.7 * v - Math.cos(rad) * kage.kMinWidthT * 0.7 * v);\r
 768         poly.push(x3 + Math.cos(rad) * kage.kMinWidthT * v, y3 + Math.sin(rad) * kage.kMinWidthT * v);\r
 769         poly.push(x3 + Math.cos(rad) * kage.kMinWidthT * 0.7 * v - Math.sin(rad) * kage.kMinWidthT * 0.7 * v,\r
 770                   y3 + Math.sin(rad) * kage.kMinWidthT * 0.7 * v + Math.cos(rad) * kage.kMinWidthT * 0.7 * v);\r
 771         poly.push(x3 - Math.sin(rad) * kage.kMinWidthT * v, y3 + Math.cos(rad) * kage.kMinWidthT * v);\r
 772         polygons.push(poly);\r
 773       }\r
 774     }\r
 775     \r
 776     if(a2 == 9 || (a1 == 7 && a2 == 0)){ // Math.sinnyu & L2RD Harai ... no need for a2=9\r
 777       if(y2 == y3){\r
 778         poly = new Polygon();\r
 779         poly.push(x3, y3 + kage.kMinWidthT * kage.kL2RDfatten);\r
 780         poly.push(x3, y3 - kage.kMinWidthT * kage.kL2RDfatten);\r
 781         poly.push(x3 + kage.kMinWidthT * kage.kL2RDfatten, y3 - kage.kMinWidthT * kage.kL2RDfatten);\r
 782         polygons.push(poly);\r
 783       }\r
 784       else{\r
 785         poly = new Polygon();\r
 786         poly.push(x3 + kage.kMinWidthT * kage.kL2RDfatten * YX, y3 + kage.kMinWidthT * kage.kL2RDfatten * YY);\r
 787         poly.push(x3 - kage.kMinWidthT * kage.kL2RDfatten * YX, y3 - kage.kMinWidthT * kage.kL2RDfatten * YY);\r
 788         poly.push(x3 + kage.kMinWidthT * kage.kL2RDfatten * XX - kage.kMinWidthT * kage.kL2RDfatten * YX,\r
 789                   y3 + kage.kMinWidthT * kage.kL2RDfatten * XY - kage.kMinWidthT * kage.kL2RDfatten * YY);\r
 790         polygons.push(poly);\r
 791       }\r
 792     }\r
 793     \r
 794     if(a2 == 15){ //jump up ... it can change 15->5\r
 795       if(y2 == y3){\r
 796         poly = new Polygon();\r
 797         poly.push(x3, y3 - kage.kMinWidthT + 1);\r
 798         poly.push(x3 + 2, y3 - kage.kMinWidthT - kage.kWidth * 5);\r
 799         poly.push(x3, y3 - kage.kMinWidthT - kage.kWidth * 5);\r
 800         poly.push(x3 - kage.kMinWidthT, y3 - kage.kMinWidthT + 1);\r
 801         polygons.push(poly);\r
 802       }\r
 803       else{\r
 804         poly = new Polygon();\r
 805         poly.push(x3 + (kage.kMinWidthT - 1) * Math.sin(rad) * v, y3 - (kage.kMinWidthT - 1) * Math.cos(rad) * v);\r
 806         poly.push(x3 + 2 * Math.cos(rad) * v + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
 807                   y3 + 2 * Math.sin(rad) * v - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
 808         poly.push(x3 + (kage.kMinWidthT + kage.kWidth * 5) * Math.sin(rad) * v,\r
 809                   y3 - (kage.kMinWidthT + kage.kWidth * 5) * Math.cos(rad) * v);\r
 810         poly.push(x3 + (kage.kMinWidthT - 1) * Math.sin(rad) * v - kage.kMinWidthT * Math.cos(rad) * v,\r
 811                   y3 - (kage.kMinWidthT - 1) * Math.cos(rad) * v - kage.kMinWidthT * Math.sin(rad) * v);\r
 812         polygons.push(poly);\r
 813       }\r
 814     }\r
 815     \r
 816     if(a2 == 14){ //jump to left, allways go left ... it can change 14->4\r
 817       poly = new Polygon();\r
 818       poly.push(x3, y3);\r
 819       poly.push(x3, y3 - kage.kMinWidthT);\r
 820       poly.push(x3 - kage.kWidth * 4, y3 - kage.kMinWidthT);\r
 821       poly.push(x3 - kage.kWidth * 4, y3 - kage.kMinWidthT * 0.5);\r
 822       polygons.push(poly);\r
 823     }\r
 824   }\r
 825   else{ //gothic\r
 826     if(a1 % 10 == 2){\r
 827       if(x1 == x2){\r
 828         if(y1 < y2){ y1 = y1 - kage.kWidth; } else{ y1 = y1 + kage.kWidth; }\r
 829       }\r
 830       else if(y1 == y2){\r
 831         if(x1 < x2){ x1 = x1 - kage.kWidth; } else{ x1 = x1 + kage.kWidth; }\r
 832       }\r
 833       else{\r
 834         rad = Math.atan((y2 - y1) / (x2 - x1));\r
 835         if(x1 < x2){ v = 1; } else{ v = -1; }\r
 836         x1 = x1 - kage.kWidth * Math.cos(rad) * v;\r
 837         y1 = y1 - kage.kWidth * Math.sin(rad) * v;\r
 838       }\r
 839     }\r
 840     \r
 841     if(a1 % 10 == 3){\r
 842       if(x1 == x2){\r
 843         if(y1 < y2){\r
 844           y1 = y1 - kage.kWidth * kage.kKakato;\r
 845         }\r
 846         else{\r
 847           y1 = y1 + kage.kWidth * kage.kKakato;\r
 848         }\r
 849       }\r
 850       else if(y1 == y2){\r
 851         if(x1 < x2){\r
 852           x1 = x1 - kage.kWidth * kage.kKakato;\r
 853         }\r
 854         else{\r
 855           x1 = x1 + kage.kWidth * kage.kKakato;\r
 856         }\r
 857       }\r
 858       else{\r
 859         rad = Math.atan((y2 - y1) / (x2 - x1));\r
 860         if(x1 < x2){ v = 1; } else{ v = -1; }\r
 861         x1 = x1 - kage.kWidth * Math.cos(rad) * v * kage.kKakato;\r
 862         y1 = y1 - kage.kWidth * Math.sin(rad) * v * kage.kKakato;\r
 863       }\r
 864     }\r
 865     if(a2 % 10 == 2){\r
 866       if(x2 == x3){\r
 867         if(y2 < y3){ y3 = y3 + kage.kWidth; } else{ y3 = y3 - kage.kWidth; }\r
 868       }\r
 869       else if(y2 == y3){\r
 870         if(x2 < x3){ x3 = x3 + kage.kWidth; } else{ x3 = x3 - kage.kWidth; }\r
 871       }\r
 872       else{\r
 873         rad = Math.atan((y3 - y2) / (x3 - x2));\r
 874         if(x2 < x3){ v = 1; } else{ v = -1; }\r
 875         x3 = x3 + kage.kWidth * Math.cos(rad) * v;\r
 876         y3 = y3 + kage.kWidth * Math.sin(rad) * v;\r
 877       }\r
 878     }\r
 879     \r
 880     if(a2 % 10 == 3){\r
 881       if(x2 == x3){\r
 882         if(y2 < y3){\r
 883           y3 = y3 + kage.kWidth * kage.kKakato;\r
 884         }\r
 885         else{\r
 886           y3 = y3 - kage.kWidth * kage.kKakato;\r
 887         }\r
 888       }\r
 889       else if(y2 == y3){\r
 890         if(x2 < x3){\r
 891           x3 = x3 + kage.kWidth * kage.kKakato;\r
 892         }\r
 893         else{\r
 894           x3 = x3 - kage.kWidth * kage.kKakato;\r
 895         }\r
 896       }\r
 897       else{\r
 898         rad = Math.atan((y3 - y2) / (x3 - x2));\r
 899         if(x2 < x3){ v = 1; } else{ v = -1; }\r
 900         x3 = x3 + kage.kWidth * Math.cos(rad) * v * kage.kKakato;\r
 901         y3 = y3 + kage.kWidth * Math.sin(rad) * v * kage.kKakato;\r
 902       }\r
 903     }\r
 904     \r
 905     poly = new Polygon();\r
 906     poly2 = new Polygon();\r
 907     \r
 908     for(tt = 0; tt <= 1000; tt = tt + kage.kRate){\r
 909       t = tt / 1000;\r
 910       \r
 911       //calculating each point\r
 912       x = ((1.0 - t) * (1.0 - t) * x1 + 2.0 * t * (1.0 - t) * x2 + t * t * x3);\r
 913       y = ((1.0 - t) * (1.0 - t) * y1 + 2.0 * t * (1.0 - t) * y2 + t * t * y3);\r
 914       \r
 915       //SESSEN NO KATAMUKI NO KEISAN(BIBUN)\r
 916       ix = (x1 - 2.0 * x2 + x3) * 2.0 * t + (-2.0 * x1 + 2.0 * x2);\r
 917       iy = (y1 - 2.0 * y2 + y3) * 2.0 * t + (-2.0 * y1 + 2.0 * y2);\r
 918       \r
 919       //SESSEN NI SUICHOKU NA CHOKUSEN NO KEISAN\r
 920       if(kage.kShotai == kage.kMincho){ //always false ?\r
 921         if(ix != 0 && iy != 0){\r
 922           ir = Math.atan(iy / ix * -1.0);\r
 923           ia = Math.sin(ir) * kage.kMinWidthT;\r
 924           ib = Math.cos(ir) * kage.kMinWidthT;\r
 925         }\r
 926         else if(ix == 0){\r
 927           ia = kage.kMinWidthT;\r
 928           ib = 0;\r
 929         }\r
 930         else{\r
 931           ia = 0;\r
 932           ib = kage.kMinWidthT;\r
 933         }\r
 934         ia = ia * Math.sqrt(1.0 - t);\r
 935         ib = ib * Math.sqrt(1.0 - t);\r
 936       }\r
 937       else{\r
 938         if(ix != 0 && iy != 0){\r
 939           ir = Math.atan(iy / ix * -1.0);\r
 940           ia = Math.sin(ir) * kage.kWidth;\r
 941           ib = Math.cos(ir) * kage.kWidth;\r
 942         }\r
 943         else if(ix == 0){\r
 944           ia = kage.kWidth;\r
 945           ib = 0;\r
 946         }\r
 947         else{\r
 948           ia = 0;\r
 949           ib = kage.kWidth;\r
 950         }\r
 951       }\r
 952       \r
 953       //reverse if vector is going 2nd/3rd quadrants\r
 954       if(ix <= 0){\r
 955         ia = ia * -1;\r
 956         ib = ib * -1;\r
 957       }\r
 958       \r
 959       //save to polygon\r
 960       poly.push(x - ia, y - ib);\r
 961       poly2.push(x + ia, y + ib);\r
 962     }\r
 963     \r
 964     poly2.reverse();\r
 965     poly.concat(poly2);\r
 966     polygons.push(poly);\r
 967   }\r
 968 }\r
 969 \r
 970 function cdDrawLine(kage, polygons, tx1, ty1, tx2, ty2, ta1, ta2){\r
 971   var rad;\r
 972   var v, x1, y1, x2, y2;\r
 973   var a1, a2, opt1, opt2;\r
 974   var XX, XY, YX, YY;\r
 975   var poly;\r
 976   \r
 977   if(kage.kShotai == kage.kMincho){ //mincho\r
 978     x1 = tx1;\r
 979     y1 = ty1;\r
 980     x2 = tx2;\r
 981     y2 = ty2;\r
 982     a1 = ta1 % 100;\r
 983     a2 = ta2 % 100;\r
 984     opt1 = Math.floor(ta1 / 100);\r
 985     opt2 = Math.floor(ta2 / 100);\r
 986     \r
 987     if(x1 == x2){ //if TATE stroke, use y-axis\r
 988       poly = new Polygon(4);\r
 989       switch(a1){\r
 990       case 0:\r
 991         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY / 2);\r
 992         poly.set(0, x1 + kage.kMinWidthT, y1 + kage.kMinWidthY / 2);\r
 993         break;\r
 994       case 1:\r
 995       case 6: //... no need\r
 996       case 22:\r
 997         poly.set(3, x1 - kage.kMinWidthT, y1);\r
 998         poly.set(0, x1 + kage.kMinWidthT, y1);\r
 999         break;\r
1000       case 12:\r
1001         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY - kage.kMinWidthT);\r
1002         poly.set(0, x1 + kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1003         break;\r
1004       case 32:\r
1005         poly.set(3, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1006         poly.set(0, x1 + kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1007         break;\r
1008       }\r
1009       \r
1010       switch(a2){\r
1011       case 0:\r
1012         if(a1 == 6){ //KAGI's tail ... no need\r
1013           poly.set(2, x2 - kage.kMinWidthT, y2);\r
1014           poly.set(1, x2 + kage.kMinWidthT, y2);\r
1015         }\r
1016         else{\r
1017           poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kMinWidthT / 2);\r
1018           poly.set(1, x2 + kage.kMinWidthT, y2 - kage.kMinWidthT / 2);\r
1019         }\r
1020         break;\r
1021       case 1:\r
1022         poly.set(2, x2 - kage.kMinWidthT, y2);\r
1023         poly.set(1, x2 + kage.kMinWidthT, y2);\r
1024         break;\r
1025       case 13:\r
1026         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kAdjustKakatoL[opt2] + kage.kMinWidthT);\r
1027         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kAdjustKakatoL[opt2]);\r
1028         break;\r
1029       case 23:\r
1030         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kAdjustKakatoR[opt2] + kage.kMinWidthT);\r
1031         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kAdjustKakatoR[opt2]);\r
1032         break;\r
1033       case 32:\r
1034         poly.set(2, x2 - kage.kMinWidthT, y2 + kage.kMinWidthY);\r
1035         poly.set(1, x2 + kage.kMinWidthT, y2 + kage.kMinWidthY);\r
1036         break;\r
1037       }\r
1038       \r
1039       polygons.push(poly);\r
1040       \r
1041       if(a1 == 22){ //box's right top corner\r
1042         poly = new Polygon();\r
1043         poly.push(x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1044         poly.push(x1, y1 - kage.kMinWidthY - kage.kWidth);\r
1045         poly.push(x1 + kage.kMinWidthT + kage.kWidth, y1 + kage.kMinWidthY);\r
1046         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthT);\r
1047         poly.push(x1 - kage.kMinWidthT, y1);\r
1048         polygons.push(poly);\r
1049       }\r
1050       \r
1051       if(a1 == 0){ //beginning of the stroke\r
1052         poly = new Polygon();\r
1053         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthY * 0.5);\r
1054         poly.push(x1 + kage.kMinWidthT + kage.kMinWidthT * 0.5, y1 + kage.kMinWidthY * 0.5 + kage.kMinWidthY);\r
1055         poly.push(x1 + kage.kMinWidthT, y1 + kage.kMinWidthY * 0.5 + kage.kMinWidthY * 2);\r
1056         polygons.push(poly);\r
1057       }\r
1058       \r
1059       if((a1 == 6 && a2 == 0) || a2 == 1){ //KAGI NO YOKO BOU NO SAIGO NO MARU ... no need only used at 1st=yoko\r
1060         poly = new Polygon();\r
1061         poly.push(x2 - kage.kMinWidthT, y2);\r
1062         poly.push(x2 - kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
1063         poly.push(x2, y2 + kage.kMinWidthT);\r
1064         poly.push(x2 + kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
1065         poly.push(x2 + kage.kMinWidthT, y2);\r
1066         poly.reverse(); // for fill-rule\r
1067         polygons.push(poly);\r
1068       }\r
1069     }\r
1070     else if(y1 == y2){ //if it is YOKO stroke, use x-axis\r
1071       if(a1 == 6){ //if it is KAGI's YOKO stroke, get bold\r
1072         poly = new Polygon();\r
1073         poly.push(x1, y1 - kage.kMinWidthT);\r
1074         poly.push(x2, y2 - kage.kMinWidthT);\r
1075         poly.push(x2, y2 + kage.kMinWidthT);\r
1076         poly.push(x1, y1 + kage.kMinWidthT);\r
1077         polygons.push(poly);\r
1078         \r
1079         if(a2 == 1 || a2 == 0 || a2 == 5){ // no need a2=1\r
1080           //KAGI NO YOKO BOU NO SAIGO NO MARU\r
1081           poly = new Polygon();\r
1082           poly.push(x2, y2 - kage.kMinWidthT);\r
1083           poly.push(x2 + kage.kMinWidthT * 0.6, y2 - kage.kMinWidthT * 0.6);\r
1084           poly.push(x2 + kage.kMinWidthT, y2);\r
1085           poly.push(x2 + kage.kMinWidthT * 0.6, y2 + kage.kMinWidthT * 0.6);\r
1086           poly.push(x2, y2 + kage.kMinWidthT);\r
1087           polygons.push(poly);\r
1088         }\r
1089         \r
1090         if(a2 == 5){\r
1091           //KAGI NO YOKO BOU NO HANE\r
1092           poly = new Polygon();\r
1093           poly.push(x2, y2 - kage.kMinWidthT + 1);\r
1094           poly.push(x2 + 2, y2 - kage.kMinWidthT - kage.kWidth * 5);\r
1095           poly.push(x2, y2 - kage.kMinWidthT - kage.kWidth * 5);\r
1096           poly.push(x2 - kage.kMinWidthT, y2 - kage.kMinWidthT + 1);\r
1097           poly.reverse(); // for fill-rule\r
1098           polygons.push(poly);\r
1099         }\r
1100       }\r
1101       else{\r
1102         poly = new Polygon(4);\r
1103         switch(a1){\r
1104         case 0:\r
1105           poly.set(0, x1, y1 - kage.kMinWidthY);\r
1106           poly.set(3, x1, y1 + kage.kMinWidthY);\r
1107           break;\r
1108         case 2:\r
1109           poly.set(0, x1 - kage.kMinWidthT, y1 - kage.kMinWidthY);\r
1110           poly.set(3, x1 - kage.kMinWidthT, y1 + kage.kMinWidthY);\r
1111           break;\r
1112         }\r
1113         \r
1114         switch(a2){\r
1115         case 0:\r
1116           poly.set(1, x2, y2 - kage.kMinWidthY);\r
1117           poly.set(2, x2, y2 + kage.kMinWidthY);\r
1118           break;\r
1119         case 2:\r
1120           poly.set(1, x2 + kage.kMinWidthT, y2 - kage.kMinWidthY);\r
1121           poly.set(2, x2 + kage.kMinWidthT, y2 + kage.kMinWidthY);\r
1122         }\r
1123         \r
1124         polygons.push(poly);\r
1125         \r
1126         //UROKO\r
1127         if(a2 == 0){\r
1128           poly = new Polygon();\r
1129           poly.push(x2, y2 - kage.kMinWidthY);\r
1130           poly.push(x2 - 24, y2);\r
1131           poly.push(x2 - 12, y2 - 12);\r
1132           polygons.push(poly);\r
1133         }\r
1134       }\r
1135     }\r
1136     else{ //for others, use x-axis\r
1137       rad = Math.atan((y2 - y1) / (x2 - x1));\r
1138       if((Math.abs(y2 - y1) < Math.abs(x2 - x1)) && (a1 != 6) && (a2 != 6) && !(x1 > x2)){ //ASAI KAUDO\r
1139         poly = new Polygon(4);\r
1140         switch(a1){ //must be 0 or 2\r
1141         case 0:\r
1142           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthY, y1 - Math.cos(rad) * kage.kMinWidthY);\r
1143           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthY, y1 + Math.cos(rad) * kage.kMinWidthY);\r
1144           break;\r
1145         case 2:\r
1146           poly.set(0, x1 + Math.sin(rad) * kage.kMinWidthY - kage.kMinWidthT * Math.cos(rad),\r
1147                    y1 - Math.cos(rad) * kage.kMinWidthY - kage.kMinWidthT * Math.sin(rad));\r
1148           poly.set(3, x1 - Math.sin(rad) * kage.kMinWidthY - kage.kMinWidthT * Math.cos(rad),\r
1149                    y1 + Math.cos(rad) * kage.kMinWidthY - kage.kMinWidthT * Math.sin(rad));\r
1150           break;\r
1151         }\r
1152         \r
1153         switch(a2){ //must be 0 or 2\r
1154         case 0:\r
1155           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthY, y2 - Math.cos(rad) * kage.kMinWidthY);\r
1156           poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthY, y2 + Math.cos(rad) * kage.kMinWidthY);\r
1157           break;\r
1158         case 2:\r
1159           poly.set(1, x2 + Math.sin(rad) * kage.kMinWidthY + kage.kMinWidthT * Math.cos(rad),\r
1160                    y2 - Math.cos(rad) * kage.kMinWidthY + kage.kMinWidthT * Math.sin(rad));\r
1161           poly.set(2, x2 - Math.sin(rad) * kage.kMinWidthY + kage.kMinWidthT * Math.cos(rad),\r
1162                    y2 + Math.cos(rad) * kage.kMinWidthY + kage.kMinWidthT * Math.sin(rad));\r
1163         }\r
1164         \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) * 24, y2 - Math.sin(rad) * 24);\r
1172           poly.push(x2 - Math.cos(rad) * 12 + Math.sin(rad) * 12, y2 - Math.sin(rad) * 12 - Math.cos(rad) * 12);\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