/**
* Read a polygon file and convert it to an NMG shell
*
* A polygon file consists of the following:
*
* The first line consists of two integer numbers: the number of
* points (vertices) in the file, followed by the number of polygons
* in the file. This line is followed by lines for each of the
* vertices. Each vertex is listed on its own line, as the 3tuple "X
* Y Z". After the list of vertices comes the list of polygons.
* each polygon is represented by a line containing 1) the number of
* vertices in the polygon, followed by 2) the indices of the
* vertices that make up the polygon.
*
* Implicitly returns r->s_p which is a new shell containing all the
* faces from the polygon file.
*
* XXX This is a horrible way to do this. Lee violates his own rules
* about not creating fundamental structures on his own... :-)
* Retired in favor of more modern tessellation strategies.
*/
struct shell *
nmg_polytonmg(FILE *fp, struct nmgregion *r, const struct bn_tol *tol)
{
int i, j, num_pts, num_facets, pts_this_face, facet;
int vl_len;
struct vertex **v; /* list of all vertices */
struct vertex **vl; /* list of vertices for this polygon*/
point_t p;
struct shell *s;
struct faceuse *fu;
struct loopuse *lu;
struct edgeuse *eu;
plane_t plane;
struct model *m;
s = nmg_msv(r);
m = s->r_p->m_p;
nmg_kvu(s->vu_p);
/* get number of points & number of facets in file */
if (fscanf(fp, "%d %d", &num_pts, &num_facets) != 2)
bu_bomb("polytonmg() Error in first line of poly file\n");
else
if (RTG.NMG_debug & DEBUG_POLYTO)
bu_log("points: %d facets: %d\n",
num_pts, num_facets);
v = (struct vertex **) bu_calloc(num_pts, sizeof (struct vertex *),
"vertices");
/* build the vertices */
for (i = 0; i < num_pts; ++i) {
GET_VERTEX(v[i], m);
v[i]->magic = NMG_VERTEX_MAGIC;
}
/* read in the coordinates of the vertices */
for (i=0; i < num_pts; ++i) {
if (fscanf(fp, "%lg %lg %lg", &p[0], &p[1], &p[2]) != 3)
bu_bomb("polytonmg() Error reading point");
else
if (RTG.NMG_debug & DEBUG_POLYTO)
bu_log("read vertex #%d (%g %g %g)\n",
i, p[0], p[1], p[2]);
nmg_vertex_gv(v[i], p);
}
vl = (struct vertex **)bu_calloc(vl_len=8, sizeof (struct vertex *),
"vertex parameter list");
for (facet = 0; facet < num_facets; ++facet) {
if (fscanf(fp, "%d", &pts_this_face) != 1)
bu_bomb("polytonmg() error getting pt count for this face");
if (RTG.NMG_debug & DEBUG_POLYTO)
bu_log("facet %d pts in face %d\n",
facet, pts_this_face);
if (pts_this_face > vl_len) {
while (vl_len < pts_this_face) vl_len *= 2;
vl = (struct vertex **)bu_realloc((char *)vl,
vl_len*sizeof(struct vertex *),
"vertex parameter list (realloc)");
}
for (i=0; i < pts_this_face; ++i) {
if (fscanf(fp, "%d", &j) != 1)
bu_bomb("polytonmg() error getting point index for v in f");
vl[i] = v[j-1];
}
fu = nmg_cface(s, vl, pts_this_face);
lu = BU_LIST_FIRST(loopuse, &fu->lu_hd);
/* XXX should check for vertex-loop */
eu = BU_LIST_FIRST(edgeuse, &lu->down_hd);
NMG_CK_EDGEUSE(eu);
if (bn_mk_plane_3pts(plane, eu->vu_p->v_p->vg_p->coord,
BU_LIST_PNEXT(edgeuse, eu)->vu_p->v_p->vg_p->coord,
BU_LIST_PLAST(edgeuse, eu)->vu_p->v_p->vg_p->coord,
tol)) {
bu_log("At %d in %s\n", __LINE__, __FILE__);
bu_bomb("polytonmg() cannot make plane equation\n");
} else nmg_face_g(fu, plane);
}
for (i=0; i < num_pts; ++i) {
if (BU_LIST_IS_EMPTY(&v[i]->vu_hd)) continue;
FREE_VERTEX(v[i]);
}
bu_free((char *)v, "vertex array");
return s;
}
/* IEEE patch number of the Bi-Cubic Bezier patch and convert it
* to a B-Spline surface (Bezier surfaces are a subset of B-spline surfaces
* and output it to a BRL-CAD binary format.
*/
void
dump_patch(int (*patch)[4])
{
struct vertex *verts[4];
struct faceuse *fu;
struct loopuse *lu;
struct edgeuse *eu;
int i, j, pt_type;
fastf_t *mesh=NULL;
fastf_t *ukv=NULL;
fastf_t *vkv=NULL;
/* U and V parametric Direction Spline parameters
* Cubic = order 4,
* knot size is Control point + order = 8
* control point size is 4
* point size is 3
*/
for ( i=0; i<4; i++ )
verts[i] = (struct vertex *)NULL;
fu = nmg_cface( s, verts, 4 );
NMG_CK_FACEUSE( fu );
for ( i=0; i<4; i++ )
{
struct vertexuse *vu;
vect_t uvw;
point_t pnt;
int k, j;
switch ( i )
{
default:
case 0:
VSET( uvw, 0.0, 0.0, 0.0 );
k = 0;
j = 0;
break;
case 1:
VSET( uvw, 1.0, 0.0, 0.0 );
k = 0;
j = 3;
break;
case 2:
VSET( uvw, 1.0, 1.0, 0.0 );
k = 3;
j = 3;
break;
case 3:
VSET( uvw, 0.0, 1.0, 0.0 );
k = 3;
j = 0;
break;
}
VSET( pnt ,
ducks[patch[k][j]-1].x * 1000 ,
ducks[patch[k][j]-1].y * 1000 ,
ducks[patch[k][j]-1].z * 1000 );
nmg_vertex_gv( verts[i], pnt );
for ( BU_LIST_FOR( vu, vertexuse, &verts[i]->vu_hd ) )
nmg_vertexuse_a_cnurb( vu, uvw );
}
pt_type = RT_NURB_MAKE_PT_TYPE(3, RT_NURB_PT_XYZ, 0); /* see nurb.h for details */
nmg_face_g_snurb( fu, 4, 4, 8, 8, ukv, vkv, 4, 4, pt_type, mesh );
NMG_CK_FACE( fu->f_p );
NMG_CK_FACE_G_SNURB( fu->f_p->g.snurb_p );
mesh = fu->f_p->g.snurb_p->ctl_points;
/* Copy the control points */
for ( i = 0; i< 4; i++)
for ( j = 0; j < 4; j++)
{
*mesh = ducks[patch[i][j]-1].x * 1000;
*(mesh+1) = ducks[patch[i][j]-1].y * 1000;
*(mesh+2) = ducks[patch[i][j]-1].z * 1000;
mesh += 3;
}
/* Both u and v knot vectors are [ 0 0 0 0 1 1 1 1] */
ukv = fu->f_p->g.snurb_p->u.knots;
vkv = fu->f_p->g.snurb_p->v.knots;
/* set the knot vectors */
for ( i=0; i<4; i++ )
{
*(ukv+i) = 0.0;
*(vkv+i) = 0.0;
}
for ( i=0; i<4; i++ )
{
*(ukv+4+i) = 1.0;
*(vkv+4+i) = 1.0;
}
/* set eu geometry */
pt_type = RT_NURB_MAKE_PT_TYPE(2, RT_NURB_PT_UV, 0); /* see nurb.h for details */
lu = BU_LIST_FIRST( loopuse, &fu->lu_hd );
NMG_CK_LOOPUSE( lu );
for ( BU_LIST_FOR( eu, edgeuse, &lu->down_hd ) )
{
#if 0
nmg_edge_g_cnurb( eu, 2, 0, (fastf_t *)NULL, 2 ,
pt_type, (fastf_t *)NULL );
#else
nmg_edge_g_cnurb_plinear( eu );
#endif
}
nmg_face_bb( fu->f_p, &tol );
}
/**
* R T _ P G _ T E S S
*/
int
rt_pg_tess(struct nmgregion **r, struct model *m, struct rt_db_internal *ip, const struct rt_tess_tol *UNUSED(ttol), const struct bn_tol *tol)
{
size_t i;
struct shell *s;
struct vertex **verts; /* dynamic array of pointers */
struct vertex ***vertp;/* dynamic array of ptrs to pointers */
struct faceuse *fu;
size_t p; /* current polygon number */
struct rt_pg_internal *pgp;
RT_CK_DB_INTERNAL(ip);
pgp = (struct rt_pg_internal *)ip->idb_ptr;
RT_PG_CK_MAGIC(pgp);
*r = nmg_mrsv(m); /* Make region, empty shell, vertex */
s = BU_LIST_FIRST(shell, &(*r)->s_hd);
verts = (struct vertex **)bu_malloc(
pgp->max_npts * sizeof(struct vertex *), "pg_tess verts[]");
vertp = (struct vertex ***)bu_malloc(
pgp->max_npts * sizeof(struct vertex **), "pg_tess vertp[]");
for (i=0; i < pgp->max_npts; i++)
vertp[i] = &verts[i];
for (p = 0; p < pgp->npoly; p++) {
struct rt_pg_face_internal *pp;
pp = &pgp->poly[p];
/* Locate these points, if previously mentioned */
for (i=0; i < pp->npts; i++) {
verts[i] = nmg_find_pt_in_shell(s,
&pp->verts[3*i], tol);
}
/* Construct the face. Verts should be in CCW order */
if ((fu = nmg_cmface(s, vertp, pp->npts)) == (struct faceuse *)0) {
bu_log("rt_pg_tess() nmg_cmface failed, skipping face %zu\n",
p);
}
/* Associate vertex geometry, where none existed before */
for (i=0; i < pp->npts; i++) {
if (verts[i]->vg_p) continue;
nmg_vertex_gv(verts[i], &pp->verts[3*i]);
}
/* Associate face geometry */
if (nmg_calc_face_g(fu)) {
nmg_pr_fu_briefly(fu, "");
bu_free((char *)verts, "pg_tess verts[]");
bu_free((char *)vertp, "pg_tess vertp[]");
return -1; /* FAIL */
}
}
/* Compute "geometry" for region and shell */
nmg_region_a(*r, tol);
/* Polysolids are often built with incorrect face normals.
* Don't depend on them here.
*/
nmg_fix_normals(s, tol);
bu_free((char *)verts, "pg_tess verts[]");
bu_free((char *)vertp, "pg_tess vertp[]");
return 0; /* OK */
}
int
psurf_to_nmg(struct model *m, FILE *fp, char *jfile)
/* Input/output, nmg model. */
/* Input, pointer to psurf data file. */
/* Name of Jack data base file. */
{
int face, fail, i, lst[MAX_NUM_PTS], nf, nv;
struct faceuse *outfaceuses[MAX_NUM_PTS];
struct nmgregion *r;
struct shell *s;
struct vertex *vertlist[MAX_NUM_PTS];
struct vlist vert;
/* Copied from proc-db/nmgmodel.c */
tol.magic = BN_TOL_MAGIC;
tol.dist = 0.01;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 0.001;
tol.para = 0.999;
face = 0;
r = nmg_mrsv(m); /* Make region, empty shell, vertex. */
s = BU_LIST_FIRST(shell, &r->s_hd);
while ((nv = read_psurf_vertices(fp, &vert)) != 0) {
size_t ret;
while ((nf = read_psurf_face(fp, lst)) != 0) {
/* Make face out of vertices in lst (ccw ordered). */
for (i = 0; i < nf; i++)
vertlist[i] = vert.vt[lst[i]-1];
outfaceuses[face] = nmg_cface(s, vertlist, nf);
face++;
/* Save (possibly) newly created vertex structs. */
for (i = 0; i < nf; i++)
vert.vt[lst[i]-1] = vertlist[i];
}
ret = fscanf(fp, ";;");
if (ret > 0)
bu_log("unknown parsing error\n");
/* Associate the vertex geometry, ccw. */
for (i = 0; i < nv; i++)
if (vert.vt[i])
nmg_vertex_gv(vert.vt[i], &vert.pt[3*i]);
else
fprintf(stderr, "%s, vertex %d is unused\n",
jfile, i+1);
}
nmg_vertex_fuse(&m->magic, &tol);
/* Associate the face geometry. */
for (i = 0, fail = 0; i < face; i++)
{
struct loopuse *lu;
plane_t pl;
lu = BU_LIST_FIRST(loopuse, &outfaceuses[i]->lu_hd);
if (nmg_loop_plane_area(lu, pl) < 0.0)
{
fail = 1;
nmg_kfu(outfaceuses[i]);
}
else
nmg_face_g(outfaceuses[i], pl);
}
if (fail)
return -1;
if (face)
{
int empty_model;
empty_model = nmg_kill_zero_length_edgeuses(m);
if (!empty_model) {
/* Compute "geometry" for region and shell */
nmg_region_a(r, &tol);
nmg_break_e_on_v(&m->magic, &tol);
empty_model = nmg_kill_zero_length_edgeuses(m);
/* Glue edges of outward pointing face uses together. */
if (!empty_model) nmg_edge_fuse(&m->magic, &tol);
}
}
return 0;
}
/*
* Convert an ascii description of an nmg to an actual nmg.
* (This should be done with lex and yacc.)
*/
static void
descr_to_nmg(struct shell *s, FILE *fp, fastf_t *Ext)
/* NMG shell to add loops to. */
/* File pointer for ascii nmg file. */
/* Extrusion vector. */
{
#define MAXV 10000
char token[80] = {0}; /* Token read from ascii nmg file. */
double x, y, z; /* Coordinates of a vertex. */
int dir = OT_NONE; /* Direction of face. */
int i,
lu_verts[MAXV] = {0}, /* Vertex names making up loop. */
n, /* Number of vertices so far in loop. */
status, /* Set to EOF when finished ascii file. */
vert_num; /* Current vertex in ascii file. */
fastf_t pts[3*MAXV] = {(fastf_t)0}; /* Points in current loop. */
struct faceuse *fu; /* Face created. */
struct vertex *cur_loop[MAXV], /* Vertices in current loop. */
*verts[MAXV]; /* Vertices in all loops. */
n = 0; /* No vertices read in yet. */
fu = NULL; /* Face to be created elsewhere. */
for (i = 0; i < MAXV; i++) {
cur_loop[i] = NULL;
verts[i] = NULL;
}
status = fscanf(fp, "%80s", token); /* Get 1st token. */
do {
switch (token[0]) {
case 'e': /* Extrude face. */
status = fscanf(fp, "%80s", token);
switch (token[0]) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '.':
case '+':
case '-':
/* Get x value of vector. */
x = atof(token);
if (fscanf(fp, "%lf%lf", &y, &z) != 2)
bu_exit(EXIT_FAILURE, "descr_to_nmg: messed up vector\n");
VSET(Ext, x, y, z);
/* Get token for next trip through loop. */
status = fscanf(fp, "%80s", token);
break;
}
break;
case 'l': /* Start new loop. */
/* Make a loop with vertices previous to this 'l'. */
if (n) {
for (i = 0; i < n; i++)
if (lu_verts[i] >= 0)
cur_loop[i] = verts[lu_verts[i]];
else /* Reuse of a vertex. */
cur_loop[i] = NULL;
fu = nmg_add_loop_to_face(s, fu, cur_loop, n,
dir);
/* Associate geometry with vertices. */
for (i = 0; i < n; i++) {
if (lu_verts[i] >= 0 && !verts[lu_verts[i]]) {
nmg_vertex_gv( cur_loop[i],
&pts[3*lu_verts[i]]);
verts[lu_verts[i]] =
cur_loop[i];
}
}
/* Take care of reused vertices. */
for (i = 0; i < n; i++)
if (lu_verts[i] < 0)
nmg_jv(verts[-lu_verts[i]], cur_loop[i]);
n = 0;
}
status = fscanf(fp, "%80s", token);
switch (token[0]) {
case 'h': /* Is it cw or ccw? */
if (BU_STR_EQUAL(token, "hole"))
dir = OT_OPPOSITE;
else
bu_exit(EXIT_FAILURE, "descr_to_nmg: expected \"hole\"\n");
/* Get token for next trip through loop. */
status = fscanf(fp, "%80s", token);
break;
default:
dir = OT_SAME;
break;
}
break;
case 'v': /* Vertex in current loop. */
if (token[1] == '\0')
bu_exit(EXIT_FAILURE, "descr_to_nmg: vertices must be numbered.\n");
vert_num = atoi(token+1);
if (vert_num < 0 || vert_num >= MAXV) {
bu_log("Vertex number out of bounds: %d\nAborting\n", vert_num);
return;
}
status = fscanf(fp, "%80s", token);
switch (token[0]) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '.':
case '+':
case '-':
/* Get coordinates of vertex. */
x = atof(token);
if (fscanf(fp, "%lf%lf", &y, &z) != 2)
bu_exit(EXIT_FAILURE, "descr_to_nmg: messed up vertex\n");
/* Save vertex with others in current loop. */
pts[3*vert_num] = x;
pts[3*vert_num+1] = y;
pts[3*vert_num+2] = z;
/* Save vertex number. */
lu_verts[n] = vert_num;
if (++n > MAXV)
bu_exit(EXIT_FAILURE, "descr_to_nmg: too many points in loop\n");
/* Get token for next trip through loop. */
status = fscanf(fp, "%80s", token);
break;
default:
/* Use negative vert number to mark vertex as being reused. */
lu_verts[n] = -vert_num;
if (++n > MAXV)
bu_exit(EXIT_FAILURE, "descr_to_nmg: too many points in loop\n");
break;
}
break;
default:
bu_exit(1, "descr_to_nmg: unexpected token \"%s\"\n", token);
break;
}
} while (status != EOF);
/* Make a loop with vertices previous to this 'l'. */
if (n) {
for (i = 0; i < n; i++)
if (lu_verts[i] >= 0)
cur_loop[i] = verts[lu_verts[i]];
else /* Reuse of a vertex. */
cur_loop[i] = NULL;
nmg_add_loop_to_face(s, fu, cur_loop, n, dir);
/* Associate geometry with vertices. */
for (i = 0; i < n; i++) {
if (lu_verts[i] >= 0 && !verts[lu_verts[i]]) {
nmg_vertex_gv( cur_loop[i],
&pts[3*lu_verts[i]]);
verts[lu_verts[i]] =
cur_loop[i];
}
}
/* Take care of reused vertices. */
for (i = 0; i < n; i++)
if (lu_verts[i] < 0)
nmg_jv(verts[-lu_verts[i]], cur_loop[i]);
n = 0;
}
}
int
extrude(int entityno)
{
fastf_t length; /* extrusion length */
vect_t edir; /* a unit vector (direction of extrusion */
vect_t evect; /* Scaled vector for extrusion */
int sol_num; /* IGES solid type number */
int curve; /* pointer to directory entry for base curve */
struct ptlist *curv_pts; /* List of points along curve */
int i;
/* Default values */
VSET(edir, 0.0, 0.0, 1.0);
/* Acquiring Data */
if (dir[entityno]->param <= pstart) {
bu_log("Illegal parameter pointer for entity D%07d (%s)\n" ,
dir[entityno]->direct, dir[entityno]->name);
return 0;
}
Readrec(dir[entityno]->param);
Readint(&sol_num, "");
/* Read pointer to directory entry for curve to be extruded */
Readint(&curve, "");
/* Convert this to a "dir" index */
curve = (curve-1)/2;
Readcnv(&length, "");
Readflt(&edir[X], "");
Readflt(&edir[Y], "");
Readflt(&edir[Z], "");
if (length <= 0.0) {
bu_log("Illegal parameters for entity D%07d (%s)\n" ,
dir[entityno]->direct, dir[entityno]->name);
return 0;
}
/*
* Unitize direction vector
*/
VUNITIZE(edir);
/* Scale vector */
VSCALE(evect, edir, length);
/* Switch based on type of curve to be extruded */
switch (dir[curve]->type) {
case 100: /* circular arc */
return Extrudcirc(entityno, curve, evect);
case 104: /* conic arc */
return Extrudcon(entityno, curve, evect);
case 102: /* composite curve */
case 106: /* copius data */
case 112: /* parametric spline */
case 126: {
/* B-spline */
int npts;
struct model *m;
struct nmgregion *r;
struct shell *s;
struct faceuse *fu;
struct loopuse *lu;
struct edgeuse *eu;
struct ptlist *pt_ptr;
npts = Getcurve(curve, &curv_pts);
if (npts < 3)
return 0;
m = nmg_mm();
r = nmg_mrsv(m);
s = BU_LIST_FIRST(shell, &r->s_hd);
fu = nmg_cface(s, (struct vertex **)NULL, npts-1);
pt_ptr = curv_pts;
lu = BU_LIST_FIRST(loopuse, &fu->lu_hd);
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
struct vertex *v;
v = eu->vu_p->v_p;
nmg_vertex_gv(v, pt_ptr->pt);
pt_ptr = pt_ptr->next;
}
if (nmg_calc_face_g(fu)) {
bu_log("Extrude: Failed to calculate face geometry\n");
nmg_km(m);
bu_free((char *)curv_pts, "curve_pts");
return 0;
}
if (nmg_extrude_face(fu, evect, &tol)) {
bu_log("Extrude: extrusion failed\n");
nmg_km(m);
bu_free((char *)curv_pts, "curve_pts");
return 0;
}
mk_bot_from_nmg(fdout, dir[entityno]->name, s);
nmg_km(m);
bu_free((char *)curv_pts, "curve_pts");
return 1;
}
default:
i = (-1);
while (dir[curve]->type != typecount[++i].type && i < ntypes);
bu_log("Extrusions of %s are not allowed\n", typecount[i].name);
break;
}
return 0;
}
int read_faces(struct model *m, FILE *fgeom)
{
int nverts, nfaces, nedges;
int i, j, fail=0;
fastf_t *pts;
struct vertex **verts;
struct faceuse **outfaceuses;
struct nmgregion *r;
struct shell *s;
size_t ret;
/* Get numbers of vertices and faces, and grab the appropriate amount of memory */
if (fscanf(fgeom, "%d %d %d", &nverts, &nfaces, &nedges) != 3)
bu_exit(1, "Cannot read number of vertices, faces, edges.\n");
pts = (fastf_t *) bu_malloc(sizeof(fastf_t) * 3 * nverts, "points list");
verts = (struct vertex **) bu_malloc(sizeof(struct vertex *) * nverts, "vertices");
outfaceuses = (struct faceuse **) bu_malloc(sizeof(struct faceuse *) * nfaces, "faceuses");
/* Read in vertex geometry, store in geometry list */
for (i = 0; i < nverts; i++) {
double scan[3];
if (fscanf(fgeom, "%lf %lf %lf", &scan[0], &scan[1], &scan[2]) != 3) {
bu_exit(1, "Not enough data points in geometry file.\n");
}
pts[3*i] = scan[0];
pts[3*i+1] = scan[1];
pts[3*i+2] = scan[2];
verts[i] = (struct vertex *) 0;
ret = fscanf(fgeom, "%*[^\n]");
if (ret > 0)
bu_log("unknown parsing error\n");
}
r = nmg_mrsv(m); /* Make region, empty shell, vertex. */
s = BU_LIST_FIRST(shell, &r->s_hd);
for (i = 0; i < nfaces; i++) {
/* Read in each of the faces */
struct vertex **vlist;
int *pinds;
if (fscanf(fgeom, "%d", &nedges) != 1) {
bu_exit(1, "Not enough faces in geometry file.\n");
}
/* Grab memory for list for this face. */
vlist = (struct vertex **) bu_malloc(sizeof(struct vertex *) * nedges, "vertex list");
pinds = (int *) bu_malloc(sizeof(int) * nedges, "point indices");
for (j = 0; j < nedges; j++) {
/* Read list of point indices. */
if (fscanf(fgeom, "%d", &pinds[j]) != 1) {
bu_exit(1, "Not enough points on face.\n");
}
vlist[j] = verts[pinds[j]-1];
}
outfaceuses[i] = nmg_cface(s, vlist, nedges); /* Create face. */
NMG_CK_FACEUSE(outfaceuses[i]);
for (j = 0; j < nedges; j++) /* Save (possibly) newly created vertex structs. */
verts[pinds[j]-1] = vlist[j];
ret = fscanf(fgeom, "%*[^\n]");
if (ret > 0)
bu_log("unknown parsing error\n");
bu_free((char *)vlist, "vertext list");
bu_free((char *)pinds, "point indices");
}
for (i = 0; i < nverts; i++)
if (verts[i] != 0)
nmg_vertex_gv(verts[i], &pts[3*i]);
else
fprintf(stderr, "Warning: vertex %d unused.\n", i+1);
for (i = 0; i < nfaces; i++) {
plane_t pl;
fprintf(stderr, "planeeqning face %d.\n", i);
if ( nmg_loop_plane_area( BU_LIST_FIRST( loopuse, &outfaceuses[i]->lu_hd ), pl ) < 0.0 )
fail = 1;
else
nmg_face_g( outfaceuses[i], pl );
}
if (fail) return -1;
nmg_gluefaces(outfaceuses, nfaces, &tol);
nmg_region_a(r, &tol);
bu_free((char *)pts, "points list");
return 0;
}
HIDDEN void
get_ctria3(void)
{
int pid;
int g1, g2, g3;
int gin1, gin2, gin3;
point_t pt1, pt2, pt3;
struct vertex **v[3];
struct faceuse *fu;
struct shell *s;
struct pshell *psh;
int pid_index=0;
pid = atoi(curr_rec[2]);
pid_index = get_pid_index(pid);
g1 = atoi(curr_rec[3]);
g2 = atoi(curr_rec[4]);
g3 = atoi(curr_rec[5]);
gin1 = get_gridi(g1);
gin2 = get_gridi(g2);
gin3 = get_gridi(g3);
v[0] = &g_pts[gin1].v[pid_index];
v[1] = &g_pts[gin2].v[pid_index];
v[2] = &g_pts[gin3].v[pid_index];
VSCALE(pt1, g_pts[gin1].pt, conv[units]);
VSCALE(pt2, g_pts[gin2].pt, conv[units]);
VSCALE(pt3, g_pts[gin3].pt, conv[units]);
if (!nmg_model && !pid) {
struct nmgregion *r;
nmg_model = nmg_mm();
r = nmg_mrsv(nmg_model);
nmg_shell = BU_LIST_FIRST(shell, &r->s_hd);
}
if (!pid)
s = nmg_shell;
else {
int found=0;
/* find pshell entry for this pid */
for (BU_LIST_FOR(psh, pshell, &pshell_head.l)) {
if (psh->pid == pid) {
found = 1;
break;
}
}
if (!found) {
bu_log("Cannot find PSHELL entry for a CTRIA3 element (ignoring)!\n");
write_fields();
return;
}
if (psh->s)
s = psh->s;
else {
struct model *m;
struct nmgregion *r;
m = nmg_mm();
r = nmg_mrsv(m);
s = BU_LIST_FIRST(shell, &r->s_hd);
psh->s = s;
}
}
fu = nmg_cmface(s, v, 3);
if (!g_pts[gin1].v[pid_index]->vg_p)
nmg_vertex_gv(g_pts[gin1].v[pid_index], pt1);
if (!g_pts[gin2].v[pid_index]->vg_p)
nmg_vertex_gv(g_pts[gin2].v[pid_index], pt2);
if (!g_pts[gin3].v[pid_index]->vg_p)
nmg_vertex_gv(g_pts[gin3].v[pid_index], pt3);
nmg_calc_face_g(fu);
}
struct faceuse *
Make_planar_face(struct shell *s, int entityno, int face_orient)
{
int sol_num; /* IGES solid type number */
int no_of_edges; /* edge count for this loop */
int no_of_param_curves;
int vert_count = 0; /* Actual number of vertices used to make face */
struct iges_edge_use *edge_list; /* list of edgeuses from iges loop entity */
struct faceuse *fu = NULL; /* NMG face use */
struct loopuse *lu; /* NMG loop use */
struct vertex ***verts; /* list of vertices */
struct iges_vertex_list *v_list;
int done;
int i, j, k;
/* Acquiring Data */
if (dir[entityno]->param <= pstart) {
bu_log("Illegal parameter pointer for entity D%07d (%s)\n" ,
dir[entityno]->direct, dir[entityno]->name);
return 0;
}
Readrec(dir[entityno]->param);
Readint(&sol_num, "");
if (sol_num != 508) {
bu_exit(1, "ERROR: Entity #%d is not a loop (it's a %s)\n", entityno, iges_type(sol_num));
}
Readint(&no_of_edges, "");
edge_list = (struct iges_edge_use *)bu_calloc(no_of_edges, sizeof(struct iges_edge_use) ,
"Make_face (edge_list)");
for (i = 0; i < no_of_edges; i++) {
Readint(&edge_list[i].edge_is_vertex, "");
Readint(&edge_list[i].edge_de, "");
Readint(&edge_list[i].index, "");
Readint(&edge_list[i].orient, "");
if (!face_orient) {
/* need opposite orientation of edge */
if (edge_list[i].orient)
edge_list[i].orient = 0;
else
edge_list[i].orient = 1;
}
edge_list[i].root = (struct iges_param_curve *)NULL;
Readint(&no_of_param_curves, "");
for (j = 0; j < no_of_param_curves; j++) {
struct iges_param_curve *new_crv;
struct iges_param_curve *crv;
Readint(&k, ""); /* ignore iso-parametric flag */
BU_ALLOC(new_crv, struct iges_param_curve);
if (edge_list[i].root == (struct iges_param_curve *)NULL)
edge_list[i].root = new_crv;
else {
crv = edge_list[i].root;
while (crv->next != (struct iges_param_curve *)NULL)
crv = crv->next;
crv->next = new_crv;
}
Readint(&new_crv->curve_de, "");
new_crv->next = (struct iges_param_curve *)NULL;
}
}
verts = (struct vertex ***)bu_calloc(no_of_edges, sizeof(struct vertex **) ,
"Make_face: vertex_list **");
for (i = 0; i < no_of_edges; i++) {
if (face_orient)
verts[i] = Get_vertex(&edge_list[i]);
else
verts[no_of_edges-1-i] = Get_vertex(&edge_list[i]);
}
/* eliminate zero length edges */
vert_count = no_of_edges;
done = 0;
while (!done) {
done = 1;
for (i = 0; i < vert_count; i++) {
k = i + 1;
if (k == vert_count)
k = 0;
if (verts[i] == verts[k]) {
bu_log("Ignoring zero length edge\n");
done = 0;
vert_count--;
for (j = i; j < vert_count; j++)
verts[j] = verts[j+1];
}
}
}
if (vert_count) {
plane_t pl; /* Plane equation for face */
fastf_t area; /* area of loop */
fastf_t dist;
vect_t min2max;
point_t outside_pt;
fu = nmg_cmface(s, verts, vert_count);
/* associate geometry */
v_list = vertex_root;
while (v_list != NULL) {
for (i = 0; i < v_list->no_of_verts; i++) {
if (v_list->i_verts[i].v != NULL && v_list->i_verts[i].v->vg_p == NULL) {
NMG_CK_VERTEX(v_list->i_verts[i].v);
nmg_vertex_gv(v_list->i_verts[i].v ,
v_list->i_verts[i].pt);
}
}
v_list = v_list->next;
}
lu = BU_LIST_FIRST(loopuse, &fu->lu_hd);
NMG_CK_LOOPUSE(lu);
area = nmg_loop_plane_area(lu, pl);
if (area < 0.0) {
bu_log("Could not calculate area for face (entityno = %d)\n", entityno);
nmg_pr_fu_briefly(fu, "");
nmg_kfu(fu);
fu = (struct faceuse *)NULL;
goto err;
}
nmg_face_g(fu, pl);
nmg_face_bb(fu->f_p, &tol);
/* find a point that is surely outside the loop */
VSUB2(min2max, fu->f_p->max_pt, fu->f_p->min_pt);
VADD2(outside_pt, fu->f_p->max_pt, min2max);
/* move it to the plane of the face */
dist = DIST_PT_PLANE(outside_pt, pl);
VJOIN1(outside_pt, outside_pt, -dist, pl);
if (nmg_class_pt_lu_except(outside_pt, lu, (struct edge *)NULL, &tol) != NMG_CLASS_AoutB) {
nmg_reverse_face(fu);
if (fu->orientation != OT_SAME) {
fu = fu->fumate_p;
if (fu->orientation != OT_SAME)
bu_exit(1, "ERROR: no OT_SAME use for a face!\n");
}
}
} else
bu_log("No edges left!\n");
err:
bu_free((char *)edge_list, "Make_face (edge_list)");
bu_free((char *)verts, "Make_face (vertexlist)");
return fu;
}
/**
* "Tessellate" an ARB into an NMG data structure.
* Purely a mechanical transformation of one faceted object
* into another.
*
* Returns -
* -1 failure
* 0 OK. *r points to nmgregion that holds this tessellation.
*/
int
rt_arbn_tess(struct nmgregion **r, struct model *m, struct rt_db_internal *ip, const struct rt_tess_tol *UNUSED(ttol), const struct bn_tol *tol)
{
struct rt_arbn_internal *aip;
struct shell *s;
struct faceuse **fu; /* array of faceuses */
size_t nverts; /* maximum possible number of vertices = neqn!/(3!(neqn-3)! */
size_t point_count = 0; /* actual number of vertices */
size_t face_count = 0; /* actual number of faces built */
size_t i, j, k, l, n;
struct arbn_pts *pts;
struct arbn_edges *edges; /* A list of edges for each plane eqn (each face) */
size_t *edge_count; /* number of edges for each face */
size_t max_edge_count; /* maximum number of edges for any face */
struct vertex **verts; /* Array of pointers to vertex structs */
struct vertex ***loop_verts; /* Array of pointers to vertex structs to pass to nmg_cmface */
RT_CK_DB_INTERNAL(ip);
aip = (struct rt_arbn_internal *)ip->idb_ptr;
RT_ARBN_CK_MAGIC(aip);
/* Allocate memory for the vertices */
nverts = aip->neqn * (aip->neqn-1) * (aip->neqn-2) / 6;
pts = (struct arbn_pts *)bu_calloc(nverts, sizeof(struct arbn_pts), "rt_arbn_tess: pts");
/* Allocate memory for arbn_edges */
edges = (struct arbn_edges *)bu_calloc(aip->neqn*aip->neqn, sizeof(struct arbn_edges) ,
"rt_arbn_tess: edges");
edge_count = (size_t *)bu_calloc(aip->neqn, sizeof(size_t), "rt_arbn_tess: edge_count");
/* Allocate memory for faceuses */
fu = (struct faceuse **)bu_calloc(aip->neqn, sizeof(struct faceuse *), "rt_arbn_tess: fu");
/* Calculate all vertices */
for (i = 0; i < aip->neqn; i++) {
for (j = i + 1; j < aip->neqn; j++) {
for (k = j + 1; k < aip->neqn; k++) {
int keep_point = 1;
if (bn_mkpoint_3planes(pts[point_count].pt, aip->eqn[i], aip->eqn[j], aip->eqn[k]))
continue;
for (l = 0; l < aip->neqn; l++) {
if (l == i || l == j || l == k)
continue;
if (DIST_PT_PLANE(pts[point_count].pt, aip->eqn[l]) > tol->dist) {
keep_point = 0;
break;
}
}
if (keep_point) {
pts[point_count].plane_no[0] = i;
pts[point_count].plane_no[1] = j;
pts[point_count].plane_no[2] = k;
point_count++;
}
}
}
}
/* Allocate memory for the NMG vertex pointers */
verts = (struct vertex **)bu_calloc(point_count, sizeof(struct vertex *) ,
"rt_arbn_tess: verts");
/* Associate points with vertices */
for (i = 0; i < point_count; i++)
pts[i].vp = &verts[i];
/* Check for duplicate points */
for (i = 0; i < point_count; i++) {
for (j = i + 1; j < point_count; j++) {
if (DIST_PT_PT_SQ(pts[i].pt, pts[j].pt) < tol->dist_sq) {
/* These two points should point to the same vertex */
pts[j].vp = pts[i].vp;
}
}
}
/* Make list of edges for each face */
for (i = 0; i < aip->neqn; i++) {
/* look for a point that lies in this face */
for (j = 0; j < point_count; j++) {
if (pts[j].plane_no[0] != (int)i
&& pts[j].plane_no[1] != (int)i
&& pts[j].plane_no[2] != (int)i)
continue;
/* look for another point that shares plane "i" and another with this one */
for (k = j + 1; k < point_count; k++) {
size_t match = (size_t)-1;
size_t pt1, pt2;
int duplicate = 0;
/* skip points not on plane "i" */
if (pts[k].plane_no[0] != (int)i
&& pts[k].plane_no[1] != (int)i
&& pts[k].plane_no[2] != (int)i)
continue;
for (l = 0; l < 3; l++) {
for (n = 0; n < 3; n++) {
if (pts[j].plane_no[l] == pts[k].plane_no[n]
&& pts[j].plane_no[l] != (int)i) {
match = pts[j].plane_no[l];
break;
}
}
if (match != (size_t)-1)
break;
}
if (match == (size_t)-1)
continue;
/* convert equivalent points to lowest point number */
pt1 = j;
pt2 = k;
for (l = 0; l < pt1; l++) {
if (pts[pt1].vp == pts[l].vp) {
pt1 = l;
break;
}
}
for (l = 0; l < pt2; l++) {
if (pts[pt2].vp == pts[l].vp) {
pt2 = l;
break;
}
}
/* skip null edges */
if (pt1 == pt2)
continue;
/* check for duplicate edge */
for (l = 0; l < edge_count[i]; l++) {
if ((edges[LOC(i, l)].v1_no == (int)pt1
&& edges[LOC(i, l)].v2_no == (int)pt2)
|| (edges[LOC(i, l)].v2_no == (int)pt1
&& edges[LOC(i, l)].v1_no == (int)pt2))
{
duplicate = 1;
break;
}
}
if (duplicate)
continue;
/* found an edge belonging to faces "i" and "match" */
if (edge_count[i] == aip->neqn) {
bu_log("Too many edges found for one face\n");
goto fail;
}
edges[LOC(i, edge_count[i])].v1_no = pt1;
edges[LOC(i, edge_count[i])].v2_no = pt2;
edge_count[i]++;
}
}
}
/* for each face, sort the list of edges into a loop */
Sort_edges(edges, edge_count, aip);
/* Get max number of edges for any face */
max_edge_count = 0;
for (i = 0; i < aip->neqn; i++)
if (edge_count[i] > max_edge_count)
max_edge_count = edge_count[i];
/* Allocate memory for array to pass to nmg_cmface */
loop_verts = (struct vertex ***) bu_calloc(max_edge_count, sizeof(struct vertex **) ,
"rt_arbn_tess: loop_verts");
*r = nmg_mrsv(m); /* Make region, empty shell, vertex */
s = BU_LIST_FIRST(shell, &(*r)->s_hd);
/* Make the faces */
for (i = 0; i < aip->neqn; i++) {
int loop_length = 0;
for (j = 0; j < edge_count[i]; j++) {
/* skip zero length edges */
if (pts[edges[LOC(i, j)].v1_no].vp == pts[edges[LOC(i, j)].v2_no].vp)
continue;
/* put vertex pointers into loop_verts array */
loop_verts[loop_length] = pts[edges[LOC(i, j)].v2_no].vp;
loop_length++;
}
/* Make the face if there is are least 3 vertices */
if (loop_length > 2)
fu[face_count++] = nmg_cmface(s, loop_verts, loop_length);
}
/* Associate vertex geometry */
for (i = 0; i < point_count; i++) {
if (!(*pts[i].vp))
continue;
if ((*pts[i].vp)->vg_p)
continue;
nmg_vertex_gv(*pts[i].vp, pts[i].pt);
}
bu_free((char *)pts, "rt_arbn_tess: pts");
bu_free((char *)edges, "rt_arbn_tess: edges");
bu_free((char *)edge_count, "rt_arbn_tess: edge_count");
bu_free((char *)verts, "rt_arbn_tess: verts");
bu_free((char *)loop_verts, "rt_arbn_tess: loop_verts");
/* Associate face geometry */
for (i = 0; i < face_count; i++) {
if (nmg_fu_planeeqn(fu[i], tol)) {
bu_log("Failed to calculate face plane equation\n");
bu_free((char *)fu, "rt_arbn_tess: fu");
nmg_kr(*r);
*r = (struct nmgregion *)NULL;
return -1;
}
}
bu_free((char *)fu, "rt_arbn_tess: fu");
nmg_fix_normals(s, tol);
(void)nmg_mark_edges_real(&s->l.magic);
/* Compute "geometry" for region and shell */
nmg_region_a(*r, tol);
return 0;
fail:
bu_free((char *)pts, "rt_arbn_tess: pts");
bu_free((char *)edges, "rt_arbn_tess: edges");
bu_free((char *)edge_count, "rt_arbn_tess: edge_count");
bu_free((char *)verts, "rt_arbn_tess: verts");
return -1;
}
