src/gen/mkillum3.c

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

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

/*
 * Routines to print mkillum objects
 */

#include  "mkillum.h"

#define  brt(col)       (.263*(col)[0]+.655*(col)[1]+.082*(col)[2])

char    DATORD[] = "RGB";               /* data ordering */
char    DATSUF[] = ".dat";              /* data file suffix */
char    DSTSUF[] = ".dist";             /* distribution suffix */
char    FNCFNM[] = "illum.cal";         /* function file name */


printobj(mod, obj)              /* print out an object */
char  *mod;
register OBJREC  *obj;
{
        register int  i;

        if (issurface(obj->otype) && !strcmp(mod, VOIDID))
                return;         /* don't print void surfaces */
        printf("\n%s %s %s", mod, ofun[obj->otype].funame, obj->oname);
        printf("\n%d", obj->oargs.nsargs);
        for (i = 0; i < obj->oargs.nsargs; i++)
                printf(" %s", obj->oargs.sarg[i]);
#ifdef  IARGS
        printf("\n%d", obj->oargs.niargs);
        for (i = 0; i < obj->oargs.niargs; i++)
                printf(" %d", obj->oargs.iarg[i]);
#else
        printf("\n0");
#endif
        printf("\n%d", obj->oargs.nfargs);
        for (i = 0; i < obj->oargs.nfargs; i++) {
                if (i%3 == 0)
                        putchar('\n');
                printf(" %18.12g", obj->oargs.farg[i]);
        }
        putchar('\n');
}


char *
dfname(il, c)                   /* return data file name */
struct illum_args  *il;
int  c;
{
        extern char  *getpath(), *strcpy();
        char  fname[MAXSTR];
        register char  *s;

        s = strcpy(fname, il->datafile);
        s += strlen(s);
        if (c) *s++ = c;
        if (il->dfnum > 0) {
                sprintf(s, "%d", il->dfnum);
                s += strlen(s);
        }
        strcpy(s, DATSUF);
        return(getpath(fname, NULL, 0));
}


FILE *
dfopen(il, c)                   /* open data file */
register struct illum_args  *il;
int  c;
{
        char  *fn;
        FILE  *fp;
                                        /* get a usable file name */
        for (fn = dfname(il, c);
                        !(il->flags & IL_DATCLB) && access(fn, F_OK) == 0;
                        fn = dfname(il, c))
                il->dfnum++;
                                        /* open it for writing */
        if ((fp = fopen(fn, "w")) == NULL) {
                sprintf(errmsg, "cannot open data file \"%s\"", fn);
                error(SYSTEM, errmsg);
        }
        return(fp);
}


flatout(il, da, n, m, u, v, w)          /* write hemispherical distribution */
struct illum_args  *il;
float  *da;
int  n, m;
FVECT  u, v, w;
{
        float  *Ninv;
        FILE  *dfp;
        int  i;

        if ((Ninv = (float *)malloc(3*m*sizeof(float))) == NULL)
                error(SYSTEM, "out of memory in flatout");
        compinv(Ninv, da, m);
        if (il->flags & IL_COLDST) {
                printf("\n%s %s %s%s", VOIDID, ofun[PAT_CDATA].funame,
                                il->matname, DSTSUF);
                printf("\n9 red green blue");
                for (i = 0; i < 3; i++) {
                        dfp = dfopen(il, DATORD[i]);
                        fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
                                        1.+.5/n, .5/n, n+1,
                                        0., 2.*PI, m+1);
                        colorout(i, Ninv, 1, m, 1./il->nsamps/il->col[i], dfp);
                        colorout(i, da, n, m, 1./il->nsamps/il->col[i], dfp);
                        fputeol(dfp);
                        fclose(dfp);
                        printf(" %s", dfname(il, DATORD[i]));
                }
        } else {
                printf("\n%s %s %s%s", VOIDID, ofun[PAT_BDATA].funame,
                                il->matname, DSTSUF);
                printf("\n5 noneg");
                dfp = dfopen(il, 0);
                fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
                                1.+.5/n, .5/n, n+1,
                                0., 2.*PI, m+1);
                brightout(Ninv, 1, m, 1./il->nsamps/brt(il->col), dfp);
                brightout(da, n, m, 1./il->nsamps/brt(il->col), dfp);
                fputeol(dfp);
                fclose(dfp);
                printf(" %s", dfname(il, 0));
        }
        printf("\n\t%s il_alth il_azih", FNCFNM);
        printf("\n0\n9\n");
        printf("\t%f\t%f\t%f\n", u[0], u[1], u[2]);
        printf("\t%f\t%f\t%f\n", v[0], v[1], v[2]);
        printf("\t%f\t%f\t%f\n", w[0], w[1], w[2]);
        il->dfnum++;
        free((char *)Ninv);
}


