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

Comparing ray/src/rt/data.c (file contents):
Revision 1.3 by greg, Tue Sep 12 12:26:14 1989 UTC vs.
Revision 1.6 by greg, Fri Apr 6 14:12:21 1990 UTC

# Line 31 | Line 31 | char  *dname;
31          char  *dfname;
32          FILE  *fp;
33          int  asize;
34 <        register int  i;
34 >        register int  i, j;
35          register DATARRAY  *dp;
36                                                  /* look for array in list */
37          for (dp = dlist; dp != NULL; dp = dp->next)
# Line 44 | Line 44 | char  *dname;
44           *
45           *      The file has the following format:
46           *
47 <         *              #dimensions
47 >         *              N
48           *              beg0    end0    n0
49           *              beg1    end1    n1
50           *              . . .
51 +         *              begN    endN    nN
52           *              data, later dimensions changing faster
53           *              . . .
54           *
55 +         *      For irregularly spaced points, the following can be
56 +         *  substituted for begi endi ni:
57 +         *
58 +         *              0 0 ni p0i p1i .. pni
59           */
60  
61          if ((dfname = getpath(dname, libpath, R_OK)) == NULL) {
# Line 79 | Line 84 | char  *dname;
84                                  &dp->dim[i].org, &dp->dim[i].siz,
85                                  &dp->dim[i].ne) != 3)
86                          goto scanerr;
87 <                dp->dim[i].siz -= dp->dim[i].org;
87 >                if (dp->dim[i].ne < 2)
88 >                        goto scanerr;
89                  asize *= dp->dim[i].ne;
90 +                if ((dp->dim[i].siz -= dp->dim[i].org) == 0) {
91 +                        dp->dim[i].p = (double *)malloc(dp->dim[i].ne*sizeof(double));
92 +                        if (dp->dim[i].p == NULL)
93 +                                goto memerr;
94 +                        for (j = 0; j < dp->dim[i].ne; j++)
95 +                                if (fscanf(fp, "%lf", &dp->dim[i].p[j]) != 1)
96 +                                        goto scanerr;
97 +                        for (j = 1; j < dp->dim[i].ne-1; j++)
98 +                                if ((dp->dim[i].p[j-1] < dp->dim[i].p[j]) !=
99 +                                        (dp->dim[i].p[j] < dp->dim[i].p[j+1]))
100 +                                        goto scanerr;
101 +                        dp->dim[i].org = dp->dim[i].p[0];
102 +                        dp->dim[i].siz = dp->dim[i].p[dp->dim[i].ne-1]
103 +                                                - dp->dim[i].p[0];
104 +                } else
105 +                        dp->dim[i].p = NULL;
106          }
107          if ((dp->arr = (DATATYPE *)malloc(asize*sizeof(DATATYPE))) == NULL)
108                  goto memerr;
# Line 102 | Line 124 | scanerr:
124   }
125  
126  
127 + static double  inpaspect;               /* aspect ratio of input picture */
128 +
129 + static
130 + headaspect(s)                           /* check string for aspect ratio */
131 + char  *s;
132 + {
133 +        if (isaspect(s))
134 +                inpaspect *= aspectval(s);
135 + }
136 +
137 +
138   DATARRAY *
139   getpict(pname)                          /* get picture pname */
140   char  *pname;
# Line 135 | Line 168 | char  *pname;
168                  error(SYSTEM, errmsg);
169          }
170                                                  /* get dimensions */
171 <        getheader(fp, NULL);
171 >        inpaspect = 1.0;
172 >        getheader(fp, headaspect);
173          if (fgetresolu(&width, &height, fp) != (YMAJOR|YDECR))
174                  goto readerr;
175          for (i = 0; i < 3; i++) {
# Line 144 | Line 178 | char  *pname;
178                  pp[i].dim[1].ne = height;
179                  pp[i].dim[0].org =
180                  pp[i].dim[1].org = 0.0;
181 <                if (width <= height) {
181 >                if (width <= height*inpaspect) {
182                          pp[i].dim[0].siz = 1.0;
183 <                        pp[i].dim[1].siz = (double)height/width;
183 >                        pp[i].dim[1].siz = inpaspect*(double)height/width;
184                  } else {
185 <                        pp[i].dim[0].siz = (double)width/height;
185 >                        pp[i].dim[0].siz = (double)width/height/inpaspect;
186                          pp[i].dim[1].siz = 1.0;
187                  }
188                  pp[i].arr = (DATATYPE *)malloc(width*height*sizeof(DATATYPE));
# Line 184 | Line 218 | freedata(dname)                        /* free memory associated with dname
218   char  *dname;
219   {
220          register DATARRAY  *dp, *dpl;
221 +        register int  i;
222  
223          for (dpl = NULL, dp = dlist; dp != NULL; dpl = dp, dp = dp->next)
224                  if (!strcmp(dname, dp->name)) {
# Line 192 | Line 227 | char  *dname;
227                          else
228                                  dpl->next = dp->next;
229                          free((char *)dp->arr);
230 +                        for (i = 0; i < dp->nd; i++)
231 +                                if (dp->dim[i].p != NULL)
232 +                                        free((char *)dp->dim[i].p);
233                          freestr(dp->name);
234                          free((char *)dp);
235                          return;
# Line 227 | Line 265 | double  *pt;
265   {
266          DATARRAY  sd;
267          int  asize;
268 +        int  lower, upper;
269          register int  i;
270          double  x, y, y0, y1;
271 <
271 >                                        /* set up dimensions for recursion */
272          sd.nd = dp->nd - 1;
273          asize = 1;
274          for (i = 0; i < sd.nd; i++) {
275                  sd.dim[i].org = dp->dim[i+1].org;
276                  sd.dim[i].siz = dp->dim[i+1].siz;
277 +                sd.dim[i].p = dp->dim[i+1].p;
278                  asize *= sd.dim[i].ne = dp->dim[i+1].ne;
279          }
280 <
281 <        x = (pt[0] - dp->dim[0].org)/dp->dim[0].siz;
282 <
283 <        x *= dp->dim[0].ne - 1;
284 <
285 <        i = x;
286 <        if (i < 0)
287 <                i = 0;
288 <        else if (i > dp->dim[0].ne - 2)
289 <                i = dp->dim[0].ne - 2;
290 <
280 >                                        /* get independent variable */
281 >        if (dp->dim[0].p == NULL) {             /* evenly spaced points */
282 >                x = (pt[0] - dp->dim[0].org)/dp->dim[0].siz;
283 >                x = x * (dp->dim[0].ne - 1);
284 >                i = x;
285 >                if (i < 0)
286 >                        i = 0;
287 >                else if (i > dp->dim[0].ne - 2)
288 >                        i = dp->dim[0].ne - 2;
289 >        } else {                                /* unevenly spaced points */
290 >                if (dp->dim[0].siz > 0.0) {
291 >                        lower = 0;
292 >                        upper = dp->dim[0].ne;
293 >                } else {
294 >                        lower = dp->dim[0].ne;
295 >                        upper = 0;
296 >                }
297 >                do {
298 >                        i = (lower + upper) >> 1;
299 >                        if (pt[0] >= dp->dim[0].p[i])
300 >                                lower = i;
301 >                        else if (pt[0] < dp->dim[0].p[i])
302 >                                upper = i;
303 >                } while (i != (lower + upper) >> 1);
304 >                if (i < 0)
305 >                        i = 0;
306 >                else if (i > dp->dim[0].ne - 2)
307 >                        i = dp->dim[0].ne - 2;
308 >                x = i + (pt[0] - dp->dim[0].p[i]) /
309 >                                (dp->dim[0].p[i+1] - dp->dim[0].p[i]);
310 >        }
311 >                                        /* get dependent variable */
312          if (dp->nd == 1) {
313                  y0 = dp->arr[i];
314                  y1 = dp->arr[i+1];
# Line 257 | Line 318 | double  *pt;
318                  sd.arr = &dp->arr[(i+1)*asize];
319                  y1 = datavalue(&sd, pt+1);
320          }
260
321          /*
322           * Extrapolate as far as one division, then
323           * taper off harmonically to zero.

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines