ViewVC Help

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

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

Comparing ray/src/util/rad.c (file contents):
Revision 2.47 by greg, Fri Dec 8 19:55:50 1995 UTC vs.
Revision 2.50 by greg, Fri Jan 5 14:43:03 1996 UTC

#	Line 10 | Line 10 | static char SCCSid[] = "$SunId$ LBL";
10
11		#include "standard.h"
12		#include "paths.h"
13	+	#include "vars.h"
14		#include <ctype.h>
15		#include <sys/types.h>
16
16	–
17	–	typedef struct {
18	–	char    *name;          /* variable name */
19	–	short   nick;           /* # characters required for nickname */
20	–	short   nass;           /* # assignments made */
21	–	char    *value;         /* assigned value(s) */
22	–	int     (*fixval)();    /* assignment checking function */
23	–	} VARIABLE;
24	–
25	–	int     onevalue(), catvalues(), boolvalue(),
26	–	qualvalue(), fltvalue(), intvalue();
27	–
17		/* variables */
18		#define OBJECT          0               /* object files */
19		#define SCENE           1               /* scene files */
#	Line 52 | Line 41 | int    onevalue(), catvalues(), boolvalue(),
41		#define RAWFILE         23              /* raw picture file root name */
42		#define ZFILE           24              /* distance file root name */
43		/* total number of variables */
44	<	#define NVARS           25
44	>	int NVARS = 25;
45
46	<	VARIABLE        vv[NVARS] = {           /* variable-value pairs */
46	>	VARIABLE        vv[] = {                /* variable-value pairs */
47		{"objects",     3,      0,      NULL,   catvalues},
48		{"scene",       3,      0,      NULL,   catvalues},
49		{"materials",   3,      0,      NULL,   catvalues},
#	Line 82 | Line 71 | VARIABLE       vv[NVARS] = {           /* variable-value pairs */
71		{"ZFILE",       2,      0,      NULL,   onevalue},
72		};
73
85	–	VARIABLE        *matchvar();
86	–	char    *nvalue();
87	–
88	–	#define UPPER(c)        ((c)&~0x20)     /* ASCII trick */
89	–
90	–	#define vnam(vc)        (vv[vc].name)
91	–	#define vdef(vc)        (vv[vc].nass)
92	–	#define vval(vc)        (vv[vc].value)
93	–	#define vint(vc)        atoi(vval(vc))
94	–	#define vlet(vc)        UPPER(vval(vc)[0])
95	–	#define vscale          vlet
96	–	#define vbool(vc)       (vlet(vc)=='T')
97	–
98	–	#define HIGH            'H'
99	–	#define MEDIUM          'M'
100	–	#define LOW             'L'
101	–
74		/* overture calculation file */
75		#ifdef NIX
76		char    overfile[] = "overture.unf";
#	Line 180 | Line 152 | char   *argv[];
152		/* assign Radiance root file name */
153		rootname(radname, rifname);
154		/* load variable values */
155	<	load(rifname);
155	>	loadvars(rifname);
156		/* get any additional assignments */
157		for (i++; i < argc; i++)
158		setvariable(argv[i]);
#	Line 192 | Line 164 | char   *argv[];
164		setdefaults();
165		/* print all values if requested */
166		if (explicate)
167	<	printvals();
167	>	printvars(stdout);
168		/* build octree (and run mkillum) */
169		oconv();
170		/* check date on ambient file */
#	Line 228 | Line 200 | register char  *rn, *fn;
200		}
201
202
231	–	#define NOCHAR  127             /* constant for character to delete */
232	–
233	–
234	–	load(rfname)                    /* load Radiance simulation file */
235	–	char    *rfname;
236	–	{
237	–	FILE    *fp;
238	–	char    buf[512];
239	–	register char   *cp;
240	–
241	–	if (rfname == NULL)
242	–	fp = stdin;
243	–	else if ((fp = fopen(rfname, "r")) == NULL)
244	–	syserr(rfname);
245	–	while (fgetline(buf, sizeof(buf), fp) != NULL) {
246	–	for (cp = buf; *cp; cp++) {
247	–	switch (*cp) {
248	–	case '\\':
249	–	*cp++ = NOCHAR;
250	–	continue;
251	–	case '#':
252	–	*cp = '\0';
253	–	break;
254	–	default:
255	–	continue;
256	–	}
257	–	break;
258	–	}
259	–	setvariable(buf);
260	–	}
261	–	fclose(fp);
262	–	}
263	–
264	–
265	–	setvariable(ass)                /* assign variable according to string */
266	–	register char   *ass;
267	–	{
268	–	char    varname[32];
269	–	int     n;
270	–	register char   *cp;
271	–	register VARIABLE       *vp;
272	–	register int    i;
273	–
274	–	while (isspace(*ass))           /* skip leading space */
275	–	ass++;
276	–	cp = varname;                   /* extract name */
277	–	while (cp < varname+sizeof(varname)-1
278	–	&& *ass && !isspace(*ass) && *ass != '=')
279	–	*cp++ = *ass++;
280	–	*cp = '\0';
281	–	if (!varname[0])
282	–	return;         /* no variable name! */
283	–	/* trim value */
284	–	while (isspace(*ass) || *ass == '=')
285	–	ass++;
286	–	for (n = strlen(ass); n > 0; n--)
287	–	if (!isspace(ass[n-1]))
288	–	break;
289	–	if (!n && !nowarn) {
290	–	fprintf(stderr, "%s: warning - missing value for variable '%s'\n",
291	–	progname, varname);
292	–	return;
293	–	}
294	–	/* match variable from list */
295	–	vp = matchvar(varname);
296	–	if (vp == NULL) {
297	–	fprintf(stderr, "%s: unknown variable '%s'\n",
298	–	progname, varname);
299	–	exit(1);
300	–	}
301	–	/* assign new value */
302	–	if (i = vp->nass) {
303	–	cp = vp->value;
304	–	while (i--)
305	–	while (*cp++)
306	–	;
307	–	i = cp - vp->value;
308	–	vp->value = realloc(vp->value, i+n+1);
309	–	} else
310	–	vp->value = malloc(n+1);
311	–	if (vp->value == NULL)
312	–	syserr(progname);
313	–	cp = vp->value+i;               /* copy value, squeezing spaces */
314	–	*cp = *ass;
315	–	for (i = 1; i <= n; i++) {
316	–	if (ass[i] == NOCHAR)
317	–	continue;
318	–	if (isspace(*cp))
319	–	while (isspace(ass[i]))
320	–	i++;
321	–	*++cp = ass[i];
322	–	}
323	–	if (isspace(*cp))               /* remove trailing space */
324	–	*cp = '\0';
325	–	vp->nass++;
326	–	}
327	–
328	–
329	–	VARIABLE *
330	–	matchvar(nam)                   /* match a variable by its name */
331	–	char    *nam;
332	–	{
333	–	int     n = strlen(nam);
334	–	register int    i;
335	–
336	–	for (i = 0; i < NVARS; i++)
337	–	if (n >= vv[i].nick && !strncmp(nam, vv[i].name, n))
338	–	return(vv+i);
339	–	return(NULL);
340	–	}
341	–
342	–
343	–	char *
344	–	nvalue(vp, n)                   /* return nth variable value */
345	–	VARIABLE        *vp;
346	–	register int    n;
347	–	{
348	–	register char   *cp;
349	–
350	–	if (vp == NULL | n < 0 | n >= vp->nass)
351	–	return(NULL);
352	–	cp = vp->value;
353	–	while (n--)
354	–	while (*cp++)
355	–	;
356	–	return(cp);
357	–	}
358	–
359	–
360	–	checkvalues()                   /* check assignments */
361	–	{
362	–	register int    i;
363	–
364	–	for (i = 0; i < NVARS; i++)
365	–	if (vv[i].fixval != NULL)
366	–	(*vv[i].fixval)(vv+i);
367	–	}
368	–
369	–
370	–	onevalue(vp)                    /* only one assignment for this variable */
371	–	register VARIABLE       *vp;
372	–	{
373	–	if (vp->nass < 2)
374	–	return;
375	–	if (!nowarn)
376	–	fprintf(stderr,
377	–	"%s: warning - multiple assignment of variable '%s'\n",
378	–	progname, vp->name);
379	–	do
380	–	vp->value += strlen(vp->value)+1;
381	–	while (--vp->nass > 1);
382	–	}
383	–
384	–
385	–	catvalues(vp)                   /* concatenate variable values */
386	–	register VARIABLE       *vp;
387	–	{
388	–	register char   *cp;
389	–
390	–	if (vp->nass < 2)
391	–	return;
392	–	for (cp = vp->value; vp->nass > 1; vp->nass--) {
393	–	while (*cp)
394	–	cp++;
395	–	*cp++ = ' ';
396	–	}
397	–	}
398	–
399	–
400	–	int
401	–	badmatch(tv, cv)                /* case insensitive truncated comparison */
402	–	register char   *tv, *cv;
403	–	{
404	–	if (!*tv) return(1);            /* null string cannot match */
405	–	do
406	–	if (UPPER(*tv) != *cv++)
407	–	return(1);
408	–	while (*++tv);
409	–	return(0);              /* OK */
410	–	}
411	–
412	–
413	–	boolvalue(vp)                   /* check boolean for legal values */
414	–	register VARIABLE       *vp;
415	–	{
416	–	if (!vp->nass) return;
417	–	onevalue(vp);
418	–	switch (UPPER(vp->value[0])) {
419	–	case 'T':
420	–	if (badmatch(vp->value, "TRUE")) break;
421	–	return;
422	–	case 'F':
423	–	if (badmatch(vp->value, "FALSE")) break;
424	–	return;
425	–	}
426	–	fprintf(stderr, "%s: illegal value for boolean variable '%s'\n",
427	–	progname, vp->name);
428	–	exit(1);
429	–	}
430	–
431	–
432	–	qualvalue(vp)                   /* check qualitative var. for legal values */
433	–	register VARIABLE       *vp;
434	–	{
435	–	if (!vp->nass) return;
436	–	onevalue(vp);
437	–	switch (UPPER(vp->value[0])) {
438	–	case 'L':
439	–	if (badmatch(vp->value, "LOW")) break;
440	–	return;
441	–	case 'M':
442	–	if (badmatch(vp->value, "MEDIUM")) break;
443	–	return;
444	–	case 'H':
445	–	if (badmatch(vp->value, "HIGH")) break;
446	–	return;
447	–	}
448	–	fprintf(stderr, "%s: illegal value for qualitative variable '%s'\n",
449	–	progname, vp->name);
450	–	exit(1);
451	–	}
452	–
453	–
454	–	intvalue(vp)                    /* check integer variable for legal values */
455	–	register VARIABLE       *vp;
456	–	{
457	–	if (!vp->nass) return;
458	–	onevalue(vp);
459	–	if (isint(vp->value)) return;
460	–	fprintf(stderr, "%s: illegal value for integer variable '%s'\n",
461	–	progname, vp->name);
462	–	exit(1);
463	–	}
464	–
465	–
466	–	fltvalue(vp)                    /* check float variable for legal values */
467	–	register VARIABLE       *vp;
468	–	{
469	–	if (!vp->nass) return;
470	–	onevalue(vp);
471	–	if (isflt(vp->value)) return;
472	–	fprintf(stderr, "%s: illegal value for real variable '%s'\n",
473	–	progname, vp->name);
474	–	exit(1);
475	–	}
476	–
477	–
203		time_t
204		checklast(fnames)                       /* check files and find most recent */
205		register char   *fnames;
#	Line 654 | Line 379 | setdefaults()                  /* set default values for unassigned v
379		}
380
381
657	–	printvals()                     /* print variable values */
658	–	{
659	–	int     i, j, clipline;
660	–	register char   *cp;
661	–	register int    k;
662	–
663	–	for (i = 0; i < NVARS; i++)             /* print each variable */
664	–	for (j = 0; j < vdef(i); j++) {     /* print each assignment */
665	–	fputs(vnam(i), stdout);
666	–	fputs("= ", stdout);
667	–	k = clipline = ( vv[i].fixval == catvalues ? 64 : 320 )
668	–	- strlen(vnam(i)) ;
669	–	cp = nvalue(vv+i, j);
670	–	while (*cp) {
671	–	putchar(*cp++);
672	–	if (--k <= 0) {             /* line too long */
673	–	while (*cp && !isspace(*cp))
674	–	putchar(*cp++);     /* finish this word */
675	–	if (*cp) {              /* start new line */
676	–	putchar('\n');
677	–	fputs(vnam(i), stdout);
678	–	putchar('=');
679	–	k = clipline;
680	–	}
681	–	}
682	–	}
683	–	putchar('\n');
684	–	}
685	–	fflush(stdout);
686	–	}
687	–
688	–
382		oconv()                         /* run oconv and mkillum if necessary */
383		{
384		static char     illumtmp[] = "ilXXXXXX";
#	Line 842 | Line 535 | ambval()                               /* compute ambient value */
535		{
536		if (vdef(EXPOSURE)) {
537		if (vval(EXPOSURE)[0] == '+' || vval(EXPOSURE)[0] == '-')
538	<	return(.5/pow(2.,atof(vval(EXPOSURE))));
539	<	return(.5/atof(vval(EXPOSURE)));
538	>	return(.5/pow(2.,vflt(EXPOSURE)));
539	>	return(.5/vflt(EXPOSURE));
540		}
541		if (vlet(ZONE) == 'E')
542		return(10.);
#	Line 1103 | Line 796 | char   *ro;
796		return;
797		if (vdef(OPTFILE)) {
798		for (cp = ro; cp[1]; cp++)
799	<	if (isspace(cp[1]) && cp[2] == '-' && isalpha(cp[3]))
799	>	if (isspace(cp[1]) && (cp[2] == '@' ||
800	>	(cp[2] == '-' && isalpha(cp[3]))))
801		*cp = '\n';
802		else
803		*cp = cp[1];

Diff Legend

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