ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/p_data.c
(Generate patch)

Comparing ray/src/rt/p_data.c (file contents):
Revision 1.2 by greg, Tue Mar 14 11:12:55 1989 UTC vs.
Revision 2.5 by greg, Sat Feb 22 02:07:29 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1986 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  p_data.c - routine for stored patterns.
6 + */
7 +
8 + /* ====================================================================
9 + * The Radiance Software License, Version 1.0
10   *
11 < *     6/4/86
11 > * Copyright (c) 1990 - 2002 The Regents of the University of California,
12 > * through Lawrence Berkeley National Laboratory.   All rights reserved.
13 > *
14 > * Redistribution and use in source and binary forms, with or without
15 > * modification, are permitted provided that the following conditions
16 > * are met:
17 > *
18 > * 1. Redistributions of source code must retain the above copyright
19 > *         notice, this list of conditions and the following disclaimer.
20 > *
21 > * 2. Redistributions in binary form must reproduce the above copyright
22 > *       notice, this list of conditions and the following disclaimer in
23 > *       the documentation and/or other materials provided with the
24 > *       distribution.
25 > *
26 > * 3. The end-user documentation included with the redistribution,
27 > *           if any, must include the following acknowledgment:
28 > *             "This product includes Radiance software
29 > *                 (http://radsite.lbl.gov/)
30 > *                 developed by the Lawrence Berkeley National Laboratory
31 > *               (http://www.lbl.gov/)."
32 > *       Alternately, this acknowledgment may appear in the software itself,
33 > *       if and wherever such third-party acknowledgments normally appear.
34 > *
35 > * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
36 > *       and "The Regents of the University of California" must
37 > *       not be used to endorse or promote products derived from this
38 > *       software without prior written permission. For written
39 > *       permission, please contact [email protected].
40 > *
41 > * 5. Products derived from this software may not be called "Radiance",
42 > *       nor may "Radiance" appear in their name, without prior written
43 > *       permission of Lawrence Berkeley National Laboratory.
44 > *
45 > * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
46 > * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47 > * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48 > * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
49 > * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50 > * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
51 > * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
52 > * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
53 > * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
54 > * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
55 > * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56 > * SUCH DAMAGE.
57 > * ====================================================================
58 > *
59 > * This software consists of voluntary contributions made by many
60 > * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
61 > * information on Lawrence Berkeley National Laboratory, please see
62 > * <http://www.lbl.gov/>.
63   */
64  
65   #include  "ray.h"
66  
67   #include  "data.h"
68  
69 + #include  "func.h"
70 +
71   /*
72   *      A stored pattern can either be brightness or
73   *  color data.  Brightness data is specified as:
# Line 52 | Line 106 | p_bdata(m, r)                  /* interpolate brightness data */
106   register OBJREC  *m;
107   RAY  *r;
108   {
55 –        extern double  varvalue(), funvalue(), datavalue();
56 –        extern int  errno;
57 –        int  nv;
109          double  bval;
110          double  pt[MAXDIM];
111          DATARRAY  *dp;
112 <        register char  **sa;
112 >        register MFUNC  *mf;
113 >        register int  i;
114  
63 –        setfunc(m, r);
64 –
65 –        sa = m->oargs.sarg;
66 –
115          if (m->oargs.nsargs < 4)
116                  objerror(m, USER, "bad # arguments");
117 <        if (!vardefined(sa[3]))
118 <                loadfunc(sa[2]);
117 >        dp = getdata(m->oargs.sarg[1]);
118 >        i = (1 << dp->nd) - 1;
119 >        mf = getfunc(m, 2, i<<3, 0);
120 >        setfunc(m, r);
121          errno = 0;
122 <        for (nv = 0; nv+3 < m->oargs.nsargs &&
123 <                        sa[nv+3][0] != '-'; nv++) {
124 <                if (nv >= MAXDIM)
125 <                        goto dimerr;
76 <                pt[nv] = varvalue(sa[nv+3]);
122 >        for (i = dp->nd; i-- > 0; ) {
123 >                pt[i] = evalue(mf->ep[i]);
124 >                if (errno)
125 >                        goto computerr;
126          }
78 –        if (errno)
79 –                goto computerr;
80 –        dp = getdata(sa[1]);
81 –        if (dp->nd != nv)
82 –                goto dimerr;
127          bval = datavalue(dp, pt);
128          errno = 0;
129 <        bval = funvalue(sa[0], 1, &bval);
129 >        bval = funvalue(m->oargs.sarg[0], 1, &bval);
130          if (errno)
131                  goto computerr;
132          scalecolor(r->pcol, bval);
133 <        return;
90 <
91 < dimerr:
92 <        objerror(m, USER, "dimension error");
93 <
133 >        return(0);
134   computerr:
135          objerror(m, WARNING, "compute error");
136 <        return;
136 >        return(0);
137   }
138  
139  
# Line 101 | Line 141 | p_cdata(m, r)                  /* interpolate color data */
141   register OBJREC  *m;
142   RAY  *r;
143   {
104 –        extern double  varvalue(), funvalue(), datavalue();
105 –        extern int  errno;
106 –        int  i, nv;
144          double  col[3];
145          COLOR  cval;
146          double  pt[MAXDIM];
147 +        int  nv;
148          DATARRAY  *dp;
149 <        register char  **sa;
149 >        register MFUNC  *mf;
150 >        register int  i;
151  
113 –        setfunc(m, r);
114 –
115 –        sa = m->oargs.sarg;
116 –
152          if (m->oargs.nsargs < 8)
153                  objerror(m, USER, "bad # arguments");
154 <        if (!vardefined(sa[7]))
155 <                loadfunc(sa[6]);
156 <        for (nv = 0; nv+7 < m->oargs.nsargs &&
157 <                        sa[nv+7][0] != '-'; nv++) {
158 <                if (nv >= MAXDIM)
159 <                        goto dimerr;
160 <                errno = 0;
126 <                pt[nv] = varvalue(sa[nv+7]);
154 >        dp = getdata(m->oargs.sarg[3]);
155 >        i = (1 << (nv = dp->nd)) - 1;
156 >        mf = getfunc(m, 6, i<<7, 0);
157 >        setfunc(m, r);
158 >        errno = 0;
159 >        for (i = 0; i < nv; i++) {
160 >                pt[i] = evalue(mf->ep[i]);
161                  if (errno)
162                          goto computerr;
163          }
164 <        for (i = 0; i < 3; i++) {
165 <                dp = getdata(sa[i+3]);
164 >        col[0] = datavalue(dp, pt);
165 >        for (i = 1; i < 3; i++) {
166 >                dp = getdata(m->oargs.sarg[i+3]);
167                  if (dp->nd != nv)
168 <                        goto dimerr;
168 >                        objerror(m, USER, "dimension error");
169                  col[i] = datavalue(dp, pt);
170          }
171          errno = 0;
172 <        setcolor(cval,  funvalue(sa[0], 3, col),
173 <                        funvalue(sa[1], 3, col),
174 <                        funvalue(sa[2], 3, col));
172 >        for (i = 0; i < 3; i++)
173 >                if (fundefined(m->oargs.sarg[i]) < 3)
174 >                        colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
175 >                else
176 >                        colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
177          if (errno)
178                  goto computerr;
179          multcolor(r->pcol, cval);
180 <        return;
144 <
145 < dimerr:
146 <        objerror(m, USER, "dimension error");
147 <
180 >        return(0);
181   computerr:
182          objerror(m, WARNING, "compute error");
183 <        return;
183 >        return(0);
184   }
185  
186  
# Line 155 | Line 188 | p_pdata(m, r)                  /* interpolate picture data */
188   register OBJREC  *m;
189   RAY  *r;
190   {
158 –        extern double  varvalue(), funvalue(), datavalue();
159 –        extern int  errno;
160 –        int  i;
191          double  col[3];
192          COLOR  cval;
193          double  pt[2];
194          DATARRAY  *dp;
195 <        register char  **sa;
195 >        register MFUNC  *mf;
196 >        register int  i;
197  
167 –        setfunc(m, r);
168 –
169 –        sa = m->oargs.sarg;
170 –
198          if (m->oargs.nsargs < 7)
199                  objerror(m, USER, "bad # arguments");
200 <        if (!vardefined(sa[5]))
201 <                loadfunc(sa[4]);
202 <        for (i = 0; i < 2; i++) {
203 <                errno = 0;
204 <                pt[i] = varvalue(sa[i+5]);
205 <                if (errno)
206 <                        goto computerr;
207 <        }
181 <        dp = getpict(sa[3]);
200 >        mf = getfunc(m, 4, 0x3<<5, 0);
201 >        setfunc(m, r);
202 >        errno = 0;
203 >        pt[1] = evalue(mf->ep[0]);      /* y major ordering */
204 >        pt[0] = evalue(mf->ep[1]);
205 >        if (errno)
206 >                goto computerr;
207 >        dp = getpict(m->oargs.sarg[3]);
208          for (i = 0; i < 3; i++)
209                  col[i] = datavalue(dp+i, pt);
210          errno = 0;
211 <        setcolor(cval,  funvalue(sa[0], 3, col),
212 <                        funvalue(sa[1], 3, col),
213 <                        funvalue(sa[2], 3, col));
211 >        for (i = 0; i < 3; i++)
212 >                if (fundefined(m->oargs.sarg[i]) < 3)
213 >                        colval(cval,i) = funvalue(m->oargs.sarg[i], 1, col+i);
214 >                else
215 >                        colval(cval,i) = funvalue(m->oargs.sarg[i], 3, col);
216          if (errno)
217                  goto computerr;
218          multcolor(r->pcol, cval);
219 <        return;
219 >        return(0);
220  
221   computerr:
222          objerror(m, WARNING, "compute error");
223 <        return;
223 >        return(0);
224   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines