src/ot/oconv.c

#ifndef lint
static const char RCSid[] = "$Id: oconv.c,v 2.21 2005/09/23 19:04:52 greg Exp $";
#endif
/*
 *  oconv.c - main program for object to octree conversion.
 *
 *     7/29/85
 */

#include  "platform.h"
#include  "standard.h"
#include  "octree.h"
#include  "object.h"
#include  "otypes.h"
#include  "paths.h"
#include  "resolu.h"
#include  "oconv.h"

#define  OMARGIN        (10*FTINY)      /* margin around global cube */

#define  MAXOBJFIL      255             /* maximum number of scene files */

char  *progname;                        /* argv[0] */

int  nowarn = 0;                        /* supress warnings? */

int  objlim = 6;                        /* # of objects before split */

int  resolu = 16384;                    /* octree resolution limit */

CUBE  thescene = {{0.0, 0.0, 0.0}, 0.0, EMPTY};         /* our scene */

char  *ofname[MAXOBJFIL+1];             /* object file names */
int  nfiles = 0;                        /* number of object files */

double  mincusize;                      /* minimum cube size from resolu */

void  (*addobjnotify[])() = {NULL};     /* new object notifier functions */

static void addobject(CUBE  *cu, OBJECT obj);
static void add2full(CUBE  *cu, OBJECT  obj, int  inc);


int
main(           /* convert object files to an octree */
        int  argc,
        char  *argv[]
)
{
        FVECT  bbmin, bbmax;
        char  *infile = NULL;
        int  inpfrozen = 0;
        int  outflags = IO_ALL;
        OBJECT  startobj;
        int  i;

        progname = argv[0] = fixargv0(argv[0]);

        ot_initotypes();

        for (i = 1; i < argc && argv[i][0] == '-'; i++)
                switch (argv[i][1]) {
                case '\0':                              /* scene from stdin */
                        goto breakopt;
                case 'i':                               /* input octree */
                        infile = argv[++i];
                        break;
                case 'b':                               /* bounding cube */
                        thescene.cuorg[0] = atof(argv[++i]) - OMARGIN;
                        thescene.cuorg[1] = atof(argv[++i]) - OMARGIN;
                        thescene.cuorg[2] = atof(argv[++i]) - OMARGIN;
                        thescene.cusize = atof(argv[++i]) + 2*OMARGIN;
                        break;
                case 'n':                               /* set limit */
                        objlim = atoi(argv[++i]);
                        break;
                case 'r':                               /* resolution limit */
                        resolu = atoi(argv[++i]);
                        break;
                case 'f':                               /* freeze octree */
                        outflags &= ~IO_FILES;
                        break;
                case 'w':                               /* supress warnings */
                        nowarn = 1;
                        break;
                default:
                        sprintf(errmsg, "unknown option: '%s'", argv[i]);
                        error(USER, errmsg);
                        break;
                }
breakopt:
        SET_FILE_BINARY(stdout);
        if (infile != NULL) {           /* get old octree & objects */
                if (thescene.cusize > FTINY)
                        error(USER, "only one of '-b' or '-i'");
                nfiles = readoct(infile, IO_ALL, &thescene, ofname);
                if (nfiles == 0)
                        inpfrozen++;
        } else
                newheader("RADIANCE", stdout);  /* new binary file header */
        printargs(argc, argv, stdout);
        fputformat(OCTFMT, stdout);
        printf("\n");

        startobj = nobjects;            /* previous objects already converted */

        for ( ; i < argc; i++)          /* read new scene descriptions */
                if (!strcmp(argv[i], "-")) {    /* from stdin */
                        readobj(NULL);
                        outflags &= ~IO_FILES;
                } else {                        /* from file */
                        if (nfiles >= MAXOBJFIL)
                                error(INTERNAL, "too many scene files");
                        readobj(ofname[nfiles++] = argv[i]);
                }

        ofname[nfiles] = NULL;

        if (inpfrozen && outflags & IO_FILES) {
                error(WARNING, "frozen octree");
                outflags &= ~IO_FILES;
        }
                                                /* find bounding box */
        bbmin[0] = bbmin[1] = bbmin[2] = FHUGE;
        bbmax[0] = bbmax[1] = bbmax[2] = -FHUGE;
        for (i = startobj; i < nobjects; i++)
                add2bbox(objptr(i), bbmin, bbmax);
                                                /* set/check cube */
        if (thescene.cusize == 0.0) {
                if (bbmin[0] <= bbmax[0]) {
                        for (i = 0; i < 3; i++) {
                                bbmin[i] -= OMARGIN;
                                bbmax[i] += OMARGIN;
                        }
                        for (i = 0; i < 3; i++)
                                if (bbmax[i] - bbmin[i] > thescene.cusize)
                                        thescene.cusize = bbmax[i] - bbmin[i];
                        for (i = 0; i < 3; i++)
                                thescene.cuorg[i] =
                                        (bbmax[i]+bbmin[i]-thescene.cusize)*.5;
                }
        } else {
                for (i = 0; i < 3; i++)
                        if (bbmin[i] < thescene.cuorg[i] ||
                                bbmax[i] > thescene.cuorg[i] + thescene.cusize)
                                error(USER, "boundary does not encompass scene");
        }

        mincusize = thescene.cusize / resolu - FTINY;

        for (i = startobj; i < nobjects; i++)           /* add new objects */
                addobject(&thescene, i);

        thescene.cutree = combine(thescene.cutree);     /* optimize */

        writeoct(outflags, &thescene, ofname);  /* write structures to stdout */

        quit(0);
        return 0; /* pro forma return */
}


