src/rt/p_data.c

#ifndef lint
static const char       RCSid[] = "$Id: p_data.c,v 2.9 2014/07/08 18:25:00 greg Exp $";
#endif
/*
 *  p_data.c - routine for stored patterns.
 */

#include "copyright.h"

#include  "ray.h"
#include  "data.h"
#include  "func.h"
#include  "rtotypes.h"

/*
 *      A stored pattern can either be brightness,
 *  color, or spectral data.  Brightness data is specified as:
 *
 *      modifier brightdata name
 *      4+ func dfname vfname v0 v1 .. xf
 *      0
 *      n A1 A2 ..
 *
 *  Color data is specified as:
 *
 *      modifier colordata name
 *      8+ rfunc gfunc bfunc rdfname gdfname bdfname vfname v0 v1 .. xf
 *      0
 *      n A1 A2 ..
 *
 *  Color picture data is specified as:
 *
 *      modifier colorpict name
 *      7+ rfunc gfunc bfunc pfname vfname vx vy xf
 *      0
 *      n A1 A2 ..
 *
 *  A simple spectrum is specified as:
 *
 *      modifier spectrum name
 *      0
 *      0
 *      5+ nmA nmB s1 s2 s3 ..
 *
 *  A constant spectrum from a data file is given as:
 *
 *      modifier specfile name
 *      1 dfname
 *      0
 *      0
 *
 *  Vfname is the name of the file where the variable definitions
 *  can be found.  The list of real arguments can be accessed by
 *  definitions in the file.  The dfnames are the data file
 *  names.  The dimensions of the data files and the number
 *  of variables must match.  The funcs take a single argument
 *  for brightdata, and three for colordata and colorpict to produce
 *  interpolated values from the file.  The xf is a transform spec
 *  to get from the original coordinates to the current coordinates.
 */


int
p_bdata(                        /* interpolate brightness data */
        OBJREC  *m,
        RAY  *r
)
{
        double  bval;
        double  pt[MAXDDIM];
        DATARRAY  *dp;
        MFUNC  *mf;
        int  i;

        if (m->oargs.nsargs < 4)
                objerror(m, USER, "bad # arguments");
        dp = getdata(m->oargs.sarg[1]);
        i = (1 << dp->nd) - 1;
        mf = getfunc(m, 2, i<<3, 0);
        setfunc(m, r);
        errno = 0;
        for (i = dp->nd; i-- > 0; ) {
                pt[i] = evalue(mf->ep[i]);
                if ((errno == EDOM) | (errno == ERANGE))
                        goto computerr;
        }
        bval = datavalue(dp, pt);
        errno = 0;
        bval = funvalue(m->oargs.sarg[0], 1, &bval);
        if ((errno == EDOM) | (errno == ERANGE))
                goto computerr;
        scalescolor(r->pcol, bval);
        return(0);
computerr:
        objerror(m, WARNING, "compute error");
        return(0);
}


int
p_cdata(                        /* interpolate color data */
        OBJREC  *m,
        RAY  *r
)
{
        double  col[3];
        COLOR  cval;
        double  pt[MAXDDIM];
        int  nv;
        DATARRAY  *dp;
        MFUNC  *mf;
        int  i;

        if (m->oargs.nsargs < 8)
                objerror(m, USER, "bad # arguments");
        dp = getdata(m->oargs.sarg[3]);
        i = (1 << (nv = dp->nd)) - 1;
        mf = getfunc(m, 6, i<<7, 0);
        setfunc(m, r);
        errno = 0;
        for (i = 0; i < nv; i++) {
                pt[i] = evalue(mf->ep[i]);
                if ((errno == EDOM) | (errno == ERANGE))
                        goto computerr;
        }
        col[0] = datavalue(dp, pt);
        for (i = 1; i < 3; i++) {
                dp = getdata(m->oargs.sarg[i+3]);
                if (dp->nd != nv)
                        objerror(m, USER, "dimension error");
                col[i] = datavalue(dp, pt);
        }
        errno = 0;
        for (i = 0; i < 3; i++)
                if (fundefined(m->oargs.sarg[i]) < 3)
                        colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
                else
                        colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
        if ((errno == EDOM) | (errno == ERANGE))
                goto computerr;
        smultcolor(r->pcol, cval);
        return(0);
computerr:
        objerror(m, WARNING, "compute error");
        return(0);
}


