src/meta/rplot.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 *   Plotting routines for meta-files to raster files
 */


#include  "meta.h"

#include  "plot.h"

#include  "rast.h"


int  minwidth = 0;

static PLIST  inqueue = {NULL, NULL};

static PRIMITIVE  nextp;


plot(infp)              /* plot meta-file */

FILE  *infp;

{

    do {
        readp(&nextp, infp);
        initplot();
        while (inqueue.ptop != NULL || isprim(nextp.com))
            plotblock(infp);
        doglobal(&nextp);
        fargs(&nextp);
    } while (nextp.com != PEOF);

}


initplot()                      /* initialize this plot */

{
    int  i;

    thispage();
                                        /* allocate block */
    if (outblock.xright <= 0) {
        for (i = 0; i < NUMSCANS; i++)
            if ((outblock.cols[i] = (unsigned char *)malloc(dxsize)) == NULL)
                error(SYSTEM, "out of memory in initplot");
    }
    outblock.xleft = 0;
    outblock.xright = dxsize-1;
    if (ydown) {
        outblock.ytop = dysize+NUMSCANS-1;
        outblock.ybot = dysize;
    } else {
        outblock.ytop = -1;
        outblock.ybot = -NUMSCANS;
    }

}


doglobal(g)                     /* execute a global command */

PRIMITIVE  *g;

{
    char  c;
    int  tty;

    switch (g->com) {

        case PEOF:
            break;

        case PEOP:
            if (g->arg0 & 0200)         /* advance page */
                nextpage();
            else
                error(USER, "illegal continue direction in doglobal");
            break;

        case PSET:
            set(g->arg0, g->args);
            break;

        case PUNSET:
            unset(g->arg0);
            break;

        case PRESET:
            reset(g->arg0);
            break;

        default:
            sprintf(errmsg, "unknown command '%c' in doglobal", g->com);
            error(WARNING, errmsg);
            break;
        }

}


plotblock(infp)                 /* plot next block */

FILE  *infp;

{
    PLIST  lastinq;
    register PRIMITIVE  *p;

                                        /* clear block */
    nextblock();
                                        /* plot from queue */
    lastinq.ptop = inqueue.ptop;
    lastinq.pbot = inqueue.pbot;
    inqueue.ptop = inqueue.pbot = NULL;
    while ((p = pop(&lastinq)) != NULL) {
        doprim(p);
        pfree(p);
    }
                                        /* plot from file */
    while (isprim(nextp.com) && inthis(&nextp)) {
        doprim(&nextp);
        fargs(&nextp);
        readp(&nextp, infp);
    }
                                        /* print out block */
    outputblock();

}


nextblock()             /* prepare next block */

{
    register int  i, n;
    register unsigned char  *colp;
                                                /* clear block */
    for (i = 0; i < NUMSCANS; i++) {
        colp = outblock.cols[i];
        n = dxsize;
        while (n--)
            *colp++ = IWHT<<3 | IWHT;
    }
                                                /* advance */
    if (ydown) {
        outblock.ytop -= NUMSCANS;
        outblock.ybot -= NUMSCANS;
    } else {
        outblock.ytop += NUMSCANS;
        outblock.ybot += NUMSCANS;
    }
    return;
memerr:
    error(SYSTEM, "out of memory in nextblock");
}


outputblock()           /* output block to printer */
{
    register int  i, n;
    register unsigned char  *colp;

    for (i = 0; i < NUMSCANS; i++) {            /* overlay blocks */

        n = outblock.xright - outblock.xleft + 1;
        colp = outblock.cols[i] + outblock.xleft;
        while (n--) {
            *colp = *colp>>3 & *colp;
            colp++;
        }
    }
    printblock();                       /* print block */
}


doprim(p)               /* plot primitive */

register PRIMITIVE  *p;

{
    register PRIMITIVE  *newp;
    
    switch (p->com) {

        case PLSEG:
            plotlseg(p);
            break;

        case PRFILL:
            fill((p->arg0&0103) | (pati[(p->arg0>>2)&03]<<2),
                        CONV(p->xy[XMN],dxsize),CONV(p->xy[YMN],dysize),
                        CONV(p->xy[XMX],dxsize)+(p->arg0&0100?-1:0),
                        CONV(p->xy[YMX],dysize)+(p->arg0&0100?-1:0));
            break;

        case PTFILL:
            tfill(p);
            break;
                
        default:
            sprintf(errmsg, "unknown command '%c' in doprim", p->com);
            error(WARNING, errmsg);
            return;
    }

    if (innext(p)) {                    /* save for next time */
        if ((newp = palloc()) == NULL)
            error(SYSTEM, "memory limit exceeded in doprim");
        mcopy((char *)newp, (char *)p, sizeof(PRIMITIVE));
        newp->args = savestr(p->args);
        add(newp, &inqueue);
    }
        
}


