void
nmg_visit_shell(struct shell *s, const struct nmg_visit_handlers *htab, void *state)
/* Handler's private state */
{
struct faceuse *fu;
struct loopuse *lu;
struct edgeuse *eu;
NMG_CK_SHELL(s);
if (htab->bef_shell) htab->bef_shell((uint32_t *)s, state, 0);
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
nmg_visit_faceuse(fu, htab, state);
}
for (BU_LIST_FOR(lu, loopuse, &s->lu_hd)) {
nmg_visit_loopuse(lu, htab, state);
}
for (BU_LIST_FOR(eu, edgeuse, &s->eu_hd)) {
nmg_visit_edgeuse(eu, htab, state);
}
if (s->vu_p) nmg_visit_vertexuse(s->vu_p, htab, state);
if (htab->vis_shell_a && s->sa_p)
htab->vis_shell_a((uint32_t *)s->sa_p, state, 0);
if (htab->aft_shell) htab->aft_shell((uint32_t *)s, state, 1);
}
void
rt_vlist_export(struct bu_vls *vls, struct bu_list *hp, const char *name)
{
register struct bn_vlist *vp;
size_t nelem;
size_t namelen;
size_t nbytes;
unsigned char *buf;
unsigned char *bp;
BU_CK_VLS(vls);
/* Count number of element in the vlist */
nelem = 0;
for (BU_LIST_FOR(vp, bn_vlist, hp)) {
nelem += vp->nused;
}
/* Build output buffer for binary transmission
* nelem[4], String[n+1], cmds[nelem*1], pts[3*nelem*8]
*/
namelen = strlen(name)+1;
nbytes = namelen + 4 + nelem * (1+ELEMENTS_PER_VECT*SIZEOF_NETWORK_DOUBLE) + 2;
/* FIXME: this is pretty much an abuse of vls. should be using
* vlb for variable-length byte buffers.
*/
bu_vls_setlen(vls, (int)nbytes);
buf = (unsigned char *)bu_vls_addr(vls);
*(uint32_t *)buf = htonl((uint32_t)nelem);
bp = buf+sizeof(uint32_t);
bu_strlcpy((char *)bp, name, namelen);
bp += namelen;
/* Output cmds, as bytes */
for (BU_LIST_FOR(vp, bn_vlist, hp)) {
register int i;
register int nused = vp->nused;
register int *cmd = vp->cmd;
for (i = 0; i < nused; i++) {
*bp++ = *cmd++;
}
}
/* Output points, as three 8-byte doubles */
for (BU_LIST_FOR(vp, bn_vlist, hp)) {
register int i;
register int nused = vp->nused;
register point_t *pt = vp->pt;
/* must be double for import and export */
double point[ELEMENTS_PER_POINT];
for (i = 0; i < nused; i++) {
VMOVE(point, pt[i]); /* convert fastf_t to double */
htond(bp, (unsigned char *)point, ELEMENTS_PER_VECT);
bp += ELEMENTS_PER_VECT*SIZEOF_NETWORK_DOUBLE;
}
}
}
extern "C" void
rt_nmg_brep(ON_Brep **b, const struct rt_db_internal *ip, const struct bn_tol *tol)
{
struct model *m;
struct nmgregion *r;
struct shell *s;
struct faceuse *fu;
// Verify NMG
RT_CK_DB_INTERNAL(ip);
m = (struct model *)ip->idb_ptr;
NMG_CK_MODEL(m);
// Both NMG and brep structures re-use components between faces. In order to track
// when the conversion routine has already handled an NMG element, use an array.
long *brepi = static_cast<long*>(bu_malloc(m->maxindex * sizeof(long), "rt_nmg_brep: brepi[]"));
for (int i = 0; i < m->maxindex; i++) brepi[i] = -INT_MAX;
// Iterate over all faces in the NMG
for (BU_LIST_FOR(r, nmgregion, &m->r_hd)) {
for (BU_LIST_FOR(s, shell, &r->s_hd)) {
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME) continue;
if (nmg_brep_face(b, fu, tol, brepi)) return;
}
(*b)->SetTrimIsoFlags();
}
}
}
inline void
rt_metaball_norm_internal(vect_t *n, point_t *p, struct rt_metaball_internal *mb)
{
struct wdb_metaballpt *mbpt;
vect_t v;
fastf_t a;
VSETALL(*n, 0.0);
switch (mb->method) {
case METABALL_METABALL: bu_log("Sorry, strict metaballs are not yet implemented\n");
break;
case METABALL_ISOPOTENTIAL:
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head)) {
VSUB2(v, *p, mbpt->coord);
a = MAGSQ(v);
VJOIN1(*n, *n, fabs(mbpt->fldstr)*mbpt->fldstr / (SQ(a)), v); /* f/r^4 */
}
break;
case METABALL_BLOB:
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head)) {
VSUB2(v, *p, mbpt->coord);
a = MAGSQ(v);
VJOIN1(*n, *n, 2.0*mbpt->sweat/SQ(mbpt->fldstr)*exp(mbpt->sweat*(1-(a/SQ(mbpt->fldstr)))) , v);
}
break;
default: bu_log("unknown metaball method\n"); break;
}
VUNITIZE(*n);
}
/**
* Makes a deep copy of a NMG model structure.
*/
struct model *
nmg_clone_model(const struct model *original)
{
struct model *ret;
void * *structArray;
const struct nmgregion *originalRegion;
struct bn_tol tolerance;
NMG_CK_MODEL(original);
structArray = (void **)bu_calloc(original->maxindex, sizeof(void *), "nmg_clone_model() structArray");
ret = nmg_mm();
ret->index = original->index;
ret->maxindex = original->maxindex;
structArray[ret->index] = ret;
tolerance.magic = BN_TOL_MAGIC;
tolerance.dist = 0.0005;
tolerance.dist_sq = tolerance.dist * tolerance.dist;
tolerance.perp = 1e-6;
tolerance.para = 1 - tolerance.perp;
for (BU_LIST_FOR(originalRegion, nmgregion, &original->r_hd)) {
struct nmgregion *newRegion = (struct nmgregion *)structArray[originalRegion->index];
if (newRegion == NULL) {
const struct shell *originalShell;
newRegion = nmg_construct_region(ret, originalRegion, structArray);
for (BU_LIST_FOR(originalShell, shell, &originalRegion->s_hd)) {
struct shell *newShell = (struct shell *)structArray[originalShell->index];
if (newShell == NULL)
newShell = nmg_construct_shell(newRegion, originalShell, structArray);
BU_LIST_INSERT(&newRegion->s_hd, &newShell->l);
}
BU_LIST_INSERT(&ret->r_hd, &newRegion->l);
}
}
bu_free(structArray, "nmg_clone_model() structArray");
return ret;
}
struct region_pair *
add_unique_pair(struct region_pair *list, /* list to add into */
struct region *r1, /* first region involved */
struct region *r2, /* second region involved */
double dist, /* distance/thickness metric value */
point_t pt) /* location where this takes place */
{
struct region_pair *rp, *rpair;
/* look for it in our list */
bu_semaphore_acquire(GED_SEM_LIST);
for (BU_LIST_FOR (rp, region_pair, &list->l)) {
if ((r1 == rp->r.r1 && r2 == rp->r2) || (r1 == rp->r2 && r2 == rp->r.r1)) {
/* we already have an entry for this region pair, we
* increase the counter, check the depth and update
* thickness maximum and entry point if need be and
* return.
*/
rp->count++;
if (dist > rp->max_dist) {
rp->max_dist = dist;
VMOVE(rp->coord, pt);
}
rpair = rp;
goto found;
}
}
/* didn't find it in the list. Add it */
BU_ALLOC(rpair, struct region_pair);
rpair->r.r1 = r1;
rpair->r2 = r2;
rpair->count = 1;
rpair->max_dist = dist;
VMOVE(rpair->coord, pt);
list->max_dist ++; /* really a count */
/* insert in the list at the "nice" place */
for (BU_LIST_FOR (rp, region_pair, &list->l)) {
if (bu_strcmp(rp->r.r1->reg_name, r1->reg_name) <= 0)
break;
}
BU_LIST_INSERT(&rp->l, &rpair->l);
found:
bu_semaphore_release(GED_SEM_LIST);
return rpair;
}
void
rt_label_vlist_verts(struct bn_vlblock *vbp, struct bu_list *src, fastf_t *mat,
double sz, double mm2local)
{
struct bn_vlist *vp;
struct bu_list *vhead;
char label[256];
vhead = bn_vlblock_find(vbp, 255, 255, 255); /* white */
for (BU_LIST_FOR(vp, bn_vlist, src)) {
register int i;
register int nused = vp->nused;
register int *cmd = vp->cmd;
register point_t *pt = vp->pt;
for (i = 0; i < nused; i++, cmd++, pt++) {
/* default coordinates label */
/* XXX Skip polygon markers? */
sprintf(label, " %g, %g, %g",
(*pt)[0]*mm2local, (*pt)[1]*mm2local, (*pt)[2]*mm2local);
bn_vlist_3string(vhead, vbp->free_vlist_hd, label, (*pt), mat, sz);
}
}
}
HIDDEN struct bu_cmdhist_obj *
cho_open(ClientData UNUSED(clientData), Tcl_Interp *interp, const char *name)
{
struct bu_cmdhist_obj *chop;
/* check to see if command history object exists */
for (BU_LIST_FOR(chop, bu_cmdhist_obj, &HeadCmdHistObj.l)) {
if (BU_STR_EQUAL(name, bu_vls_addr(&chop->cho_name))) {
Tcl_AppendResult(interp, "ch_open: ", name,
" exists.\n", (char *)NULL);
return BU_CMDHIST_OBJ_NULL;
}
}
BU_GET(chop, struct bu_cmdhist_obj);
bu_vls_init(&chop->cho_name);
bu_vls_strcpy(&chop->cho_name, name);
BU_LIST_INIT(&chop->cho_head.l);
bu_vls_init(&chop->cho_head.h_command);
chop->cho_head.h_start.tv_sec = chop->cho_head.h_start.tv_usec =
chop->cho_head.h_finish.tv_sec = chop->cho_head.h_finish.tv_usec = 0L;
chop->cho_head.h_status = TCL_OK;
chop->cho_curr = &chop->cho_head;
BU_LIST_APPEND(&HeadCmdHistObj.l, &chop->l);
return chop;
}
int
cho_open_tcl(ClientData clientData, Tcl_Interp *interp, int argc, const char **argv)
{
struct bu_cmdhist_obj *chop;
struct bu_vls vls = BU_VLS_INIT_ZERO;
if (argc == 1) {
/* get list of command history objects */
for (BU_LIST_FOR(chop, bu_cmdhist_obj, &HeadCmdHistObj.l))
Tcl_AppendResult(interp, bu_vls_addr(&chop->cho_name), " ", (char *)NULL);
return TCL_OK;
}
if (argc == 2) {
if ((chop = cho_open(clientData, interp, argv[1])) == BU_CMDHIST_OBJ_NULL)
return TCL_ERROR;
(void)Tcl_CreateCommand(interp,
bu_vls_addr(&chop->cho_name),
(Tcl_CmdProc *)cho_cmd,
(ClientData)chop,
cho_deleteProc);
/* Return new function name as result */
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, bu_vls_addr(&chop->cho_name), (char *)NULL);
return TCL_OK;
}
bu_vls_printf(&vls, "helplib ch_open");
Tcl_Eval(interp, bu_vls_addr(&vls));
bu_vls_free(&vls);
return TCL_ERROR;
}
int
nmg_eu_is_part_of_crack(const struct edgeuse *eu)
{
struct loopuse *lu;
struct edgeuse *eu_test;
NMG_CK_EDGEUSE(eu);
/* must be part of a loop to be a crack */
if (*eu->up.magic_p != NMG_LOOPUSE_MAGIC)
return 0;
lu = eu->up.lu_p;
NMG_CK_LOOPUSE(lu);
for (BU_LIST_FOR(eu_test, edgeuse, &lu->down_hd)) {
if (eu_test == eu)
continue;
if (eu_test->vu_p->v_p == eu->eumate_p->vu_p->v_p &&
eu_test->eumate_p->vu_p->v_p == eu->vu_p->v_p)
return 1;
}
return 0;
}
void
rt_vlist_to_uplot(FILE *fp, const struct bu_list *vhead)
{
register struct bn_vlist *vp;
for (BU_LIST_FOR(vp, bn_vlist, vhead)) {
register int i;
register int nused = vp->nused;
register const int *cmd = vp->cmd;
register point_t *pt = vp->pt;
for (i = 0; i < nused; i++, cmd++, pt++) {
switch (*cmd) {
case BN_VLIST_POLY_START:
case BN_VLIST_TRI_START:
break;
case BN_VLIST_POLY_MOVE:
case BN_VLIST_LINE_MOVE:
case BN_VLIST_TRI_MOVE:
pdv_3move(fp, *pt);
break;
case BN_VLIST_POLY_DRAW:
case BN_VLIST_POLY_END:
case BN_VLIST_LINE_DRAW:
case BN_VLIST_TRI_DRAW:
case BN_VLIST_TRI_END:
pdv_3cont(fp, *pt);
break;
default:
bu_log("rt_vlist_to_uplot: unknown vlist cmd x%x\n",
*cmd);
}
}
}
}
HIDDEN int
convert_grid(int idx)
{
struct coord_sys *cs;
point_t tmp_pt;
VSETALL(tmp_pt, 0.0);
if (!g_pts[idx].cid)
return 0;
for (BU_LIST_FOR(cs, coord_sys, &coord_head.l)) {
if (cs->cid != g_pts[idx].cid)
continue;
break;
}
if (BU_LIST_IS_HEAD(&cs->l, &coord_head.l)) {
bu_exit(1, "No coordinate system defined for grid point #%d!\n", g_pts[idx].gid);
}
if (convert_pt(g_pts[idx].pt, cs, tmp_pt))
return 1;
VMOVE(g_pts[idx].pt, tmp_pt);
g_pts[idx].cid = 0;
return 0;
}
void
rt_metaball_print(register const struct soltab *stp)
{
int metaball_count = 0;
struct rt_metaball_internal *mb;
struct wdb_metaballpt *mbpt;
mb = (struct rt_metaball_internal *)stp->st_specific;
RT_METABALL_CK_MAGIC(mb);
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head)) ++metaball_count;
bu_log("Metaball with %d points and a threshold of %g (%s rendering)\n", metaball_count, mb->threshold, rt_metaball_lookup_type_name(mb->method));
metaball_count = 0;
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head))
bu_log("\t%d: %g field strength at (%g, %g, %g) and 'goo' of %g\n", ++metaball_count, mbpt->fldstr, V3ARGS(mbpt->coord), mbpt->sweat);
return;
}
HIDDEN void
wdb_do_inter(struct bu_list *hp)
{
struct tokens *tok;
for (BU_LIST_FOR(tok, tokens, hp)) {
struct tokens *prev, *next;
union tree *tp;
if (tok->type != WDB_TOK_INTER)
continue;
prev = BU_LIST_PREV(tokens, &tok->l);
next = BU_LIST_NEXT(tokens, &tok->l);
if (prev->type !=WDB_TOK_TREE || next->type != WDB_TOK_TREE)
continue;
/* this is an eligible intersection operation */
BU_ALLOC(tp, union tree);
RT_TREE_INIT(tp);
tp->tr_b.tb_op = OP_INTERSECT;
tp->tr_b.tb_regionp = (struct region *)NULL;
tp->tr_b.tb_left = prev->tp;
tp->tr_b.tb_right = next->tp;
BU_LIST_DEQUEUE(&tok->l);
bu_free((char *)tok, "tok");
BU_LIST_DEQUEUE(&prev->l);
bu_free((char *)prev, "prev");
next->tp = tp;
tok = next;
}
}
HIDDEN int
wdb_do_paren(struct bu_list *hp)
{
struct tokens *tok;
for (BU_LIST_FOR(tok, tokens, hp)) {
struct tokens *prev, *next;
if (tok->type != WDB_TOK_TREE)
continue;
prev = BU_LIST_PREV(tokens, &tok->l);
next = BU_LIST_NEXT(tokens, &tok->l);
if (prev->type !=WDB_TOK_LPAREN || next->type != WDB_TOK_RPAREN)
continue;
/* this is an eligible operand surrounded by parens */
BU_LIST_DEQUEUE(&next->l);
bu_free((char *)next, "next");
BU_LIST_DEQUEUE(&prev->l);
bu_free((char *)prev, "prev");
}
if (hp->forw == hp->back && hp->forw != hp)
return 1; /* done */
else if (BU_LIST_IS_EMPTY(hp))
return -1; /* empty tree!!!! */
else
return 0; /* more to do */
}
static void
Write_euclid_face(const struct loopuse *lu, const int facet_type, const int regionid, const int face_number)
{
struct faceuse *fu;
struct edgeuse *eu;
plane_t plane;
int vertex_count = 0;
NMG_CK_LOOPUSE(lu);
if (verbose)
bu_log("Write_euclid_face: lu=%p, facet_type=%d, regionid=%d, face_number=%d\n",
(void *)lu, facet_type, regionid, face_number);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC)
return;
if (*lu->up.magic_p != NMG_FACEUSE_MAGIC)
return;
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd))
vertex_count++;
fprintf(fp_out, "%10d%3d 0. 1%5d", regionid, facet_type, vertex_count);
vertex_count = 0;
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd))
{
struct vertex *v;
int i;
NMG_CK_EDGEUSE(eu);
v = eu->vu_p->v_p;
NMG_CK_VERTEX(v);
/* fprintf(fp_out, "%10d%8f%8f%8f", ++vertex_count, V3ARGS(v->vg_p->coord)); */
vertex_count++;
fprintf(fp_out, "%10d", vertex_count);
for (i=X; i<=Z; i++)
fastf_print(fp_out, 8, v->vg_p->coord[i]);
}
fu = lu->up.fu_p;
NMG_CK_FACEUSE(fu);
NMG_GET_FU_PLANE(plane, fu);
fprintf(fp_out, "%10d%15.5f%15.5f%15.5f%15.5f", face_number, V4ARGS(plane));
}
/**
* Creates one metaball object that includes all points from an
* existing list (in 'av') of named metaballs. This routine creates
* an rt_metaball_internal object directly via LIBRT given it requires
* reading existing metaballs from the database.
*/
static void
mix_balls(struct db_i *dbip, const char *name, int ac, const char *av[])
{
int i;
struct directory *dp;
struct rt_metaball_internal *newmp;
RT_CK_DBI(dbip);
/* allocate a struct rt_metaball_internal object that we'll
* manually fill in with points from the other metaballs being
* joined together.
*/
BU_ALLOC(newmp, struct rt_metaball_internal);
newmp->magic = RT_METABALL_INTERNAL_MAGIC;
newmp->threshold = 1.0;
newmp->method = 1;
BU_LIST_INIT(&newmp->metaball_ctrl_head);
bu_log("Combining together the following metaballs:\n");
for (i = 0; i < ac; i++) {
struct rt_db_internal dir;
struct rt_metaball_internal *mp;
struct wdb_metaballpt *mpt;
/* get a handle on the existing database object */
bu_log("\t%s\n", av[i]);
dp = db_lookup(dbip, av[i], 1);
if (!dp) {
bu_log("Unable to find %s\n", av[i]);
continue;
}
/* load the existing database object */
if (rt_db_get_internal(&dir, dp, dbip, NULL, &rt_uniresource) < 0) {
bu_log("Unable to load %s\n", av[i]);
continue;
}
/* access the metaball-specific internal structure */
mp = (struct rt_metaball_internal *)dir.idb_ptr;
RT_METABALL_CK_MAGIC(mp);
/* iterate over each point in that database object and add it
* to our new metaball.
*/
for (BU_LIST_FOR(mpt, wdb_metaballpt, &mp->metaball_ctrl_head)) {
bu_log("Adding point (%lf %lf %lf)\n", V3ARGS(mpt->coord));
rt_metaball_add_point(newmp, (const point_t *)&mpt->coord, mpt->fldstr, mpt->sweat);
}
}
bu_log("Joining balls together and creating [%s] object\n", name);
/* write out new "mega metaball" out to disk */
dbip->dbi_wdbp = wdb_dbopen(dbip, RT_WDB_TYPE_DB_DISK);
wdb_export(dbip->dbi_wdbp, name, newmp, ID_METABALL, 1.0);
}
/*
* Go poke the rgb values of a region, on the fly.
* This does not update the inmemory database,
* so any changes will vanish on next re-prep unless other measures
* are taken.
*/
int
sh_directchange_shader(ClientData UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
{
long int rtip_val;
struct rt_i *rtip;
struct region *regp;
struct directory *dp;
struct bu_vls shader = BU_VLS_INIT_ZERO;
if ( argc < 4 ) {
Tcl_AppendResult(interp, "Usage: sh_directchange_shader $rtip comb shader_arg(s)\n", NULL);
return TCL_ERROR;
}
rtip_val = atol(argv[1]);
rtip = (struct rt_i *)rtip_val;
RT_CK_RTI(rtip);
if ( rtip->needprep ) {
Tcl_AppendResult(interp, "rt_prep() hasn't been called yet, error.\n", NULL);
return TCL_ERROR;
}
if ( (dp = db_lookup( rtip->rti_dbip, argv[2], LOOKUP_NOISY)) == RT_DIR_NULL ) {
Tcl_AppendResult(interp, argv[2], ": not found\n", NULL);
return TCL_ERROR;
}
bu_vls_from_argv(&shader, argc-3, argv+3);
bu_vls_trimspace(&shader);
/* Find all region names which match /comb/ pattern */
for ( BU_LIST_FOR( regp, region, &rtip->HeadRegion ) ) {
/* if ( dp->d_flags & RT_DIR_REGION ) { */
/* name will occur at end of region string w/leading slash */
/* } else { */
/* name will occur anywhere, bracketed by slashes */
/* } */
/* XXX quick hack */
if ( strstr( regp->reg_name, argv[2] ) == NULL ) continue;
/* Modify the region's shader string */
bu_log("sh_directchange_shader() changing %s\n", regp->reg_name);
if ( regp->reg_mater.ma_shader )
bu_free( (void *)regp->reg_mater.ma_shader, "reg_mater.ma_shader");
regp->reg_mater.ma_shader = bu_vls_strdup(&shader);
/* Update the shader */
mlib_free(regp);
if ( mlib_setup( &mfHead, regp, rtip ) != 1 ) {
Tcl_AppendResult(interp, regp->reg_name, ": mlib_setup() failure\n", NULL);
}
}
bu_vls_free(&shader);
return TCL_OK;
}
/**
* Intersect all the edges in fu1 that don't lie on any of the faces
* of shell s2 with s2, i.e. "interior" edges, where the endpoints lie
* on s2, but the edge is not shared with a face of s2. Such edges
* wouldn't have been processed by the NEWLINE version of
* nmg_isect_two_generic_faces(), so intersections need to be looked
* for here. Fortunately, it's easy to reject everything except edges
* that need processing using only the topology structures.
*
* The "_int" at the end of the name is to signify that this routine
* does only "interior" edges, and is not a general face/shell
* intersector.
*/
void
nmg_isect_face3p_shell_int(struct nmg_inter_struct *is, struct faceuse *fu1, struct shell *s2)
{
struct shell *s1;
struct loopuse *lu1;
struct edgeuse *eu1;
NMG_CK_INTER_STRUCT(is);
NMG_CK_FACEUSE(fu1);
NMG_CK_SHELL(s2);
s1 = fu1->s_p;
NMG_CK_SHELL(s1);
if (RTG.NMG_debug & DEBUG_POLYSECT)
bu_log("nmg_isect_face3p_shell_int(, fu1=x%x, s2=x%x) START\n", fu1, s2);
for (BU_LIST_FOR (lu1, loopuse, &fu1->lu_hd)) {
NMG_CK_LOOPUSE(lu1);
if (BU_LIST_FIRST_MAGIC(&lu1->down_hd) == NMG_VERTEXUSE_MAGIC)
continue;
for (BU_LIST_FOR (eu1, edgeuse, &lu1->down_hd)) {
struct edgeuse *eu2;
eu2 = nmg_find_matching_eu_in_s(eu1, s2);
if (eu2) {
bu_log("nmg_isect_face3p_shell_int() eu1=x%x, e1=x%x, eu2=x%x, e2=x%x (nothing to do)\n", eu1, eu1->e_p, eu2, eu2->e_p);
/* Whether the edgeuse is in a face, or a wire
* edgeuse, the other guys will isect it.
*/
continue;
}
/* vu2a and vu2b are in shell s2, but there is no edge
* running between them in shell s2. Create a line of
* intersection, and go to it!.
*/
bu_log("nmg_isect_face3p_shell_int(, s2=x%x) eu1=x%x, no eu2\n", s2, eu1);
/* XXX eso no existe todavia */
/* nmg_isect_edge3p_shell(is, eu1, s2); */
}
}
if (RTG.NMG_debug & DEBUG_POLYSECT)
bu_log("nmg_isect_face3p_shell_int(, fu1=x%x, s2=x%x) END\n", fu1, s2);
}
/*
* Go poke the rgb values of a region, on the fly.
* This does not update the inmemory database,
* so any changes will vanish on next re-prep unless other measures
* are taken.
*/
int
sh_directchange_rgb(ClientData UNUSED(clientData), Tcl_Interp *interp, int argc, const char *argv[])
{
long int rtip_val;
struct rt_i *rtip;
struct region *regp;
struct directory *dp;
float r, g, b;
if ( argc != 6 ) {
Tcl_AppendResult(interp, "Usage: sh_directchange_rgb $rtip comb r g b\n", NULL);
return TCL_ERROR;
}
r = atoi(argv[3+0]) / 255.0;
g = atoi(argv[3+1]) / 255.0;
b = atoi(argv[3+2]) / 255.0;
rtip_val = atol(argv[1]);
rtip = (struct rt_i *)rtip_val;
RT_CK_RTI(rtip);
if ( rtip->needprep ) {
Tcl_AppendResult(interp, "rt_prep() hasn't been called yet, error.\n", NULL);
return TCL_ERROR;
}
if ( (dp = db_lookup( rtip->rti_dbip, argv[2], LOOKUP_NOISY)) == RT_DIR_NULL ) {
Tcl_AppendResult(interp, argv[2], ": not found\n", NULL);
return TCL_ERROR;
}
/* Find all region names which match /comb/ pattern */
for ( BU_LIST_FOR( regp, region, &rtip->HeadRegion ) ) {
/* if ( dp->d_flags & RT_DIR_REGION ) { */
/* name will occur at end of region string w/leading slash */
/* } else { */
/* name will occur anywhere, bracketed by slashes */
/* } */
/* XXX quick hack */
if ( strstr( regp->reg_name, argv[2] ) == NULL ) continue;
/* Modify the region's color */
bu_log("sh_directchange_rgb() changing %s\n", regp->reg_name);
VSET( regp->reg_mater.ma_color, r, g, b );
/* Update the shader */
mlib_free(regp);
if ( mlib_setup( &mfHead, regp, rtip ) != 1 ) {
Tcl_AppendResult(interp, regp->reg_name, ": mlib_setup() failure\n", NULL);
}
}
return TCL_OK;
}
/**
* Mesh every edge in shell 1 with every edge in shell 2.
* The return is the number of edges meshed.
*
* Does not use nmg_mesh_face_shell() to keep face/self meshing
* to the absolute minimum necessary.
*/
int
nmg_mesh_shell_shell(struct shell *s1, struct shell *s2, const struct bn_tol *tol)
{
struct faceuse *fu1;
struct faceuse *fu2;
int count = 0;
NMG_CK_SHELL(s1);
NMG_CK_SHELL(s2);
BN_CK_TOL(tol);
nmg_region_v_unique(s1->r_p, tol);
nmg_region_v_unique(s2->r_p, tol);
/* First, mesh all faces of shell 2 with themselves */
for (BU_LIST_FOR(fu2, faceuse, &s2->fu_hd)) {
NMG_CK_FACEUSE(fu2);
count += nmg_mesh_two_faces(fu2, fu2, tol);
}
/* Visit every face in shell 1 */
for (BU_LIST_FOR(fu1, faceuse, &s1->fu_hd)) {
NMG_CK_FACEUSE(fu1);
/* First, mesh each face in shell 1 with itself */
count += nmg_mesh_two_faces(fu1, fu1, tol);
/* Visit every face in shell 2 */
for (BU_LIST_FOR(fu2, faceuse, &s2->fu_hd)) {
NMG_CK_FACEUSE(fu2);
count += nmg_mesh_two_faces(fu1, fu2, tol);
}
}
/* XXX What about wire edges in the shell? */
/* Visit every wire loop in shell 1 */
/* Visit every wire edge in shell 1 */
return count;
}
HIDDEN void
get_cbar(void)
{
int eid, pid;
int g1, g2;
point_t pt1, pt2;
fastf_t radius;
vect_t height;
struct pbar *pb;
char cbar_name[NAMESIZE+1];
eid = atoi( curr_rec[1] );
pid = atoi( curr_rec[2] );
if ( !pid )
{
if ( bar_def_pid )
pid = bar_def_pid;
else
pid = eid;
}
g1 = atoi( curr_rec[3] );
g2 = atoi( curr_rec[4] );
get_grid( g1, pt1 );
get_grid( g2, pt2 );
for ( BU_LIST_FOR( pb, pbar, &pbar_head.l ) )
{
if ( pb->pid == pid )
break;
}
if ( BU_LIST_IS_HEAD( &pb->l, &pbar_head.l ) )
{
log_line( "Non-existent PID referenced in CBAR" );
return;
}
VSCALE( pt1, pt1, conv[units] );
VSCALE( pt2, pt2, conv[units] );
radius = sqrt( pb->area/bn_pi );
radius = radius * conv[units];
VSUB2( height, pt2, pt1 );
sprintf( cbar_name, "cbar.%d", eid );
mk_rcc( fpout, cbar_name, pt1, height, radius );
mk_addmember( cbar_name, &pb->head.l, NULL, WMOP_UNION );
}
void show_sites (struct bu_list *sl)
{
struct site *sp;
BU_CK_LIST_HEAD(sl);
for (BU_LIST_FOR(sp, site, sl)) {
bu_log("I got a site (%g, %g, %g)\n",
sp->s_x, sp->s_y, sp->s_z);
}
}
/**
* storage is something like
* long numpoints
* long method
* fastf_t threshold
* fastf_t X1 (start point)
* fastf_t Y1
* fastf_t Z1
* fastf_t fldstr1
* fastf_t sweat1 (end point)
* fastf_t X2 (start point)
* ...
*/
int
rt_metaball_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
{
struct rt_metaball_internal *mb;
struct wdb_metaballpt *mbpt;
int metaball_count = 0, i = 1;
/* must be double for import and export */
double *buf = NULL;
if (dbip) RT_CK_DBI(dbip);
RT_CK_DB_INTERNAL(ip);
if (ip->idb_type != ID_METABALL)
return -1;
mb = (struct rt_metaball_internal *)ip->idb_ptr;
RT_METABALL_CK_MAGIC(mb);
if (mb->metaball_ctrl_head.magic == 0) return -1;
/* Count number of points */
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head)) metaball_count++;
BU_CK_EXTERNAL(ep);
ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE*(1+5*metaball_count) + 2*SIZEOF_NETWORK_LONG;
ep->ext_buf = (uint8_t *)bu_malloc(ep->ext_nbytes, "metaball external");
if (ep->ext_buf == NULL)
bu_bomb("Failed to allocate DB space!\n");
*(uint32_t *)ep->ext_buf = htonl(metaball_count);
*(uint32_t *)(ep->ext_buf + SIZEOF_NETWORK_LONG) = htonl(mb->method);
/* pack the point data */
buf = (double *)bu_malloc((metaball_count*5+1)*SIZEOF_NETWORK_DOUBLE, "rt_metaball_export5: buf");
buf[0] = mb->threshold;
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head), i+=5) {
VSCALE(&buf[i], mbpt->coord, local2mm);
buf[i+3] = mbpt->fldstr * local2mm;
buf[i+4] = mbpt->sweat;
}
bu_cv_htond((unsigned char *)ep->ext_buf + 2*SIZEOF_NETWORK_LONG, (unsigned char *)buf, 1 + 5 * metaball_count);
bu_free(buf, "rt_metaball_export5: buf");
return 0;
}
void
bu_call_hook(struct bu_hook_list *hlp, genptr_t buf)
{
struct bu_hook_list *call_hook;
for (BU_LIST_FOR(call_hook, bu_hook_list, &hlp->l)) {
if ( !(call_hook->hookfunc) ) {
exit(EXIT_FAILURE); /* don't call through 0! */
}
call_hook->hookfunc(call_hook->clientdata, buf);
}
}
/*
* List the objects currently prepped for drawing
*
* Usage:
* who [r(eal)|p(hony)|b(oth)]
*
*/
int
ged_who(struct ged *gedp, int argc, const char *argv[])
{
struct ged_display_list *gdlp;
int skip_real, skip_phony;
static const char *usage = "[r(eal)|p(hony)|b(oth)]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (2 < argc) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
skip_real = 0;
skip_phony = 1;
if (argc == 2) {
switch (argv[1][0]) {
case 'b':
skip_real = 0;
skip_phony = 0;
break;
case 'p':
skip_real = 1;
skip_phony = 0;
break;
case 'r':
skip_real = 0;
skip_phony = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "ged_who: argument not understood\n");
return GED_ERROR;
}
}
for (BU_LIST_FOR(gdlp, ged_display_list, gedp->ged_gdp->gd_headDisplay)) {
if (gdlp->gdl_dp->d_addr == RT_DIR_PHONY_ADDR) {
if (skip_phony) continue;
} else {
if (skip_real) continue;
}
bu_vls_printf(gedp->ged_result_str, "%s ", bu_vls_addr(&gdlp->gdl_path));
}
return GED_OK;
}
/**
* Classify a point vs a vertex (touching/missed)
*/
static int
nmg_class_pt_vu(struct fpi *fpi, struct vertexuse *vu)
{
vect_t delta;
struct ve_dist *ved;
NMG_CK_VERTEXUSE(vu);
/* see if we've classified this vertex WRT the point already */
for (BU_LIST_FOR(ved, ve_dist, &fpi->ve_dh)) {
NMG_CK_VED(ved);
if (ved->magic_p == &vu->v_p->magic) {
goto found;
}
}
/* if we get here, we didn't find the vertex in the list of
* previously classified geometry. Create an entry in the
* face's list of processed geometry.
*/
VSUB2(delta, vu->v_p->vg_p->coord, fpi->pt);
BU_ALLOC(ved, struct ve_dist);
ved->magic_p = &vu->v_p->magic;
ved->dist = MAGNITUDE(delta);
if (ved->dist < fpi->tol->dist_sq) {
ved->status = NMG_FPI_TOUCHED;
if (fpi->hits == NMG_FPI_PERGEOM) {
/* need to cast vu_func pointer for actual use as a function */
void (*cfp)(struct vertexuse *, point_t, const char*);
cfp = (void (*)(struct vertexuse *, point_t, const char *))fpi->vu_func;
cfp(vu, fpi->pt, fpi->priv);
}
} else ved->status = NMG_FPI_MISSED;
ved->v1 = ved->v2 = vu->v_p;
BU_LIST_MAGIC_SET(&ved->l, NMG_VE_DIST_MAGIC);
BU_LIST_APPEND(&fpi->ve_dh, &ved->l);
found:
if (fpi->vu_func &&
ved->status == NMG_FPI_TOUCHED &&
fpi->hits == NMG_FPI_PERUSE) {
/* need to cast vu_func pointer for actual use as a function */
void (*cfp)(struct vertexuse *, point_t, const char*);
cfp = (void (*)(struct vertexuse *, point_t, const char *))fpi->vu_func;
cfp(vu, fpi->pt, fpi->priv);
}
return ved->status;
}
HIDDEN int
convert_all_cs(void)
{
int ret=0;
struct coord_sys *cs;
for (BU_LIST_FOR(cs, coord_sys, &coord_head.l)) {
if (convert_cs(cs))
ret = 1;
}
return ret;
}
fastf_t
rt_metaball_point_value_iso(const point_t *p, const struct bu_list *points)
{
struct wdb_metaballpt *mbpt;
fastf_t ret = 0.0;
point_t v;
for (BU_LIST_FOR(mbpt, wdb_metaballpt, points)) {
VSUB2(v, mbpt->coord, *p);
ret += fabs(mbpt->fldstr) * mbpt->fldstr / MAGSQ(v); /* f/r^2 */
}
return ret;
}
/**
* Make human-readable formatted presentation of this solid. First
* line describes type of solid. Additional lines are indented one
* tab, and give parameter values.
*/
int
rt_metaball_describe(struct bu_vls *str, const struct rt_db_internal *ip, int verbose, double UNUSED(mm2local))
{
int metaball_count = 0;
char buf[BUFSIZ];
struct rt_metaball_internal *mb;
struct wdb_metaballpt *mbpt;
RT_CK_DB_INTERNAL(ip);
mb = (struct rt_metaball_internal *)ip->idb_ptr;
RT_METABALL_CK_MAGIC(mb);
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head)) metaball_count++;
snprintf(buf, BUFSIZ, "Metaball with %d points and a threshold of %g (%s rendering)\n", metaball_count, mb->threshold, rt_metaball_lookup_type_name(mb->method));
bu_vls_strcat(str, buf);
if (!verbose)
return 0;
metaball_count = 0;
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head)) {
switch (mb->method) {
case METABALL_ISOPOTENTIAL:
snprintf(buf, BUFSIZ, "\t%d: %g field strength at (%g, %g, %g)\n",
++metaball_count, mbpt->fldstr, V3ARGS(mbpt->coord));
break;
case METABALL_METABALL:
case METABALL_BLOB:
snprintf(buf, BUFSIZ, "\t%d: %g field strength at (%g, %g, %g) and blobbiness factor of %g\n",
++metaball_count, mbpt->fldstr, V3ARGS(mbpt->coord), mbpt->sweat);
break;
default:
bu_bomb("Bad metaball method"); /* asplode */
}
bu_vls_strcat(str, buf);
}
return 0;
}
