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

Comparing ray/src/hd/rhcopy.c (file contents):
Revision 3.7 by gregl, Wed Jan 7 17:46:18 1998 UTC vs.
Revision 3.13 by gwlarson, Mon Feb 1 10:22:46 1999 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1997 Silicon Graphics, Inc. */
1 > /* Copyright (c) 1999 Silicon Graphics, Inc. */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ SGI";
# Line 12 | Line 12 | static char SCCSid[] = "$SunId$ SGI";
12   #include "view.h"
13   #include "resolu.h"
14  
15 < #ifndef BLOADSIZE
16 < #define BLOADSIZE       1024    /* number of input beams to load at a time */
15 > #ifndef BKBSIZE
16 > #define BKBSIZE         256             /* beam clump size (kilobytes) */
17   #endif
18  
19   int     checkdepth = 1;         /* check depth (!-f option)? */
# Line 35 | Line 35 | char   *argv[];
35          frompicz = -1;
36          for (i = 2; i < argc && argv[i][0] == '-'; i++)
37                  switch (argv[i][1]) {
38 <                case 'c':
38 >                case 'u':
39                          checkrepeats = 1;
40                          break;
41 <                case 'f':
41 >                case 'd':
42                          checkdepth = 0;
43                          break;
44                  case 'h':
# Line 55 | Line 55 | char   *argv[];
55          if (frompicz && (argc-i)%2)
56                  goto userr;
57          noutsects = openholo(argv[1], 1);
58 <        if (frompicz)
58 >        if (frompicz) {
59                  for ( ; i < argc; i += 2)
60                          addpicz(argv[i], argv[i+1]);
61 <        else
61 >        } else {
62 >                if (BKBSIZE*1024*1.5 > hdcachesize)
63 >                        hdcachesize = BKBSIZE*1024*1.5;
64                  for ( ; i < argc; i++)
65                          addholo(argv[i]);
66 +        }
67          quit(0);
68   userr:
69 <        fprintf(stderr, "Usage: %s output.hdk [-c][-f] -h inp1.hdk ..\n",
69 >        fprintf(stderr, "Usage: %s output.hdk [-u][-d] -h inp1.hdk ..\n",
70                          progname);
71 <        fprintf(stderr, "   Or: %s output.hdk [-c][-f] -pz inp1.pic inp1.zbf ..\n",
71 >        fprintf(stderr, "   Or: %s output.hdk [-u][-d] -p inp1.pic inp1.zbf ..\n",
72                          progname);
73          exit(1);
74   }
# Line 75 | Line 78 | userr:
78   #define H_OBST  02
79   #define H_OBSF  04
80  
81 + int
82   holheadline(s, hf)              /* check holodeck header line */
83   register char   *s;
84   int     *hf;
# Line 86 | Line 90 | int    *hf;
90                          *hf |= H_BADF;
91                  else
92                          *hf &= ~H_BADF;
93 <                return;
93 >                return(0);
94          }
95          if (!strncmp(s, "OBSTRUCTIONS=", 13)) {
96                  s += 13;
# Line 97 | Line 101 | int    *hf;
101                          *hf |= H_OBSF;
102                  else
103                          error(WARNING, "bad OBSTRUCTIONS value in holodeck");
104 <                return;
104 >                return(0);
105          }
106 +        return(0);
107   }
108  
109   int
# Line 170 | Line 175 | COLR   cv;
175                  bi = hdbindex(hp, gc);          /* check for duplicates */
176                  if (checkrepeats && (bp = hdgetbeam(hp, bi)) != NULL) {
177                          for (n = bp->nrm, rv = hdbray(bp); n--; rv++)
178 <                                if (rv->d == dc &&
178 >                                if ((hp->priv != NULL || rv->d == dc) &&
179                                                  rv->r[0][0] == rr[0][0] &&
180                                                  rv->r[0][1] == rr[0][1] &&
181                                                  rv->r[1][0] == rr[1][0] &&
# Line 188 | Line 193 | COLR   cv;
193   }
194  
195  
196 < addholo(hdf)                    /* add a holodeck file */
197 < char    *hdf;
196 > static BEAMI    *beamdir;
197 >
198 > static int
199 > bpcmp(b1p, b2p)                 /* compare beam positions on disk */
200 > int     *b1p, *b2p;
201   {
202 <        HDBEAMI hbl[BLOADSIZE];
203 <        int     fd;
204 <        register HOLO   *hp;
205 <        register BEAM   *bp;
202 >        register long   pdif = beamdir[*b1p].fo - beamdir[*b2p].fo;
203 >
204 >        if (pdif > 0L) return(1);
205 >        if (pdif < 0L) return(-1);
206 >        return(0);
207 > }
208 >
209 > static int
210 > addclump(hp, bq, nb)            /* transfer the given clump and free */
211 > HOLO    *hp;
212 > int     *bq, nb;
213 > {
214          GCOORD  gc[2];
215          FVECT   ro, rd;
216          double  d;
217 <        int     i, j, n, li;
217 >        int     i;
218          register int    k;
219 +        register BEAM   *bp;
220 +                                        /* sort based on file position */
221 +        beamdir = hp->bi;
222 +        qsort((char *)bq, nb, sizeof(*bq), bpcmp);
223 +                                        /* transfer each beam */
224 +        for (i = 0; i < nb; i++) {
225 +                bp = hdgetbeam(hp, bq[i]);
226 +                hdbcoord(gc, hp, bq[i]);
227 +                                                /* add each ray to output */
228 +                for (k = bp->nrm; k--; ) {
229 +                        d = hdray(ro, rd, hp, gc, hdbray(bp)[k].r);
230 +                        if (hp->priv == &unobstr)
231 +                                VSUM(ro, ro, rd, d);
232 +                        else
233 +                                d = 0.;
234 +                        d = hddepth(hp, hdbray(bp)[k].d) - d;
235 +                        addray(ro, rd, d, hdbray(bp)[k].v);
236 +                }
237 +                hdfreebeam(hp, bq[i]);          /* free the beam */
238 +        }
239 +        hdfreebeam(NULL, 0);                    /* write & free clump */
240 +        return(0);
241 + }
242 +
243 + addholo(hdf)                    /* add a holodeck file */
244 + char    *hdf;
245 + {
246 +        int     fd;
247                                          /* open the holodeck for reading */
248          openholo(hdf, 0);
249          fd = hdlist[noutsects]->fd;     /* remember the file handle */
250 <        while ((hp = hdlist[noutsects]) != NULL) {      /* load each section */
251 <                for (j = 0; j < nbeams(hp); j++) {      /* load each beam */
252 <                        if (!(li = j % BLOADSIZE)) {    /* optimize order */
253 <                                if (j+BLOADSIZE > nbeams(hp))
210 <                                        k = n = nbeams(hp) - j;
211 <                                else
212 <                                        k = n = BLOADSIZE;
213 <                                while (k--) {
214 <                                        hbl[k].h = hp;
215 <                                        hbl[k].b = j+k+1;
216 <                                }
217 <                                qsort((char *)hbl, n,
218 <                                                sizeof(HDBEAMI), hdfilord);
219 <                        }
220 <                        if ((bp = hdgetbeam(hp, hbl[li].b)) != NULL) {
221 <                                hdbcoord(gc, hp, hbl[li].b);
222 <                                for (k = bp->nrm; k--; ) {
223 <                                        d = hdray(ro, rd,
224 <                                                hp, gc, hdbray(bp)[k].r);
225 <                                        if (hp->priv == &unobstr)
226 <                                                VSUM(ro, ro, rd, d);
227 <                                        else
228 <                                                d = 0.;
229 <                                        d = hddepth(hp, hdbray(bp)[k].d) - d;
230 <                                        addray(ro, rd, d, hdbray(bp)[k].v);
231 <                                }
232 <                                hdfreebeam(hp, hbl[li].b);      /* free beam */
233 <                        }
234 <                }
235 <                hddone(hp);                             /* free the section */
250 >        while (hdlist[noutsects] != NULL) {     /* load each section */
251 >                                                        /* clump the beams */
252 >                clumpbeams(hdlist[noutsects], 0, BKBSIZE*1024, addclump);
253 >                hddone(hdlist[noutsects]);              /* free the section */
254          }
255 <        close(fd);                      /* close the file */
255 >        close(fd);                      /* close input file */
256 >        hdflush(NULL);                  /* flush output */
257   }
258  
259  
# Line 247 | Line 266 | struct phead {
266   };
267  
268  
269 + int
270   picheadline(s, ph)              /* process picture header line */
271   char    *s;
272   struct phead    *ph;
# Line 255 | Line 275 | struct phead   *ph;
275  
276          if (formatval(fmt, s)) {
277                  ph->badfmt = strcmp(fmt, COLRFMT);
278 <                return;
278 >                return(0);
279          }
280          if (isprims(s)) {
281                  ph->altprims++;         /* don't want to deal with this */
282 <                return;
282 >                return(0);
283          }
284          if (isexpos(s)) {
285                  ph->expos *= exposval(s);
286 <                return;
286 >                return(0);
287          }
288          if (isview(s)) {
289                  ph->gotview += sscanview(&ph->vw, s);
290 <                return;
290 >                return(0);
291          }
292 +        return(0);
293   }
294  
295  
# Line 367 | Line 388 | char   *pcf, *zbf;
388                          addray(ro, rd, (double)zscn[i], cscn[i]);
389                  }
390          }
391 +                                /* write output and free beams */
392 +        hdflush(NULL);
393                                  /* clean up */
394          free((char *)cscn);
395          free((char *)zscn);

Diff Legend

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