plotlseg(p)             /* plot a line segment */

register PRIMITIVE  *p;

{
    register int  ti;
    long  run2 = 0L, rise2 = 0L;
    int  x, y, run, rise, xstop, ystop, hrad, vrad, lpat, n;

                                                /* compute line pattern */
    lpat = (p->arg0 >> 2) & 014;
    if (p->arg0 & 0100 && lpat != 0)
        lpat += 014;
    lpat |= p->arg0 & 03;

    ti = (p->arg0 >> 2) & 03;                   /* compute line radius */
    ti = WIDTH(ti) / 2;
    hrad = CONV(ti, dxsize);
    vrad = CONV(ti, dysize);
    if (hrad < minwidth)
        hrad = minwidth;
    if (vrad < minwidth)
        vrad = minwidth;

    x = CONV(p->xy[XMX], dxsize);               /* start at top */
    y = CONV(p->xy[YMX], dysize);
    run = CONV(p->xy[XMN], dxsize) - x;
    rise = CONV(p->xy[YMN], dysize) - y;

    if (p->arg0 & 0100)                         /* slope < 0; reverse x */
        x -= (run = -run);

    xstop = x + run;                            /* compute end point */
    ystop = y + rise;

    if ((ti = outblock.ytop+vrad+1-y) < 0) {    /* adjust to top of block */
        run2 = rise2 = (long)ti*run;
        x += rise2/rise;
        y += ti;
    }

    if ((ti = outblock.ybot-vrad-1-ystop) > 0) {        /* adjust to bottom of block */
        xstop += (long)ti*run/rise;
        ystop += ti;
    }

    if (abs(run) > -rise)
        n = abs(xstop - x);
    else
        n = y - ystop;
    
    paintline(x, y, run, rise, hrad, vrad, lpat, run2, rise2, n);

}


/*
 *  This routine paints a line with calls to fill().  The line can
 *    start and end at arbitrary points on a longer line segment.
 */

paintline(x, y, run, rise, hrad, vrad, lpat, run2, rise2, n)

register int  x, y;
int  run, rise;
int  hrad, vrad;
int  lpat;
long  run2, rise2;
int  n;

{
    int  xstep, ystep;

    if (run >= 0)
        xstep = 1;
    else {
        xstep = -1;
        run = -run;
    }
    if (rise >= 0)
        ystep = 1;
    else {
        ystep = -1;
        rise = -rise;
    }
    if (n < 0)
        n = max(run, rise);

    if (run > rise)
        while (n >= 0)
            if (run2 >= rise2) {
                fill(lpat, x-hrad, y-vrad, x+hrad, y+vrad);
                n--;
                x += xstep;
                rise2 += rise;
            } else {
                y += ystep;
                run2 += run;
            }
    else
        while (n >= 0)
            if (rise2 >= run2) {
                fill(lpat, x-hrad, y-vrad, x+hrad, y+vrad);
                n--;
                y += ystep;
                run2 += run;
            } else {
                x += xstep;
                rise2 += rise;
            }

}


tfill(p)                        /* fill a triangle */
register PRIMITIVE  *p;
{
    register int  x, txmin, txmax;      
    int  xmn, ymn, tpat;
    long  xsz, ysz;

    xmn = CONV(p->xy[XMN], dxsize);
    xsz = CONV(p->xy[XMX], dxsize) - xmn;
    ymn = CONV(p->xy[YMN], dysize);
    ysz = CONV(p->xy[YMX], dysize) - ymn;
    if (xsz <= 0 || ysz <= 0)
        return; 
    txmin = (outblock.ybot - ymn)*xsz/ysz;
    txmax = (outblock.ytop - ymn)*xsz/ysz;
    if (p->arg0 & 020) {                                /* up or down */
        x = txmin;
        txmin = xsz - txmax;
        txmax = xsz - x;
    }
    txmin += xmn;
    txmax += xmn;
    txmin = max(txmin, xmn);
    txmax = min(txmax, xmn + (int)xsz - 1);
    tpat = (p->arg0&0103) | (pati[(p->arg0>>2)&03]<<2);

    if (p->arg0 & 040) {                                /* left or down */
        fill(tpat, xmn, ymn, txmin - 1, ymn + (int)ysz - 1);
        for (x = txmin; x <= txmax; x++)
            if (p->arg0 & 020)                  /* down */
                fill(tpat, x, ymn, x, (int)(ysz-(x-xmn)*ysz/xsz) + ymn - 1);
            else                                /* left */
                fill(tpat, x, (int)((x-xmn)*ysz/xsz) + ymn, x, ymn + (int)ysz - 1);
    } else {                                            /* right or up */
        for (x = txmin; x <= txmax; x++)
            if (p->arg0 & 020)                  /* up */
                fill(tpat, x, (int)(ysz-(x-xmn)*ysz/xsz) + ymn, x, ymn + (int)ysz - 1);
            else                                /* right */
                fill(tpat, x, ymn, x, (int)((x-xmn)*ysz/xsz) + ymn - 1);
        fill(tpat, txmax + 1, ymn, xmn + (int)xsz - 1, ymn + (int)ysz - 1);
    }
}


