void make_2manifold_bits(struct bn_tol *tol) { struct vertex *f2_vertl[8]; /* make a non-dangling internal face */ f2_vertl[0] = vertl[1]; f2_vertl[1] = vertl[2]; f2_vertl[2] = vertl[7]; f2_vertl[3] = vertl[5]; fu = nmg_cface(s, f2_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* * we need to make the 2-manifolds share edge topology */ nmg_mesh_faces(tc_fu, fu, tol); nmg_mesh_faces(fl_fu, fu, tol); nmg_mesh_faces(bl_fu, fu, tol); nmg_mesh_faces(ul_fu, fu, tol); /* make a dangling internal face */ f2_vertl[0] = vertl[9]; f2_vertl[1] = vertl[10]; f2_vertl[2] = vertl[11]; f2_vertl[3] = vertl[8]; fu = nmg_cface(s, f2_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* make faces share edge topology */ nmg_mesh_faces(tc_fu, fu, tol); nmg_mesh_faces(fl_fu, fu, tol); nmg_mesh_faces(bl_fu, fu, tol); /* make an exterior, connected dangling face */ f2_vertl[0] = vertl[0]; f2_vertl[1] = vertl[3]; f2_vertl[2] = vertl[31]; f2_vertl[3] = vertl[30]; fu = nmg_cface(s, f2_vertl, 4); vertl[30] = f2_vertl[3]; vertl[31] = f2_vertl[2]; nmg_vertex_g(vertl[30], 150.0, 100.0, 150.0); nmg_vertex_g(vertl[31], 150.0, 0.0, 150.0); (void)nmg_fu_planeeqn(fu, tol); nmg_mesh_faces(fr_fu, fu, tol); }
/** * "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; }
void make_3manifold_bits(struct bn_tol *tol) { plane_t plane; struct faceuse *fu_end; memset((char *)vertl, 0, sizeof(vertl)); memset((char *)f_vertl, 0, sizeof(f_vertl)); /* front right */ f_vertl[0] = &vertl[0]; f_vertl[1] = &vertl[1]; f_vertl[2] = &vertl[2]; f_vertl[3] = &vertl[3]; fr_fu = fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[0], 100.0, 100.0, 100.0); nmg_vertex_g(vertl[1], 50.0, 100.0, 100.0); nmg_vertex_g(vertl[2], 50.0, 0.0, 100.0); nmg_vertex_g(vertl[3], 100.0, 0.0, 100.0); (void)nmg_fu_planeeqn(fu, tol); /* make top right */ f_vertl[0] = &vertl[0]; f_vertl[1] = &vertl[4]; f_vertl[2] = &vertl[5]; f_vertl[3] = &vertl[1]; fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[4], 100.0, 100.0, 0.0); nmg_vertex_g(vertl[5], 50.0, 100.0, 0.0); (void)nmg_fu_planeeqn(fu, tol); /* back right */ f_vertl[0] = &vertl[5]; f_vertl[1] = &vertl[4]; f_vertl[2] = &vertl[6]; f_vertl[3] = &vertl[7]; fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[6], 100.0, 0.0, 0.0); nmg_vertex_g(vertl[7], 50.0, 0.0, 0.0); (void)nmg_fu_planeeqn(fu, tol); /* bottom right */ f_vertl[0] = &vertl[7]; f_vertl[1] = &vertl[6]; f_vertl[2] = &vertl[3]; f_vertl[3] = &vertl[2]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* right end */ f_vertl[0] = &vertl[3]; f_vertl[1] = &vertl[6]; f_vertl[2] = &vertl[4]; f_vertl[3] = &vertl[0]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* make split top */ f_vertl[0] = &vertl[1]; f_vertl[1] = &vertl[5]; f_vertl[2] = &vertl[8]; f_vertl[3] = &vertl[9]; tc_fu = fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[8], 25.0, 100.0, 0.0); nmg_vertex_g(vertl[9], 25.0, 100.0, 100.0); (void)nmg_fu_planeeqn(fu, tol); f_vertl[0] = &vertl[9]; f_vertl[1] = &vertl[8]; f_vertl[2] = &vertl[12]; f_vertl[3] = &vertl[13]; fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[12], 0.0, 100.0, 0.0); nmg_vertex_g(vertl[13], 0.0, 100.0, 100.0); (void)nmg_fu_planeeqn(fu, tol); /* make split & funky front side * we make the convex face first, make the second (non-convex) portion * after the face normal has been computed. */ f_vertl[0] = &vertl[14]; f_vertl[1] = &vertl[18]; f_vertl[2] = &vertl[15]; f_vertl[3] = &vertl[16]; fl_fu = fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[14], 0.0, 25.0, 100.0); nmg_vertex_g(vertl[15], 25.0, 0.0, 100.0); nmg_vertex_g(vertl[16], 25.0, 25.0, 100.0); nmg_vertex_g(vertl[18], 0.0, 0.0, 100.0); (void)nmg_fu_planeeqn(fu, tol); f_vertl[0] = &vertl[1]; f_vertl[1] = &vertl[9]; f_vertl[2] = &vertl[10]; f_vertl[3] = &vertl[9]; f_vertl[4] = &vertl[13]; f_vertl[5] = &vertl[14]; f_vertl[6] = &vertl[16]; f_vertl[7] = &vertl[15]; f_vertl[8] = &vertl[2]; nmg_jf(fu, nmg_cmface(s, f_vertl, 9)); nmg_vertex_g(vertl[10], 25.0, 75.0, 100.0); /* make split back side */ f_vertl[0] = &vertl[5]; f_vertl[1] = &vertl[7]; f_vertl[2] = &vertl[17]; f_vertl[3] = &vertl[12]; f_vertl[4] = &vertl[8]; f_vertl[5] = &vertl[11]; f_vertl[6] = &vertl[8]; bl_fu = fu = nmg_cmface(s, f_vertl, 7); nmg_vertex_g(vertl[11], 25.0, 75.0, 0.0); nmg_vertex_g(vertl[17], 0.0, 0.0, 0.0); /* this face isn't strictly convex, so we have to make the plane * equation the old-fashioned way. */ bn_mk_plane_3pts(plane, vertl[7]->vg_p->coord, vertl[17]->vg_p->coord, vertl[12]->vg_p->coord, tol); nmg_face_g(fu, plane); /* make funky end */ f_vertl[0] = &vertl[14]; f_vertl[1] = &vertl[20]; f_vertl[2] = &vertl[19]; f_vertl[3] = &vertl[18]; fu_end = fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[19], 0.0, 0.0, 75.0); nmg_vertex_g(vertl[20], 0.0, 25.0, 75.0); (void)nmg_fu_planeeqn(fu, tol); f_vertl[0] = &vertl[12]; f_vertl[1] = &vertl[17]; f_vertl[2] = &vertl[19]; f_vertl[3] = &vertl[20]; f_vertl[4] = &vertl[14]; f_vertl[5] = &vertl[13]; nmg_jf(fu, nmg_cmface(s, f_vertl, 6)); /* make funky bottom */ f_vertl[0] = &vertl[15]; f_vertl[1] = &vertl[18]; f_vertl[2] = &vertl[19]; f_vertl[3] = &vertl[21]; ul_fu = fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[21], 25.0, 0.0, 75.0); (void)nmg_fu_planeeqn(fu, tol); f_vertl[0] = &vertl[7]; f_vertl[1] = &vertl[2]; f_vertl[2] = &vertl[15]; f_vertl[3] = &vertl[21]; f_vertl[4] = &vertl[19]; f_vertl[5] = &vertl[17]; nmg_jf(fu, nmg_cmface(s, f_vertl, 6)); /* now create the (3manifold) hole through the object */ /* make the holes in the end face */ f_vertl[0] = &vertl[29]; f_vertl[1] = &vertl[28]; f_vertl[2] = &vertl[27]; f_vertl[3] = &vertl[26]; fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[26], 0.0, 60.0, 10.0); nmg_vertex_g(vertl[27], 0.0, 60.0, 25.0); nmg_vertex_g(vertl[28], 0.0, 40.0, 25.0); nmg_vertex_g(vertl[29], 0.0, 40.0, 10.0); /* GROSS HACK XXX * we reverse the orientation of the faceuses and loopuses * so that we can make the hole as a face, and transfer the hole * to an existing face */ lu = BU_LIST_FIRST(loopuse, &fu->lu_hd); lu->orientation = OT_OPPOSITE; lu->lumate_p->orientation = OT_OPPOSITE; fu->orientation = OT_OPPOSITE; fu->fumate_p->orientation = OT_SAME; nmg_jf(fu_end, fu->fumate_p); f_vertl[0] = &vertl[22]; f_vertl[1] = &vertl[23]; f_vertl[2] = &vertl[24]; f_vertl[3] = &vertl[25]; fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[22], 10.0, 60.0, 0.0); nmg_vertex_g(vertl[23], 25.0, 60.0, 0.0); nmg_vertex_g(vertl[24], 25.0, 40.0, 0.0); nmg_vertex_g(vertl[25], 10.0, 40.0, 0.0); /* GROSS HACK XXX * we reverse the orientation of the faceuses and loopuses * so that we can make the hole as a face, and transfer the hole * to an existing face. */ lu = BU_LIST_FIRST(loopuse, &fu->lu_hd); lu->orientation = OT_OPPOSITE; lu->lumate_p->orientation = OT_OPPOSITE; fu->orientation = OT_OPPOSITE; fu->fumate_p->orientation = OT_SAME; nmg_jf(bl_fu, fu->fumate_p); /* make the top of the hole */ f_vertl[0] = &vertl[22]; f_vertl[1] = &vertl[23]; f_vertl[2] = &vertl[27]; f_vertl[3] = &vertl[26]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* make the bottom of the hole */ f_vertl[0] = &vertl[24]; f_vertl[1] = &vertl[25]; f_vertl[2] = &vertl[29]; f_vertl[3] = &vertl[28]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* make origin-ward side of the hole */ f_vertl[0] = &vertl[22]; f_vertl[1] = &vertl[26]; f_vertl[2] = &vertl[29]; f_vertl[3] = &vertl[25]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* make last side of hole */ f_vertl[0] = &vertl[23]; f_vertl[1] = &vertl[24]; f_vertl[2] = &vertl[28]; f_vertl[3] = &vertl[27]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* now make the void in the center of the solid */ /* void bottom */ f_vertl[0] = &vertl[41]; f_vertl[1] = &vertl[40]; f_vertl[2] = &vertl[39]; f_vertl[3] = &vertl[38]; fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[38], 85.0, 40.0, 60.0); nmg_vertex_g(vertl[39], 65.0, 40.0, 60.0); nmg_vertex_g(vertl[40], 65.0, 40.0, 40.0); nmg_vertex_g(vertl[41], 85.0, 40.0, 40.0); (void)nmg_fu_planeeqn(fu, tol); /* void top */ f_vertl[0] = &vertl[42]; f_vertl[1] = &vertl[43]; f_vertl[2] = &vertl[44]; f_vertl[3] = &vertl[45]; fu = nmg_cmface(s, f_vertl, 4); nmg_vertex_g(vertl[42], 85.0, 60.0, 40.0); nmg_vertex_g(vertl[43], 85.0, 60.0, 60.0); nmg_vertex_g(vertl[44], 65.0, 60.0, 60.0); nmg_vertex_g(vertl[45], 65.0, 60.0, 40.0); (void)nmg_fu_planeeqn(fu, tol); /* void front */ f_vertl[0] = &vertl[44]; f_vertl[1] = &vertl[43]; f_vertl[2] = &vertl[38]; f_vertl[3] = &vertl[39]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* void back */ f_vertl[0] = &vertl[42]; f_vertl[1] = &vertl[45]; f_vertl[2] = &vertl[40]; f_vertl[3] = &vertl[41]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* void left */ f_vertl[0] = &vertl[45]; f_vertl[1] = &vertl[44]; f_vertl[2] = &vertl[39]; f_vertl[3] = &vertl[40]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); /* void right */ f_vertl[0] = &vertl[42]; f_vertl[1] = &vertl[41]; f_vertl[2] = &vertl[38]; f_vertl[3] = &vertl[43]; fu = nmg_cmface(s, f_vertl, 4); (void)nmg_fu_planeeqn(fu, tol); }