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

Comparing ray/src/hd/rhpict.c (file contents):
Revision 3.1 by gwlarson, Thu Mar 4 10:30:04 1999 UTC vs.
Revision 3.8 by greg, Sat Feb 22 02:07:25 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1999 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Radiance holodeck picture generator
6   */
7  
8   #include "rholo.h"
9   #include "view.h"
13 – #include "resolu.h"
10  
11   char    *progname;              /* our program name */
12   char    *hdkfile;               /* holodeck file name */
13 + char    gargc;                  /* global argc */
14 + char    **gargv;                /* global argv */
15  
16   VIEW    myview = STDVIEW;       /* current output view */
17   int     xres = 512, yres = 512; /* max. horizontal and vertical resolution */
18   char    *outspec = NULL;        /* output file specification */
19 + double  randfrac = -1.;         /* random resampling fraction */
20   double  pixaspect = 1.;         /* pixel aspect ratio */
21   int     seqstart = 0;           /* sequence start frame */
22   double  expval = 1.;            /* exposure value */
23  
24   COLOR   *mypixel;               /* pixels being rendered */
25   float   *myweight;              /* weights (used to compute final pixels) */
26 + float   *mydepth;               /* depth values (visibility culling) */
27   int     hres, vres;             /* current horizontal and vertical res. */
28  
29   extern int      nowarn;         /* turn warnings off? */
# Line 35 | Line 35 | char   *argv[];
35   {
36          int     i, rval;
37  
38 +        gargc = argc; gargv = argv;
39          progname = argv[0];                     /* get arguments */
40          for (i = 1; i < argc && argv[i][0] == '-'; i++) {
41                  rval = getviewopt(&myview, argc-i, argv+i);
# Line 49 | Line 50 | char   *argv[];
50                  case 'p':                       /* pixel aspect/exposure */
51                          if (badarg(argc-i-1,argv+i+1,"f"))
52                                  goto userr;
53 <                        if (argv[i][1] == 'a')
53 >                        if (argv[i][2] == 'a')
54                                  pixaspect = atof(argv[++i]);
55 <                        else if (argv[i][1] == 'e') {
55 >                        else if (argv[i][2] == 'e') {
56                                  expval = atof(argv[++i]);
57                                  if (argv[i][0] == '-' | argv[i][0] == '+')
58                                          expval = pow(2., expval);
# Line 73 | Line 74 | char   *argv[];
74                                  goto userr;
75                          outspec = argv[++i];
76                          break;
77 +                case 'r':                       /* random sampling */
78 +                        if (badarg(argc-i-1,argv+i+1,"f"))
79 +                                goto userr;
80 +                        randfrac = atof(argv[++i]);
81 +                        break;
82 +                case 's':                       /* smooth sampling */
83 +                        randfrac = -1.;
84 +                        break;
85                  case 'S':                       /* sequence start */
86                          if (badarg(argc-i-1,argv+i+1,"i"))
87                                  goto userr;
88                          seqstart = atoi(argv[++i]);
89                          break;
90                  case 'v':                       /* view file */
91 <                        if (argv[i][1]!='f' || badarg(argc-i-1,argv+i+1,"s"))
91 >                        if (argv[i][2]!='f' || badarg(argc-i-1,argv+i+1,"s"))
92                                  goto userr;
93                          rval = viewfile(argv[++i], &myview, NULL);
94                          if (rval < 0) {
# Line 97 | Line 106 | char   *argv[];
106                  }
107          }
108                                                  /* open holodeck file */
109 <        if (i >= argc)
109 >        if (i != argc-1)
110                  goto userr;
111 <        hdkfile = argv[i++];
111 >        hdkfile = argv[i];
112          initialize();
113                                                  /* render picture(s) */
114          if (seqstart <= 0)
# Line 110 | Line 119 | char   *argv[];
119          quit(0);                                /* all done! */
120   userr:
121          fprintf(stderr,
122 < "Usage: %s [-w][-pa pa][-pe ex][-x hr][-y vr][-S stfn][-o outp][view] input.hdk\n",
122 > "Usage: %s [-w][-r rf][-pa pa][-pe ex][-x hr][-y vr][-S stfn][-o outp][view] input.hdk\n",
123                          progname);
124          quit(1);
125   }
# Line 134 | Line 143 | int    fn;
143                                          /* render image */
144          if (blist.nb > 0) {
145                  render_frame(blist.bl, blist.nb);
146 <                free((char *)blist.bl);
146 >                free((void *)blist.bl);
147          } else {
148                  sprintf(errmsg, "no section visible in frame %d", fn);
149                  error(WARNING, errmsg);
# Line 144 | Line 153 | int    fn;
153                  sprintf(errmsg, "error writing frame %d", fn);
154                  error(SYSTEM, errmsg);
155          }
156 + #ifdef DEBUG
157          if (blist.nb > 0 & rval > 0) {
158 <                sprintf(errmsg, "%.1f%% unrendered pixels in frame %d",
159 <                                100.*rval/(hres*vres), fn);
158 >                sprintf(errmsg, "%d unrendered pixels in frame %d (%.1f%%)",
159 >                                rval, fn, 100.*rval/(hres*vres));
160                  error(WARNING, errmsg);
161          }
162 + #endif
163   }
164  
165  
# Line 156 | Line 167 | render_frame(bl, nb)           /* render frame from beam values
167   register PACKHEAD       *bl;
168   int     nb;
169   {
170 <        extern int      render_beam();
170 >        extern int      pixBeam();
171          register HDBEAMI        *bil;
172          register int    i;
173  
# Line 167 | Line 178 | int    nb;
178                  bil[i].h = hdlist[bl[i].hd];
179                  bil[i].b = bl[i].bi;
180          }
181 <        hdloadbeams(bil, nb, render_beam);
182 <        free((char *)bil);
181 >        hdloadbeams(bil, nb, pixBeam);
182 >        pixFinish(randfrac);
183 >        free((void *)bil);
184   }
185  
186  
# Line 192 | Line 204 | int    fn;
204                                  /* write header */
205          newheader("RADIANCE", stdout);
206          printf("SOFTWARE= %s\n", VersionID);
207 <        printf("%s %s\n", progname, hdkfile);
207 >        printargs(gargc, gargv, stdout);
208          if (fn)
209                  printf("FRAME=%d\n", fn);
210          fputs(VIEWSTR, stdout);
# Line 209 | Line 221 | int    fn;
221                                  /* prepare image buffers */
222          bzero((char *)mypixel, hres*vres*sizeof(COLOR));
223          bzero((char *)myweight, hres*vres*sizeof(float));
224 +        bzero((char *)mydepth, hres*vres*sizeof(float));
225   }
226  
227  
228   int
229   endpicture()                    /* finish and write out pixels */
230   {
231 <        int     nunrend = 0;
232 <        int     v;
231 >        int     lastr = -1, nunrend = 0;
232 >        int4    lastp, lastrp;
233 >        register int4   p;
234          register double d;
221 –        register int    p;
235                                  /* compute final pixel values */
236          for (p = hres*vres; p--; ) {
237                  if (myweight[p] <= FTINY) {
238 +                        if (lastr >= 0)
239 +                                if (p/hres == lastp/hres)
240 +                                        copycolor(mypixel[p], mypixel[lastp]);
241 +                                else
242 +                                        copycolor(mypixel[p], mypixel[lastrp]);
243                          nunrend++;
244                          continue;
245                  }
246                  d = expval/myweight[p];
247                  scalecolor(mypixel[p], d);
248 +                if ((lastp=p)/hres != lastr)
249 +                        lastr = (lastrp=p)/hres;
250          }
251                                  /* write each scanline */
252 <        for (v = vres; v--; )
253 <                if (fwritescan(mypixel+v*hres, hres, stdout) < 0)
252 >        for (p = vres; p--; )
253 >                if (fwritescan(mypixel+p*hres, hres, stdout) < 0)
254                          return(-1);
255          if (fflush(stdout) == EOF)
256                  return(-1);
# Line 262 | Line 282 | initialize()                   /* initialize holodeck and buffers */
282          fd = dup(fileno(fp));                   /* dup file descriptor */
283          fclose(fp);                             /* done with stdio */
284          for (n = 0; nextloc > 0L; n++) {        /* initialize each section */
285 <                lseek(fd, (long)nextloc, 0);
285 >                lseek(fd, (off_t)nextloc, 0);
286                  read(fd, (char *)&nextloc, sizeof(nextloc));
287                  hdinit(fd, NULL);
288          }
289                                          /* allocate picture buffer */
290          mypixel = (COLOR *)bmalloc(xres*yres*sizeof(COLOR));
291          myweight = (float *)bmalloc(xres*yres*sizeof(float));
292 <        if (mypixel == NULL | myweight == NULL)
292 >        mydepth = (float *)bmalloc(xres*yres*sizeof(float));
293 >        if (mypixel == NULL | myweight == NULL | mydepth == NULL)
294                  error(SYSTEM, "out of memory in initialize");
295   }
296  
297  
298 + void
299   eputs(s)                        /* put error message to stderr */
300   register char  *s;
301   {

Diff Legend

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