ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/util/glareval.c

Comparing ray/src/util/glareval.c (file contents):
Revision 1.13 by greg, Thu Apr 18 15:18:25 1991 UTC vs.
Revision 2.7 by schorsch, Thu Jun 26 00:58:11 2003 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1991 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Compute pixels for glare calculation
6		*/
7
8	+	#include "rtprocess.h" /* Windows: must come first because of conflicts */
9		#include "glare.h"
12	–	#include <sys/param.h>
13	–	/* compute rtrace buffer size */
14	–	#ifndef PIPE_BUF
15	–	#define PIPE_BUF        512             /* hyperconservative */
16	–	#endif
17	–	#define MAXPIX          (PIPE_BUF/(6*sizeof(float)) - 1)
10
11	<	#ifndef BSD
12	<	#define vfork           fork
21	<	#endif
11	>	/* maximum rtrace buffer size */
12	>	#define MAXPIX          (4096/(6*sizeof(float)))
13
14	<	#define MAXSBUF         524268  /* maximum total size of scanline buffer */
14	>	#define MAXSBUF         786432  /* maximum total size of scanline buffer */
15		#define HSIZE           317     /* size of scanline hash table */
16		#define NRETIRE         16      /* number of scanlines to retire at once */
17
18	<	int     rt_pid = -1;            /* process id for rtrace */
28	<	int     fd_tort, fd_fromrt;     /* pipe descriptors */
18	>	static SUBPROC  rt_pd = SP_INACTIVE; /* process id & descriptors for rtrace */
19
20		FILE    *pictfp = NULL;         /* picture file pointer */
21		double  exposure;               /* picture exposure */
#	Line 44 | Line 34 | typedef struct scan {
34		#define scandata(sl)    ((COLR *)((sl)+1))
35		#define shash(y)        ((y)%HSIZE)
36
37	+	static int      maxpix;         /* maximum number of pixels to buffer */
38	+
39		static SCAN     *freelist;              /* scanline free list */
40		static SCAN     *hashtab[HSIZE];        /* scanline hash table */
41
42	+	static long     scanbufsiz;             /* size of allocated scanline buffer */
43	+
44		static long     ncall = 0L;     /* number of calls to getpictscan */
45		static long     nread = 0L;     /* number of scanlines read */
46	+	static long     nrecl = 0L;     /* number of scanlines reclaimed */
47
48		static int      wrongformat = 0;
49
#	Line 77 | Line 72 | int    y;
72		if (sl->y == y) {               /* reclaim */
73		sl->next = hashtab[hi];
74		hashtab[hi] = sl;
75	<	#ifdef DEBUG
81	<	if (verbose)
82	<	fprintf(stderr,
83	<	"%s: scanline %d reclaimed\n",
84	<	progname, y);
85	<	#endif
75	>	nrecl++;
76		}
77		return(sl);
78		}
#	Line 146 | Line 136 | pict_stats()                   /* print out picture read statistics */
136		{
137		static long     lastcall = 0L;  /* ncall at last report */
138		static long     lastread = 0L;  /* nread at last report */
139	+	static long     lastrecl = 0L;  /* nrecl at last report */
140
141		if (ncall == lastcall)
142		return;
143	<	fprintf(stderr, "%s: %ld scanlines read in %ld calls\n",
144	<	progname, nread-lastread, ncall-lastcall);
143	>	fprintf(stderr, "%s: %ld scanlines read (%ld reclaimed) in %ld calls\n",
144	>	progname, nread-lastread, nrecl-lastrecl, ncall-lastcall);
145		lastcall = ncall;
146		lastread = nread;
147	+	lastrecl = nrecl;
148		}
149		#endif
150
#	Line 162 | Line 154 | pict_val(vd)                   /* find picture value for view directio
154		FVECT   vd;
155		{
156		FVECT   pp;
157	<	double  vpx, vpy, vpz;
157	>	FVECT   ip;
158		COLOR   res;
159
160		if (pictfp == NULL)
#	Line 170 | Line 162 | FVECT  vd;
162		pp[0] = pictview.vp[0] + vd[0];
163		pp[1] = pictview.vp[1] + vd[1];
164		pp[2] = pictview.vp[2] + vd[2];
165	<	viewpixel(&vpx, &vpy, &vpz, &pictview, pp);
166	<	if (vpz <= FTINY || vpx < 0. || vpx >= 1. || vpy < 0. || vpy >= 1.)
165	>	viewloc(ip, &pictview, pp);
166	>	if (ip[2] <= FTINY || ip[0] < 0. || ip[0] >= 1. ||
167	>	ip[1] < 0. || ip[1] >= 1.)
168		return(-1.0);
169	<	colr_color(res, getpictscan((int)(vpy*pysiz))[(int)(vpx*pxsiz)]);
169	>	colr_color(res, getpictscan((int)(ip[1]*pysiz))[(int)(ip[0]*pxsiz)]);
170		return(luminance(res)/exposure);
171		}
172
173
174		double
175	<	getviewpix(vh, vv, se)          /* compute single view pixel */
175	>	getviewpix(vh, vv)              /* compute single view pixel */
176		int     vh, vv;
184	–	SPANERR *se;
177		{
178		FVECT   dir;
179	<	float   rt_buf[6];
179	>	float   rt_buf[12];
180		double  res;
181
182	<	if (compdir(dir, vh, vv, se) < 0)
182	>	if (compdir(dir, vh, vv) < 0)
183		return(-1.0);
184		npixinvw++;
185		if ((res = pict_val(dir)) >= 0.0)
186		return(res);
187	<	if (rt_pid == -1) {
187	>	if (rt_pd.r == -1) {
188		npixmiss++;
189		return(-1.0);
190		}
#	Line 214 | Line 206 | float  *vb;
206		float   rt_buf[6*MAXPIX];       /* rtrace send/receive buffer */
207		register int    n;              /* number of pixels in buffer */
208		short   buf_vh[MAXPIX];         /* pixel positions */
217	–	SPANERR sperr;
209		FVECT   dir;
210		register int    vh;
211
#	Line 223 | Line 214 | float  *vb;
214		fprintf(stderr, "%s: computing view span at %d...\n",
215		progname, vv);
216		#endif
226	–	setspanerr(&sperr, vv);
217		n = 0;
218		for (vh = -hsize; vh <= hsize; vh++) {
219	<	if (compdir(dir, vh, vv, &sperr) < 0) { /* not in view */
219	>	if (compdir(dir, vh, vv) < 0) {         /* not in view */
220		vb[vh+hsize] = -1.0;
221		continue;
222		}
223		npixinvw++;
224		if ((vb[vh+hsize] = pict_val(dir)) >= 0.0)
225		continue;
226	<	if (rt_pid == -1) {             /* missing information */
226	>	if (rt_pd.r == -1) {            /* missing information */
227		npixmiss++;
228		continue;
229		}
230		/* send to rtrace */
231	<	if (n >= MAXPIX) {                      /* flush */
231	>	if (n >= maxpix) {                      /* flush */
232		rt_compute(rt_buf, n);
233		while (n-- > 0)
234		vb[buf_vh[n]+hsize] = luminance(rt_buf+3*n);
#	Line 267 | Line 257 | rt_compute(pb, np)             /* process buffer through rtrace *
257		float   *pb;
258		int     np;
259		{
270	–	static float    nbuf[6] = {0.,0.,0.,0.,0.,0.};
271	–
260		#ifdef DEBUG
261		if (verbose && np > 1)
262		fprintf(stderr, "%s: sending %d samples to rtrace...\n",
263		progname, np);
264		#endif
265	<	if (writebuf(fd_tort,(char *)pb,6*sizeof(float)*np) < 6*sizeof(float)*np
266	<	|| writebuf(fd_tort,(char *)nbuf,sizeof(nbuf)) < sizeof(nbuf)) {
267	<	fprintf(stderr, "%s: error writing to rtrace process\n",
265	>	bzero(pb+6*np, 6*sizeof(float));
266	>	if (process(&rt_pd, (char *)pb, (char *)pb, 3*sizeof(float)*(np+1),
267	>	6*sizeof(float)*(np+1)) < 3*sizeof(float)*(np+1)) {
268	>	fprintf(stderr, "%s: rtrace communication error\n",
269		progname);
270		exit(1);
271		}
283	–	if (readbuf(fd_fromrt, (char *)pb, 3*sizeof(float)*np)
284	–	< 3*sizeof(float)*np) {
285	–	fprintf(stderr, "%s: error reading from rtrace process\n",
286	–	progname);
287	–	exit(1);
288	–	}
272		}
273
274
275	+	int
276		getexpos(s)                     /* get exposure from header line */
277		char    *s;
278		{
#	Line 300 | Line 284 | char   *s;
284		formatval(fmt, s);
285		wrongformat = strcmp(fmt, COLRFMT);
286		}
287	+	return(0);
288		}
289
290
#	Line 307 | Line 292 | open_pict(fn)                  /* open picture file */
292		char    *fn;
293		{
294		if ((pictfp = fopen(fn, "r")) == NULL) {
295	<	fprintf("%s: cannot open\n", fn);
295	>	fprintf(stderr, "%s: cannot open\n", fn);
296		exit(1);
297		}
298		exposure = 1.0;
299		getheader(pictfp, getexpos, NULL);
300	<	if (wrongformat ||
301	<	fgetresolu(&pxsiz, &pysiz, pictfp) != (YMAJOR|YDECR)) {
317	<	fprintf("%s: bad picture format\n", fn);
300	>	if (wrongformat || !fscnresolu(&pxsiz, &pysiz, pictfp)) {
301	>	fprintf(stderr, "%s: incompatible picture format\n", fn);
302		exit(1);
303		}
304		initscans();
#	Line 334 | Line 318 | close_pict()                   /* done with picture */
318		fork_rtrace(av)                 /* open pipe and start rtrace */
319		char    *av[];
320		{
321	<	int     p0[2], p1[2];
321	>	int     rval;
322
323	<	if (pipe(p0) < 0 || pipe(p1) < 0) {
323	>	rval = open_process(&rt_pd, av);
324	>	if (rval < 0) {
325		perror(progname);
326		exit(1);
327		}
328	<	if ((rt_pid = vfork()) == 0) {          /* if child */
329	<	close(p0[1]);
345	<	close(p1[0]);
346	<	if (p0[0] != 0) {       /* connect p0 to stdin */
347	<	dup2(p0[0], 0);
348	<	close(p0[0]);
349	<	}
350	<	if (p1[1] != 0) {       /* connect p1 to stdout */
351	<	dup2(p1[1], 1);
352	<	close(p1[1]);
353	<	}
354	<	execvp(av[0], av);
355	<	perror(av[0]);
356	<	_exit(127);
357	<	}
358	<	if (rt_pid == -1) {
359	<	perror(progname);
328	>	if (rval == 0) {
329	>	fprintf(stderr, "%s: command not found\n", av[0]);
330		exit(1);
331		}
332	<	close(p0[0]);
333	<	close(p1[1]);
334	<	fd_tort = p0[1];
335	<	fd_fromrt = p1[0];
332	>	maxpix = rval/(6*sizeof(float));
333	>	if (maxpix > MAXPIX)
334	>	maxpix = MAXPIX;
335	>	maxpix--;
336		}
337
338
339		done_rtrace()                   /* wait for rtrace to finish */
340		{
341	<	int     pid, status;
341	>	int     status;
342
343	<	if (rt_pid == -1)
344	<	return;
375	<	close(fd_tort);
376	<	close(fd_fromrt);
377	<	while ((pid = wait(&status)) != -1 && pid != rt_pid)
378	<	;
379	<	if (pid == rt_pid && status != 0) {
343	>	status = close_process(&rt_pd);
344	>	if (status > 0) {
345		fprintf(stderr, "%s: bad status (%d) from rtrace\n",
346		progname, status);
347		exit(1);
348		}
349	<	rt_pid = -1;
349	>	rt_pd.r = -1;
350		}
351
352
388	–	int
389	–	readbuf(fd, bpos, siz)
390	–	int     fd;
391	–	char    *bpos;
392	–	int     siz;
393	–	{
394	–	register int    cc, nrem = siz;
395	–
396	–	while (nrem > 0 && (cc = read(fd, bpos, nrem)) > 0) {
397	–	bpos += cc;
398	–	nrem -= cc;
399	–	}
400	–	if (cc < 0)
401	–	return(cc);
402	–	return(siz-nrem);
403	–	}
404	–
405	–
406	–	int
407	–	writebuf(fd, bpos, siz)
408	–	char    *bpos;
409	–	int     siz;
410	–	{
411	–	register int    cc, nrem = siz;
412	–
413	–	while (nrem > 0 && (cc = write(fd, bpos, nrem)) > 0) {
414	–	bpos += cc;
415	–	nrem -= cc;
416	–	}
417	–	if (cc < 0)
418	–	return(cc);
419	–	return(siz-nrem);
420	–	}
421	–
422	–
353		SCAN *
354		scanretire()                    /* retire old scanlines to free list */
355		{
#	Line 470 | Line 400 | initscans()                            /* initialize scanline buffers */
400		register SCAN   *ptr;
401		register int    i;
402		/* initialize positions */
403	<	scanpos = (long *)malloc(pysiz*sizeof(long));
403	>	scanpos = (long *)bmalloc(pysiz*sizeof(long));
404		if (scanpos == NULL)
405		memerr("scanline positions");
406		for (i = pysiz-1; i >= 0; i--)
#	Line 482 | Line 412 | initscans()                            /* initialize scanline buffers */
412		/* allocate scanline buffers */
413		scansize = sizeof(SCAN) + pxsiz*sizeof(COLR);
414		#ifdef ALIGN
415	<	scansize = scansize+(sizeof(ALIGN)-1)) & ~(sizeof(ALIGN)-1);
415	>	scansize = scansize+(sizeof(ALIGN)-1) & ~(sizeof(ALIGN)-1);
416		#endif
417		i = MAXSBUF / scansize;         /* compute number to allocate */
418		if (i > HSIZE)
419		i = HSIZE;
420	<	scan_buf = malloc(i*scansize);  /* get in one big chunk */
420	>	scanbufsiz = i*scansize;
421	>	scan_buf = bmalloc(scanbufsiz); /* get in one big chunk */
422		if (scan_buf == NULL)
423		memerr("scanline buffers");
424		ptr = (SCAN *)scan_buf;
#	Line 504 | Line 435 | initscans()                            /* initialize scanline buffers */
435
436		donescans()                             /* free up scanlines */
437		{
438	<	free(scan_buf);
439	<	free((char *)scanpos);
438	>	bfree(scan_buf, scanbufsiz);
439	>	bfree((char *)scanpos, pysiz*sizeof(long));
440		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)