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