src/rt/p_data.c

#ifndef lint
static const char       RCSid[] = "$Id: p_data.c,v 2.12 2023/12/14 00:51:12 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
 *
 *  A spectral data file is given as:
 *
 *      modifier specdata name
 *      4+ sfunc dfname vfname v0 .. xf
 *      0
 *      n A1 A2 ..
 *
 *  A spectral image is given as:
 *
 *      modifier specpict name
 *      5+ sfunc sfname vfname vx vy xf
 *      0
 *      n A1 A2 ..
 *
 *  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, except for specdata, which has a "hidden"
 *  last variable for the wavelength.  The funcs take a single argument
 *  for brightdata, three for colordata and colorpict, and two for
 *  specdata and specpict to modify 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[3+i]);
                if (dp->nd != nv)
                        objerror(m, USER, "dimension error");
                col[i] = datavalue(dp, pt);
        }
        errno = 0;
        for (i = 0; i < 3; i++)
                if (i && 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 (i && 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);
                convertscolorcol(scval, 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);
                }
                convertscolorcol(scval, 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);
}


int
p_specdata(                     /* varied spectrum from (N+1)-D file */
        OBJREC  *m,
        RAY  *r
)
{
        SCOLOR          scval;
        COLORV          *scdat;
        double          pt[MAXDDIM];
        DATARRAY        *dp;
        MFUNC           *mf;
        double          step;
        int             i;

        if (m->oargs.nsargs < 4)
                objerror(m, USER, "bad # arguments");
        dp = getdata(m->oargs.sarg[1]);
        if (dp->nd < 2)
                objerror(m, USER, "need at least 2-dimensional data");
        i = (1 << (dp->nd-1)) - 1;
        mf = getfunc(m, 2, i<<3, 0);
        setfunc(m, r);
        errno = 0;
        for (i = dp->nd-1; i-- > 0; ) {
                pt[i] = evalue(mf->ep[i]);
                if ((errno == EDOM) | (errno == ERANGE))
                        goto computerr;
        }
        step = dp->dim[dp->nd-1].siz / (dp->dim[dp->nd-1].ne - 1.0);
        scdat = (COLORV *)malloc(sizeof(COLORV)*dp->dim[dp->nd-1].ne);
        if (scdat == NULL)
                objerror(m, SYSTEM, "out of memory");
        for (i = dp->dim[dp->nd-1].ne; i-- > 0; ) {
                double  bval[2];
                pt[dp->nd-1] = dp->dim[dp->nd-1].org + i*step;
                bval[0] = datavalue(dp, pt);
                bval[1] = pt[dp->nd-1];
                errno = 0;
                scdat[i] = funvalue(m->oargs.sarg[0], 2, bval);
                if ((errno == EDOM) | (errno == ERANGE))
                        goto computerr;
        }
        convertscolorcol(scval, scdat, dp->dim[dp->nd-1].ne,
                        dp->dim[dp->nd-1].org-.5*step,
                        dp->dim[dp->nd-1].org+dp->dim[dp->nd-1].siz+.5*step);
        free(scdat);
        smultscolor(r->pcol, scval);
        return(0);
computerr:
        objerror(m, WARNING, "compute error");
        return(0);
}