fill(attrib, xmin, ymin, xmax, ymax)    /* fill rectangle with attribute */

register int  attrib;
int  xmin, ymin, xmax, ymax;

{
    register int  i, j;

    xmin = max(xmin, outblock.xleft);
    ymin = max(ymin, outblock.ybot);
    xmax = min(xmax, outblock.xright);
    ymax = min(ymax, outblock.ytop);

    for (j = ymin; j <= ymax; j++)
        for (i = xmin; i <= xmax; i++)
            if (pattern[(attrib&074)>>2]
                        [(j>>3)%(PATSIZE>>3)][i%PATSIZE] & 1<<(j&07))

                if (attrib & 0100) {
                    pixtog(i,j,attrib&03);
                } else {
                    pixmix(i,j,attrib&03);
                }

}
Revision:	1.1
Committed:	Sat Feb 22 02:07:26 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R5
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2			static const char RCSid[] = "$Id$";
3			#endif
4			/*
5			* Plotting routines for meta-files to raster files
6			*/
7
8
9			#include "meta.h"
10
11			#include "plot.h"
12
13			#include "rast.h"
14
15
16			int minwidth = 0;
17
18			static PLIST inqueue = {NULL, NULL};
19
20			static PRIMITIVE nextp;
21
22
23			plot(infp) /* plot meta-file */
24
25			FILE *infp;
26
27			{
28
29			do {
30			readp(&nextp, infp);
31			initplot();
32			while (inqueue.ptop != NULL \|\| isprim(nextp.com))
33			plotblock(infp);
34			doglobal(&nextp);
35			fargs(&nextp);
36			} while (nextp.com != PEOF);
37
38			}
39
40
41
42
43
44			initplot() /* initialize this plot */
45
46			{
47			int i;
48
49			thispage();
50			/* allocate block */
51			if (outblock.xright <= 0) {
52			for (i = 0; i < NUMSCANS; i++)
53			if ((outblock.cols[i] = (unsigned char *)malloc(dxsize)) == NULL)
54			error(SYSTEM, "out of memory in initplot");
55			}
56			outblock.xleft = 0;
57			outblock.xright = dxsize-1;
58			if (ydown) {
59			outblock.ytop = dysize+NUMSCANS-1;
60			outblock.ybot = dysize;
61			} else {
62			outblock.ytop = -1;
63			outblock.ybot = -NUMSCANS;
64			}
65
66			}
67
68
69
70
71
72			doglobal(g) /* execute a global command */
73
74			PRIMITIVE *g;
75
76			{
77			char c;
78			int tty;
79
80			switch (g->com) {
81
82			case PEOF:
83			break;
84
85			case PEOP:
86			if (g->arg0 & 0200) /* advance page */
87			nextpage();
88			else
89			error(USER, "illegal continue direction in doglobal");
90			break;
91
92			case PSET:
93			set(g->arg0, g->args);
94			break;
95
96			case PUNSET:
97			unset(g->arg0);
98			break;
99
100			case PRESET:
101			reset(g->arg0);
102			break;
103
104			default:
105			sprintf(errmsg, "unknown command '%c' in doglobal", g->com);
106			error(WARNING, errmsg);
107			break;
108			}
109
110			}
111
112
113
114
115
116			plotblock(infp) /* plot next block */
117
118			FILE *infp;
119
120			{
121			PLIST lastinq;
122			register PRIMITIVE *p;
123
124			/* clear block */
125			nextblock();
126			/* plot from queue */
127			lastinq.ptop = inqueue.ptop;
128			lastinq.pbot = inqueue.pbot;
129			inqueue.ptop = inqueue.pbot = NULL;
130			while ((p = pop(&lastinq)) != NULL) {
131			doprim(p);
132			pfree(p);
133			}
134			/* plot from file */
135			while (isprim(nextp.com) && inthis(&nextp)) {
136			doprim(&nextp);
137			fargs(&nextp);
138			readp(&nextp, infp);
139			}
140			/* print out block */
141			outputblock();
142
143			}
144
145
146
147
148
149			nextblock() /* prepare next block */
150
151			{
152			register int i, n;
153			register unsigned char *colp;
154			/* clear block */
155			for (i = 0; i < NUMSCANS; i++) {
156			colp = outblock.cols[i];
157			n = dxsize;
158			while (n--)
159			*colp++ = IWHT<<3 \| IWHT;
160			}
161			/* advance */
162			if (ydown) {
163			outblock.ytop -= NUMSCANS;
164			outblock.ybot -= NUMSCANS;
165			} else {
166			outblock.ytop += NUMSCANS;
167			outblock.ybot += NUMSCANS;
168			}
169			return;
170			memerr:
171			error(SYSTEM, "out of memory in nextblock");
172			}
173
174
175
176			outputblock() /* output block to printer */
177			{
178			register int i, n;
179			register unsigned char *colp;
180
181			for (i = 0; i < NUMSCANS; i++) { /* overlay blocks */
182
183			n = outblock.xright - outblock.xleft + 1;
184			colp = outblock.cols[i] + outblock.xleft;
185			while (n--) {
186			colp = colp>>3 & *colp;
187			colp++;
188			}
189			}
190			printblock(); /* print block */
191			}
192
193
194
195			doprim(p) /* plot primitive */
196
197			register PRIMITIVE *p;
198
199			{
200			register PRIMITIVE *newp;
201
202			switch (p->com) {
203
204			case PLSEG:
205			plotlseg(p);
206			break;
207
208			case PRFILL:
209			fill((p->arg0&0103) \| (pati[(p->arg0>>2)&03]<<2),
210			CONV(p->xy[XMN],dxsize),CONV(p->xy[YMN],dysize),
211			CONV(p->xy[XMX],dxsize)+(p->arg0&0100?-1:0),
212			CONV(p->xy[YMX],dysize)+(p->arg0&0100?-1:0));
213			break;
214
215			case PTFILL:
216			tfill(p);
217			break;
218
219			default:
220			sprintf(errmsg, "unknown command '%c' in doprim", p->com);
221			error(WARNING, errmsg);
222			return;
223			}
224
225			if (innext(p)) { /* save for next time */
226			if ((newp = palloc()) == NULL)
227			error(SYSTEM, "memory limit exceeded in doprim");
228			mcopy((char )newp, (char )p, sizeof(PRIMITIVE));
229			newp->args = savestr(p->args);
230			add(newp, &inqueue);
231			}
232
233			}
234
235
236
237
238
239			plotlseg(p) /* plot a line segment */
240
241			register PRIMITIVE *p;
242
243			{
244			register int ti;
245			long run2 = 0L, rise2 = 0L;
246			int x, y, run, rise, xstop, ystop, hrad, vrad, lpat, n;
247
248			/* compute line pattern */
249			lpat = (p->arg0 >> 2) & 014;
250			if (p->arg0 & 0100 && lpat != 0)
251			lpat += 014;
252			lpat \|= p->arg0 & 03;
253
254			ti = (p->arg0 >> 2) & 03; /* compute line radius */
255			ti = WIDTH(ti) / 2;
256			hrad = CONV(ti, dxsize);
257			vrad = CONV(ti, dysize);
258			if (hrad < minwidth)
259			hrad = minwidth;
260			if (vrad < minwidth)
261			vrad = minwidth;
262
263			x = CONV(p->xy[XMX], dxsize); /* start at top */
264			y = CONV(p->xy[YMX], dysize);
265			run = CONV(p->xy[XMN], dxsize) - x;
266			rise = CONV(p->xy[YMN], dysize) - y;
267
268			if (p->arg0 & 0100) /* slope < 0; reverse x */
269			x -= (run = -run);
270
271			xstop = x + run; /* compute end point */
272			ystop = y + rise;
273
274			if ((ti = outblock.ytop+vrad+1-y) < 0) { /* adjust to top of block */
275			run2 = rise2 = (long)ti*run;
276			x += rise2/rise;
277			y += ti;
278			}
279
280			if ((ti = outblock.ybot-vrad-1-ystop) > 0) { /* adjust to bottom of block */
281			xstop += (long)ti*run/rise;
282			ystop += ti;
283			}
284
285			if (abs(run) > -rise)
286			n = abs(xstop - x);
287			else
288			n = y - ystop;
289
290			paintline(x, y, run, rise, hrad, vrad, lpat, run2, rise2, n);
291
292			}
293
294
295
296			/*
297			* This routine paints a line with calls to fill(). The line can
298			* start and end at arbitrary points on a longer line segment.
299			*/
300
301			paintline(x, y, run, rise, hrad, vrad, lpat, run2, rise2, n)
302
303			register int x, y;
304			int run, rise;
305			int hrad, vrad;
306			int lpat;
307			long run2, rise2;
308			int n;
309
310			{
311			int xstep, ystep;
312
313			if (run >= 0)
314			xstep = 1;
315			else {
316			xstep = -1;
317			run = -run;
318			}
319			if (rise >= 0)
320			ystep = 1;
321			else {
322			ystep = -1;
323			rise = -rise;
324			}
325			if (n < 0)
326			n = max(run, rise);
327
328			if (run > rise)
329			while (n >= 0)
330			if (run2 >= rise2) {
331			fill(lpat, x-hrad, y-vrad, x+hrad, y+vrad);
332			n--;
333			x += xstep;
334			rise2 += rise;
335			} else {
336			y += ystep;
337			run2 += run;
338			}
339			else
340			while (n >= 0)
341			if (rise2 >= run2) {
342			fill(lpat, x-hrad, y-vrad, x+hrad, y+vrad);
343			n--;
344			y += ystep;
345			run2 += run;
346			} else {
347			x += xstep;
348			rise2 += rise;
349			}
350
351			}
352
353
354
355			tfill(p) /* fill a triangle */
356			register PRIMITIVE *p;
357			{
358			register int x, txmin, txmax;
359			int xmn, ymn, tpat;
360			long xsz, ysz;
361
362			xmn = CONV(p->xy[XMN], dxsize);
363			xsz = CONV(p->xy[XMX], dxsize) - xmn;
364			ymn = CONV(p->xy[YMN], dysize);
365			ysz = CONV(p->xy[YMX], dysize) - ymn;
366			if (xsz <= 0 \|\| ysz <= 0)
367			return;
368			txmin = (outblock.ybot - ymn)*xsz/ysz;
369			txmax = (outblock.ytop - ymn)*xsz/ysz;
370			if (p->arg0 & 020) { /* up or down */
371			x = txmin;
372			txmin = xsz - txmax;
373			txmax = xsz - x;
374			}
375			txmin += xmn;
376			txmax += xmn;
377			txmin = max(txmin, xmn);
378			txmax = min(txmax, xmn + (int)xsz - 1);
379			tpat = (p->arg0&0103) \| (pati[(p->arg0>>2)&03]<<2);
380
381			if (p->arg0 & 040) { /* left or down */
382			fill(tpat, xmn, ymn, txmin - 1, ymn + (int)ysz - 1);
383			for (x = txmin; x <= txmax; x++)
384			if (p->arg0 & 020) /* down */
385			fill(tpat, x, ymn, x, (int)(ysz-(x-xmn)*ysz/xsz) + ymn - 1);
386			else /* left */
387			fill(tpat, x, (int)((x-xmn)*ysz/xsz) + ymn, x, ymn + (int)ysz - 1);
388			} else { /* right or up */
389			for (x = txmin; x <= txmax; x++)
390			if (p->arg0 & 020) /* up */
391			fill(tpat, x, (int)(ysz-(x-xmn)*ysz/xsz) + ymn, x, ymn + (int)ysz - 1);
392			else /* right */
393			fill(tpat, x, ymn, x, (int)((x-xmn)*ysz/xsz) + ymn - 1);
394			fill(tpat, txmax + 1, ymn, xmn + (int)xsz - 1, ymn + (int)ysz - 1);
395			}
396			}
397
398
399
400
401			fill(attrib, xmin, ymin, xmax, ymax) /* fill rectangle with attribute */
402
403			register int attrib;
404			int xmin, ymin, xmax, ymax;
405
406			{
407			register int i, j;
408
409			xmin = max(xmin, outblock.xleft);
410			ymin = max(ymin, outblock.ybot);
411			xmax = min(xmax, outblock.xright);
412			ymax = min(ymax, outblock.ytop);
413
414			for (j = ymin; j <= ymax; j++)
415			for (i = xmin; i <= xmax; i++)
416			if (pattern[(attrib&074)>>2]
417			[(j>>3)%(PATSIZE>>3)][i%PATSIZE] & 1<<(j&07))
418
419			if (attrib & 0100) {
420			pixtog(i,j,attrib&03);
421			} else {
422			pixmix(i,j,attrib&03);
423			}
424
425			}