/*
* 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);
}
/*
* 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;
}
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;
}
/*
* 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;
}
/*
* 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;
}
/*
* Called from db_walk_tree().
*
* This routine must be prepared to run in parallel.
*/
union tree *
do_nmg_region_end(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *curtree, void *UNUSED(client_data))
{
union tree *result;
struct nmgregion *r;
struct bu_list vhead;
struct directory *dp;
int dependent;
size_t i;
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_nmg_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++;
if (verbose)
bu_log("\ndoing boolean tree evaluate...\n");
/* evaluate the boolean */
result = process_boolean(tsp, curtree, pathp);
if (result)
r = result->tr_d.td_r;
else
r = (struct nmgregion *)NULL;
if (verbose)
bu_log("\nfinished boolean tree evaluate...\n");
regions_done++;
if (r != NULL) {
dp = DB_FULL_PATH_CUR_DIR(pathp);
if (multi_file) {
/* Open the output file */
if (output_file == NULL)
fp_dir = stdout;
else {
char *multi_name;
size_t len;
int unique = 0;
char suffix[SUFFIX_LEN+1];
/* construct a unique file name */
len = strlen(output_file) + strlen(dp->d_namep) + 6 + SUFFIX_LEN;
multi_name = (char *)bu_malloc(sizeof(char)*len, "multi_name");
snprintf(multi_name, len, "%s/%s.igs", output_file, dp->d_namep);
bu_strlcpy(suffix, "a", sizeof(suffix));
suffix[0]--;
while (!unique) {
if (bu_file_readable(multi_name)) {
unique = 1;
break;
}
/* not unique, try adding a suffix */
len = strlen(suffix);
i = len - 1;
suffix[i]++;
while (suffix[i] > 'z' && i > 0) {
suffix[i] = 'a';
i--;
suffix[i]++;
}
if (suffix[0] > 'z' && len < SUFFIX_LEN) {
for (i = 0; i <= len; i++)
suffix[i] = 'a';
} else if (suffix[0] > 'z' && len >= SUFFIX_LEN) {
bu_log("too many files with the same name (%s)\n", dp->d_namep);
bu_exit(1, "Cannot create a unique filename, \n");
}
snprintf(multi_name, len, "%s/%s%s.igs", output_file, dp->d_namep, suffix);
}
if ((fp_dir = fopen(multi_name, "wb")) == NULL) {
perror("g-iges");
bu_exit(1, "Cannot open output file: %s\n", multi_name);
}
}
/* Open the temporary file for the parameter section */
if ((fp_param = bu_temp_file(NULL, 0)) == NULL) {
perror("g-iges");
bu_exit(1, "Cannot open temporary file\n");
}
/* let the IGES routines know the selected tolerances and the database pointer */
iges_init(&tol, &ttol, verbose, DBIP);
/* Write start and global sections of the IGES file */
w_start_global(fp_dir, fp_param, db_name, prog_name, output_file, __DATE__, brlcad_version());
}
if (mode == FACET_MODE) {
dependent = 1;
for (i = 0; i < no_of_indeps; i++) {
if (!bu_strncmp(dp->d_namep, independent[i], NAMESIZE+1)) {
dependent = 0;
break;
}
}
dp->d_uses = (-nmgregion_to_iges(dp->d_namep, r, dependent, fp_dir, fp_param));
} else if (mode == TRIMMED_SURF_MODE)
dp->d_uses = (-nmgregion_to_tsurf(dp->d_namep, r, fp_dir, fp_param));
/* NMG region is no longer necessary */
nmg_kr(r);
if (multi_file) {
char copy_buffer[CP_BUF_SIZE] = {0};
/* Copy the parameter section from the temporary file to the output file */
if ((bu_fseek(fp_param, 0, 0))) {
perror("g-iges");
bu_exit(1, "Cannot seek to start of temporary file\n");
}
while ((i = fread(copy_buffer, 1, CP_BUF_SIZE, fp_param)))
if (fwrite(copy_buffer, 1, i, fp_dir) != i) {
perror("g-iges");
bu_exit(1, "Error in copying parameter data to %s\n", output_file);
}
/* Write the terminate section */
w_terminate(fp_dir);
fclose(fp_dir);
fclose(fp_param);
}
}
/*
* 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 *
gcv_region_end_mc(struct db_tree_state *tsp, const struct db_full_path *pathp, union tree *curtree, void *client_data)
{
union tree *tp = NULL;
struct model *m = NULL;
struct nmgregion *r = NULL;
struct shell *s = NULL;
struct bu_list vhead;
int empty_region = 0;
int empty_model = 0;
int NMG_debug_state = 0;
int count = 0;
void (*write_region)(struct nmgregion *, const struct db_full_path *, int, int, float [3]);
if (!tsp || !pathp || !client_data) {
bu_log("INTERNAL ERROR: gcv_region_end_mc missing parameters\n");
return TREE_NULL;
}
write_region = ((struct gcv_data *)client_data)->func;
if (!write_region) {
bu_log("INTERNAL ERROR: gcv_region_end missing conversion callback function\n");
return TREE_NULL;
}
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);
/*
if (curtree->tr_op == OP_NOP)
return 0;
*/
/* get a copy to play with as the parameters might get clobbered
* by a longjmp. FIXME: db_dup_subtree() doesn't create real copies
*/
tp = db_dup_subtree(curtree, &rt_uniresource);
/* FIXME: we can't free curtree until we get a "real" copy form
* db_dup_subtree(). right now we get a fake copy just so we can
* keep the compiler quiet about clobbering curtree during longjmp
*/
/* db_free_tree(curtree, &rt_uniresource); */
/* Sometimes the NMG library adds debugging bits when it detects
* an internal error, before bombing. Stash.
*/
NMG_debug_state = RTG.NMG_debug;
m = nmg_mmr();
r = nmg_mrsv(m);
s = BU_LIST_FIRST(shell, &r->s_hd);
if (tsp->ts_rtip == NULL)
tsp->ts_rtip = rt_new_rti(tsp->ts_dbip);
count += nmg_mc_evaluate (s, tsp->ts_rtip, pathp, tsp->ts_ttol, tsp->ts_tol);
/* empty region? */
if (count == 0) {
bu_log("Region %s appears to be empty.\n", db_path_to_string(pathp));
return TREE_NULL;
}
/*
bu_log("Target is shot, %d triangles seen.\n", count);
bu_log("Fusing\n"); fflush(stdout);
nmg_model_fuse(m, tsp->ts_tol);
bu_log("Done\n"); fflush(stdout);
*/
/* Kill cracks */
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;
}
}
/*
nmg_shell_coplanar_face_merge(s, tsp->ts_tol, 42);
*/
s = next_s;
}
if (empty_region)
return _gcv_cleanup(NMG_debug_state, tp);
/* kill zero length edgeuses */
empty_model = nmg_kill_zero_length_edgeuses(*tsp->ts_m);
if (empty_model)
return _gcv_cleanup(NMG_debug_state, tp);
if (BU_SETJUMP) {
/* Error, bail out */
char *sofar;
/* Relinquish bomb protection */
BU_UNSETJUMP;
sofar = db_path_to_string(pathp);
bu_log("FAILED in triangulator: %s\n", sofar);
bu_free((char *)sofar, "sofar");
/* 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();
nmg_kr(r);
return _gcv_cleanup(NMG_debug_state, tp);
} else {
/* Write the region out */
write_region(r, pathp, tsp->ts_regionid, tsp->ts_gmater, tsp->ts_mater.ma_color);
} BU_UNSETJUMP; /* Relinquish bomb protection */
nmg_kr(r);
return _gcv_cleanup(NMG_debug_state, tp);
}
/**
* "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;
}
/*
* 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 = NULL;
struct bu_list vhead;
/* static due to longjmp */
static struct nmgregion *r = NULL;
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);
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++;
/* do the deed */
ret_tree = process_region(pathp, curtree, tsp);
if (ret_tree)
r = ret_tree->tr_d.td_r;
else {
if (verbose) {
printf("\tNothing left of this region after Boolean evaluation\n");
fprintf(fpe, "WARNING: Nothing left after Boolean evaluation: %s\n",
db_path_to_string(pathp));
fflush(fpe);
}
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) {
if (!BU_SETJUMP) {
/* try */
/* Write the region to the TANKILL file */
nmg_to_acad(r, pathp, tsp->ts_regionid);
regions_written++;
} else {
/* catch */
char *sofar;
BU_UNSETJUMP;
sofar = db_path_to_string(pathp);
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();
/* FIXME: leaking memory with curtree */
return TREE_NULL;
} BU_UNSETJUMP;
}
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.
*/
if (regions_tried>0) {
float npercent, tpercent;
npercent = (float)(regions_converted * 100) / regions_tried;
tpercent = (float)(regions_written * 100) / regions_tried;
printf("Tried %d regions, %d conv. to NMG's %d conv. to tri. nmgper = %.2f%% triper = %.2f%% \n",
regions_tried, regions_converted, regions_written, npercent, tpercent);
}
BU_ALLOC(curtree, union tree);
RT_TREE_INIT(curtree);
curtree->tr_op = OP_NOP;
return curtree;
}
