engine/kagecd.js

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