roundout(il, da, n, m)                  /* write spherical distribution */
struct illum_args  *il;
float  *da;
int  n, m;
{
        float  *Ninv, *Sinv;
        FILE  *dfp;
        int  i;

        if ((Ninv = (float *)malloc(3*m*sizeof(float))) == NULL ||
                        (Sinv = (float *)malloc(3*m*sizeof(float))) == NULL)
                error(SYSTEM, "out of memory in roundout");
        compinv(Ninv, da, m);
        compinv(Sinv, da+3*m*(n-1), m);
        if (il->flags & IL_COLDST) {
                printf("\n%s %s %s%s", VOIDID, ofun[PAT_CDATA].funame,
                                il->matname, DSTSUF);
                printf("\n9 red green blue");
                for (i = 0; i < 3; i++) {
                        dfp = dfopen(il, DATORD[i]);
                        fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
                                        1.+1./n, -1.-1./n, n+2,
                                        0., 2.*PI, m+1);
                        colorout(i, Ninv, 1, m, 1./il->nsamps/il->col[i], dfp);
                        colorout(i, da, n, m, 1./il->nsamps/il->col[i], dfp);
                        colorout(i, Sinv, 1, m, 1./il->nsamps/il->col[i], dfp);
                        fputeol(dfp);
                        fclose(dfp);
                        printf(" %s", dfname(il, DATORD[i]));
                }
        } else {
                printf("\n%s %s %s%s", VOIDID, ofun[PAT_BDATA].funame,
                                il->matname, DSTSUF);
                printf("\n5 noneg");
                dfp = dfopen(il, 0);
                fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
                                1.+1./n, -1.-1./n, n+2,
                                0., 2.*PI, m+1);
                brightout(Ninv, 1, m, 1./il->nsamps/brt(il->col), dfp);
                brightout(da, n, m, 1./il->nsamps/brt(il->col), dfp);
                brightout(Sinv, 1, m, 1./il->nsamps/brt(il->col), dfp);
                fputeol(dfp);
                fclose(dfp);
                printf(" %s", dfname(il, 0));
        }
        printf("\n\t%s il_alt il_azi", FNCFNM);
        printf("\n0\n0\n");
        il->dfnum++;
        free((char *)Ninv);
        free((char *)Sinv);
}


illumout(il, ob)                /* print illum object */
register struct illum_args  *il;
OBJREC  *ob;
{
        double  cout[3];

        if (il->sampdens <= 0)
                printf("\n%s ", VOIDID);
        else
                printf("\n%s%s ", il->matname, DSTSUF);
        printf("%s %s", ofun[il->flags&IL_LIGHT?MAT_LIGHT:MAT_ILLUM].funame,
                        il->matname);
        if (il->flags & IL_LIGHT || !strcmp(il->altmat,VOIDID))
                printf("\n0");
        else
                printf("\n1 %s", il->altmat);
        if (il->flags & IL_COLAVG) {
                cout[0] = il->col[0];
                cout[1] = il->col[1];
                cout[2] = il->col[2];
        } else {
                cout[0] = cout[1] = cout[2] = brt(il->col);
        }
        printf("\n0\n3 %f %f %f\n", cout[0], cout[1], cout[2]);

        printobj(il->matname, ob);
}


