src/common/readoct.c

/* Copyright (c) 1991 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  readoct.c - routines to read octree information.
 *
 *     7/30/85
 */

#include  "standard.h"

#include  "octree.h"

#include  "object.h"

#include  "otypes.h"

extern double  atof();
static double  getflt();
static long  getint();
static char  *getstr();
static OCTREE  getfullnode(), gettree();

static char  *infn;                     /* input file name */
static FILE  *infp;                     /* input file stream */
static OBJECT  objorig;                 /* zeroeth object */
static short  otypmap[NUMOTYPE+8];      /* object type map */


int
readoct(fname, load, scene, ofn)        /* read in octree from file */
char  *fname;
int  load;
CUBE  *scene;
char  *ofn[];
{
        extern int  fputs();
        char  sbuf[512];
        int  nf;
        OBJECT  fnobjects;
        register int  i;
        
        if (fname == NULL) {
                infn = "standard input";
                infp = stdin;
        } else {
                infn = fname;
                if ((infp = fopen(fname, "r")) == NULL) {
                        sprintf(errmsg, "cannot open octree file \"%s\"",
                                        fname);
                        error(SYSTEM, errmsg);
                }
        }
                                        /* get header */
        if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : NULL) < 0)
                octerror(USER, "not an octree");
                                        /* check format */
        if (getint(2) != OCTMAGIC)
                octerror(USER, "incompatible octree format");
                                        /* get boundaries */
        if (load & IO_BOUNDS) {
                for (i = 0; i < 3; i++)
                        scene->cuorg[i] = atof(getstr(sbuf));
                scene->cusize = atof(getstr(sbuf));
        } else {
                for (i = 0; i < 4; i++)
                        getstr(sbuf);
        }
        objorig = nobjects;             /* set object offset */
        nf = 0;                         /* get object files */
        while (*getstr(sbuf)) {
                if (load & IO_SCENE)
                        readobj(sbuf);
                if (load & IO_FILES)
                        ofn[nf] = savqstr(sbuf);
                nf++;
        }
        if (load & IO_FILES)
                ofn[nf] = NULL;
                                        /* get number of objects */
        fnobjects = getint(sizeof(OBJECT));

        if (load & IO_TREE) {
                                                /* get the octree */
                scene->cutree = gettree();
                                                /* get the scene */
                if (nf == 0 && load & IO_SCENE) {
                        for (i = 0; *getstr(sbuf); i++)
                                if ((otypmap[i] = otype(sbuf)) < 0) {
                                        sprintf(errmsg, "unknown type \"%s\"",
                                                        sbuf);
                                        octerror(WARNING, errmsg);
                                }
                        while (getobj() != OVOID)
                                ;
                } else if (load & IO_SCENE) {           /* consistency checks */
                                                /* check object count */
                        if (nobjects != objorig+fnobjects)
                                octerror(USER, "bad object count; octree stale?");
                                                /* check for non-surfaces */
                        if (nonsurfinset(objorig, fnobjects))
                                octerror(USER, "non-surface in set; octree stale?");
                }
        }
        fclose(infp);
        return(nf);
}


static char *
getstr(s)                       /* get null-terminated string */
char  *s;
{
        register char  *cp;
        register int  c;

        cp = s;
        while ((c = getc(infp)) != EOF)
                if ((*cp++ = c) == '\0')
                        return(s);
                
        octerror(USER, "truncated octree");
}


static OCTREE
getfullnode()                   /* get a set, return fullnode */
{
        OBJECT  set[MAXSET+1];
        register int  i;

        set[0] = getint(sizeof(OBJECT));
        if (set[0] > MAXSET)
                octerror(USER, "bad set in getfullnode");
        for (i = 1; i <= set[0]; i++)
                set[i] = getint(sizeof(OBJECT)) + objorig;
        return(fullnode(set));
}       


static long
getint(siz)                     /* get a siz-byte integer */
register int  siz;
{
        register int  c;
        register long  r;

        if ((c = getc(infp)) == EOF)
                goto end_file;
        r = 0x80&c ? -1<<8|c : c;               /* sign extend */
        while (--siz > 0) {
                if ((c = getc(infp)) == EOF)
                        goto end_file;
                r <<= 8;
                r |= c;
        }
        return(r);
end_file:
        octerror(USER, "truncated octree");
}


