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.2 by greg, Thu Jul 27 22:25:10 1989 UTC vs.
Revision 1.8 by greg, Tue Jan 15 22:24:19 1991 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1991 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# 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);
172 <        if (fscanf(fp, "-Y %d +X %d\n", &height, &width) != 2)
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++) {
176                  pp[i].nd = 2;
177 <                pp[i].dim[0].ne = width;
178 <                pp[i].dim[1].ne = height;
177 >                pp[i].dim[0].ne = height;
178 >                pp[i].dim[1].ne = width;
179                  pp[i].dim[0].org =
180                  pp[i].dim[1].org = 0.0;
181 <                if (width <= height) {
182 <                        pp[i].dim[0].siz = 1.0;
149 <                        pp[i].dim[1].siz = (double)height/width;
150 <                } else {
151 <                        pp[i].dim[0].siz = (double)width/height;
181 >                if (width <= height*inpaspect) {
182 >                        pp[i].dim[0].siz = inpaspect*(double)height/width;
183                          pp[i].dim[1].siz = 1.0;
184 +                } else {
185 +                        pp[i].dim[0].siz = 1.0;
186 +                        pp[i].dim[1].siz = (double)width/height/inpaspect;
187                  }
188 +                pp[i].dim[0].p = pp[i].dim[1].p = NULL;
189                  pp[i].arr = (DATATYPE *)malloc(width*height*sizeof(DATATYPE));
190                  if (pp[i].arr == NULL)
191                          goto memerr;
# Line 163 | Line 198 | char  *pname;
198                          goto readerr;
199                  for (x = 0; x < width; x++)
200                          for (i = 0; i < 3; i++)
201 <                                pp[i].arr[x*height+y] = colval(scanin[x],i);
201 >                                pp[i].arr[y*width+x] = colval(scanin[x],i);
202          }
203          free((char *)scanin);
204          fclose(fp);
# Line 184 | Line 219 | freedata(dname)                        /* free memory associated with dname
219   char  *dname;
220   {
221          register DATARRAY  *dp, *dpl;
222 +        register int  i;
223  
224          for (dpl = NULL, dp = dlist; dp != NULL; dpl = dp, dp = dp->next)
225                  if (!strcmp(dname, dp->name)) {
# Line 192 | Line 228 | char  *dname;
228                          else
229                                  dpl->next = dp->next;
230                          free((char *)dp->arr);
231 +                        for (i = 0; i < dp->nd; i++)
232 +                                if (dp->dim[i].p != NULL)
233 +                                        free((char *)dp->dim[i].p);
234                          freestr(dp->name);
235                          free((char *)dp);
236                          return;
# Line 227 | Line 266 | double  *pt;
266   {
267          DATARRAY  sd;
268          int  asize;
269 +        int  lower, upper;
270          register int  i;
271          double  x, y, y0, y1;
272 <
272 >                                        /* set up dimensions for recursion */
273          sd.nd = dp->nd - 1;
274          asize = 1;
275          for (i = 0; i < sd.nd; i++) {
276                  sd.dim[i].org = dp->dim[i+1].org;
277                  sd.dim[i].siz = dp->dim[i+1].siz;
278 +                sd.dim[i].p = dp->dim[i+1].p;
279                  asize *= sd.dim[i].ne = dp->dim[i+1].ne;
280          }
281 <
282 <        x = (pt[0] - dp->dim[0].org)/dp->dim[0].siz;
283 <
284 <        x *= dp->dim[0].ne - 1;
285 <
286 <        i = x;
287 <        if (i < 0)
288 <                i = 0;
289 <        else if (i > dp->dim[0].ne - 2)
290 <                i = dp->dim[0].ne - 2;
291 <
281 >                                        /* get independent variable */
282 >        if (dp->dim[0].p == NULL) {             /* evenly spaced points */
283 >                x = (pt[0] - dp->dim[0].org)/dp->dim[0].siz;
284 >                x = x * (dp->dim[0].ne - 1);
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 >        } else {                                /* unevenly spaced points */
291 >                if (dp->dim[0].siz > 0.0) {
292 >                        lower = 0;
293 >                        upper = dp->dim[0].ne;
294 >                } else {
295 >                        lower = dp->dim[0].ne;
296 >                        upper = 0;
297 >                }
298 >                do {
299 >                        i = (lower + upper) >> 1;
300 >                        if (pt[0] >= dp->dim[0].p[i])
301 >                                lower = i;
302 >                        else
303 >                                upper = i;
304 >                } while (i != (lower + upper) >> 1);
305 >                if (i > dp->dim[0].ne - 2)
306 >                        i = dp->dim[0].ne - 2;
307 >                x = i + (pt[0] - dp->dim[0].p[i]) /
308 >                                (dp->dim[0].p[i+1] - dp->dim[0].p[i]);
309 >        }
310 >                                        /* get dependent variable */
311          if (dp->nd == 1) {
312                  y0 = dp->arr[i];
313                  y1 = dp->arr[i+1];
# Line 257 | Line 317 | double  *pt;
317                  sd.arr = &dp->arr[(i+1)*asize];
318                  y1 = datavalue(&sd, pt+1);
319          }
260 –
320          /*
321           * Extrapolate as far as one division, then
322           * taper off harmonically to zero.

Diff Legend

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