compavg(col, da, n)             /* compute average for set of data values */
float  col[3];
register float  *da;
int  n;
{
        register int  i;

        col[0] = col[1] = col[2] = 0.;
        i = n;
        while (i-- > 0) {
                col[0] += *da++;
                col[1] += *da++;
                col[2] += *da++;
        }
        for (i = 0; i < 3; i++)
                col[i] /= (double)n;
}


compinv(rinv, rp, m)            /* compute other side of row average */
register float  *rinv, *rp;
int  m;
{
        float  avg[3];

        compavg(avg, rp, m);            /* row average */
        while (m-- > 0) {
                *rinv++ = 2.*avg[0] - *rp++;
                *rinv++ = 2.*avg[1] - *rp++;
                *rinv++ = 2.*avg[2] - *rp++;
        }
}


average(il, da, n)              /* evaluate average value for distribution */
register struct illum_args  *il;
float  *da;
int  n;
{
        compavg(il->col, da, n);        /* average */
        if (il->nsamps > 1) {
                il->col[0] /= (double)il->nsamps;
                il->col[1] /= (double)il->nsamps;
                il->col[2] /= (double)il->nsamps;
        }
                                        /* brighter than minimum? */
        return(brt(il->col) > il->minbrt+FTINY);
}


static int      colmcnt = 0;    /* count of columns written */

fputnum(d, fp)                  /* put out a number to fp */
double  d;
FILE  *fp;
{
        if (colmcnt++ % 5 == 0)
                putc('\n', fp);
        fprintf(fp, " %11e", d);
}


fputeol(fp)                     /* write end of line to fp */
register FILE  *fp;
{
        putc('\n', fp);
        colmcnt = 0;
}


colorout(p, da, n, m, mult, fp) /* put out color distribution data */
int  p;
register float  *da;
int  n, m;
double  mult;
FILE  *fp;
{
        register int  i, j;

        for (i = 0; i < n; i++) {
                for (j = 0; j < m; j++) {
                        fputnum(mult*da[p], fp);
                        da += 3;
                }
                fputnum(mult*da[p-3*m], fp);    /* wrap phi */
        }
}


