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.6 by gregl, Wed Jan 7 10:49:12 1998 UTC vs.
Revision 3.30 by greg, Thu Aug 2 18:33:42 2018 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1997 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Copy data into a holodeck file
6   */
7  
8 + #include "platform.h"
9 + #include "rterror.h"
10   #include "holo.h"
11   #include "view.h"
13 – #include "resolu.h"
12  
13 < int     checkdepth = 1;         /* check depth (!-f option)? */
14 < int     checkrepeats = 0;       /* check for repeats (-c option)? */
13 > #ifndef BKBSIZE
14 > #define BKBSIZE         256             /* beam clump size (kilobytes) */
15 > #endif
16 >
17 > int     checkdepth = 1;         /* check depth (!-d option)? */
18 > int     checkrepeats = 0;       /* check for repeats (-u option)? */
19   int     frompicz;               /* input from pictures & depth-buffers? */
20   int     noutsects;              /* number of output sections */
21   char    obstr, unobstr;         /* flag pointer values */
22  
23   char    *progname;              /* global argv[0] */
24  
25 + struct phead {
26 +        VIEW    vw;
27 +        double  expos;
28 +        short   gotview;
29 +        short   badfmt;
30 +        short   altprims;
31 + };
32 + static int openholo(char *fname, int append);
33 + static void addray(FVECT ro, FVECT rd, double d, COLR cv);
34 + static gethfunc holheadline;
35 + static int bpcmp(const void *b1p, const void *b2p);
36 + static int addclump(HOLO *hp, int *bq, int nb);
37 + static void addholo(char *hdf);
38 + static gethfunc picheadline;
39 + static void addpicz(char *pcf, char *zbf);
40  
41 < main(argc, argv)
42 < int     argc;
43 < char    *argv[];
41 >
42 >
43 > int
44 > main(
45 >        int     argc,
46 >        char    *argv[]
47 > )
48   {
49          int     i;
50  
# Line 31 | Line 52 | char   *argv[];
52          frompicz = -1;
53          for (i = 2; i < argc && argv[i][0] == '-'; i++)
54                  switch (argv[i][1]) {
55 <                case 'c':
55 >                case 'u':
56                          checkrepeats = 1;
57                          break;
58 <                case 'f':
58 >                case 'd':
59                          checkdepth = 0;
60                          break;
61                  case 'h':
# Line 51 | Line 72 | char   *argv[];
72          if (frompicz && (argc-i)%2)
73                  goto userr;
74          noutsects = openholo(argv[1], 1);
75 <        if (frompicz)
75 >        if (frompicz) {
76                  for ( ; i < argc; i += 2)
77                          addpicz(argv[i], argv[i+1]);
78 <        else
78 >        } else {
79 >                if (BKBSIZE*1024*1.5 > hdcachesize)
80 >                        hdcachesize = BKBSIZE*1024*1.5;
81                  for ( ; i < argc; i++)
82                          addholo(argv[i]);
83 +        }
84          quit(0);
85   userr:
86 <        fprintf(stderr, "Usage: %s output.hdk [-c][-f] -h inp1.hdk ..\n",
86 >        fprintf(stderr, "Usage: %s output.hdk [-u][-d] -h inp1.hdk ..\n",
87                          progname);
88 <        fprintf(stderr, "   Or: %s output.hdk [-c][-f] -pz inp1.pic inp1.zbf ..\n",
88 >        fprintf(stderr, "   Or: %s output.hdk [-u][-d] -p inp1.hdr inp1.zbf ..\n",
89                          progname);
90          exit(1);
91   }
# Line 71 | Line 95 | userr:
95   #define H_OBST  02
96   #define H_OBSF  04
97  
98 < holheadline(s, hf)              /* check holodeck header line */
99 < register char   *s;
100 < int     *hf;
98 > static int
99 > holheadline(            /* check holodeck header line */
100 >        register char   *s,
101 >        void    *vhf
102 > )
103   {
104 <        char    fmt[32];
104 >        char    fmt[MAXFMTLEN];
105 >        int     *hf = vhf;
106  
107          if (formatval(fmt, s)) {
108                  if (strcmp(fmt, HOLOFMT))
109                          *hf |= H_BADF;
110                  else
111                          *hf &= ~H_BADF;
112 <                return;
112 >                return(0);
113          }
114          if (!strncmp(s, "OBSTRUCTIONS=", 13)) {
115                  s += 13;
116                  while (*s == ' ') s++;
117 <                if (*s == 't' | *s == 'T')
117 >                if ((*s == 't') | (*s == 'T'))
118                          *hf |= H_OBST;
119 <                else if (*s == 'f' | *s == 'F')
119 >                else if ((*s == 'f') | (*s == 'F'))
120                          *hf |= H_OBSF;
121                  else
122                          error(WARNING, "bad OBSTRUCTIONS value in holodeck");
123 <                return;
123 >                return(0);
124          }
125 +        return(0);
126   }
127  
128   int
129 < openholo(fname, append)         /* open existing holodeck file for i/o */
130 < char    *fname;
131 < int     append;
129 > openholo(               /* open existing holodeck file for i/o */
130 >        char    *fname,
131 >        int     append
132 > )
133   {
105 –        extern long     ftell();
134          FILE    *fp;
135          int     fd;
136          int     hflags = 0;
137 <        long    nextloc;
137 >        off_t   nextloc;
138          int     n;
139                                          /* open holodeck file */
140          if ((fp = fopen(fname, append ? "r+" : "r")) == NULL) {
# Line 124 | Line 152 | int    append;
152          nextloc = ftell(fp);                    /* get stdio position */
153          fclose(fp);                             /* done with stdio */
154          for (n = 0; nextloc > 0L; n++) {        /* initialize each section */
155 <                lseek(fd, nextloc, 0);
155 >                lseek(fd, nextloc, SEEK_SET);
156                  read(fd, (char *)&nextloc, sizeof(nextloc));
157                  hdinit(fd, NULL)->priv = hflags&H_OBST ? &obstr :
158                                  hflags&H_OBSF ? &unobstr : (char *)NULL;
# Line 137 | Line 165 | int    append;
165   #undef H_OBSF
166  
167  
168 < addray(ro, rd, d, cv)           /* add a ray to our output holodeck */
169 < FVECT   ro, rd;
170 < double  d;
171 < COLR    cv;
168 > void
169 > addray(         /* add a ray to our output holodeck */
170 >        FVECT   ro,
171 >        FVECT   rd,
172 >        double  d,
173 >        COLR    cv
174 > )
175   {
176          int     sn, bi, n;
177          register HOLO   *hp;
178          GCOORD  gc[2];
179 <        BYTE    rr[2][2];
179 >        uby8    rr[2][2];
180          BEAM    *bp;
181          double  d0, d1;
182          unsigned        dc;
# Line 166 | Line 197 | COLR   cv;
197                  bi = hdbindex(hp, gc);          /* check for duplicates */
198                  if (checkrepeats && (bp = hdgetbeam(hp, bi)) != NULL) {
199                          for (n = bp->nrm, rv = hdbray(bp); n--; rv++)
200 <                                if (rv->d == dc &&
200 >                                if ((hp->priv != NULL || rv->d == dc) &&
201                                                  rv->r[0][0] == rr[0][0] &&
202                                                  rv->r[0][1] == rr[0][1] &&
203                                                  rv->r[1][0] == rr[1][0] &&
# Line 184 | Line 215 | COLR   cv;
215   }
216  
217  
218 < addholo(hdf)                    /* add a holodeck file */
219 < char    *hdf;
218 > static BEAMI    *beamdir;
219 >
220 > static int
221 > bpcmp(                  /* compare beam positions on disk */
222 >        const void      *b1p,
223 >        const void      *b2p
224 > )
225   {
226 <        int     fd;
227 <        register HOLO   *hp;
228 <        register BEAM   *bp;
229 <        register HDBEAMI        *hbl;
226 >        register off_t  pdif = beamdir[*(int*)b1p].fo - beamdir[*(int*)b2p].fo;
227 >
228 >        if (pdif > 0L) return(1);
229 >        if (pdif < 0L) return(-1);
230 >        return(0);
231 > }
232 >
233 > static int
234 > addclump(               /* transfer the given clump and free */
235 >        HOLO    *hp,
236 >        int     *bq,
237 >        int     nb
238 > )
239 > {
240          GCOORD  gc[2];
241          FVECT   ro, rd;
242          double  d;
243 <        int     i, j;
243 >        int     i;
244          register int    k;
245 +        register BEAM   *bp;
246 +                                        /* sort based on file position */
247 +        beamdir = hp->bi;
248 +        qsort((char *)bq, nb, sizeof(*bq), bpcmp);
249 +                                        /* transfer each beam */
250 +        for (i = 0; i < nb; i++) {
251 +                bp = hdgetbeam(hp, bq[i]);
252 +                hdbcoord(gc, hp, bq[i]);
253 +                                                /* add each ray to output */
254 +                for (k = bp->nrm; k--; ) {
255 +                        d = hdray(ro, rd, hp, gc, hdbray(bp)[k].r);
256 +                        if (hp->priv == &unobstr)
257 +                                VSUM(ro, ro, rd, d);
258 +                        else
259 +                                d = 0.;
260 +                        d = hddepth(hp, hdbray(bp)[k].d) - d;
261 +                        addray(ro, rd, d, hdbray(bp)[k].v);
262 +                }
263 +                hdfreebeam(hp, bq[i]);          /* free the beam */
264 +        }
265 +        return(0);
266 + }
267 +
268 +
269 + void
270 + addholo(                        /* add a holodeck file */
271 +        char    *hdf
272 + )
273 + {
274 +        int     fd;
275                                          /* open the holodeck for reading */
276          openholo(hdf, 0);
277          fd = hdlist[noutsects]->fd;     /* remember the file handle */
278 <        while ((hp = hdlist[noutsects]) != NULL) {      /* load each section */
279 <                hbl = (HDBEAMI *)malloc(nbeams(hp)*sizeof(HDBEAMI));
280 <                if (hbl == NULL)
281 <                        error(SYSTEM, "out of memory in addholo");
206 <                for (j = nbeams(hp); j--; ) {   /* sort the beams */
207 <                        hbl[j].h = hp;
208 <                        hbl[j].b = j+1;
209 <                }
210 <                qsort((char *)hbl, nbeams(hp), sizeof(HDBEAMI), hdfilord);
211 <                for (j = 0; j < nbeams(hp); j++)        /* load each beam */
212 <                        if ((bp = hdgetbeam(hp, hbl[j].b)) != NULL) {
213 <                                hdbcoord(gc, hp, hbl[j].b);
214 <                                for (k = bp->nrm; k--; ) {
215 <                                        d = hdray(ro, rd,
216 <                                                hp, gc, hdbray(bp)[k].r);
217 <                                        if (hp->priv == &unobstr)
218 <                                                VSUM(ro, ro, rd, d);
219 <                                        else
220 <                                                d = 0.;
221 <                                        d = hddepth(hp, hdbray(bp)[k].d) - d;
222 <                                        addray(ro, rd, d, hdbray(bp)[k].v);
223 <                                }
224 <                                hdfreebeam(hp, hbl[j].b);       /* free beam */
225 <                        }
226 <                free((char *)hbl);                      /* free beam list */
227 <                hddone(hp);                             /* free the section */
278 >        while (hdlist[noutsects] != NULL) {     /* load each section */
279 >                                                        /* clump the beams */
280 >                clumpbeams(hdlist[noutsects], 0, BKBSIZE*1024, addclump);
281 >                hddone(hdlist[noutsects]);              /* free the section */
282          }
283 <        close(fd);                      /* close the file */
283 >        close(fd);                      /* close input file */
284 >        hdflush(NULL);                  /* flush output */
285   }
286  
287  
233 – struct phead {
234 –        VIEW    vw;
235 –        double  expos;
236 –        short   gotview;
237 –        short   badfmt;
238 –        short   altprims;
239 – };
288  
289 <
290 < picheadline(s, ph)              /* process picture header line */
291 < char    *s;
292 < struct phead    *ph;
289 > static int
290 > picheadline(            /* process picture header line */
291 >        char    *s,
292 >        void    *vph
293 > )
294   {
295          char    fmt[32];
296 +        struct phead *ph = vph;
297  
298          if (formatval(fmt, s)) {
299                  ph->badfmt = strcmp(fmt, COLRFMT);
300 <                return;
300 >                return(0);
301          }
302          if (isprims(s)) {
303                  ph->altprims++;         /* don't want to deal with this */
304 <                return;
304 >                return(0);
305          }
306          if (isexpos(s)) {
307                  ph->expos *= exposval(s);
308 <                return;
308 >                return(0);
309          }
310          if (isview(s)) {
311                  ph->gotview += sscanview(&ph->vw, s);
312 <                return;
312 >                return(0);
313          }
314 +        return(0);
315   }
316  
317  
318 < addpicz(pcf, zbf)               /* add a picture + depth-buffer */
319 < char    *pcf, *zbf;
318 > void
319 > addpicz(                /* add a picture + depth-buffer */
320 >        char    *pcf,
321 >        char    *zbf
322 > )
323   {
324          FILE    *pfp;
325          int     zfd;
# Line 275 | Line 329 | char   *pcf, *zbf;
329          int     eshft;
330          double  emult;
331          RESOLU  prs;
332 <        FLOAT   vl[2];
332 >        RREAL   vl[2];
333          FVECT   ro, rd;
334          double  aftd;
335          COLOR   ctmp;
# Line 291 | Line 345 | char   *pcf, *zbf;
345                  error(SYSTEM, pcf);
346          }
347                                  /* load picture header */
348 <        copystruct(&phd.vw, &stdview);
348 >        phd.vw = stdview;
349          phd.expos = 1.0;
350          phd.badfmt = phd.gotview = phd.altprims = 0;
351          if (getheader(pfp, picheadline, &phd) < 0 ||
# Line 305 | Line 359 | char   *pcf, *zbf;
359                  error(USER, errmsg);
360          }
361          if (phd.altprims) {
362 <                sprintf(errmsg, "ignoring primary values in picture \"%s\"",
362 >                sprintf(errmsg, "ignoring color primaries in picture \"%s\"",
363                                  pcf);
364                  error(WARNING, errmsg);
365          }
366                                  /* figure out what to do about exposure */
367 <        if (phd.expos < 0.99 | phd.expos > 1.01) {
367 >        if ((phd.expos < 0.99) | (phd.expos > 1.01)) {
368                  emult = -log(phd.expos)/log(2.);
369                  eshft = emult >= 0. ? emult+.5 : emult-.5;
370                  emult -= (double)eshft;
371 <                if (emult <= 0.01 & emult >= -0.01)
371 >                if ((emult <= 0.01) & (emult >= -0.01))
372                          emult = -1.;
373                  else {
374                          emult = 1./phd.expos;
# Line 327 | Line 381 | char   *pcf, *zbf;
381                                  /* allocate buffers */
382          cscn = (COLR *)malloc(scanlen(&prs)*sizeof(COLR));
383          zscn = (float *)malloc(scanlen(&prs)*sizeof(float));
384 <        if (cscn == NULL | zscn == NULL)
384 >        if ((cscn == NULL) | (zscn == NULL))
385                  error(SYSTEM, "out of memory in addpicz");
386                                  /* read and process each scanline */
387          for (j = 0; j < numscans(&prs); j++) {
# Line 344 | Line 398 | char   *pcf, *zbf;
398                          error(USER, errmsg);
399                  }
400                  for (i = scanlen(&prs); i--; ) {        /* do each pixel */
401 +                        if (zscn[i] <= 0.0)
402 +                                continue;               /* illegal depth */
403                          pix2loc(vl, &prs, i, j);
404                          aftd = viewray(ro, rd, &phd.vw, vl[0], vl[1]);
405                          if (aftd < -FTINY)
# Line 359 | Line 415 | char   *pcf, *zbf;
415                          addray(ro, rd, (double)zscn[i], cscn[i]);
416                  }
417          }
418 +                                /* write output and free beams */
419 +        hdflush(NULL);
420                                  /* clean up */
421 <        free((char *)cscn);
422 <        free((char *)zscn);
421 >        free((void *)cscn);
422 >        free((void *)zscn);
423          fclose(pfp);
424          close(zfd);
425   }
426  
427  
428 < eputs(s)                        /* put error message to stderr */
429 < register char  *s;
428 > void
429 > eputs(                  /* put error message to stderr */
430 >        register char  *s
431 > )
432   {
433          static int  midline = 0;
434  
# Line 386 | Line 446 | register char  *s;
446   }
447  
448  
449 < quit(code)                      /* exit the program gracefully */
450 < int     code;
449 > void
450 > quit(                   /* exit the program gracefully */
451 >        int     code
452 > )
453   {
454          hdsync(NULL, 1);        /* write out any buffered data */
455          exit(code);

Diff Legend

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