static double
getflt()                        /* get a floating point number */
{
        extern double  ldexp();
        double  d;

        d = (double)getint(4)/0x7fffffff;
        return(ldexp(d, (int)getint(1)));
}
        

static OCTREE
gettree()                       /* get a pre-ordered octree */
{
        register OCTREE  ot;
        register int  i;
        
        switch (getc(infp)) {
        case OT_EMPTY:
                return(EMPTY);
        case OT_FULL:
                return(getfullnode());
        case OT_TREE:
                if ((ot = octalloc()) == EMPTY)
                        octerror(SYSTEM, "out of tree space in gettree");
                for (i = 0; i < 8; i++)
                        octkid(ot, i) = gettree();
                return(ot);
        case EOF:
                octerror(USER, "truncated octree");
        default:
                octerror(USER, "damaged octree");
        }
}


static
getobj()                                /* get next object */
{
        char  sbuf[MAXSTR];
        int  obj;
        register int  i;
        register OBJREC  *objp;

        i = getint(1);
        if (i == -1)
                return(OVOID);          /* terminator */
        if ((obj = newobject()) == OVOID)
                error(SYSTEM, "out of object space");
        objp = objptr(obj);
        if ((objp->otype = otypmap[i]) < 0)
                octerror(USER, "reference to unknown type");
        if ((objp->omod = getint(sizeof(OBJECT))) != OVOID)
                objp->omod += objorig;
        objp->oname = savqstr(getstr(sbuf));
        if (objp->oargs.nsargs = getint(2)) {
                objp->oargs.sarg = (char **)bmalloc
                                (objp->oargs.nsargs*sizeof(char *));
                if (objp->oargs.sarg == NULL)
                        goto memerr;
                for (i = 0; i < objp->oargs.nsargs; i++)
                        objp->oargs.sarg[i] = savestr(getstr(sbuf));
        } else
                objp->oargs.sarg = NULL;
#ifdef  IARGS
        if (objp->oargs.niargs = getint(2)) {
                objp->oargs.iarg = (long *)bmalloc
                                (objp->oargs.niargs*sizeof(long));
                if (objp->oargs.iarg == NULL)
                        goto memerr;
                for (i = 0; i < objp->oargs.niargs; i++)
                        objp->oargs.iarg[i] = getint(4);
        } else
                objp->oargs.iarg = NULL;
#endif
        if (objp->oargs.nfargs = getint(2)) {
                objp->oargs.farg = (double *)bmalloc
                                (objp->oargs.nfargs*sizeof(double));
                if (objp->oargs.farg == NULL)
                        goto memerr;
                for (i = 0; i < objp->oargs.nfargs; i++)
                        objp->oargs.farg[i] = getflt();
        } else
                objp->oargs.farg = NULL;
                                                /* initialize */
        objp->os = NULL;
        objp->lastrno = -1;
                                                /* insert */
        insertobject(obj);
        return(obj);
memerr:
        error(SYSTEM, "out of memory in getobj");
}


