![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to draw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / troff / Old|
Return to draw.c CVS log | Up to [Research Unix] / researchv10no / cmd / troff / Old |
1.1 root 1: #include <stdio.h>
2: #include <math.h>
3: #define PI 3.141592654
4: #define hmot(n) hpos += n
5: #define hgoto(n) hpos = n
6: #define vmot(n) vgoto(vpos + n)
7:
8: extern int hpos;
9: extern int vpos;
10: extern int size;
11: extern short *pstab;
12: extern int DX; /* step size in x */
13: extern int DY; /* step size in y */
14: extern int drawdot; /* character to use when drawing */
15: extern int drawsize; /* shrink point size by this facter */
16:
17: int maxdots = 32000; /* maximum number of dots in an object */
18:
19: #define sgn(n) ((n > 0) ? 1 : ((n < 0) ? -1 : 0))
20: #define abs(n) ((n) >= 0 ? (n) : -(n))
21: #define max(x,y) ((x) > (y) ? (x) : (y))
22: #define min(x,y) ((x) < (y) ? (x) : (y))
23: #define arcmove(x,y) { hgoto(x); vmot(-vpos-(y)); }
24:
25: drawline(dx, dy, s) /* draw line from here to dx, dy using s */
26: int dx, dy;
27: char *s;
28: {
29: int xd, yd;
30: float val, slope;
31: int i, numdots;
32: int dirmot, perp;
33: int motincr, perpincr;
34: int ohpos, ovpos, osize, ofont;
35: float incrway;
36:
37: osize = size;
38: setsize(t_size(pstab[osize-1] / drawsize));
39: ohpos = hpos;
40: ovpos = vpos;
41: xd = dx / DX;
42: yd = dy / DX;
43: if (xd == 0) {
44: numdots = abs (yd);
45: numdots = min(numdots, maxdots);
46: motincr = DX * sgn (yd);
47: for (i = 0; i < numdots; i++) {
48: vmot(motincr);
49: put1(drawdot);
50: }
51: vgoto(ovpos + dy);
52: setsize(osize);
53: return;
54: }
55: if (yd == 0) {
56: numdots = abs (xd);
57: motincr = DX * sgn (xd);
58: for (i = 0; i < numdots; i++) {
59: hmot(motincr);
60: put1(drawdot);
61: }
62: hgoto(ohpos + dx);
63: setsize(osize);
64: return;
65: }
66: if (abs (xd) > abs (yd)) {
67: val = slope = (float) xd/yd;
68: numdots = abs (xd);
69: numdots = min(numdots, maxdots);
70: dirmot = 'h';
71: perp = 'v';
72: motincr = DX * sgn (xd);
73: perpincr = DX * sgn (yd);
74: }
75: else {
76: val = slope = (float) yd/xd;
77: numdots = abs (yd);
78: numdots = min(numdots, maxdots);
79: dirmot = 'v';
80: perp = 'h';
81: motincr = DX * sgn (yd);
82: perpincr = DX * sgn (xd);
83: }
84: incrway = sgn ((int) slope);
85: for (i = 0; i < numdots; i++) {
86: val -= incrway;
87: if (dirmot == 'h')
88: hmot(motincr);
89: else
90: vmot(motincr);
91: if (val * slope < 0) {
92: if (perp == 'h')
93: hmot(perpincr);
94: else
95: vmot(perpincr);
96: val += slope;
97: }
98: put1(drawdot);
99: }
100: hgoto(ohpos + dx);
101: vgoto(ovpos + dy);
102: setsize(osize);
103: }
104:
105: drawwig(s) /* draw wiggly line */
106: char *s;
107: {
108: int x[50], y[50], xp, yp, pxp, pyp;
109: float t1, t2, t3, w;
110: int i, j, numdots, N;
111: int osize, ofont;
112: char temp[50], *p, *getstr();
113:
114: osize = size;
115: setsize(t_size(pstab[osize-1] / drawsize));
116: p = s;
117: for (N = 2; (p=getstr(p,temp)) != NULL && N < sizeof(x)/sizeof(x[0]); N++) {
118: x[N] = atoi(temp);
119: p = getstr(p, temp);
120: y[N] = atoi(temp);
121: }
122: x[0] = x[1] = hpos;
123: y[0] = y[1] = vpos;
124: for (i = 1; i < N; i++) {
125: x[i+1] += x[i];
126: y[i+1] += y[i];
127: }
128: x[N] = x[N-1];
129: y[N] = y[N-1];
130: pxp = pyp = -9999;
131: for (i = 0; i < N-1; i++) { /* interval */
132: numdots = (dist(x[i],y[i], x[i+1],y[i+1]) + dist(x[i+1],y[i+1], x[i+2],y[i+2])) / 2;
133: numdots /= DX;
134: numdots = min(numdots, maxdots);
135: for (j = 0; j < numdots; j++) { /* points within */
136: w = (float) j / numdots;
137: t1 = 0.5 * w * w;
138: w = w - 0.5;
139: t2 = 0.75 - w * w;
140: w = w - 0.5;
141: t3 = 0.5 * w * w;
142: xp = t1 * x[i+2] + t2 * x[i+1] + t3 * x[i] + 0.5;
143: yp = t1 * y[i+2] + t2 * y[i+1] + t3 * y[i] + 0.5;
144: if (xp != pxp || yp != pyp) {
145: hgoto(xp);
146: vgoto(yp);
147: put1(drawdot);
148: pxp = xp;
149: pyp = yp;
150: }
151: }
152: }
153: setsize(osize);
154: }
155:
156: char *getstr(p, temp) /* copy next non-blank string from p to temp, update p */
157: char *p, *temp;
158: {
159: while (*p == ' ' || *p == '\t' || *p == '\n')
160: p++;
161: if (*p == '\0') {
162: temp[0] = 0;
163: return(NULL);
164: }
165: while (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\0')
166: *temp++ = *p++;
167: *temp = '\0';
168: return(p);
169: }
170:
171: drawcirc(d)
172: {
173: int xc, yc;
174:
175: xc = hpos;
176: yc = vpos;
177: conicarc(hpos + d/2, -vpos, hpos, -vpos, hpos, -vpos, d/2, d/2);
178: hgoto(xc + d); /* circle goes to right side */
179: vgoto(yc);
180: }
181:
182: dist(x1, y1, x2, y2) /* integer distance from x1,y1 to x2,y2 */
183: {
184: float dx, dy;
185:
186: dx = x2 - x1;
187: dy = y2 - y1;
188: return sqrt(dx*dx + dy*dy) + 0.5;
189: }
190:
191: drawarc(dx1, dy1, dx2, dy2)
192: {
193: int x0, y0, x2, y2, r;
194:
195: x0 = hpos + dx1; /* center */
196: y0 = vpos + dy1;
197: x2 = x0 + dx2; /* "to" */
198: y2 = y0 + dy2;
199: r = sqrt((float) dx1 * dx1 + (float) dy1 * dy1) + 0.5;
200: conicarc(x0, -y0, hpos, -vpos, x2, -y2, r, r);
201: }
202:
203: drawellip(a, b)
204: {
205: int xc, yc;
206:
207: xc = hpos;
208: yc = vpos;
209: conicarc(hpos + a/2, -vpos, hpos, -vpos, hpos, -vpos, a/2, b/2);
210: hgoto(xc + a);
211: vgoto(yc);
212: }
213:
214: #define sqr(x) (long int)(x)*(x)
215:
216: conicarc(x, y, x0, y0, x1, y1, a, b)
217: {
218: /* based on Bresenham, CACM, Feb 77, pp 102-3 */
219: /* by Chris Van Wyk */
220: /* capitalized vars are an internal reference frame */
221: long dotcount = 0;
222: int osize, ofont;
223: int xs, ys, xt, yt, Xs, Ys, qs, Xt, Yt, qt,
224: M1x, M1y, M2x, M2y, M3x, M3y,
225: Q, move, Xc, Yc;
226: int ox1, oy1;
227: long delta;
228: float xc, yc;
229: float radius, slope;
230: float xstep, ystep;
231:
232: osize = size;
233: setsize(t_size(pstab[osize-1] / drawsize));
234: ox1 = x1;
235: oy1 = y1;
236: if (a != b) /* an arc of an ellipse; internally, will still think of circle */
237: if (a > b) {
238: xstep = (float)a / b;
239: ystep = 1;
240: radius = b;
241: } else {
242: xstep = 1;
243: ystep = (float)b / a;
244: radius = a;
245: }
246: else { /* a circular arc; radius is computed from center and first point */
247: xstep = ystep = 1;
248: radius = sqrt((float)(sqr(x0 - x) + sqr(y0 - y)));
249: }
250:
251:
252: xc = x0;
253: yc = y0;
254: /* now, use start and end point locations to figure out
255: the angle at which start and end happen; use these
256: angles with known radius to figure out where start
257: and end should be
258: */
259: slope = atan2((double)(y0 - y), (double)(x0 - x) );
260: if (slope == 0.0 && x0 < x)
261: slope = 3.14159265;
262: x0 = x + radius * cos(slope) + 0.5;
263: y0 = y + radius * sin(slope) + 0.5;
264: slope = atan2((double)(y1 - y), (double)(x1 - x));
265: if (slope == 0.0 && x1 < x)
266: slope = 3.14159265;
267: x1 = x + radius * cos(slope) + 0.5;
268: y1 = y + radius * sin(slope) + 0.5;
269: /* step 2: translate to zero-centered circle */
270: xs = x0 - x;
271: ys = y0 - y;
272: xt = x1 - x;
273: yt = y1 - y;
274: /* step 3: normalize to first quadrant */
275: if (xs < 0)
276: if (ys < 0) {
277: Xs = abs(ys);
278: Ys = abs(xs);
279: qs = 3;
280: M1x = 0;
281: M1y = -1;
282: M2x = 1;
283: M2y = -1;
284: M3x = 1;
285: M3y = 0;
286: } else {
287: Xs = abs(xs);
288: Ys = abs(ys);
289: qs = 2;
290: M1x = -1;
291: M1y = 0;
292: M2x = -1;
293: M2y = -1;
294: M3x = 0;
295: M3y = -1;
296: }
297: else if (ys < 0) {
298: Xs = abs(xs);
299: Ys = abs(ys);
300: qs = 0;
301: M1x = 1;
302: M1y = 0;
303: M2x = 1;
304: M2y = 1;
305: M3x = 0;
306: M3y = 1;
307: } else {
308: Xs = abs(ys);
309: Ys = abs(xs);
310: qs = 1;
311: M1x = 0;
312: M1y = 1;
313: M2x = -1;
314: M2y = 1;
315: M3x = -1;
316: M3y = 0;
317: }
318:
319:
320: Xc = Xs;
321: Yc = Ys;
322: if (xt < 0)
323: if (yt < 0) {
324: Xt = abs(yt);
325: Yt = abs(xt);
326: qt = 3;
327: } else {
328: Xt = abs(xt);
329: Yt = abs(yt);
330: qt = 2;
331: }
332: else if (yt < 0) {
333: Xt = abs(xt);
334: Yt = abs(yt);
335: qt = 0;
336: } else {
337: Xt = abs(yt);
338: Yt = abs(xt);
339: qt = 1;
340: }
341:
342:
343: /* step 4: calculate number of quadrant crossings */
344: if (((4 + qt - qs)
345: % 4 == 0)
346: && (Xt <= Xs)
347: && (Yt >= Ys)
348: )
349: Q = 3;
350: else
351: Q = (4 + qt - qs) % 4 - 1;
352: /* step 5: calculate initial decision difference */
353: delta = sqr(Xs + 1)
354: + sqr(Ys - 1)
355: -sqr(xs)
356: -sqr(ys);
357: /* here begins the work of drawing
358: we hope it ends here too */
359: while ((Q >= 0)
360: || ((Q > -2)
361: && ((Xt > Xc)
362: && (Yt < Yc)
363: )
364: )
365: ) {
366: if (dotcount++ % DX == 0)
367: putdot((int)xc, (int)yc);
368: if (Yc < 0.5) {
369: /* reinitialize */
370: Xs = Xc = 0;
371: Ys = Yc = sqrt((float)(sqr(xs) + sqr(ys)));
372: delta = sqr(Xs + 1) + sqr(Ys - 1) - sqr(xs) - sqr(ys);
373: Q--;
374: M1x = M3x;
375: M1y = M3y;
376: {
377: int T;
378: T = M2y;
379: M2y = M2x;
380: M2x = -T;
381: T = M3y;
382: M3y = M3x;
383: M3x = -T;
384: }
385: } else {
386: if (delta <= 0)
387: if (2 * delta + 2 * Yc - 1 <= 0)
388: move = 1;
389: else
390: move = 2;
391: else if (2 * delta - 2 * Xc - 1 <= 0)
392: move = 2;
393: else
394: move = 3;
395: switch (move) {
396: case 1:
397: Xc++;
398: delta += 2 * Xc + 1;
399: xc += M1x * xstep;
400: yc += M1y * ystep;
401: break;
402: case 2:
403: Xc++;
404: Yc--;
405: delta += 2 * Xc - 2 * Yc + 2;
406: xc += M2x * xstep;
407: yc += M2y * ystep;
408: break;
409: case 3:
410: Yc--;
411: delta -= 2 * Yc + 1;
412: xc += M3x * xstep;
413: yc += M3y * ystep;
414: break;
415: }
416: }
417: }
418:
419:
420: setsize(osize);
421: drawline((int)xc-ox1,(int)yc-oy1,".");
422: }
423:
424: putdot(x, y)
425: {
426: arcmove(x, y);
427: put1(drawdot);
428: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.