src/cv/bsdfrbf.c

#ifndef lint
static const char RCSid[] = "$Id: bsdfrbf.c,v 2.4 2013/03/20 01:00:22 greg Exp $";
#endif
/*
 * Radial basis function representation for BSDF data.
 *
 *      G. Ward
 */

#define _USE_MATH_DEFINES
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "bsdfrep.h"

#ifndef RSCA
#define RSCA            2.7             /* radius scaling factor (empirical) */
#endif
                                /* our loaded grid for this incident angle */
GRIDVAL                 dsf_grid[GRIDRES][GRIDRES];

/* Start new DSF input grid */
void
new_bsdf_data(double new_theta, double new_phi)
{
        if (!new_input_direction(new_theta, new_phi))
                exit(1);
        memset(dsf_grid, 0, sizeof(dsf_grid));
}

/* Add BSDF data point */
void
add_bsdf_data(double theta_out, double phi_out, double val, int isDSF)
{
        FVECT   ovec;
        int     pos[2];

        if (!output_orient)             /* check output orientation */
                output_orient = 1 - 2*(theta_out > 90.);
        else if (output_orient > 0 ^ theta_out < 90.) {
                fputs("Cannot handle output angles on both sides of surface\n",
                                stderr);
                exit(1);
        }
        ovec[2] = sin((M_PI/180.)*theta_out);
        ovec[0] = cos((M_PI/180.)*phi_out) * ovec[2];
        ovec[1] = sin((M_PI/180.)*phi_out) * ovec[2];
        ovec[2] = sqrt(1. - ovec[2]*ovec[2]);

        if (!isDSF)
                val *= ovec[2];         /* convert from BSDF to DSF */

                                        /* update BSDF histogram */
        if (val < BSDF2BIG*ovec[2] && val > BSDF2SML*ovec[2])
                ++bsdf_hist[histndx(val/ovec[2])];

        pos_from_vec(pos, ovec);

        dsf_grid[pos[0]][pos[1]].vsum += val;
        dsf_grid[pos[0]][pos[1]].nval++;
}

/* Compute radii for non-empty bins */
/* (distance to furthest empty bin for which non-empty bin is the closest) */
static void
compute_radii(void)
{
        unsigned int    fill_grid[GRIDRES][GRIDRES];
        unsigned short  fill_cnt[GRIDRES][GRIDRES];
        FVECT           ovec0, ovec1;
        double          ang2, lastang2;
        int             r, i, j, jn, ii, jj, inear, jnear;

        r = GRIDRES/2;                          /* proceed in zig-zag */
        for (i = 0; i < GRIDRES; i++)
            for (jn = 0; jn < GRIDRES; jn++) {
                j = (i&1) ? jn : GRIDRES-1-jn;
                if (dsf_grid[i][j].nval)        /* find empty grid pos. */
                        continue;
                ovec_from_pos(ovec0, i, j);
                inear = jnear = -1;             /* find nearest non-empty */
                lastang2 = M_PI*M_PI;
                for (ii = i-r; ii <= i+r; ii++) {
                    if (ii < 0) continue;
                    if (ii >= GRIDRES) break;
                    for (jj = j-r; jj <= j+r; jj++) {
                        if (jj < 0) continue;
                        if (jj >= GRIDRES) break;
                        if (!dsf_grid[ii][jj].nval)
                                continue;
                        ovec_from_pos(ovec1, ii, jj);
                        ang2 = 2. - 2.*DOT(ovec0,ovec1);
                        if (ang2 >= lastang2)
                                continue;
                        lastang2 = ang2;
                        inear = ii; jnear = jj;
                    }
                }
                if (inear < 0) {
                        fprintf(stderr,
                                "%s: Could not find non-empty neighbor!\n",
                                        progname);
                        exit(1);
                }
                ang2 = sqrt(lastang2);
                r = ANG2R(ang2);                /* record if > previous */
                if (r > dsf_grid[inear][jnear].crad)
                        dsf_grid[inear][jnear].crad = r;
                                                /* next search radius */
                r = ang2*(2.*GRIDRES/M_PI) + 3;
            }
                                                /* blur radii over hemisphere */
        memset(fill_grid, 0, sizeof(fill_grid));
        memset(fill_cnt, 0, sizeof(fill_cnt));
        for (i = 0; i < GRIDRES; i++)
            for (j = 0; j < GRIDRES; j++) {
                if (!dsf_grid[i][j].crad)
                        continue;               /* missing distance */
                r = R2ANG(dsf_grid[i][j].crad)*(2.*RSCA*GRIDRES/M_PI);
                for (ii = i-r; ii <= i+r; ii++) {
                    if (ii < 0) continue;
                    if (ii >= GRIDRES) break;
                    for (jj = j-r; jj <= j+r; jj++) {
                        if (jj < 0) continue;
                        if (jj >= GRIDRES) break;
                        if ((ii-i)*(ii-i) + (jj-j)*(jj-j) > r*r)
                                continue;
                        fill_grid[ii][jj] += dsf_grid[i][j].crad;
                        fill_cnt[ii][jj]++;
                    }
                }
            }
                                                /* copy back blurred radii */
        for (i = 0; i < GRIDRES; i++)
            for (j = 0; j < GRIDRES; j++)
                if (fill_cnt[i][j])
                        dsf_grid[i][j].crad = fill_grid[i][j]/fill_cnt[i][j];
}

