![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to arcgen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / pic|
Return to arcgen.c CVS log | Up to [Research Unix] / researchv9 / cmd / pic |
1.1 root 1: #include <stdio.h>
2: #include <math.h>
3: #include "pic.h"
4: #include "y.tab.h"
5:
6: obj *arcgen(type) /* handles circular and (eventually) elliptical arcs */
7: {
8: static float prevw = HT10;
9: static float prevh = HT5;
10: static float prevrad = HT2;
11: static int dtox[2][4] ={ 1, -1, -1, 1, 1, 1, -1, -1 };
12: static int dtoy[2][4] ={ 1, 1, -1, -1, -1, 1, 1, -1 };
13: static int dctrx[2][4] ={ 0, -1, 0, 1, 0, 1, 0, -1 };
14: static int dctry[2][4] ={ 1, 0, -1, 0, -1, 0, 1, 0 };
15: static int nexthv[2][4] ={ U_DIR, L_DIR, D_DIR, R_DIR, D_DIR, R_DIR, U_DIR, L_DIR };
16: float dx2, dy2, ht, phi, r, d, ddval;
17: int i, head, to, at, cw, invis, ddtype;
18: obj *p, *ppos;
19: float fromx, fromy, tox, toy;
20: Attr *ap;
21:
22: prevrad = getfval("arcrad");
23: prevh = getfval("arrowht");
24: prevw = getfval("arrowwid");
25: fromx = curx;
26: fromy = cury;
27: head = to = at = cw = invis = ddtype = 0;
28: for (i = 0; i < nattr; i++) {
29: ap = &attr[i];
30: switch (ap->a_type) {
31: case TEXTATTR:
32: savetext(ap->a_sub, ap->a_val.p);
33: break;
34: case HEAD:
35: head += ap->a_val.i;
36: break;
37: case INVIS:
38: invis = INVIS;
39: break;
40: case DOT:
41: case DASH:
42: ddtype = ap->a_type==DOT ? DOTBIT : DASHBIT;
43: if (ap->a_sub == DEFAULT)
44: ddval = getfval("dashwid");
45: else
46: ddval = ap->a_val.f;
47: break;
48: case HEIGHT: /* length of arrowhead */
49: prevh = ap->a_val.f;
50: break;
51: case WIDTH: /* width of arrowhead */
52: prevw = ap->a_val.f;
53: break;
54: case RADIUS:
55: prevrad = ap->a_val.f;
56: break;
57: case DIAMETER:
58: prevrad = ap->a_val.f / 2;
59: break;
60: case CW:
61: cw = 1;
62: break;
63: case FROM: /* start point of arc */
64: ppos = ap->a_val.o;
65: fromx = ppos->o_x;
66: fromy = ppos->o_y;
67: break;
68: case TO: /* end point of arc */
69: ppos = ap->a_val.o;
70: tox = ppos->o_x;
71: toy = ppos->o_y;
72: to++;
73: break;
74: case AT: /* center of arc */
75: ppos = ap->a_val.o;
76: curx = ppos->o_x;
77: cury = ppos->o_y;
78: at = 1;
79: break;
80: case UP:
81: hvmode = U_DIR;
82: break;
83: case DOWN:
84: hvmode = D_DIR;
85: break;
86: case RIGHT:
87: hvmode = R_DIR;
88: break;
89: case LEFT:
90: hvmode = L_DIR;
91: break;
92: }
93: }
94: if (!at && !to) { /* the defaults are mostly OK */
95: curx = fromx + prevrad * dctrx[cw][hvmode];
96: cury = fromy + prevrad * dctry[cw][hvmode];
97: tox = fromx + prevrad * dtox[cw][hvmode];
98: toy = fromy + prevrad * dtoy[cw][hvmode];
99: hvmode = nexthv[cw][hvmode];
100: }
101: else if (!at) {
102: dx2 = (tox - fromx) / 2;
103: dy2 = (toy - fromy) / 2;
104: phi = atan2(dy2, dx2) + (cw ? -PI/2 : PI/2);
105: if (prevrad <= 0.0)
106: prevrad = dx2*dx2+dy2*dy2;
107: for (r=prevrad; (d = r*r - (dx2*dx2+dy2*dy2)) <= 0.0; r *= 2)
108: ; /* this kludge gets around too-small radii */
109: prevrad = r;
110: ht = sqrt(d);
111: curx = fromx + dx2 + ht * cos(phi);
112: cury = fromy + dy2 + ht * sin(phi);
113: dprintf("dx2,dy2=%g,%g, phi=%g, r,ht=%g,%g\n",
114: dx2, dy2, phi, r, ht);
115: }
116: else if (at && !to) { /* do we have all the cases??? */
117: tox = fromx + prevrad * dtox[cw][hvmode];
118: toy = fromy + prevrad * dtoy[cw][hvmode];
119: hvmode = nexthv[cw][hvmode];
120: }
121: if (cw) { /* interchange roles of from-to and heads */
122: float temp;
123: temp = fromx; fromx = tox; tox = temp;
124: temp = fromy; fromy = toy; toy = temp;
125: if (head == HEAD1)
126: head = HEAD2;
127: else if (head == HEAD2)
128: head = HEAD1;
129: }
130: p = makenode(type, 7);
131: arc_extreme(fromx, fromy, tox, toy, curx, cury);
132: p->o_val[0] = fromx;
133: p->o_val[1] = fromy;
134: p->o_val[2] = tox;
135: p->o_val[3] = toy;
136: if (cw) {
137: curx = fromx;
138: cury = fromy;
139: } else {
140: curx = tox;
141: cury = toy;
142: }
143: p->o_val[4] = prevw;
144: p->o_val[5] = prevh;
145: p->o_val[6] = prevrad;
146: p->o_attr = head | (cw ? CW_ARC : 0) | invis | ddtype;
147: if (head)
148: p->o_nhead = getfval("arrowhead");
149: dprintf("arc rad %g at %g %g from %g %g to %g %g head %g %g\n",
150: prevrad, p->o_x, p->o_y,
151: p->o_val[0], p->o_val[1], p->o_val[2], p->o_val[3], p->o_val[4], p->o_val[5]);
152: return(p);
153: }
154:
155: /***************************************************************************
156: bounding box of a circular arc Eric Grosse 24 May 84
157:
158: Conceptually, this routine generates a list consisting of the start,
159: end, and whichever north, east, south, and west points lie on the arc.
160: The bounding box is then the range of this list.
161: list = {start,end}
162: j = quadrant(start)
163: k = quadrant(end)
164: if( j==k && long way 'round ) append north,west,south,east
165: else
166: while( j != k )
167: append center+radius*[j-th of north,west,south,east unit vectors]
168: j += 1 (mod 4)
169: return( bounding box of list )
170: The following code implements this, with simple optimizations.
171: ***********************************************************************/
172:
173:
174: arc_extreme(x0, y0, x1, y1, xc, yc)
175: double x0, y0, x1, y1, xc, yc; /* start, end, center */
176: {
177: /* assumes center isn't too far out */
178: double r, x, y, xmin, ymin, xmax, ymax;
179: int j, k;
180: x0 -= xc; y0 -= yc; /* move to center */
181: x1 -= xc; y1 -= yc;
182: xmin = (x0<x1)?x0:x1; ymin = (y0<y1)?y0:y1;
183: xmax = (x0>x1)?x0:x1; ymax = (y0>y1)?y0:y1;
184: r = sqrt(x0*x0 + y0*y0);
185: if (r > 0.0) {
186: j = quadrant(x0,y0);
187: k = quadrant(x1,y1);
188: if (j == k && y1*x0 < x1*y0) {
189: /* viewed as complex numbers, if Im(z1/z0)<0, arc is big */
190: if( xmin > -r) xmin = -r; if( ymin > -r) ymin = -r;
191: if( xmax < r) xmax = r; if( ymax < r) ymax = r;
192: } else {
193: while (j != k) {
194: switch (j) {
195: case 1: if( ymax < r) ymax = r; break; /* north */
196: case 2: if( xmin > -r) xmin = -r; break; /* west */
197: case 3: if( ymin > -r) ymin = -r; break; /* south */
198: case 4: if( xmax < r) xmax = r; break; /* east */
199: }
200: j = j%4 + 1;
201: }
202: }
203: }
204: xmin += xc; ymin += yc;
205: xmax += xc; ymax += yc;
206: extreme(xmin, ymin);
207: extreme(xmax, ymax);
208: }
209:
210: quadrant(x,y)
211: double x, y;
212: {
213: if ( x>=0.0 && y> 0.0) return(1);
214: else if( x< 0.0 && y>=0.0) return(2);
215: else if( x<=0.0 && y< 0.0) return(3);
216: else if( x> 0.0 && y<=0.0) return(4);
217: else
218: { fprintf(stderr,"can't happen: x,y=%g,%g",x,y); exit(1);}
219: }
220:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.