int
p_pdata(                        /* interpolate picture data */
        OBJREC  *m,
        RAY  *r
)
{
        double  col[3];
        COLOR  cval;
        double  pt[2];
        DATARRAY  *dp;
        MFUNC  *mf;
        int  i;

        if (m->oargs.nsargs < 7)
                objerror(m, USER, "bad # arguments");
        mf = getfunc(m, 4, 0x3<<5, 0);
        setfunc(m, r);
        errno = 0;
        pt[1] = evalue(mf->ep[0]);      /* y major ordering */
        pt[0] = evalue(mf->ep[1]);
        if ((errno == EDOM) | (errno == ERANGE))
                goto computerr;
        dp = getpict(m->oargs.sarg[3]);
        for (i = 0; i < 3; i++)
                col[i] = datavalue(dp+i, pt);
        errno = 0;
        for (i = 0; i < 3; i++)
                if (fundefined(m->oargs.sarg[i]) < 3)
                        colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
                else
                        colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
        if ((errno == EDOM) | (errno == ERANGE))
                goto computerr;
        smultcolor(r->pcol, cval);
        return(0);

computerr:
        objerror(m, WARNING, "compute error");
        return(0);
}


int
p_spectrum(                     /* simple constant spectrum */
        OBJREC  *m,
        RAY  *r
)
{
        COLORV  *scval;

        if ((scval = (COLORV *)m->os) == NULL) {
                COLORV  *sinp;
                double  hstep;
                int     i;
                if (m->oargs.nfargs < 5)
                        objerror(m, USER, "bad # arguments");
                sinp = (COLORV *)malloc(sizeof(COLORV)*(m->oargs.nfargs-2));
                scval = (COLORV *)malloc(sizeof(COLORV)*NCSAMP);
                if ((sinp == NULL) | (scval == NULL))
                        objerror(m, SYSTEM, "out of memory");
                for (i = m->oargs.nfargs-2; i--; )
                        sinp[i] = (COLORV)m->oargs.farg[i+2];
                hstep = 0.5 * (m->oargs.farg[1] - m->oargs.farg[0]) /
                                (m->oargs.nfargs-3.0);
                convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
                                sinp, m->oargs.nfargs-2,
                                m->oargs.farg[0]-hstep, m->oargs.farg[1]+hstep);
                free(sinp);
                m->os = (void *)scval;
        }
        smultscolor(r->pcol, scval);
        return(0);
}