/* Cull points for more uniform distribution, leave all nval 0 or 1 */
static void
cull_values(void)
{
        FVECT   ovec0, ovec1;
        double  maxang, maxang2;
        int     i, j, ii, jj, r;
                                                /* simple greedy algorithm */
        for (i = 0; i < GRIDRES; i++)
            for (j = 0; j < GRIDRES; j++) {
                if (!dsf_grid[i][j].nval)
                        continue;
                if (!dsf_grid[i][j].crad)
                        continue;               /* shouldn't happen */
                ovec_from_pos(ovec0, i, j);
                maxang = 2.*R2ANG(dsf_grid[i][j].crad);
                if (maxang > ovec0[2])          /* clamp near horizon */
                        maxang = ovec0[2];
                r = maxang*(2.*GRIDRES/M_PI) + 1;
                maxang2 = maxang*maxang;
                for (ii = i-r; ii <= i+r; ii++) {
                    if (ii < 0) continue;
                    if (ii >= GRIDRES) break;
                    for (jj = j-r; jj <= j+r; jj++) {
                        if (jj < 0) continue;
                        if (jj >= GRIDRES) break;
                        if (!dsf_grid[ii][jj].nval)
                                continue;
                        if ((ii == i) & (jj == j))
                                continue;       /* don't get self-absorbed */
                        ovec_from_pos(ovec1, ii, jj);
                        if (2. - 2.*DOT(ovec0,ovec1) >= maxang2)
                                continue;
                                                /* absorb sum */
                        dsf_grid[i][j].vsum += dsf_grid[ii][jj].vsum;
                        dsf_grid[i][j].nval += dsf_grid[ii][jj].nval;
                                                /* keep value, though */
                        dsf_grid[ii][jj].vsum /= (float)dsf_grid[ii][jj].nval;
                        dsf_grid[ii][jj].nval = 0;
                    }
                }
            }
                                                /* final averaging pass */
        for (i = 0; i < GRIDRES; i++)
            for (j = 0; j < GRIDRES; j++)
                if (dsf_grid[i][j].nval > 1) {
                        dsf_grid[i][j].vsum /= (float)dsf_grid[i][j].nval;
                        dsf_grid[i][j].nval = 1;
                }
}

/* Compute minimum BSDF from histogram and clear it */
static void
comp_bsdf_min()
{
        int     cnt;
        int     i, target;

        cnt = 0;
        for (i = HISTLEN; i--; )
                cnt += bsdf_hist[i];
        if (!cnt) {                             /* shouldn't happen */
                bsdf_min = 0;
                return;
        }
        target = cnt/100;                       /* ignore bottom 1% */
        cnt = 0;
        for (i = 0; cnt <= target; i++)
                cnt += bsdf_hist[i];
        bsdf_min = histval(i-1);
        memset(bsdf_hist, 0, sizeof(bsdf_hist));
}

