src/rt/p_data.c

#ifndef lint
static const char       RCSid[] = "$Id: p_data.c,v 2.13 2024/01/17 17:35:35 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++) {
                if (!strcmp(m->oargs.sarg[3+i], m->oargs.sarg[3])) {
                        col[i] = col[0];        /* same data */
                        continue;
                }
                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.14
Committed:	Thu Feb 22 20:11:54 2024 UTC (20 months, 1 week ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.13:	+5 -1 lines
Log Message:	perf: Eliminated redundant calculations when same data file is reused for RGB
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.14	static const char RCSid[] = "$Id: p_data.c,v 2.13 2024/01/17 17:35:35 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.14	if (!strcmp(m->oargs.sarg[3+i], m->oargs.sarg[3])) {
145			col[i] = col[0]; /* same data */
146			continue;
147			}
148	greg	2.11	dp = getdata(m->oargs.sarg[3+i]);
149	greg	1.1	if (dp->nd != nv)
150	greg	2.2	objerror(m, USER, "dimension error");
151	greg	1.1	col[i] = datavalue(dp, pt);
152			}
153			errno = 0;
154	greg	2.3	for (i = 0; i < 3; i++)
155	greg	2.11	if (i && fundefined(m->oargs.sarg[i]) < 3)
156	greg	2.3	colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
157			else
158			colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
159	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
160	greg	1.1	goto computerr;
161	greg	2.10	smultcolor(r->pcol, cval);
162	greg	2.4	return(0);
163	greg	1.1	computerr:
164			objerror(m, WARNING, "compute error");
165	greg	2.4	return(0);
166	greg	1.1	}
167
168
169	greg	2.9	int
170	schorsch	2.8	p_pdata( /* interpolate picture data */
171	greg	2.9	OBJREC *m,
172	schorsch	2.8	RAY *r
173			)
174	greg	1.1	{
175			double col[3];
176			COLOR cval;
177			double pt[2];
178			DATARRAY *dp;
179	greg	2.9	MFUNC *mf;
180			int i;
181	greg	1.1
182			if (m->oargs.nsargs < 7)
183			objerror(m, USER, "bad # arguments");
184	greg	2.2	mf = getfunc(m, 4, 0x3<<5, 0);
185			setfunc(m, r);
186	greg	1.4	errno = 0;
187	greg	2.2	pt[1] = evalue(mf->ep[0]); /* y major ordering */
188			pt[0] = evalue(mf->ep[1]);
189	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
190	greg	1.4	goto computerr;
191	greg	2.2	dp = getpict(m->oargs.sarg[3]);
192	greg	1.1	for (i = 0; i < 3; i++)
193			col[i] = datavalue(dp+i, pt);
194			errno = 0;
195	greg	2.3	for (i = 0; i < 3; i++)
196	greg	2.11	if (i && fundefined(m->oargs.sarg[i]) < 3)
197	greg	2.3	colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
198			else
199			colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
200	greg	2.10	if ((errno == EDOM) \| (errno == ERANGE))
201	greg	1.1	goto computerr;
202	greg	2.10	smultcolor(r->pcol, cval);
203	greg	2.4	return(0);
204	greg	1.1
205			computerr:
206			objerror(m, WARNING, "compute error");
207	greg	2.4	return(0);
208	greg	1.1	}
209	greg	2.10
210
211			int
212			p_spectrum( /* simple constant spectrum */
213			OBJREC *m,
214			RAY *r
215			)
216			{
217			COLORV *scval;
218
219			if ((scval = (COLORV *)m->os) == NULL) {
220			COLORV *sinp;
221			double hstep;
222			int i;
223			if (m->oargs.nfargs < 5)
224			objerror(m, USER, "bad # arguments");
225			sinp = (COLORV )malloc(sizeof(COLORV)(m->oargs.nfargs-2));
226			scval = (COLORV )malloc(sizeof(COLORV)NCSAMP);
227			if ((sinp == NULL) \| (scval == NULL))
228			objerror(m, SYSTEM, "out of memory");
229			for (i = m->oargs.nfargs-2; i--; )
230			sinp[i] = (COLORV)m->oargs.farg[i+2];
231			hstep = 0.5 * (m->oargs.farg[1] - m->oargs.farg[0]) /
232			(m->oargs.nfargs-3.0);
233	greg	2.13	convertscolorcol(scval, sinp, m->oargs.nfargs-2,
234	greg	2.10	m->oargs.farg[0]-hstep, m->oargs.farg[1]+hstep);
235			free(sinp);
236			m->os = (void *)scval;
237			}
238			smultscolor(r->pcol, scval);
239			return(0);
240			}
241
242
243			int
244			p_specfile( /* constant spectrum from 1-D data file */
245			OBJREC *m,
246			RAY *r
247			)
248			{
249			COLORV *scval;
250
251			if ((scval = (COLORV *)m->os) == NULL) {
252			DATARRAY *dp;
253			COLORV *sinp;
254			double step;
255			int i;
256			if (m->oargs.nsargs != 1)
257			objerror(m, USER, "bad # arguments");
258			dp = getdata(m->oargs.sarg[0]);
259			if (dp->nd != 1)
260			objerror(m, USER, "data file must be 1-dimensional");
261
262			sinp = (COLORV )malloc(sizeof(COLORV)dp->dim[0].ne);
263			scval = (COLORV )malloc(sizeof(COLORV)NCSAMP);
264			if ((sinp == NULL) \| (scval == NULL))
265			objerror(m, SYSTEM, "out of memory");
266			step = dp->dim[0].siz / (dp->dim[0].ne - 1.0);
267			for (i = dp->dim[0].ne; i-- > 0; ) {
268			double wl = dp->dim[0].org + i*step;
269			sinp[i] = (COLORV)datavalue(dp, &wl);
270			}
271	greg	2.13	convertscolorcol(scval, sinp, dp->dim[0].ne,
272			dp->dim[0].org-.5*step,
273	greg	2.10	dp->dim[0].org+dp->dim[0].siz+.5*step);
274			free(sinp);
275			m->os = (void *)scval;
276			}
277			smultscolor(r->pcol, scval);
278			return(0);
279			}
280	greg	2.11
281
282			int
283			p_specdata( /* varied spectrum from (N+1)-D file */
284			OBJREC *m,
285			RAY *r
286			)
287			{
288			SCOLOR scval;
289			COLORV *scdat;
290			double pt[MAXDDIM];
291			DATARRAY *dp;
292			MFUNC *mf;
293			double step;
294			int i;
295
296			if (m->oargs.nsargs < 4)
297			objerror(m, USER, "bad # arguments");
298			dp = getdata(m->oargs.sarg[1]);
299			if (dp->nd < 2)
300			objerror(m, USER, "need at least 2-dimensional data");
301			i = (1 << (dp->nd-1)) - 1;
302			mf = getfunc(m, 2, i<<3, 0);
303			setfunc(m, r);
304			errno = 0;
305			for (i = dp->nd-1; i-- > 0; ) {
306			pt[i] = evalue(mf->ep[i]);
307			if ((errno == EDOM) \| (errno == ERANGE))
308			goto computerr;
309			}
310			step = dp->dim[dp->nd-1].siz / (dp->dim[dp->nd-1].ne - 1.0);
311			scdat = (COLORV )malloc(sizeof(COLORV)dp->dim[dp->nd-1].ne);
312			if (scdat == NULL)
313			objerror(m, SYSTEM, "out of memory");
314			for (i = dp->dim[dp->nd-1].ne; i-- > 0; ) {
315			double bval[2];
316			pt[dp->nd-1] = dp->dim[dp->nd-1].org + i*step;
317			bval[0] = datavalue(dp, pt);
318			bval[1] = pt[dp->nd-1];
319			errno = 0;
320			scdat[i] = funvalue(m->oargs.sarg[0], 2, bval);
321			if ((errno == EDOM) \| (errno == ERANGE))
322			goto computerr;
323			}
324	greg	2.13	convertscolorcol(scval, scdat, dp->dim[dp->nd-1].ne,
325	greg	2.11	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	greg	2.13	convertscolorcol(scval, scdat, dp->dim[2].ne,
371	greg	2.11	dp->dim[2].org-.5*step,
372			dp->dim[2].org+dp->dim[2].siz+.5*step);
373			smultscolor(r->pcol, scval);
374			return(0);
375			computerr:
376			objerror(m, WARNING, "compute error");
377			return(0);
378			}