src/rt/rpict.c

/* Copyright (c) 1986 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  rpict.c - routines and variables for picture generation.
 *
 *     8/14/85
 */

#include  "ray.h"

#ifdef BSD
#include  <sys/time.h>
#include  <sys/resource.h>
#endif

#include  "view.h"

#include  "random.h"

VIEW  ourview = STDVIEW(512);           /* view parameters */

int  psample = 4;                       /* pixel sample size */
double  maxdiff = .05;                  /* max. difference for interpolation */
double  dstrpix = 0.67;                 /* square pixel distribution */

double  dstrsrc = 0.0;                  /* square source distribution */
double  shadthresh = .05;               /* shadow threshold */
double  shadcert = .5;                  /* shadow certainty */

int  maxdepth = 6;                      /* maximum recursion depth */
double  minweight = 5e-3;               /* minimum ray weight */

COLOR  ambval = BLKCOLOR;               /* ambient value */
double  ambacc = 0.2;                   /* ambient accuracy */
int  ambres = 128;                      /* ambient resolution */
int  ambdiv = 128;                      /* ambient divisions */
int  ambssamp = 0;                      /* ambient super-samples */
int  ambounce = 0;                      /* ambient bounces */
char  *amblist[128];                    /* ambient include/exclude list */
int  ambincl = -1;                      /* include == 1, exclude == 0 */

int  ralrm = 0;                         /* seconds between reports */

double  pctdone = 0.0;                  /* percentage done */

extern long  nrays;                     /* number of rays traced */

#define  MAXDIV         32              /* maximum sample size */

#define  pixjitter()    (.5+dstrpix*(.5-frandom()))


quit(code)                      /* quit program */
int  code;
{
        if (code || ralrm > 0)          /* report status */
                report();

        exit(code);
}


report()                /* report progress */
{
#ifdef BSD
        struct rusage  rubuf;
        double  t;

        getrusage(RUSAGE_SELF, &rubuf);
        t = (rubuf.ru_utime.tv_usec + rubuf.ru_stime.tv_usec) / 1e6;
        t += rubuf.ru_utime.tv_sec + rubuf.ru_stime.tv_sec;
        getrusage(RUSAGE_CHILDREN, &rubuf);
        t += (rubuf.ru_utime.tv_usec + rubuf.ru_stime.tv_usec) / 1e6;
        t += rubuf.ru_utime.tv_sec + rubuf.ru_stime.tv_sec;

        sprintf(errmsg, "%ld rays, %4.2f%% done after %5.4f CPU hours\n",
                        nrays, pctdone, t/3600.0);
#else
        sprintf(errmsg, "%ld rays, %4.2f%% done\n", nrays, pctdone);
#endif
        eputs(errmsg);

        if (ralrm > 0)
                alarm(ralrm);
}


render(oldfile)                         /* render the scene */
char  *oldfile;
{
        COLOR  *scanbar[MAXDIV+1];      /* scanline arrays of pixel values */
        int  ypos;                      /* current scanline */
        COLOR  *colptr;
        register int  i;

        if (psample < 1)
                psample = 1;
        else if (psample > MAXDIV)
                psample = MAXDIV;

        ourview.hresolu -= ourview.hresolu % psample;
        ourview.vresolu -= ourview.vresolu % psample;
                
        for (i = 0; i <= psample; i++) {
                scanbar[i] = (COLOR *)malloc((ourview.hresolu+1)*sizeof(COLOR));
                if (scanbar[i] == NULL)
                        error(SYSTEM, "out of memory in render");
        }
        
                                        /* write out boundaries */
        printf("-Y %d +X %d\n", ourview.vresolu, ourview.hresolu);

        ypos = ourview.vresolu - salvage(oldfile);      /* find top line */
        fillscanline(scanbar[0], ypos, psample);        /* top scan */

        for (ypos -= psample; ypos > -psample; ypos -= psample) {
        
                colptr = scanbar[psample];              /* get last scanline */
                scanbar[psample] = scanbar[0];
                scanbar[0] = colptr;

                fillscanline(scanbar[0], ypos, psample);        /* base scan */
        
                fillscanbar(scanbar, ypos, psample);
                
                for (i = psample-1; i >= 0; i--)
                        if (fwritescan(scanbar[i], ourview.hresolu, stdout) < 0)
                                goto writerr;
                if (fflush(stdout) == EOF)
                        goto writerr;
                pctdone = 100.0*(ourview.vresolu-ypos)/ourview.vresolu;
        }
                
        for (i = 0; i <= psample; i++)
                free((char *)scanbar[i]);
        return;
writerr:
        error(SYSTEM, "write error in render");
}


