src/meta/plotin.c

#ifndef lint
static const char       RCSid[] = "$Id: plotin.c,v 1.1 2003/02/22 02:07:26 greg Exp $";
#endif
/*
 *  Program to convert plot(5) files to metafiles
 *
 *  cc -o plotin plotin.c primout.o mfio.o syscalls.o misc.o -lm
 *
 *     5/20/85
 */

#include  <string.h>

#include  "meta.h"
#include  "plot.h"

#define  getsi(f, m)  ICONV(geti(f)-(m), size)


char  *progname;

static int  xmin = 0, ymin = 0,         /* current space settings */
            size =  XYSIZE;

static int  curx = -1,          /* current position */
            cury = -1;

static short  curmod = 0;       /* current line drawing mode */

static void convert(FILE  *infp);
static int geti(FILE  *fp);
static int quadr(int x, int y, int xp, int yp);
static void step(int d);

static void linemod(char  s[]);
static void erase(void);
static void space(int  xmn, int ymn, int xmx, int ymx);
static void move(int  x, int  y);
static void cont(int  x, int  y);
static void line(int  x0, int y0, int x1, int y1);
static void label(register char  *s);
static void point(int  x, int  y);
static void arc(int x, int y, int x0, int y0, int x1, int y1);
static void circle(int x, int y, int r);


int
main(
        int  argc,
        char  **argv
)
{
 FILE  *fp;

 progname = *argv++;
 argc--;

 while (argc && **argv == '-')  {
    switch (*(*argv+1))  {
       default:
          error(WARNING, "unknown option");
          break;
       }
    argv++;
    argc--;
    }

 if (argc)
    while (argc)  {
          fp = efopen(*argv, "r");
          convert(fp);
          fclose(fp);
          argv++;
          argc--;
          }
 else
    convert(stdin);

 pglob(PEOF, 0200, NULL);

 return(0);
}


void
convert(                /* convert to meta-file */
        FILE  *infp
)
{
    char  *fgets(), sbuf[BUFSIZ];
    int  command;
    int  a1, a2, a3, a4, a5, a6;

    while ((command = getc(infp)) != EOF)
        switch (command) {
            case 'm':
                a1 = getsi(infp, xmin);
                a2 = getsi(infp, ymin);
                move(a1, a2);
                break;
            case 'n':
                a1 = getsi(infp, xmin);
                a2 = getsi(infp, ymin);
                cont(a1, a2);
                break;
            case 'p':
                a1 = getsi(infp, xmin);
                a2 = getsi(infp, ymin);
                point(a1, a2);
                break;
            case 'l':
                a1 = getsi(infp, xmin);
                a2 = getsi(infp, ymin);
                a3 = getsi(infp, xmin);
                a4 = getsi(infp, ymin);
                line(a1, a2, a3, a4);
                break;
            case 't':
                fgets(sbuf, sizeof(sbuf), infp);
                sbuf[strlen(sbuf)-1] = '\0';
                label(sbuf);
                break;
            case 'a':
                a1 = getsi(infp, xmin);
                a2 = getsi(infp, ymin);
                a3 = getsi(infp, xmin);
                a4 = getsi(infp, ymin);
                a5 = getsi(infp, xmin);
                a6 = getsi(infp, ymin);
                arc(a1, a2, a3, a4, a5, a6);
                break;
            case 'c':
                a1 = getsi(infp, xmin);
                a2 = getsi(infp, ymin);
                a3 = getsi(infp, 0);
                circle(a1, a2, a3);
                break;
            case 'e':
                erase();
                break;
            case 'f':
                fgets(sbuf, sizeof(sbuf), infp);
                linemod(sbuf);
                break;
            case 's':
                a1 = geti(infp);
                a2 = geti(infp);
                a3 = geti(infp);
                a4 = geti(infp);
                space(a1, a2, a3, a4);
                break;
            default:
                error(USER, "unknown command in convert");
                break;
        }
}


int
geti(           /* get two-byte integer from file */
        register FILE  *fp
)
{
    register int  i;

    i = getc(fp);
    i |= getc(fp) << 8;
    if (i & 0100000)
        i |= ~0177777;          /* manual sign extend */
    if (feof(fp))
        error(USER, "unexpected end of file in geti");
    
    return(i);
}


