ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/ot/oconv.c

Comparing ray/src/ot/oconv.c (file contents):
Revision 1.5 by greg, Wed Jun 21 08:56:35 1989 UTC vs.
Revision 2.15 by schorsch, Thu Jun 5 19:29:34 2003 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		*
#	Line 18 | Line 15 | static char SCCSid[] = "$SunId$ LBL";
15
16		#include  "otypes.h"
17
18	<	#define  OMARGIN        (10*FTINY)      /* margin around global cube */
18	>	#include  "paths.h"
19
20	<	#define  MAXOBJFIL      63              /* maximum number of scene files */
20	>	#define  OMARGIN        (10*FTINY)      /* margin around global cube */
21
22	+	#define  MAXOBJFIL      127             /* maximum number of scene files */
23	+
24		char  *progname;                        /* argv[0] */
25
27	–	char  *libpath;                         /* library search path */
28	–
26		int  nowarn = 0;                        /* supress warnings? */
27
28	<	int  objlim = 5;                        /* # of objects before split */
28	>	int  objlim = 6;                        /* # of objects before split */
29
30	<	int  resolu = 1024;                     /* octree resolution limit */
30	>	int  resolu = 16384;                    /* octree resolution limit */
31
32		CUBE  thescene = {EMPTY, {0.0, 0.0, 0.0}, 0.0};         /* our scene */
33
34		char  *ofname[MAXOBJFIL+1];             /* object file names */
35		int  nfiles = 0;                        /* number of object files */
36
37	<	double  mincusize;                      /* minimum cube size from resolu */
37	>	double  mincusize;                      /* minimum cube size from resolu */
38
39	+	void  (*addobjnotify[])() = {NULL};     /* new object notifier functions */
40
41	+
42		main(argc, argv)                /* convert object files to an octree */
43		int  argc;
44	<	char  **argv;
44	>	char  *argv[];
45		{
47	–	char  *getenv();
48	–	double  atof();
46		FVECT  bbmin, bbmax;
47		char  *infile = NULL;
48	+	int  inpfrozen = 0;
49		int  outflags = IO_ALL;
50	<	OBJECT  startobj;
50	>	OBJECT  startobj;
51		int  i;
52
53	<	progname = argv[0];
53	>	progname = argv[0] = fixargv0(argv[0]);
54
55	<	if ((libpath = getenv("RAYPATH")) == NULL)
58	<	libpath = ":/usr/local/lib/ray";
55	>	initotypes();
56
57		for (i = 1; i < argc && argv[i][0] == '-'; i++)
58		switch (argv[i][1]) {
#	Line 88 | Line 85 | char  **argv;
85		break;
86		}
87		breakopt:
88	+	SET_FILE_BINARY(stdout);
89		if (infile != NULL) {           /* get old octree & objects */
90		if (thescene.cusize > FTINY)
91		error(USER, "only one of '-b' or '-i'");
92		nfiles = readoct(infile, IO_ALL, &thescene, ofname);
93	<	if (nfiles == 0 && outflags & IO_FILES) {
94	<	error(WARNING, "frozen octree");
95	<	outflags &= ~IO_FILES;
96	<	}
97	<	}
98	<
101	<	printargs(argc, argv, stdout);  /* info. header */
93	>	if (nfiles == 0)
94	>	inpfrozen++;
95	>	} else
96	>	newheader("RADIANCE", stdout);  /* new binary file header */
97	>	printargs(argc, argv, stdout);
98	>	fputformat(OCTFMT, stdout);
99		printf("\n");
100
101		startobj = nobjects;            /* previous objects already converted */
102	<
102	>
103		for ( ; i < argc; i++)          /* read new scene descriptions */
104		if (!strcmp(argv[i], "-")) {    /* from stdin */
105		readobj(NULL);
#	Line 114 | Line 111 | breakopt:
111		}
112
113		ofname[nfiles] = NULL;
114	+
115	+	if (inpfrozen && outflags & IO_FILES) {
116	+	error(WARNING, "frozen octree");
117	+	outflags &= ~IO_FILES;
118	+	}
119		/* find bounding box */
120		bbmin[0] = bbmin[1] = bbmin[2] = FHUGE;
121		bbmax[0] = bbmax[1] = bbmax[2] = -FHUGE;
#	Line 141 | Line 143 | breakopt:
143		}
144
145		mincusize = thescene.cusize / resolu - FTINY;
146	<
146	>
147		for (i = startobj; i < nobjects; i++)           /* add new objects */
148		addobject(&thescene, i);
149	<
149	>
150		thescene.cutree = combine(thescene.cutree);     /* optimize */
151
152		writeoct(outflags, &thescene, ofname);  /* write structures to stdout */
#	Line 153 | Line 155 | breakopt:
155		}
156
157
158	+	void
159		quit(code)                              /* exit program */
160		int  code;
161		{
#	Line 160 | Line 163 | int  code;
163		}
164
165
166	+	void
167		cputs()                                 /* interactive error */
168		{
169		/* referenced, but not used */
170		}
171
172
173	+	void
174		wputs(s)                                /* warning message */
175		char  *s;
176		{
#	Line 174 | Line 179 | char  *s;
179		}
180
181
182	+	void
183		eputs(s)                                /* put string to stderr */
184		register char  *s;
185		{
186	<	static int  inline = 0;
186	>	static int  inln = 0;
187
188	<	if (!inline++) {
188	>	if (!inln++) {
189		fputs(progname, stderr);
190		fputs(": ", stderr);
191		}
192		fputs(s, stderr);
193		if (*s && s[strlen(s)-1] == '\n')
194	<	inline = 0;
194	>	inln = 0;
195		}
196
197
198	+	#define  bitop(f,i,op)          (f[((i)>>3)] op (1<<((i)&7)))
199	+	#define  tstbit(f,i)            bitop(f,i,&)
200	+	#define  setbit(f,i)            bitop(f,i,|=)
201	+	#define  clrbit(f,i)            bitop(f,i,&=~)
202	+	#define  tglbit(f,i)            bitop(f,i,^=)
203	+
204	+
205		addobject(cu, obj)                      /* add an object to a cube */
206		register CUBE  *cu;
207	<	OBJECT  obj;
207	>	OBJECT  obj;
208		{
209	<	CUBE  cukid;
197	<	OCTREE  ot;
198	<	OBJECT  oset[MAXSET+1];
199	<	int  in;
200	<	register int  i, j;
209	>	int  inc;
210
211	<	in = (*ofun[objptr(obj)->otype].funp)(objptr(obj), cu);
211	>	inc = (*ofun[objptr(obj)->otype].funp)(objptr(obj), cu);
212
213	<	if (!in)
213	>	if (inc == O_MISS)
214		return;                         /* no intersection */
215	<
215	>
216		if (istree(cu->cutree)) {
217	<	/* do children */
217	>	CUBE  cukid;                    /* do children */
218	>	int  i, j;
219		cukid.cusize = cu->cusize * 0.5;
220		for (i = 0; i < 8; i++) {
221		cukid.cutree = octkid(cu->cutree, i);
#	Line 217 | Line 227 | OBJECT  obj;
227		addobject(&cukid, obj);
228		octkid(cu->cutree, i) = cukid.cutree;
229		}
230	<
231	<	} else if (isempty(cu->cutree)) {
232	<	/* singular set */
230	>	return;
231	>	}
232	>	if (isempty(cu->cutree)) {
233	>	OBJECT  oset[2];                /* singular set */
234		oset[0] = 1; oset[1] = obj;
235		cu->cutree = fullnode(oset);
236	<
237	<	} else {
238	<	/* add to full node */
239	<	objset(oset, cu->cutree);
240	<	cukid.cusize = cu->cusize * 0.5;
230	<
231	<	if (in == 2 || oset[0] < objlim || cukid.cusize < mincusize) {
232	<	/* add to set */
233	<	if (oset[0] >= MAXSET) {
234	<	sprintf(errmsg,
235	<	"set overflow in addobject (%s)",
236	<	objptr(obj)->oname);
237	<	error(INTERNAL, errmsg);
238	<	}
239	<	insertelem(oset, obj);
240	<	cu->cutree = fullnode(oset);
236	>	return;
237	>	}
238	>	/* add to full node */
239	>	add2full(cu, obj, inc);
240	>	}
241
242	<	} else {
243	<	/* subdivide cube */
244	<	if ((ot = octalloc()) == EMPTY)
245	<	error(SYSTEM, "out of octree space");
246	<	for (i = 0; i < 8; i++) {
247	<	cukid.cutree = EMPTY;
248	<	for (j = 0; j < 3; j++) {
249	<	cukid.cuorg[j] = cu->cuorg[j];
250	<	if ((1<<j) & i)
251	<	cukid.cuorg[j] += cukid.cusize;
252	<	}
253	<	for (j = 1; j <= oset[0]; j++)
254	<	addobject(&cukid, oset[j]);
255	<	addobject(&cukid, obj);
256	<	octkid(ot, i) = cukid.cutree;
257	<	}
258	<	cu->cutree = ot;
242	>
243	>	add2full(cu, obj, inc)                  /* add object to full node */
244	>	register CUBE  *cu;
245	>	OBJECT  obj;
246	>	int  inc;
247	>	{
248	>	OCTREE  ot;
249	>	OBJECT  oset[MAXSET+1];
250	>	CUBE  cukid;
251	>	unsigned char  inflg[(MAXSET+7)/8], volflg[(MAXSET+7)/8];
252	>	register int  i, j;
253	>
254	>	objset(oset, cu->cutree);
255	>	cukid.cusize = cu->cusize * 0.5;
256	>
257	>	if (inc==O_IN || oset[0] < objlim || cukid.cusize < mincusize) {
258	>	/* add to set */
259	>	if (oset[0] >= MAXSET) {
260	>	sprintf(errmsg, "set overflow in addobject (%s)",
261	>	objptr(obj)->oname);
262	>	error(INTERNAL, errmsg);
263		}
264	+	insertelem(oset, obj);
265	+	cu->cutree = fullnode(oset);
266	+	return;
267		}
268	+	/* subdivide cube */
269	+	if ((ot = octalloc()) == EMPTY)
270	+	error(SYSTEM, "out of octree space");
271	+	/* mark volumes */
272	+	j = (oset[0]+7)>>3;
273	+	while (j--)
274	+	volflg[j] = inflg[j] = 0;
275	+	for (j = 1; j <= oset[0]; j++)
276	+	if (isvolume(objptr(oset[j])->otype)) {
277	+	setbit(volflg,j-1);
278	+	if ((*ofun[objptr(oset[j])->otype].funp)
279	+	(objptr(oset[j]), cu) == O_IN)
280	+	setbit(inflg,j-1);
281	+	}
282	+	/* assign subcubes */
283	+	for (i = 0; i < 8; i++) {
284	+	cukid.cutree = EMPTY;
285	+	for (j = 0; j < 3; j++) {
286	+	cukid.cuorg[j] = cu->cuorg[j];
287	+	if ((1<<j) & i)
288	+	cukid.cuorg[j] += cukid.cusize;
289	+	}
290	+	/* surfaces first */
291	+	for (j = 1; j <= oset[0]; j++)
292	+	if (!tstbit(volflg,j-1))
293	+	addobject(&cukid, oset[j]);
294	+	/* then this object */
295	+	addobject(&cukid, obj);
296	+	/* then partial volumes */
297	+	for (j = 1; j <= oset[0]; j++)
298	+	if (tstbit(volflg,j-1) &&
299	+	!tstbit(inflg,j-1))
300	+	addobject(&cukid, oset[j]);
301	+	/* full volumes last */
302	+	for (j = 1; j <= oset[0]; j++)
303	+	if (tstbit(inflg,j-1))
304	+	addobject(&cukid, oset[j]);
305	+	/* returned node */
306	+	octkid(ot, i) = cukid.cutree;
307	+	}
308	+	cu->cutree = ot;
309		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)