ViewVC Help

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

root/Development/ray/src/gen/mkillum3.c

Comparing ray/src/gen/mkillum3.c (file contents):
Revision 2.5 by greg, Wed Aug 12 14:18:04 1992 UTC vs.
Revision 2.10 by greg, Tue Sep 28 17:54:18 2004 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		* Routines to print mkillum objects
6		*/
#	Line 17 | Line 14 | char   DATSUF[] = ".dat";              /* data file suffix */
14		char    DSTSUF[] = ".dist";             /* distribution suffix */
15		char    FNCFNM[] = "illum.cal";         /* function file name */
16
17	+	void compinv(float *rinv, float *rp, int m);
18	+	void colorout(int p, float *da, int n, int m, double mult, FILE *fp);
19	+	void fputnum(double d, FILE *fp);
20	+	void brightout(float *da, int n, int m, double mult, FILE *fp);
21	+	void fputeol(FILE *fp);
22	+	void compavg(float col[3], float *da, int n);
23	+	char * dfname(struct illum_args *il, int c);
24	+	FILE * dfopen(struct illum_args *il, int c);
25
26	<	printobj(mod, obj)              /* print out an object */
27	<	char  *mod;
28	<	register OBJREC  *obj;
26	>
27	>	void
28	>	printobj(               /* print out an object */
29	>	char  *mod,
30	>	register OBJREC  *obj
31	>	)
32		{
33		register int  i;
34
#	Line 48 | Line 56 | register OBJREC  *obj;
56
57
58		char *
59	<	dfname(il, c)                   /* return data file name */
60	<	struct illum_args  *il;
61	<	int  c;
59	>	dfname(                 /* return data file name */
60	>	struct illum_args  *il,
61	>	int  c
62	>	)
63		{
55	–	extern char  *getpath(), *strcpy();
64		char  fname[MAXSTR];
65		register char  *s;
66
#	Line 69 | Line 77 | int  c;
77
78
79		FILE *
80	<	dfopen(il, c)                   /* open data file */
81	<	register struct illum_args  *il;
82	<	int  c;
80	>	dfopen(                 /* open data file */
81	>	register struct illum_args  *il,
82	>	int  c
83	>	)
84		{
85		char  *fn;
86		FILE  *fp;
#	Line 89 | Line 98 | int  c;
98		}
99
100
101	<	flatout(il, da, n, m, u, v, w)          /* write hemispherical distribution */
102	<	struct illum_args  *il;
103	<	float  *da;
104	<	int  n, m;
105	<	FVECT  u, v, w;
101	>	extern void
102	>	flatout(                /* write hemispherical distribution */
103	>	struct illum_args  *il,
104	>	float  *da,
105	>	int  n,
106	>	int  m,
107	>	FVECT  u,
108	>	FVECT  v,
109	>	FVECT  w
110	>	)
111		{
112		float  *Ninv;
113		FILE  *dfp;
#	Line 122 | Line 136 | FVECT  u, v, w;
136		il->matname, DSTSUF);
137		printf("\n5 noneg");
138		dfp = dfopen(il, 0);
139	<	fprintf(dfp, "2\n%f %f %d\n%f %f %d\n", 1.+.5/n, .5/n, n+1,
139	>	fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
140	>	1.+.5/n, .5/n, n+1,
141		0., 2.*PI, m+1);
142		brightout(Ninv, 1, m, 1./il->nsamps/brt(il->col), dfp);
143		brightout(da, n, m, 1./il->nsamps/brt(il->col), dfp);
#	Line 136 | Line 151 | FVECT  u, v, w;
151		printf("\t%f\t%f\t%f\n", v[0], v[1], v[2]);
152		printf("\t%f\t%f\t%f\n", w[0], w[1], w[2]);
153		il->dfnum++;
154	<	free((char *)Ninv);
154	>	free((void *)Ninv);
155		}
156
157
158	<	roundout(il, da, n, m)                  /* write spherical distribution */
159	<	struct illum_args  *il;
160	<	float  *da;
161	<	int  n, m;
158	>	extern void
159	>	roundout(                       /* write spherical distribution */
160	>	struct illum_args  *il,
161	>	float  *da,
162	>	int  n,
163	>	int  m
164	>	)
165		{
166		float  *Ninv, *Sinv;
167		FILE  *dfp;
#	Line 151 | Line 169 | int  n, m;
169
170		if ((Ninv = (float *)malloc(3*m*sizeof(float))) == NULL ||
171		(Sinv = (float *)malloc(3*m*sizeof(float))) == NULL)
172	<	error(SYSTEM, "out of memory in flatout");
172	>	error(SYSTEM, "out of memory in roundout");
173		compinv(Ninv, da, m);
174		compinv(Sinv, da+3*m*(n-1), m);
175		if (il->flags & IL_COLDST) {
#	Line 175 | Line 193 | int  n, m;
193		il->matname, DSTSUF);
194		printf("\n5 noneg");
195		dfp = dfopen(il, 0);
196	<	fprintf(dfp, "2\n%f %f %d\n%f %f %d\n", 1.-1./n, -1.+1./n, n,
196	>	fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
197	>	1.+1./n, -1.-1./n, n+2,
198		0., 2.*PI, m+1);
199		brightout(Ninv, 1, m, 1./il->nsamps/brt(il->col), dfp);
200		brightout(da, n, m, 1./il->nsamps/brt(il->col), dfp);
#	Line 187 | Line 206 | int  n, m;
206		printf("\n\t%s il_alt il_azi", FNCFNM);
207		printf("\n0\n0\n");
208		il->dfnum++;
209	<	free((char *)Ninv);
210	<	free((char *)Sinv);
209	>	free((void *)Ninv);
210	>	free((void *)Sinv);
211		}
212
213
214	<	illumout(il, ob)                /* print illum object */
215	<	register struct illum_args  *il;
216	<	OBJREC  *ob;
214	>	extern void
215	>	illumout(               /* print illum object */
216	>	register struct illum_args  *il,
217	>	OBJREC  *ob
218	>	)
219		{
220		double  cout[3];
221
#	Line 221 | Line 242 | OBJREC  *ob;
242		}
243
244
245	<	compavg(col, da, n)             /* compute average for set of data values */
246	<	float  col[3];
247	<	register float  *da;
248	<	int  n;
245	>	void
246	>	compavg(                /* compute average for set of data values */
247	>	float  col[3],
248	>	register float  *da,
249	>	int  n
250	>	)
251		{
252		register int  i;
253
#	Line 240 | Line 263 | int  n;
263		}
264
265
266	<	compinv(rinv, rp, m)            /* compute other side of row average */
267	<	register float  *rinv, *rp;
268	<	int  m;
266	>	void
267	>	compinv(                /* compute other side of row average */
268	>	register float  *rinv,
269	>	register float  *rp,
270	>	int  m
271	>	)
272		{
273		float  avg[3];
274
#	Line 255 | Line 281 | int  m;
281		}
282
283
284	<	average(il, da, n)              /* evaluate average value for distribution */
285	<	register struct illum_args  *il;
286	<	float  *da;
287	<	int  n;
284	>	extern int
285	>	average(                /* evaluate average value for distribution */
286	>	register struct illum_args  *il,
287	>	float  *da,
288	>	int  n
289	>	)
290		{
291		compavg(il->col, da, n);        /* average */
292		if (il->nsamps > 1) {
#	Line 273 | Line 301 | int  n;
301
302		static int      colmcnt = 0;    /* count of columns written */
303
304	<	fputnum(d, fp)                  /* put out a number to fp */
305	<	double  d;
306	<	FILE  *fp;
304	>	void
305	>	fputnum(                        /* put out a number to fp */
306	>	double  d,
307	>	FILE  *fp
308	>	)
309		{
310		if (colmcnt++ % 5 == 0)
311		putc('\n', fp);
#	Line 283 | Line 313 | FILE  *fp;
313		}
314
315
316	<	fputeol(fp)                     /* write end of line to fp */
317	<	register FILE  *fp;
316	>	void
317	>	fputeol(                        /* write end of line to fp */
318	>	register FILE  *fp
319	>	)
320		{
321		putc('\n', fp);
322		colmcnt = 0;
323		}
324
325
326	<	colorout(p, da, n, m, mult, fp) /* put out color distribution data */
327	<	int  p;
328	<	register float  *da;
329	<	int  n, m;
330	<	double  mult;
331	<	FILE  *fp;
326	>	void
327	>	colorout(       /* put out color distribution data */
328	>	int  p,
329	>	register float  *da,
330	>	int  n,
331	>	int  m,
332	>	double  mult,
333	>	FILE  *fp
334	>	)
335		{
336		register int  i, j;
337
#	Line 310 | Line 345 | FILE  *fp;
345		}
346
347
348	<	brightout(da, n, m, mult, fp)   /* put out brightness distribution data */
349	<	register float  *da;
350	<	int  n, m;
351	<	double  mult;
352	<	FILE  *fp;
348	>	void
349	>	brightout(      /* put out brightness distribution data */
350	>	register float  *da,
351	>	int  n,
352	>	int  m,
353	>	double  mult,
354	>	FILE  *fp
355	>	)
356		{
357		register int  i, j;
358

Diff Legend

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