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

Comparing ray/src/rt/rview.c (file contents):
Revision 1.7 by greg, Wed Oct 25 15:37:19 1989 UTC vs.
Revision 2.18 by greg, Sat Feb 22 02:07:29 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1987 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  rview.c - routines and variables for interactive view generation.
6   *
7 < *     3/24/87
7 > *  External symbols declared in rpaint.h
8   */
9  
10 < #include  "standard.h"
10 > /* ====================================================================
11 > * The Radiance Software License, Version 1.0
12 > *
13 > * Copyright (c) 1990 - 2002 The Regents of the University of California,
14 > * through Lawrence Berkeley National Laboratory.   All rights reserved.
15 > *
16 > * Redistribution and use in source and binary forms, with or without
17 > * modification, are permitted provided that the following conditions
18 > * are met:
19 > *
20 > * 1. Redistributions of source code must retain the above copyright
21 > *         notice, this list of conditions and the following disclaimer.
22 > *
23 > * 2. Redistributions in binary form must reproduce the above copyright
24 > *       notice, this list of conditions and the following disclaimer in
25 > *       the documentation and/or other materials provided with the
26 > *       distribution.
27 > *
28 > * 3. The end-user documentation included with the redistribution,
29 > *           if any, must include the following acknowledgment:
30 > *             "This product includes Radiance software
31 > *                 (http://radsite.lbl.gov/)
32 > *                 developed by the Lawrence Berkeley National Laboratory
33 > *               (http://www.lbl.gov/)."
34 > *       Alternately, this acknowledgment may appear in the software itself,
35 > *       if and wherever such third-party acknowledgments normally appear.
36 > *
37 > * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
38 > *       and "The Regents of the University of California" must
39 > *       not be used to endorse or promote products derived from this
40 > *       software without prior written permission. For written
41 > *       permission, please contact [email protected].
42 > *
43 > * 5. Products derived from this software may not be called "Radiance",
44 > *       nor may "Radiance" appear in their name, without prior written
45 > *       permission of Lawrence Berkeley National Laboratory.
46 > *
47 > * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
48 > * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49 > * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
50 > * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
51 > * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52 > * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53 > * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
54 > * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55 > * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
56 > * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57 > * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 > * SUCH DAMAGE.
59 > * ====================================================================
60 > *
61 > * This software consists of voluntary contributions made by many
62 > * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
63 > * information on Lawrence Berkeley National Laboratory, please see
64 > * <http://www.lbl.gov/>.
65 > */
66  
67 < #include  "color.h"
67 > #include  "ray.h"
68  
69   #include  "rpaint.h"
70  
# Line 20 | Line 72 | static char SCCSid[] = "$SunId$ LBL";
72  
73   #include  <ctype.h>
74  
75 < VIEW  ourview = STDVIEW(470);           /* viewing parameters */
75 > CUBE  thescene;                         /* our scene */
76 > OBJECT  nsceneobjs;                     /* number of objects in our scene */
77  
78 + int  dimlist[MAXDIM];                   /* sampling dimensions */
79 + int  ndims = 0;                         /* number of sampling dimensions */
80 + int  samplendx = 0;                     /* index for this sample */
81 +
82 + extern void  ambnotify();
83 + void  (*addobjnotify[])() = {ambnotify, NULL};
84 +
85 + VIEW  ourview = STDVIEW;                /* viewing parameters */
86 + int  hresolu, vresolu;                  /* image resolution */
87 +
88 + void  (*trace)() = NULL;                /* trace call */
89 +
90 + int  do_irrad = 0;                      /* compute irradiance? */
91 +
92   int  psample = 8;                       /* pixel sample size */
93 < double  maxdiff = .15;                  /* max. sample difference */
93 > double  maxdiff = .15;                  /* max. sample difference */
94  
95 < double  exposure = 1.0;                 /* exposure for scene */
95 > double  exposure = 1.0;                 /* exposure for scene */
96  
97 < double  dstrsrc = 0.0;                  /* square source distribution */
98 < double  shadthresh = .1;                /* shadow threshold */
99 < double  shadcert = .25;                 /* shadow certainty */
97 > double  dstrsrc = 0.0;                  /* square source distribution */
98 > double  shadthresh = .1;                /* shadow threshold */
99 > double  shadcert = .25;                 /* shadow certainty */
100 > int  directrelay = 0;                   /* number of source relays */
101 > int  vspretest = 128;                   /* virtual source pretest density */
102 > int  directvis = 1;                     /* sources visible? */
103 > double  srcsizerat = 0.;                /* maximum ratio source size/dist. */
104  
105 + COLOR  cextinction = BLKCOLOR;          /* global extinction coefficient */
106 + COLOR  salbedo = BLKCOLOR;              /* global scattering albedo */
107 + double  seccg = 0.;                     /* global scattering eccentricity */
108 + double  ssampdist = 0.;                 /* scatter sampling distance */
109 +
110 + double  specthresh = .3;                /* specular sampling threshold */
111 + double  specjitter = 1.;                /* specular sampling jitter */
112 +
113 + int  backvis = 1;                       /* back face visibility */
114 +
115   int  maxdepth = 4;                      /* maximum recursion depth */
116 < double  minweight = 1e-2;               /* minimum ray weight */
116 > double  minweight = 1e-2;               /* minimum ray weight */
117  
118 + char  *ambfile = NULL;                  /* ambient file name */
119   COLOR  ambval = BLKCOLOR;               /* ambient value */
120 < double  ambacc = 0.2;                   /* ambient accuracy */
120 > int  ambvwt = 0;                        /* initial weight for ambient value */
121 > double  ambacc = 0.2;                   /* ambient accuracy */
122   int  ambres = 8;                        /* ambient resolution */
123   int  ambdiv = 32;                       /* ambient divisions */
124   int  ambssamp = 0;                      /* ambient super-samples */
# Line 44 | Line 127 | char  *amblist[128];                   /* ambient include/exclude list
127   int  ambincl = -1;                      /* include == 1, exclude == 0 */
128  
129   int  greyscale = 0;                     /* map colors to brightness? */
130 < char  *devname = "X";                   /* output device name */
130 > char  *dvcname = dev_default;           /* output device name */
131  
132   struct driver  *dev = NULL;             /* driver functions */
133  
134 + char  rifname[128];                     /* rad input file name */
135 +
136   VIEW  oldview;                          /* previous view parameters */
137  
138   PNODE  ptrunk;                          /* the base of our image */
139   RECT  pframe;                           /* current frame boundaries */
140   int  pdepth;                            /* image depth in current frame */
141  
142 < #define  CTRL(c)        ('c'-'@')
142 > static char  *reserve_mem = NULL;       /* pre-allocated reserve memory */
143  
144 + #define RESERVE_AMT     32768           /* amount of memory to reserve */
145  
146 + #define  CTRL(c)        ((c)-'@')
147 +
148 +
149 + void
150   quit(code)                      /* quit program */
151   int  code;
152   {
153 + #ifdef MSTATS
154 +        if (code == 2 && errno == ENOMEM)
155 +                printmemstats(stderr);
156 + #endif
157          devclose();
158          exit(code);
159   }
160  
161  
162 + void
163   devopen(dname)                          /* open device driver */
164   char  *dname;
165   {
# Line 81 | Line 176 | char  *dname;
176                                  error(USER, errmsg);
177                          } else
178                                  return;
179 + #ifndef NIX                                                
180                                                  /* not there, try exec */
181          if ((dev = comm_init(dname, id)) == NULL) {
182                  sprintf(errmsg, "cannot start device \"%s\"", dname);
183                  error(USER, errmsg);
184          }
185 + #endif
186   }
187  
188  
189 + void
190   devclose()                              /* close our device */
191   {
192          if (dev != NULL)
# Line 97 | Line 195 | devclose()                             /* close our device */
195   }
196  
197  
198 + void
199   printdevices()                          /* print list of output devices */
200   {
201          register int  i;
# Line 106 | Line 205 | printdevices()                         /* print list of output devices */
205   }
206  
207  
208 + void
209   rview()                         /* do a view */
210   {
211          char  buf[32];
212  
213 <        devopen(devname);               /* open device */
214 <        newimage();                     /* set up image */
213 >        devopen(dvcname);               /* open device */
214 >        newimage();                     /* start image (calls fillreserves) */
215  
216          for ( ; ; ) {                   /* quit in command() */
217 <                while (ourview.hresolu <= 1<<pdepth &&
118 <                                ourview.vresolu <= 1<<pdepth)
217 >                while (hresolu <= 1<<pdepth && vresolu <= 1<<pdepth)
218                          command("done: ");
219 <
220 <                if (ourview.hresolu <= psample<<pdepth &&
221 <                                ourview.vresolu <= psample<<pdepth) {
219 >                while (reserve_mem == NULL)
220 >                        command("out of memory: ");
221 >                errno = 0;
222 >                if (hresolu <= psample<<pdepth && vresolu <= psample<<pdepth) {
223                          sprintf(buf, "%d sampling...\n", 1<<pdepth);
224                          (*dev->comout)(buf);
225                          rsample();
226                  } else {
227                          sprintf(buf, "%d refining...\n", 1<<pdepth);
228                          (*dev->comout)(buf);
229 <                        refine(&ptrunk, 0, 0, ourview.hresolu,
130 <                                        ourview.vresolu, pdepth+1);
229 >                        refine(&ptrunk, 0, 0, hresolu, vresolu, pdepth+1);
230                  }
231 <                if (dev->inpready)
231 >                if (errno == ENOMEM)            /* ran out of memory */
232 >                        freereserves();
233 >                else if (dev->inpready)         /* noticed some input */
234                          command(": ");
235 <                else
235 >                else                            /* finished this depth */
236                          pdepth++;
237          }
238   }
239  
240  
241 + void
242 + fillreserves()                  /* fill memory reserves */
243 + {
244 +        if (reserve_mem != NULL)
245 +                return;
246 +        reserve_mem = (char *)malloc(RESERVE_AMT);
247 + }
248 +
249 +
250 + void
251 + freereserves()                  /* free memory reserves */
252 + {
253 +        if (reserve_mem == NULL)
254 +                return;
255 +        free(reserve_mem);
256 +        reserve_mem = NULL;
257 + }
258 +
259 +
260 + void
261   command(prompt)                 /* get/execute command */
262   char  *prompt;
263   {
264 < #define  badcom(s)      strncmp(s, inpbuf, args-inpbuf-1)
144 <        double  atof();
264 > #define  badcom(s)      strncmp(s, inpbuf, args-inpbuf-1)
265          char  inpbuf[256];
266          char  *args;
267   again:
268 <        (*dev->comout)(prompt);                 /* get command + arguments */
149 <        (*dev->comin)(inpbuf);
268 >        (*dev->comin)(inpbuf, prompt);          /* get command + arguments */
269          for (args = inpbuf; *args && *args != ' '; args++)
270                  ;
271          if (*args) *args++ = '\0';
272          else *++args = '\0';
273          
274          switch (inpbuf[0]) {
275 <        case 'f':                               /* new frame */
276 <                if (badcom("frame"))
277 <                        goto commerr;
275 >        case 'f':                               /* new frame (or free mem.) */
276 >                if (badcom("frame")) {
277 >                        if (badcom("free"))
278 >                                goto commerr;
279 >                        free_objmem();
280 >                        break;
281 >                }
282                  getframe(args);
283                  break;
284          case 'v':                               /* view */
# Line 168 | Line 291 | again:
291                          goto commerr;
292                  lastview(args);
293                  break;
294 +        case 'V':                               /* save view */
295 +                if (badcom("V"))
296 +                        goto commerr;
297 +                saveview(args);
298 +                break;
299 +        case 'L':                               /* load view */
300 +                if (badcom("L"))
301 +                        goto commerr;
302 +                loadview(args);
303 +                break;
304          case 'e':                               /* exposure */
305                  if (badcom("exposure"))
306                          goto commerr;
307                  getexposure(args);
308                  break;
309          case 's':                               /* set a parameter */
310 <                if (badcom("set"))
310 >                if (badcom("set")) {
311 > #ifdef  SIGTSTP
312 >                        if (!badcom("stop"))
313 >                                goto dostop;
314 > #endif
315                          goto commerr;
316 +                }
317                  setparam(args);
318                  break;
319          case 'n':                               /* new picture */
# Line 193 | Line 331 | again:
331                          goto commerr;
332                  getaim(args);
333                  break;
334 <        case 'm':                               /* move camera */
334 >        case 'm':                               /* move camera (or memstats) */
335                  if (badcom("move"))
336 + #ifdef  MSTATS
337 +                {
338 +                        if (badcom("memory"))
339 +                                goto commerr;
340 +                        printmemstats(stderr);
341 +                        break;
342 +                }
343 + #else
344                          goto commerr;
345 + #endif
346                  getmove(args);
347                  break;
348 <        case 'r':                               /* rotate camera */
349 <                if (badcom("rotate"))
350 <                        goto commerr;
348 >        case 'r':                               /* rotate/repaint */
349 >                if (badcom("rotate")) {
350 >                        if (badcom("repaint")) {
351 >                                if (badcom("redraw"))
352 >                                        goto commerr;
353 >                                redraw();
354 >                                break;
355 >                        }
356 >                        getrepaint(args);
357 >                        break;
358 >                }
359                  getrotate(args);
360                  break;
361          case 'p':                               /* pivot view */
362 <                if (badcom("pivot"))
363 <                        goto commerr;
362 >                if (badcom("pivot")) {
363 >                        if (badcom("pause"))
364 >                                goto commerr;
365 >                        goto again;
366 >                }
367                  getpivot(args);
368                  break;
369 <        case CTRL(R):                           /* redraw */
369 >        case CTRL('R'):                         /* redraw */
370                  redraw();
371                  break;
372          case 'w':                               /* write */
# Line 220 | Line 378 | again:
378                  if (badcom("quit"))
379                          goto commerr;
380                  quit(0);
381 <        case CTRL(C):                           /* interrupt */
381 >        case CTRL('C'):                         /* interrupt */
382                  goto again;
383 < #ifdef  SIGTSTP
384 <        case CTRL(Z):                           /* stop */
383 > #ifdef  SIGTSTP
384 >        case CTRL('Z'):;                        /* stop */
385 > dostop:
386                  devclose();
387                  kill(0, SIGTSTP);
388                  /* pc stops here */
389 <                devopen(devname);
389 >                devopen(dvcname);
390                  redraw();
391                  break;
392   #endif
# Line 243 | Line 402 | commerr:
402                  error(COMMAND, errmsg);
403                  break;
404          }
405 < #undef  badcom
405 > #undef  badcom
406   }
407  
408  
409 + void
410   rsample()                       /* sample the image */
411   {
412          int  xsiz, ysiz, y;
413          RECT  r;
414          PNODE  *p;
415          register RECT  *rl;
416 <        register PNODE  **pl;
416 >        register PNODE  **pl;
417          register int  x;
418          /*
419           *     We initialize the bottom row in the image at our current
420 <         * resolution.  During sampling, we check super-pixels to the
420 >         * resolution.  During sampling, we check super-pixels to the
421           * right and above by calling bigdiff().  If there is a significant
422           * difference, we subsample the super-pixels.  The testing process
423           * includes initialization of the next row.
424           */
425 <        xsiz = (((pframe.r-pframe.l)<<pdepth)+ourview.hresolu-1) /
426 <                        ourview.hresolu;
267 <        ysiz = (((pframe.u-pframe.d)<<pdepth)+ourview.vresolu-1) /
268 <                        ourview.vresolu;
425 >        xsiz = (((long)(pframe.r-pframe.l)<<pdepth)+hresolu-1) / hresolu;
426 >        ysiz = (((long)(pframe.u-pframe.d)<<pdepth)+vresolu-1) / vresolu;
427          rl = (RECT *)malloc(xsiz*sizeof(RECT));
428 +        if (rl == NULL)
429 +                return;
430          pl = (PNODE **)malloc(xsiz*sizeof(PNODE *));
431 <        if (rl == NULL || pl == NULL)
432 <                error(SYSTEM, "out of memory in rsample");
431 >        if (pl == NULL) {
432 >                free((void *)rl);
433 >                return;
434 >        }
435          /*
436           * Initialize the bottom row.
437           */
438          rl[0].l = rl[0].d = 0;
439 <        rl[0].r = ourview.hresolu; rl[0].u = ourview.vresolu;
439 >        rl[0].r = hresolu; rl[0].u = vresolu;
440          pl[0] = findrect(pframe.l, pframe.d, &ptrunk, rl, pdepth);
441          for (x = 1; x < xsiz; x++) {
442                  rl[x].l = rl[x].d = 0;
443 <                rl[x].r = ourview.hresolu; rl[x].u = ourview.vresolu;
444 <                pl[x] = findrect(pframe.l+((x*ourview.hresolu)>>pdepth),
443 >                rl[x].r = hresolu; rl[x].u = vresolu;
444 >                pl[x] = findrect(pframe.l+((x*hresolu)>>pdepth),
445                                  pframe.d, &ptrunk, rl+x, pdepth);
446          }
447                                                  /* sample the image */
448          for (y = 0; /* y < ysiz */ ; y++) {
449                  for (x = 0; x < xsiz-1; x++) {
450 <                        if (dev->inpready)
450 >                        if (dev->inpready || errno == ENOMEM)
451                                  goto escape;
452                          /*
453                           * Test super-pixel to the right.
# Line 301 | Line 463 | rsample()                      /* sample the image */
463                  if (y >= ysiz-1)
464                          break;
465                  for (x = 0; x < xsiz; x++) {
466 <                        if (dev->inpready)
466 >                        if (dev->inpready || errno == ENOMEM)
467                                  goto escape;
468                          /*
469                           * Find super-pixel at this position in next row.
470                           */
471                          r.l = r.d = 0;
472 <                        r.r = ourview.hresolu; r.u = ourview.vresolu;
473 <                        p = findrect(pframe.l+((x*ourview.hresolu)>>pdepth),
474 <                                pframe.d+(((y+1)*ourview.vresolu)>>pdepth),
472 >                        r.r = hresolu; r.u = vresolu;
473 >                        p = findrect(pframe.l+((x*hresolu)>>pdepth),
474 >                                pframe.d+(((y+1)*vresolu)>>pdepth),
475                                          &ptrunk, &r, pdepth);
476                          /*
477                           * Test super-pixel in next row.
# Line 328 | Line 490 | rsample()                      /* sample the image */
490                  }
491          }
492   escape:
493 <        free((char *)rl);
494 <        free((char *)pl);
493 >        free((void *)rl);
494 >        free((void *)pl);
495   }
496  
497  
498   int
499   refine(p, xmin, ymin, xmax, ymax, pd)           /* refine a node */
500 < register PNODE  *p;
500 > register PNODE  *p;
501   int  xmin, ymin, xmax, ymax;
502   int  pd;
503   {
# Line 356 | Line 518 | int  pd;
518          if (p->kid == NULL) {                   /* subdivide */
519  
520                  if ((p->kid = newptree()) == NULL)
521 <                        error(SYSTEM, "out of memory in refine");
521 >                        return(0);
522                  /*
523                   *  The following paint order can leave a black pixel
524 <                 *  when redraw() is called in (*dev->paintr)().
524 >                 *  if redraw() is called in (*dev->paintr)().
525                   */
526                  if (p->x >= mx && p->y >= my)
527                          pcopy(p, p->kid+UR);

Diff Legend

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