void
quit(                           /* exit program */
        int  code
)
{
        exit(code);
}


void
cputs(void)                                     /* interactive error */
{
        /* referenced, but not used */
}


void
wputs(                          /* warning message */
        char  *s
)
{
        if (!nowarn)
                eputs(s);
}


void
eputs(                          /* put string to stderr */
        register char  *s
)
{
        static int  inln = 0;

        if (!inln++) {
                fputs(progname, stderr);
                fputs(": ", stderr);
        }
        fputs(s, stderr);
        if (*s && s[strlen(s)-1] == '\n')
                inln = 0;
}

                                /* conflicting def's in param.h */
#undef  tstbit
#undef  setbit
#undef  clrbit
#undef  tglbit

#define  bitop(f,i,op)          (f[((i)>>3)] op (1<<((i)&7)))
#define  tstbit(f,i)            bitop(f,i,&)
#define  setbit(f,i)            bitop(f,i,|=)
#define  clrbit(f,i)            bitop(f,i,&=~)
#define  tglbit(f,i)            bitop(f,i,^=)


static void
addobject(                      /* add an object to a cube */
        register CUBE  *cu,
        OBJECT  obj
)
{
        int  inc;

        inc = (*ofun[objptr(obj)->otype].funp)(objptr(obj), cu);

        if (inc == O_MISS)
                return;                         /* no intersection */

        if (istree(cu->cutree)) {
                CUBE  cukid;                    /* do children */
                int  i, j;
                cukid.cusize = cu->cusize * 0.5;
                for (i = 0; i < 8; i++) {
                        cukid.cutree = octkid(cu->cutree, i);
                        for (j = 0; j < 3; j++) {
                                cukid.cuorg[j] = cu->cuorg[j];
                                if ((1<<j) & i)
                                        cukid.cuorg[j] += cukid.cusize;
                        }
                        addobject(&cukid, obj);
                        octkid(cu->cutree, i) = cukid.cutree;
                }
                return;
        }
        if (isempty(cu->cutree)) {
                OBJECT  oset[2];                /* singular set */
                oset[0] = 1; oset[1] = obj;
                cu->cutree = fullnode(oset);
                return;
        }
                                        /* add to full node */
        add2full(cu, obj, inc);
}


