ViewVC Help

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

root/Development/ray/src/common/bsdf_t.c

Comparing ray/src/common/bsdf_t.c (file contents):
Revision 3.9 by greg, Wed Apr 27 23:05:51 2011 UTC vs.
Revision 3.24 by greg, Sun Sep 2 15:33:15 2012 UTC

#	Line 10 | Line 10 | static const char RCSid[] = "$Id$";
10		*
11		*/
12
13	+	#define _USE_MATH_DEFINES
14		#include "rtio.h"
15		#include <stdlib.h>
16		#include <math.h>
#	Line 25 | Line 26 | typedef int    SDtreCallback(float val, const double *cmi
26
27		/* reference width maximum (1.0) */
28		static const unsigned   iwbits = sizeof(unsigned)*4;
29	<	static const unsigned   iwmax = (1<<(sizeof(unsigned)*4))-1;
29	>	static const unsigned   iwmax = 1<<(sizeof(unsigned)*4);
30		/* maximum cumulative value */
31		static const unsigned   cumlmax = ~0;
32	+	/* constant z-vector */
33	+	static const FVECT      zvec = {.0, .0, 1.};
34	+	/* quantization value */
35	+	static double           quantum = 1./256.;
36
37		/* Struct used for our distribution-building callback */
38		typedef struct {
39	<	int             nic;            /* number of input coordinates */
39	>	short           nic;            /* number of input coordinates */
40	>	short           rev;            /* reversing query */
41		unsigned        alen;           /* current array length */
42		unsigned        nall;           /* number of allocated entries */
43		unsigned        wmin;           /* minimum square size so far */
#	Line 61 | Line 67 | SDnewNode(int nd, int lg)
67		if (lg < 0) {
68		st = (SDNode *)malloc(sizeof(SDNode) +
69		sizeof(st->u.t[0])*((1<<nd) - 1));
70	<	if (st != NULL)
65	<	memset(st->u.t, 0, sizeof(st->u.t[0])<<nd);
66	<	} else
67	<	st = (SDNode *)malloc(sizeof(SDNode) +
68	<	sizeof(st->u.v[0])*((1 << nd*lg) - 1));
69	<
70	<	if (st == NULL) {
71	<	if (lg < 0)
70	>	if (st == NULL) {
71		sprintf(SDerrorDetail,
72		"Cannot allocate %d branch BSDF tree", 1<<nd);
73	<	else
73	>	return NULL;
74	>	}
75	>	memset(st->u.t, 0, sizeof(st->u.t[0])<<nd);
76	>	} else {
77	>	st = (SDNode *)malloc(sizeof(SDNode) +
78	>	sizeof(st->u.v[0])*((1 << nd*lg) - 1));
79	>	if (st == NULL) {
80		sprintf(SDerrorDetail,
81		"Cannot allocate %d BSDF leaves", 1 << nd*lg);
82	<	return NULL;
82	>	return NULL;
83	>	}
84		}
85		st->ndim = nd;
86		st->log2GR = lg;
#	Line 85 | Line 91 | SDnewNode(int nd, int lg)
91		static void
92		SDfreeTre(SDNode *st)
93		{
94	<	int     i;
94	>	int     n;
95
96		if (st == NULL)
97		return;
98	<	for (i = (st->log2GR < 0) << st->ndim; i--; )
99	<	SDfreeTre(st->u.t[i]);
100	<	free((void *)st);
98	>	for (n = (st->log2GR < 0) << st->ndim; n--; )
99	>	SDfreeTre(st->u.t[n]);
100	>	free(st);
101		}
102
103		/* Free a variable-resolution BSDF */
#	Line 125 | Line 131 | fill_grid_branch(float *dptr, const float *sptr, int n
131		static float *
132		grid_branch_start(SDNode *st, int n)
133		{
134	<	unsigned        skipsiz = 1 << st->log2GR;
134	>	unsigned        skipsiz = 1 << (st->log2GR - 1);
135		float           *vptr = st->u.v;
136		int             i;
137
138		for (i = st->ndim; i--; skipsiz <<= st->log2GR)
139		if (1<<i & n)
140	<	vptr += skipsiz >> 1;
140	>	vptr += skipsiz;
141		return vptr;
142		}
143
#	Line 187 | Line 193 | SDsmallestLeaf(const SDNode *st)
193		static double
194		SDiterSum(const float *va, int nd, int shft, const int *imin, const int *imax)
195		{
196	<	const unsigned  skipsiz = 1 << nd*shft;
196	>	const unsigned  skipsiz = 1 << --nd*shft;
197		double          sum = .0;
198		int             i;
199	<
199	>
200	>	va += *imin * skipsiz;
201	>
202		if (skipsiz == 1)
203		for (i = *imin; i < *imax; i++)
204	<	sum += va[i];
204	>	sum += *va++;
205		else
206	<	for (i = *imin; i < *imax; i++)
207	<	sum += SDiterSum(va + i*skipsiz,
200	<	nd-1, shft, imin+1, imax+1);
206	>	for (i = *imin; i < *imax; i++, va += skipsiz)
207	>	sum += SDiterSum(va, nd, shft, imin+1, imax+1);
208		return sum;
209		}
210
#	Line 205 | Line 212 | SDiterSum(const float *va, int nd, int shft, const int
212		static double
213		SDavgTreBox(const SDNode *st, const double *bmin, const double *bmax)
214		{
208	–	int             imin[SD_MAXDIM], imax[SD_MAXDIM];
215		unsigned        n;
216		int             i;
217
#	Line 215 | Line 221 | SDavgTreBox(const SDNode *st, const double *bmin, cons
221		for (i = st->ndim; i--; ) {
222		if (bmin[i] >= 1.)
223		return .0;
224	<	if (bmax[i] <= .0)
224	>	if (bmax[i] <= 0)
225		return .0;
226		if (bmin[i] >= bmax[i])
227		return .0;
#	Line 223 | Line 229 | SDavgTreBox(const SDNode *st, const double *bmin, cons
229		if (st->log2GR < 0) {           /* iterate on subtree */
230		double          sum = .0, wsum = 1e-20;
231		double          sbmin[SD_MAXDIM], sbmax[SD_MAXDIM], w;
226	–
232		for (n = 1 << st->ndim; n--; ) {
233		w = 1.;
234		for (i = st->ndim; i--; ) {
#	Line 235 | Line 240 | SDavgTreBox(const SDNode *st, const double *bmin, cons
240		}
241		if (sbmin[i] < .0) sbmin[i] = .0;
242		if (sbmax[i] > 1.) sbmax[i] = 1.;
243	+	if (sbmin[i] >= sbmax[i]) {
244	+	w = .0;
245	+	break;
246	+	}
247		w *= sbmax[i] - sbmin[i];
248		}
249		if (w > 1e-10) {
#	Line 243 | Line 252 | SDavgTreBox(const SDNode *st, const double *bmin, cons
252		}
253		}
254		return sum / wsum;
255	+	} else {                        /* iterate over leaves */
256	+	int             imin[SD_MAXDIM], imax[SD_MAXDIM];
257	+
258	+	n = 1;
259	+	for (i = st->ndim; i--; ) {
260	+	imin[i] = (bmin[i] <= 0) ? 0 :
261	+	(int)((1 << st->log2GR)*bmin[i]);
262	+	imax[i] = (bmax[i] >= 1.) ? (1 << st->log2GR) :
263	+	(int)((1 << st->log2GR)*bmax[i] + .999999);
264	+	n *= imax[i] - imin[i];
265	+	}
266	+	if (n)
267	+	return SDiterSum(st->u.v, st->ndim,
268	+	st->log2GR, imin, imax) / (double)n;
269		}
270	<	n = 1;                          /* iterate over leaves */
248	<	for (i = st->ndim; i--; ) {
249	<	imin[i] = (bmin[i] <= 0) ? 0
250	<	: (int)((1 << st->log2GR)*bmin[i]);
251	<	imax[i] = (bmax[i] >= 1.) ? (1 << st->log2GR)
252	<	: (int)((1 << st->log2GR)*bmax[i] + .999999);
253	<	n *= imax[i] - imin[i];
254	<	}
255	<	if (!n)
256	<	return .0;
257	<
258	<	return SDiterSum(st->u.v, st->ndim, st->log2GR, imin, imax) / (double)n;
270	>	return .0;
271		}
272
273		/* Recursive call for SDtraverseTre() */
#	Line 270 | Line 282 | SDdotravTre(const SDNode *st, const double *pos, int c
282		/* in branches? */
283		if (st->log2GR < 0) {
284		unsigned        skipmask = 0;
273	–
285		csiz *= .5;
286		for (i = st->ndim; i--; )
287		if (1<<i & cmask)
288		if (pos[i] < cmin[i] + csiz)
289	<	for (n = 1 << st->ndim; n--; )
289	>	for (n = 1 << st->ndim; n--; ) {
290		if (n & 1<<i)
291		skipmask |= 1<<n;
292	+	}
293		else
294	<	for (n = 1 << st->ndim; n--; )
294	>	for (n = 1 << st->ndim; n--; ) {
295		if (!(n & 1<<i))
296		skipmask |= 1<<n;
297	+	}
298		for (n = 1 << st->ndim; n--; ) {
299		if (1<<n & skipmask)
300		continue;
#	Line 315 | Line 328 | SDdotravTre(const SDNode *st, const double *pos, int c
328		clim[i][0] = 0;
329		clim[i][1] = 1 << st->log2GR;
330		}
318	–	/* fill in unused dimensions */
319	–	for (i = SD_MAXDIM; i-- > st->ndim; ) {
320	–	clim[i][0] = 0; clim[i][1] = 1;
321	–	}
331		#if (SD_MAXDIM == 4)
332		bmin[0] = cmin[0] + csiz*clim[0][0];
333		for (cpos[0] = clim[0][0]; cpos[0] < clim[0][1]; cpos[0]++) {
334		bmin[1] = cmin[1] + csiz*clim[1][0];
335		for (cpos[1] = clim[1][0]; cpos[1] < clim[1][1]; cpos[1]++) {
336		bmin[2] = cmin[2] + csiz*clim[2][0];
337	<	for (cpos[2] = clim[2][0]; cpos[2] < clim[2][1]; cpos[2]++) {
338	<	bmin[3] = cmin[3] + csiz*(cpos[3] = clim[3][0]);
337	>	if (st->ndim == 3) {
338	>	cpos[2] = clim[2][0];
339		n = cpos[0];
340	<	for (i = 1; i < st->ndim; i++)
340	>	for (i = 1; i < 3; i++)
341		n = (n << st->log2GR) + cpos[i];
342	<	for ( ; cpos[3] < clim[3][1]; cpos[3]++) {
342	>	for ( ; cpos[2] < clim[2][1]; cpos[2]++) {
343		rval += rv = (*cf)(st->u.v[n++], bmin, csiz, cptr);
344		if (rv < 0)
345		return rv;
346	<	bmin[3] += csiz;
346	>	bmin[2] += csiz;
347		}
348	<	bmin[2] += csiz;
348	>	} else {
349	>	for (cpos[2] = clim[2][0]; cpos[2] < clim[2][1]; cpos[2]++) {
350	>	bmin[3] = cmin[3] + csiz*(cpos[3] = clim[3][0]);
351	>	n = cpos[0];
352	>	for (i = 1; i < 4; i++)
353	>	n = (n << st->log2GR) + cpos[i];
354	>	for ( ; cpos[3] < clim[3][1]; cpos[3]++) {
355	>	rval += rv = (*cf)(st->u.v[n++], bmin, csiz, cptr);
356	>	if (rv < 0)
357	>	return rv;
358	>	bmin[3] += csiz;
359	>	}
360	>	bmin[2] += csiz;
361	>	}
362		}
363		bmin[1] += csiz;
364		}
#	Line 411 | Line 433 | SDlookupTre(const SDNode *st, const double *pos, doubl
433		static float
434		SDqueryTre(const SDTre *sdt, const FVECT outVec, const FVECT inVec, double *hc)
435		{
436	<	static const FVECT      zvec = {.0, .0, 1.};
437	<	FVECT                   rOutVec;
438	<	double                  gridPos[4];
436	>	const RREAL     *vtmp;
437	>	FVECT           rOutVec;
438	>	double          gridPos[4];
439
440		switch (sdt->sidef) {           /* whose side are you on? */
441	<	case SD_UFRONT:
441	>	case SD_FREFL:
442		if ((outVec[2] < 0) | (inVec[2] < 0))
443		return -1.;
444		break;
445	<	case SD_UBACK:
445	>	case SD_BREFL:
446		if ((outVec[2] > 0) | (inVec[2] > 0))
447		return -1.;
448		break;
449	<	case SD_XMIT:
450	<	if ((outVec[2] > 0) == (inVec[2] > 0))
449	>	case SD_FXMIT:
450	>	if (outVec[2] > 0) {
451	>	if (inVec[2] > 0)
452	>	return -1.;
453	>	vtmp = outVec; outVec = inVec; inVec = vtmp;
454	>	} else if (inVec[2] < 0)
455		return -1.;
456		break;
457	+	case SD_BXMIT:
458	+	if (inVec[2] > 0) {
459	+	if (outVec[2] > 0)
460	+	return -1.;
461	+	vtmp = outVec; outVec = inVec; inVec = vtmp;
462	+	} else if (outVec[2] < 0)
463	+	return -1.;
464	+	break;
465		default:
466		return -1.;
467		}
468		/* convert vector coordinates */
469		if (sdt->st->ndim == 3) {
470	<	spinvector(rOutVec, outVec, zvec, -atan2(inVec[1],inVec[0]));
470	>	spinvector(rOutVec, outVec, zvec, -atan2(-inVec[1],-inVec[0]));
471		gridPos[0] = .5 - .5*sqrt(inVec[0]*inVec[0] + inVec[1]*inVec[1]);
472		SDdisk2square(gridPos+1, rOutVec[0], rOutVec[1]);
473		} else if (sdt->st->ndim == 4) {
#	Line 467 | Line 501 | build_scaffold(float val, const double *cmin, double c
501		int             wid = csiz*(double)iwmax + .5;
502		bitmask_t       bmin[2], bmax[2];
503
504	<	cmin += sp->nic;                /* skip to output coords */
504	>	cmin += sp->nic * !sp->rev;     /* skip to output coords */
505		if (wid < sp->wmin)             /* new minimum width? */
506		sp->wmin = wid;
507		if (wid > sp->wmax)             /* new maximum? */
508		sp->wmax = wid;
509		if (sp->alen >= sp->nall) {     /* need more space? */
510		struct outdir_s *ndarr;
511	<	sp->nall += 8192;
511	>	sp->nall += 1024;
512		ndarr = (struct outdir_s *)realloc(sp->darr,
513		sizeof(struct outdir_s)*sp->nall);
514	<	if (ndarr == NULL)
514	>	if (ndarr == NULL) {
515	>	sprintf(SDerrorDetail,
516	>	"Cannot grow scaffold to %u entries", sp->nall);
517		return -1;      /* abort build */
518	+	}
519		sp->darr = ndarr;
520		}
521		/* find Hilbert entry index */
522		bmin[0] = cmin[0]*(double)iwmax + .5;
523		bmin[1] = cmin[1]*(double)iwmax + .5;
524	<	bmax[0] = bmin[0] + wid;
525	<	bmax[1] = bmin[1] + wid;
524	>	bmax[0] = bmin[0] + wid-1;
525	>	bmax[1] = bmin[1] + wid-1;
526		hilbert_box_vtx(2, sizeof(bitmask_t), iwbits, 1, bmin, bmax);
527		sp->darr[sp->alen].hent = hilbert_c2i(2, iwbits, bmin);
528		sp->darr[sp->alen].wid = wid;
#	Line 498 | Line 535 | build_scaffold(float val, const double *cmin, double c
535		static int
536		sscmp(const void *p1, const void *p2)
537		{
538	<	return (int)((*(const struct outdir_s *)p1).hent -
539	<	(*(const struct outdir_s *)p2).hent);
538	>	unsigned        h1 = (*(const struct outdir_s *)p1).hent;
539	>	unsigned        h2 = (*(const struct outdir_s *)p2).hent;
540	>
541	>	if (h1 > h2)
542	>	return 1;
543	>	if (h1 < h2)
544	>	return -1;
545	>	return 0;
546		}
547
548		/* Create a new cumulative distribution for the given input direction */
549		static SDTreCDst *
550	<	make_cdist(const SDTre *sdt, const double *pos)
550	>	make_cdist(const SDTre *sdt, const double *invec, int rev)
551		{
552		SDdistScaffold  myScaffold;
553	+	double          pos[4];
554	+	int             cmask;
555		SDTreCDst       *cd;
556		struct outdir_s *sp;
557		double          scale, cursum;
#	Line 515 | Line 560 | make_cdist(const SDTre *sdt, const double *pos)
560		myScaffold.wmin = iwmax;
561		myScaffold.wmax = 0;
562		myScaffold.nic = sdt->st->ndim - 2;
563	+	myScaffold.rev = rev;
564		myScaffold.alen = 0;
565	<	myScaffold.nall = 8192;
565	>	myScaffold.nall = 512;
566		myScaffold.darr = (struct outdir_s *)malloc(sizeof(struct outdir_s) *
567		myScaffold.nall);
568		if (myScaffold.darr == NULL)
569		return NULL;
570	+	/* set up traversal */
571	+	cmask = (1<<myScaffold.nic) - 1;
572	+	for (i = myScaffold.nic; i--; )
573	+	pos[i+2*rev] = invec[i];
574	+	cmask <<= 2*rev;
575		/* grow the distribution */
576	<	if (SDtraverseTre(sdt->st, pos, (1<<myScaffold.nic)-1,
576	>	if (SDtraverseTre(sdt->st, pos, cmask,
577		&build_scaffold, &myScaffold) < 0) {
578		free(myScaffold.darr);
579		return NULL;
#	Line 531 | Line 582 | make_cdist(const SDTre *sdt, const double *pos)
582		cd = (SDTreCDst *)malloc(sizeof(SDTreCDst) +
583		sizeof(cd->carr[0])*myScaffold.alen);
584		if (cd == NULL) {
585	+	sprintf(SDerrorDetail,
586	+	"Cannot allocate %u entry cumulative distribution",
587	+	myScaffold.alen);
588		free(myScaffold.darr);
589		return NULL;
590		}
591	+	cd->isodist = (myScaffold.nic == 1);
592		/* sort the distribution */
593		qsort(myScaffold.darr, cd->calen = myScaffold.alen,
594		sizeof(struct outdir_s), &sscmp);
#	Line 544 | Line 599 | make_cdist(const SDTre *sdt, const double *pos)
599		cd->clim[i][0] = floor(pos[i]/scale) * scale;
600		cd->clim[i][1] = cd->clim[i][0] + scale;
601		}
602	+	if (cd->isodist) {              /* avoid issue in SDqueryTreProjSA() */
603	+	cd->clim[1][0] = cd->clim[0][0];
604	+	cd->clim[1][1] = cd->clim[0][1];
605	+	}
606		cd->max_psa = myScaffold.wmax / (double)iwmax;
607		cd->max_psa *= cd->max_psa * M_PI;
608	<	cd->sidef = sdt->sidef;
608	>	if (rev)
609	>	cd->sidef = (sdt->sidef==SD_BXMIT) ? SD_FXMIT : SD_BXMIT;
610	>	else
611	>	cd->sidef = sdt->sidef;
612		cd->cTotal = 1e-20;             /* compute directional total */
613		sp = myScaffold.darr;
614		for (i = myScaffold.alen; i--; sp++)
#	Line 573 | Line 635 | SDgetTreCDist(const FVECT inVec, SDComponent *sdc)
635		{
636		const SDTre     *sdt;
637		double          inCoord[2];
576	–	int             vflags;
638		int             i;
639	+	int             mode;
640		SDTreCDst       *cd, *cdlast;
641		/* check arguments */
642		if ((inVec == NULL) | (sdc == NULL) ||
643		(sdt = (SDTre *)sdc->dist) == NULL)
644		return NULL;
645	<	if (sdt->st->ndim == 3)         /* isotropic BSDF? */
645	>	switch (mode = sdt->sidef) {    /* check direction */
646	>	case SD_FREFL:
647	>	if (inVec[2] < 0)
648	>	return NULL;
649	>	break;
650	>	case SD_BREFL:
651	>	if (inVec[2] > 0)
652	>	return NULL;
653	>	break;
654	>	case SD_FXMIT:
655	>	if (inVec[2] < 0)
656	>	mode = SD_BXMIT;
657	>	break;
658	>	case SD_BXMIT:
659	>	if (inVec[2] > 0)
660	>	mode = SD_FXMIT;
661	>	break;
662	>	default:
663	>	return NULL;
664	>	}
665	>	if (sdt->st->ndim == 3) {       /* isotropic BSDF? */
666	>	if (mode != sdt->sidef) /* XXX unhandled reciprocity */
667	>	return &SDemptyCD;
668		inCoord[0] = .5 - .5*sqrt(inVec[0]*inVec[0] + inVec[1]*inVec[1]);
669	<	else if (sdt->st->ndim == 4)
669	>	} else if (sdt->st->ndim == 4) {
670		SDdisk2square(inCoord, -inVec[0], -inVec[1]);
671	<	else
671	>	} else
672		return NULL;            /* should be internal error */
673	+	/* quantize to avoid f.p. errors */
674	+	for (i = sdt->st->ndim - 2; i--; )
675	+	inCoord[i] = floor(inCoord[i]/quantum)*quantum + .5*quantum;
676		cdlast = NULL;                  /* check for direction in cache list */
677		for (cd = (SDTreCDst *)sdc->cdList; cd != NULL;
678	<	cdlast = cd, cd = (SDTreCDst *)cd->next) {
678	>	cdlast = cd, cd = cd->next) {
679	>	if (cd->sidef != mode)
680	>	continue;
681		for (i = sdt->st->ndim - 2; i--; )
682		if ((cd->clim[i][0] > inCoord[i]) |
683		(inCoord[i] >= cd->clim[i][1]))
#	Line 597 | Line 686 | SDgetTreCDist(const FVECT inVec, SDComponent *sdc)
686		break;          /* means we have a match */
687		}
688		if (cd == NULL)                 /* need to create new entry? */
689	<	cdlast = cd = make_cdist(sdt, inCoord);
689	>	cdlast = cd = make_cdist(sdt, inCoord, mode != sdt->sidef);
690		if (cdlast != NULL) {           /* move entry to head of cache list */
691		cdlast->next = cd->next;
692	<	cd->next = sdc->cdList;
692	>	cd->next = (SDTreCDst *)sdc->cdList;
693		sdc->cdList = (SDCDst *)cd;
694		}
695		return (SDCDst *)cd;            /* ready to go */
#	Line 663 | Line 752 | SDsampTreCDist(FVECT ioVec, double randX, const SDCDst
752		const SDTreCDst *cd = (const SDTreCDst *)cdp;
753		const unsigned  target = randX*cumlmax;
754		bitmask_t       hndx, hcoord[2];
755	<	double          gpos[3];
755	>	double          gpos[3], rotangle;
756		int             i, iupper, ilower;
757		/* check arguments */
758		if ((ioVec == NULL) | (cd == NULL))
759		return SDEargument;
760	+	if (!cd->sidef)
761	+	return SDEnone;         /* XXX should never happen */
762		if (ioVec[2] > 0) {
763	<	if (!(cd->sidef & SD_UFRONT))
763	>	if ((cd->sidef != SD_FREFL) & (cd->sidef != SD_FXMIT))
764		return SDEargument;
765	<	} else if (!(cd->sidef & SD_UBACK))
765	>	} else if ((cd->sidef != SD_BREFL) & (cd->sidef != SD_BXMIT))
766		return SDEargument;
767		/* binary search to find position */
768		ilower = 0; iupper = cd->calen;
769		while ((i = (iupper + ilower) >> 1) != ilower)
770	<	if ((long)target >= (long)cd->carr[i].cuml)
770	>	if (target >= cd->carr[i].cuml)
771		ilower = i;
772		else
773		iupper = i;
#	Line 697 | Line 788 | SDsampTreCDist(FVECT ioVec, double randX, const SDCDst
788		if (gpos[2] > 0)                /* paranoia, I hope */
789		gpos[2] = sqrt(gpos[2]);
790		/* emit from back? */
791	<	if (ioVec[2] > 0 ^ cd->sidef != SD_XMIT)
791	>	if ((cd->sidef == SD_BREFL) | (cd->sidef == SD_FXMIT))
792		gpos[2] = -gpos[2];
793	<	VCOPY(ioVec, gpos);
793	>	if (cd->isodist) {              /* rotate isotropic result */
794	>	rotangle = atan2(-ioVec[1],-ioVec[0]);
795	>	VCOPY(ioVec, gpos);
796	>	spinvector(ioVec, ioVec, zvec, rotangle);
797	>	} else
798	>	VCOPY(ioVec, gpos);
799		return SDEnone;
800		}
801
#	Line 712 | Line 808 | next_token(char **spp)
808		return **spp;
809		}
810
811	<	#define eat_token(spp,c)        (next_token(spp)==(c) ? *(*(spp))++ : 0)
811	>	/* Advance pointer past matching token (or any token if c==0) */
812	>	#define eat_token(spp,c)        (next_token(spp)==(c) ^ !(c) ? *(*(spp))++ : 0)
813
814		/* Count words from this point in string to '}' */
815		static int
#	Line 721 | Line 818 | count_values(char *cp)
818		int     n = 0;
819
820		while (next_token(&cp) != '}' && *cp) {
821	<	if (*cp == '{')
822	<	return -1;
823	<	while (*cp && (*cp != ',') & (*cp != '}') & !isspace(*cp))
727	<	++cp;
821	>	while (!isspace(*cp) & (*cp != ',') & (*cp != '}'))
822	>	if (!*++cp)
823	>	break;
824		++n;
825		eat_token(&cp, ',');
826		}
#	Line 769 | Line 865 | load_tree_data(char **spp, int nd)
865		} else {                        /* else load value grid */
866		int     bsiz;
867		n = count_values(*spp); /* see how big the grid is */
868	<	if (n <= 0) {
773	<	strcpy(SDerrorDetail, "Bad tensor tree data");
774	<	return NULL;
775	<	}
776	<	for (bsiz = 0; bsiz < 8*sizeof(size_t)-1; bsiz += nd)
868	>	for (bsiz = 0; bsiz < 8*sizeof(size_t); bsiz += nd)
869		if (1<<bsiz == n)
870		break;
871		if (bsiz >= 8*sizeof(size_t)) {
#	Line 806 | Line 898 | get_extrema(SDSpectralDF *df)
898		double  stepWidth, dhemi, bmin[4], bmax[4];
899
900		stepWidth = SDsmallestLeaf(st);
901	+	if (quantum > stepWidth)        /* adjust quantization factor */
902	+	quantum = stepWidth;
903		df->minProjSA = M_PI*stepWidth*stepWidth;
904		if (stepWidth < .03125)
905		stepWidth = .03125;     /* 1/32 resolution good enough */
#	Line 845 | Line 939 | load_bsdf_data(SDData *sd, ezxml_t wdb, int ndim)
939		SDSpectralDF    *df;
940		SDTre           *sdt;
941		char            *sdata;
848	–	int             i;
942		/* allocate BSDF component */
943		sdata = ezxml_txt(ezxml_child(wdb, "WavelengthDataDirection"));
944		if (!sdata)
#	Line 853 | Line 946 | load_bsdf_data(SDData *sd, ezxml_t wdb, int ndim)
946		/*
947		* Remember that front and back are reversed from WINDOW 6 orientations
948		*/
949	<	if (!strcasecmp(sdata, "Transmission")) {
949	>	if (!strcasecmp(sdata, "Transmission Front")) {
950		if (sd->tf != NULL)
951		SDfreeSpectralDF(sd->tf);
952		if ((sd->tf = SDnewSpectralDF(1)) == NULL)
953		return SDEmemory;
954		df = sd->tf;
955	+	} else if (!strcasecmp(sdata, "Transmission Back")) {
956	+	if (sd->tb != NULL)
957	+	SDfreeSpectralDF(sd->tb);
958	+	if ((sd->tb = SDnewSpectralDF(1)) == NULL)
959	+	return SDEmemory;
960	+	df = sd->tb;
961		} else if (!strcasecmp(sdata, "Reflection Front")) {
962		if (sd->rb != NULL)     /* note back-front reversal */
963		SDfreeSpectralDF(sd->rb);
#	Line 886 | Line 985 | load_bsdf_data(SDData *sd, ezxml_t wdb, int ndim)
985		if (sdt == NULL)
986		return SDEmemory;
987		if (df == sd->rf)
988	<	sdt->sidef = SD_UFRONT;
988	>	sdt->sidef = SD_FREFL;
989		else if (df == sd->rb)
990	<	sdt->sidef = SD_UBACK;
991	<	else
992	<	sdt->sidef = SD_XMIT;
990	>	sdt->sidef = SD_BREFL;
991	>	else if (df == sd->tf)
992	>	sdt->sidef = SD_FXMIT;
993	>	else /* df == sd->tb */
994	>	sdt->sidef = SD_BXMIT;
995		sdt->st = NULL;
996		df->comp[0].cspec[0] = c_dfcolor; /* XXX monochrome for now */
997		df->comp[0].dist = sdt;
#	Line 922 | Line 1023 | load_bsdf_data(SDData *sd, ezxml_t wdb, int ndim)
1023		static float
1024		SDgetTreMin(const SDNode *st)
1025		{
1026	<	float   vmin = 1./M_PI;
1026	>	float   vmin = FHUGE;
1027		int     n;
1028
1029		if (st->log2GR < 0) {
#	Line 950 | Line 1051 | SDsubtractTreVal(SDNode *st, float val)
1051		SDsubtractTreVal(st->u.t[n], val);
1052		} else {
1053		for (n = 1<<(st->ndim*st->log2GR); n--; )
1054	<	st->u.v[n] -= val;
1054	>	if ((st->u.v[n] -= val) < 0)
1055	>	st->u.v[n] = .0f;
1056		}
1057		}
1058
#	Line 960 | Line 1062 | subtract_min(SDNode *st)
1062		{
1063		float   vmin;
1064		/* be sure to skip unused portion */
1065	<	if ((st->ndim == 3) & (st->log2GR < 0)) {
1066	<	float   v;
965	<	int     i;
1065	>	if (st->ndim == 3) {
1066	>	int     n;
1067		vmin = 1./M_PI;
1068	<	for (i = 0; i < 4; i++) {
1069	<	v = SDgetTreMin(st->u.t[i]);
1070	<	if (v < vmin)
1071	<	vmin = v;
1072	<	}
1068	>	if (st->log2GR < 0) {
1069	>	for (n = 0; n < 8; n += 2) {
1070	>	float   v = SDgetTreMin(st->u.t[n]);
1071	>	if (v < vmin)
1072	>	vmin = v;
1073	>	}
1074	>	} else if (st->log2GR) {
1075	>	for (n = 1 << (3*st->log2GR - 1); n--; )
1076	>	if (st->u.v[n] < vmin)
1077	>	vmin = st->u.v[n];
1078	>	} else
1079	>	vmin = st->u.v[0];
1080		} else                          /* anisotropic covers entire tree */
1081		vmin = SDgetTreMin(st);
1082
#	Line 1045 | Line 1153 | SDloadTre(SDData *sd, ezxml_t wtl)
1153		/* separate diffuse components */
1154		extract_diffuse(&sd->rLambFront, sd->rf);
1155		extract_diffuse(&sd->rLambBack, sd->rb);
1156	<	extract_diffuse(&sd->tLamb, sd->tf);
1156	>	extract_diffuse(&sd->tLamb, (sd->tf != NULL) ? sd->tf : sd->tb);
1157		/* return success */
1158		return SDEnone;
1159		}

Diff Legend

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