src/common/face.c

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

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

/*
 *  face.c - routines dealing with polygonal faces.
 *
 *     8/30/85
 */

#include  "standard.h"

#include  "object.h"

#include  "face.h"

/*
 *      A face is given as a list of 3D vertices.  The normal
 *  direction and therefore the surface orientation is determined
 *  by the ordering of the vertices.  Looking in the direction opposite
 *  the normal (at the front of the face), the vertices will be
 *  listed in counter-clockwise order.
 *      There is no checking done to insure that the edges do not cross
 *  one another.  This was considered too expensive and should be unnecessary.
 *  The last vertex is automatically connected to the first.
 */

#ifdef  SMLFLT
#define  VERTEPS        1e-2            /* allowed vertex error */
#else
#define  VERTEPS        1e-4            /* allowed vertex error */
#endif


FACE *
getface(o)                      /* get arguments for a face */
OBJREC  *o;
{
        double  d1;
        int  badvert;
        FVECT  v1, v2, v3;
        register FACE  *f;
        register int  i;

        if ((f = (FACE *)o->os) != NULL)
                return(f);                      /* already done */

        f = (FACE *)malloc(sizeof(FACE));
        if (f == NULL)
                error(SYSTEM, "out of memory in makeface");

        if (o->oargs.nfargs < 9 || o->oargs.nfargs % 3)
                objerror(o, USER, "bad # arguments");

        o->os = (char *)f;                      /* save face */

        f->va = o->oargs.farg;
        f->nv = o->oargs.nfargs / 3;
                                                /* compute area and normal */
        f->norm[0] = f->norm[1] = f->norm[2] = 0.0;
        v1[0] = v1[1] = v1[2] = 0.0;
        for (i = 1; i < f->nv; i++) {
                v2[0] = VERTEX(f,i)[0] - VERTEX(f,0)[0];
                v2[1] = VERTEX(f,i)[1] - VERTEX(f,0)[1];
                v2[2] = VERTEX(f,i)[2] - VERTEX(f,0)[2];
                fcross(v3, v1, v2);
                f->norm[0] += v3[0];
                f->norm[1] += v3[1];
                f->norm[2] += v3[2];
                VCOPY(v1, v2);
        }
        f->area = normalize(f->norm);
        if (f->area == 0.0) {
                objerror(o, WARNING, "zero area");      /* used to be fatal */
                f->offset = 0.0;
                f->ax = 0;
                return(f);
        }
        f->area *= 0.5;
                                                /* compute offset */
        badvert = 0;
        f->offset = DOT(f->norm, VERTEX(f,0));
        for (i = 1; i < f->nv; i++) {
                d1 = DOT(f->norm, VERTEX(f,i));
                badvert += fabs(d1 - f->offset/i) > VERTEPS;
                f->offset += d1;
        }
        f->offset /= (double)f->nv;
        if (badvert)
                objerror(o, WARNING, "non-planar vertex");
                                                /* find axis */
        f->ax = fabs(f->norm[0]) > fabs(f->norm[1]) ? 0 : 1;
        if (fabs(f->norm[2]) > fabs(f->norm[f->ax]))
                f->ax = 2;

        return(f);
}


freeface(o)                     /* free memory associated with face */
OBJREC  *o;
{
        if (o->os == NULL)
                return;
        free(o->os);
        o->os = NULL;
}