void
move(                   /* move to new position */
        register int  x,
        register int  y
)
{
    curx = x;
    cury = y;
}


void
cont(                   /* draw line to point */
        register int  x,
        register int  y
)
{
    plseg(curmod, curx, cury, x, y);
    curx = x;
    cury = y;
}


void
point(                  /* draw a point */
        register int  x,
        register int  y
)
{
    plseg(0, x, y, x, y);
    curx = x;
    cury = y;
}


void
line(           /* draw a line segment */
        int  x0,
        int y0,
        int x1,
        int y1
)
{
    move(x0, y0);
    cont(x1, y1);
}


void
label(                  /* print a label */
        register char  *s
)
{
    pprim(PMSTR, 0, curx, cury, curx, cury, s);
}


static int del = 100;

void
step(
        int d
)
{
        del = d;
}

void
arc(
        int x,
        int y,
        int x0,
        int y0,
        int x1,
        int y1
)
{
        double pc;
        double sqrt();
        int flg,m,xc,yc,xs,ys,qs,qf;
        float dx,dy,r;
        char use;
        dx = x-x0;
        dy = y-y0;
        r = dx*dx+dy*dy;
        pc = r;
        pc = sqrt(pc);
        flg = pc/4;
        if(flg == 0)step(1);
        else if(flg < del)step(flg);
        xc = xs = x0;
        yc = ys = y0;
        move(xs,ys);
        if(x0 == x1 && y0 == y1)flg=0;
        else flg=1;
        qs = quadr(x,y,x0,y0);
        qf = quadr(x,y,x1,y1);
        if(abs(x-x1) < abs(y-y1)){
                use = 'x';
                if(qs == 2 || qs ==3)m = -1;
                else m=1;
        }
        else {
                use = 'y';
                if(qs > 2)m= -1;
                else m= 1;
        }
        while(1){
                switch(use){
                case 'x':       
                        if(qs == 2 || qs == 3)yc -= del;
                        else yc += del;
                        dy = yc-y;
                        pc = r-dy*dy;
                        xc = m*sqrt(pc)+x;
                        if((x < xs && x >= xc) || ( x > xs && x <= xc) ||
                            (y < ys && y >= yc) || ( y > ys && y <=  yc) )
                        {
                                if(++qs > 4)qs=1;
                                if(qs == 2 || qs == 3)m= -1;
                                else m=1;
                                flg=1;
                        }
                        cont(xc,yc);
                        xs = xc; 
                        ys = yc;
                        if(qs == qf && flg == 1)
                                switch(qf){
                                case 3:
                                case 4: 
                                        if(xs >= x1)return;
                                        continue;
                                case 1:
                                case 2:
                                        if(xs <= x1)return;
                                }
                        continue;
                case 'y':       
                        if(qs > 2)xc += del;
                        else xc -= del;
                        dx = xc-x;
                        pc = r-dx*dx;
                        yc = m*sqrt(pc)+y;
                        if((x < xs && x >= xc) || ( x > xs && x <= xc ) ||
                            (y < ys && y >= yc) || (y > ys && y <= yc) )
                        {
                                if(++qs > 4)qs=1;
                                if(qs > 2)m = -1;
                                else m = 1;
                                flg=1;
                        }
                        cont(xc,yc);
                        xs = xc; 
                        ys = yc;
                        if(qs == qf && flg == 1)
                                switch(qs){
                                case 1:
                                case 4:
                                        if(ys >= y1)return;
                                        continue;
                                case 2:
                                case 3:
                                        if(ys <= y1)return;
                                }
                }
        }
}

int
quadr(
        int x,
        int y,
        int xp,
        int yp
)
{
        if(x < xp)
                if(y <= yp)return(1);
                else return(4);
        else if(x > xp)
                if(y < yp)return(2);
                else return(3);
        else if(y < yp)return(2);
        else return(4);
}


void
circle(
        int x,
        int y,
        int r
)
{
        arc(x,y,x+r,y,x+r,y);
}


void
erase(void)                             /* erase plot */
{
    pglob(PEOP, 0200, NULL);
}


