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

Comparing ray/src/ot/oconv.c (file contents):
Revision 1.9 by greg, Tue Jun 26 09:02:03 1990 UTC vs.
Revision 2.10 by greg, Fri Jan 6 10:13:04 1995 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1992 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 18 | Line 18 | static char SCCSid[] = "$SunId$ LBL";
18  
19   #include  "otypes.h"
20  
21 < #define  OMARGIN        (10*FTINY)      /* margin around global cube */
21 > #include  "paths.h"
22  
23 < #define  MAXOBJFIL      63              /* maximum number of scene files */
23 > #define  OMARGIN        (10*FTINY)      /* margin around global cube */
24  
25 + #define  MAXOBJFIL      63              /* maximum number of scene files */
26 +
27   char  *progname;                        /* argv[0] */
28  
27 – char  *libpath;                         /* library search path */
28 –
29   int  nowarn = 0;                        /* supress warnings? */
30  
31   int  objlim = 5;                        /* # of objects before split */
# Line 37 | Line 37 | CUBE  thescene = {EMPTY, {0.0, 0.0, 0.0}, 0.0};                /* ou
37   char  *ofname[MAXOBJFIL+1];             /* object file names */
38   int  nfiles = 0;                        /* number of object files */
39  
40 < double  mincusize;                      /* minimum cube size from resolu */
40 > double  mincusize;                      /* minimum cube size from resolu */
41  
42   int  (*addobjnotify[])() = {NULL};      /* new object notifier functions */
43  
44  
45   main(argc, argv)                /* convert object files to an octree */
46   int  argc;
47 < char  **argv;
47 > char  *argv[];
48   {
49 –        char  *getenv();
50 –        double  atof();
49          FVECT  bbmin, bbmax;
50          char  *infile = NULL;
51 +        int  inpfrozen = 0;
52          int  outflags = IO_ALL;
53 <        OBJECT  startobj;
53 >        OBJECT  startobj;
54          int  i;
55  
56 <        progname = argv[0];
56 >        progname = argv[0] = fixargv0(argv[0]);
57  
58 <        if ((libpath = getenv("RAYPATH")) == NULL)
60 <                libpath = ":/usr/local/lib/ray";
58 >        initotypes();
59  
60          for (i = 1; i < argc && argv[i][0] == '-'; i++)
61                  switch (argv[i][1]) {
# Line 90 | Line 88 | char  **argv;
88                          break;
89                  }
90   breakopt:
91 + #ifdef MSDOS
92 +        setmode(fileno(stdout), O_BINARY);
93 + #endif
94          if (infile != NULL) {           /* get old octree & objects */
95                  if (thescene.cusize > FTINY)
96                          error(USER, "only one of '-b' or '-i'");
97                  nfiles = readoct(infile, IO_ALL, &thescene, ofname);
98 <                if (nfiles == 0 && outflags & IO_FILES) {
99 <                        error(WARNING, "frozen octree");
100 <                        outflags &= ~IO_FILES;
101 <                }
102 <        }
103 <
103 <        printargs(argc, argv, stdout);  /* info. header */
98 >                if (nfiles == 0)
99 >                        inpfrozen++;
100 >        } else
101 >                newheader("RADIANCE", stdout);  /* new binary file header */
102 >        printargs(argc, argv, stdout);
103 >        fputformat(OCTFMT, stdout);
104          printf("\n");
105  
106          startobj = nobjects;            /* previous objects already converted */
107 <        
107 >
108          for ( ; i < argc; i++)          /* read new scene descriptions */
109                  if (!strcmp(argv[i], "-")) {    /* from stdin */
110                          readobj(NULL);
# Line 116 | Line 116 | breakopt:
116                  }
117  
118          ofname[nfiles] = NULL;
119 +
120 +        if (inpfrozen && outflags & IO_FILES) {
121 +                error(WARNING, "frozen octree");
122 +                outflags &= ~IO_FILES;
123 +        }
124                                                  /* find bounding box */
125          bbmin[0] = bbmin[1] = bbmin[2] = FHUGE;
126          bbmax[0] = bbmax[1] = bbmax[2] = -FHUGE;
# Line 143 | Line 148 | breakopt:
148          }
149  
150          mincusize = thescene.cusize / resolu - FTINY;
151 <                
151 >
152          for (i = startobj; i < nobjects; i++)           /* add new objects */
153                  addobject(&thescene, i);
154 <        
154 >
155          thescene.cutree = combine(thescene.cutree);     /* optimize */
156  
157          writeoct(outflags, &thescene, ofname);  /* write structures to stdout */
# Line 191 | Line 196 | register char  *s;
196   }
197  
198  
199 + #define  bitop(f,i,op)          (f[((i)>>3)] op (1<<((i)&7)))
200 + #define  tstbit(f,i)            bitop(f,i,&)
201 + #define  setbit(f,i)            bitop(f,i,|=)
202 + #define  clrbit(f,i)            bitop(f,i,&=~)
203 + #define  tglbit(f,i)            bitop(f,i,^=)
204 +
205 +
206   addobject(cu, obj)                      /* add an object to a cube */
207   register CUBE  *cu;
208 < OBJECT  obj;
208 > OBJECT  obj;
209   {
210          CUBE  cukid;
211 <        OCTREE  ot;
212 <        OBJECT  oset[MAXSET+1];
211 >        OCTREE  ot;
212 >        OBJECT  oset[MAXSET+1];
213 >        unsigned char  inflg[(MAXSET+7)/8], volflg[(MAXSET+7)/8];
214          int  in;
215          register int  i, j;
216  
# Line 205 | Line 218 | OBJECT  obj;
218  
219          if (in == O_MISS)
220                  return;                         /* no intersection */
221 <        
221 >
222          if (istree(cu->cutree)) {
223                                                  /* do children */
224                  cukid.cusize = cu->cusize * 0.5;
# Line 219 | Line 232 | OBJECT  obj;
232                          addobject(&cukid, obj);
233                          octkid(cu->cutree, i) = cukid.cutree;
234                  }
235 <                
236 <        } else if (isempty(cu->cutree)) {
235 >                return;
236 >        }
237 >        if (isempty(cu->cutree)) {
238                                                  /* singular set */
239                  oset[0] = 1; oset[1] = obj;
240                  cu->cutree = fullnode(oset);
241 <                
242 <        } else {
243 <                                                /* add to full node */
244 <                objset(oset, cu->cutree);
245 <                cukid.cusize = cu->cusize * 0.5;
232 <                
233 <                if (in==O_IN || oset[0] < objlim || cukid.cusize < mincusize) {
234 <                                                        /* add to set */
235 <                        if (oset[0] >= MAXSET) {
236 <                                sprintf(errmsg,
237 <                                        "set overflow in addobject (%s)",
238 <                                                objptr(obj)->oname);
239 <                                error(INTERNAL, errmsg);
240 <                        }
241 <                        insertelem(oset, obj);
242 <                        cu->cutree = fullnode(oset);
241 >                return;
242 >        }
243 >                                        /* add to full node */
244 >        objset(oset, cu->cutree);
245 >        cukid.cusize = cu->cusize * 0.5;
246  
247 <                } else {
248 <                                                        /* subdivide cube */
249 <                        if ((ot = octalloc()) == EMPTY)
250 <                                error(SYSTEM, "out of octree space");
251 <                        for (i = 0; i < 8; i++) {
252 <                                cukid.cutree = EMPTY;
250 <                                for (j = 0; j < 3; j++) {
251 <                                        cukid.cuorg[j] = cu->cuorg[j];
252 <                                        if ((1<<j) & i)
253 <                                                cukid.cuorg[j] += cukid.cusize;
254 <                                }
255 <                                                        /* surfaces first */
256 <                                for (j = 1; j <= oset[0]; j++)
257 <                                        if (!isvolume(objptr(oset[j])->otype))
258 <                                                addobject(&cukid, oset[j]);
259 <                                                        /* then this object */
260 <                                addobject(&cukid, obj);
261 <                                                        /* volumes last */
262 <                                for (j = 1; j <= oset[0]; j++)
263 <                                        if (isvolume(objptr(oset[j])->otype))
264 <                                                addobject(&cukid, oset[j]);
265 <                                octkid(ot, i) = cukid.cutree;
266 <                        }
267 <                        cu->cutree = ot;
247 >        if (in==O_IN || oset[0] < objlim || cukid.cusize < mincusize) {
248 >                                                /* add to set */
249 >                if (oset[0] >= MAXSET) {
250 >                        sprintf(errmsg, "set overflow in addobject (%s)",
251 >                                        objptr(obj)->oname);
252 >                        error(INTERNAL, errmsg);
253                  }
254 +                insertelem(oset, obj);
255 +                cu->cutree = fullnode(oset);
256 +                return;
257          }
258 +                                        /* subdivide cube */
259 +        if ((ot = octalloc()) == EMPTY)
260 +                error(SYSTEM, "out of octree space");
261 +                                        /* mark volumes */
262 +        j = (oset[0]+7)>>3;
263 +        while (j--)
264 +                volflg[j] = inflg[j] = 0;
265 +        for (j = 1; j <= oset[0]; j++)
266 +                if (isvolume(objptr(oset[j])->otype)) {
267 +                        setbit(volflg,j-1);
268 +                        if ((*ofun[objptr(oset[j])->otype].funp)
269 +                                        (objptr(oset[j]), cu) == O_IN)
270 +                                setbit(inflg,j-1);
271 +                }
272 +                                        /* assign subcubes */
273 +        for (i = 0; i < 8; i++) {
274 +                cukid.cutree = EMPTY;
275 +                for (j = 0; j < 3; j++) {
276 +                        cukid.cuorg[j] = cu->cuorg[j];
277 +                        if ((1<<j) & i)
278 +                                cukid.cuorg[j] += cukid.cusize;
279 +                }
280 +                                        /* surfaces first */
281 +                for (j = 1; j <= oset[0]; j++)
282 +                        if (!tstbit(volflg,j-1))
283 +                                addobject(&cukid, oset[j]);
284 +                                        /* then this object */
285 +                addobject(&cukid, obj);
286 +                                        /* then partial volumes */
287 +                for (j = 1; j <= oset[0]; j++)
288 +                        if (tstbit(volflg,j-1) &&
289 +                                        !tstbit(inflg,j-1))
290 +                                addobject(&cukid, oset[j]);
291 +                                        /* full volumes last */
292 +                for (j = 1; j <= oset[0]; j++)
293 +                        if (tstbit(inflg,j-1))
294 +                                addobject(&cukid, oset[j]);
295 +                                        /* returned node */
296 +                octkid(ot, i) = cukid.cutree;
297 +        }
298 +        cu->cutree = ot;
299   }

Diff Legend

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