static union tree *
process_region(const struct db_full_path *pathp, union tree *curtree, struct db_tree_state *tsp)
{
/* Begin bomb protection */
if (!BU_SETJUMP) {
/* try */
union tree *ret_tree;
printf("Attempting to process region %s\n", db_path_to_string(pathp));
fflush(stdout);
ret_tree = nmg_booltree_evaluate(curtree, tsp->ts_tol, &rt_uniresource);
if (ret_tree != curtree) {
db_free_tree(curtree, &rt_uniresource);
}
return ret_tree;
} else {
/* catch */
/* Error, bail out */
char *sofar;
BU_UNSETJUMP; /* Relinquish the protection */
sofar = db_path_to_string(pathp);
bu_log("FAILED in Boolean evaluation: %s\n", sofar);
fprintf(fpe, "Failed Bool. Eval.: %s\n", sofar);
fflush(fpe);
bu_free((char *)sofar, "sofar");
/* Sometimes the NMG library adds debugging bits when
* it detects an internal error, before bombing out.
*/
RTG.NMG_debug = NMG_debug; /* restore mode */
/* Release any intersector 2d tables */
nmg_isect2d_final_cleanup();
/* Release the tree memory & input regions */
/* FIXME: memory leak? */
/* db_free_tree(curtree);*/ /* Does an nmg_kr() */
/* Get rid of (m)any other intermediate structures */
if ((*tsp->ts_m)->magic == NMG_MODEL_MAGIC) {
nmg_km(*tsp->ts_m);
} else {
bu_log("WARNING: tsp->ts_m pointer corrupted, ignoring it.\n");
}
/* Now, make a new, clean model structure for next pass. */
*tsp->ts_m = nmg_mm();
return TREE_NULL;
}
}
/*
* Called from db_walk_tree().
*
* This routine must be prepared to run in parallel.
*/
union tree *
do_region_end(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *curtree, void *client_data)
{
struct plate_mode *pmp = (struct plate_mode *)client_data;
char *name;
BARRIER_CHECK;
if ( tsp->ts_is_fastgen != REGION_FASTGEN_PLATE ) {
clean_pmp( pmp );
return nmg_region_end(tsp, pathp, curtree, client_data);
}
/* FASTGEN plate mode region, just spew the bot triangles */
if ( pmp->num_bots < 1 || pmp->num_nonbots > 0 ) {
clean_pmp( pmp );
BARRIER_CHECK;
return nmg_region_end(tsp, pathp, curtree, client_data);
}
if (RT_G_DEBUG&DEBUG_TREEWALK || verbose) {
bu_log("\nConverted %d%% so far (%d of %d)\n",
regions_tried>0 ? (regions_converted * 100) / regions_tried : 0,
regions_converted, regions_tried );
}
regions_tried++;
name = db_path_to_string( pathp );
bu_log( "Attempting %s\n", name );
bu_free( name, "db_path_to_string" );
bot2vrml( pmp, pathp, tsp->ts_regionid );
clean_pmp( pmp );
regions_converted++;
BARRIER_CHECK;
return (union tree *)NULL;
}
static union tree *
bev_facetize_region_end(struct db_tree_state *UNUSED(tsp), const struct db_full_path *pathp, union tree *curtree, genptr_t client_data)
{
struct bu_list vhead;
struct ged *gedp = (struct ged *)client_data;
BU_LIST_INIT(&vhead);
if (RT_G_DEBUG&DEBUG_TREEWALK) {
char *sofar = db_path_to_string(pathp);
bu_vls_printf(gedp->ged_result_str, "bev_facetize_region_end() path='%s'\n", sofar);
bu_free((genptr_t)sofar, "path string");
}
if (curtree->tr_op == OP_NOP) return curtree;
bu_semaphore_acquire(RT_SEM_MODEL);
if (bev_facetize_tree) {
union tree *tr;
BU_ALLOC(tr, union tree);
RT_TREE_INIT(tr);
tr->tr_op = OP_UNION;
tr->tr_b.tb_regionp = REGION_NULL;
tr->tr_b.tb_left = bev_facetize_tree;
tr->tr_b.tb_right = curtree;
bev_facetize_tree = tr;
} else {
bev_facetize_tree = curtree;
}
bu_semaphore_release(RT_SEM_MODEL);
/* Tree has been saved, and will be freed later */
return TREE_NULL;
}
void
db_pr_full_path(const char *msg, const struct db_full_path *pathp)
{
char *sofar = db_path_to_string(pathp);
bu_log("%s %s\n", msg, sofar);
bu_free(sofar, "path string");
}
/**
* JRA's tree pretty-printer. Formats the tree compactly into a
* dynamically allocated string. Uses recursion and lots of
* malloc/free activity.
*/
char *
rt_pr_tree_str(const union tree *tree)
{
char *left, *right;
char *return_str;
char op = OP_GUARD;
size_t return_length;
if (tree == NULL)
return bu_strdup("NULL_ptr");
RT_CK_TREE(tree);
if (tree->tr_op == OP_UNION || tree->tr_op == OP_SUBTRACT || tree->tr_op == OP_INTERSECT) {
char *blankl, *blankr;
left = rt_pr_tree_str(tree->tr_b.tb_left);
right = rt_pr_tree_str(tree->tr_b.tb_right);
switch (tree->tr_op) {
case OP_UNION:
op = 'u';
break;
case OP_SUBTRACT:
op = '-';
break;
case OP_INTERSECT:
op = '+';
break;
}
return_length = strlen(left) + strlen(right) + 8;
return_str = (char *)bu_malloc(return_length, "rt_pr_tree_str: return string");
blankl = strchr(left, ' ');
blankr = strchr(right, ' ');
if (blankl && blankr)
snprintf(return_str, return_length, "(%s) %c (%s)", left, op, right);
else if (blankl && !blankr)
snprintf(return_str, return_length, "(%s) %c %s", left, op, right);
else if (!blankl && blankr)
snprintf(return_str, return_length, "%s %c (%s)", left, op, right);
else
snprintf(return_str, return_length, "%s %c %s", left, op, right);
if (tree->tr_b.tb_left->tr_op != OP_DB_LEAF)
bu_free((void *)left, "rt_pr_tree_str: left string");
if (tree->tr_b.tb_right->tr_op != OP_DB_LEAF)
bu_free((void *)right, "rt_pr_tree_str: right string");
return return_str;
} else if (tree->tr_op == OP_DB_LEAF)
return bu_strdup(tree->tr_l.tl_name);
else if (tree->tr_op == OP_REGION)
return db_path_to_string(&tree->tr_c.tc_ctsp->cts_p);
else if (tree->tr_op == OP_SOLID) {
RT_CK_SOLTAB(tree->tr_a.tu_stp);
return bu_strdup(tree->tr_a.tu_stp->st_dp->d_namep);
}
return bu_strdup("Unknown:tr_op");
}
/**
* L E A F _ F U N C
*
* @brief Function to process a leaf node.
*
* This is actually invoked from db_recurse() from db_walk_subtree().
*
* @return (union tree *) representing the leaf, or
* TREE_NULL if leaf does not exist or has an error.
*/
union tree *
leaf_func (struct db_tree_state *UNUSED(tsp),
const struct db_full_path *pathp,
struct rt_db_internal *internp,
genptr_t UNUSED(client_data))
{
/* the rt_db_internal structure is used to manage the payload of
* "internal" or "in memory" representation of geometry as opposed
* to different the "on-disk" serialized "external" version.
*/
struct rt_db_internal *ip = internp; /* only set for commenting
purposes */
if (debug&DEBUG_NAMES) {
char *name = db_path_to_string(pathp);
bu_log("leaf_func %s\n", name);
bu_free(name, "region_end name");
}
/* here we do primitive type specific processing */
switch (ip->idb_minor_type) {
case ID_BOT:
{
/* This is the data payload for a "Bag of Triangles" or
* "BOT" primitive. see rtgeom.h for more information
* about primitive solid specific data structures.
*/
struct rt_bot_internal *bot = (struct rt_bot_internal *)ip->idb_ptr;
RT_BOT_CK_MAGIC(bot); /* check for data corruption */
/* code to process bot goes here */
break;
}
case ID_ARB8:
{
struct rt_arb_internal *arb = (struct rt_arb_internal *)ip->idb_ptr;
RT_ARB_CK_MAGIC(arb);
/* code to process arb goes here */
break;
}
/*
* Note: A complete program would process each possible type of object here,
* not just a couple of primitive types
*/
}
return (union tree *)NULL;
}
/**
* R E G I O N _ S T A R T
*
* @brief This routine is called when a region is first encountered in the
* hierarchy when processing a tree
*
* @param pathp A listing of all the nodes traversed to get to this node in the database
*/
int
region_start(struct db_tree_state *UNUSED(tsp),
const struct db_full_path *pathp,
const struct rt_comb_internal *UNUSED(combp),
genptr_t UNUSED(client_data))
{
if (debug&DEBUG_NAMES) {
char *name = db_path_to_string(pathp);
bu_log("region_start %s\n", name);
bu_free(name, "reg_start name");
}
return 0;
}
/**
* R E G I O N _ E N D
*
*
* @brief This is called when all sub-elements of a region have been processed by leaf_func.
*
* @param pathp
* @param curtree
*
* @return TREE_NULL if data in curtree was "stolen", otherwise db_walk_tree will
* clean up the data in the union tree * that is returned
*
* If it wants to retain the data in curtree it can by returning TREE_NULL. Otherwise
* db_walk_tree will clean up the data in the union tree * that is returned.
*
*/
union tree *
region_end(struct db_tree_state *UNUSED(tsp),
const struct db_full_path * pathp,
union tree *curtree,
genptr_t UNUSED(client_data))
{
if (debug&DEBUG_NAMES) {
char *name = db_path_to_string(pathp);
bu_log("region_end %s\n", name);
bu_free(name, "region_end name");
}
return curtree;
}
union tree *get_layer(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *UNUSED(curtree), void *UNUSED(client_data))
{
char *layer_name;
int color_num;
layer_name = db_path_to_string(pathp);
color_num = find_closest_color(tsp->ts_mater.ma_color);
fprintf(fp, "0\nLAYER\n2\n%s\n62\n%d\n", layer_name, color_num);
bu_free(layer_name, "layer name");
return (union tree *)NULL;
}
/**
* @brief This is called when all sub-elements of a region have been processed by leaf_func.
*
* @param tsp tree state
* @param pathp db path
* @param curtree current tree
*
* @return TREE_NULL if data in curtree was "stolen", otherwise db_walk_tree will
* clean up the data in the union tree * that is returned
*
* If it wants to retain the data in curtree it can by returning TREE_NULL. Otherwise
* db_walk_tree will clean up the data in the union tree * that is returned.
*
*/
union tree *
region_end (struct db_tree_state *tsp,
const struct db_full_path *pathp,
union tree *curtree,
void *UNUSED(client_data))
{
char *name;
RT_CK_DBTS(tsp);
name = db_path_to_string(pathp);
bu_log("region_end %s\n", name);
bu_free(name, "region_end name");
return curtree;
}
static union tree *
process_boolean(union tree *curtree, struct db_tree_state *tsp, const struct db_full_path *pathp)
{
union tree *ret_tree = TREE_NULL;
/* Begin bomb protection */
if (!BU_SETJUMP) {
/* try */
(void)nmg_model_fuse(*tsp->ts_m, tsp->ts_tol);
ret_tree = nmg_booltree_evaluate(curtree, tsp->ts_tol, &rt_uniresource);
} else {
/* catch */
char *name = db_path_to_string(pathp);
/* Error, bail out */
bu_log("conversion of %s FAILED!\n", name);
/* Sometimes the NMG library adds debugging bits when
* it detects an internal error, before before bombing out.
*/
RTG.NMG_debug = NMG_debug;/* restore mode */
/* Release any intersector 2d tables */
nmg_isect2d_final_cleanup();
/* Release the tree memory & input regions */
db_free_tree(curtree, &rt_uniresource);/* Does an nmg_kr() */
/* Get rid of (m)any other intermediate structures */
if ((*tsp->ts_m)->magic == NMG_MODEL_MAGIC) {
nmg_km(*tsp->ts_m);
} else {
bu_log("WARNING: tsp->ts_m pointer corrupted, ignoring it.\n");
}
bu_free(name, "db_path_to_string");
/* Now, make a new, clean model structure for next pass. */
*tsp->ts_m = nmg_mm();
} BU_UNSETJUMP;/* Relinquish the protection */
return ret_tree;
}
static int
process_boolean(union tree *curtree, struct db_tree_state *tsp, const struct db_full_path *pathp, struct _ged_client_data *dgcdp)
{
int result = 1;
if (!BU_SETJUMP) {
/* try */
result = nmg_boolean(curtree, *tsp->ts_m, tsp->ts_tol, tsp->ts_resp);
} else {
/* catch */
char *sofar = db_path_to_string(pathp);
bu_vls_printf(dgcdp->gedp->ged_result_str, "WARNING: Boolean evaluation of %s failed!\n", sofar);
bu_free((void *)sofar, "path string");
} BU_UNSETJUMP;
return result;
}
static union tree *
process_boolean(struct db_tree_state *tsp, union tree *curtree, const struct db_full_path *pathp)
{
union tree *result = NULL;
/* Begin bomb protection */
if (!BU_SETJUMP) {
/* try */
(void)nmg_model_fuse(*tsp->ts_m, tsp->ts_tol);
result = nmg_booltree_evaluate(curtree, tsp->ts_tol, &rt_uniresource);
} else {
/* catch */
char *sofar;
/* Error, bail out */
sofar = db_path_to_string(pathp);
bu_log("FAILED: Cannot convert %s!\n", sofar);
bu_free(sofar, "path string");
/* Sometimes the NMG library adds debugging bits when
* it detects an internal error, before bombing out.
*/
RTG.NMG_debug = NMG_debug; /* restore mode */
/* Release the tree memory & input regions */
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
/* Get rid of (m)any other intermediate structures */
if ((*tsp->ts_m)->magic == NMG_MODEL_MAGIC)
nmg_km(*tsp->ts_m);
/* Now, make a new, clean model structure for next pass. */
*tsp->ts_m = nmg_mm();
} BU_UNSETJUMP; /* Relinquish the protection */
return result;
}
static void
draw_forced_wireframe(
const struct db_full_path *pathp,
const struct _ged_client_data *dgcdp)
{
int ac = 1;
const char *av[2];
/* draw the path with the given client data, but force wireframe mode */
struct _ged_client_data dgcd = *dgcdp;
dgcd.gedp->ged_gdp->gd_shaded_mode = 0;
dgcd.shaded_mode_override = _GED_SHADED_MODE_UNSET;
dgcd.dmode = _GED_WIREFRAME;
av[0] = db_path_to_string(pathp);
av[1] = (char *)0;
_ged_drawtrees(dgcd.gedp, ac, av, _GED_DRAW_WIREFRAME, &dgcd);
bu_free((void *)av[0], "draw_forced_wireframe: av[0]");
}
static void
plot_shaded(
struct db_tree_state *tsp,
const struct db_full_path *pathp,
struct rt_db_internal *ip,
struct _ged_client_data *dgcdp)
{
if (ip->idb_major_type == DB5_MAJORTYPE_BRLCAD &&
(ip->idb_minor_type == DB5_MINORTYPE_BRLCAD_BOT ||
ip->idb_minor_type == DB5_MINORTYPE_BRLCAD_POLY ||
ip->idb_minor_type == DB5_MINORTYPE_BRLCAD_BREP))
{
struct bu_list vhead;
BU_LIST_INIT(&vhead);
switch (ip->idb_minor_type) {
case DB5_MINORTYPE_BRLCAD_BOT:
(void)rt_bot_plot_poly(&vhead, ip, tsp->ts_ttol, tsp->ts_tol);
break;
case DB5_MINORTYPE_BRLCAD_POLY:
(void)rt_pg_plot_poly(&vhead, ip, tsp->ts_ttol, tsp->ts_tol);
break;
case DB5_MINORTYPE_BRLCAD_BREP:
(void)rt_brep_plot_poly(&vhead, pathp, ip, tsp->ts_ttol,
tsp->ts_tol, NULL);
}
_ged_drawH_part2(0, &vhead, pathp, tsp, dgcdp);
} else {
int ac = 1;
const char *av[2];
av[0] = db_path_to_string(pathp);
av[1] = (char *)0;
_ged_drawtrees(dgcdp->gedp, ac, av, _GED_DRAW_NMG_POLY, dgcdp);
bu_free((void *)av[0], "plot_shaded: av[0]");
}
}
static int
process_triangulation(struct db_tree_state *tsp, const struct db_full_path *pathp, struct _ged_client_data *dgcdp)
{
int result = 1;
if (!BU_SETJUMP) {
/* try */
nmg_triangulate_model(*tsp->ts_m, tsp->ts_tol);
result = 0;
} else {
/* catch */
char *sofar = db_path_to_string(pathp);
bu_vls_printf(dgcdp->gedp->ged_result_str, "WARNING: Triangulation of %s failed!\n", sofar);
bu_free((void *)sofar, "path string");
} BU_UNSETJUMP;
return result;
}
static void
process_triangulation(struct nmgregion *r, const struct db_full_path *pathp, struct db_tree_state *tsp)
{
if (!BU_SETJUMP) {
/* try */
/* Write the facetized region to the output file */
output_nmg(r, pathp, tsp->ts_regionid, tsp->ts_gmater);
} else {
/* catch */
char *sofar;
sofar = db_path_to_string(pathp);
bu_log("FAILED in triangulator: %s\n", sofar);
bu_free((char *)sofar, "sofar");
/* Sometimes the NMG library adds debugging bits when
* it detects an internal error, before bombing out.
*/
RTG.NMG_debug = NMG_debug; /* restore mode */
/* Release any intersector 2d tables */
nmg_isect2d_final_cleanup();
/* Get rid of (m)any other intermediate structures */
if ((*tsp->ts_m)->magic == NMG_MODEL_MAGIC) {
nmg_km(*tsp->ts_m);
} else {
bu_log("WARNING: tsp->ts_m pointer corrupted, ignoring it.\n");
}
/* Now, make a new, clean model structure for next pass. */
*tsp->ts_m = nmg_mm();
} BU_UNSETJUMP;
}
/**
* @brief This routine is called when a region is first encountered in the
* hierarchy when processing a tree
*
* @param tsp tree state (for parsing the tree)
* @param pathp A listing of all the nodes traversed to get to this node in the database
* @param combp the combination record for this region
*/
int
region_start(struct db_tree_state *tsp,
const struct db_full_path *pathp,
const struct rt_comb_internal *combp,
void *client_data)
{
char *name;
struct directory *dp;
struct bu_vls str = BU_VLS_INIT_ZERO;
struct user_data *your_stuff = (struct user_data *)client_data;
RT_CK_DBTS(tsp);
name = db_path_to_string(pathp);
bu_log("region_start %s\n", name);
bu_free(name, "reg_start name");
bu_log("data = %ld\n", your_stuff->data);
rt_pr_tol(&your_stuff->tol);
dp = DB_FULL_PATH_CUR_DIR(pathp);
/* here is where the conversion should be done */
if (combp->region_flag)
printf("Write this region (name=%s) as a part in your format:\n", dp->d_namep);
else
printf("Write this combination (name=%s) as an assembly in your format:\n", dp->d_namep);
describe_tree(combp->tree, &str);
printf("\t%s\n\n", bu_vls_addr(&str));
bu_vls_free(&str);
return 0;
}
void
bot2vrml( struct plate_mode *pmp, const struct db_full_path *pathp, int region_id )
{
char *path_str;
int appearance;
struct rt_bot_internal *bot;
int bot_num;
size_t i;
size_t vert_count=0;
BARRIER_CHECK;
path_str = db_path_to_string( pathp );
/* replace all occurrences of '.' with '_' */
char_replace(path_str, '.', '_');
fprintf( outfp, "\t<Shape DEF=\"%s\">\n", path_str);
bu_free( path_str, "result of db_path_to_string" );
appearance = region_id / 1000;
appearance = appearance * 1000 + 999;
fprintf( outfp, "\t\t<Appearance USE=\"Material_%d\">\n", appearance);
fprintf( outfp, "\t\t<IndexedFaceSet coordIndex=\"\n");
vert_count = 0;
for ( bot_num = 0; bot_num < pmp->num_bots; bot_num++ ) {
bot = pmp->bots[bot_num];
RT_BOT_CK_MAGIC( bot );
for ( i=0; i<bot->num_faces; i++ )
fprintf( outfp, "\t\t\t\t%lu, %lu, %lu, -1,\n",
(long unsigned int)vert_count+bot->faces[i*3],
(long unsigned int)vert_count+bot->faces[i*3+1],
(long unsigned int)vert_count+bot->faces[i*3+2]);
vert_count += bot->num_vertices;
}
/* close coordIndex */
fprintf( outfp, "\" ");
fprintf( outfp, "normalPerVertex=\"false\" ");
fprintf( outfp, "convex=\"true\" ");
fprintf( outfp, "creaseAngle=\"0.5\" ");
fprintf( outfp, "solid=\"false\" ");
/* close IndexedFaceSet open tag */
fprintf( outfp, ">\n");
fprintf( outfp, "\t\t<Coordinate point=\"");
for ( bot_num = 0; bot_num < pmp->num_bots; bot_num++ ) {
bot = pmp->bots[bot_num];
RT_BOT_CK_MAGIC( bot );
for ( i=0; i<bot->num_vertices; i++ )
{
point_t pt;
VSCALE( pt, &bot->vertices[i*3], scale_factor );
fprintf( outfp, "%10.10e %10.10e %10.10e, ", V3ARGS( pt ));
vert_count++;
}
}
/* close point */
fprintf(outfp, "\"");
/* close Coordinate */
fprintf(outfp, "/>\n");
/* IndexedFaceSet end tag */
fprintf( outfp, "\t\t</IndexedFaceSet>\n");
/* Shape end tag */
fprintf( outfp, "\t</Shape>\n");
BARRIER_CHECK;
}
static void
nmg_to_egg(struct nmgregion *r, const struct db_full_path *pathp, int UNUSED(region_id), int UNUSED(material_id), float UNUSED(color[3]), void *client_data)
{
struct model *m;
struct shell *s;
struct vertex *v;
char *region_name;
int region_polys=0;
int vert_count=0;
struct egg_conv_data *conv_data = (struct egg_conv_data *)client_data;
NMG_CK_REGION(r);
RT_CK_FULL_PATH(pathp);
region_name = db_path_to_string(pathp);
m = r->m_p;
NMG_CK_MODEL(m);
/* triangulate model */
nmg_triangulate_model(m, &conv_data->tol);
/* Write pertinent info for this region */
fprintf(conv_data->fp, " <VertexPool> %s {\n", (region_name+1));
/* Build the VertexPool */
for (BU_LIST_FOR (s, shell, &r->s_hd)) {
struct faceuse *fu;
NMG_CK_SHELL(s);
for (BU_LIST_FOR (fu, faceuse, &s->fu_hd)) {
struct loopuse *lu;
vect_t facet_normal;
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME)
continue;
/* Grab the face normal and save it for all the vertex loops */
NMG_GET_FU_NORMAL(facet_normal, fu);
for (BU_LIST_FOR (lu, loopuse, &fu->lu_hd)) {
struct edgeuse *eu;
NMG_CK_LOOPUSE(lu);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC)
continue;
/* check vertex numbers for each triangle */
for (BU_LIST_FOR (eu, edgeuse, &lu->down_hd)) {
NMG_CK_EDGEUSE(eu);
vert_count++;
v = eu->vu_p->v_p;
NMG_CK_VERTEX(v);
fprintf(conv_data->fp, " <Vertex> %d {\n %f %f %f\n <Normal> { %f %f %f }\n }\n",
vert_count,
V3ARGS(v->vg_p->coord),
V3ARGS(facet_normal));
}
}
}
}
fprintf(conv_data->fp, " }\n");
vert_count = 0;
for (BU_LIST_FOR (s, shell, &r->s_hd)) {
struct faceuse *fu;
NMG_CK_SHELL(s);
for (BU_LIST_FOR (fu, faceuse, &s->fu_hd)) {
struct loopuse *lu;
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME)
continue;
for (BU_LIST_FOR (lu, loopuse, &fu->lu_hd)) {
struct edgeuse *eu;
NMG_CK_LOOPUSE(lu);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC)
continue;
fprintf(conv_data->fp, " <Polygon> { \n <RGBA> { 1 1 1 1 } \n <VertexRef> { ");
/* check vertex numbers for each triangle */
for (BU_LIST_FOR (eu, edgeuse, &lu->down_hd)) {
NMG_CK_EDGEUSE(eu);
vert_count++;
v = eu->vu_p->v_p;
NMG_CK_VERTEX(v);
fprintf(conv_data->fp, " %d", vert_count);
}
fprintf(conv_data->fp, " <Ref> { \"%s\" } }\n }\n", region_name+1);
region_polys++;
}
}
}
conv_data->tot_polygons += region_polys;
bu_free(region_name, "region name");
}
/* routine to output the faceted NMG representation of a BRL-CAD region */
static void
output_nmg(struct nmgregion *r, const struct db_full_path *pathp, int UNUSED(region_id), int UNUSED(material_id))
{
struct model *m;
struct shell *s;
struct vertex *v;
char *region_name;
NMG_CK_REGION(r);
RT_CK_FULL_PATH(pathp);
region_name = db_path_to_string(pathp);
m = r->m_p;
NMG_CK_MODEL(m);
/* triangulate model */
nmg_triangulate_model(m, &tol);
/* Output triangles */
if (verbose) {
printf("Convert these triangles to your format for region %s\n", region_name);
} else {
printf("Converted %s\n", region_name);
}
for (BU_LIST_FOR(s, shell, &r->s_hd))
{
struct faceuse *fu;
NMG_CK_SHELL(s);
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd))
{
struct loopuse *lu;
/* vect_t facet_normal; */
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME)
continue;
/* Grab the face normal if needed */
/* NMG_GET_FU_NORMAL(facet_normal, fu); */
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd))
{
struct edgeuse *eu;
NMG_CK_LOOPUSE(lu);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC)
continue;
/* loop through the edges in this loop (facet) */
if (verbose)
printf("\tfacet:\n");
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd))
{
NMG_CK_EDGEUSE(eu);
v = eu->vu_p->v_p;
NMG_CK_VERTEX(v);
if (verbose)
printf("\t\t(%g %g %g)\n", V3ARGS(v->vg_p->coord));
}
tot_polygons++;
}
}
}
bu_free(region_name, "region name");
}
/*
* D O _ R E G I O N _ E N D
*
* Called from db_walk_tree().
*
* This routine must be prepared to run in parallel.
*/
union tree *do_region_end(register struct db_tree_state *tsp, struct db_full_path *pathp, union tree *curtree, genptr_t client_data)
{
union tree *ret_tree;
struct nmgregion *r;
struct bu_list vhead;
RT_CK_TESS_TOL(tsp->ts_ttol);
BN_CK_TOL(tsp->ts_tol);
NMG_CK_MODEL(*tsp->ts_m);
BU_LIST_INIT(&vhead);
if (RT_G_DEBUG&DEBUG_TREEWALK || verbose) {
char *sofar = db_path_to_string(pathp);
bu_log("\ndo_region_end(%d %d%%) %s\n",
regions_tried,
regions_tried>0 ? (regions_done * 100) / regions_tried : 0,
sofar);
bu_free(sofar, "path string");
}
if (curtree->tr_op == OP_NOP)
return curtree;
regions_tried++;
/* Begin bomb protection */
if ( ncpu == 1 ) {
if ( BU_SETJUMP ) {
/* Error, bail out */
BU_UNSETJUMP; /* Relinquish the protection */
/* Sometimes the NMG library adds debugging bits when
* it detects an internal error, before bombing out.
*/
rt_g.NMG_debug = NMG_debug; /* restore mode */
/* Release the tree memory & input regions */
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
/* Get rid of (m)any other intermediate structures */
if ( (*tsp->ts_m)->magic != -1L )
nmg_km(*tsp->ts_m);
/* Now, make a new, clean model structure for next pass. */
*tsp->ts_m = nmg_mm();
goto out;
}
}
(void)nmg_model_fuse(*tsp->ts_m, tsp->ts_tol);
ret_tree = nmg_booltree_evaluate(curtree, tsp->ts_tol, &rt_uniresource); /* librt/nmg_bool.c */
BU_UNSETJUMP; /* Relinquish the protection */
if ( ret_tree )
r = ret_tree->tr_d.td_r;
else
r = (struct nmgregion *)NULL;
regions_done++;
if (r != 0) {
FILE *fp_psurf;
int i;
struct bu_vls file_base;
struct bu_vls file;
bu_vls_init(&file_base);
bu_vls_init(&file);
bu_vls_strcpy(&file_base, prefix);
bu_vls_strcat(&file_base, DB_FULL_PATH_CUR_DIR(pathp)->d_namep);
/* Dots confuse Jack's Peabody language. Change to '_'. */
for (i = 0; i < file_base.vls_len; i++)
if (file_base.vls_str[i] == '.')
file_base.vls_str[i] = '_';
/* Write color attribute to .fig figure file. */
if (tsp->ts_mater.ma_color_valid != 0) {
fprintf(fp_fig, "\tattribute %s {\n",
bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\trgb = (%f, %f, %f);\n",
V3ARGS(tsp->ts_mater.ma_color));
fprintf(fp_fig, "\t\tambient = 0.18;\n");
fprintf(fp_fig, "\t\tdiffuse = 0.72;\n");
fprintf(fp_fig, "\t}\n");
}
/* Write segment attributes to .fig figure file. */
fprintf(fp_fig, "\tsegment %s_seg {\n", bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\tpsurf=\"%s.pss\";\n", bu_vls_addr(&file_base));
if (tsp->ts_mater.ma_color_valid != 0)
fprintf(fp_fig,
"\t\tattribute=%s;\n", bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\tsite base->location=trans(0, 0, 0);\n");
fprintf(fp_fig, "\t}\n");
if ( bu_vls_strlen(&base_seg) <= 0 ) {
bu_vls_vlscat( &base_seg, &file_base );
} else {
fprintf(fp_fig, "\tjoint %s_jt {\n",
bu_vls_addr(&file_base));
fprintf(fp_fig,
"\t\tconnect %s_seg.base to %s_seg.base;\n",
bu_vls_addr(&file_base),
bu_vls_addr(&base_seg) );
fprintf(fp_fig, "\t}\n");
}
bu_vls_vlscat(&file, &file_base);
bu_vls_strcat(&file, ".pss"); /* Required Jack suffix. */
/* Write psurf to .pss file. */
if ((fp_psurf = fopen(bu_vls_addr(&file), "wb")) == NULL)
perror(bu_vls_addr(&file));
else {
nmg_to_psurf(r, fp_psurf);
fclose(fp_psurf);
if (verbose) bu_log("*** Wrote %s\n", bu_vls_addr(&file));
}
bu_vls_free(&file);
/* Also write as UNIX-plot file, if desired */
if ( debug_plots ) {
FILE *fp;
bu_vls_vlscat(&file, &file_base);
bu_vls_strcat(&file, ".pl");
if ((fp = fopen(bu_vls_addr(&file), "wb")) == NULL)
perror(bu_vls_addr(&file));
else {
struct bu_list vhead;
pl_color( fp,
(int)(tsp->ts_mater.ma_color[0] * 255),
(int)(tsp->ts_mater.ma_color[1] * 255),
(int)(tsp->ts_mater.ma_color[2] * 255) );
/* nmg_pl_r( fp, r ); */
BU_LIST_INIT( &vhead );
nmg_r_to_vlist( &vhead, r, 0 );
rt_vlist_to_uplot( fp, &vhead );
fclose(fp);
if (verbose) bu_log("*** Wrote %s\n", bu_vls_addr(&file));
}
bu_vls_free(&file);
}
/* NMG region is no longer necessary */
nmg_kr(r);
}
/*
* Dispose of original tree, so that all associated dynamic
* memory is released now, not at the end of all regions.
* A return of TREE_NULL from this routine signals an error,
* so we need to cons up an OP_NOP node to return.
*/
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
out:
BU_GETUNION(curtree, tree);
curtree->magic = RT_TREE_MAGIC;
curtree->tr_op = OP_NOP;
return(curtree);
}
void
nmg_2_vrml(struct db_tree_state *tsp, const struct db_full_path *pathp, struct model *m)
{
struct mater_info *mater = &tsp->ts_mater;
const struct bn_tol *tol2 = tsp->ts_tol;
struct nmgregion *reg;
struct bu_ptbl verts;
struct vrml_mat mat;
struct bu_vls vls = BU_VLS_INIT_ZERO;
char *tok;
int i;
int first = 1;
int is_light = 0;
point_t ave_pt = VINIT_ZERO;
struct bu_vls shape_name = BU_VLS_INIT_ZERO;
char *full_path;
/* There may be a better way to capture the region_id, than
* getting the rt_comb_internal structure, (and may be a better
* way to capture the rt_comb_internal struct), but for now I just
* copied the method used in select_lights/select_non_lights above,
* could have used a global variable but I noticed none other were
* used, so I didn't want to be the first
*/
struct directory *dp;
struct rt_db_internal intern;
struct rt_comb_internal *comb;
int id;
/* static due to libbu exception handling */
static float r, g, b;
NMG_CK_MODEL(m);
full_path = db_path_to_string(pathp);
RT_CK_FULL_PATH(pathp);
dp = DB_FULL_PATH_CUR_DIR(pathp);
if (!(dp->d_flags & RT_DIR_COMB)) {
return;
}
id = rt_db_get_internal(&intern, dp, dbip, (matp_t)NULL, &rt_uniresource);
if (id < 0) {
bu_log("Cannot internal form of %s\n", dp->d_namep);
return;
}
if (id != ID_COMBINATION) {
bu_log("Directory/database mismatch!\n\t is '%s' a combination or not?\n",
dp->d_namep);
return;
}
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB(comb);
if (mater->ma_color_valid) {
r = mater->ma_color[0];
g = mater->ma_color[1];
b = mater->ma_color[2];
} else {
r = g = b = 0.5;
}
if (mater->ma_shader) {
tok = strtok(mater->ma_shader, tok_sep);
bu_strlcpy(mat.shader, tok, TXT_NAME_SIZE);
} else {
mat.shader[0] = '\0';
}
mat.shininess = -1;
mat.transparency = -1.0;
mat.lt_fraction = -1.0;
VSETALL(mat.lt_dir, 0.0);
mat.lt_angle = -1.0;
mat.tx_file[0] = '\0';
mat.tx_w = -1;
mat.tx_n = -1;
bu_vls_strcpy(&vls, &mater->ma_shader[strlen(mat.shader)]);
(void)bu_struct_parse(&vls, vrml_mat_parse, (char *)&mat, NULL);
if (bu_strncmp("light", mat.shader, 5) == 0) {
/* this is a light source */
is_light = 1;
} else {
path_2_vrml_id(&shape_name, full_path);
fprintf(fp_out, "\t\tDEF %s Shape {\n", bu_vls_addr(&shape_name));
fprintf(fp_out, "\t\t\t# Component_ID: %ld %s\n", comb->region_id, full_path);
fprintf(fp_out, "\t\t\tappearance Appearance {\n");
if (bu_strncmp("plastic", mat.shader, 7) == 0) {
if (mat.shininess < 0) {
mat.shininess = 10;
}
if (mat.transparency < SMALL_FASTF) {
mat.transparency = 0.0;
}
fprintf(fp_out, "\t\t\t\tmaterial Material {\n");
fprintf(fp_out, "\t\t\t\t\tdiffuseColor %g %g %g \n", r, g, b);
fprintf(fp_out, "\t\t\t\t\tshininess %g\n", 1.0-exp(-(double)mat.shininess/20.0));
if (mat.transparency > SMALL_FASTF) {
fprintf(fp_out, "\t\t\t\t\ttransparency %g\n", mat.transparency);
}
fprintf(fp_out, "\t\t\t\t\tspecularColor %g %g %g \n\t\t\t\t}\n", 1.0, 1.0, 1.0);
} else if (bu_strncmp("glass", mat.shader, 5) == 0) {
if (mat.shininess < 0) {
mat.shininess = 4;
}
if (mat.transparency < SMALL_FASTF) {
mat.transparency = 0.8;
}
fprintf(fp_out, "\t\t\t\tmaterial Material {\n");
fprintf(fp_out, "\t\t\t\t\tdiffuseColor %g %g %g \n", r, g, b);
fprintf(fp_out, "\t\t\t\t\tshininess %g\n", 1.0-exp(-(double)mat.shininess/20.0));
if (mat.transparency > SMALL_FASTF) {
fprintf(fp_out, "\t\t\t\t\ttransparency %g\n", mat.transparency);
}
fprintf(fp_out, "\t\t\t\t\tspecularColor %g %g %g \n\t\t\t\t}\n", 1.0, 1.0, 1.0);
} else if (bu_strncmp("texture", mat.shader, 7) == 0) {
if (mat.tx_w < 0) {
mat.tx_w = 512;
}
if (mat.tx_n < 0) {
mat.tx_n = 512;
}
if (strlen(mat.tx_file)) {
int tex_fd;
unsigned char tex_buf[TXT_BUF_LEN * 3];
if ((tex_fd = open(mat.tx_file, O_RDONLY | O_BINARY)) == (-1)) {
bu_log("Cannot open texture file (%s)\n", mat.tx_file);
perror("g-vrml: ");
} else {
long tex_len;
long bytes_read = 0;
long bytes_to_go = 0;
/* Johns note - need to check (test) the texture stuff */
fprintf(fp_out, "\t\t\t\ttextureTransform TextureTransform {\n");
fprintf(fp_out, "\t\t\t\t\tscale 1.33333 1.33333\n\t\t\t\t}\n");
fprintf(fp_out, "\t\t\t\ttexture PixelTexture {\n");
fprintf(fp_out, "\t\t\t\t\trepeatS TRUE\n");
fprintf(fp_out, "\t\t\t\t\trepeatT TRUE\n");
fprintf(fp_out, "\t\t\t\t\timage %d %d %d\n", mat.tx_w, mat.tx_n, 3);
tex_len = mat.tx_w*mat.tx_n * 3;
while (bytes_read < tex_len) {
int nbytes;
long readval;
bytes_to_go = tex_len - bytes_read;
CLAMP(bytes_to_go, 0, TXT_BUF_LEN * 3);
nbytes = 0;
while (nbytes < bytes_to_go) {
readval = read(tex_fd, &tex_buf[nbytes], bytes_to_go-nbytes);
if (readval < 0) {
perror("READ ERROR");
break;
} else {
nbytes += readval;
}
}
bytes_read += nbytes;
for (i = 0; i < nbytes; i += 3) {
fprintf(fp_out, "\t\t\t0x%02x%02x%02x\n",
tex_buf[i], tex_buf[i+1], tex_buf[i+2]);
}
}
fprintf(fp_out, "\t\t\t\t}\n");
close(tex_fd);
}
}
} else if (mater->ma_color_valid) {
/* no shader specified, but a color is assigned */
fprintf(fp_out, "\t\t\t\tmaterial Material {\n");
fprintf(fp_out, "\t\t\t\t\tdiffuseColor %g %g %g }\n", r, g, b);
} else {
/* If no color was defined set the colors according to the thousands groups */
int thou = comb->region_id / 1000;
thou == 0 ? fprintf(fp_out, "\t\t\tmaterial USE Material_999\n")
: thou == 1 ? fprintf(fp_out, "\t\t\tmaterial USE Material_1999\n")
: thou == 2 ? fprintf(fp_out, "\t\t\tmaterial USE Material_2999\n")
: thou == 3 ? fprintf(fp_out, "\t\t\tmaterial USE Material_3999\n")
: thou == 4 ? fprintf(fp_out, "\t\t\tmaterial USE Material_4999\n")
: thou == 5 ? fprintf(fp_out, "\t\t\tmaterial USE Material_5999\n")
: thou == 6 ? fprintf(fp_out, "\t\t\tmaterial USE Material_6999\n")
: thou == 7 ? fprintf(fp_out, "\t\t\tmaterial USE Material_7999\n")
: thou == 8 ? fprintf(fp_out, "\t\t\tmaterial USE Material_8999\n")
: fprintf(fp_out, "\t\t\tmaterial USE Material_9999\n");
}
}
if (!is_light) {
nmg_triangulate_model(m, tol2);
fprintf(fp_out, "\t\t\t}\n");
fprintf(fp_out, "\t\t\tgeometry IndexedFaceSet {\n");
fprintf(fp_out, "\t\t\t\tcoord Coordinate {\n");
}
/* get list of vertices */
nmg_vertex_tabulate(&verts, &m->magic);
if (!is_light) {
fprintf(fp_out, "\t\t\t\t\tpoint [");
} else {
VSETALL(ave_pt, 0.0);
}
for (i = 0; i < BU_PTBL_END(&verts); i++) {
struct vertex *v;
struct vertex_g *vg;
point_t pt_meters;
v = (struct vertex *)BU_PTBL_GET(&verts, i);
NMG_CK_VERTEX(v);
vg = v->vg_p;
NMG_CK_VERTEX_G(vg);
/* convert to desired units */
VSCALE(pt_meters, vg->coord, scale_factor);
if (is_light) {
VADD2(ave_pt, ave_pt, pt_meters);
}
if (first) {
if (!is_light) {
fprintf(fp_out, " %10.10e %10.10e %10.10e, # point %d\n", V3ARGS(pt_meters), i);
}
first = 0;
} else if (!is_light) {
fprintf(fp_out, "\t\t\t\t\t%10.10e %10.10e %10.10e, # point %d\n", V3ARGS(pt_meters), i);
}
}
if (!is_light) {
fprintf(fp_out, "\t\t\t\t\t]\n\t\t\t\t}\n");
} else {
fastf_t one_over_count;
one_over_count = 1.0/(fastf_t)BU_PTBL_END(&verts);
VSCALE(ave_pt, ave_pt, one_over_count);
}
first = 1;
if (!is_light) {
fprintf(fp_out, "\t\t\t\tcoordIndex [\n");
for (BU_LIST_FOR(reg, nmgregion, &m->r_hd)) {
struct shell *s;
NMG_CK_REGION(reg);
for (BU_LIST_FOR(s, shell, ®->s_hd)) {
struct faceuse *fu;
NMG_CK_SHELL(s);
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
struct loopuse *lu;
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME) {
continue;
}
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
struct edgeuse *eu;
NMG_CK_LOOPUSE(lu);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC) {
continue;
}
if (!first) {
fprintf(fp_out, ",\n");
} else {
first = 0;
}
fprintf(fp_out, "\t\t\t\t\t");
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
struct vertex *v;
NMG_CK_EDGEUSE(eu);
v = eu->vu_p->v_p;
NMG_CK_VERTEX(v);
fprintf(fp_out, " %d,", bu_ptbl_locate(&verts, (long *)v));
}
fprintf(fp_out, "-1");
}
}
}
}
fprintf(fp_out, "\n\t\t\t\t]\n\t\t\t\tnormalPerVertex FALSE\n");
fprintf(fp_out, "\t\t\t\tconvex FALSE\n");
fprintf(fp_out, "\t\t\t\tcreaseAngle 0.5\n");
fprintf(fp_out, "\t\t\t}\n\t\t}\n");
} else {
static void
nmg_to_obj(struct nmgregion *r, struct db_full_path *pathp, int region_id, int aircode, int los, int material_id)
{
struct model *m;
struct shell *s;
struct vertex *v;
struct bu_ptbl verts;
struct bu_ptbl norms;
char *region_name;
int numverts = 0; /* Number of vertices to output */
int numtri = 0; /* Number of triangles to output */
int i;
NMG_CK_REGION( r );
RT_CK_FULL_PATH(pathp);
region_name = db_path_to_string( pathp );
#if 0
printf("Attempting to process region %s\n", region_name);
fflush(stdout);
#endif
m = r->m_p;
NMG_CK_MODEL( m );
/* triangulate model */
nmg_triangulate_model( m, &tol );
/* list all vertices in result */
nmg_vertex_tabulate( &verts, &r->l.magic );
/* Get number of vertices */
numverts = BU_PTBL_END (&verts);
/* get list of vertexuse normals */
if ( do_normals )
nmg_vertexuse_normal_tabulate( &norms, &r->l.magic );
/* XXX Check vertices, shells faces first? Do not want to punt mid-stream */
/* BEGIN CHECK SECTION */
/* Check vertices */
for ( i=0; i<numverts; i++ )
{
v = (struct vertex *)BU_PTBL_GET( &verts, i );
NMG_CK_VERTEX( v );
}
/* Check triangles */
for ( BU_LIST_FOR( s, shell, &r->s_hd ) )
{
struct faceuse *fu;
NMG_CK_SHELL( s );
for ( BU_LIST_FOR( fu, faceuse, &s->fu_hd ) )
{
struct loopuse *lu;
NMG_CK_FACEUSE( fu );
if ( fu->orientation != OT_SAME )
continue;
for ( BU_LIST_FOR( lu, loopuse, &fu->lu_hd ) )
{
struct edgeuse *eu;
int vert_count=0;
NMG_CK_LOOPUSE( lu );
if ( BU_LIST_FIRST_MAGIC( &lu->down_hd ) != NMG_EDGEUSE_MAGIC )
continue;
/* check vertex numbers for each triangle */
for ( BU_LIST_FOR( eu, edgeuse, &lu->down_hd ) )
{
NMG_CK_EDGEUSE( eu );
v = eu->vu_p->v_p;
NMG_CK_VERTEX( v );
vert_count++;
i = bu_ptbl_locate( &verts, (long *)v );
if ( i < 0 )
{
/*XXX*/ bu_ptbl_free( &verts);
/*XXX*/ bu_free( region_name, "region name" );
bu_log( "Vertex from eu x%x is not in nmgregion x%x\n", eu, r );
bu_exit(1, "ERROR: Can't find vertex in list!");
}
}
if ( vert_count > 3 )
{
/*XXX*/ bu_ptbl_free( &verts);
/*XXX*/ bu_free( region_name, "region name" );
bu_log( "lu x%x has %d vertices!\n", lu, vert_count );
bu_exit(1, "ERROR: LU is not a triangle\n");
}
else if ( vert_count < 3 )
continue;
numtri++;
}
}
}
/* END CHECK SECTION */
/* Write pertinent info for this region */
if ( usemtl )
fprintf( fp, "usemtl %d_%d_%d\n", aircode, los, material_id );
fprintf( fp, "g %s", pathp->fp_names[0]->d_namep );
for ( i=1; i<pathp->fp_len; i++ )
fprintf( fp, "/%s", pathp->fp_names[i]->d_namep );
fprintf( fp, "\n" );
/* Write vertices */
for ( i=0; i<numverts; i++ )
{
v = (struct vertex *)BU_PTBL_GET( &verts, i );
NMG_CK_VERTEX( v );
if (inches)
fprintf( fp, "v %f %f %f\n", V3ARGSIN( v->vg_p->coord ));
else
fprintf( fp, "v %f %f %f\n", V3ARGS( v->vg_p->coord ));
}
/* Write vertexuse normals */
if ( do_normals )
{
for ( i=0; i<BU_PTBL_END( &norms ); i++ )
{
struct vertexuse_a_plane *va;
va = (struct vertexuse_a_plane *)BU_PTBL_GET( &norms, i );
NMG_CK_VERTEXUSE_A_PLANE( va );
if (inches)
fprintf( fp, "vn %f %f %f\n", V3ARGSIN( va->N ));
else
fprintf( fp, "vn %f %f %f\n", V3ARGS( va->N ));
}
}
/* output triangles */
for ( BU_LIST_FOR( s, shell, &r->s_hd ) )
{
struct faceuse *fu;
NMG_CK_SHELL( s );
for ( BU_LIST_FOR( fu, faceuse, &s->fu_hd ) )
{
struct loopuse *lu;
NMG_CK_FACEUSE( fu );
if ( fu->orientation != OT_SAME )
continue;
for ( BU_LIST_FOR( lu, loopuse, &fu->lu_hd ) )
{
struct edgeuse *eu;
int vert_count=0;
int use_normals=1;
NMG_CK_LOOPUSE( lu );
if ( BU_LIST_FIRST_MAGIC( &lu->down_hd ) != NMG_EDGEUSE_MAGIC )
continue;
/* Each vertexuse of the face must have a normal in order
* to use the normals in Wavefront
*/
if ( do_normals )
{
for ( BU_LIST_FOR( eu, edgeuse, &lu->down_hd ) )
{
NMG_CK_EDGEUSE( eu );
if ( !eu->vu_p->a.magic_p )
{
use_normals = 0;
break;
}
if ( *eu->vu_p->a.magic_p != NMG_VERTEXUSE_A_PLANE_MAGIC )
{
use_normals = 0;
break;
}
}
}
else
use_normals = 0;
fprintf( fp, "f" );
/* list vertex numbers for each triangle */
for ( BU_LIST_FOR( eu, edgeuse, &lu->down_hd ) )
{
NMG_CK_EDGEUSE( eu );
v = eu->vu_p->v_p;
NMG_CK_VERTEX( v );
vert_count++;
i = bu_ptbl_locate( &verts, (long *)v );
if ( i < 0 )
{
bu_ptbl_free( &verts);
bu_log( "Vertex from eu x%x is not in nmgregion x%x\n", eu, r );
/*XXX*/ bu_free( region_name, "region name" );
/*XXX*/ bu_exit(1, "Can't find vertex in list!\n");
}
if ( use_normals )
{
int j;
j = bu_ptbl_locate( &norms, (long *)eu->vu_p->a.magic_p );
fprintf( fp, " %ld//%ld", i+1+vert_offset, j+1+norm_offset );
}
else
fprintf( fp, " %ld", i+1+vert_offset );
}
fprintf( fp, "\n" );
if ( vert_count > 3 )
{
bu_ptbl_free( &verts);
bu_free( region_name, "region name" );
bu_log( "lu x%x has %d vertices!\n", lu, vert_count );
bu_exit(1, "ERROR: LU is not a triangle\n" );
}
}
}
}
/**
* Produce a compact representation of this tree. The destination vls
* must be initialized by the caller.
*
* Operations are responsible for generating white space.
*/
void
rt_pr_tree_vls(struct bu_vls *vls, register const union tree *tp)
{
char *str;
if (tp == TREE_NULL) {
bu_vls_strcat(vls, "??NULL_tree??");
return;
}
switch (tp->tr_op) {
case OP_NOP:
bu_vls_strcat(vls, "NOP");
return;
case OP_SOLID:
bu_vls_strcat(vls, tp->tr_a.tu_stp->st_dp->d_namep);
return;
case OP_REGION:
str = db_path_to_string(&(tp->tr_c.tc_ctsp->cts_p));
bu_vls_strcat(vls, str);
bu_free(str, "path string");
return;
case OP_DB_LEAF:
bu_vls_strcat(vls, tp->tr_l.tl_name);
return;
default:
bu_log("rt_pr_tree_vls() Unknown op=x%x\n", tp->tr_op);
return;
case OP_UNION:
/* BINARY type */
bu_vls_strcat(vls, " (");
rt_pr_tree_vls(vls, tp->tr_b.tb_left);
bu_vls_strcat(vls, ") u (");
rt_pr_tree_vls(vls, tp->tr_b.tb_right);
bu_vls_strcat(vls, ") ");
break;
case OP_INTERSECT:
/* BINARY type */
bu_vls_strcat(vls, " (");
rt_pr_tree_vls(vls, tp->tr_b.tb_left);
bu_vls_strcat(vls, ") + (");
rt_pr_tree_vls(vls, tp->tr_b.tb_right);
bu_vls_strcat(vls, ") ");
break;
case OP_SUBTRACT:
/* BINARY type */
bu_vls_strcat(vls, " (");
rt_pr_tree_vls(vls, tp->tr_b.tb_left);
bu_vls_strcat(vls, ") - (");
rt_pr_tree_vls(vls, tp->tr_b.tb_right);
bu_vls_strcat(vls, ") ");
break;
case OP_XOR:
/* BINARY type */
bu_vls_strcat(vls, " (");
rt_pr_tree_vls(vls, tp->tr_b.tb_left);
bu_vls_strcat(vls, ") ^ (");
rt_pr_tree_vls(vls, tp->tr_b.tb_right);
bu_vls_strcat(vls, ") ");
break;
case OP_NOT:
/* UNARY tree */
bu_vls_strcat(vls, " !(");
rt_pr_tree_vls(vls, tp->tr_b.tb_left);
bu_vls_strcat(vls, ") ");
break;
case OP_GUARD:
/* UNARY tree */
bu_vls_strcat(vls, " guard(");
rt_pr_tree_vls(vls, tp->tr_b.tb_left);
bu_vls_strcat(vls, ") ");
break;
case OP_XNOP:
/* UNARY tree */
bu_vls_strcat(vls, " xnop(");
rt_pr_tree_vls(vls, tp->tr_b.tb_left);
bu_vls_strcat(vls, ") ");
break;
}
}
/*
* D O _ R E G I O N _ E N D
*
* Called from db_walk_tree().
*
* This routine must be prepared to run in parallel.
*/
union tree *do_region_end(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *curtree, genptr_t UNUSED(client_data))
{
union tree *ret_tree;
struct nmgregion *r;
RT_CK_TESS_TOL(tsp->ts_ttol);
BN_CK_TOL(tsp->ts_tol);
NMG_CK_MODEL(*tsp->ts_m);
if (RT_G_DEBUG&DEBUG_TREEWALK || verbose) {
char *sofar = db_path_to_string(pathp);
bu_log("\ndo_region_end(%d %d%%) %s\n",
regions_tried,
regions_tried>0 ? (regions_done * 100) / regions_tried : 0,
sofar);
bu_free(sofar, "path string");
}
if (curtree->tr_op == OP_NOP)
return curtree;
regions_tried++;
ret_tree = process_boolean(curtree, tsp, pathp);
if ( ret_tree )
r = ret_tree->tr_d.td_r;
else
r = (struct nmgregion *)NULL;
regions_done++;
if (r != 0) {
FILE *fp_psurf;
size_t i;
struct bu_vls file_base = BU_VLS_INIT_ZERO;
struct bu_vls file = BU_VLS_INIT_ZERO;
bu_vls_strcpy(&file_base, prefix);
bu_vls_strcat(&file_base, DB_FULL_PATH_CUR_DIR(pathp)->d_namep);
/* Dots confuse Jack's Peabody language. Change to '_'. */
for (i = 0; i < file_base.vls_len; i++)
if (file_base.vls_str[i] == '.')
file_base.vls_str[i] = '_';
/* Write color attribute to .fig figure file. */
if (tsp->ts_mater.ma_color_valid != 0) {
fprintf(fp_fig, "\tattribute %s {\n",
bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\trgb = (%f, %f, %f);\n",
V3ARGS(tsp->ts_mater.ma_color));
fprintf(fp_fig, "\t\tambient = 0.18;\n");
fprintf(fp_fig, "\t\tdiffuse = 0.72;\n");
fprintf(fp_fig, "\t}\n");
}
/* Write segment attributes to .fig figure file. */
fprintf(fp_fig, "\tsegment %s_seg {\n", bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\tpsurf=\"%s.pss\";\n", bu_vls_addr(&file_base));
if (tsp->ts_mater.ma_color_valid != 0)
fprintf(fp_fig,
"\t\tattribute=%s;\n", bu_vls_addr(&file_base));
fprintf(fp_fig, "\t\tsite base->location=trans(0, 0, 0);\n");
fprintf(fp_fig, "\t}\n");
if ( bu_vls_strlen(&base_seg) <= 0 ) {
bu_vls_vlscat( &base_seg, &file_base );
} else {
fprintf(fp_fig, "\tjoint %s_jt {\n",
bu_vls_addr(&file_base));
fprintf(fp_fig,
"\t\tconnect %s_seg.base to %s_seg.base;\n",
bu_vls_addr(&file_base),
bu_vls_addr(&base_seg) );
fprintf(fp_fig, "\t}\n");
}
bu_vls_vlscat(&file, &file_base);
bu_vls_strcat(&file, ".pss"); /* Required Jack suffix. */
/* Write psurf to .pss file. */
if ((fp_psurf = fopen(bu_vls_addr(&file), "wb")) == NULL)
perror(bu_vls_addr(&file));
else {
nmg_to_psurf(r, fp_psurf);
fclose(fp_psurf);
if (verbose) bu_log("*** Wrote %s\n", bu_vls_addr(&file));
}
bu_vls_free(&file);
/* Also write as UNIX-plot file, if desired */
if ( debug_plots ) {
FILE *fp;
bu_vls_vlscat(&file, &file_base);
bu_vls_strcat(&file, ".pl");
if ((fp = fopen(bu_vls_addr(&file), "wb")) == NULL)
perror(bu_vls_addr(&file));
else {
struct bu_list vhead;
pl_color( fp,
(int)(tsp->ts_mater.ma_color[0] * 255),
(int)(tsp->ts_mater.ma_color[1] * 255),
(int)(tsp->ts_mater.ma_color[2] * 255) );
/* nmg_pl_r( fp, r ); */
BU_LIST_INIT( &vhead );
nmg_r_to_vlist( &vhead, r, 0 );
rt_vlist_to_uplot( fp, &vhead );
fclose(fp);
if (verbose) bu_log("*** Wrote %s\n", bu_vls_addr(&file));
}
bu_vls_free(&file);
}
/* NMG region is no longer necessary */
nmg_kr(r);
}
/*
* Dispose of original tree, so that all associated dynamic
* memory is released now, not at the end of all regions.
* A return of TREE_NULL from this routine signals an error,
* so we need to cons up an OP_NOP node to return.
*/
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
BU_ALLOC(curtree, union tree);
RT_TREE_INIT(curtree);
curtree->tr_op = OP_NOP;
return curtree;
}
union tree *
nmg_region_end(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *curtree, void *UNUSED(client_data))
{
struct nmgregion *r;
struct bu_list vhead;
union tree *ret_tree;
char *name;
RT_CK_TESS_TOL(tsp->ts_ttol);
BN_CK_TOL(tsp->ts_tol);
NMG_CK_MODEL(*tsp->ts_m);
BARRIER_CHECK;
BU_LIST_INIT(&vhead);
if (RT_G_DEBUG&DEBUG_TREEWALK || verbose) {
bu_log("\nConverted %d%% so far (%d of %d)\n",
regions_tried>0 ? (regions_converted * 100) / regions_tried : 0,
regions_converted, regions_tried );
}
if (curtree->tr_op == OP_NOP)
return curtree;
name = db_path_to_string( pathp );
bu_log( "Attempting %s\n", name );
regions_tried++;
ret_tree = process_boolean(curtree, tsp, pathp);
if ( ret_tree )
r = ret_tree->tr_d.td_r;
else
r = (struct nmgregion *)NULL;
bu_free( name, "db_path_to_string" );
regions_converted++;
if (r != (struct nmgregion *)NULL)
{
struct shell *s;
int empty_region=0;
int empty_model=0;
/* Kill cracks */
s = BU_LIST_FIRST( shell, &r->s_hd );
while ( BU_LIST_NOT_HEAD( &s->l, &r->s_hd ) )
{
struct shell *next_s;
next_s = BU_LIST_PNEXT( shell, &s->l );
if ( nmg_kill_cracks( s ) )
{
if ( nmg_ks( s ) )
{
empty_region = 1;
break;
}
}
s = next_s;
}
/* kill zero length edgeuses */
if ( !empty_region )
{
empty_model = nmg_kill_zero_length_edgeuses( *tsp->ts_m );
}
if ( !empty_region && !empty_model )
{
/* Write the nmgregion to the output file */
nmg_2_vrml( outfp, pathp, r->m_p, &tsp->ts_mater );
}
/* NMG region is no longer necessary */
if ( !empty_model )
nmg_kr(r);
}
else
bu_log( "WARNING: Nothing left after Boolean evaluation of %s\n",
db_path_to_string( pathp ) );
/*
* Dispose of original tree, so that all associated dynamic
* memory is released now, not at the end of all regions.
* A return of TREE_NULL from this routine signals an error,
* so we need to cons up an OP_NOP node to return.
*/
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
BU_ALLOC(curtree, union tree);
RT_TREE_INIT(curtree);
curtree->tr_op = OP_NOP;
BARRIER_CHECK;
return curtree;
}
void
nmg_2_vrml(FILE *fp, const struct db_full_path *pathp, struct model *m, struct mater_info *mater)
{
struct nmgregion *reg;
struct bu_ptbl verts;
struct vrml_mat mat;
struct bu_vls vls = BU_VLS_INIT_ZERO;
char *tok;
int i;
int first=1;
int is_light=0;
float r, g, b;
point_t ave_pt;
char *full_path;
/*There may be a better way to capture the region_id, than getting the rt_comb_internal structure,
* (and may be a better way to capture the rt_comb_internal struct), but for now I just copied the
* method used in select_lights/select_non_lights above, could have used a global variable but I noticed
* none other were used, so I didn't want to be the first
*/
struct directory *dp;
struct rt_db_internal intern;
struct rt_comb_internal *comb;
int id;
NMG_CK_MODEL( m );
BARRIER_CHECK;
full_path = db_path_to_string( pathp );
/* replace all occurrences of '.' with '_' */
char_replace(full_path, '.', '_');
RT_CK_FULL_PATH( pathp );
dp = DB_FULL_PATH_CUR_DIR( pathp );
if ( !(dp->d_flags & RT_DIR_COMB) )
return;
id = rt_db_get_internal( &intern, dp, dbip, (matp_t)NULL, &rt_uniresource );
if ( id < 0 )
{
bu_log( "Cannot internal form of %s\n", dp->d_namep );
return;
}
if ( id != ID_COMBINATION )
{
bu_log( "Directory/database mismatch!\n\t is '%s' a combination or not?\n",
dp->d_namep );
return;
}
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB( comb );
if ( mater->ma_color_valid )
{
r = mater->ma_color[0];
g = mater->ma_color[1];
b = mater->ma_color[2];
}
else
{
r = g = b = 0.5;
}
if ( mater->ma_shader )
{
tok = strtok( mater->ma_shader, tok_sep );
bu_strlcpy( mat.shader, tok, TXT_NAME_SIZE );
}
else
mat.shader[0] = '\0';
mat.shininess = -1;
mat.transparency = -1.0;
mat.lt_fraction = -1.0;
VSETALL( mat.lt_dir, 0.0 );
mat.lt_angle = -1.0;
mat.tx_file[0] = '\0';
mat.tx_w = -1;
mat.tx_n = -1;
bu_vls_strcpy( &vls, &mater->ma_shader[strlen(mat.shader)] );
(void)bu_struct_parse( &vls, vrml_mat_parse, (char *)&mat, NULL);
if ( bu_strncmp( "light", mat.shader, 5 ) == 0 )
{
/* this is a light source */
is_light = 1;
}
else
{
fprintf( fp, "\t<Shape DEF=\"%s\">\n", full_path);
fprintf( fp, "\t\t<Appearance>\n");
if ( bu_strncmp( "plastic", mat.shader, 7 ) == 0 )
{
if ( mat.shininess < 0 )
mat.shininess = 10;
V_MAX(mat.transparency, 0.0);
fprintf( fp, "\t\t\t<Material diffuseColor=\"%g %g %g\" shininess=\"%g\" transparency=\"%g\" specularColor=\"%g %g %g\"/>\n", r, g, b, 1.0-exp(-(double)mat.shininess/20.0), mat.transparency, 1.0, 1.0, 1.0);
}
else if ( bu_strncmp( "glass", mat.shader, 5 ) == 0 )
{
if ( mat.shininess < 0 )
mat.shininess = 4;
if ( mat.transparency < 0.0 )
mat.transparency = 0.8;
fprintf( fp, "\t\t\t<Material diffuseColor=\"%g %g %g\" shininess=\"%g\" transparency=\"%g\" specularColor=\"%g %g %g\"/>\n", r, g, b, 1.0-exp(-(double)mat.shininess/20.0), mat.transparency, 1.0, 1.0, 1.0);
}
else if ( mater->ma_color_valid )
{
fprintf( fp, "\t\t\t<Material diffuseColor=\"%g %g %g\"/>\n", r, g, b);
}
else
{
/* If no color was defined set the colors according to the thousands groups */
int thou = comb->region_id/1000;
thou == 0 ? fprintf( fp, "\t\t\t<Material USE=\"Material_999\"/>\n")
: thou == 1 ? fprintf( fp, "\t\t\t<Material USE=\"Material_1999\"/>\n")
: thou == 2 ? fprintf( fp, "\t\t\t<Material USE=\"Material_2999\"/>\n")
: thou == 3 ? fprintf( fp, "\t\t\t<Material USE=\"Material_3999\"/>\n")
: thou == 4 ? fprintf( fp, "\t\t\t<Material USE=\"Material_4999\"/>\n")
: thou == 5 ? fprintf( fp, "\t\t\t<Material USE=\"Material_5999\"/>\n")
: thou == 6 ? fprintf( fp, "\t\t\t<Material USE=\"Material_6999\"/>\n")
: thou == 7 ? fprintf( fp, "\t\t\t<Material USE=\"Material_7999\"/>\n")
: thou == 8 ? fprintf( fp, "\t\t\t<Material USE=\"Material_8999\"/>\n")
: fprintf( fp, "\t\t\t<Material USE=\"Material_9999\"/>\n");
}
}
if ( !is_light )
{
process_non_light(m);
fprintf( fp, "\t\t</Appearance>\n");
}
/* FIXME: need code to handle light */
/* get list of vertices */
nmg_vertex_tabulate( &verts, &m->magic );
fprintf( fp, "\t\t<IndexedFaceSet coordIndex=\"\n");
first = 1;
if ( !is_light )
{
for ( BU_LIST_FOR( reg, nmgregion, &m->r_hd ) )
{
struct shell *s;
NMG_CK_REGION( reg );
for ( BU_LIST_FOR( s, shell, ®->s_hd ) )
{
struct faceuse *fu;
NMG_CK_SHELL( s );
for ( BU_LIST_FOR( fu, faceuse, &s->fu_hd ) )
{
struct loopuse *lu;
NMG_CK_FACEUSE( fu );
if ( fu->orientation != OT_SAME )
continue;
for ( BU_LIST_FOR( lu, loopuse, &fu->lu_hd ) )
{
struct edgeuse *eu;
NMG_CK_LOOPUSE( lu );
if ( BU_LIST_FIRST_MAGIC( &lu->down_hd ) != NMG_EDGEUSE_MAGIC )
continue;
if ( !first )
fprintf( fp, ",\n" );
else
first = 0;
fprintf( fp, "\t\t\t\t" );
for ( BU_LIST_FOR( eu, edgeuse, &lu->down_hd ) )
{
struct vertex *v;
NMG_CK_EDGEUSE( eu );
v = eu->vu_p->v_p;
NMG_CK_VERTEX( v );
fprintf( fp, " %d,", bu_ptbl_locate( &verts, (long *)v ) );
}
fprintf( fp, "-1" );
}
}
}
}
/* close coordIndex */
fprintf( fp, "\" ");
fprintf( fp, "normalPerVertex=\"false\" ");
fprintf( fp, "convex=\"false\" ");
fprintf( fp, "creaseAngle=\"0.5\" ");
/* close IndexedFaceSet open tag */
fprintf( fp, ">\n");
}
fprintf( fp, "\t\t\t<Coordinate point=\"");
for ( i=0; i<BU_PTBL_END( &verts ); i++ )
{
struct vertex *v;
struct vertex_g *vg;
point_t pt_meters;
v = (struct vertex *)BU_PTBL_GET( &verts, i );
NMG_CK_VERTEX( v );
vg = v->vg_p;
NMG_CK_VERTEX_G( vg );
/* convert to desired units */
VSCALE( pt_meters, vg->coord, scale_factor );
if ( is_light )
VADD2( ave_pt, ave_pt, pt_meters );
if ( first )
{
if ( !is_light )
fprintf( fp, " %10.10e %10.10e %10.10e, ", V3ARGS(pt_meters));
first = 0;
}
else
if ( !is_light )
fprintf( fp, "%10.10e %10.10e %10.10e, ", V3ARGS( pt_meters ));
}
/* close point */
fprintf(fp, "\"");
/* close Coordinate */
fprintf(fp, "/>\n");
/* IndexedFaceSet end tag */
fprintf( fp, "\t\t</IndexedFaceSet>\n");
/* Shape end tag */
fprintf( fp, "\t</Shape>\n");
BARRIER_CHECK;
}
/*
* Called from db_walk_tree().
*
* This routine must be prepared to run in parallel.
*/
union tree *do_region_end(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *curtree, void *UNUSED(client_data))
{
union tree *ret_tree;
struct bu_list vhead;
struct nmgregion *r;
RT_CK_FULL_PATH(pathp);
RT_CK_TREE(curtree);
RT_CK_TESS_TOL(tsp->ts_ttol);
BN_CK_TOL(tsp->ts_tol);
NMG_CK_MODEL(*tsp->ts_m);
BU_LIST_INIT(&vhead);
{
char *sofar = db_path_to_string(pathp);
bu_log("\ndo_region_end(%d %d%%) %s\n",
regions_tried,
regions_tried>0 ? (regions_converted * 100) / regions_tried : 0,
sofar);
bu_free(sofar, "path string");
}
if (curtree->tr_op == OP_NOP)
return curtree;
regions_tried++;
if (verbose)
bu_log("Attempting to process region %s\n", db_path_to_string(pathp));
ret_tree= process_boolean(curtree, tsp, pathp);
if (ret_tree)
r = ret_tree->tr_d.td_r;
else
{
if (verbose)
bu_log("\tNothing left of this region after Boolean evaluation\n");
regions_written++; /* don't count as a failure */
r = (struct nmgregion *)NULL;
}
regions_converted++;
if (r != (struct nmgregion *)NULL)
{
struct shell *s;
int empty_region=0;
int empty_model=0;
/* Kill cracks */
s = BU_LIST_FIRST(shell, &r->s_hd);
while (BU_LIST_NOT_HEAD(&s->l, &r->s_hd))
{
struct shell *next_s;
next_s = BU_LIST_PNEXT(shell, &s->l);
if (nmg_kill_cracks(s))
{
if (nmg_ks(s))
{
empty_region = 1;
break;
}
}
s = next_s;
}
/* kill zero length edgeuses */
if (!empty_region) {
empty_model = nmg_kill_zero_length_edgeuses(*tsp->ts_m);
}
if (!empty_region && !empty_model) {
process_triangulation(r, pathp, tsp);
regions_written++;
}
if (!empty_model)
nmg_kr(r);
}
/*
* Dispose of original tree, so that all associated dynamic
* memory is released now, not at the end of all regions.
* A return of TREE_NULL from this routine signals an error,
* and there is no point to adding _another_ message to our output,
* so we need to cons up an OP_NOP node to return.
*/
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
BU_ALLOC(curtree, union tree);
RT_TREE_INIT(curtree);
curtree->tr_op = OP_NOP;
return curtree;
}
/*
* Called from db_walk_tree().
*
* This routine must be prepared to run in parallel.
*/
union tree *
do_region_end(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *curtree, void *UNUSED(client_data))
{
struct nmgregion *r;
struct bu_list vhead;
union tree *ret_tree;
if (verbose)
bu_log("do_region_end: regionid = %d\n", tsp->ts_regionid);
RT_CK_TESS_TOL(tsp->ts_ttol);
BN_CK_TOL(tsp->ts_tol);
NMG_CK_MODEL(*tsp->ts_m);
BU_LIST_INIT(&vhead);
if (RT_G_DEBUG&DEBUG_TREEWALK || verbose) {
char *sofar = db_path_to_string(pathp);
bu_log("\ndo_region_end(%d %d%%) %s\n",
regions_tried,
regions_tried>0 ? (regions_converted * 100) / regions_tried : 0,
sofar);
bu_free(sofar, "path string");
}
if (curtree->tr_op == OP_NOP)
return curtree;
regions_tried++;
if (verbose)
bu_log("\tEvaluating region\n");
ret_tree = process_boolean(curtree, tsp, pathp);
if (ret_tree)
r = ret_tree->tr_d.td_r;
else
r = (struct nmgregion *)NULL;
regions_converted++;
if (r != (struct nmgregion *)NULL) {
struct shell *s;
int empty_region = 0;
int empty_model = 0;
/* Kill cracks */
s = BU_LIST_FIRST(shell, &r->s_hd);
while (BU_LIST_NOT_HEAD(&s->l, &r->s_hd)) {
struct shell *next_s;
next_s = BU_LIST_PNEXT(shell, &s->l);
if (nmg_kill_cracks(s)) {
if (nmg_ks(s)) {
empty_region = 1;
break;
}
}
s = next_s;
}
/* kill zero length edgeuses */
if (!empty_region) {
empty_model = nmg_kill_zero_length_edgeuses(*tsp->ts_m);
}
if (!empty_region && !empty_model) {
/* Write the region to the EUCLID file */
Write_euclid_region(r, tsp);
}
if (!empty_model)
nmg_kr(r);
}
/*
* Dispose of original tree, so that all associated dynamic
* memory is released now, not at the end of all regions.
* A return of TREE_NULL from this routine signals an error,
* so we need to cons up an OP_NOP node to return.
*/
db_free_tree(curtree, &rt_uniresource); /* Does an nmg_kr() */
BU_ALLOC(curtree, union tree);
RT_TREE_INIT(curtree);
curtree->tr_op = OP_NOP;
return curtree;
}
