src/gen/mkillum3.c

#ifndef lint
static const char RCSid[] = "$Id: mkillum3.c,v 2.10 2004/09/28 17:54:18 greg Exp $";
#endif
/*
 * Routines to print mkillum objects
 */

#include  "mkillum.h"
#include  "paths.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 */

void compinv(float *rinv, float *rp, int m);
void colorout(int p, float *da, int n, int m, double mult, FILE *fp);
void fputnum(double d, FILE *fp);
void brightout(float *da, int n, int m, double mult, FILE *fp);
void fputeol(FILE *fp);
void compavg(float col[3], float *da, int n);
char * dfname(struct illum_args *il, int c);
FILE * dfopen(struct illum_args *il, int c);


void
printobj(               /* 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(                 /* return data file name */
        struct illum_args  *il,
        int  c
)
{
        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(                 /* 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);
}


extern void
flatout(                /* write hemispherical distribution */
        struct illum_args  *il,
        float  *da,
        int  n,
        int  m,
        FVECT  u,
        FVECT  v,
        FVECT  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((void *)Ninv);
}


extern void
roundout(                       /* write spherical distribution */
        struct illum_args  *il,
        float  *da,
        int  n,
        int  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((void *)Ninv);
        free((void *)Sinv);
}


extern void
illumout(               /* 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);
}


void
compavg(                /* 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;
}


void
compinv(                /* compute other side of row average */
        register float  *rinv,
        register float  *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++;
        }
}


extern int
average(                /* 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 */

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


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


void
colorout(       /* put out color distribution data */
        int  p,
        register float  *da,
        int  n,
        int  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 */
        }
}


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