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.5 by greg, Tue Apr 3 17:48:46 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 +         *              @ ni p0i p1i .. pni
59           */
60  
61          if ((dfname = getpath(dname, libpath, R_OK)) == NULL) {
# Line 77 | Line 82 | char  *dname;
82          for (i = 0; i < dp->nd; i++) {
83                  if (fscanf(fp, "%lf %lf %d",
84                                  &dp->dim[i].org, &dp->dim[i].siz,
85 <                                &dp->dim[i].ne) != 3)
85 >                                &dp->dim[i].ne) == 3) {
86 >                        dp->dim[i].siz -= dp->dim[i].org;
87 >                        dp->dim[i].p = NULL;
88 >                } else if (fscanf(fp, "@ %d", &dp->dim[i].ne) == 1) {
89 >                        dp->dim[i].p = (double *)malloc(dp->dim[i].ne*sizeof(double));
90 >                        if (dp->dim[i].p == NULL)
91 >                                goto memerr;
92 >                        for (j = 0; j < dp->dim[i].ne; j++)
93 >                                if (fscanf(fp, "%lf", &dp->dim[i].p[j]) != 1)
94 >                                        goto scanerr;
95 >                        for (j = 1; j < dp->dim[i].ne-1; j++)
96 >                                if ((dp->dim[i].p[j-1] < dp->dim[i].p[j]) !=
97 >                                        (dp->dim[i].p[j] < dp->dim[i].p[j+1]))
98 >                                        goto scanerr;
99 >                        dp->dim[i].org = dp->dim[i].p[0];
100 >                        dp->dim[i].siz = dp->dim[i].p[dp->dim[i].ne-1]
101 >                                                - dp->dim[i].p[0];
102 >                } else
103                          goto scanerr;
104 <                dp->dim[i].siz -= dp->dim[i].org;
104 >                if (dp->dim[i].siz == 0.0 || dp->dim[i].ne < 2)
105 >                        goto scanerr;
106                  asize *= dp->dim[i].ne;
107          }
108          if ((dp->arr = (DATATYPE *)malloc(asize*sizeof(DATATYPE))) == NULL)
# Line 102 | Line 125 | scanerr:
125   }
126  
127  
128 + static double  inpaspect;               /* aspect ratio of input picture */
129 +
130 + static
131 + headaspect(s)                           /* check string for aspect ratio */
132 + char  *s;
133 + {
134 +        if (isaspect(s))
135 +                inpaspect *= aspectval(s);
136 + }
137 +
138 +
139   DATARRAY *
140   getpict(pname)                          /* get picture pname */
141   char  *pname;
# Line 135 | Line 169 | char  *pname;
169                  error(SYSTEM, errmsg);
170          }
171                                                  /* get dimensions */
172 <        getheader(fp, NULL);
172 >        inpaspect = 1.0;
173 >        getheader(fp, headaspect);
174          if (fgetresolu(&width, &height, fp) != (YMAJOR|YDECR))
175                  goto readerr;
176          for (i = 0; i < 3; i++) {
# Line 144 | Line 179 | char  *pname;
179                  pp[i].dim[1].ne = height;
180                  pp[i].dim[0].org =
181                  pp[i].dim[1].org = 0.0;
182 <                if (width <= height) {
182 >                if (width <= height*inpaspect) {
183                          pp[i].dim[0].siz = 1.0;
184 <                        pp[i].dim[1].siz = (double)height/width;
184 >                        pp[i].dim[1].siz = inpaspect*(double)height/width;
185                  } else {
186 <                        pp[i].dim[0].siz = (double)width/height;
186 >                        pp[i].dim[0].siz = (double)width/height/inpaspect;
187                          pp[i].dim[1].siz = 1.0;
188                  }
189                  pp[i].arr = (DATATYPE *)malloc(width*height*sizeof(DATATYPE));
# 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 229 | Line 268 | double  *pt;
268          int  asize;
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 >                        for (i = 0; i < dp->dim[0].ne; i++)
292 >                                if (pt[0] < dp->dim[0].p[i])
293 >                                        break;
294 >                else
295 >                        for (i = 0; i < dp->dim[0].ne; i++)
296 >                                if (pt[0] >= dp->dim[0].p[i])
297 >                                        break;
298 >                if (i <= 0)
299 >                        i = 0;
300 >                else if (i >= dp->dim[0].ne)
301 >                        i = dp->dim[0].ne - 2;
302 >                else
303 >                        i--;
304 >                x = i + (pt[0] - dp->dim[0].p[i]) /
305 >                                (dp->dim[0].p[i+1] - dp->dim[0].p[i]);
306 >        }
307 >                                        /* get dependent variable */
308          if (dp->nd == 1) {
309                  y0 = dp->arr[i];
310                  y1 = dp->arr[i+1];
# Line 257 | Line 314 | double  *pt;
314                  sd.arr = &dp->arr[(i+1)*asize];
315                  y1 = datavalue(&sd, pt+1);
316          }
260 –
317          /*
318           * Extrapolate as far as one division, then
319           * taper off harmonically to zero.

Diff Legend

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