ViewVC Help

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

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

Comparing ray/src/common/bsdf_m.c (file contents):
Revision 3.8 by greg, Thu Feb 24 20:14:26 2011 UTC vs.
Revision 3.17 by greg, Tue Jun 28 21:13:46 2011 UTC

#	Line 11 | Line 11 | static const char RCSid[] = "$Id$";
11		*
12		*/
13
14	+	#define _USE_MATH_DEFINES
15		#include "rtio.h"
16		#include <stdlib.h>
17		#include <math.h>
#	Line 81 | Line 82 | static int     nabases = 3;    /* current number of defined b
82		static int
83		fequal(double a, double b)
84		{
85	<	if (b != .0)
85	>	if (b != 0)
86		a = a/b - 1.;
87		return (a <= 1e-6) & (a >= -1e-6);
88		}
89
90	<	/* returns the name of the given tag */
90	<	#ifdef ezxml_name
91	<	#undef ezxml_name
92	<	static char *
93	<	ezxml_name(ezxml_t xml)
94	<	{
95	<	if (xml == NULL)
96	<	return NULL;
97	<	return xml->name;
98	<	}
99	<	#endif
100	<
101	<	/* returns the given tag's character content or empty string if none */
90	>	/* Returns the given tag's character content or empty string if none */
91		#ifdef ezxml_txt
92		#undef ezxml_txt
93		static char *
#	Line 159 | Line 148 | SDnewMatrix(int ni, int no)
148
149		/* get vector for this angle basis index (front exiting) */
150		static int
151	<	fo_getvec(FVECT v, int ndx, double randX, void *p)
151	>	fo_getvec(FVECT v, double ndxr, void *p)
152		{
153	<	ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
153	>	ANGLE_BASIS     *ab = (ANGLE_BASIS *)p;
154	>	int             ndx = (int)ndxr;
155	>	double          randX = ndxr - ndx;
156		double          rx[2];
157		int             li;
158		double          pol, azi, d;
159
160	<	if ((ndx < 0) | (ndx >= ab->nangles))
160	>	if ((ndxr < 0) | (ndx >= ab->nangles))
161		return RC_FAIL;
162		for (li = 0; ndx >= ab->lat[li].nphis; li++)
163		ndx -= ab->lat[li].nphis;
#	Line 185 | Line 176 | fo_getvec(FVECT v, int ndx, double randX, void *p)
176		static int
177		fo_getndx(const FVECT v, void *p)
178		{
179	<	ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
179	>	ANGLE_BASIS     *ab = (ANGLE_BASIS *)p;
180		int     li, ndx;
181	<	double  pol, azi, d;
181	>	double  pol, azi;
182
183		if (v == NULL)
184		return -1;
185	<	if ((v[2] < .0) | (v[2] > 1.0))
185	>	if ((v[2] < 0) | (v[2] > 1.))
186		return -1;
187		pol = 180.0/M_PI*acos(v[2]);
188		azi = 180.0/M_PI*atan2(v[1], v[0]);
#	Line 237 | Line 228 | io_getohm(int ndx, void *p)
228
229		/* get vector for this angle basis index (back incident) */
230		static int
231	<	bi_getvec(FVECT v, int ndx, double randX, void *p)
231	>	bi_getvec(FVECT v, double ndxr, void *p)
232		{
233	<	if (!fo_getvec(v, ndx, randX, p))
233	>	if (!fo_getvec(v, ndxr, p))
234		return RC_FAIL;
235
236		v[0] = -v[0];
#	Line 264 | Line 255 | bi_getndx(const FVECT v, void *p)
255
256		/* get vector for this angle basis index (back exiting) */
257		static int
258	<	bo_getvec(FVECT v, int ndx, double randX, void *p)
258	>	bo_getvec(FVECT v, double ndxr, void *p)
259		{
260	<	if (!fo_getvec(v, ndx, randX, p))
260	>	if (!fo_getvec(v, ndxr, p))
261		return RC_FAIL;
262
263		v[2] = -v[2];
#	Line 289 | Line 280 | bo_getndx(const FVECT v, void *p)
280
281		/* get vector for this angle basis index (front incident) */
282		static int
283	<	fi_getvec(FVECT v, int ndx, double randX, void *p)
283	>	fi_getvec(FVECT v, double ndxr, void *p)
284		{
285	<	if (!fo_getvec(v, ndx, randX, p))
285	>	if (!fo_getvec(v, ndxr, p))
286		return RC_FAIL;
287
288		v[0] = -v[0];
#	Line 350 | Line 341 | load_angle_basis(ezxml_t wab)
341		"ThetaBounds"), "LowerTheta"))),
342		abase_list[nabases].lat[i].tmin)) {
343		sprintf(SDerrorDetail, "Theta values disagree in '%s'",
344	<	abname);
344	>	abname);
345		return RC_DATERR;
346		}
347		abase_list[nabases].nangles +=
#	Line 360 | Line 351 | load_angle_basis(ezxml_t wab)
351		(abase_list[nabases].lat[i].nphis == 1 &&
352		abase_list[nabases].lat[i].tmin > FTINY)) {
353		sprintf(SDerrorDetail, "Illegal phi count in '%s'",
354	<	abname);
354	>	abname);
355		return RC_DATERR;
356		}
357		}
#	Line 416 | Line 407 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
407		int             i;
408		/* allocate BSDF component */
409		sdata = ezxml_txt(ezxml_child(wdb, "WavelengthDataDirection"));
410	+	if (!sdata)
411	+	return RC_FAIL;
412		/*
413		* Remember that front and back are reversed from WINDOW 6 orientations
414	+	* Favor their "Front" (incoming light) since that's more often valid
415		*/
416	<	if ((tfront = !strcasecmp(sdata, "Transmission Back")) ||
417	<	(sd->tf == NULL &&
418	<	!strcasecmp(sdata, "Transmission Front"))) {
416	>	tfront = !strcasecmp(sdata, "Transmission Back");
417	>	if (!strcasecmp(sdata, "Transmission Front") ||
418	>	tfront & (sd->tf == NULL)) {
419		if (sd->tf != NULL)
420		SDfreeSpectralDF(sd->tf);
421		if ((sd->tf = SDnewSpectralDF(1)) == NULL)
#	Line 504 | Line 498 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
498		df->comp[0].dist = dp;
499		df->comp[0].func = &SDhandleMtx;
500		/* read BSDF data */
501	<	sdata  = ezxml_txt(ezxml_child(wdb,"ScatteringData"));
501	>	sdata = ezxml_txt(ezxml_child(wdb, "ScatteringData"));
502		if (!sdata || !*sdata) {
503		sprintf(SDerrorDetail, "Missing BSDF ScatteringData in '%s'",
504		sd->name);
#	Line 518 | Line 512 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
512		sd->name);
513		return RC_FORMERR;
514		}
515	<	while (*sdnext && isspace(*sdnext))
515	>	while (isspace(*sdnext))
516		sdnext++;
517		if (*sdnext == ',') sdnext++;
518		if (rowinc) {
519		int     r = i/dp->nout;
520	<	int     c = i - c*dp->nout;
520	>	int     c = i - r*dp->nout;
521		mBSDF_value(dp,r,c) = atof(sdata);
522		} else
523		dp->bsdf[i] = atof(sdata);
#	Line 543 | Line 537 | subtract_min(SDMat *sm)
537		for (i = n; --i; )
538		if (sm->bsdf[i] < minv)
539		minv = sm->bsdf[i];
540	+
541	+	if (minv <= FTINY)
542	+	return .0;
543	+
544		for (i = n; i--; )
545		sm->bsdf[i] -= minv;
546
#	Line 568 | Line 566 | extract_diffuse(SDValue *dv, SDSpectralDF *df)
566		c_cmix(&dv->spec, dv->cieY, &dv->spec, ymin, &df->comp[n].cspec[0]);
567		dv->cieY += ymin;
568		}
569	<	df->maxHemi -= dv->cieY;        /* adjust minimum hemispherical */
569	>	df->maxHemi -= dv->cieY;        /* adjust maximum hemispherical */
570		/* make sure everything is set */
571		c_ccvt(&dv->spec, C_CSXY+C_CSSPEC);
572		}
#	Line 577 | Line 575 | extract_diffuse(SDValue *dv, SDSpectralDF *df)
575		SDError
576		SDloadMtx(SDData *sd, ezxml_t wtl)
577		{
578	<	ezxml_t                 wld, wdb;
579	<	int                     rowIn;
580	<	struct BSDF_data        *dp;
581	<	char                    *txt;
582	<	int                     rval;
585	<
578	>	ezxml_t         wld, wdb;
579	>	int             rowIn;
580	>	char            *txt;
581	>	int             rval;
582	>	/* basic checks and data ordering */
583		txt = ezxml_txt(ezxml_child(ezxml_child(wtl,
584		"DataDefinition"), "IncidentDataStructure"));
585		if (txt == NULL || !*txt) {
#	Line 601 | Line 598 | SDloadMtx(SDData *sd, ezxml_t wtl)
598		sd->name);
599		return SDEsupport;
600		}
601	<	/* get angle basis */
601	>	/* get angle basis */
602		rval = load_angle_basis(ezxml_child(ezxml_child(wtl,
603		"DataDefinition"), "AngleBasis"));
604		if (rval < 0)
605		return convert_errcode(rval);
606	<	/* load BSDF components */
606	>	/* load BSDF components */
607		for (wld = ezxml_child(wtl, "WavelengthData");
608		wld != NULL; wld = wld->next) {
609		if (strcasecmp(ezxml_txt(ezxml_child(wld,"Wavelength")),
#	Line 617 | Line 614 | SDloadMtx(SDData *sd, ezxml_t wtl)
614		if ((rval = load_bsdf_data(sd, wdb, rowIn)) < 0)
615		return convert_errcode(rval);
616		}
617	<	/* separate diffuse components */
617	>	/* separate diffuse components */
618		extract_diffuse(&sd->rLambFront, sd->rf);
619		extract_diffuse(&sd->rLambBack, sd->rb);
620		extract_diffuse(&sd->tLamb, sd->tf);
621	<	/* return success */
621	>	/* return success */
622		return SDEnone;
623		}
624
625		/* Get Matrix BSDF value */
626		static int
627		SDgetMtxBSDF(float coef[SDmaxCh], const FVECT outVec,
628	<	const FVECT inVec, const void *dist)
628	>	const FVECT inVec, SDComponent *sdc)
629		{
630	<	const SDMat     *dp = (const SDMat *)dist;
630	>	const SDMat     *dp;
631		int             i_ndx, o_ndx;
632	+	/* check arguments */
633	+	if ((coef == NULL) | (outVec == NULL) | (inVec == NULL) | (sdc == NULL)
634	+	|| (dp = (SDMat *)sdc->dist) == NULL)
635	+	return 0;
636		/* get angle indices */
637		i_ndx = mBSDF_incndx(dp, inVec);
638		o_ndx = mBSDF_outndx(dp, outVec);
#	Line 646 | Line 647 | SDgetMtxBSDF(float coef[SDmaxCh], const FVECT outVec,
647		return 1;                       /* XXX monochrome for now */
648		}
649
650	<	/* Query solid angle for vector */
650	>	/* Query solid angle for vector(s) */
651		static SDError
652	<	SDqueryMtxProjSA(double *psa, const FVECT vec, int qflags, const void *dist)
652	>	SDqueryMtxProjSA(double *psa, const FVECT v1, const RREAL *v2,
653	>	int qflags, SDComponent *sdc)
654		{
655	<	const SDMat     *dp = (const SDMat *)dist;
655	>	const SDMat     *dp;
656		double          inc_psa, out_psa;
657		/* check arguments */
658	<	if ((psa == NULL) | (vec == NULL) | (dp == NULL))
658	>	if ((psa == NULL) | (v1 == NULL) | (sdc == NULL) ||
659	>	(dp = (SDMat *)sdc->dist) == NULL)
660		return SDEargument;
661	+	if (v2 == NULL)
662	+	v2 = v1;
663		/* get projected solid angles */
664	<	inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
665	<	out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
664	>	out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, v1));
665	>	inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, v2));
666	>	if ((v1 != v2) & (out_psa <= 0) & (inc_psa <= 0)) {
667	>	inc_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, v2));
668	>	out_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, v1));
669	>	}
670
671		switch (qflags) {               /* record based on flag settings */
663	–	case SDqueryVal:
664	–	psa[0] = .0;
665	–	/* fall through */
672		case SDqueryMax:
673		if (inc_psa > psa[0])
674		psa[0] = inc_psa;
#	Line 670 | Line 676 | SDqueryMtxProjSA(double *psa, const FVECT vec, int qfl
676		psa[0] = out_psa;
677		break;
678		case SDqueryMin+SDqueryMax:
679	<	if (inc_psa > psa[0])
679	>	if (inc_psa > psa[1])
680		psa[1] = inc_psa;
681	<	if (out_psa > psa[0])
681	>	if (out_psa > psa[1])
682		psa[1] = out_psa;
683		/* fall through */
684	+	case SDqueryVal:
685	+	if (qflags == SDqueryVal)
686	+	psa[0] = M_PI;
687	+	/* fall through */
688		case SDqueryMin:
689	<	if ((inc_psa > .0) & (inc_psa < psa[0]))
689	>	if ((inc_psa > 0) & (inc_psa < psa[0]))
690		psa[0] = inc_psa;
691	<	if ((out_psa > .0) & (out_psa < psa[0]))
691	>	if ((out_psa > 0) & (out_psa < psa[0]))
692		psa[0] = out_psa;
693		break;
694		}
695		/* make sure it's legal */
696	<	return (psa[0] <= .0) ? SDEinternal : SDEnone;
696	>	return (psa[0] <= 0) ? SDEinternal : SDEnone;
697		}
698
699		/* Compute new cumulative distribution from BSDF */
#	Line 721 | Line 731 | make_cdist(SDMatCDst *cd, const FVECT inVec, SDMat *dp
731		static const SDCDst *
732		SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
733		{
734	<	SDMat           *dp = (SDMat *)sdc->dist;
734	>	SDMat           *dp;
735		int             reverse;
736		SDMatCDst       myCD;
737		SDMatCDst       *cd, *cdlast;
738		/* check arguments */
739	<	if ((inVec == NULL) | (dp == NULL))
739	>	if ((inVec == NULL) | (sdc == NULL) ||
740	>	(dp = (SDMat *)sdc->dist) == NULL)
741		return NULL;
742		memset(&myCD, 0, sizeof(myCD));
743		myCD.indx = mBSDF_incndx(dp, inVec);
#	Line 745 | Line 756 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
756		reverse = 1;
757		}
758		cdlast = NULL;                  /* check for it in cache list */
759	<	for (cd = (SDMatCDst *)sdc->cdList;
760	<	cd != NULL; cd = (SDMatCDst *)cd->next) {
759	>	for (cd = (SDMatCDst *)sdc->cdList; cd != NULL;
760	>	cdlast = cd, cd = (SDMatCDst *)cd->next)
761		if (cd->indx == myCD.indx && (cd->calen == myCD.calen) &
762		(cd->ob_priv == myCD.ob_priv) &
763		(cd->ob_vec == myCD.ob_vec))
764		break;
754	–	cdlast = cd;
755	–	}
765		if (cd == NULL) {               /* need to allocate new entry */
766		cd = (SDMatCDst *)malloc(sizeof(SDMatCDst) +
767	<	myCD.calen*sizeof(myCD.carr[0]));
767	>	sizeof(myCD.carr[0])*myCD.calen);
768		if (cd == NULL)
769		return NULL;
770		*cd = myCD;             /* compute cumulative distribution */
#	Line 775 | Line 784 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
784
785		/* Sample cumulative distribution */
786		static SDError
787	<	SDsampMtxCDist(FVECT outVec, double randX, const SDCDst *cdp)
787	>	SDsampMtxCDist(FVECT ioVec, double randX, const SDCDst *cdp)
788		{
789		const unsigned  maxval = ~0;
790		const SDMatCDst *mcd = (const SDMatCDst *)cdp;
791		const unsigned  target = randX*maxval;
792		int             i, iupper, ilower;
793		/* check arguments */
794	<	if ((outVec == NULL) | (mcd == NULL))
794	>	if ((ioVec == NULL) | (mcd == NULL))
795		return SDEargument;
796		/* binary search to find index */
797		ilower = 0; iupper = mcd->calen;
#	Line 795 | Line 804 | SDsampMtxCDist(FVECT outVec, double randX, const SDCDs
804		randX = (randX*maxval - mcd->carr[ilower]) /
805		(double)(mcd->carr[iupper] - mcd->carr[ilower]);
806		/* convert index to vector */
807	<	if ((*mcd->ob_vec)(outVec, i, randX, mcd->ob_priv))
807	>	if ((*mcd->ob_vec)(ioVec, i+randX, mcd->ob_priv))
808		return SDEnone;
809	<	strcpy(SDerrorDetail, "BSDF sampling fault");
809	>	strcpy(SDerrorDetail, "Matrix BSDF sampling fault");
810		return SDEinternal;
811		}
812

Diff Legend

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