int
p_specpict(                     /* interpolate hyperspectral image data */
        OBJREC  *m,
        RAY  *r
)
{
        SCOLOR          scdat, scval;
        double          pt[3];
        DATARRAY        *dp;
        MFUNC           *mf;
        double          step;
        int             i;

        if (m->oargs.nsargs < 5)
                objerror(m, USER, "bad # arguments");
        mf = getfunc(m, 2, 0x3<<3, 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 = getspec(m->oargs.sarg[1]);
        step = dp->dim[2].siz / (dp->dim[2].ne - 1.0);
        for (i = dp->dim[2].ne; i-- > 0; ) {
                double  bval[2];
                pt[2] = dp->dim[2].org + i*step;
                bval[0] = datavalue(dp, pt);
                bval[1] = pt[2];
                errno = 0;
                scdat[i] = funvalue(m->oargs.sarg[0], 2, bval);
                if ((errno == EDOM) | (errno == ERANGE))
                        goto computerr;
        }
        convertscolorcol(scval, scdat, dp->dim[2].ne,
                        dp->dim[2].org-.5*step,
                        dp->dim[2].org+dp->dim[2].siz+.5*step);
        smultscolor(r->pcol, scval);
        return(0);
computerr:
        objerror(m, WARNING, "compute error");
        return(0);
}
Revision:	2.13
Committed:	Wed Jan 17 17:35:35 2024 UTC (4 months, 2 weeks ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.12:	+6 -9 lines
Log Message:	perf(rvu, rpict, rtrace, rcontrib): Better rendering of spectral primitives in RGB mode
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.13	static const char RCSid[] = "$Id: p_data.c,v 2.12 2023/12/14 00:51:12 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	2.11	* A spectral data file is given as:
53			*
54			* modifier specdata name
55			* 4+ sfunc dfname vfname v0 .. xf
56			* 0
57			* n A1 A2 ..
58			*
59			* A spectral image is given as:
60			*
61			* modifier specpict name
62			* 5+ sfunc sfname vfname vx vy xf
63			* 0
64			* n A1 A2 ..
65			*
66	greg	1.1	* Vfname is the name of the file where the variable definitions
67			* can be found. The list of real arguments can be accessed by
68			* definitions in the file. The dfnames are the data file
69			* names. The dimensions of the data files and the number
70	greg	2.11	* of variables must match, except for specdata, which has a "hidden"
71			* last variable for the wavelength. The funcs take a single argument
72			* for brightdata, three for colordata and colorpict, and two for
73			* specdata and specpict to modify interpolated values from the file.
74			* The xf is a transform spec to get from the original coordinates to
75			* the current coordinates.
76	greg	1.1	*/
77
78
79	greg	2.9	int
80	schorsch	2.8	p_bdata( /* interpolate brightness data */
81	greg	2.9	OBJREC *m,
82	schorsch	2.8	RAY *r
83			)
84	greg	1.1	{
85			double bval;
86	greg	2.10	double pt[MAXDDIM];
87	greg	1.1	DATARRAY *dp;
88	greg	2.9	MFUNC *mf;
89			int i;
90	greg	1.1
91			if (m->oargs.nsargs < 4)
92			objerror(m, USER, "bad # arguments");
93	greg	2.2	dp = getdata(m->oargs.sarg[1]);
94			i = (1 << dp->nd) - 1;
95			mf = getfunc(m, 2, i<<3, 0);
96			setfunc(m, r);
97	greg	1.2	errno = 0;
98	greg	2.2	for (i = dp->nd; i-- > 0; ) {
99			pt[i] = evalue(mf->ep[i]);
100	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
101	greg	2.2	goto computerr;
102	greg	1.1	}
103			bval = datavalue(dp, pt);
104			errno = 0;
105	greg	2.2	bval = funvalue(m->oargs.sarg[0], 1, &bval);
106	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
107	greg	1.1	goto computerr;
108	greg	2.10	scalescolor(r->pcol, bval);
109	greg	2.4	return(0);
110	greg	1.1	computerr:
111			objerror(m, WARNING, "compute error");
112	greg	2.4	return(0);
113	greg	1.1	}
114
115
116	greg	2.9	int
117	schorsch	2.8	p_cdata( /* interpolate color data */
118	greg	2.9	OBJREC *m,
119	schorsch	2.8	RAY *r
120			)
121	greg	1.1	{
122			double col[3];
123			COLOR cval;
124	greg	2.10	double pt[MAXDDIM];
125	greg	2.2	int nv;
126	greg	1.1	DATARRAY *dp;
127	greg	2.9	MFUNC *mf;
128			int i;
129	greg	1.1
130			if (m->oargs.nsargs < 8)
131			objerror(m, USER, "bad # arguments");
132	greg	2.2	dp = getdata(m->oargs.sarg[3]);
133			i = (1 << (nv = dp->nd)) - 1;
134			mf = getfunc(m, 6, i<<7, 0);
135			setfunc(m, r);
136			errno = 0;
137			for (i = 0; i < nv; i++) {
138			pt[i] = evalue(mf->ep[i]);
139	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
140	greg	1.1	goto computerr;
141			}
142	greg	2.2	col[0] = datavalue(dp, pt);
143			for (i = 1; i < 3; i++) {
144	greg	2.11	dp = getdata(m->oargs.sarg[3+i]);
145	greg	1.1	if (dp->nd != nv)
146	greg	2.2	objerror(m, USER, "dimension error");
147	greg	1.1	col[i] = datavalue(dp, pt);
148			}
149			errno = 0;
150	greg	2.3	for (i = 0; i < 3; i++)
151	greg	2.11	if (i && fundefined(m->oargs.sarg[i]) < 3)
152	greg	2.3	colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
153			else
154			colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
155	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
156	greg	1.1	goto computerr;
157	greg	2.10	smultcolor(r->pcol, cval);
158	greg	2.4	return(0);
159	greg	1.1	computerr:
160			objerror(m, WARNING, "compute error");
161	greg	2.4	return(0);
162	greg	1.1	}
163
164
165	greg	2.9	int
166	schorsch	2.8	p_pdata( /* interpolate picture data */
167	greg	2.9	OBJREC *m,
168	schorsch	2.8	RAY *r
169			)
170	greg	1.1	{
171			double col[3];
172			COLOR cval;
173			double pt[2];
174			DATARRAY *dp;
175	greg	2.9	MFUNC *mf;
176			int i;
177	greg	1.1
178			if (m->oargs.nsargs < 7)
179			objerror(m, USER, "bad # arguments");
180	greg	2.2	mf = getfunc(m, 4, 0x3<<5, 0);
181			setfunc(m, r);
182	greg	1.4	errno = 0;
183	greg	2.2	pt[1] = evalue(mf->ep[0]); /* y major ordering */
184			pt[0] = evalue(mf->ep[1]);
185	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
186	greg	1.4	goto computerr;
187	greg	2.2	dp = getpict(m->oargs.sarg[3]);
188	greg	1.1	for (i = 0; i < 3; i++)
189			col[i] = datavalue(dp+i, pt);
190			errno = 0;
191	greg	2.3	for (i = 0; i < 3; i++)
192	greg	2.11	if (i && fundefined(m->oargs.sarg[i]) < 3)
193	greg	2.3	colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
194			else
195			colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
196	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
197	greg	1.1	goto computerr;
198	greg	2.10	smultcolor(r->pcol, cval);
199	greg	2.4	return(0);
200	greg	1.1
201			computerr:
202			objerror(m, WARNING, "compute error");
203	greg	2.4	return(0);
204	greg	1.1	}
205	greg	2.10
206
207			int
208			p_spectrum( /* simple constant spectrum */
209			OBJREC *m,
210			RAY *r
211			)
212			{
213			COLORV *scval;
214
215			if ((scval = (COLORV *)m->os) == NULL) {
216			COLORV *sinp;
217			double hstep;
218			int i;
219			if (m->oargs.nfargs < 5)
220			objerror(m, USER, "bad # arguments");
221			sinp = (COLORV )malloc(sizeof(COLORV)(m->oargs.nfargs-2));
222			scval = (COLORV )malloc(sizeof(COLORV)NCSAMP);
223			if ((sinp == NULL) \| (scval == NULL))
224			objerror(m, SYSTEM, "out of memory");
225			for (i = m->oargs.nfargs-2; i--; )
226			sinp[i] = (COLORV)m->oargs.farg[i+2];
227			hstep = 0.5 * (m->oargs.farg[1] - m->oargs.farg[0]) /
228			(m->oargs.nfargs-3.0);
229	greg	2.13	convertscolorcol(scval, sinp, m->oargs.nfargs-2,
230	greg	2.10	m->oargs.farg[0]-hstep, m->oargs.farg[1]+hstep);
231			free(sinp);
232			m->os = (void *)scval;
233			}
234			smultscolor(r->pcol, scval);
235			return(0);
236			}
237
238
239			int
240			p_specfile( /* constant spectrum from 1-D data file */
241			OBJREC *m,
242			RAY *r
243			)
244			{
245			COLORV *scval;
246
247			if ((scval = (COLORV *)m->os) == NULL) {
248			DATARRAY *dp;
249			COLORV *sinp;
250			double step;
251			int i;
252			if (m->oargs.nsargs != 1)
253			objerror(m, USER, "bad # arguments");
254			dp = getdata(m->oargs.sarg[0]);
255			if (dp->nd != 1)
256			objerror(m, USER, "data file must be 1-dimensional");
257
258			sinp = (COLORV )malloc(sizeof(COLORV)dp->dim[0].ne);
259			scval = (COLORV )malloc(sizeof(COLORV)NCSAMP);
260			if ((sinp == NULL) \| (scval == NULL))
261			objerror(m, SYSTEM, "out of memory");
262			step = dp->dim[0].siz / (dp->dim[0].ne - 1.0);
263			for (i = dp->dim[0].ne; i-- > 0; ) {
264			double wl = dp->dim[0].org + i*step;
265			sinp[i] = (COLORV)datavalue(dp, &wl);
266			}
267	greg	2.13	convertscolorcol(scval, sinp, dp->dim[0].ne,
268			dp->dim[0].org-.5*step,
269	greg	2.10	dp->dim[0].org+dp->dim[0].siz+.5*step);
270			free(sinp);
271			m->os = (void *)scval;
272			}
273			smultscolor(r->pcol, scval);
274			return(0);
275			}
276	greg	2.11
277
278			int
279			p_specdata( /* varied spectrum from (N+1)-D file */
280			OBJREC *m,
281			RAY *r
282			)
283			{
284			SCOLOR scval;
285			COLORV *scdat;
286			double pt[MAXDDIM];
287			DATARRAY *dp;
288			MFUNC *mf;
289			double step;
290			int i;
291
292			if (m->oargs.nsargs < 4)
293			objerror(m, USER, "bad # arguments");
294			dp = getdata(m->oargs.sarg[1]);
295			if (dp->nd < 2)
296			objerror(m, USER, "need at least 2-dimensional data");
297			i = (1 << (dp->nd-1)) - 1;
298			mf = getfunc(m, 2, i<<3, 0);
299			setfunc(m, r);
300			errno = 0;
301			for (i = dp->nd-1; i-- > 0; ) {
302			pt[i] = evalue(mf->ep[i]);
303			if ((errno == EDOM) \| (errno == ERANGE))
304			goto computerr;
305			}
306			step = dp->dim[dp->nd-1].siz / (dp->dim[dp->nd-1].ne - 1.0);
307			scdat = (COLORV )malloc(sizeof(COLORV)dp->dim[dp->nd-1].ne);
308			if (scdat == NULL)
309			objerror(m, SYSTEM, "out of memory");
310			for (i = dp->dim[dp->nd-1].ne; i-- > 0; ) {
311			double bval[2];
312			pt[dp->nd-1] = dp->dim[dp->nd-1].org + i*step;
313			bval[0] = datavalue(dp, pt);
314			bval[1] = pt[dp->nd-1];
315			errno = 0;
316			scdat[i] = funvalue(m->oargs.sarg[0], 2, bval);
317			if ((errno == EDOM) \| (errno == ERANGE))
318			goto computerr;
319			}
320	greg	2.13	convertscolorcol(scval, scdat, dp->dim[dp->nd-1].ne,
321	greg	2.11	dp->dim[dp->nd-1].org-.5*step,
322			dp->dim[dp->nd-1].org+dp->dim[dp->nd-1].siz+.5*step);
323			free(scdat);
324			smultscolor(r->pcol, scval);
325			return(0);
326			computerr:
327			objerror(m, WARNING, "compute error");
328			return(0);
329			}
330
331
332			int
333			p_specpict( /* interpolate hyperspectral image data */
334			OBJREC *m,
335			RAY *r
336			)
337			{
338			SCOLOR scdat, scval;
339			double pt[3];
340			DATARRAY *dp;
341			MFUNC *mf;
342			double step;
343			int i;
344
345			if (m->oargs.nsargs < 5)
346			objerror(m, USER, "bad # arguments");
347			mf = getfunc(m, 2, 0x3<<3, 0);
348			setfunc(m, r);
349			errno = 0;
350			pt[1] = evalue(mf->ep[0]); /* y major ordering */
351			pt[0] = evalue(mf->ep[1]);
352			if ((errno == EDOM) \| (errno == ERANGE))
353			goto computerr;
354			dp = getspec(m->oargs.sarg[1]);
355			step = dp->dim[2].siz / (dp->dim[2].ne - 1.0);
356			for (i = dp->dim[2].ne; i-- > 0; ) {
357			double bval[2];
358			pt[2] = dp->dim[2].org + i*step;
359			bval[0] = datavalue(dp, pt);
360			bval[1] = pt[2];
361			errno = 0;
362			scdat[i] = funvalue(m->oargs.sarg[0], 2, bval);
363			if ((errno == EDOM) \| (errno == ERANGE))
364			goto computerr;
365			}
366	greg	2.13	convertscolorcol(scval, scdat, dp->dim[2].ne,
367	greg	2.11	dp->dim[2].org-.5*step,
368			dp->dim[2].org+dp->dim[2].siz+.5*step);
369			smultscolor(r->pcol, scval);
370			return(0);
371			computerr:
372			objerror(m, WARNING, "compute error");
373			return(0);
374			}