int
p_specfile(                     /* constant spectrum from 1-D data file */
        OBJREC  *m,
        RAY  *r
)
{
        COLORV  *scval;

        if ((scval = (COLORV *)m->os) == NULL) {
                DATARRAY        *dp;
                COLORV          *sinp;
                double          step;
                int             i;
                if (m->oargs.nsargs != 1)
                        objerror(m, USER, "bad # arguments");
                dp = getdata(m->oargs.sarg[0]);
                if (dp->nd != 1)
                        objerror(m, USER, "data file must be 1-dimensional");

                sinp = (COLORV *)malloc(sizeof(COLORV)*dp->dim[0].ne);
                scval = (COLORV *)malloc(sizeof(COLORV)*NCSAMP);
                if ((sinp == NULL) | (scval == NULL))
                        objerror(m, SYSTEM, "out of memory");
                step = dp->dim[0].siz / (dp->dim[0].ne - 1.0);
                for (i = dp->dim[0].ne; i-- > 0; ) {
                        double  wl = dp->dim[0].org + i*step;
                        sinp[i] = (COLORV)datavalue(dp, &wl);
                }
                convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
                                sinp, dp->dim[0].ne, dp->dim[0].org-.5*step,
                                dp->dim[0].org+dp->dim[0].siz+.5*step);
                free(sinp);
                m->os = (void *)scval;
        }
        smultscolor(r->pcol, scval);
        return(0);
}
Revision:	2.10
Committed:	Wed Nov 15 18:02:53 2023 UTC (6 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.9:	+101 -15 lines
Log Message:	feat(rpict,rtrace,rcontrib,rtpict): Hyperspectral rendering (except photon map)
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.10	static const char RCSid[] = "$Id: p_data.c,v 2.9 2014/07/08 18:25:00 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* p_data.c - routine for stored patterns.
6	greg	2.5	*/
7
8	greg	2.6	#include "copyright.h"
9	greg	1.1
10			#include "ray.h"
11			#include "data.h"
12	greg	2.2	#include "func.h"
13	schorsch	2.8	#include "rtotypes.h"
14	greg	2.2
15	greg	1.1	/*
16	greg	2.10	* A stored pattern can either be brightness,
17			* color, or spectral data. Brightness data is specified as:
18	greg	1.1	*
19			* modifier brightdata name
20			* 4+ func dfname vfname v0 v1 .. xf
21			* 0
22			* n A1 A2 ..
23			*
24			* Color data is specified as:
25			*
26			* modifier colordata name
27			* 8+ rfunc gfunc bfunc rdfname gdfname bdfname vfname v0 v1 .. xf
28			* 0
29			* n A1 A2 ..
30			*
31			* Color picture data is specified as:
32			*
33			* modifier colorpict name
34			* 7+ rfunc gfunc bfunc pfname vfname vx vy xf
35			* 0
36			* n A1 A2 ..
37			*
38	greg	2.10	* A simple spectrum is specified as:
39			*
40			* modifier spectrum name
41			* 0
42			* 0
43			* 5+ nmA nmB s1 s2 s3 ..
44			*
45			* A constant spectrum from a data file is given as:
46			*
47			* modifier specfile name
48			* 1 dfname
49			* 0
50			* 0
51			*
52	greg	1.1	* Vfname is the name of the file where the variable definitions
53			* can be found. The list of real arguments can be accessed by
54			* definitions in the file. The dfnames are the data file
55			* names. The dimensions of the data files and the number
56			* of variables must match. The funcs take a single argument
57			* for brightdata, and three for colordata and colorpict to produce
58	greg	2.10	* interpolated values from the file. The xf is a transform spec
59	greg	1.1	* to get from the original coordinates to the current coordinates.
60			*/
61
62
63	greg	2.9	int
64	schorsch	2.8	p_bdata( /* interpolate brightness data */
65	greg	2.9	OBJREC *m,
66	schorsch	2.8	RAY *r
67			)
68	greg	1.1	{
69			double bval;
70	greg	2.10	double pt[MAXDDIM];
71	greg	1.1	DATARRAY *dp;
72	greg	2.9	MFUNC *mf;
73			int i;
74	greg	1.1
75			if (m->oargs.nsargs < 4)
76			objerror(m, USER, "bad # arguments");
77	greg	2.2	dp = getdata(m->oargs.sarg[1]);
78			i = (1 << dp->nd) - 1;
79			mf = getfunc(m, 2, i<<3, 0);
80			setfunc(m, r);
81	greg	1.2	errno = 0;
82	greg	2.2	for (i = dp->nd; i-- > 0; ) {
83			pt[i] = evalue(mf->ep[i]);
84	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
85	greg	2.2	goto computerr;
86	greg	1.1	}
87			bval = datavalue(dp, pt);
88			errno = 0;
89	greg	2.2	bval = funvalue(m->oargs.sarg[0], 1, &bval);
90	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
91	greg	1.1	goto computerr;
92	greg	2.10	scalescolor(r->pcol, bval);
93	greg	2.4	return(0);
94	greg	1.1	computerr:
95			objerror(m, WARNING, "compute error");
96	greg	2.4	return(0);
97	greg	1.1	}
98
99
100	greg	2.9	int
101	schorsch	2.8	p_cdata( /* interpolate color data */
102	greg	2.9	OBJREC *m,
103	schorsch	2.8	RAY *r
104			)
105	greg	1.1	{
106			double col[3];
107			COLOR cval;
108	greg	2.10	double pt[MAXDDIM];
109	greg	2.2	int nv;
110	greg	1.1	DATARRAY *dp;
111	greg	2.9	MFUNC *mf;
112			int i;
113	greg	1.1
114			if (m->oargs.nsargs < 8)
115			objerror(m, USER, "bad # arguments");
116	greg	2.2	dp = getdata(m->oargs.sarg[3]);
117			i = (1 << (nv = dp->nd)) - 1;
118			mf = getfunc(m, 6, i<<7, 0);
119			setfunc(m, r);
120			errno = 0;
121			for (i = 0; i < nv; i++) {
122			pt[i] = evalue(mf->ep[i]);
123	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
124	greg	1.1	goto computerr;
125			}
126	greg	2.2	col[0] = datavalue(dp, pt);
127			for (i = 1; i < 3; i++) {
128			dp = getdata(m->oargs.sarg[i+3]);
129	greg	1.1	if (dp->nd != nv)
130	greg	2.2	objerror(m, USER, "dimension error");
131	greg	1.1	col[i] = datavalue(dp, pt);
132			}
133			errno = 0;
134	greg	2.3	for (i = 0; i < 3; i++)
135			if (fundefined(m->oargs.sarg[i]) < 3)
136			colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
137			else
138			colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
139	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
140	greg	1.1	goto computerr;
141	greg	2.10	smultcolor(r->pcol, cval);
142	greg	2.4	return(0);
143	greg	1.1	computerr:
144			objerror(m, WARNING, "compute error");
145	greg	2.4	return(0);
146	greg	1.1	}
147
148
149	greg	2.9	int
150	schorsch	2.8	p_pdata( /* interpolate picture data */
151	greg	2.9	OBJREC *m,
152	schorsch	2.8	RAY *r
153			)
154	greg	1.1	{
155			double col[3];
156			COLOR cval;
157			double pt[2];
158			DATARRAY *dp;
159	greg	2.9	MFUNC *mf;
160			int i;
161	greg	1.1
162			if (m->oargs.nsargs < 7)
163			objerror(m, USER, "bad # arguments");
164	greg	2.2	mf = getfunc(m, 4, 0x3<<5, 0);
165			setfunc(m, r);
166	greg	1.4	errno = 0;
167	greg	2.2	pt[1] = evalue(mf->ep[0]); /* y major ordering */
168			pt[0] = evalue(mf->ep[1]);
169	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
170	greg	1.4	goto computerr;
171	greg	2.2	dp = getpict(m->oargs.sarg[3]);
172	greg	1.1	for (i = 0; i < 3; i++)
173			col[i] = datavalue(dp+i, pt);
174			errno = 0;
175	greg	2.3	for (i = 0; i < 3; i++)
176			if (fundefined(m->oargs.sarg[i]) < 3)
177			colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
178			else
179			colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
180	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
181	greg	1.1	goto computerr;
182	greg	2.10	smultcolor(r->pcol, cval);
183	greg	2.4	return(0);
184	greg	1.1
185			computerr:
186			objerror(m, WARNING, "compute error");
187	greg	2.4	return(0);
188	greg	1.1	}
189	greg	2.10
190
191			int
192			p_spectrum( /* simple constant spectrum */
193			OBJREC *m,
194			RAY *r
195			)
196			{
197			COLORV *scval;
198
199			if ((scval = (COLORV *)m->os) == NULL) {
200			COLORV *sinp;
201			double hstep;
202			int i;
203			if (m->oargs.nfargs < 5)
204			objerror(m, USER, "bad # arguments");
205			sinp = (COLORV )malloc(sizeof(COLORV)(m->oargs.nfargs-2));
206			scval = (COLORV )malloc(sizeof(COLORV)NCSAMP);
207			if ((sinp == NULL) \| (scval == NULL))
208			objerror(m, SYSTEM, "out of memory");
209			for (i = m->oargs.nfargs-2; i--; )
210			sinp[i] = (COLORV)m->oargs.farg[i+2];
211			hstep = 0.5 * (m->oargs.farg[1] - m->oargs.farg[0]) /
212			(m->oargs.nfargs-3.0);
213			convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
214			sinp, m->oargs.nfargs-2,
215			m->oargs.farg[0]-hstep, m->oargs.farg[1]+hstep);
216			free(sinp);
217			m->os = (void *)scval;
218			}
219			smultscolor(r->pcol, scval);
220			return(0);
221			}
222
223
224			int
225			p_specfile( /* constant spectrum from 1-D data file */
226			OBJREC *m,
227			RAY *r
228			)
229			{
230			COLORV *scval;
231
232			if ((scval = (COLORV *)m->os) == NULL) {
233			DATARRAY *dp;
234			COLORV *sinp;
235			double step;
236			int i;
237			if (m->oargs.nsargs != 1)
238			objerror(m, USER, "bad # arguments");
239			dp = getdata(m->oargs.sarg[0]);
240			if (dp->nd != 1)
241			objerror(m, USER, "data file must be 1-dimensional");
242
243			sinp = (COLORV )malloc(sizeof(COLORV)dp->dim[0].ne);
244			scval = (COLORV )malloc(sizeof(COLORV)NCSAMP);
245			if ((sinp == NULL) \| (scval == NULL))
246			objerror(m, SYSTEM, "out of memory");
247			step = dp->dim[0].siz / (dp->dim[0].ne - 1.0);
248			for (i = dp->dim[0].ne; i-- > 0; ) {
249			double wl = dp->dim[0].org + i*step;
250			sinp[i] = (COLORV)datavalue(dp, &wl);
251			}
252			convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
253			sinp, dp->dim[0].ne, dp->dim[0].org-.5*step,
254			dp->dim[0].org+dp->dim[0].siz+.5*step);
255			free(sinp);
256			m->os = (void *)scval;
257			}
258			smultscolor(r->pcol, scval);
259			return(0);
260			}