src/rt/p_data.c

#ifndef lint
static const char       RCSid[] = "$Id: p_data.c,v 2.10 2023/11/15 18:02:53 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);
                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);
}


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");
        if (dp->dim[dp->nd-1].ne > MAXCSAMP)
                objerror(m, USER, "too many spectral samples in data file");
        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;
        }
        convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
                        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;
        }
        convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
                        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.11
Committed:	Wed Dec 13 23:26:16 2023 UTC (5 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.10:	+127 -8 lines
Log Message:	feat(rpict,rvu,rtrace,rcontrib): Added "specdata" and "specpict" pattern primitives
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.11	static const char RCSid[] = "$Id: p_data.c,v 2.10 2023/11/15 18:02:53 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			convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
230			sinp, m->oargs.nfargs-2,
231			m->oargs.farg[0]-hstep, m->oargs.farg[1]+hstep);
232			free(sinp);
233			m->os = (void *)scval;
234			}
235			smultscolor(r->pcol, scval);
236			return(0);
237			}
238
239
240			int
241			p_specfile( /* constant spectrum from 1-D data file */
242			OBJREC *m,
243			RAY *r
244			)
245			{
246			COLORV *scval;
247
248			if ((scval = (COLORV *)m->os) == NULL) {
249			DATARRAY *dp;
250			COLORV *sinp;
251			double step;
252			int i;
253			if (m->oargs.nsargs != 1)
254			objerror(m, USER, "bad # arguments");
255			dp = getdata(m->oargs.sarg[0]);
256			if (dp->nd != 1)
257			objerror(m, USER, "data file must be 1-dimensional");
258
259			sinp = (COLORV )malloc(sizeof(COLORV)dp->dim[0].ne);
260			scval = (COLORV )malloc(sizeof(COLORV)NCSAMP);
261			if ((sinp == NULL) \| (scval == NULL))
262			objerror(m, SYSTEM, "out of memory");
263			step = dp->dim[0].siz / (dp->dim[0].ne - 1.0);
264			for (i = dp->dim[0].ne; i-- > 0; ) {
265			double wl = dp->dim[0].org + i*step;
266			sinp[i] = (COLORV)datavalue(dp, &wl);
267			}
268			convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
269			sinp, dp->dim[0].ne, dp->dim[0].org-.5*step,
270			dp->dim[0].org+dp->dim[0].siz+.5*step);
271			free(sinp);
272			m->os = (void *)scval;
273			}
274			smultscolor(r->pcol, scval);
275			return(0);
276			}
277	greg	2.11
278
279			int
280			p_specdata( /* varied spectrum from (N+1)-D file */
281			OBJREC *m,
282			RAY *r
283			)
284			{
285			SCOLOR scval;
286			COLORV *scdat;
287			double pt[MAXDDIM];
288			DATARRAY *dp;
289			MFUNC *mf;
290			double step;
291			int i;
292
293			if (m->oargs.nsargs < 4)
294			objerror(m, USER, "bad # arguments");
295			dp = getdata(m->oargs.sarg[1]);
296			if (dp->nd < 2)
297			objerror(m, USER, "need at least 2-dimensional data");
298			if (dp->dim[dp->nd-1].ne > MAXCSAMP)
299			objerror(m, USER, "too many spectral samples in data file");
300			i = (1 << (dp->nd-1)) - 1;
301			mf = getfunc(m, 2, i<<3, 0);
302			setfunc(m, r);
303			errno = 0;
304			for (i = dp->nd-1; i-- > 0; ) {
305			pt[i] = evalue(mf->ep[i]);
306			if ((errno == EDOM) \| (errno == ERANGE))
307			goto computerr;
308			}
309			step = dp->dim[dp->nd-1].siz / (dp->dim[dp->nd-1].ne - 1.0);
310			scdat = (COLORV )malloc(sizeof(COLORV)dp->dim[dp->nd-1].ne);
311			if (scdat == NULL)
312			objerror(m, SYSTEM, "out of memory");
313			for (i = dp->dim[dp->nd-1].ne; i-- > 0; ) {
314			double bval[2];
315			pt[dp->nd-1] = dp->dim[dp->nd-1].org + i*step;
316			bval[0] = datavalue(dp, pt);
317			bval[1] = pt[dp->nd-1];
318			errno = 0;
319			scdat[i] = funvalue(m->oargs.sarg[0], 2, bval);
320			if ((errno == EDOM) \| (errno == ERANGE))
321			goto computerr;
322			}
323			convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
324			scdat, dp->dim[dp->nd-1].ne,
325			dp->dim[dp->nd-1].org-.5*step,
326			dp->dim[dp->nd-1].org+dp->dim[dp->nd-1].siz+.5*step);
327			free(scdat);
328			smultscolor(r->pcol, scval);
329			return(0);
330			computerr:
331			objerror(m, WARNING, "compute error");
332			return(0);
333			}
334
335
336			int
337			p_specpict( /* interpolate hyperspectral image data */
338			OBJREC *m,
339			RAY *r
340			)
341			{
342			SCOLOR scdat, scval;
343			double pt[3];
344			DATARRAY *dp;
345			MFUNC *mf;
346			double step;
347			int i;
348
349			if (m->oargs.nsargs < 5)
350			objerror(m, USER, "bad # arguments");
351			mf = getfunc(m, 2, 0x3<<3, 0);
352			setfunc(m, r);
353			errno = 0;
354			pt[1] = evalue(mf->ep[0]); /* y major ordering */
355			pt[0] = evalue(mf->ep[1]);
356			if ((errno == EDOM) \| (errno == ERANGE))
357			goto computerr;
358			dp = getspec(m->oargs.sarg[1]);
359			step = dp->dim[2].siz / (dp->dim[2].ne - 1.0);
360			for (i = dp->dim[2].ne; i-- > 0; ) {
361			double bval[2];
362			pt[2] = dp->dim[2].org + i*step;
363			bval[0] = datavalue(dp, pt);
364			bval[1] = pt[2];
365			errno = 0;
366			scdat[i] = funvalue(m->oargs.sarg[0], 2, bval);
367			if ((errno == EDOM) \| (errno == ERANGE))
368			goto computerr;
369			}
370			convertscolor(scval, NCSAMP, WLPART[0], WLPART[3],
371			scdat, dp->dim[2].ne,
372			dp->dim[2].org-.5*step,
373			dp->dim[2].org+dp->dim[2].siz+.5*step);
374			smultscolor(r->pcol, scval);
375			return(0);
376			computerr:
377			objerror(m, WARNING, "compute error");
378			return(0);
379			}