/* Count up filled nodes and build RBF representation from current grid */ 
RBFNODE *
make_rbfrep(void)
{
        int     niter = 16;
        double  lastVar, thisVar = 100.;
        int     nn;
        RBFNODE *newnode;
        RBFVAL  *itera;
        int     i, j;
                                /* compute RBF radii */
        compute_radii();
                                /* coagulate lobes */
        cull_values();
        nn = 0;                 /* count selected bins */
        for (i = 0; i < GRIDRES; i++)
            for (j = 0; j < GRIDRES; j++)
                nn += dsf_grid[i][j].nval;
                                /* compute minimum BSDF */
        comp_bsdf_min();
                                /* allocate RBF array */
        newnode = (RBFNODE *)malloc(sizeof(RBFNODE) + sizeof(RBFVAL)*(nn-1));
        if (newnode == NULL)
                goto memerr;
        newnode->ord = -1;
        newnode->next = NULL;
        newnode->ejl = NULL;
        newnode->invec[2] = sin((M_PI/180.)*theta_in_deg);
        newnode->invec[0] = cos((M_PI/180.)*phi_in_deg)*newnode->invec[2];
        newnode->invec[1] = sin((M_PI/180.)*phi_in_deg)*newnode->invec[2];
        newnode->invec[2] = input_orient*sqrt(1. - newnode->invec[2]*newnode->invec[2]);
        newnode->vtotal = 0;
        newnode->nrbf = nn;
        nn = 0;                 /* fill RBF array */
        for (i = 0; i < GRIDRES; i++)
            for (j = 0; j < GRIDRES; j++)
                if (dsf_grid[i][j].nval) {
                        newnode->rbfa[nn].peak = dsf_grid[i][j].vsum;
                        newnode->rbfa[nn].crad = RSCA*dsf_grid[i][j].crad + .5;
                        newnode->rbfa[nn].gx = i;
                        newnode->rbfa[nn].gy = j;
                        ++nn;
                }
                                /* iterate to improve interpolation accuracy */
        itera = (RBFVAL *)malloc(sizeof(RBFVAL)*newnode->nrbf);
        if (itera == NULL)
                goto memerr;
        memcpy(itera, newnode->rbfa, sizeof(RBFVAL)*newnode->nrbf);
        do {
                double  dsum = 0, dsum2 = 0;
                nn = 0;
                for (i = 0; i < GRIDRES; i++)
                    for (j = 0; j < GRIDRES; j++)
                        if (dsf_grid[i][j].nval) {
                                FVECT   odir;
                                double  corr;
                                ovec_from_pos(odir, i, j);
                                itera[nn++].peak *= corr =
                                        dsf_grid[i][j].vsum /
                                                eval_rbfrep(newnode, odir);
                                dsum += 1. - corr;
                                dsum2 += (1.-corr)*(1.-corr);
                        }
                memcpy(newnode->rbfa, itera, sizeof(RBFVAL)*newnode->nrbf);
                lastVar = thisVar;
                thisVar = dsum2/(double)nn;
#ifdef DEBUG
                fprintf(stderr, "Avg., RMS error: %.1f%%  %.1f%%\n",
                                        100.*dsum/(double)nn,
                                        100.*sqrt(thisVar));
#endif
        } while (--niter > 0 && lastVar-thisVar > 0.02*lastVar);

        free(itera);
        nn = 0;                 /* compute sum for normalization */
        while (nn < newnode->nrbf)
                newnode->vtotal += rbf_volume(&newnode->rbfa[nn++]);
#ifdef DEBUG
        fprintf(stderr, "Integrated DSF at (%.1f,%.1f) deg. is %.2f\n",
                        get_theta180(newnode->invec), get_phi360(newnode->invec),
                        newnode->vtotal);
#endif
        insert_dsf(newnode);

        return(newnode);
memerr:
        fprintf(stderr, "%s: Out of memory in make_rbfrep()\n", progname);
        exit(1);
}
Revision:	2.5
Committed:	Fri Jun 28 23:18:51 2013 UTC (10 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.4:	+25 -1 lines
Log Message:	Fixed calculation of bsdf_min
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.5	static const char RCSid[] = "$Id: bsdfrbf.c,v 2.4 2013/03/20 01:00:22 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Radial basis function representation for BSDF data.
6			*
7			* G. Ward
8			*/
9
10			#define _USE_MATH_DEFINES
11			#include <stdio.h>
12			#include <stdlib.h>
13			#include <string.h>
14			#include <math.h>
15			#include "bsdfrep.h"
16
17			#ifndef RSCA
18			#define RSCA 2.7 /* radius scaling factor (empirical) */
19			#endif
20			/* our loaded grid for this incident angle */
21			GRIDVAL dsf_grid[GRIDRES][GRIDRES];
22
23			/* Start new DSF input grid */
24			void
25			new_bsdf_data(double new_theta, double new_phi)
26			{
27			if (!new_input_direction(new_theta, new_phi))
28			exit(1);
29			memset(dsf_grid, 0, sizeof(dsf_grid));
30			}
31
32			/* Add BSDF data point */
33			void
34			add_bsdf_data(double theta_out, double phi_out, double val, int isDSF)
35			{
36			FVECT ovec;
37			int pos[2];
38
39			if (!output_orient) /* check output orientation */
40			output_orient = 1 - 2*(theta_out > 90.);
41			else if (output_orient > 0 ^ theta_out < 90.) {
42			fputs("Cannot handle output angles on both sides of surface\n",
43			stderr);
44			exit(1);
45			}
46			ovec[2] = sin((M_PI/180.)*theta_out);
47			ovec[0] = cos((M_PI/180.)phi_out) ovec[2];
48			ovec[1] = sin((M_PI/180.)phi_out) ovec[2];
49			ovec[2] = sqrt(1. - ovec[2]*ovec[2]);
50
51			if (!isDSF)
52			val = ovec[2]; / convert from BSDF to DSF */
53
54	greg	2.4	/* update BSDF histogram */
55			if (val < BSDF2BIGovec[2] && val > BSDF2SMLovec[2])
56			++bsdf_hist[histndx(val/ovec[2])];
57
58	greg	2.1	pos_from_vec(pos, ovec);
59
60			dsf_grid[pos[0]][pos[1]].vsum += val;
61			dsf_grid[pos[0]][pos[1]].nval++;
62			}
63
64			/* Compute radii for non-empty bins */
65			/* (distance to furthest empty bin for which non-empty bin is the closest) */
66			static void
67			compute_radii(void)
68			{
69			unsigned int fill_grid[GRIDRES][GRIDRES];
70			unsigned short fill_cnt[GRIDRES][GRIDRES];
71			FVECT ovec0, ovec1;
72			double ang2, lastang2;
73			int r, i, j, jn, ii, jj, inear, jnear;
74
75			r = GRIDRES/2; /* proceed in zig-zag */
76			for (i = 0; i < GRIDRES; i++)
77			for (jn = 0; jn < GRIDRES; jn++) {
78			j = (i&1) ? jn : GRIDRES-1-jn;
79			if (dsf_grid[i][j].nval) /* find empty grid pos. */
80			continue;
81			ovec_from_pos(ovec0, i, j);
82			inear = jnear = -1; /* find nearest non-empty */
83			lastang2 = M_PI*M_PI;
84			for (ii = i-r; ii <= i+r; ii++) {
85			if (ii < 0) continue;
86			if (ii >= GRIDRES) break;
87			for (jj = j-r; jj <= j+r; jj++) {
88			if (jj < 0) continue;
89			if (jj >= GRIDRES) break;
90			if (!dsf_grid[ii][jj].nval)
91			continue;
92			ovec_from_pos(ovec1, ii, jj);
93			ang2 = 2. - 2.*DOT(ovec0,ovec1);
94			if (ang2 >= lastang2)
95			continue;
96			lastang2 = ang2;
97			inear = ii; jnear = jj;
98			}
99			}
100			if (inear < 0) {
101			fprintf(stderr,
102			"%s: Could not find non-empty neighbor!\n",
103			progname);
104			exit(1);
105			}
106			ang2 = sqrt(lastang2);
107			r = ANG2R(ang2); /* record if > previous */
108			if (r > dsf_grid[inear][jnear].crad)
109			dsf_grid[inear][jnear].crad = r;
110			/* next search radius */
111			r = ang2(2.GRIDRES/M_PI) + 3;
112			}
113			/* blur radii over hemisphere */
114			memset(fill_grid, 0, sizeof(fill_grid));
115			memset(fill_cnt, 0, sizeof(fill_cnt));
116			for (i = 0; i < GRIDRES; i++)
117			for (j = 0; j < GRIDRES; j++) {
118			if (!dsf_grid[i][j].crad)
119			continue; /* missing distance */
120			r = R2ANG(dsf_grid[i][j].crad)(2.RSCA*GRIDRES/M_PI);
121			for (ii = i-r; ii <= i+r; ii++) {
122			if (ii < 0) continue;
123			if (ii >= GRIDRES) break;
124			for (jj = j-r; jj <= j+r; jj++) {
125			if (jj < 0) continue;
126			if (jj >= GRIDRES) break;
127			if ((ii-i)(ii-i) + (jj-j)(jj-j) > r*r)
128			continue;
129			fill_grid[ii][jj] += dsf_grid[i][j].crad;
130			fill_cnt[ii][jj]++;
131			}
132			}
133			}
134			/* copy back blurred radii */
135			for (i = 0; i < GRIDRES; i++)
136			for (j = 0; j < GRIDRES; j++)
137			if (fill_cnt[i][j])
138			dsf_grid[i][j].crad = fill_grid[i][j]/fill_cnt[i][j];
139			}
140
141			/* Cull points for more uniform distribution, leave all nval 0 or 1 */
142			static void
143			cull_values(void)
144			{
145			FVECT ovec0, ovec1;
146			double maxang, maxang2;
147			int i, j, ii, jj, r;
148			/* simple greedy algorithm */
149			for (i = 0; i < GRIDRES; i++)
150			for (j = 0; j < GRIDRES; j++) {
151			if (!dsf_grid[i][j].nval)
152			continue;
153			if (!dsf_grid[i][j].crad)
154			continue; /* shouldn't happen */
155			ovec_from_pos(ovec0, i, j);
156			maxang = 2.*R2ANG(dsf_grid[i][j].crad);
157			if (maxang > ovec0[2]) /* clamp near horizon */
158			maxang = ovec0[2];
159			r = maxang(2.GRIDRES/M_PI) + 1;
160			maxang2 = maxang*maxang;
161			for (ii = i-r; ii <= i+r; ii++) {
162			if (ii < 0) continue;
163			if (ii >= GRIDRES) break;
164			for (jj = j-r; jj <= j+r; jj++) {
165			if (jj < 0) continue;
166			if (jj >= GRIDRES) break;
167			if (!dsf_grid[ii][jj].nval)
168			continue;
169			if ((ii == i) & (jj == j))
170			continue; /* don't get self-absorbed */
171			ovec_from_pos(ovec1, ii, jj);
172			if (2. - 2.*DOT(ovec0,ovec1) >= maxang2)
173			continue;
174			/* absorb sum */
175			dsf_grid[i][j].vsum += dsf_grid[ii][jj].vsum;
176			dsf_grid[i][j].nval += dsf_grid[ii][jj].nval;
177			/* keep value, though */
178			dsf_grid[ii][jj].vsum /= (float)dsf_grid[ii][jj].nval;
179			dsf_grid[ii][jj].nval = 0;
180			}
181			}
182			}
183			/* final averaging pass */
184			for (i = 0; i < GRIDRES; i++)
185			for (j = 0; j < GRIDRES; j++)
186			if (dsf_grid[i][j].nval > 1) {
187			dsf_grid[i][j].vsum /= (float)dsf_grid[i][j].nval;
188			dsf_grid[i][j].nval = 1;
189			}
190			}
191
192	greg	2.5	/* Compute minimum BSDF from histogram and clear it */
193			static void
194			comp_bsdf_min()
195			{
196			int cnt;
197			int i, target;
198
199			cnt = 0;
200			for (i = HISTLEN; i--; )
201			cnt += bsdf_hist[i];
202			if (!cnt) { /* shouldn't happen */
203			bsdf_min = 0;
204			return;
205			}
206			target = cnt/100; /* ignore bottom 1% */
207			cnt = 0;
208			for (i = 0; cnt <= target; i++)
209			cnt += bsdf_hist[i];
210			bsdf_min = histval(i-1);
211			memset(bsdf_hist, 0, sizeof(bsdf_hist));
212			}
213
214	greg	2.1	/* Count up filled nodes and build RBF representation from current grid */
215			RBFNODE *
216			make_rbfrep(void)
217			{
218			int niter = 16;
219			double lastVar, thisVar = 100.;
220			int nn;
221			RBFNODE *newnode;
222	greg	2.2	RBFVAL *itera;
223	greg	2.1	int i, j;
224			/* compute RBF radii */
225			compute_radii();
226			/* coagulate lobes */
227			cull_values();
228			nn = 0; /* count selected bins */
229			for (i = 0; i < GRIDRES; i++)
230			for (j = 0; j < GRIDRES; j++)
231			nn += dsf_grid[i][j].nval;
232	greg	2.5	/* compute minimum BSDF */
233			comp_bsdf_min();
234	greg	2.1	/* allocate RBF array */
235			newnode = (RBFNODE )malloc(sizeof(RBFNODE) + sizeof(RBFVAL)(nn-1));
236	greg	2.2	if (newnode == NULL)
237			goto memerr;
238	greg	2.1	newnode->ord = -1;
239			newnode->next = NULL;
240			newnode->ejl = NULL;
241			newnode->invec[2] = sin((M_PI/180.)*theta_in_deg);
242			newnode->invec[0] = cos((M_PI/180.)phi_in_deg)newnode->invec[2];
243			newnode->invec[1] = sin((M_PI/180.)phi_in_deg)newnode->invec[2];
244			newnode->invec[2] = input_orientsqrt(1. - newnode->invec[2]newnode->invec[2]);
245			newnode->vtotal = 0;
246			newnode->nrbf = nn;
247			nn = 0; /* fill RBF array */
248			for (i = 0; i < GRIDRES; i++)
249			for (j = 0; j < GRIDRES; j++)
250			if (dsf_grid[i][j].nval) {
251			newnode->rbfa[nn].peak = dsf_grid[i][j].vsum;
252			newnode->rbfa[nn].crad = RSCA*dsf_grid[i][j].crad + .5;
253			newnode->rbfa[nn].gx = i;
254			newnode->rbfa[nn].gy = j;
255			++nn;
256			}
257			/* iterate to improve interpolation accuracy */
258	greg	2.2	itera = (RBFVAL )malloc(sizeof(RBFVAL)newnode->nrbf);
259			if (itera == NULL)
260			goto memerr;
261			memcpy(itera, newnode->rbfa, sizeof(RBFVAL)*newnode->nrbf);
262	greg	2.1	do {
263			double dsum = 0, dsum2 = 0;
264			nn = 0;
265			for (i = 0; i < GRIDRES; i++)
266			for (j = 0; j < GRIDRES; j++)
267			if (dsf_grid[i][j].nval) {
268			FVECT odir;
269			double corr;
270			ovec_from_pos(odir, i, j);
271	greg	2.2	itera[nn++].peak *= corr =
272	greg	2.1	dsf_grid[i][j].vsum /
273			eval_rbfrep(newnode, odir);
274	greg	2.2	dsum += 1. - corr;
275			dsum2 += (1.-corr)*(1.-corr);
276	greg	2.1	}
277	greg	2.2	memcpy(newnode->rbfa, itera, sizeof(RBFVAL)*newnode->nrbf);
278	greg	2.1	lastVar = thisVar;
279			thisVar = dsum2/(double)nn;
280			#ifdef DEBUG
281			fprintf(stderr, "Avg., RMS error: %.1f%% %.1f%%\n",
282			100.*dsum/(double)nn,
283			100.*sqrt(thisVar));
284			#endif
285			} while (--niter > 0 && lastVar-thisVar > 0.02*lastVar);
286
287	greg	2.2	free(itera);
288	greg	2.1	nn = 0; /* compute sum for normalization */
289			while (nn < newnode->nrbf)
290			newnode->vtotal += rbf_volume(&newnode->rbfa[nn++]);
291	greg	2.3	#ifdef DEBUG
292			fprintf(stderr, "Integrated DSF at (%.1f,%.1f) deg. is %.2f\n",
293			get_theta180(newnode->invec), get_phi360(newnode->invec),
294			newnode->vtotal);
295			#endif
296	greg	2.1	insert_dsf(newnode);
297
298			return(newnode);
299	greg	2.2	memerr:
300			fprintf(stderr, "%s: Out of memory in make_rbfrep()\n", progname);
301			exit(1);
302	greg	2.1	}