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

Comparing ray/src/hd/rhdisp3.c (file contents):
Revision 3.4 by gregl, Fri Nov 21 18:17:37 1997 UTC vs.
Revision 3.8 by gregl, Fri Dec 19 11:54:16 1997 UTC

# Line 20 | Line 20 | struct cellist {
20  
21   int
22   npixels(vp, hr, vr, hp, bi)     /* compute appropriate number to evaluate */
23 < VIEW    *vp;
23 > register VIEW   *vp;
24   int     hr, vr;
25   HOLO    *hp;
26   int     bi;
27   {
28 <        static VIEW     vdo, vlast;
29 <        static HOLO     *hplast;
28 >        VIEW    vrev;
29          GCOORD  gc[2];
30 <        FVECT   cp[4];
31 <        FVECT   ip[4];
33 <        double  d;
30 >        FVECT   cp[4], ip[4];
31 >        double  af, ab;
32          register int    i;
33                                          /* compute cell corners in image */
34          if (!hdbcoord(gc, hp, bi))
35                  error(CONSISTENCY, "bad beam index in npixels");
36 <                                        /* has holodeck or view changed? */
37 <        if (hp != hplast || bcmp((char *)vp, (char *)&vlast, sizeof(VIEW))) {
38 <                copystruct(&vdo, vp);
39 <                if (sect_behind(hp, &vdo)) {    /* reverse view sense */
40 <                        vdo.vdir[0] = -vdo.vdir[0];
41 <                        vdo.vdir[1] = -vdo.vdir[1];
44 <                        vdo.vdir[2] = -vdo.vdir[2];
45 <                        setview(&vdo);
36 >        hdcell(cp, hp, gc+1);           /* find cell on front image */
37 >        for (i = 0; i < 4; i++) {
38 >                viewloc(ip[i], vp, cp[i]);
39 >                if (ip[i][2] < 0.) {
40 >                        af = 0;
41 >                        goto getback;
42                  }
43 <                hplast = hp;
44 <                copystruct(&vlast, vp);
43 >                ip[i][0] *= (double)hr; /* scale by resolution */
44 >                ip[i][1] *= (double)vr;
45          }
46 <        hdcell(cp, hp, gc+1);           /* find cell on image */
46 >                                        /* compute front area */
47 >        af = (ip[1][0]-ip[0][0])*(ip[2][1]-ip[0][1]) -
48 >                (ip[2][0]-ip[0][0])*(ip[1][1]-ip[0][1]);
49 >        af += (ip[2][0]-ip[3][0])*(ip[1][1]-ip[3][1]) -
50 >                (ip[1][0]-ip[3][0])*(ip[2][1]-ip[3][1]);
51 >        if (af >= 0) af *= 0.5;
52 >        else af *= -0.5;
53 > getback:
54 >        copystruct(&vrev, vp);          /* compute reverse view */
55 >        for (i = 0; i < 3; i++) {
56 >                vrev.vdir[i] = -vp->vdir[i];
57 >                vrev.vup[i] = -vp->vup[i];
58 >                vrev.hvec[i] = -vp->hvec[i];
59 >                vrev.vvec[i] = -vp->vvec[i];
60 >        }
61 >        hdcell(cp, hp, gc);             /* find cell on back image */
62          for (i = 0; i < 4; i++) {
63 <                viewloc(ip[i], &vdo, cp[i]);
63 >                viewloc(ip[i], &vrev, cp[i]);
64                  if (ip[i][2] < 0.)
65 <                        return(0);
65 >                        return((int)(af + 0.5));
66                  ip[i][0] *= (double)hr; /* scale by resolution */
67                  ip[i][1] *= (double)vr;
68          }
69 <                                        /* compute quad area */
70 <        d = (ip[1][0]-ip[0][0])*(ip[2][1]-ip[0][1]) -
69 >                                        /* compute back area */
70 >        ab = (ip[1][0]-ip[0][0])*(ip[2][1]-ip[0][1]) -
71                  (ip[2][0]-ip[0][0])*(ip[1][1]-ip[0][1]);
72 <        d += (ip[2][0]-ip[3][0])*(ip[1][1]-ip[3][1]) -
72 >        ab += (ip[2][0]-ip[3][0])*(ip[1][1]-ip[3][1]) -
73                  (ip[1][0]-ip[3][0])*(ip[2][1]-ip[3][1]);
74 <        if (d < 0)
75 <                d = -d;
76 <                                        /* round off result */
77 <        return((int)(.5*d+.5));
74 >        if (ab >= 0) ab *= 0.5;
75 >        else ab *= -0.5;
76 >                                        /* round off smaller area */
77 >        if (af <= ab)
78 >                return((int)(af + 0.5));
79 >        return((int)(ab + 0.5));
80   }
81  
82  
# Line 71 | Line 84 | int    bi;
84   * The ray directions that define the pyramid in visit_cells() needn't
85   * be normalized, but they must be given in clockwise order as seen
86   * from the pyramid's apex (origin).
87 + * If no cell centers fall within the domain, the closest cell is visited.
88   */
89   int
90   visit_cells(orig, pyrd, hp, vf, dp)     /* visit cells within a pyramid */
91   FVECT   orig, pyrd[4];          /* pyramid ray directions in clockwise order */
92 < HOLO    *hp;
92 > register HOLO   *hp;
93   int     (*vf)();
94   char    *dp;
95   {
96 <        int     n = 0;
96 >        int     ncalls = 0, n = 0;
97          int     inflags = 0;
98          FVECT   gp, pn[4], lo, ld;
99          double  po[4], lbeg, lend, d, t;
100 <        GCOORD  gc;
100 >        GCOORD  gc, gc2[2];
101          register int    i;
102                                          /* figure out whose side we're on */
103          hdgrid(gp, hp, orig);
# Line 129 | Line 143 | char   *dp;
143                          if (lbeg >= lend)
144                                  continue;
145                          i = lend + .5;          /* visit cells on this scan */
146 <                        for (gc.i[0] = lbeg + .5; gc.i[0] < i; gc.i[0]++)
146 >                        for (gc.i[0] = lbeg + .5; gc.i[0] < i; gc.i[0]++) {
147                                  n += (*vf)(&gc, dp);
148 +                                ncalls++;
149 +                        }
150                  }
151          }
152 <        return(n);
152 >        if (ncalls)                     /* got one at least */
153 >                return(n);
154 >                                        /* else find closest cell */
155 >        VSUM(ld, pyrd[0], pyrd[1], 1.);
156 >        VSUM(ld, ld, pyrd[2], 1.);
157 >        VSUM(ld, ld, pyrd[3], 1.);
158 > #if 0
159 >        if (normalize(ld) == 0.0)       /* technically not necessary */
160 >                return(0);
161 > #endif
162 >        d = hdinter(gc2, NULL, &t, hp, orig, ld);
163 >        if (d >= FHUGE || t <= 0.)
164 >                return(0);
165 >        return((*vf)(gc2+1, dp));       /* visit it */
166   }
167  
168  
# Line 257 | Line 286 | VIEW   *vp;
286          return(cl.cl);
287   memerr:
288          error(SYSTEM, "out of memory in getviewcells");
289 + }
290 +
291 +
292 + gridlines(f)                    /* run through holodeck section grid lines */
293 + int     (*f)();
294 + {
295 +        register int    hd, w, i;
296 +        int     g0, g1;
297 +        FVECT   wp[2], mov;
298 +        double  d;
299 +                                        /* do each wall on each section */
300 +        for (hd = 0; hdlist[hd] != NULL; hd++)
301 +                for (w = 0; w < 6; w++) {
302 +                        g0 = ((w>>1)+1)%3;
303 +                        g1 = ((w>>1)+2)%3;
304 +                        d = 1.0/hdlist[hd]->grid[g0];
305 +                        mov[0] = d * hdlist[hd]->xv[g0][0];
306 +                        mov[1] = d * hdlist[hd]->xv[g0][1];
307 +                        mov[2] = d * hdlist[hd]->xv[g0][2];
308 +                        if (w & 1) {
309 +                                VSUM(wp[0], hdlist[hd]->orig,
310 +                                                hdlist[hd]->xv[w>>1], 1.);
311 +                                VSUM(wp[0], wp[0], mov, 1.);
312 +                        } else
313 +                                VCOPY(wp[0], hdlist[hd]->orig);
314 +                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g1], 1.);
315 +                        for (i = hdlist[hd]->grid[g0]; ; ) {    /* g0 lines */
316 +                                (*f)(wp);
317 +                                if (!--i) break;
318 +                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
319 +                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
320 +                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
321 +                        }
322 +                        d = 1.0/hdlist[hd]->grid[g1];
323 +                        mov[0] = d * hdlist[hd]->xv[g1][0];
324 +                        mov[1] = d * hdlist[hd]->xv[g1][1];
325 +                        mov[2] = d * hdlist[hd]->xv[g1][2];
326 +                        if (w & 1)
327 +                                VSUM(wp[0], hdlist[hd]->orig,
328 +                                                hdlist[hd]->xv[w>>1], 1.);
329 +                        else
330 +                                VSUM(wp[0], hdlist[hd]->orig, mov, 1.);
331 +                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g0], 1.);
332 +                        for (i = hdlist[hd]->grid[g1]; ; ) {    /* g1 lines */
333 +                                (*f)(wp);
334 +                                if (!--i) break;
335 +                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
336 +                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
337 +                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
338 +                        }
339 +                }
340   }

Diff Legend

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