brightout(da, n, m, mult, fp)   /* put out brightness distribution data */
register float  *da;
int  n, m;
double  mult;
FILE  *fp;
{
        register int  i, j;

        for (i = 0; i < n; i++) {
                for (j = 0; j < m; j++) {
                        fputnum(mult*brt(da), fp);
                        da += 3;
                }
                fputnum(mult*brt(da-3*m), fp);  /* wrap phi */
        }
}
Revision:	2.6
Committed:	Wed Aug 12 14:24:08 1992 UTC (31 years, 8 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.5:	+5 -3 lines
Log Message:	fixed a couple of minor oversights (bugs!)
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1991 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Routines to print mkillum objects
9			*/
10
11			#include "mkillum.h"
12
13	greg	1.7	#define brt(col) (.263(col)[0]+.655(col)[1]+.082*(col)[2])
14	greg	1.1
15			char DATORD[] = "RGB"; /* data ordering */
16			char DATSUF[] = ".dat"; /* data file suffix */
17			char DSTSUF[] = ".dist"; /* distribution suffix */
18			char FNCFNM[] = "illum.cal"; /* function file name */
19
20
21			printobj(mod, obj) /* print out an object */
22			char *mod;
23			register OBJREC *obj;
24			{
25			register int i;
26
27	greg	2.3	if (issurface(obj->otype) && !strcmp(mod, VOIDID))
28			return; /* don't print void surfaces */
29	greg	1.1	printf("\n%s %s %s", mod, ofun[obj->otype].funame, obj->oname);
30			printf("\n%d", obj->oargs.nsargs);
31			for (i = 0; i < obj->oargs.nsargs; i++)
32			printf(" %s", obj->oargs.sarg[i]);
33			#ifdef IARGS
34			printf("\n%d", obj->oargs.niargs);
35			for (i = 0; i < obj->oargs.niargs; i++)
36			printf(" %d", obj->oargs.iarg[i]);
37			#else
38			printf("\n0");
39			#endif
40			printf("\n%d", obj->oargs.nfargs);
41			for (i = 0; i < obj->oargs.nfargs; i++) {
42			if (i%3 == 0)
43			putchar('\n');
44			printf(" %18.12g", obj->oargs.farg[i]);
45			}
46			putchar('\n');
47			}
48
49
50			char *
51			dfname(il, c) /* return data file name */
52			struct illum_args *il;
53			int c;
54			{
55			extern char getpath(), strcpy();
56			char fname[MAXSTR];
57			register char *s;
58
59			s = strcpy(fname, il->datafile);
60			s += strlen(s);
61			if (c) *s++ = c;
62			if (il->dfnum > 0) {
63			sprintf(s, "%d", il->dfnum);
64			s += strlen(s);
65			}
66			strcpy(s, DATSUF);
67			return(getpath(fname, NULL, 0));
68			}
69
70
71			FILE *
72			dfopen(il, c) /* open data file */
73			register struct illum_args *il;
74			int c;
75			{
76			char *fn;
77			FILE *fp;
78			/* get a usable file name */
79			for (fn = dfname(il, c);
80			!(il->flags & IL_DATCLB) && access(fn, F_OK) == 0;
81			fn = dfname(il, c))
82			il->dfnum++;
83			/* open it for writing */
84			if ((fp = fopen(fn, "w")) == NULL) {
85			sprintf(errmsg, "cannot open data file \"%s\"", fn);
86			error(SYSTEM, errmsg);
87			}
88			return(fp);
89			}
90
91
92			flatout(il, da, n, m, u, v, w) /* write hemispherical distribution */
93			struct illum_args *il;
94			float *da;
95			int n, m;
96			FVECT u, v, w;
97			{
98	greg	2.5	float *Ninv;
99	greg	1.1	FILE *dfp;
100			int i;
101
102	greg	2.5	if ((Ninv = (float )malloc(3m*sizeof(float))) == NULL)
103			error(SYSTEM, "out of memory in flatout");
104			compinv(Ninv, da, m);
105	greg	1.1	if (il->flags & IL_COLDST) {
106			printf("\n%s %s %s%s", VOIDID, ofun[PAT_CDATA].funame,
107			il->matname, DSTSUF);
108	greg	2.5	printf("\n9 red green blue");
109	greg	1.1	for (i = 0; i < 3; i++) {
110			dfp = dfopen(il, DATORD[i]);
111	greg	1.6	fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
112	greg	2.5	1.+.5/n, .5/n, n+1,
113	greg	1.6	0., 2.*PI, m+1);
114	greg	2.5	colorout(i, Ninv, 1, m, 1./il->nsamps/il->col[i], dfp);
115	greg	1.6	colorout(i, da, n, m, 1./il->nsamps/il->col[i], dfp);
116	greg	2.5	fputeol(dfp);
117	greg	1.1	fclose(dfp);
118			printf(" %s", dfname(il, DATORD[i]));
119			}
120			} else {
121			printf("\n%s %s %s%s", VOIDID, ofun[PAT_BDATA].funame,
122			il->matname, DSTSUF);
123	greg	2.5	printf("\n5 noneg");
124	greg	1.1	dfp = dfopen(il, 0);
125	greg	2.6	fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
126			1.+.5/n, .5/n, n+1,
127	greg	1.6	0., 2.*PI, m+1);
128	greg	2.5	brightout(Ninv, 1, m, 1./il->nsamps/brt(il->col), dfp);
129	greg	1.6	brightout(da, n, m, 1./il->nsamps/brt(il->col), dfp);
130	greg	2.5	fputeol(dfp);
131	greg	1.1	fclose(dfp);
132			printf(" %s", dfname(il, 0));
133			}
134			printf("\n\t%s il_alth il_azih", FNCFNM);
135	greg	2.5	printf("\n0\n9\n");
136	greg	1.1	printf("\t%f\t%f\t%f\n", u[0], u[1], u[2]);
137			printf("\t%f\t%f\t%f\n", v[0], v[1], v[2]);
138			printf("\t%f\t%f\t%f\n", w[0], w[1], w[2]);
139			il->dfnum++;
140	greg	2.5	free((char *)Ninv);
141	greg	1.1	}
142
143
144			roundout(il, da, n, m) /* write spherical distribution */
145			struct illum_args *il;
146			float *da;
147			int n, m;
148			{
149	greg	2.5	float Ninv, Sinv;
150	greg	1.1	FILE *dfp;
151			int i;
152
153	greg	2.5	if ((Ninv = (float )malloc(3m*sizeof(float))) == NULL \|\|
154			(Sinv = (float )malloc(3m*sizeof(float))) == NULL)
155	greg	2.6	error(SYSTEM, "out of memory in roundout");
156	greg	2.5	compinv(Ninv, da, m);
157			compinv(Sinv, da+3m(n-1), m);
158	greg	1.1	if (il->flags & IL_COLDST) {
159			printf("\n%s %s %s%s", VOIDID, ofun[PAT_CDATA].funame,
160			il->matname, DSTSUF);
161	greg	2.5	printf("\n9 red green blue");
162	greg	1.1	for (i = 0; i < 3; i++) {
163			dfp = dfopen(il, DATORD[i]);
164	greg	1.6	fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
165	greg	2.5	1.+1./n, -1.-1./n, n+2,
166	greg	1.6	0., 2.*PI, m+1);
167	greg	2.5	colorout(i, Ninv, 1, m, 1./il->nsamps/il->col[i], dfp);
168	greg	1.6	colorout(i, da, n, m, 1./il->nsamps/il->col[i], dfp);
169	greg	2.5	colorout(i, Sinv, 1, m, 1./il->nsamps/il->col[i], dfp);
170			fputeol(dfp);
171	greg	1.1	fclose(dfp);
172			printf(" %s", dfname(il, DATORD[i]));
173			}
174			} else {
175			printf("\n%s %s %s%s", VOIDID, ofun[PAT_BDATA].funame,
176			il->matname, DSTSUF);
177	greg	2.5	printf("\n5 noneg");
178	greg	1.1	dfp = dfopen(il, 0);
179	greg	2.6	fprintf(dfp, "2\n%f %f %d\n%f %f %d\n",
180			1.+1./n, -1.-1./n, n+2,
181	greg	1.6	0., 2.*PI, m+1);
182	greg	2.5	brightout(Ninv, 1, m, 1./il->nsamps/brt(il->col), dfp);
183	greg	1.6	brightout(da, n, m, 1./il->nsamps/brt(il->col), dfp);
184	greg	2.5	brightout(Sinv, 1, m, 1./il->nsamps/brt(il->col), dfp);
185			fputeol(dfp);
186	greg	1.1	fclose(dfp);
187			printf(" %s", dfname(il, 0));
188			}
189			printf("\n\t%s il_alt il_azi", FNCFNM);
190	greg	2.5	printf("\n0\n0\n");
191	greg	1.1	il->dfnum++;
192	greg	2.5	free((char *)Ninv);
193			free((char *)Sinv);
194	greg	1.2	}
195
196
197			illumout(il, ob) /* print illum object */
198			register struct illum_args *il;
199			OBJREC *ob;
200			{
201			double cout[3];
202
203	greg	1.4	if (il->sampdens <= 0)
204			printf("\n%s ", VOIDID);
205			else
206			printf("\n%s%s ", il->matname, DSTSUF);
207			printf("%s %s", ofun[il->flags&IL_LIGHT?MAT_LIGHT:MAT_ILLUM].funame,
208	greg	1.2	il->matname);
209			if (il->flags & IL_LIGHT \|\| !strcmp(il->altmat,VOIDID))
210			printf("\n0");
211			else
212			printf("\n1 %s", il->altmat);
213			if (il->flags & IL_COLAVG) {
214			cout[0] = il->col[0];
215			cout[1] = il->col[1];
216			cout[2] = il->col[2];
217			} else {
218			cout[0] = cout[1] = cout[2] = brt(il->col);
219			}
220	greg	1.3	printf("\n0\n3 %f %f %f\n", cout[0], cout[1], cout[2]);
221	greg	1.2
222			printobj(il->matname, ob);
223	greg	1.1	}
224
225
226	greg	2.5	compavg(col, da, n) /* compute average for set of data values */
227	greg	2.4	float col[3];
228	greg	1.1	register float *da;
229	greg	2.5	int n;
230	greg	1.1	{
231			register int i;
232
233	greg	2.4	col[0] = col[1] = col[2] = 0.;
234	greg	1.1	i = n;
235			while (i-- > 0) {
236	greg	2.4	col[0] += *da++;
237			col[1] += *da++;
238			col[2] += *da++;
239	greg	1.1	}
240			for (i = 0; i < 3; i++)
241	greg	2.5	col[i] /= (double)n;
242	greg	2.4	}
243	greg	1.5
244	greg	2.4
245	greg	2.5	compinv(rinv, rp, m) /* compute other side of row average */
246			register float rinv, rp;
247			int m;
248			{
249			float avg[3];
250
251			compavg(avg, rp, m); /* row average */
252			while (m-- > 0) {
253			rinv++ = 2.avg[0] - *rp++;
254			rinv++ = 2.avg[1] - *rp++;
255			rinv++ = 2.avg[2] - *rp++;
256			}
257			}
258
259
260	greg	2.4	average(il, da, n) /* evaluate average value for distribution */
261			register struct illum_args *il;
262			float *da;
263			int n;
264			{
265	greg	2.5	compavg(il->col, da, n); /* average */
266			if (il->nsamps > 1) {
267			il->col[0] /= (double)il->nsamps;
268			il->col[1] /= (double)il->nsamps;
269			il->col[2] /= (double)il->nsamps;
270			}
271	greg	2.4	/* brighter than minimum? */
272	greg	1.6	return(brt(il->col) > il->minbrt+FTINY);
273	greg	1.1	}
274
275
276	greg	1.6	static int colmcnt = 0; /* count of columns written */
277
278			fputnum(d, fp) /* put out a number to fp */
279			double d;
280			FILE *fp;
281			{
282	greg	2.5	if (colmcnt++ % 5 == 0)
283	greg	1.6	putc('\n', fp);
284			fprintf(fp, " %11e", d);
285			}
286
287
288			fputeol(fp) /* write end of line to fp */
289			register FILE *fp;
290			{
291			putc('\n', fp);
292			colmcnt = 0;
293			}
294
295
296			colorout(p, da, n, m, mult, fp) /* put out color distribution data */
297	greg	1.1	int p;
298			register float *da;
299	greg	1.6	int n, m;
300	greg	1.1	double mult;
301			FILE *fp;
302			{
303	greg	1.6	register int i, j;
304	greg	1.1
305			for (i = 0; i < n; i++) {
306	greg	1.6	for (j = 0; j < m; j++) {
307			fputnum(mult*da[p], fp);
308			da += 3;
309			}
310			fputnum(multda[p-3m], fp); /* wrap phi */
311	greg	1.1	}
312			}
313
314
315	greg	1.6	brightout(da, n, m, mult, fp) /* put out brightness distribution data */
316	greg	1.1	register float *da;
317	greg	1.6	int n, m;
318	greg	1.1	double mult;
319			FILE *fp;
320			{
321	greg	1.6	register int i, j;
322	greg	1.1
323			for (i = 0; i < n; i++) {
324	greg	1.6	for (j = 0; j < m; j++) {
325			fputnum(mult*brt(da), fp);
326			da += 3;
327			}
328			fputnum(multbrt(da-3m), fp); /* wrap phi */
329	greg	1.1	}
330			}