static void
add2full(                       /* add object to full node */
        register CUBE  *cu,
        OBJECT  obj,
        int  inc
)
{
        OCTREE  ot;
        OBJECT  oset[MAXSET+1];
        CUBE  cukid;
        unsigned char  inflg[(MAXSET+7)/8], volflg[(MAXSET+7)/8];
        register int  i, j;

        objset(oset, cu->cutree);
        cukid.cusize = cu->cusize * 0.5;

        if (inc==O_IN || oset[0] < objlim || cukid.cusize <
                        (oset[0] < MAXSET ? mincusize : mincusize/256.0)) {
                                                /* add to set */
                if (oset[0] >= MAXSET) {
                        sprintf(errmsg, "set overflow in addobject (%s)",
                                        objptr(obj)->oname);
                        error(INTERNAL, errmsg);
                }
                insertelem(oset, obj);
                cu->cutree = fullnode(oset);
                return;
        }
                                        /* subdivide cube */
        if ((ot = octalloc()) == EMPTY)
                error(SYSTEM, "out of octree space");
                                        /* mark volumes */
        j = (oset[0]+7)>>3;
        while (j--)
                volflg[j] = inflg[j] = 0;
        for (j = 1; j <= oset[0]; j++)
                if (isvolume(objptr(oset[j])->otype)) {
                        setbit(volflg,j-1);
                        if ((*ofun[objptr(oset[j])->otype].funp)
                                        (objptr(oset[j]), cu) == O_IN)
                                setbit(inflg,j-1);
                }
                                        /* assign subcubes */
        for (i = 0; i < 8; i++) {
                cukid.cutree = EMPTY;
                for (j = 0; j < 3; j++) {
                        cukid.cuorg[j] = cu->cuorg[j];
                        if ((1<<j) & i)
                                cukid.cuorg[j] += cukid.cusize;
                }
                                        /* surfaces first */
                for (j = 1; j <= oset[0]; j++)
                        if (!tstbit(volflg,j-1))
                                addobject(&cukid, oset[j]);
                                        /* then this object */
                addobject(&cukid, obj);
                                        /* then partial volumes */
                for (j = 1; j <= oset[0]; j++)
                        if (tstbit(volflg,j-1) &&
                                        !tstbit(inflg,j-1))
                                addobject(&cukid, oset[j]);
                                        /* full volumes last */
                for (j = 1; j <= oset[0]; j++)
                        if (tstbit(inflg,j-1))
                                addobject(&cukid, oset[j]);
                                        /* returned node */
                octkid(ot, i) = cukid.cutree;
        }
        cu->cutree = ot;
}
Revision:	2.22
Committed:	Tue Jun 17 18:18:50 2014 UTC (11 years, 4 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R3, rad5R2, rad5R1, rad5R0, rad4R2P2, rad4R2P1, rad4R2
Changes since 2.21:	+2 -2 lines
Log Message:	Increased maximum number of scene files from 127 to 255
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.22	static const char RCSid[] = "$Id: oconv.c,v 2.21 2005/09/23 19:04:52 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* oconv.c - main program for object to octree conversion.
6			*
7			* 7/29/85
8			*/
9
10	greg	2.18	#include "platform.h"
11	greg	1.1	#include "standard.h"
12			#include "octree.h"
13			#include "object.h"
14			#include "otypes.h"
15	greg	2.4	#include "paths.h"
16	schorsch	2.19	#include "resolu.h"
17			#include "oconv.h"
18	greg	1.14
19	greg	2.4	#define OMARGIN (10FTINY) / margin around global cube */
20	greg	1.2
21	greg	2.22	#define MAXOBJFIL 255 /* maximum number of scene files */
22	greg	1.1
23			char progname; / argv[0] */
24
25			int nowarn = 0; /* supress warnings? */
26
27	greg	2.14	int objlim = 6; /* # of objects before split */
28	greg	1.1
29	greg	2.14	int resolu = 16384; /* octree resolution limit */
30	greg	1.1
31	greg	2.21	CUBE thescene = {{0.0, 0.0, 0.0}, 0.0, EMPTY}; /* our scene */
32	greg	1.1
33			char ofname[MAXOBJFIL+1]; / object file names */
34			int nfiles = 0; /* number of object files */
35
36	greg	2.4	double mincusize; /* minimum cube size from resolu */
37	greg	1.1
38	greg	2.12	void (addobjnotify[])() = {NULL}; / new object notifier functions */
39	greg	1.7
40	schorsch	2.19	static void addobject(CUBE *cu, OBJECT obj);
41			static void add2full(CUBE *cu, OBJECT obj, int inc);
42	greg	1.1
43	schorsch	2.19
44			int
45			main( /* convert object files to an octree */
46			int argc,
47			char *argv[]
48			)
49	greg	1.1	{
50			FVECT bbmin, bbmax;
51			char *infile = NULL;
52	greg	2.6	int inpfrozen = 0;
53	greg	1.1	int outflags = IO_ALL;
54	greg	2.4	OBJECT startobj;
55	greg	1.1	int i;
56
57	greg	2.5	progname = argv[0] = fixargv0(argv[0]);
58	greg	1.1
59	schorsch	2.19	ot_initotypes();
60	greg	1.12
61	greg	1.5	for (i = 1; i < argc && argv[i][0] == '-'; i++)
62	greg	1.1	switch (argv[i][1]) {
63	greg	1.5	case '\0': /* scene from stdin */
64			goto breakopt;
65	greg	1.1	case 'i': /* input octree */
66			infile = argv[++i];
67			break;
68			case 'b': /* bounding cube */
69	greg	1.2	thescene.cuorg[0] = atof(argv[++i]) - OMARGIN;
70			thescene.cuorg[1] = atof(argv[++i]) - OMARGIN;
71			thescene.cuorg[2] = atof(argv[++i]) - OMARGIN;
72			thescene.cusize = atof(argv[++i]) + 2*OMARGIN;
73	greg	1.1	break;
74			case 'n': /* set limit */
75			objlim = atoi(argv[++i]);
76			break;
77			case 'r': /* resolution limit */
78			resolu = atoi(argv[++i]);
79			break;
80			case 'f': /* freeze octree */
81			outflags &= ~IO_FILES;
82			break;
83			case 'w': /* supress warnings */
84			nowarn = 1;
85			break;
86			default:
87			sprintf(errmsg, "unknown option: '%s'", argv[i]);
88			error(USER, errmsg);
89			break;
90			}
91	greg	1.5	breakopt:
92	schorsch	2.15	SET_FILE_BINARY(stdout);
93	greg	1.1	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	greg	2.6	if (nfiles == 0)
98			inpfrozen++;
99	greg	2.8	} else
100			newheader("RADIANCE", stdout); /* new binary file header */
101	greg	2.7	printargs(argc, argv, stdout);
102	greg	1.13	fputformat(OCTFMT, stdout);
103	greg	1.1	printf("\n");
104
105			startobj = nobjects; /* previous objects already converted */
106	greg	2.5
107	greg	1.4	for ( ; i < argc; i++) /* read new scene descriptions */
108			if (!strcmp(argv[i], "-")) { /* from stdin */
109			readobj(NULL);
110			outflags &= ~IO_FILES;
111			} else { /* from file */
112			if (nfiles >= MAXOBJFIL)
113			error(INTERNAL, "too many scene files");
114			readobj(ofname[nfiles++] = argv[i]);
115			}
116
117	greg	1.1	ofname[nfiles] = NULL;
118	greg	2.6
119			if (inpfrozen && outflags & IO_FILES) {
120			error(WARNING, "frozen octree");
121			outflags &= ~IO_FILES;
122			}
123	greg	1.1	/* find bounding box */
124			bbmin[0] = bbmin[1] = bbmin[2] = FHUGE;
125			bbmax[0] = bbmax[1] = bbmax[2] = -FHUGE;
126			for (i = startobj; i < nobjects; i++)
127			add2bbox(objptr(i), bbmin, bbmax);
128			/* set/check cube */
129			if (thescene.cusize == 0.0) {
130			if (bbmin[0] <= bbmax[0]) {
131			for (i = 0; i < 3; i++) {
132	greg	1.2	bbmin[i] -= OMARGIN;
133			bbmax[i] += OMARGIN;
134	greg	1.1	}
135			for (i = 0; i < 3; i++)
136			if (bbmax[i] - bbmin[i] > thescene.cusize)
137			thescene.cusize = bbmax[i] - bbmin[i];
138	greg	1.3	for (i = 0; i < 3; i++)
139			thescene.cuorg[i] =
140			(bbmax[i]+bbmin[i]-thescene.cusize)*.5;
141	greg	1.1	}
142			} else {
143			for (i = 0; i < 3; i++)
144			if (bbmin[i] < thescene.cuorg[i] \|\|
145			bbmax[i] > thescene.cuorg[i] + thescene.cusize)
146			error(USER, "boundary does not encompass scene");
147			}
148
149			mincusize = thescene.cusize / resolu - FTINY;
150	greg	2.5
151	greg	1.1	for (i = startobj; i < nobjects; i++) /* add new objects */
152			addobject(&thescene, i);
153	greg	2.5
154	greg	1.1	thescene.cutree = combine(thescene.cutree); /* optimize */
155
156			writeoct(outflags, &thescene, ofname); /* write structures to stdout */
157
158			quit(0);
159	schorsch	2.19	return 0; /* pro forma return */
160	greg	1.1	}
161
162
163	greg	2.12	void
164	schorsch	2.19	quit( /* exit program */
165			int code
166			)
167	greg	1.1	{
168			exit(code);
169			}
170
171
172	greg	2.12	void
173	schorsch	2.19	cputs(void) /* interactive error */
174	greg	1.1	{
175			/* referenced, but not used */
176			}
177
178
179	greg	2.12	void
180	schorsch	2.19	wputs( /* warning message */
181			char *s
182			)
183	greg	1.1	{
184			if (!nowarn)
185			eputs(s);
186			}
187
188
189	greg	2.12	void
190	schorsch	2.19	eputs( /* put string to stderr */
191			register char *s
192			)
193	greg	1.1	{
194	greg	1.9	static int inln = 0;
195	greg	1.1
196	greg	1.9	if (!inln++) {
197	greg	1.1	fputs(progname, stderr);
198			fputs(": ", stderr);
199			}
200			fputs(s, stderr);
201			if (*s && s[strlen(s)-1] == '\n')
202	greg	1.9	inln = 0;
203	greg	1.1	}
204
205	greg	2.17	/* conflicting def's in param.h */
206			#undef tstbit
207			#undef setbit
208			#undef clrbit
209			#undef tglbit
210	greg	1.1
211	greg	2.4	#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	greg	1.11
217
218	schorsch	2.19	static void
219			addobject( /* add an object to a cube */
220			register CUBE *cu,
221			OBJECT obj
222			)
223	greg	1.1	{
224	greg	2.13	int inc;
225	greg	1.1
226	greg	2.13	inc = (*ofun[objptr(obj)->otype].funp)(objptr(obj), cu);
227	greg	1.1
228	greg	2.13	if (inc == O_MISS)
229	greg	1.1	return; /* no intersection */
230	greg	2.5
231	greg	1.1	if (istree(cu->cutree)) {
232	greg	2.13	CUBE cukid; /* do children */
233			int i, j;
234	greg	1.1	cukid.cusize = cu->cusize * 0.5;
235			for (i = 0; i < 8; i++) {
236			cukid.cutree = octkid(cu->cutree, i);
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			addobject(&cukid, obj);
243			octkid(cu->cutree, i) = cukid.cutree;
244			}
245	greg	1.11	return;
246			}
247			if (isempty(cu->cutree)) {
248	greg	2.13	OBJECT oset[2]; /* singular set */
249	greg	1.1	oset[0] = 1; oset[1] = obj;
250			cu->cutree = fullnode(oset);
251	greg	1.11	return;
252			}
253			/* add to full node */
254	greg	2.13	add2full(cu, obj, inc);
255			}
256
257
258	schorsch	2.19	static void
259			add2full( /* add object to full node */
260			register CUBE *cu,
261			OBJECT obj,
262			int inc
263			)
264	greg	2.13	{
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	greg	1.11	objset(oset, cu->cutree);
272			cukid.cusize = cu->cusize * 0.5;
273	greg	2.5
274	greg	2.20	if (inc==O_IN \|\| oset[0] < objlim \|\| cukid.cusize <
275			(oset[0] < MAXSET ? mincusize : mincusize/256.0)) {
276	greg	1.11	/* add to set */
277			if (oset[0] >= MAXSET) {
278	greg	2.3	sprintf(errmsg, "set overflow in addobject (%s)",
279	greg	1.11	objptr(obj)->oname);
280			error(INTERNAL, errmsg);
281	greg	1.1	}
282	greg	1.11	insertelem(oset, obj);
283			cu->cutree = fullnode(oset);
284			return;
285	greg	1.1	}
286	greg	1.11	/* subdivide cube */
287			if ((ot = octalloc()) == EMPTY)
288			error(SYSTEM, "out of octree space");
289			/* mark volumes */
290			j = (oset[0]+7)>>3;
291			while (j--)
292			volflg[j] = inflg[j] = 0;
293			for (j = 1; j <= oset[0]; j++)
294			if (isvolume(objptr(oset[j])->otype)) {
295			setbit(volflg,j-1);
296			if ((*ofun[objptr(oset[j])->otype].funp)
297	greg	2.3	(objptr(oset[j]), cu) == O_IN)
298	greg	1.11	setbit(inflg,j-1);
299			}
300			/* assign subcubes */
301			for (i = 0; i < 8; i++) {
302			cukid.cutree = EMPTY;
303			for (j = 0; j < 3; j++) {
304			cukid.cuorg[j] = cu->cuorg[j];
305			if ((1<<j) & i)
306			cukid.cuorg[j] += cukid.cusize;
307			}
308			/* surfaces first */
309			for (j = 1; j <= oset[0]; j++)
310			if (!tstbit(volflg,j-1))
311			addobject(&cukid, oset[j]);
312			/* then this object */
313			addobject(&cukid, obj);
314	greg	2.3	/* then partial volumes */
315	greg	1.11	for (j = 1; j <= oset[0]; j++)
316			if (tstbit(volflg,j-1) &&
317			!tstbit(inflg,j-1))
318			addobject(&cukid, oset[j]);
319	greg	2.3	/* full volumes last */
320	greg	1.11	for (j = 1; j <= oset[0]; j++)
321			if (tstbit(inflg,j-1))
322			addobject(&cukid, oset[j]);
323			/* returned node */
324			octkid(ot, i) = cukid.cutree;
325			}
326			cu->cutree = ot;
327	greg	1.1	}