fillscanline(scanline, y, xstep)                /* fill scan line at y */
register COLOR  *scanline;
int  y, xstep;
{
        int  b = xstep;
        register int  i;
        
        pixvalue(scanline[0], 0, y);

        for (i = xstep; i <= ourview.hresolu; i += xstep) {
        
                pixvalue(scanline[i], i, y);
                
                b = fillsample(scanline+i-xstep, i-xstep, y, xstep, 0, b/2);
        }
}


fillscanbar(scanbar, y, ysize)          /* fill interior */
register COLOR  *scanbar[];
int  y, ysize;
{
        COLOR  vline[MAXDIV+1];
        int  b = ysize;
        register int  i, j;
        
        for (i = 0; i < ourview.hresolu; i++) {
                
                copycolor(vline[0], scanbar[0][i]);
                copycolor(vline[ysize], scanbar[ysize][i]);
                
                b = fillsample(vline, i, y, 0, ysize, b/2);
                
                for (j = 1; j < ysize; j++)
                        copycolor(scanbar[j][i], vline[j]);
        }
}


int
fillsample(colline, x, y, xlen, ylen, b)        /* fill interior points */
register COLOR  *colline;
int  x, y;
int  xlen, ylen;
int  b;
{
        double  ratio;
        COLOR  ctmp;
        int  ncut;
        register int  len;
        
        if (xlen > 0)                   /* x or y length is zero */
                len = xlen;
        else
                len = ylen;
                
        if (len <= 1)                   /* limit recursion */
                return(0);
        
        if (b > 0 || bigdiff(colline[0], colline[len], maxdiff)) {
        
                pixvalue(colline[len>>1], x + (xlen>>1), y + (ylen>>1));
                ncut = 1;
                
        } else {                                        /* interpolate */
        
                copycolor(colline[len>>1], colline[len]);
                ratio = (double)(len>>1) / len;
                scalecolor(colline[len>>1], ratio);
                copycolor(ctmp, colline[0]);
                ratio = 1.0 - ratio;
                scalecolor(ctmp, ratio);
                addcolor(colline[len>>1], ctmp);
                ncut = 0;
        }
                                                        /* recurse */
        ncut += fillsample(colline, x, y, xlen>>1, ylen>>1, (b-1)/2);
        
        ncut += fillsample(colline + (len>>1), x + (xlen>>1), y + (ylen>>1),
                                xlen - (xlen>>1), ylen - (ylen>>1), b/2);

        return(ncut);
}


pixvalue(col, x, y)             /* compute pixel value */
COLOR  col;                     /* returned color */
int  x, y;                      /* pixel position */
{
        static RAY  thisray;    /* our ray for this pixel */

        rayview(thisray.rorg, thisray.rdir, &ourview,
                        x + pixjitter(), y + pixjitter());

        rayorigin(&thisray, NULL, PRIMARY, 1.0);
        
        rayvalue(&thisray);                     /* trace ray */

        copycolor(col, thisray.rcol);           /* return color */
}