void
linemod(                /* set line mode according to s */
        char  s[]
)
{
    switch (s[2]) {
        case 'l':               /* solid */
            curmod = 0;
            break;
        case 't':               /* dotted */
            curmod = 1;
            break;
        case 'n':               /* long dashed */
            curmod = 2;
            break;
        case 'o':               /* short dashed (dot dashed) */
            curmod = 3;
            break;
        default:
            error(WARNING, "unknown line mode in linemod");
            break;
    }
}


void
space(  /* change space */
        int  xmn,
        int ymn,
        int xmx,
        int ymx
)
{
    if (xmn >= xmx || ymn >= ymx)
        error(USER, "illegal space specification in space");
    
    xmin = xmn;
    ymin = ymn;
    size = min(xmx-xmn, ymx-ymn);
}
Revision:	1.2
Committed:	Sat Nov 15 02:13:37 2003 UTC (20 years, 5 months ago) by schorsch
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4, rad5R2, rad4R2P2, rad5R0, rad5R1, rad3R7P2, rad3R7P1, rad4R2, rad4R1, rad4R0, rad3R6, rad3R6P1, rad3R8, rad3R9, rad4R2P1, rad5R3, HEAD
Changes since 1.1:	+104 -81 lines
Log Message:	Continued ANSIfication, and reduced other compile warnings.
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	schorsch	1.2	static const char RCSid[] = "$Id: plotin.c,v 1.1 2003/02/22 02:07:26 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* Program to convert plot(5) files to metafiles
6			*
7			* cc -o plotin plotin.c primout.o mfio.o syscalls.o misc.o -lm
8			*
9			* 5/20/85
10			*/
11
12	schorsch	1.2	#include <string.h>
13
14	greg	1.1	#include "meta.h"
15	schorsch	1.2	#include "plot.h"
16	greg	1.1
17			#define getsi(f, m) ICONV(geti(f)-(m), size)
18
19
20
21			char *progname;
22
23			static int xmin = 0, ymin = 0, /* current space settings */
24			size = XYSIZE;
25
26			static int curx = -1, /* current position */
27			cury = -1;
28
29			static short curmod = 0; /* current line drawing mode */
30
31	schorsch	1.2	static void convert(FILE *infp);
32			static int geti(FILE *fp);
33			static int quadr(int x, int y, int xp, int yp);
34			static void step(int d);
35
36			static void linemod(char s[]);
37			static void erase(void);
38			static void space(int xmn, int ymn, int xmx, int ymx);
39			static void move(int x, int y);
40			static void cont(int x, int y);
41			static void line(int x0, int y0, int x1, int y1);
42			static void label(register char *s);
43			static void point(int x, int y);
44			static void arc(int x, int y, int x0, int y0, int x1, int y1);
45			static void circle(int x, int y, int r);
46	greg	1.1
47
48	schorsch	1.2	int
49			main(
50			int argc,
51			char **argv
52			)
53	greg	1.1	{
54			FILE *fp;
55
56			progname = *argv++;
57			argc--;
58
59			while (argc && **argv == '-') {
60			switch ((argv+1)) {
61			default:
62			error(WARNING, "unknown option");
63			break;
64			}
65			argv++;
66			argc--;
67			}
68
69			if (argc)
70			while (argc) {
71			fp = efopen(*argv, "r");
72			convert(fp);
73			fclose(fp);
74			argv++;
75			argc--;
76			}
77			else
78			convert(stdin);
79
80			pglob(PEOF, 0200, NULL);
81
82			return(0);
83	schorsch	1.2	}
84	greg	1.1
85
86
87
88	schorsch	1.2	void
89			convert( /* convert to meta-file */
90			FILE *infp
91			)
92	greg	1.1	{
93			char *fgets(), sbuf[BUFSIZ];
94			int command;
95			int a1, a2, a3, a4, a5, a6;
96
97			while ((command = getc(infp)) != EOF)
98			switch (command) {
99			case 'm':
100			a1 = getsi(infp, xmin);
101			a2 = getsi(infp, ymin);
102			move(a1, a2);
103			break;
104			case 'n':
105			a1 = getsi(infp, xmin);
106			a2 = getsi(infp, ymin);
107			cont(a1, a2);
108			break;
109			case 'p':
110			a1 = getsi(infp, xmin);
111			a2 = getsi(infp, ymin);
112			point(a1, a2);
113			break;
114			case 'l':
115			a1 = getsi(infp, xmin);
116			a2 = getsi(infp, ymin);
117			a3 = getsi(infp, xmin);
118			a4 = getsi(infp, ymin);
119			line(a1, a2, a3, a4);
120			break;
121			case 't':
122			fgets(sbuf, sizeof(sbuf), infp);
123			sbuf[strlen(sbuf)-1] = '\0';
124			label(sbuf);
125			break;
126			case 'a':
127			a1 = getsi(infp, xmin);
128			a2 = getsi(infp, ymin);
129			a3 = getsi(infp, xmin);
130			a4 = getsi(infp, ymin);
131			a5 = getsi(infp, xmin);
132			a6 = getsi(infp, ymin);
133			arc(a1, a2, a3, a4, a5, a6);
134			break;
135			case 'c':
136			a1 = getsi(infp, xmin);
137			a2 = getsi(infp, ymin);
138			a3 = getsi(infp, 0);
139			circle(a1, a2, a3);
140			break;
141			case 'e':
142			erase();
143			break;
144			case 'f':
145			fgets(sbuf, sizeof(sbuf), infp);
146			linemod(sbuf);
147			break;
148			case 's':
149			a1 = geti(infp);
150			a2 = geti(infp);
151			a3 = geti(infp);
152			a4 = geti(infp);
153			space(a1, a2, a3, a4);
154			break;
155			default:
156			error(USER, "unknown command in convert");
157			break;
158			}
159			}
160
161
162
163
164			int
165	schorsch	1.2	geti( /* get two-byte integer from file */
166			register FILE *fp
167			)
168	greg	1.1	{
169			register int i;
170
171			i = getc(fp);
172			i \|= getc(fp) << 8;
173			if (i & 0100000)
174			i \|= ~0177777; /* manual sign extend */
175			if (feof(fp))
176			error(USER, "unexpected end of file in geti");
177
178			return(i);
179			}
180
181
182
183	schorsch	1.2	void
184			move( /* move to new position */
185			register int x,
186			register int y
187			)
188	greg	1.1	{
189			curx = x;
190			cury = y;
191			}
192
193
194
195	schorsch	1.2	void
196			cont( /* draw line to point */
197			register int x,
198			register int y
199			)
200	greg	1.1	{
201			plseg(curmod, curx, cury, x, y);
202			curx = x;
203			cury = y;
204			}
205
206
207	schorsch	1.2	void
208			point( /* draw a point */
209			register int x,
210			register int y
211			)
212	greg	1.1	{
213			plseg(0, x, y, x, y);
214			curx = x;
215			cury = y;
216			}
217
218
219
220	schorsch	1.2	void
221			line( /* draw a line segment */
222			int x0,
223			int y0,
224			int x1,
225			int y1
226			)
227	greg	1.1	{
228			move(x0, y0);
229			cont(x1, y1);
230			}
231
232
233	schorsch	1.2	void
234			label( /* print a label */
235			register char *s
236			)
237	greg	1.1	{
238			pprim(PMSTR, 0, curx, cury, curx, cury, s);
239			}
240
241
242
243	schorsch	1.2	static int del = 100;
244	greg	1.1
245	schorsch	1.2	void
246			step(
247			int d
248			)
249			{
250	greg	1.1	del = d;
251			}
252	schorsch	1.2
253			void
254			arc(
255			int x,
256			int y,
257			int x0,
258			int y0,
259			int x1,
260			int y1
261			)
262			{
263	greg	1.1	double pc;
264			double sqrt();
265			int flg,m,xc,yc,xs,ys,qs,qf;
266			float dx,dy,r;
267			char use;
268			dx = x-x0;
269			dy = y-y0;
270			r = dxdx+dydy;
271			pc = r;
272			pc = sqrt(pc);
273			flg = pc/4;
274			if(flg == 0)step(1);
275			else if(flg < del)step(flg);
276			xc = xs = x0;
277			yc = ys = y0;
278			move(xs,ys);
279			if(x0 == x1 && y0 == y1)flg=0;
280			else flg=1;
281			qs = quadr(x,y,x0,y0);
282			qf = quadr(x,y,x1,y1);
283			if(abs(x-x1) < abs(y-y1)){
284			use = 'x';
285			if(qs == 2 \|\| qs ==3)m = -1;
286			else m=1;
287			}
288			else {
289			use = 'y';
290			if(qs > 2)m= -1;
291			else m= 1;
292			}
293			while(1){
294			switch(use){
295			case 'x':
296			if(qs == 2 \|\| qs == 3)yc -= del;
297			else yc += del;
298			dy = yc-y;
299			pc = r-dy*dy;
300			xc = m*sqrt(pc)+x;
301			if((x < xs && x >= xc) \|\| ( x > xs && x <= xc) \|\|
302			(y < ys && y >= yc) \|\| ( y > ys && y <= yc) )
303			{
304			if(++qs > 4)qs=1;
305			if(qs == 2 \|\| qs == 3)m= -1;
306			else m=1;
307			flg=1;
308			}
309			cont(xc,yc);
310			xs = xc;
311			ys = yc;
312			if(qs == qf && flg == 1)
313			switch(qf){
314			case 3:
315			case 4:
316			if(xs >= x1)return;
317			continue;
318			case 1:
319			case 2:
320			if(xs <= x1)return;
321			}
322			continue;
323			case 'y':
324			if(qs > 2)xc += del;
325			else xc -= del;
326			dx = xc-x;
327			pc = r-dx*dx;
328			yc = m*sqrt(pc)+y;
329			if((x < xs && x >= xc) \|\| ( x > xs && x <= xc ) \|\|
330			(y < ys && y >= yc) \|\| (y > ys && y <= yc) )
331			{
332			if(++qs > 4)qs=1;
333			if(qs > 2)m = -1;
334			else m = 1;
335			flg=1;
336			}
337			cont(xc,yc);
338			xs = xc;
339			ys = yc;
340			if(qs == qf && flg == 1)
341			switch(qs){
342			case 1:
343			case 4:
344			if(ys >= y1)return;
345			continue;
346			case 2:
347			case 3:
348			if(ys <= y1)return;
349			}
350			}
351			}
352			}
353	schorsch	1.2
354			int
355			quadr(
356			int x,
357			int y,
358			int xp,
359			int yp
360			)
361			{
362	greg	1.1	if(x < xp)
363			if(y <= yp)return(1);
364			else return(4);
365			else if(x > xp)
366			if(y < yp)return(2);
367			else return(3);
368			else if(y < yp)return(2);
369			else return(4);
370			}
371
372
373	schorsch	1.2	void
374			circle(
375			int x,
376			int y,
377			int r
378			)
379			{
380	greg	1.1	arc(x,y,x+r,y,x+r,y);
381			}
382
383
384
385	schorsch	1.2	void
386			erase(void) /* erase plot */
387	greg	1.1	{
388			pglob(PEOP, 0200, NULL);
389			}
390
391
392	schorsch	1.2	void
393			linemod( /* set line mode according to s */
394			char s[]
395			)
396	greg	1.1	{
397			switch (s[2]) {
398			case 'l': /* solid */
399			curmod = 0;
400			break;
401			case 't': /* dotted */
402			curmod = 1;
403			break;
404			case 'n': /* long dashed */
405			curmod = 2;
406			break;
407			case 'o': /* short dashed (dot dashed) */
408			curmod = 3;
409			break;
410			default:
411			error(WARNING, "unknown line mode in linemod");
412			break;
413			}
414			}
415
416
417	schorsch	1.2	void
418			space( /* change space */
419			int xmn,
420			int ymn,
421			int xmx,
422			int ymx
423			)
424	greg	1.1	{
425			if (xmn >= xmx \|\| ymn >= ymx)
426			error(USER, "illegal space specification in space");
427
428			xmin = xmn;
429			ymin = ymn;
430			size = min(xmx-xmn, ymx-ymn);
431			}