1 function divide_curve(kage, x1, y1, sx1, sy1, x2, y2, curve, div_curve, off_curve){
\r
3 var cut = Math.floor(curve.length * rate);
\r
4 var cut_rate = cut / curve.length;
\r
5 var tx1 = x1 + (sx1 - x1) * cut_rate;
\r
6 var ty1 = y1 + (sy1 - y1) * cut_rate;
\r
7 var tx2 = sx1 + (x2 - sx1) * cut_rate;
\r
8 var ty2 = sy1 + (y2 - sy1) * cut_rate;
\r
9 var tx3 = tx1 + (tx2 - tx1) * cut_rate;
\r
10 var ty3 = ty1 + (ty2 - ty1) * cut_rate;
\r
12 div_curve[0] = new Array();
\r
13 div_curve[1] = new Array();
\r
14 off_curve[0] = new Array(6);
\r
15 off_curve[1] = new Array(6);
\r
17 // must think about 0 : <0
\r
19 for(i = 0; i <= cut; i++){
\r
20 div_curve[0].push(curve[i]);
\r
22 off_curve[0][0] = x1;
\r
23 off_curve[0][1] = y1;
\r
24 off_curve[0][2] = tx1;
\r
25 off_curve[0][3] = ty1;
\r
26 off_curve[0][4] = tx3;
\r
27 off_curve[0][5] = ty3;
\r
29 for(i = cut; i < curve.length; i++){
\r
30 div_curve[1].push(curve[i]);
\r
32 off_curve[1][0] = tx3;
\r
33 off_curve[1][1] = ty3;
\r
34 off_curve[1][2] = tx2;
\r
35 off_curve[1][3] = ty2;
\r
36 off_curve[1][4] = x2;
\r
37 off_curve[1][5] = y2;
\r
40 // ------------------------------------------------------------------
\r
41 function find_offcurve(kage, curve, sx, sy, result){
\r
42 var nx1, ny1, nx2, ny2, tx, ty;
\r
43 var minx, miny, count, diff;
\r
44 var tt, t, x, y, ix, iy;
\r
45 var mindiff = 100000;
\r
48 // area = 10 mesh = 5 -> 281 calcs
\r
49 // area = 10 mesh = 4 -> 180 calcs
\r
50 // area = 8 mesh = 4 -> 169 calcs
\r
51 // area = 7.5 mesh = 3 -> 100 calcs
\r
52 // area = 8 mesh = 2 -> 97 calcs
\r
53 // area = 7 mesh = 2 -> 80 calcs
\r
57 nx2 = curve[curve.length - 1][0];
\r
58 ny2 = curve[curve.length - 1][1];
\r
60 for(tx = sx - area; tx < sx + area; tx += mesh){
\r
61 for(ty = sy - area; ty < sy + area; ty += mesh){
\r
64 for(tt = 0; tt < curve.length; tt++){
\r
65 t = tt / curve.length;
\r
68 x = ((1.0 - t) * (1.0 - t) * nx1 + 2.0 * t * (1.0 - t) * tx + t * t * nx2);
\r
69 y = ((1.0 - t) * (1.0 - t) * ny1 + 2.0 * t * (1.0 - t) * ty + t * t * ny2);
\r
71 //KATAMUKI of vector by BIBUN
\r
72 ix = (nx1 - 2.0 * tx + nx2) * 2.0 * t + (-2.0 * nx1 + 2.0 * tx);
\r
73 iy = (ny1 - 2.0 * ty + ny2) * 2.0 * t + (-2.0 * ny1 + 2.0 * ty);
\r
75 diff += (curve[count][0] - x) * (curve[count][0] - x) + (curve[count][1] - y) * (curve[count][1] - y);
\r
89 for(tx = minx - mesh + 1; tx <= minx + mesh - 1; tx += 0.5){
\r
90 for(ty = miny - mesh + 1; ty <= miny + mesh - 1; ty += 0.5){
\r
93 for(tt = 0; tt < curve.length; tt++){
\r
94 t = tt / curve.length;
\r
97 x = ((1.0 - t) * (1.0 - t) * nx1 + 2.0 * t * (1.0 - t) * tx + t * t * nx2);
\r
98 y = ((1.0 - t) * (1.0 - t) * ny1 + 2.0 * t * (1.0 - t) * ty + t * t * ny2);
\r
100 //KATAMUKI of vector by BIBUN
\r
101 ix = (nx1 - 2.0 * tx + nx2) * 2.0 * t + (-2.0 * nx1 + 2.0 * tx);
\r
102 iy = (ny1 - 2.0 * ty + ny2) * 2.0 * t + (-2.0 * ny1 + 2.0 * ty);
\r
104 diff += (curve[count][0] - x) * (curve[count][0] - x) + (curve[count][1] - y) * (curve[count][1] - y);
\r
105 if(diff > mindiff){
\r
110 if(diff < mindiff){
\r
124 result[6] = mindiff;
\r
127 // ------------------------------------------------------------------
\r
128 function get_candidate(kage, curve, a1, a2, x1, y1, sx1, sy1, x2, y2, opt3){
\r
129 var x, y, ix, iy, ir, ia, ib, tt, t, deltad;
\r
132 curve[0] = new Array();
\r
133 curve[1] = new Array();
\r
135 for(tt = 0; tt <= 1000; tt = tt + kage.kRate){
\r
139 x = ((1.0 - t) * (1.0 - t) * x1 + 2.0 * t * (1.0 - t) * sx1 + t * t * x2);
\r
140 y = ((1.0 - t) * (1.0 - t) * y1 + 2.0 * t * (1.0 - t) * sy1 + t * t * y2);
\r
142 //KATAMUKI of vector by BIBUN
\r
143 ix = (x1 - 2.0 * sx1 + x2) * 2.0 * t + (-2.0 * x1 + 2.0 * sx1);
\r
144 iy = (y1 - 2.0 * sy1 + y2) * 2.0 * t + (-2.0 * y1 + 2.0 * sy1);
\r
145 //line SUICHOKU by vector
\r
146 if(ix != 0 && iy != 0){
\r
147 ir = Math.atan(iy / ix * -1);
\r
148 ia = Math.sin(ir) * (kage.kMinWidthT);
\r
149 ib = Math.cos(ir) * (kage.kMinWidthT);
\r
152 ia = kage.kMinWidthT;
\r
157 ib = kage.kMinWidthT;
\r
160 if(a1 == 7 && a2 == 0){ // L2RD: fatten
\r
161 deltad = Math.pow(t, hosomi) * kage.kL2RDfatten;
\r
164 deltad = Math.pow(t, hosomi);
\r
167 deltad = Math.pow(1.0 - t, hosomi);
\r
170 deltad = ((kage.kMinWidthT - opt3 / 2) / kage.kMinWidthT) + opt3 / 2 / kage.kMinWidthT * t;
\r
172 else{ deltad = 1; }
\r
180 //reverse if vector is going 2nd/3rd quadrants
\r
186 temp = new Array(2);
\r
189 curve[0].push(temp);
\r
190 temp = new Array(2);
\r
193 curve[1].push(temp);
\r