int
salvage(oldfile)                /* salvage scanlines from killed program */
char  *oldfile;
{
        COLR  *scanline;
        FILE  *fp;
        int  x, y;

        if (oldfile == NULL)
                return(0);
        else if ((fp = fopen(oldfile, "r")) == NULL) {
                sprintf(errmsg, "cannot open recover file \"%s\"", oldfile);
                error(WARNING, errmsg);
                return(0);
        }
                                /* discard header */
        getheader(fp, NULL);
                                /* get picture size */
        if (fscanf(fp, "-Y %d +X %d\n", &y, &x) != 2) {
                sprintf(errmsg, "bad recover file \"%s\"", oldfile);
                error(WARNING, errmsg);
                fclose(fp);
                return(0);
        }

        if (x != ourview.hresolu || y != ourview.vresolu) {
                sprintf(errmsg, "resolution mismatch in recover file \"%s\"",
                                oldfile);
                error(USER, errmsg);
                return(0);
        }

        scanline = (COLR *)malloc(ourview.hresolu*sizeof(COLR));
        if (scanline == NULL)
                error(SYSTEM, "out of memory in salvage");
        for (y = 0; y < ourview.vresolu; y++) {
                if (freadcolrs(scanline, ourview.hresolu, fp) < 0)
                        break;
                if (fwritecolrs(scanline, ourview.hresolu, stdout) < 0)
                        goto writerr;
        }
        if (fflush(stdout) == EOF)
                goto writerr;
        free((char *)scanline);
        fclose(fp);
        unlink(oldfile);
        return(y);
writerr:
        error(SYSTEM, "write error in salvage");
}
Revision:	1.5
Committed:	Tue Jun 13 10:57:40 1989 UTC (34 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.4:	+1 -0 lines
Log Message:	Added direct certainty variable (compromise btwn. thresh. & tol.)
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1986 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* rpict.c - routines and variables for picture generation.
9			*
10			* 8/14/85
11			*/
12
13			#include "ray.h"
14
15			#ifdef BSD
16			#include <sys/time.h>
17			#include <sys/resource.h>
18			#endif
19
20			#include "view.h"
21
22			#include "random.h"
23
24			VIEW ourview = STDVIEW(512); /* view parameters */
25
26			int psample = 4; /* pixel sample size */
27			double maxdiff = .05; /* max. difference for interpolation */
28	greg	1.3	double dstrpix = 0.67; /* square pixel distribution */
29	greg	1.1
30			double dstrsrc = 0.0; /* square source distribution */
31	greg	1.4	double shadthresh = .05; /* shadow threshold */
32	greg	1.5	double shadcert = .5; /* shadow certainty */
33	greg	1.1
34			int maxdepth = 6; /* maximum recursion depth */
35			double minweight = 5e-3; /* minimum ray weight */
36
37			COLOR ambval = BLKCOLOR; /* ambient value */
38			double ambacc = 0.2; /* ambient accuracy */
39			int ambres = 128; /* ambient resolution */
40			int ambdiv = 128; /* ambient divisions */
41			int ambssamp = 0; /* ambient super-samples */
42			int ambounce = 0; /* ambient bounces */
43			char amblist[128]; / ambient include/exclude list */
44			int ambincl = -1; /* include == 1, exclude == 0 */
45
46			int ralrm = 0; /* seconds between reports */
47
48			double pctdone = 0.0; /* percentage done */
49
50			extern long nrays; /* number of rays traced */
51
52			#define MAXDIV 32 /* maximum sample size */
53
54			#define pixjitter() (.5+dstrpix*(.5-frandom()))
55
56
57			quit(code) /* quit program */
58			int code;
59			{
60			if (code \|\| ralrm > 0) /* report status */
61			report();
62
63			exit(code);
64			}
65
66
67			report() /* report progress */
68			{
69			#ifdef BSD
70			struct rusage rubuf;
71			double t;
72
73			getrusage(RUSAGE_SELF, &rubuf);
74			t = (rubuf.ru_utime.tv_usec + rubuf.ru_stime.tv_usec) / 1e6;
75			t += rubuf.ru_utime.tv_sec + rubuf.ru_stime.tv_sec;
76			getrusage(RUSAGE_CHILDREN, &rubuf);
77			t += (rubuf.ru_utime.tv_usec + rubuf.ru_stime.tv_usec) / 1e6;
78			t += rubuf.ru_utime.tv_sec + rubuf.ru_stime.tv_sec;
79
80			sprintf(errmsg, "%ld rays, %4.2f%% done after %5.4f CPU hours\n",
81			nrays, pctdone, t/3600.0);
82			#else
83			sprintf(errmsg, "%ld rays, %4.2f%% done\n", nrays, pctdone);
84			#endif
85			eputs(errmsg);
86
87			if (ralrm > 0)
88			alarm(ralrm);
89			}
90
91
92			render(oldfile) /* render the scene */
93			char *oldfile;
94			{
95			COLOR scanbar[MAXDIV+1]; / scanline arrays of pixel values */
96			int ypos; /* current scanline */
97			COLOR *colptr;
98			register int i;
99
100			if (psample < 1)
101			psample = 1;
102			else if (psample > MAXDIV)
103			psample = MAXDIV;
104
105			ourview.hresolu -= ourview.hresolu % psample;
106			ourview.vresolu -= ourview.vresolu % psample;
107
108			for (i = 0; i <= psample; i++) {
109			scanbar[i] = (COLOR )malloc((ourview.hresolu+1)sizeof(COLOR));
110			if (scanbar[i] == NULL)
111			error(SYSTEM, "out of memory in render");
112			}
113
114			/* write out boundaries */
115			printf("-Y %d +X %d\n", ourview.vresolu, ourview.hresolu);
116
117			ypos = ourview.vresolu - salvage(oldfile); /* find top line */
118			fillscanline(scanbar[0], ypos, psample); /* top scan */
119
120			for (ypos -= psample; ypos > -psample; ypos -= psample) {
121
122			colptr = scanbar[psample]; /* get last scanline */
123			scanbar[psample] = scanbar[0];
124			scanbar[0] = colptr;
125
126			fillscanline(scanbar[0], ypos, psample); /* base scan */
127
128			fillscanbar(scanbar, ypos, psample);
129
130			for (i = psample-1; i >= 0; i--)
131			if (fwritescan(scanbar[i], ourview.hresolu, stdout) < 0)
132			goto writerr;
133			if (fflush(stdout) == EOF)
134			goto writerr;
135			pctdone = 100.0*(ourview.vresolu-ypos)/ourview.vresolu;
136			}
137
138			for (i = 0; i <= psample; i++)
139			free((char *)scanbar[i]);
140			return;
141			writerr:
142			error(SYSTEM, "write error in render");
143			}
144
145
146			fillscanline(scanline, y, xstep) /* fill scan line at y */
147			register COLOR *scanline;
148			int y, xstep;
149			{
150			int b = xstep;
151			register int i;
152
153			pixvalue(scanline[0], 0, y);
154
155			for (i = xstep; i <= ourview.hresolu; i += xstep) {
156
157			pixvalue(scanline[i], i, y);
158
159			b = fillsample(scanline+i-xstep, i-xstep, y, xstep, 0, b/2);
160			}
161			}
162
163
164			fillscanbar(scanbar, y, ysize) /* fill interior */
165			register COLOR *scanbar[];
166			int y, ysize;
167			{
168			COLOR vline[MAXDIV+1];
169			int b = ysize;
170			register int i, j;
171
172			for (i = 0; i < ourview.hresolu; i++) {
173
174			copycolor(vline[0], scanbar[0][i]);
175			copycolor(vline[ysize], scanbar[ysize][i]);
176
177			b = fillsample(vline, i, y, 0, ysize, b/2);
178
179			for (j = 1; j < ysize; j++)
180			copycolor(scanbar[j][i], vline[j]);
181			}
182			}
183
184
185			int
186			fillsample(colline, x, y, xlen, ylen, b) /* fill interior points */
187			register COLOR *colline;
188			int x, y;
189			int xlen, ylen;
190			int b;
191			{
192			double ratio;
193			COLOR ctmp;
194			int ncut;
195			register int len;
196
197			if (xlen > 0) /* x or y length is zero */
198			len = xlen;
199			else
200			len = ylen;
201
202			if (len <= 1) /* limit recursion */
203			return(0);
204
205			if (b > 0 \|\| bigdiff(colline[0], colline[len], maxdiff)) {
206
207			pixvalue(colline[len>>1], x + (xlen>>1), y + (ylen>>1));
208			ncut = 1;
209
210			} else { /* interpolate */
211
212			copycolor(colline[len>>1], colline[len]);
213			ratio = (double)(len>>1) / len;
214			scalecolor(colline[len>>1], ratio);
215			copycolor(ctmp, colline[0]);
216			ratio = 1.0 - ratio;
217			scalecolor(ctmp, ratio);
218			addcolor(colline[len>>1], ctmp);
219			ncut = 0;
220			}
221			/* recurse */
222			ncut += fillsample(colline, x, y, xlen>>1, ylen>>1, (b-1)/2);
223
224			ncut += fillsample(colline + (len>>1), x + (xlen>>1), y + (ylen>>1),
225			xlen - (xlen>>1), ylen - (ylen>>1), b/2);
226
227			return(ncut);
228			}
229
230
231			pixvalue(col, x, y) /* compute pixel value */
232			COLOR col; /* returned color */
233			int x, y; /* pixel position */
234			{
235			static RAY thisray; /* our ray for this pixel */
236
237			rayview(thisray.rorg, thisray.rdir, &ourview,
238			x + pixjitter(), y + pixjitter());
239
240			rayorigin(&thisray, NULL, PRIMARY, 1.0);
241
242			rayvalue(&thisray); /* trace ray */
243
244			copycolor(col, thisray.rcol); /* return color */
245			}
246
247
248			int
249			salvage(oldfile) /* salvage scanlines from killed program */
250			char *oldfile;
251			{
252			COLR *scanline;
253			FILE *fp;
254			int x, y;
255
256			if (oldfile == NULL)
257			return(0);
258			else if ((fp = fopen(oldfile, "r")) == NULL) {
259			sprintf(errmsg, "cannot open recover file \"%s\"", oldfile);
260			error(WARNING, errmsg);
261			return(0);
262			}
263			/* discard header */
264			getheader(fp, NULL);
265			/* get picture size */
266			if (fscanf(fp, "-Y %d +X %d\n", &y, &x) != 2) {
267	greg	1.2	sprintf(errmsg, "bad recover file \"%s\"", oldfile);
268			error(WARNING, errmsg);
269	greg	1.1	fclose(fp);
270			return(0);
271			}
272
273			if (x != ourview.hresolu \|\| y != ourview.vresolu) {
274			sprintf(errmsg, "resolution mismatch in recover file \"%s\"",
275			oldfile);
276			error(USER, errmsg);
277			return(0);
278			}
279
280			scanline = (COLR )malloc(ourview.hresolusizeof(COLR));
281			if (scanline == NULL)
282			error(SYSTEM, "out of memory in salvage");
283			for (y = 0; y < ourview.vresolu; y++) {
284			if (freadcolrs(scanline, ourview.hresolu, fp) < 0)
285			break;
286			if (fwritecolrs(scanline, ourview.hresolu, stdout) < 0)
287			goto writerr;
288			}
289			if (fflush(stdout) == EOF)
290			goto writerr;
291			free((char *)scanline);
292			fclose(fp);
293			unlink(oldfile);
294			return(y);
295			writerr:
296			error(SYSTEM, "write error in salvage");
297			}