inface(p, f)                    /* determine if point is in face */
FVECT  p;
FACE  *f;
{
        int  ncross, n;
        double  x, y;
        register int  xi, yi;
        register FLOAT  *p0, *p1;

        xi = (f->ax+1)%3;
        yi = (f->ax+2)%3;
        x = p[xi];
        y = p[yi];
        n = f->nv;
        p0 = f->va + 3*(n-1);           /* connect last to first */
        p1 = f->va;
        ncross = 0;
                                        /* positive x axis cross test */
        while (n--) {
                if ((p0[yi] > y) ^ (p1[yi] > y))
                        if (p0[xi] > x && p1[xi] > x)
                                ncross++;
                        else if (p0[xi] > x || p1[xi] > x)
                                ncross += (p1[yi] > p0[yi]) ^
                                                ((p0[yi]-y)*(p1[xi]-x) >
                                                (p0[xi]-x)*(p1[yi]-y));
                p0 = p1;
                p1 += 3;
        }
        return(ncross & 01);
}
Revision:	2.3
Committed:	Fri May 14 13:42:53 1993 UTC (30 years, 11 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.2:	+4 -0 lines
Log Message:	made vertex error a function of SMLFLT define
#	User	Rev	Content
1	greg	1.5	/* 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			* face.c - routines dealing with polygonal faces.
9			*
10			* 8/30/85
11			*/
12
13			#include "standard.h"
14
15			#include "object.h"
16
17			#include "face.h"
18
19			/*
20			* A face is given as a list of 3D vertices. The normal
21			* direction and therefore the surface orientation is determined
22			* by the ordering of the vertices. Looking in the direction opposite
23			* the normal (at the front of the face), the vertices will be
24			* listed in counter-clockwise order.
25			* There is no checking done to insure that the edges do not cross
26			* one another. This was considered too expensive and should be unnecessary.
27			* The last vertex is automatically connected to the first.
28			*/
29
30	greg	2.3	#ifdef SMLFLT
31			#define VERTEPS 1e-2 /* allowed vertex error */
32			#else
33	greg	1.1	#define VERTEPS 1e-4 /* allowed vertex error */
34	greg	2.3	#endif
35	greg	1.1
36
37			FACE *
38			getface(o) /* get arguments for a face */
39			OBJREC *o;
40			{
41			double d1;
42			int badvert;
43			FVECT v1, v2, v3;
44			register FACE *f;
45			register int i;
46
47			if ((f = (FACE *)o->os) != NULL)
48			return(f); /* already done */
49
50			f = (FACE *)malloc(sizeof(FACE));
51			if (f == NULL)
52			error(SYSTEM, "out of memory in makeface");
53
54			if (o->oargs.nfargs < 9 \|\| o->oargs.nfargs % 3)
55			objerror(o, USER, "bad # arguments");
56
57	greg	1.3	o->os = (char )f; / save face */
58
59	greg	1.1	f->va = o->oargs.farg;
60			f->nv = o->oargs.nfargs / 3;
61			/* compute area and normal */
62			f->norm[0] = f->norm[1] = f->norm[2] = 0.0;
63			v1[0] = v1[1] = v1[2] = 0.0;
64			for (i = 1; i < f->nv; i++) {
65			v2[0] = VERTEX(f,i)[0] - VERTEX(f,0)[0];
66			v2[1] = VERTEX(f,i)[1] - VERTEX(f,0)[1];
67			v2[2] = VERTEX(f,i)[2] - VERTEX(f,0)[2];
68			fcross(v3, v1, v2);
69			f->norm[0] += v3[0];
70			f->norm[1] += v3[1];
71			f->norm[2] += v3[2];
72			VCOPY(v1, v2);
73			}
74			f->area = normalize(f->norm);
75			if (f->area == 0.0) {
76			objerror(o, WARNING, "zero area"); /* used to be fatal */
77	greg	1.2	f->offset = 0.0;
78	greg	1.1	f->ax = 0;
79			return(f);
80			}
81			f->area *= 0.5;
82	greg	1.2	/* compute offset */
83	greg	1.1	badvert = 0;
84	greg	1.2	f->offset = DOT(f->norm, VERTEX(f,0));
85	greg	1.1	for (i = 1; i < f->nv; i++) {
86			d1 = DOT(f->norm, VERTEX(f,i));
87	greg	1.2	badvert += fabs(d1 - f->offset/i) > VERTEPS;
88			f->offset += d1;
89	greg	1.1	}
90	greg	1.5	f->offset /= (double)f->nv;
91	greg	1.1	if (badvert)
92			objerror(o, WARNING, "non-planar vertex");
93			/* find axis */
94			f->ax = fabs(f->norm[0]) > fabs(f->norm[1]) ? 0 : 1;
95			if (fabs(f->norm[2]) > fabs(f->norm[f->ax]))
96			f->ax = 2;
97
98			return(f);
99			}
100
101
102			freeface(o) /* free memory associated with face */
103			OBJREC *o;
104			{
105	greg	1.4	if (o->os == NULL)
106			return;
107	greg	1.1	free(o->os);
108			o->os = NULL;
109			}
110
111
112			inface(p, f) /* determine if point is in face */
113			FVECT p;
114			FACE *f;
115			{
116			int ncross, n;
117			double x, y;
118			register int xi, yi;
119	greg	1.6	register FLOAT p0, p1;
120	greg	1.1
121			xi = (f->ax+1)%3;
122			yi = (f->ax+2)%3;
123			x = p[xi];
124			y = p[yi];
125			n = f->nv;
126			p0 = f->va + 3(n-1); / connect last to first */
127			p1 = f->va;
128			ncross = 0;
129			/* positive x axis cross test */
130			while (n--) {
131			if ((p0[yi] > y) ^ (p1[yi] > y))
132			if (p0[xi] > x && p1[xi] > x)
133			ncross++;
134			else if (p0[xi] > x \|\| p1[xi] > x)
135			ncross += (p1[yi] > p0[yi]) ^
136			((p0[yi]-y)*(p1[xi]-x) >
137			(p0[xi]-x)*(p1[yi]-y));
138			p0 = p1;
139			p1 += 3;
140			}
141			return(ncross & 01);
142			}