static
octerror(etyp, msg)                     /* octree error */
int  etyp;
char  *msg;
{
        char  msgbuf[128];

        sprintf(msgbuf, "(%s): %s", infn, msg);
        error(etyp, msgbuf);
}
Revision:	1.13
Committed:	Mon Aug 5 08:58:52 1991 UTC (32 years, 9 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.12:	+8 -10 lines
Log Message:	fixed small logic problem
#	User	Rev	Content
1	greg	1.13	/* Copyright (c) 1991 Regents of the University of California */
2	greg	1.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* readoct.c - routines to read octree information.
9			*
10			* 7/30/85
11			*/
12
13			#include "standard.h"
14
15			#include "octree.h"
16
17			#include "object.h"
18
19			#include "otypes.h"
20
21	greg	1.7	extern double atof();
22			static double getflt();
23			static long getint();
24			static char *getstr();
25			static OCTREE getfullnode(), gettree();
26	greg	1.1
27			static char infn; / input file name */
28			static FILE infp; / input file stream */
29			static OBJECT objorig; /* zeroeth object */
30			static short otypmap[NUMOTYPE+8]; /* object type map */
31
32
33			int
34			readoct(fname, load, scene, ofn) /* read in octree from file */
35			char *fname;
36			int load;
37			CUBE *scene;
38			char *ofn[];
39			{
40	greg	1.12	extern int fputs();
41	greg	1.11	char sbuf[512];
42	greg	1.1	int nf;
43	greg	1.8	OBJECT fnobjects;
44	greg	1.1	register int i;
45
46			if (fname == NULL) {
47			infn = "standard input";
48			infp = stdin;
49			} else {
50			infn = fname;
51			if ((infp = fopen(fname, "r")) == NULL) {
52			sprintf(errmsg, "cannot open octree file \"%s\"",
53			fname);
54			error(SYSTEM, errmsg);
55			}
56			}
57			/* get header */
58	greg	1.12	if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : NULL) < 0)
59			octerror(USER, "not an octree");
60	greg	1.1	/* check format */
61			if (getint(2) != OCTMAGIC)
62	greg	1.12	octerror(USER, "incompatible octree format");
63	greg	1.1	/* get boundaries */
64			if (load & IO_BOUNDS) {
65			for (i = 0; i < 3; i++)
66			scene->cuorg[i] = atof(getstr(sbuf));
67			scene->cusize = atof(getstr(sbuf));
68			} else {
69			for (i = 0; i < 4; i++)
70			getstr(sbuf);
71			}
72			objorig = nobjects; /* set object offset */
73			nf = 0; /* get object files */
74			while (*getstr(sbuf)) {
75			if (load & IO_SCENE)
76			readobj(sbuf);
77			if (load & IO_FILES)
78			ofn[nf] = savqstr(sbuf);
79			nf++;
80			}
81			if (load & IO_FILES)
82			ofn[nf] = NULL;
83	greg	1.8	/* get number of objects */
84			fnobjects = getint(sizeof(OBJECT));
85	greg	1.1
86			if (load & IO_TREE) {
87			/* get the octree */
88			scene->cutree = gettree();
89			/* get the scene */
90			if (nf == 0 && load & IO_SCENE) {
91			for (i = 0; *getstr(sbuf); i++)
92			if ((otypmap[i] = otype(sbuf)) < 0) {
93			sprintf(errmsg, "unknown type \"%s\"",
94			sbuf);
95			octerror(WARNING, errmsg);
96			}
97			while (getobj() != OVOID)
98			;
99	greg	1.13	} else if (load & IO_SCENE) { /* consistency checks */
100			/* check object count */
101			if (nobjects != objorig+fnobjects)
102			octerror(USER, "bad object count; octree stale?");
103			/* check for non-surfaces */
104			if (nonsurfinset(objorig, fnobjects))
105			octerror(USER, "non-surface in set; octree stale?");
106	greg	1.1	}
107			}
108			fclose(infp);
109			return(nf);
110			}
111
112
113			static char *
114			getstr(s) /* get null-terminated string */
115			char *s;
116			{
117			register char *cp;
118			register int c;
119
120			cp = s;
121			while ((c = getc(infp)) != EOF)
122			if ((*cp++ = c) == '\0')
123			return(s);
124
125			octerror(USER, "truncated octree");
126			}
127
128
129			static OCTREE
130			getfullnode() /* get a set, return fullnode */
131			{
132			OBJECT set[MAXSET+1];
133			register int i;
134
135			set[0] = getint(sizeof(OBJECT));
136			if (set[0] > MAXSET)
137			octerror(USER, "bad set in getfullnode");
138			for (i = 1; i <= set[0]; i++)
139			set[i] = getint(sizeof(OBJECT)) + objorig;
140			return(fullnode(set));
141			}
142
143
144			static long
145	greg	1.3	getint(siz) /* get a siz-byte integer */
146	greg	1.1	register int siz;
147			{
148			register int c;
149	greg	1.3	register long r;
150	greg	1.1
151	greg	1.6	if ((c = getc(infp)) == EOF)
152			goto end_file;
153			r = 0x80&c ? -1<<8\|c : c; /* sign extend */
154			while (--siz > 0) {
155	greg	1.1	if ((c = getc(infp)) == EOF)
156	greg	1.6	goto end_file;
157	greg	1.1	r <<= 8;
158			r \|= c;
159			}
160			return(r);
161	greg	1.6	end_file:
162			octerror(USER, "truncated octree");
163	greg	1.1	}
164
165
166			static double
167			getflt() /* get a floating point number */
168			{
169			extern double ldexp();
170			double d;
171
172	greg	1.3	d = (double)getint(4)/0x7fffffff;
173	greg	1.10	return(ldexp(d, (int)getint(1)));
174	greg	1.1	}
175
176
177			static OCTREE
178			gettree() /* get a pre-ordered octree */
179			{
180			register OCTREE ot;
181			register int i;
182
183			switch (getc(infp)) {
184			case OT_EMPTY:
185			return(EMPTY);
186			case OT_FULL:
187			return(getfullnode());
188			case OT_TREE:
189			if ((ot = octalloc()) == EMPTY)
190			octerror(SYSTEM, "out of tree space in gettree");
191			for (i = 0; i < 8; i++)
192			octkid(ot, i) = gettree();
193			return(ot);
194			case EOF:
195			octerror(USER, "truncated octree");
196			default:
197			octerror(USER, "damaged octree");
198			}
199			}
200
201
202			static
203			getobj() /* get next object */
204			{
205			char sbuf[MAXSTR];
206			int obj;
207			register int i;
208			register OBJREC *objp;
209
210	greg	1.2	i = getint(1);
211	greg	1.3	if (i == -1)
212	greg	1.1	return(OVOID); /* terminator */
213			if ((obj = newobject()) == OVOID)
214			error(SYSTEM, "out of object space");
215			objp = objptr(obj);
216			if ((objp->otype = otypmap[i]) < 0)
217			octerror(USER, "reference to unknown type");
218			if ((objp->omod = getint(sizeof(OBJECT))) != OVOID)
219			objp->omod += objorig;
220			objp->oname = savqstr(getstr(sbuf));
221			if (objp->oargs.nsargs = getint(2)) {
222			objp->oargs.sarg = (char **)bmalloc
223			(objp->oargs.nsargssizeof(char ));
224			if (objp->oargs.sarg == NULL)
225			goto memerr;
226			for (i = 0; i < objp->oargs.nsargs; i++)
227			objp->oargs.sarg[i] = savestr(getstr(sbuf));
228			} else
229			objp->oargs.sarg = NULL;
230			#ifdef IARGS
231			if (objp->oargs.niargs = getint(2)) {
232			objp->oargs.iarg = (long *)bmalloc
233			(objp->oargs.niargs*sizeof(long));
234			if (objp->oargs.iarg == NULL)
235			goto memerr;
236			for (i = 0; i < objp->oargs.niargs; i++)
237	greg	1.3	objp->oargs.iarg[i] = getint(4);
238	greg	1.1	} else
239			objp->oargs.iarg = NULL;
240			#endif
241			if (objp->oargs.nfargs = getint(2)) {
242			objp->oargs.farg = (double *)bmalloc
243			(objp->oargs.nfargs*sizeof(double));
244			if (objp->oargs.farg == NULL)
245			goto memerr;
246			for (i = 0; i < objp->oargs.nfargs; i++)
247			objp->oargs.farg[i] = getflt();
248			} else
249			objp->oargs.farg = NULL;
250			/* initialize */
251			objp->os = NULL;
252			objp->lastrno = -1;
253			/* insert */
254			insertobject(obj);
255			return(obj);
256			memerr:
257			error(SYSTEM, "out of memory in getobj");
258			}
259
260
261			static
262			octerror(etyp, msg) /* octree error */
263			int etyp;
264			char *msg;
265			{
266			char msgbuf[128];
267
268			sprintf(msgbuf, "(%s): %s", infn, msg);
269			error(etyp, msgbuf);
270			}