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 2.2 by greg, Thu Dec 19 15:06:31 1991 UTC vs.
Revision 2.19 by schorsch, Sat Mar 27 12:41:45 2004 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1986 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   *  oconv.c - main program for object to octree conversion.
6   *
7   *     7/29/85
8   */
9  
10 + #include  "platform.h"
11   #include  "standard.h"
14 –
12   #include  "octree.h"
16 –
13   #include  "object.h"
18 –
14   #include  "otypes.h"
15 + #include  "paths.h"
16 + #include  "resolu.h"
17 + #include  "oconv.h"
18  
19 < #ifndef  DEFPATH
22 < #define  DEFPATH        ":/usr/local/lib/ray"
23 < #endif
19 > #define  OMARGIN        (10*FTINY)      /* margin around global cube */
20  
21 < #define  OMARGIN        (10*FTINY)      /* margin around global cube */
21 > #define  MAXOBJFIL      127             /* maximum number of scene files */
22  
27 – #define  MAXOBJFIL      63              /* maximum number of scene files */
28 –
23   char  *progname;                        /* argv[0] */
24  
31 – char  *libpath;                         /* library search path */
32 –
25   int  nowarn = 0;                        /* supress warnings? */
26  
27 < int  objlim = 5;                        /* # of objects before split */
27 > int  objlim = 6;                        /* # of objects before split */
28  
29 < int  resolu = 1024;                     /* octree resolution limit */
29 > int  resolu = 16384;                    /* octree resolution limit */
30  
31   CUBE  thescene = {EMPTY, {0.0, 0.0, 0.0}, 0.0};         /* our scene */
32  
33   char  *ofname[MAXOBJFIL+1];             /* object file names */
34   int  nfiles = 0;                        /* number of object files */
35  
36 < double  mincusize;                      /* minimum cube size from resolu */
36 > double  mincusize;                      /* minimum cube size from resolu */
37  
38 < int  (*addobjnotify[])() = {NULL};      /* new object notifier functions */
38 > void  (*addobjnotify[])() = {NULL};     /* new object notifier functions */
39  
40 + static void addobject(CUBE  *cu, OBJECT obj);
41 + static void add2full(CUBE  *cu, OBJECT  obj, int  inc);
42  
43 < main(argc, argv)                /* convert object files to an octree */
44 < int  argc;
45 < char  **argv;
43 >
44 > int
45 > main(           /* convert object files to an octree */
46 >        int  argc,
47 >        char  *argv[]
48 > )
49   {
53 –        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)
63 <                libpath = DEFPATH;
59 >        ot_initotypes();
60  
65 –        initotypes();
66 –
61          for (i = 1; i < argc && argv[i][0] == '-'; i++)
62                  switch (argv[i][1]) {
63                  case '\0':                              /* scene from stdin */
# Line 95 | Line 89 | char  **argv;
89                          break;
90                  }
91   breakopt:
92 +        SET_FILE_BINARY(stdout);
93          if (infile != NULL) {           /* get old octree & objects */
94                  if (thescene.cusize > FTINY)
95                          error(USER, "only one of '-b' or '-i'");
96                  nfiles = readoct(infile, IO_ALL, &thescene, ofname);
97 <                if (nfiles == 0 && outflags & IO_FILES) {
98 <                        error(WARNING, "frozen octree");
99 <                        outflags &= ~IO_FILES;
100 <                }
101 <        }
107 <
108 <        printargs(argc, argv, stdout);  /* info. header */
97 >                if (nfiles == 0)
98 >                        inpfrozen++;
99 >        } else
100 >                newheader("RADIANCE", stdout);  /* new binary file header */
101 >        printargs(argc, argv, stdout);
102          fputformat(OCTFMT, stdout);
103          printf("\n");
104  
105          startobj = nobjects;            /* previous objects already converted */
106 <        
106 >
107          for ( ; i < argc; i++)          /* read new scene descriptions */
108                  if (!strcmp(argv[i], "-")) {    /* from stdin */
109                          readobj(NULL);
# Line 122 | Line 115 | breakopt:
115                  }
116  
117          ofname[nfiles] = NULL;
118 +
119 +        if (inpfrozen && outflags & IO_FILES) {
120 +                error(WARNING, "frozen octree");
121 +                outflags &= ~IO_FILES;
122 +        }
123                                                  /* find bounding box */
124          bbmin[0] = bbmin[1] = bbmin[2] = FHUGE;
125          bbmax[0] = bbmax[1] = bbmax[2] = -FHUGE;
# Line 149 | Line 147 | breakopt:
147          }
148  
149          mincusize = thescene.cusize / resolu - FTINY;
150 <                
150 >
151          for (i = startobj; i < nobjects; i++)           /* add new objects */
152                  addobject(&thescene, i);
153 <        
153 >
154          thescene.cutree = combine(thescene.cutree);     /* optimize */
155  
156          writeoct(outflags, &thescene, ofname);  /* write structures to stdout */
157  
158          quit(0);
159 +        return 0; /* pro forma return */
160   }
161  
162  
163 < quit(code)                              /* exit program */
164 < int  code;
163 > void
164 > quit(                           /* exit program */
165 >        int  code
166 > )
167   {
168          exit(code);
169   }
170  
171  
172 < cputs()                                 /* interactive error */
172 > void
173 > cputs(void)                                     /* interactive error */
174   {
175          /* referenced, but not used */
176   }
177  
178  
179 < wputs(s)                                /* warning message */
180 < char  *s;
179 > void
180 > wputs(                          /* warning message */
181 >        char  *s
182 > )
183   {
184          if (!nowarn)
185                  eputs(s);
186   }
187  
188  
189 < eputs(s)                                /* put string to stderr */
190 < register char  *s;
189 > void
190 > eputs(                          /* put string to stderr */
191 >        register char  *s
192 > )
193   {
194          static int  inln = 0;
195  
# Line 196 | Line 202 | register char  *s;
202                  inln = 0;
203   }
204  
205 +                                /* conflicting def's in param.h */
206 + #undef  tstbit
207 + #undef  setbit
208 + #undef  clrbit
209 + #undef  tglbit
210  
211 < #define  bitop(f,i,op)          (f[((i)>>3)] op (1<<((i)&7)))
212 < #define  tstbit(f,i)            bitop(f,i,&)
213 < #define  setbit(f,i)            bitop(f,i,|=)
214 < #define  clrbit(f,i)            bitop(f,i,&=~)
215 < #define  tglbit(f,i)            bitop(f,i,^=)
211 > #define  bitop(f,i,op)          (f[((i)>>3)] op (1<<((i)&7)))
212 > #define  tstbit(f,i)            bitop(f,i,&)
213 > #define  setbit(f,i)            bitop(f,i,|=)
214 > #define  clrbit(f,i)            bitop(f,i,&=~)
215 > #define  tglbit(f,i)            bitop(f,i,^=)
216  
217  
218 < addobject(cu, obj)                      /* add an object to a cube */
219 < register CUBE  *cu;
220 < OBJECT  obj;
218 > static void
219 > addobject(                      /* add an object to a cube */
220 >        register CUBE  *cu,
221 >        OBJECT  obj
222 > )
223   {
224 <        CUBE  cukid;
212 <        OCTREE  ot;
213 <        OBJECT  oset[MAXSET+1];
214 <        unsigned char  inflg[MAXSET/8], volflg[MAXSET/8];
215 <        int  in;
216 <        register int  i, j;
224 >        int  inc;
225  
226 <        in = (*ofun[objptr(obj)->otype].funp)(objptr(obj), cu);
226 >        inc = (*ofun[objptr(obj)->otype].funp)(objptr(obj), cu);
227  
228 <        if (in == O_MISS)
228 >        if (inc == O_MISS)
229                  return;                         /* no intersection */
230 <        
230 >
231          if (istree(cu->cutree)) {
232 <                                                /* do children */
232 >                CUBE  cukid;                    /* do children */
233 >                int  i, j;
234                  cukid.cusize = cu->cusize * 0.5;
235                  for (i = 0; i < 8; i++) {
236                          cukid.cutree = octkid(cu->cutree, i);
# Line 236 | Line 245 | OBJECT  obj;
245                  return;
246          }
247          if (isempty(cu->cutree)) {
248 <                                                /* singular set */
248 >                OBJECT  oset[2];                /* singular set */
249                  oset[0] = 1; oset[1] = obj;
250                  cu->cutree = fullnode(oset);
251                  return;
252          }
253                                          /* add to full node */
254 +        add2full(cu, obj, inc);
255 + }
256 +
257 +
258 + static void
259 + add2full(                       /* add object to full node */
260 +        register CUBE  *cu,
261 +        OBJECT  obj,
262 +        int  inc
263 + )
264 + {
265 +        OCTREE  ot;
266 +        OBJECT  oset[MAXSET+1];
267 +        CUBE  cukid;
268 +        unsigned char  inflg[(MAXSET+7)/8], volflg[(MAXSET+7)/8];
269 +        register int  i, j;
270 +
271          objset(oset, cu->cutree);
272          cukid.cusize = cu->cusize * 0.5;
273 <        
274 <        if (in==O_IN || oset[0] < objlim || cukid.cusize < mincusize) {
273 >
274 >        if (inc==O_IN || oset[0] < objlim || cukid.cusize < mincusize) {
275                                                  /* add to set */
276                  if (oset[0] >= MAXSET) {
277 <                        sprintf(errmsg,
252 <                                "set overflow in addobject (%s)",
277 >                        sprintf(errmsg, "set overflow in addobject (%s)",
278                                          objptr(obj)->oname);
279                          error(INTERNAL, errmsg);
280                  }
# Line 268 | Line 293 | OBJECT  obj;
293                  if (isvolume(objptr(oset[j])->otype)) {
294                          setbit(volflg,j-1);
295                          if ((*ofun[objptr(oset[j])->otype].funp)
296 <                                        (objptr(oset[j]),cu) == O_IN)
296 >                                        (objptr(oset[j]), cu) == O_IN)
297                                  setbit(inflg,j-1);
298                  }
299                                          /* assign subcubes */
# Line 285 | Line 310 | OBJECT  obj;
310                                  addobject(&cukid, oset[j]);
311                                          /* then this object */
312                  addobject(&cukid, obj);
313 <                                        /* partial volumes */
313 >                                        /* then partial volumes */
314                  for (j = 1; j <= oset[0]; j++)
315                          if (tstbit(volflg,j-1) &&
316                                          !tstbit(inflg,j-1))
317                                  addobject(&cukid, oset[j]);
318 <                                        /* full volumes */
318 >                                        /* full volumes last */
319                  for (j = 1; j <= oset[0]; j++)
320                          if (tstbit(inflg,j-1))
321                                  addobject(&cukid, oset[j]);

Diff Legend

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