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.1 by greg, Thu Feb 2 10:33:04 1989 UTC vs.
Revision 2.9 by greg, Thu Apr 14 05:02:06 1994 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  MAXOBJFIL      63              /* maximum number of scene files */
21 > #include  "paths.h"
22  
23 < char  *progname;                        /* argv[0] */
23 > #define  OMARGIN        (10*FTINY)      /* margin around global cube */
24  
25 < char  *libpath;                         /* library search path */
25 > #define  MAXOBJFIL      63              /* maximum number of scene files */
26  
27 + char  *progname;                        /* argv[0] */
28 +
29   int  nowarn = 0;                        /* supress warnings? */
30  
31   int  objlim = 5;                        /* # of objects before split */
# Line 35 | 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;
48   {
49 <        char  *getenv();
46 <        double  atof();
49 >        extern char  *getenv();
50          FVECT  bbmin, bbmax;
51          char  *infile = NULL;
52 +        int  inpfrozen = 0;
53          int  outflags = IO_ALL;
54 <        OBJECT  startobj;
54 >        OBJECT  startobj;
55          int  i;
56  
57 <        progname = argv[0];
57 >        progname = argv[0] = fixargv0(argv[0]);
58  
59 <        if ((libpath = getenv("RAYPATH")) == NULL)
56 <                libpath = ":/usr/local/lib/ray";
59 >        initotypes();
60  
61          for (i = 1; i < argc && argv[i][0] == '-'; i++)
62                  switch (argv[i][1]) {
63 +                case '\0':                              /* scene from stdin */
64 +                        outflags &= ~IO_FILES;
65 +                        goto breakopt;
66                  case 'i':                               /* input octree */
67                          infile = argv[++i];
68                          break;
69                  case 'b':                               /* bounding cube */
70 <                        thescene.cuorg[0] = atof(argv[++i]) - FTINY;
71 <                        thescene.cuorg[1] = atof(argv[++i]) - FTINY;
72 <                        thescene.cuorg[2] = atof(argv[++i]) - FTINY;
73 <                        thescene.cusize = atof(argv[++i]) + 2*FTINY;
70 >                        thescene.cuorg[0] = atof(argv[++i]) - OMARGIN;
71 >                        thescene.cuorg[1] = atof(argv[++i]) - OMARGIN;
72 >                        thescene.cuorg[2] = atof(argv[++i]) - OMARGIN;
73 >                        thescene.cusize = atof(argv[++i]) + 2*OMARGIN;
74                          break;
75                  case 'n':                               /* set limit */
76                          objlim = atoi(argv[++i]);
# Line 83 | Line 89 | char  **argv;
89                          error(USER, errmsg);
90                          break;
91                  }
92 <        
92 > breakopt:
93 > #ifdef MSDOS
94 >        setmode(fileno(stdout), O_BINARY);
95 > #endif
96          if (infile != NULL) {           /* get old octree & objects */
97                  if (thescene.cusize > FTINY)
98                          error(USER, "only one of '-b' or '-i'");
99                  nfiles = readoct(infile, IO_ALL, &thescene, ofname);
100 <                if (nfiles == 0 && outflags & IO_FILES) {
101 <                        error(WARNING, "frozen octree");
100 >                if (nfiles == 0)
101 >                        inpfrozen++;
102 >        } else
103 >                newheader("RADIANCE", stdout);  /* new binary file header */
104 >        printargs(argc, argv, stdout);
105 >        fputformat(OCTFMT, stdout);
106 >        printf("\n");
107 >
108 >        startobj = nobjects;            /* previous objects already converted */
109 >
110 >        for ( ; i < argc; i++)          /* read new scene descriptions */
111 >                if (!strcmp(argv[i], "-")) {    /* from stdin */
112 >                        readobj(NULL);
113                          outflags &= ~IO_FILES;
114 +                } else {                        /* from file */
115 +                        if (nfiles >= MAXOBJFIL)
116 +                                error(INTERNAL, "too many scene files");
117 +                        readobj(ofname[nfiles++] = argv[i]);
118                  }
95 –        }
119  
120 <        printargs(argc, argv, stdout);  /* info. header */
98 <        printf("\n");
120 >        ofname[nfiles] = NULL;
121  
122 <        startobj = nobjects;            /* previous objects already converted */
123 <        
124 <        for ( ; i < argc; i++) {                /* read new files */
103 <                if (nfiles >= MAXOBJFIL)
104 <                        error(INTERNAL, "too many scene files");
105 <                readobj(ofname[nfiles++] = argv[i]);
122 >        if (inpfrozen && outflags & IO_FILES) {
123 >                error(WARNING, "frozen octree");
124 >                outflags &= ~IO_FILES;
125          }
107 –        ofname[nfiles] = NULL;
126                                                  /* find bounding box */
127          bbmin[0] = bbmin[1] = bbmin[2] = FHUGE;
128          bbmax[0] = bbmax[1] = bbmax[2] = -FHUGE;
# Line 114 | Line 132 | char  **argv;
132          if (thescene.cusize == 0.0) {
133                  if (bbmin[0] <= bbmax[0]) {
134                          for (i = 0; i < 3; i++) {
135 <                                bbmin[i] -= FTINY;
136 <                                bbmax[i] += FTINY;
135 >                                bbmin[i] -= OMARGIN;
136 >                                bbmax[i] += OMARGIN;
137                          }
120 –                        VCOPY(thescene.cuorg, bbmin);
138                          for (i = 0; i < 3; i++)
139                                  if (bbmax[i] - bbmin[i] > thescene.cusize)
140                                          thescene.cusize = bbmax[i] - bbmin[i];
141 +                        for (i = 0; i < 3; i++)
142 +                                thescene.cuorg[i] =
143 +                                        (bbmax[i]+bbmin[i]-thescene.cusize)*.5;
144                  }
145          } else {
146                  for (i = 0; i < 3; i++)
# Line 130 | Line 150 | char  **argv;
150          }
151  
152          mincusize = thescene.cusize / resolu - FTINY;
153 <                
153 >
154          for (i = startobj; i < nobjects; i++)           /* add new objects */
155                  addobject(&thescene, i);
156 <        
156 >
157          thescene.cutree = combine(thescene.cutree);     /* optimize */
158  
159          writeoct(outflags, &thescene, ofname);  /* write structures to stdout */
# Line 166 | Line 186 | char  *s;
186   eputs(s)                                /* put string to stderr */
187   register char  *s;
188   {
189 <        static int  inline = 0;
189 >        static int  inln = 0;
190  
191 <        if (!inline++) {
191 >        if (!inln++) {
192                  fputs(progname, stderr);
193                  fputs(": ", stderr);
194          }
195          fputs(s, stderr);
196          if (*s && s[strlen(s)-1] == '\n')
197 <                inline = 0;
197 >                inln = 0;
198   }
199  
200  
201 + #define  bitop(f,i,op)          (f[((i)>>3)] op (1<<((i)&7)))
202 + #define  tstbit(f,i)            bitop(f,i,&)
203 + #define  setbit(f,i)            bitop(f,i,|=)
204 + #define  clrbit(f,i)            bitop(f,i,&=~)
205 + #define  tglbit(f,i)            bitop(f,i,^=)
206 +
207 +
208   addobject(cu, obj)                      /* add an object to a cube */
209   register CUBE  *cu;
210 < OBJECT  obj;
210 > OBJECT  obj;
211   {
212          CUBE  cukid;
213 <        OCTREE  ot;
214 <        OBJECT  oset[MAXSET+1];
213 >        OCTREE  ot;
214 >        OBJECT  oset[MAXSET+1];
215 >        unsigned char  inflg[(MAXSET+7)/8], volflg[(MAXSET+7)/8];
216          int  in;
217          register int  i, j;
218  
219          in = (*ofun[objptr(obj)->otype].funp)(objptr(obj), cu);
220  
221 <        if (!in)
221 >        if (in == O_MISS)
222                  return;                         /* no intersection */
223 <        
223 >
224          if (istree(cu->cutree)) {
225                                                  /* do children */
226                  cukid.cusize = cu->cusize * 0.5;
# Line 206 | Line 234 | OBJECT  obj;
234                          addobject(&cukid, obj);
235                          octkid(cu->cutree, i) = cukid.cutree;
236                  }
237 <                
238 <        } else if (isempty(cu->cutree)) {
237 >                return;
238 >        }
239 >        if (isempty(cu->cutree)) {
240                                                  /* singular set */
241                  oset[0] = 1; oset[1] = obj;
242                  cu->cutree = fullnode(oset);
243 <                
244 <        } else {
245 <                                                /* add to full node */
246 <                objset(oset, cu->cutree);
247 <                cukid.cusize = cu->cusize * 0.5;
219 <                
220 <                if (in == 2 || oset[0] < objlim || cukid.cusize < mincusize) {
221 <                                                        /* add to set */
222 <                        if (oset[0] >= MAXSET) {
223 <                                sprintf(errmsg,
224 <                                        "set overflow in addobject (%s)",
225 <                                                objptr(obj)->oname);
226 <                                error(INTERNAL, errmsg);
227 <                        }
228 <                        insertelem(oset, obj);
229 <                        cu->cutree = fullnode(oset);
243 >                return;
244 >        }
245 >                                        /* add to full node */
246 >        objset(oset, cu->cutree);
247 >        cukid.cusize = cu->cusize * 0.5;
248  
249 <                } else {
250 <                                                        /* subdivide cube */
251 <                        if ((ot = octalloc()) == EMPTY)
252 <                                error(SYSTEM, "out of octree space");
253 <                        for (i = 0; i < 8; i++) {
254 <                                cukid.cutree = EMPTY;
237 <                                for (j = 0; j < 3; j++) {
238 <                                        cukid.cuorg[j] = cu->cuorg[j];
239 <                                        if ((1<<j) & i)
240 <                                                cukid.cuorg[j] += cukid.cusize;
241 <                                }
242 <                                for (j = 1; j <= oset[0]; j++)
243 <                                        addobject(&cukid, oset[j]);
244 <                                addobject(&cukid, obj);
245 <                                octkid(ot, i) = cukid.cutree;
246 <                        }
247 <                        cu->cutree = ot;
249 >        if (in==O_IN || oset[0] < objlim || cukid.cusize < mincusize) {
250 >                                                /* add to set */
251 >                if (oset[0] >= MAXSET) {
252 >                        sprintf(errmsg, "set overflow in addobject (%s)",
253 >                                        objptr(obj)->oname);
254 >                        error(INTERNAL, errmsg);
255                  }
256 +                insertelem(oset, obj);
257 +                cu->cutree = fullnode(oset);
258 +                return;
259          }
260 +                                        /* subdivide cube */
261 +        if ((ot = octalloc()) == EMPTY)
262 +                error(SYSTEM, "out of octree space");
263 +                                        /* mark volumes */
264 +        j = (oset[0]+7)>>3;
265 +        while (j--)
266 +                volflg[j] = inflg[j] = 0;
267 +        for (j = 1; j <= oset[0]; j++)
268 +                if (isvolume(objptr(oset[j])->otype)) {
269 +                        setbit(volflg,j-1);
270 +                        if ((*ofun[objptr(oset[j])->otype].funp)
271 +                                        (objptr(oset[j]), cu) == O_IN)
272 +                                setbit(inflg,j-1);
273 +                }
274 +                                        /* assign subcubes */
275 +        for (i = 0; i < 8; i++) {
276 +                cukid.cutree = EMPTY;
277 +                for (j = 0; j < 3; j++) {
278 +                        cukid.cuorg[j] = cu->cuorg[j];
279 +                        if ((1<<j) & i)
280 +                                cukid.cuorg[j] += cukid.cusize;
281 +                }
282 +                                        /* surfaces first */
283 +                for (j = 1; j <= oset[0]; j++)
284 +                        if (!tstbit(volflg,j-1))
285 +                                addobject(&cukid, oset[j]);
286 +                                        /* then this object */
287 +                addobject(&cukid, obj);
288 +                                        /* then partial volumes */
289 +                for (j = 1; j <= oset[0]; j++)
290 +                        if (tstbit(volflg,j-1) &&
291 +                                        !tstbit(inflg,j-1))
292 +                                addobject(&cukid, oset[j]);
293 +                                        /* full volumes last */
294 +                for (j = 1; j <= oset[0]; j++)
295 +                        if (tstbit(inflg,j-1))
296 +                                addobject(&cukid, oset[j]);
297 +                                        /* returned node */
298 +                octkid(ot, i) = cukid.cutree;
299 +        }
300 +        cu->cutree = ot;
301   }

Diff Legend

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